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

Correct and improve calendar events updating algorithm.

Browse Source 
1. UpdateCalendarService will fetch all events from now to the next fetch time + Preferences.showUntil, so that EventRepository holds all events need to be shown before the next fetch;
2. Every event is updated 1 minute after the corresponding time span, to make the actual time difference consistent with the displayed getRelativeTimeSpanString;
3. Update events only when necessary, eliminate redundant alarms; cancel all update alarms when showEvents is turned off.
This commit is contained in:
azuo 2021-09-03 18:20:01 +08:00
parent 260e36b305
commit 3ab42fd163
7 changed files with 102 additions and 133 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) > 15 -> { 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 -> {

177
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) {
@ -69,7 +67,25 @@ class UpdatesReceiver : BroadcastReceiver() {
fun setUpdates(context: Context, eventId: Long? = null) { fun setUpdates(context: Context, eventId: Long? = null) {
val eventRepository = EventRepository(context) val eventRepository = EventRepository(context)
if (eventId == null) { if (eventId == null) {
removeUpdates(context) 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 +100,80 @@ 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 event.allDay
when (Preferences.widgetUpdateFrequency) { -> event.startDate
Constants.WidgetUpdateFrequency.DEFAULT.rawValue -> { diff.hours > 12
minutes = when { -> event.startDate - 12 * 1000 * 60 * 60 + 1000 * 60
diff.minutes > 50 -> 50 diff.hours > 0
diff.minutes > 30 -> 30 -> event.startDate - diff.hours * 1000 * 60 * 60 + 1000 * 60
diff.minutes > 15 -> 15 else
else -> 0 -> event.startDate - 1000 * 60 * when (Preferences.widgetUpdateFrequency) {
} Constants.WidgetUpdateFrequency.DEFAULT.rawValue -> {
} when {
Constants.WidgetUpdateFrequency.HIGH.rawValue -> { diff.minutes >= 45 -> 44
minutes = diff.minutes - (diff.minutes % 5) 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( with(context.getSystemService(Context.ALARM_SERVICE) as AlarmManager) {
AlarmManager.RTC, setExact(
if (event.startDate - limit > now.timeInMillis + 120 * 1000) event.startDate - limit else now.timeInMillis + 120000, AlarmManager.RTC,
PendingIntent.getBroadcast( fireTime.coerceAtLeast(now.timeInMillis + 1000 * 60),
context, PendingIntent.getBroadcast(
event.eventID.toInt(), context,
Intent(context, UpdatesReceiver::class.java).apply { event.eventID.toInt(),
action = Actions.ACTION_TIME_UPDATE 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()
} }

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

@ -35,8 +35,6 @@ class WeatherReceiver : BroadcastReceiver() {
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

15
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,11 +87,13 @@ class UpdateCalendarService : Service() {
) )
) { ) {
eventRepository.resetNextEventData() eventRepository.resetNextEventData()
eventRepository.clearEvents()
} else { } else {
try { try {
val provider = CalendarProvider(this@UpdateCalendarService) val provider = CalendarProvider(this@UpdateCalendarService)
// apply time zone offset to correctly fetch all-day events
val data = provider.getInstances( val data = provider.getInstances(
begin.timeInMillis + begin.timeZone.getOffset(begin.timeInMillis).coerceAtMost(0), now.timeInMillis + now.timeZone.getOffset(now.timeInMillis).coerceAtMost(0),
limit.timeInMillis + limit.timeZone.getOffset(limit.timeInMillis).coerceAtLeast(0) limit.timeInMillis + limit.timeZone.getOffset(limit.timeInMillis).coerceAtLeast(0)
) )
if (data != null) { if (data != null) {
@ -170,13 +174,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()
} }

2
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())
} }
} }