dm1sh/another-widget
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'patch-4' into patch-develop

Browse Source
This commit is contained in:
azuo 2021-09-14 13:40:14 +08:00
commit e0eb6f77da
9 changed files with 151 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
app/src/main/java/com/tommasoberlose/anotherwidget/db/EventRepository.kt
View File

@ -64,7 +64,7 @@ class EventRepository(val context: Context) {
else -> add(Calendar.HOUR, 6) else -> add(Calendar.HOUR, 6)
} }
} }
val event = if (nextEvent != null && nextEvent.endDate > now && nextEvent.startDate < limit.timeInMillis) { val event = if (nextEvent != null && nextEvent.endDate > now && nextEvent.startDate <= limit.timeInMillis) {
nextEvent nextEvent
} else { } else {
val events = getEvents() val events = getEvents()
@ -105,7 +105,6 @@ class EventRepository(val context: Context) {
} else { } else {
resetNextEventData() resetNextEventData()
} }
UpdatesReceiver.setUpdates(context)
MainWidget.updateWidget(context) MainWidget.updateWidget(context)
} }
@ -121,7 +120,6 @@ class EventRepository(val context: Context) {
} else { } else {
resetNextEventData() resetNextEventData()
} }
UpdatesReceiver.setUpdates(context)
MainWidget.updateWidget(context) MainWidget.updateWidget(context)
} }

32
app/src/main/java/com/tommasoberlose/anotherwidget/helpers/SettingsStringHelper.kt
View File

@ -88,19 +88,17 @@ object SettingsStringHelper {
fun getDifferenceText(context: Context, now: Long, start: Long): String { fun getDifferenceText(context: Context, now: Long, start: Long): String {
val nowDate = DateTime(now) val nowDate = DateTime(now)
val eventDate = DateTime(start) val eventDate = DateTime(start)
val difference = start - now
var difference = start - now
difference += 60 * 1000 - (difference % (60 * 1000))
when { when {
difference <= 0 -> { difference <= 0 -> {
return "" return ""
} }
TimeUnit.MILLISECONDS.toHours(difference) < 1 && Preferences.widgetUpdateFrequency == Constants.WidgetUpdateFrequency.HIGH.rawValue && TimeUnit.MILLISECONDS.toMinutes(difference) > 5 -> { TimeUnit.MILLISECONDS.toHours(difference) < 1 && Preferences.widgetUpdateFrequency == Constants.WidgetUpdateFrequency.HIGH.rawValue && TimeUnit.MILLISECONDS.toMinutes(difference) >= 5 -> {
return DateUtils.getRelativeTimeSpanString(start, start - 1000 * 60 * (TimeUnit.MILLISECONDS.toMinutes(difference) - 1 - (TimeUnit.MILLISECONDS.toMinutes(difference) - 1) % 5), DateUtils.MINUTE_IN_MILLIS, DateUtils.FORMAT_ABBREV_RELATIVE).toString() return DateUtils.getRelativeTimeSpanString(start, start - 1000 * 60 * (TimeUnit.MILLISECONDS.toMinutes(difference) - TimeUnit.MILLISECONDS.toMinutes(difference) % 5), DateUtils.MINUTE_IN_MILLIS, DateUtils.FORMAT_ABBREV_RELATIVE).toString()
} }
TimeUnit.MILLISECONDS.toHours(difference) < 1 && Preferences.widgetUpdateFrequency == Constants.WidgetUpdateFrequency.DEFAULT.rawValue && TimeUnit.MILLISECONDS.toMinutes(difference) > 5 -> { TimeUnit.MILLISECONDS.toHours(difference) < 1 && Preferences.widgetUpdateFrequency == Constants.WidgetUpdateFrequency.DEFAULT.rawValue && TimeUnit.MILLISECONDS.toMinutes(difference) >= 15 -> {
return DateUtils.getRelativeTimeSpanString(start, start - 1000 * 60 * (TimeUnit.MILLISECONDS.toMinutes(difference) - 1 - (TimeUnit.MILLISECONDS.toMinutes(difference) - 1) % 15), DateUtils.MINUTE_IN_MILLIS, DateUtils.FORMAT_ABBREV_RELATIVE).toString() return DateUtils.getRelativeTimeSpanString(start, start - 1000 * 60 * (TimeUnit.MILLISECONDS.toMinutes(difference) - TimeUnit.MILLISECONDS.toMinutes(difference) % 15), DateUtils.MINUTE_IN_MILLIS, DateUtils.FORMAT_ABBREV_RELATIVE).toString()
} }
TimeUnit.MILLISECONDS.toHours(difference) < 1 && Preferences.widgetUpdateFrequency == Constants.WidgetUpdateFrequency.LOW.rawValue -> { TimeUnit.MILLISECONDS.toHours(difference) < 1 && Preferences.widgetUpdateFrequency == Constants.WidgetUpdateFrequency.LOW.rawValue -> {
return context.getString(R.string.soon) return context.getString(R.string.soon)
@ -109,22 +107,7 @@ object SettingsStringHelper {
return context.getString(R.string.now) return context.getString(R.string.now)
} }
TimeUnit.MILLISECONDS.toHours(difference) < 12 -> { TimeUnit.MILLISECONDS.toHours(difference) < 12 -> {
val minutes = TimeUnit.MILLISECONDS.toMinutes(difference) - 60 * TimeUnit.MILLISECONDS.toHours(difference) return DateUtils.getRelativeTimeSpanString(start, now, DateUtils.HOUR_IN_MILLIS, DateUtils.FORMAT_ABBREV_RELATIVE).toString()
return if (minutes < 1 || minutes > 30) {
DateUtils.getRelativeTimeSpanString(
start,
now - 1000 * 60 * 40,
DateUtils.HOUR_IN_MILLIS,
DateUtils.FORMAT_ABBREV_RELATIVE
).toString()
} else {
DateUtils.getRelativeTimeSpanString(
start,
now,
DateUtils.HOUR_IN_MILLIS,
DateUtils.FORMAT_ABBREV_RELATIVE
).toString()
}
} }
eventDate.dayOfYear == nowDate.plusDays(1).dayOfYear -> { eventDate.dayOfYear == nowDate.plusDays(1).dayOfYear -> {
return String.format("%s", context.getString(R.string.tomorrow)) return String.format("%s", context.getString(R.string.tomorrow))
@ -143,9 +126,6 @@ object SettingsStringHelper {
val nowDate = DateTime(now) val nowDate = DateTime(now)
val eventDate = DateTime(start) val eventDate = DateTime(start)
var difference = start - now
difference += 60 * 1000 - (difference % (60 * 1000))
return when (eventDate.dayOfYear) { return when (eventDate.dayOfYear) {
nowDate.dayOfYear -> { nowDate.dayOfYear -> {
"" ""

3
app/src/main/java/com/tommasoberlose/anotherwidget/receivers/NewCalendarEventReceiver.kt
View File

@ -13,8 +13,7 @@ class NewCalendarEventReceiver : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) { override fun onReceive(context: Context, intent: Intent) {
val eventRepository = EventRepository(context) val eventRepository = EventRepository(context)
when (intent.action) { when (intent.action) {
Intent.ACTION_PROVIDER_CHANGED, Intent.ACTION_PROVIDER_CHANGED -> {
Intent.ACTION_TIME_CHANGED -> {
CalendarHelper.updateEventList(context) CalendarHelper.updateEventList(context)
} }
Actions.ACTION_GO_TO_NEXT_EVENT -> { Actions.ACTION_GO_TO_NEXT_EVENT -> {

191
app/src/main/java/com/tommasoberlose/anotherwidget/receivers/UpdatesReceiver.kt
View File

@ -38,6 +38,7 @@ class UpdatesReceiver : BroadcastReceiver() {
"com.sec.android.widgetapp.APPWIDGET_RESIZE", "com.sec.android.widgetapp.APPWIDGET_RESIZE",
AlarmManager.ACTION_NEXT_ALARM_CLOCK_CHANGED, AlarmManager.ACTION_NEXT_ALARM_CLOCK_CHANGED,
Actions.ACTION_ALARM_UPDATE, Actions.ACTION_ALARM_UPDATE,
Actions.ACTION_UPDATE_GREETINGS,
Actions.ACTION_TIME_UPDATE -> { Actions.ACTION_TIME_UPDATE -> {
MainWidget.updateWidget(context) MainWidget.updateWidget(context)
if (intent.hasExtra(EVENT_ID)) { if (intent.hasExtra(EVENT_ID)) {
@ -49,9 +50,6 @@ class UpdatesReceiver : BroadcastReceiver() {
ActiveNotificationsHelper.clearLastNotification(context) ActiveNotificationsHelper.clearLastNotification(context)
MainWidget.updateWidget(context) MainWidget.updateWidget(context)
} }
Actions.ACTION_UPDATE_GREETINGS -> {
MainWidget.updateWidget(context)
}
Actions.ACTION_REFRESH -> { Actions.ACTION_REFRESH -> {
GlobalScope.launch(Dispatchers.IO) { GlobalScope.launch(Dispatchers.IO) {
@ -67,9 +65,31 @@ class UpdatesReceiver : BroadcastReceiver() {
const val EVENT_ID = "EVENT_ID" const val EVENT_ID = "EVENT_ID"
fun setUpdates(context: Context, eventId: Long? = null) { fun setUpdates(context: Context, eventId: Long? = null) {
if (!Preferences.showEvents)
return
val eventRepository = EventRepository(context) val eventRepository = EventRepository(context)
if (eventId == null) { if (eventId == null) {
removeUpdates(context) // schedule ACTION_CALENDAR_UPDATE at midnight (ACTION_DATE_CHANGED no longer works)
with(context.getSystemService(Context.ALARM_SERVICE) as AlarmManager) {
setExact(
AlarmManager.RTC,
Calendar.getInstance().apply {
set(Calendar.MILLISECOND, 0)
set(Calendar.SECOND, 0)
set(Calendar.MINUTE, 0)
set(Calendar.HOUR_OF_DAY, 0)
add(Calendar.DATE, 1)
}.timeInMillis,
PendingIntent.getBroadcast(
context,
0,
Intent(context, UpdatesReceiver::class.java).apply {
action = Actions.ACTION_CALENDAR_UPDATE
},
0
)
)
}
eventRepository.getFutureEvents().forEach { event -> eventRepository.getFutureEvents().forEach { event ->
setEventUpdate(context, event) setEventUpdate(context, event)
@ -84,109 +104,90 @@ class UpdatesReceiver : BroadcastReceiver() {
} }
private fun setEventUpdate(context: Context, event: Event) { private fun setEventUpdate(context: Context, event: Event) {
with(context.getSystemService(Context.ALARM_SERVICE) as AlarmManager) { val now = Calendar.getInstance().apply {
val now = Calendar.getInstance().apply { set(Calendar.SECOND, 0)
set(Calendar.SECOND, 0) set(Calendar.MILLISECOND, 0)
set(Calendar.MILLISECOND, 0) }
} val diff = Period(now.timeInMillis, event.startDate, org.joda.time.PeriodType.time())
val diff = Period(now.timeInMillis, event.startDate) val limit = when (Preferences.showUntil) {
val limit = when (Preferences.showUntil) { 0 -> 1000 * 60 * 60 * 3
0 -> 1000 * 60 * 60 * 3 1 -> 1000 * 60 * 60 * 6
1 -> 1000 * 60 * 60 * 6 2 -> 1000 * 60 * 60 * 12
2 -> 1000 * 60 * 60 * 12 3 -> 1000 * 60 * 60 * 24
3 -> 1000 * 60 * 60 * 24 4 -> 1000 * 60 * 60 * 24 * 3
4 -> 1000 * 60 * 60 * 24 * 3 5 -> 1000 * 60 * 60 * 24 * 7
5 -> 1000 * 60 * 60 * 24 * 7 6 -> 1000 * 60 * 30
6 -> 1000 * 60 * 30 7 -> 1000 * 60 * 60
7 -> 1000 * 60 * 60 else -> 1000 * 60 * 60 * 6
else -> 1000 * 60 * 60 * 6 }
} val fireTime = when {
if (event.startDate <= limit) { event.startDate <= now.timeInMillis
if (event.startDate > now.timeInMillis) { -> event.endDate
// Update the widget every hour till the event event.startDate > now.timeInMillis + limit
if (diff.hours == 0) { -> event.startDate - limit
var minutes = 0 !Preferences.showDiffTime
when (Preferences.widgetUpdateFrequency) { -> return
Constants.WidgetUpdateFrequency.DEFAULT.rawValue -> { event.allDay
minutes = when { -> event.startDate
diff.minutes > 50 -> 50 diff.hours > 12
diff.minutes > 30 -> 30 -> event.startDate - 12 * 1000 * 60 * 60 + 1000 * 60
diff.minutes > 15 -> 15 diff.hours > 0
else -> 0 -> event.startDate - diff.hours * 1000 * 60 * 60 + 1000 * 60
} else
} -> event.startDate - 1000 * 60 * when (Preferences.widgetUpdateFrequency) {
Constants.WidgetUpdateFrequency.HIGH.rawValue -> { Constants.WidgetUpdateFrequency.DEFAULT.rawValue -> {
minutes = diff.minutes - (diff.minutes % 5) when {
} diff.minutes >= 45 -> 44
diff.minutes >= 30 -> 29
diff.minutes >= 15 -> 14
else -> 0
} }
setExact(
AlarmManager.RTC,
if (event.startDate - minutes * 1000 * 60 > (now.timeInMillis + 120 * 1000)) event.startDate - 60 * 1000 * minutes else now.timeInMillis + 120000,
PendingIntent.getBroadcast(
context,
event.eventID.toInt(),
Intent(context, UpdatesReceiver::class.java).apply {
action = Actions.ACTION_TIME_UPDATE
putExtra(EVENT_ID, event.eventID)
},
PendingIntent.FLAG_UPDATE_CURRENT
)
)
} else {
setExact(
AlarmManager.RTC,
event.startDate - diff.hours * 1000 * 60 * 60 + if (diff.minutes > 30) (-30) else (+30),
PendingIntent.getBroadcast(
context,
event.eventID.toInt(),
Intent(context, UpdatesReceiver::class.java).apply {
action = Actions.ACTION_TIME_UPDATE
putExtra(EVENT_ID, event.eventID)
},
PendingIntent.FLAG_UPDATE_CURRENT
)
)
} }
} else { Constants.WidgetUpdateFrequency.HIGH.rawValue -> {
// Update the widget one second after the event is finished when {
val fireTime = diff.minutes >= 5 -> diff.minutes - diff.minutes % 5 - 1
if (event.endDate > now.timeInMillis + 120 * 1000) event.endDate else now.timeInMillis + 120000 else -> 0
setExact( }
AlarmManager.RTC, }
fireTime, else -> 0
PendingIntent.getBroadcast(
context,
event.eventID.toInt(),
Intent(context, UpdatesReceiver::class.java).apply {
action = Actions.ACTION_TIME_UPDATE
},
0
)
)
} }
} else { }
setExact( // no need to schedule updates after the next ACTION_CALENDAR_UPDATE
AlarmManager.RTC, if (Calendar.getInstance().apply {
if (event.startDate - limit > now.timeInMillis + 120 * 1000) event.startDate - limit else now.timeInMillis + 120000, set(Calendar.MILLISECOND, 0)
PendingIntent.getBroadcast( set(Calendar.SECOND, 0)
context, set(Calendar.MINUTE, 0)
event.eventID.toInt(), set(Calendar.HOUR_OF_DAY, 0)
Intent(context, UpdatesReceiver::class.java).apply { add(Calendar.DATE, 1)
action = Actions.ACTION_TIME_UPDATE }.timeInMillis <= fireTime) return
with(context.getSystemService(Context.ALARM_SERVICE) as AlarmManager) {
setExact(
AlarmManager.RTC,
fireTime.coerceAtLeast(now.timeInMillis + 1000 * 60),
PendingIntent.getBroadcast(
context,
event.eventID.toInt(),
Intent(context, UpdatesReceiver::class.java).apply {
action = Actions.ACTION_TIME_UPDATE
if (event.startDate > now.timeInMillis)
putExtra(EVENT_ID, event.eventID) putExtra(EVENT_ID, event.eventID)
}, },
PendingIntent.FLAG_UPDATE_CURRENT PendingIntent.FLAG_UPDATE_CURRENT
)
) )
} )
} }
} }
fun removeUpdates(context: Context) { fun removeUpdates(context: Context) {
with(context.getSystemService(Context.ALARM_SERVICE) as AlarmManager) { with(context.getSystemService(Context.ALARM_SERVICE) as AlarmManager) {
cancel(PendingIntent.getBroadcast(context, 0, Intent(context, UpdatesReceiver::class.java).apply {
action = Actions.ACTION_CALENDAR_UPDATE
}, 0))
val eventRepository = EventRepository(context) val eventRepository = EventRepository(context)
eventRepository.getFutureEvents().forEach { eventRepository.getFutureEvents().forEach {
cancel(PendingIntent.getBroadcast(context, it.eventID.toInt(), Intent(context, UpdatesReceiver::class.java), 0)) cancel(PendingIntent.getBroadcast(context, it.eventID.toInt(), Intent(context, UpdatesReceiver::class.java).apply {
action = Actions.ACTION_TIME_UPDATE
}, 0))
} }
eventRepository.close() eventRepository.close()
} }

19
app/src/main/java/com/tommasoberlose/anotherwidget/receivers/WeatherReceiver.kt
View File

@ -22,21 +22,14 @@ class WeatherReceiver : BroadcastReceiver() {
Intent.ACTION_MY_PACKAGE_REPLACED, Intent.ACTION_MY_PACKAGE_REPLACED,
Intent.ACTION_TIMEZONE_CHANGED, Intent.ACTION_TIMEZONE_CHANGED,
Intent.ACTION_LOCALE_CHANGED, Intent.ACTION_LOCALE_CHANGED,
Intent.ACTION_TIME_CHANGED -> setUpdates(context) Intent.ACTION_TIME_CHANGED,
Actions.ACTION_WEATHER_UPDATE -> setUpdates(context)
Actions.ACTION_WEATHER_UPDATE -> {
GlobalScope.launch(Dispatchers.IO) {
WeatherHelper.updateWeather(context)
}
}
} }
} }
companion object { companion object {
private const val MINUTE = 60 * 1000L private const val MINUTE = 60 * 1000L
fun setUpdates(context: Context) { fun setUpdates(context: Context) {
removeUpdates(context)
if (Preferences.showWeather) { if (Preferences.showWeather) {
val interval = MINUTE * when (Preferences.weatherRefreshPeriod) { val interval = MINUTE * when (Preferences.weatherRefreshPeriod) {
0 -> 30 0 -> 30
@ -48,13 +41,15 @@ class WeatherReceiver : BroadcastReceiver() {
else -> 60 else -> 60
} }
with(context.getSystemService(Context.ALARM_SERVICE) as AlarmManager) { with(context.getSystemService(Context.ALARM_SERVICE) as AlarmManager) {
setRepeating( setExact(
AlarmManager.RTC, AlarmManager.RTC,
Calendar.getInstance().timeInMillis, System.currentTimeMillis() + interval,
interval,
PendingIntent.getBroadcast(context, 0, Intent(context, WeatherReceiver::class.java).apply { action = Actions.ACTION_WEATHER_UPDATE }, 0) PendingIntent.getBroadcast(context, 0, Intent(context, WeatherReceiver::class.java).apply { action = Actions.ACTION_WEATHER_UPDATE }, 0)
) )
} }
GlobalScope.launch(Dispatchers.IO) {
WeatherHelper.updateWeather(context)
}
} }
} }

52
app/src/main/java/com/tommasoberlose/anotherwidget/services/UpdateCalendarService.kt
View File

@ -55,18 +55,20 @@ class UpdateCalendarService : Service() {
job?.cancel() job?.cancel()
job = GlobalScope.launch(Dispatchers.IO) { job = GlobalScope.launch(Dispatchers.IO) {
UpdatesReceiver.removeUpdates(this@UpdateCalendarService)
val eventRepository = EventRepository(this@UpdateCalendarService) val eventRepository = EventRepository(this@UpdateCalendarService)
if (Preferences.showEvents) { if (Preferences.showEvents) {
val eventList = ArrayList<Event>() val eventList = ArrayList<Event>()
// fetch all events from now to next ACTION_CALENDAR_UPDATE + limit
val now = Calendar.getInstance() val now = Calendar.getInstance()
val begin = Calendar.getInstance().apply { val limit = Calendar.getInstance().apply {
set(Calendar.MILLISECOND, 0) set(Calendar.MILLISECOND, 0)
set(Calendar.SECOND, 0) set(Calendar.SECOND, 0)
set(Calendar.MINUTE, 0) set(Calendar.MINUTE, 0)
set(Calendar.HOUR_OF_DAY, 0) set(Calendar.HOUR_OF_DAY, 0)
} add(Calendar.DATE, 1)
val limit = Calendar.getInstance().apply {
when (Preferences.showUntil) { when (Preferences.showUntil) {
0 -> add(Calendar.HOUR, 3) 0 -> add(Calendar.HOUR, 3)
1 -> add(Calendar.HOUR, 6) 1 -> add(Calendar.HOUR, 6)
@ -85,29 +87,37 @@ class UpdateCalendarService : Service() {
) )
) { ) {
eventRepository.resetNextEventData() eventRepository.resetNextEventData()
eventRepository.clearEvents()
Preferences.showEvents = false
} else { } else {
try { try {
val provider = CalendarProvider(this@UpdateCalendarService) val provider = CalendarProvider(this@UpdateCalendarService)
val data = provider.getInstances(begin.timeInMillis, limit.timeInMillis) // apply time zone offset to correctly fetch all-day events
val data = provider.getInstances(
now.timeInMillis + now.timeZone.getOffset(now.timeInMillis).coerceAtMost(0),
limit.timeInMillis + limit.timeZone.getOffset(limit.timeInMillis).coerceAtLeast(0)
)
if (data != null) { if (data != null) {
val instances = data.list val instances = data.list
for (instance in instances) { for (instance in instances) {
try { try {
val e = provider.getEvent(instance.eventId) val e = provider.getEvent(instance.eventId)
if (e != null && !e.deleted && instance.begin <= limit.timeInMillis && now.timeInMillis < instance.end && !CalendarHelper.getFilteredCalendarIdList() if (e == null || e.deleted || CalendarHelper.getFilteredCalendarIdList().contains(e.calendarId))
.contains(e.calendarId) continue
) { if (e.allDay) {
if (e.allDay) { val start = Calendar.getInstance()
val start = Calendar.getInstance() start.timeInMillis = instance.begin
start.timeInMillis = instance.begin val end = Calendar.getInstance()
val end = Calendar.getInstance() end.timeInMillis = instance.end
end.timeInMillis = instance.end instance.begin =
instance.begin = start.timeInMillis - start.timeZone.getOffset(start.timeInMillis)
start.timeInMillis - start.timeZone.getOffset(start.timeInMillis) instance.end =
instance.end = end.timeInMillis - end.timeZone.getOffset(end.timeInMillis)
end.timeInMillis - end.timeZone.getOffset(end.timeInMillis) }
} if (instance.begin <= limit.timeInMillis && now.timeInMillis < instance.end) {
/* Following check may result in "fake" all-day events with
* non-UTC start/end time, and therefore cannot be found by
* Calendar when tapped to open details.
// Check all day events // Check all day events
val startDate = Calendar.getInstance() val startDate = Calendar.getInstance()
startDate.timeInMillis = instance.begin startDate.timeInMillis = instance.begin
@ -124,6 +134,7 @@ class UpdateCalendarService : Service() {
&& endDate.get(Calendar.MINUTE) == 0 && endDate.get(Calendar.MINUTE) == 0
&& endDate.get(Calendar.HOUR_OF_DAY) == 0 && endDate.get(Calendar.HOUR_OF_DAY) == 0
) )
*/
eventList.add( eventList.add(
Event( Event(
@ -133,7 +144,7 @@ class UpdateCalendarService : Service() {
startDate = instance.begin, startDate = instance.begin,
endDate = instance.end, endDate = instance.end,
calendarID = e.calendarId.toInt(), calendarID = e.calendarId.toInt(),
allDay = isAllDay, allDay = e.allDay,
address = e.eventLocation ?: "", address = e.eventLocation ?: "",
selfAttendeeStatus = e.selfAttendeeStatus.toInt(), selfAttendeeStatus = e.selfAttendeeStatus.toInt(),
availability = e.availability availability = e.availability
@ -164,13 +175,14 @@ class UpdateCalendarService : Service() {
} }
} else { } else {
eventRepository.resetNextEventData() eventRepository.resetNextEventData()
eventRepository.clearEvents()
} }
eventRepository.close()
UpdatesReceiver.setUpdates(this@UpdateCalendarService) UpdatesReceiver.setUpdates(this@UpdateCalendarService)
MainWidget.updateWidget(this@UpdateCalendarService) MainWidget.updateWidget(this@UpdateCalendarService)
EventBus.getDefault().post(MainFragment.UpdateUiMessageEvent()) EventBus.getDefault().post(MainFragment.UpdateUiMessageEvent())
eventRepository.close()
stopSelf() stopSelf()
} }

1
app/src/main/java/com/tommasoberlose/anotherwidget/ui/activities/MainActivity.kt
View File

@ -140,6 +140,7 @@ class MainActivity : AppCompatActivity(), SharedPreferences.OnSharedPreferenceCh
if (Preferences.showEvents && !checkGrantedPermission(Manifest.permission.READ_CALENDAR)) { if (Preferences.showEvents && !checkGrantedPermission(Manifest.permission.READ_CALENDAR)) {
Preferences.showEvents = false Preferences.showEvents = false
com.tommasoberlose.anotherwidget.receivers.UpdatesReceiver.removeUpdates(this)
} }
} }

5
app/src/main/java/com/tommasoberlose/anotherwidget/ui/fragments/tabs/CalendarFragment.kt
View File

@ -182,7 +182,7 @@ class CalendarFragment : Fragment() {
binding.showAllDayToggle.setOnCheckedChangeListener { _, isChecked -> binding.showAllDayToggle.setOnCheckedChangeListener { _, isChecked ->
Preferences.calendarAllDay = isChecked Preferences.calendarAllDay = isChecked
MainWidget.updateWidget(requireContext()) updateCalendar()
} }
binding.actionChangeAttendeeFilter.setOnClickListener { binding.actionChangeAttendeeFilter.setOnClickListener {
@ -227,7 +227,7 @@ class CalendarFragment : Fragment() {
binding.showOnlyBusyEventsToggle.setOnCheckedChangeListener { _, isChecked -> binding.showOnlyBusyEventsToggle.setOnCheckedChangeListener { _, isChecked ->
Preferences.showOnlyBusyEvents = isChecked Preferences.showOnlyBusyEvents = isChecked
MainWidget.updateWidget(requireContext()) updateCalendar()
} }
binding.actionShowDiffTime.setOnClickListener { binding.actionShowDiffTime.setOnClickListener {
@ -254,6 +254,7 @@ class CalendarFragment : Fragment() {
.addItem(getString(R.string.settings_widget_update_frequency_low), Constants.WidgetUpdateFrequency.LOW.rawValue) .addItem(getString(R.string.settings_widget_update_frequency_low), Constants.WidgetUpdateFrequency.LOW.rawValue)
.addOnSelectItemListener { value -> .addOnSelectItemListener { value ->
Preferences.widgetUpdateFrequency = value Preferences.widgetUpdateFrequency = value
updateCalendar()
}.show() }.show()
} }
} }

4
app/src/main/java/com/tommasoberlose/anotherwidget/ui/fragments/tabs/PreferencesFragment.kt
View File

@ -23,6 +23,7 @@ import com.tommasoberlose.anotherwidget.components.MaterialBottomSheetDialog
import com.tommasoberlose.anotherwidget.databinding.FragmentPreferencesBinding import com.tommasoberlose.anotherwidget.databinding.FragmentPreferencesBinding
import com.tommasoberlose.anotherwidget.global.Preferences import com.tommasoberlose.anotherwidget.global.Preferences
import com.tommasoberlose.anotherwidget.helpers.CalendarHelper import com.tommasoberlose.anotherwidget.helpers.CalendarHelper
import com.tommasoberlose.anotherwidget.receivers.UpdatesReceiver
import com.tommasoberlose.anotherwidget.receivers.WeatherReceiver import com.tommasoberlose.anotherwidget.receivers.WeatherReceiver
import com.tommasoberlose.anotherwidget.ui.activities.MainActivity import com.tommasoberlose.anotherwidget.ui.activities.MainActivity
import com.tommasoberlose.anotherwidget.ui.viewmodels.MainViewModel import com.tommasoberlose.anotherwidget.ui.viewmodels.MainViewModel
@ -123,6 +124,7 @@ class PreferencesFragment : Fragment() {
requireCalendarPermission() requireCalendarPermission()
} else { } else {
Preferences.showEvents = enabled Preferences.showEvents = enabled
UpdatesReceiver.removeUpdates(requireContext())
} }
} }
@ -133,6 +135,8 @@ class PreferencesFragment : Fragment() {
binding.showWeatherSwitch.setOnCheckedChangeListener { _, enabled: Boolean -> binding.showWeatherSwitch.setOnCheckedChangeListener { _, enabled: Boolean ->
Preferences.showWeather = enabled Preferences.showWeather = enabled
if (enabled) { if (enabled) {
Preferences.weatherProviderError = ""
Preferences.weatherProviderLocationError = ""
WeatherReceiver.setUpdates(requireContext()) WeatherReceiver.setUpdates(requireContext())
} else { } else {
WeatherReceiver.removeUpdates(requireContext()) WeatherReceiver.removeUpdates(requireContext())