Creare riquadri delle Impostazioni rapide personalizzati per la tua app

Le Impostazioni rapide sono riquadri visualizzati nel riquadro Impostazioni rapide, che rappresentano azioni che gli utenti possono toccare per completare rapidamente le attività ricorrenti. La tua app può fornire un riquadro personalizzato agli utenti tramite la classe TileService e utilizzare un oggetto Tile per monitorare lo stato del riquadro. Ad esempio, puoi creare un riquadro che consenta agli utenti di attivare o disattivare una VPN fornita dalla tua app.

Decidere quando creare un riquadro

Ti consigliamo di creare riquadri per funzionalità specifiche a cui prevedi che gli utenti accedano spesso o di cui hanno bisogno di accedere rapidamente (o entrambe le cose). I riquadri più efficaci sono quelli che corrispondono a entrambe le qualità, fornendo accesso rapido alle azioni eseguite di frequente.

Ad esempio, puoi creare un riquadro per un'app per il fitness che consenta agli utenti di avviare rapidamente una sessione di allenamento. Tuttavia, sconsigliamo di creare un riquadro per la stessa app che consenta agli utenti di esaminare l'intera cronologia degli allenamenti.

Per migliorare la rilevabilità e la facilità d'uso del riquadro, consigliamo di evitare alcune pratiche:

• Evita di utilizzare riquadri per avviare un'app. Utilizza invece una scorciatoia per app o un avviatore standard.

• Evita di utilizzare riquadri per azioni utente singole. Utilizza una scorciatoia per app o una notifica.

• Evita di creare troppi riquadri. Consigliamo un massimo di due per app. Utilizza invece una shorcut dell'app.

• Evita di utilizzare riquadri che mostrano informazioni, ma non sono interattivi per gli utenti. Utilizza una notifica o un widget.

Crea il tuo riquadro

Per creare un riquadro, devi prima creare un'icona per il riquadro appropriata, quindi creare e dichiarare TileService nel file manifest dell'app.

L'esempio di Impostazioni rapide fornisce un esempio di come creare e gestire un riquadro.

Creare un'icona personalizzata

Dovrai fornire un'icona personalizzata, che verrà visualizzata nel riquadro delle impostazioni rapide. Aggiungerai questa icona quando dichiari TileService, descritto nella sezione successiva. L'icona deve essere bianca a tinta unita con uno sfondo trasparente, misurare 24 x 24 dp ed essere a forma di VectorDrawable.

Crea un'icona che suggerisca visivamente lo scopo del riquadro. In questo modo gli utenti possono identificare facilmente se la tua scheda soddisfa le loro esigenze. Ad esempio, potresti creare un'icona di un cronometro per un riquadro di un'app per il fitness che consente agli utenti di avviare una sessione di allenamento.

Crea e dichiara il tuo TileService

Crea un servizio per il tuo riquadro che espanda la classe TileService.

class MyQSTileService: TileService() {

  // Called when the user adds your tile.
  override fun onTileAdded() {
    super.onTileAdded()
  }
  // Called when your app can update your tile.
  override fun onStartListening() {
    super.onStartListening()
  }

  // Called when your app can no longer update your tile.
  override fun onStopListening() {
    super.onStopListening()
  }

  // Called when the user taps on your tile in an active or inactive state.
  override fun onClick() {
    super.onClick()
  }
  // Called when the user removes your tile.
  override fun onTileRemoved() {
    super.onTileRemoved()
  }
}

public class MyQSTileService extends TileService {

  // Called when the user adds your tile.
  @Override
  public void onTileAdded() {
    super.onTileAdded();
  }

  // Called when your app can update your tile.
  @Override
  public void onStartListening() {
    super.onStartListening();
  }

  // Called when your app can no longer update your tile.
  @Override
  public void onStopListening() {
    super.onStopListening();
  }

  // Called when the user taps on your tile in an active or inactive state.
  @Override
  public void onClick() {
    super.onClick();
  }

  // Called when the user removes your tile.
  @Override
  public void onTileRemoved() {
    super.onTileRemoved();
  }
}

Dichiara TileService nel file manifest dell'app. Aggiungi il nome e l'etichetta del TileService, l'icona personalizzata che hai creato nella sezione precedente, e l'autorizzazione appropriata.

 <service
     android:name=".MyQSTileService"
     android:exported="true"
     android:label="@string/my_default_tile_label"  // 18-character limit.
     android:icon="@drawable/my_default_icon_label"
     android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
     <intent-filter>
         <action android:name="android.service.quicksettings.action.QS_TILE" />
     </intent-filter>
 </service>

Gestire TileService

Dopo aver creato e dichiarato TileService nel file manifest dell'app, devi gestire il relativo stato.

TileService è un servizio associato. TileService viene associato quando richiesto dalla tua app o se il sistema deve comunicare con esso. Un tipico ciclo di vita di un servizio associato contiene i seguenti quattro metodi di callback: onCreate(), onBind(), onUnbind() e onDestroy(). Questi metodi vengono richiamati dal sistema ogni volta che il servizio entra in una nuova fase del ciclo di vita.

Panoramica del ciclo di vita di TileService

Oltre ai callback che controllano il ciclo di vita del servizio associato, devi implementare altri metodi specifici per il ciclo di vita di TileService. Questi metodi possono essere chiamati al di fuori di onCreate() e onDestroy() perché i metodi del ciclo di vita Service e quelli del ciclo di vita TileService vengono chiamati in due thread asincroni separati.

Il ciclo di vita di TileService contiene i seguenti metodi, richiamati dal sistema ogni volta che TileService entra in una nuova fase del ciclo di vita:

• onTileAdded(): questo metodo viene chiamato solo quando l'utente aggiunge il tuo riquadro per la prima volta e se l'utente lo rimuove e lo aggiunge di nuovo. Questo è il momento migliore per eseguire qualsiasi inizializzazione una tantum. Tuttavia, questo potrebbe non soddisfare tutta l'inizializzazione necessaria.

• onStartListening() e onStopListening(): questi metodi vengono richiamati ogni volta che l'app aggiorna il riquadro e vengono richiamati spesso. Il valore TileService rimane vincolato tra onStartListening() e onStopListening(), consentendo all'app di modificare il riquadro e inviare aggiornamenti.

• onTileRemoved(): questo metodo viene chiamato solo se l'utente rimuove il riquadro.

Seleziona una modalità di ascolto

TileService ascolta in modalità attiva o non attiva. Ti consigliamo di utilizzare la modalità attiva, che dovrai dichiarare nel file manifest dell'app. In caso contrario, TileService è la modalità standard e non deve essere dichiarata.

Non dare per scontato che TileService rimarrà al di fuori della coppia di metodi onStartListening() e onStopListening().

Modalità attiva (consigliata)

Utilizza la modalità attiva per un TileService che ascolta e monitora il proprio stato nel proprio processo. Un TileService in modalità attiva è associato a onTileAdded(), onTileRemoved(), agli eventi di tocco e quando richiesto dal processo dell'app.

Consigliamo la modalità attiva se TileService viene informato quando lo stato del riquadro deve essere aggiornato dal proprio processo. Le schede attive riducono il carico sul sistema perché non devono essere associate ogni volta che il riquadro Impostazioni rapide diventa visibile all'utente.

È possibile chiamare il metodo TileService.requestListeningState() statico per richiedere l'avvio dello stato di ascolto e ricevere un callback a onStartListening().

Puoi dichiarare la modalità attiva aggiungendo META_DATA_ACTIVE_TILE al file manifest dell'app.

<service ...>
    <meta-data android:name="android.service.quicksettings.ACTIVE_TILE"
         android:value="true" />
    ...
</service>

Modalità non attiva

La modalità non attiva è quella standard. Un TileService è in modalità non attiva se è associato ogni volta che il tuo riquadro è visibile all'utente. Ciò significa che il tuo TileService potrebbe essere creato e vincolato di nuovo in momenti al di fuori del suo controllo. Inoltre, potrebbe essere slegato ed eliminato quando l'utente non sta visualizzando il riquadro.

La tua app viene richiamata a onStartListening() dopo che l'utente ha aperto il riquadro Impostazioni rapide. Puoi aggiornare l'oggetto Tile tutte le volte che vuoi tra le date onStartListening() e onStopListening().

Non è necessario dichiarare la modalità non attiva: non aggiungere semplicemente META_DATA_ACTIVE_TILE al file manifest dell'app.

Panoramica degli stati dei riquadri

Dopo che un utente ha aggiunto il tuo riquadro, questo esiste sempre in uno dei seguenti stati.

• STATE_ACTIVE: indica uno stato attivo o abilitato. L'utente può interagire con il riquadro in questo stato.

  Ad esempio, per un riquadro di un'app per il fitness che consente agli utenti di avviare una sessione di allenamento con timer, STATE_ACTIVE indica che l'utente ha avviato una sessione di allenamento e il timer è in esecuzione.

• STATE_INACTIVE: indica uno stato di disattivazione o messa in pausa. L'utente può interagire con il riquadro in questo stato.

  Per utilizzare di nuovo l'esempio di riquadro dell'app per l'attività fisica, un riquadro in STATE_INACTIVE significa che l'utente non ha avviato una sessione di allenamento, ma può farlo se lo desidera.

• STATE_UNAVAILABLE: indica uno stato temporaneamente non disponibile. L'utente non può interagire con il riquadro in questo stato.

  Ad esempio, un riquadro in STATE_UNAVAILABLE indica che non è attualmente disponibile per l'utente per qualche motivo.

Il sistema imposta solo lo stato iniziale dell'oggetto Tile. Imposti lo stato dell'Tile oggetto per tutto il resto del suo ciclo di vita.

Il sistema potrebbe colorare l'icona e lo sfondo del riquadro in base allo stato dell'oggetto Tile. Gli oggetti Tile impostati su STATE_ACTIVE sono i più scuri, mentre STATE_INACTIVE e STATE_UNAVAILABLE sono sempre più chiari. La tonalità esatta è specifica per il produttore e la versione.

Aggiorna il tuo riquadro

Puoi aggiornare il riquadro quando ricevi una chiamata al numero onStartListening(). A seconda della modalità, il riquadro può essere aggiornato almeno una volta fino a quando non riceve un callback a onStopListening().

In modalità attiva, puoi aggiornare il tuo riquadro esattamente una volta prima di ricevere una chiamata al onStopListening(). In modalità non attiva, puoi aggiornare il riquadro tutte le volte che vuoi tra onStartListening() e onStopListening().

Puoi recuperare l'oggetto Tile chiamando getQsTile(). Per aggiornare campi specifici dell'oggetto Tile, chiama i seguenti metodi:

• setContentDescription()
• setIcon()
• setLabel()
• setState()
• setStateDescription()
• setSubtitle()

Devi chiamare updateTile() per aggiornare il riquadro dopo aver impostato i valori corretti per i campi dell'oggetto Tile. In questo modo, il sistema analizzerà i dati dei riquadri aggiornati e aggiornerà l'interfaccia utente.

data class StateModel(val enabled: Boolean, val label: String, val icon: Icon)

override fun onStartListening() {
  super.onStartListening()
  val state = getStateFromService()
  qsTile.label = state.label
  qsTile.contentDescription = tile.label
  qsTile.state = if (state.enabled) Tile.STATE_ACTIVE else Tile.STATE_INACTIVE
  qsTile.icon = state.icon
  qsTile.updateTile()
}

public class StateModel {
  final boolean enabled;
  final String label;
  final Icon icon;

  public StateModel(boolean e, String l, Icon i) {
    enabled = e;
    label = l;
    icon = i;
  }
}

@Override
public void onStartListening() {
  super.onStartListening();
  StateModel state = getStateFromService();
  Tile tile = getQsTile();
  tile.setLabel(state.label);
  tile.setContentDescription(state.label);
  tile.setState(state.enabled ? Tile.STATE_ACTIVE : Tile.STATE_INACTIVE);
  tile.setIcon(state.icon);
  tile.updateTile();
}

Gestire i tocchi

Gli utenti possono toccare il tuo riquadro per attivare un'azione se il riquadro è in STATE_ACTIVE o STATE_INACTIVE. Il sistema richiama quindi il callback onClick() dell'app.

Quando l'app riceve un callback a onClick(), può aprire una finestra di dialogo o un'attività, attivare il lavoro in background o modificare lo stato del riquadro.

var clicks = 0
override fun onClick() {
  super.onClick()
  counter++
  qsTile.state = if (counter % 2 == 0) Tile.STATE_ACTIVE else Tile.STATE_INACTIVE
  qsTile.label = "Clicked $counter times"
  qsTile.contentDescription = qsTile.label
  qsTile.updateTile()
}

int clicks = 0;

@Override
public void onClick() {
  super.onClick();
  counter++;
  Tile tile = getQsTile();
  tile.setState((counter % 2 == 0) ? Tile.STATE_ACTIVE : Tile.STATE_INACTIVE);
  tile.setLabel("Clicked " + counter + " times");
  tile.setContentDescription(tile.getLabel());
  tile.updateTile();
}

Avvia una finestra di dialogo

showDialog() comprime il riquadro Impostazioni rapide e mostra una finestra di dialogo. Utilizza una finestra di dialogo per aggiungere contesto all'azione se richiede input aggiuntivi o il consenso dell'utente.

Lanciare un'attività

startActivityAndCollapse() avvia un'attività mentre comprime il riquadro. Le attività sono utili se ci sono informazioni più dettagliate da visualizzare rispetto a una finestra di dialogo o se l'azione è altamente interattiva.

Se la tua app richiede un'interazione significativa con l'utente, deve avviare un'attività solo come ultima risorsa. In alternativa, valuta la possibilità di utilizzare una finestra di dialogo o un pulsante di attivazione/disattivazione.

Se tocchi a lungo un riquadro, viene visualizzata la schermata Informazioni app. Per eseguire l'override di questo comportamento e avviare un'attività per l'impostazione delle preferenze, aggiungi un <intent-filter> a una delle tue attività con ACTION_QS_TILE_PREFERENCES.

A partire dall'API Android 28, PendingIntent deve avere il Intent.FLAG_ACTIVITY_NEW_TASK:

if (Build.VERSION.SDK_INT >= 28) {
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
}

In alternativa, puoi aggiungere il flag in AndroidManifest.xml nella sezione specificaActivity.

Contrassegna il riquadro come attivabile/disattivabile

Ti consigliamo di contrassegnare il riquadro come attivabile/disattivabile se funziona principalmente come pulsante a due stati (che è il comportamento più comune dei riquadri). In questo modo, viene fornito al sistema operativo informazioni sul comportamento della scheda e viene migliorata l'accessibilità complessiva.

Imposta i metadati TOGGLEABLE_TILE su true per contrassegnare il riquadro come attivabile/disattivabile.

<service ...>
  <meta-data android:name="android.service.quicksettings.TOGGLEABLE_TILE"
    android:value="true" />
</service>

Eseguire solo azioni sicure sui dispositivi bloccati in modo sicuro

Il riquadro potrebbe essere visualizzato sopra la schermata di blocco sui dispositivi bloccati. Se il riquadro contiene informazioni sensibili, controlla il valore di isSecure() per determinare se il dispositivo è in stato sicuro e TileService dovrebbe modificare il proprio comportamento di conseguenza.

Se l'azione del riquadro è sicura da eseguire in stato bloccato, usa startActivity() per avviare un'attività sopra la schermata di blocco.

Se l'azione del riquadro non è sicura, utilizza unlockAndRun() per chiedere all'utente di sbloccare il proprio dispositivo. In caso di esito positivo, il sistema esegue l'oggetto Runnable che trasmetti in questo metodo.

Chiedi all'utente di aggiungere il tuo riquadro

Per aggiungere manualmente il riquadro, gli utenti devono seguire diversi passaggi:

1. Scorri verso il basso per aprire il riquadro Impostazioni rapide.
2. Tocca il pulsante Modifica.
3. Scorri tutti i riquadri sul dispositivo finché non trova il tuo.
4. Tieni premuto il riquadro e trascinalo nell'elenco dei riquadri attivi.

L'utente può anche spostare o rimuovere il riquadro in qualsiasi momento.

A partire da Android 13, puoi utilizzare il metodo requestAddTileService() per semplificare l'aggiunta del tuo riquadro a un dispositivo da parte degli utenti. Questo metodo richiede agli utenti di aggiungere rapidamente il riquadro direttamente al riquadro Impostazioni rapide. La richiesta include il nome dell'applicazione, l'etichetta e l'icona forniti.

public void requestAddTileService (
  ComponentName tileServiceComponentName,
  CharSequence tileLabel,
  Icon icon,
  Executor resultExecutor,
  Consumer<Integer> resultCallback
)

Il callback contiene informazioni sull'eventuale aggiunta o meno del riquadro, se era già presente o se si è verificato un errore.

Valuta a tua discrezione quando e con quale frequenza inviare una richiesta agli utenti. Ti consigliamo di chiamare requestAddTileService() solo in contesto, ad esempio quando l'utente interagisce per la prima volta con una funzionalità semplificata dal tuo riquadro.

Il sistema può scegliere di interrompere l'elaborazione delle richieste per un determinato ComponentName se è stato rifiutato dall'utente un numero sufficiente di volte in precedenza. L'utente viene determinato dal valore Context utilizzato per recuperare questo servizio e deve corrispondere all'utente corrente.