GlanceAppWidget

GlanceAppWidget(
    errorUiLayout: @LayoutRes Int = R.layout.glance_error_layout
)

open fun onCompositionError(
    context: Context,
    glanceId: GlanceId,
    appWidgetId: Int,
    throwable: Throwable
): Unit

open suspend fun onDelete(context: Context, glanceId: GlanceId): Unit

abstract suspend fun provideGlance(context: Context, id: GlanceId): Unit

import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.rememberCoroutineScope
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.stringPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import androidx.glance.GlanceId
import androidx.glance.GlanceModifier
import androidx.glance.action.clickable
import androidx.glance.appwidget.GlanceAppWidget
import androidx.glance.appwidget.provideContent
import androidx.glance.appwidget.updateAll
import androidx.glance.text.Text

class MyWidget : GlanceAppWidget() {

    val Context.myWidgetStore by preferencesDataStore("MyWidget")
    val Name = stringPreferencesKey("name")

    override suspend fun provideGlance(context: Context, id: GlanceId) {
        // Load initial data needed to render the AppWidget here. Prefer doing heavy work before
        // provideContent, as the provideGlance function will timeout shortly after
        // provideContent is called.
        val store = context.myWidgetStore
        val initial = store.data.first()

        provideContent {
            // Observe your sources of data, and declare your @Composable layout.
            val data by store.data.collectAsState(initial)
            val scope = rememberCoroutineScope()
            Text(
                text = "Hello ${data[Name]}",
                modifier = GlanceModifier.clickable("changeName") {
                    scope.launch {
                        store.updateData {
                            it.toMutablePreferences().apply { set(Name, "Changed") }
                        }
                    }
                }
            )
        }
    }

    // Updating the widget from elsewhere in the app:
    suspend fun changeWidgetName(context: Context, newName: String) {
        context.myWidgetStore.updateData {
            it.toMutablePreferences().apply { set(Name, newName) }
        }
        // Call update/updateAll in case a Worker for the widget is not currently running. This
        // is not necessary when updating data from inside of the composition using lambdas,
        // since a Worker will be started to run lambda actions.
        MyWidget().updateAll(context)
    }
}

import androidx.compose.runtime.collectAsState
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.intPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import androidx.glance.GlanceId
import androidx.glance.appwidget.GlanceAppWidget
import androidx.glance.appwidget.provideContent
import androidx.glance.appwidget.updateAll
import androidx.glance.text.Text
import androidx.work.CoroutineWorker
import androidx.work.ExistingPeriodicWorkPolicy
import androidx.work.PeriodicWorkRequest
import androidx.work.WorkManager
import androidx.work.WorkerParameters

class WeatherWidget : GlanceAppWidget() {

    val Context.weatherWidgetStore by preferencesDataStore("WeatherWidget")
    val CurrentDegrees = intPreferencesKey("currentDegrees")

    suspend fun DataStore<Preferences>.loadWeather() {
        updateData { prefs ->
            prefs.toMutablePreferences().apply {
                this[CurrentDegrees] = Random.Default.nextInt()
            }
        }
    }

    override suspend fun provideGlance(context: Context, id: GlanceId) {
        coroutineScope {
            val store = context.weatherWidgetStore
            val currentDegrees = store.data
                .map { prefs -> prefs[CurrentDegrees] }
                .stateIn(this@coroutineScope)

            // Load the current weather if there is not a current value present.
            if (currentDegrees.value == null) store.loadWeather()

            // Create unique periodic work to keep this widget updated at a regular interval.
            WorkManager.getInstance(context).enqueueUniquePeriodicWork(
                "weatherWidgetWorker",
                ExistingPeriodicWorkPolicy.KEEP,
                PeriodicWorkRequest.Builder(
                    WeatherWidgetWorker::class.java,
                    15.minutes.toJavaDuration()
                ).setInitialDelay(15.minutes.toJavaDuration()).build()
            )

            // Note: you can also set `android:updatePeriodMillis` to control how often the
            // launcher requests an update, but this does not support periods less than
            // 30 minutes.

            provideContent {
                val degrees by currentDegrees.collectAsState()
                Text("Current weather: $degrees °F")
            }
        }
    }
}

class WeatherWidgetWorker(
    appContext: Context,
    params: WorkerParameters
) : CoroutineWorker(appContext, params) {
    override suspend fun doWork(): Result {
        WeatherWidget().apply {
            applicationContext.weatherWidgetStore.loadWeather()
            // Call update/updateAll in case a Worker for the widget is not currently running.
            updateAll(applicationContext)
        }
        return Result.success()
    }
}

suspend fun update(context: Context, id: GlanceId): Unit

open val sizeMode: SizeMode

open val stateDefinition: GlanceStateDefinition<*>?

suspend fun GlanceAppWidget.compose(
    context: Context,
    id: GlanceId = createFakeAppWidgetId(),
    options: Bundle? = null,
    size: DpSize? = null,
    state: Any? = null
): RemoteViews

@ExperimentalGlanceApi
fun GlanceAppWidget.runComposition(
    context: Context,
    id: GlanceId = createFakeAppWidgetId(),
    options: Bundle = Bundle(),
    sizes: List<DpSize>? = null,
    state: Any? = null
): Flow<RemoteViews>

suspend fun GlanceAppWidget.provideContent(
    content: @Composable @GlanceComposable () -> Unit
): Nothing

suspend fun GlanceAppWidget.updateAll(context: Context): Unit

suspend inline fun <State : Any?> GlanceAppWidget.updateIf(
    context: Context,
    predicate: (State) -> Boolean
): Unit

suspend fun <T : Any?> GlanceAppWidget.getAppWidgetState(
    context: Context,
    glanceId: GlanceId
): T