Gestire l'interazione utente

Glance semplifica la gestione dell'interazione utente utilizzando le classi Action. Le classi Action di Glance definiscono le azioni che un utente può intraprendere e puoi specificare l'operazione eseguita in risposta all'azione. Puoi applicare un Action a qualsiasi componente con il GlanceModifier.clickable metodo.

I widget delle app risiedono in un processo remoto, quindi le azioni vengono definite al momento della creazione e l'esecuzione avviene nel processo remoto. In RemoteViews nativi, questa operazione viene eseguita utilizzando PendingIntents.

Le seguenti azioni sono descritte in questa pagina:

Avviare un'attività

Per avviare un'attività in caso di interazione dell'utente, fornisci la actionStartActivity funzione a un Button o a un altro elemento composable utilizzando il GlanceModifier.clickable modificatore.

Fornisci uno dei seguenti elementi in actionStartActivity:

  • La classe di attività di destinazione
  • Il ComponentName
  • Un intent

Glance traduce l'azione in un PendingIntent con la destinazione e i parametri forniti. Nell'esempio seguente, NavigationActivity viene avviata quando un utente fa clic sul pulsante:

@Composable
fun MyContent() {
    // ..
    Button(
        text = "Go Home",
        onClick = actionStartActivity<MyActivity>()
    )
}

Avviare un servizio

Analogamente all'avvio di un'attività, avvia un servizio in caso di interazione dell'utente utilizzando uno dei actionStartService metodi.

Fornisci uno dei seguenti elementi in actionStartService:

  • La classe di attività di destinazione
  • Il ComponentName
  • Un intent

@Composable
fun MyButton() {
    // ..
    Button(
        text = "Sync",
        onClick = actionStartService<SyncService>(
            isForegroundService = true // define how the service is launched
        )
    )
}

Inviare un evento di trasmissione

Invia un evento di trasmissione in caso di interazione dell'utente utilizzando uno dei actionSendBroadcast metodi:

Fornisci uno dei seguenti elementi in actionSendBroadcast:

@Composable
fun MyButton() {
    // ..
    Button(
        text = "Send",
        onClick = actionSendBroadcast<MyReceiver>()
    )
}

Eseguire azioni personalizzate

Anziché avviare una destinazione specifica, Glance può utilizzare un'azione lambda o un actionRunCallback per eseguire un'azione, ad esempio aggiornare l'UI o lo stato in caso di interazione dell'utente.

Eseguire azioni lambda

Puoi utilizzare le funzioni lambda come callback per le interazioni dell'UI.

Ad esempio, passa la funzione lambda al modificatore GlanceModifier.clickable:

Text(
    text = "Submit",
    modifier = GlanceModifier.clickable {
        submitData()
    }
)

In alternativa, passala al parametro onClick sugli elementi composable che lo supportano:

Button(
    text = "Submit",
    onClick = {
        submitData()
    }
)

Eseguire ActionCallback

In alternativa, utilizza i actionRunCallback metodi per eseguire un'azione in caso di interazione dell'utente. Per farlo, fornisci un'implementazione personalizzata di ActionCallback:

@Composable
private fun MyContent() {
    // ..
    Image(
        provider = ImageProvider(R.drawable.ic_hourglass_animated),
        modifier = GlanceModifier.clickable(
            onClick = actionRunCallback<RefreshAction>()
        ),
        contentDescription = "Refresh"
    )
}

class RefreshAction : ActionCallback {
    override suspend fun onAction(
        context: Context,
        glanceId: GlanceId,
        parameters: ActionParameters
    ) {
        // TODO implement
    }
}

Quando l'utente fa clic, viene chiamato il metodo suspend onAction di ActionCallback fornito, che esegue la logica definita (ad es. la richiesta di aggiornamento dei dati).

Per aggiornare il widget dopo l'esecuzione dell'azione, crea una nuova istanza e chiama update(..). Per maggiori dettagli, consulta la sezione Gestire lo stato di GlanceAppWidget.

class RefreshAction : ActionCallback {
    override suspend fun onAction(
        context: Context,
        glanceId: GlanceId,
        parameters: ActionParameters
    ) {
        // do some work but offset long-term tasks (e.g a Worker)
        MyAppWidget().update(context, glanceId)
    }
}

Fornire parametri alle azioni

Per fornire informazioni aggiuntive a un'azione, utilizza l'ActionParameters API per creare una coppia chiave-valore tipizzata. Ad esempio, per definire la destinazione su cui è stato fatto clic:

private val destinationKey = ActionParameters.Key<String>(
    NavigationActivity.KEY_DESTINATION
)

class MyAppWidget : GlanceAppWidget() {

    // ..

    @Composable
    private fun MyContent() {
        // ..
        Button(
            text = "Home",
            onClick = actionStartActivity<NavigationActivity>(
                actionParametersOf(destinationKey to "home")
            )
        )
        Button(
            text = "Work",
            onClick = actionStartActivity<NavigationActivity>(
                actionParametersOf(destinationKey to "work")
            )
        )
    }

    override suspend fun provideGlance(context: Context, id: GlanceId) {
        provideContent { MyContent() }
    }
}

Sotto, i parametri sono inclusi nell'intent utilizzato per avviare l'attività, consentendo all'attività di destinazione di recuperarla.

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val destination = intent.extras?.getString(KEY_DESTINATION) ?: return
        // ...
    }
}

I parametri vengono forniti anche a ActionCallback. Utilizza Parameters.Key definito per recuperare il valore:

class RefreshAction : ActionCallback {

    private val destinationKey = ActionParameters.Key<String>(
        NavigationActivity.KEY_DESTINATION
    )

    override suspend fun onAction(
        context: Context,
        glanceId: GlanceId,
        parameters: ActionParameters
    ) {
        val destination: String = parameters[destinationKey] ?: return
        // ...
    }
}

Indietro
Test delle unità con Glance
Avanti
Monitora le metriche per il widget