CODEWITHSUNDEEP
androidandroid-jetpack-composewidgetglance-appwidgetglance
Cristi Dumitrache
Cristi Dumitrache

Reputation: 150

Issue with Frequent Updates to Jetpack Compose Glance Widget

I'm developing an application using Jetpack Compose and I have some widgets created using Glance Widget. I need to update a counter on the widget every time I receive a notification in the application. Notifications can arrive very frequently, up to 4 times per second, but can also have larger intervals of 10-15 seconds.

To update the widget, I'm using the suspend fun GlanceAppWidget.updateAll(context: Context): Unit method every time a notification is received. However, I'm encountering an issue where the widget sometimes updates the counter but sometimes it doesn't.

My questions are:

  1. Are there any limitations on how often a widget can be updated using Glance?
  2. What is the best approach to ensure the widget reliably updates the counter every time a notification is received, especially considering the high frequency of updates?

Any advice or best practices would be greatly appreciated!

Upvotes: 4

Views: 514

Answers (3)

Mohamed Mabrouki
Mohamed Mabrouki

Reputation: 478

i have faced the same issue, the problem with updating glance frequently is that updatePeriodMillis in app widget provider could be at minumum 30 minutes and if you set it less than that it won't work as excpected and in my use case i had to update more frequently and this could be done using combination of alarm manager and GlanceAppWidgetReceiver.

the widget receiver :

class WidgetReceiver() : GlanceAppWidgetReceiver(), KoinComponent{
    override val glanceAppWidget: GlanceAppWidget = MyWidget()
    private val alarmManager: AlarmManager by inject()
    private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
//this will get called when the widget gets firstly initialized so we schedule the first alarm there
override fun onEnabled(context: Context?) {
    alarmManager.scheduleUpdateWidgetAlarm(
        id = "widget",
        triggerAt = 60000,
    )
    super.onEnabled(context)
}
//this will get called when the normal update widget gets called we use it as a fallback to schedule the alarm again in case it it was cancelled
override fun onUpdate(context: Context, appWidgetManager: AppWidgetManager, appWidgetIds: IntArray) {
    super.onUpdate(context, appWidgetManager, appWidgetIds)
    alarmManager.scheduleUpdateWidgetAlarm(
        id = "widget",
        triggerAt = 60000,
    )
}
// this will get called whenever alarm manager sends broadcast to the  widget receiver
override fun onReceive(context: Context, intent: Intent) {
    super.onReceive(context, intent)
    println("intent extra: " + intent.getStringExtra("prayerTime"))
    scope.launch {
        updateWidget(context)
    }
    alarmManager.scheduleUpdateWidgetAlarm(
        id = "widget",
        triggerAt = 60000,
    )
}

private suspend fun updateWidget(context: Context) {
    try {
        val manager = GlanceAppWidgetManager(context)
        val glanceIds =     manager.getGlanceIds(PrayerTimesWidget::class.java)
            glanceIds.forEach { glanceId ->
                glanceAppWidget.update(context, glanceId)
            }
        } catch (e: Exception) {
            println("WIDGET error in updateWidget of widget receiver     ${e.message}")
        }
    }

}



fun scheduleUpdateWidgetAlarm(id: String, triggerAt: Long) {
    val intent =
        Intent(context, WidgetReceiver::class.java).apply {
            putExtra("id", id)
        }
    if (canScheduleExactAlarm) {
        alarmManager.setAlarmClock(
            android.app.AlarmManager.AlarmClockInfo(
                Clock.System.now().toEpochMilliseconds() + triggerAt,
                null,
            ),
            PendingIntent.getBroadcast(
                context,
                id.hashCode(),
                intent,
                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
            ),
        )
    }
}

so the whole idea is to use this combination to make sure that the widget gets updated whenever needed depending on the usecase in mine it get's updated every 1 minute . this is the only workaround i did find also don't forget to reschedule your alarms when the device reboots.

Upvotes: 0

Ajay S T
Ajay S T

Reputation: 1

Facing the same issue, below are my observations

  1. If you look at the update code inside the library, it talks about session and lock, the logs will also say something similar.
  2. Once the widget is updated from the app or a new widget is created, the worker session (produced by Glance lib) is locked and released after 45-50 sec.
  3. Any updates made during that 45-50-second interval are ignored, so for a successful update, the app needs to wait for that time window to pass. You can confirm this time window by watching the logs (provided one below)
  4. I don't know much about session and locks but all this is true as per my testing.
  5. My approach: I am keeping a flag for widgetUpdate = true/false and invoking the updateWidget() code only in onStop() to prevent frequent updates, as the user cannot see the widget without going to the home screen. Our app is still in development; I have no idea what to do about it.

This is the log you should look for:

Worker result SUCCESS for Work [ id=69cc3029-d1b1-4e9a-9084-108baa942a49, tags={ androidx.glance.session.SessionWorker } ]

Please update if anyone got any fix/work around.

Upvotes: 0

Dinesh Thiyagarajan
Dinesh Thiyagarajan

Reputation: 480

There are no limitations on how often the composable is recomposed.We can't initialise the recomposition process manually. If the parameters of the Composable function you are using is updated, It will get recomposed with the new data automatically. Please refer this documentation https://developer.android.com/develop/ui/compose/mental-model#recomposition

Upvotes: -1

Related Questions