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.Composable
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()
    }
}

open suspend fun providePreview(context: Context, widgetCategory: Int): Unit

import androidx.compose.runtime.Composable
import androidx.glance.GlanceId
import androidx.glance.appwidget.GlanceAppWidget
import androidx.glance.appwidget.LocalAppWidgetOptions
import androidx.glance.appwidget.provideContent
import androidx.glance.text.Text

class MyWidgetWithPreview : GlanceAppWidget() {
    override suspend fun provideGlance(context: Context, id: GlanceId) {
        provideContent {
            val widgetCategory =
                LocalAppWidgetOptions.current.getInt(
                    AppWidgetManager.OPTION_APPWIDGET_HOST_CATEGORY
                )
            Content(isPreview = false, widgetCategory)
        }
    }

    override suspend fun providePreview(context: Context, widgetCategory: Int) {
        provideContent { Content(isPreview = true, widgetCategory) }
    }

    @Composable
    fun Content(isPreview: Boolean, widgetCategory: Int) {
        val text = if (isPreview) "preview" else "bound widget"
        Text("This is a $text.")
        // Avoid showing personal information if this preview or widget is showing on the
        // lockscreen/keyguard.
        val isKeyguardWidget = widgetCategory.and(WIDGET_CATEGORY_KEYGUARD) != 0
        if (!isKeyguardWidget) {
            Text("Some personal info.")
        }
    }
}

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

open val previewSizeMode: PreviewSizeMode

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

suspend fun GlanceAppWidget.composeForPreview(
    context: Context,
    widgetCategory: Int,
    info: AppWidgetProviderInfo? = null
): RemoteViews

@ExperimentalGlanceApi
fun GlanceAppWidget.runComposition(
    context: Context,
    id: GlanceId = createFakeAppWidgetId(),
    options: Bundle = Bundle(),
    sizes: List<DpSize>? = null,
    state: Any? = null,
    lambdaReceiver: ComponentName = ComponentName(context, UnmanagedSessionReceiver::class.java)
): 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