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 TileService e utilizza un oggetto Tile per monitorare lo stato del riquadro. Ad esempio: potresti creare un riquadro che consenta agli utenti di attivare o disattivare una VPN fornita dalla tua app disattivata.

Figura 1. Riquadro Impostazioni rapide con il riquadro VPN attivato on e off.

.

Nota: questa guida illustra solo i riquadri non Wear: i riquadri delle Impostazioni rapide non hanno rispetto ai riquadri definiti in Wear OS. Per i riquadri di Wear OS, consulta Guida ai riquadri di WearOS.

Decidere quando creare un riquadro

Consigliamo di creare riquadri per le funzionalità specifiche che ti aspetti dagli utenti per poter accedere spesso o che necessitano di un accesso rapido (o entrambi). Il modo più efficace i riquadri corrispondono a entrambe le qualità e consentono di accedere rapidamente eseguite di frequente.

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

Figura 2. Esempi di riquadri consigliati e non consigliati per un'app per il fitness.

.

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

• Evita di utilizzare riquadri per avviare un'app. Utilizza una scorciatoia dell'app o una scorciatoia standard in Avvio applicazioni.

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

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

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

Crea il tuo riquadro

Per creare un riquadro, devi prima creare un'icona del riquadro appropriata, quindi crea e dichiara TileService nel file manifest dell'app.

Nota: la creazione di un TileService per l'app non ne aggiunge all'elenco di accesso rapido dell'utente Impostazioni. TileService funge da interfaccia solo con il riquadro dopo che l'utente l'ha aggiunta.

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

Crea la tua icona personalizzata

Occorre fornire un'icona personalizzata, che verrà visualizzata nel riquadro della scheda Impostazioni. (aggiungerai questa icona quando dichiari TileService, descritti nella prossima sezione.) L'icona deve essere bianca in tinta unita con una sfondo trasparente, misure 24 x 24 dp e sotto forma di VectorDrawable

Figura 3. Esempio di drawable vettoriale.

Crea un'icona che indichi visivamente lo scopo del tuo riquadro. Questo aiuta gli utenti identificare facilmente se il tuo riquadro soddisfa le loro esigenze. Ad esempio, potresti creare un'etichetta icona di un cronometro per un riquadro di un'app per l'attività fisica che consente agli utenti di avviare sessione di allenamento.

Crea e dichiara il tuo TileService

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

Kotlin

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

Java

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 di TileService, l'icona personalizzata che hai creato nella sezione precedente, e dell'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, non deve gestire il proprio stato.

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

Importante: il tuo TileService continuerà a eseguire la tipica Service durante il ciclo di vita di attività. Tuttavia, TileService è diverso dalla maggior parte degli altri servizi associati perché contiene metodi del ciclo di vita specifici per TileService a cui la tua app deve reagire a.

Panoramica del ciclo di vita di TileService

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

Il ciclo di vita di TileService contiene i seguenti metodi, che vengono richiamati dal sistema ogni volta che il tuo 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, non soddisfano tutte le inizializzazioni necessarie.

  Nota: onTileAdded() non viene chiamato ogni volta che viene creato il riquadro. Per ad esempio onTileAdded() non viene chiamato quando il dispositivo viene riavviato se il riquadro era stato aggiunto e non rimosso prima che il dispositivo fosse spento.

• onStartListening() e onStopListening(): questi metodi sono chiamati ogni volta che l'app aggiorna il riquadro e vengono chiamati spesso. La TileService rimane vincolata tra onStartListening() e onStopListening(), consentendo alla tua app di modificare il riquadro ed eseguire il push degli aggiornamenti.

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

di Gemini Advanced.

Attenzione: queste fasi possono non verificarsi in successione. onTileAdded() può essere solo chiamato una volta quando il tuo riquadro viene aggiunto da un utente al riquadro Impostazioni rapide. onStartListening() e onStopListening() potrebbero essere chiamati più volte durante il ciclo di vita di TileService. onTileRemoved() non verrà mai chiamato se l'utente non rimuove il riquadro dal riquadro Impostazioni rapide.

Seleziona una modalità di ascolto

Il tuo TileService ascolta in modalità attiva o non attiva. I nostri suggerimenti e la modalità attiva, che dovrai dichiarare nel file manifest dell'app. Altrimenti, TileService è la modalità standard e non deve essere dichiarata.

Non dare per scontato che il tuo TileService vivrà al di fuori di onStartListening() e onStopListening() coppia di metodi.

Modalità attiva (consigliata)

Usa la modalità attiva per un TileService che ascolta e monitora il suo stato processo autonomo. Un TileService in modalità attiva è associato a onTileAdded(), onTileRemoved(), tocca Eventi e quando richiesto dal processo dell'app.

Ti consigliamo la modalità attiva se il tuo TileService riceve una notifica quando il tuo riquadro dovrebbe essere aggiornato con la propria procedura. I riquadri attivi limitano la pressione sulla perché non devono essere vincolati ogni volta che il riquadro Impostazioni rapide diventa visibile all'utente.

Il metodo TileService.requestListeningState() statico può essere chiamato richiedere l'avvio dello stato di ascolto e ricevere un callback a onStartListening().

Puoi dichiarare la modalità attiva aggiungendo META_DATA_ACTIVE_TILE al tuo il 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 viene associato ogni volta che il riquadro è visibile all'utente. Ciò significa che TileService potrebbe essere creato e vincolato di nuovo a volte al di fuori del suo controllo. it Inoltre, può essere slegato ed eliminato quando l'utente non sta visualizzando il riquadro.

La tua app riceve un callback a onStartListening() dopo che l'utente ha aperto il suo Riquadro Impostazioni rapide. Puoi aggiornare l'oggetto Tile tutte le volte che vuoi vuoi tra onStartListening() e onStopListening().

Attenzione: se utilizzi la modalità non attiva anziché la modalità attiva, TileService potrebbe essere vincolato ogni volta che l'utente apre il riquadro Impostazioni rapide.

Non è necessario dichiarare la modalità non attiva, basta non aggiungere il META_DATA_ACTIVE_TILE al file manifest dell'app.

Panoramica degli stati dei riquadri

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

• STATE_ACTIVE: indica se lo stato è attivo o attivato. L'utente può interagire con il riquadro mentre si trova in questo stato.

  Ad esempio, per il riquadro di un'app per l'attività fisica che consente agli utenti di avviare un esercizio a tempo sessione, STATE_ACTIVE significa che l'utente ha avviato un'attività fisica sessione e il timer è in esecuzione.

• STATE_INACTIVE: indica lo stato disattivato o in pausa. L'utente può interagire con il riquadro mentre si trova in questo stato.

  Per utilizzare nuovamente l'esempio di riquadro dell'app per l'attività fisica, un riquadro in STATE_INACTIVE indica che l'utente non ha avviato una sessione di allenamento, ma potrebbe farlo se che desideravano.

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

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

  Attenzione: utilizza STATE_UNAVAILABLE per i riquadri attualmente non disponibili ma potrebbe essere reso disponibile in un secondo momento. Se il componente non esegue mai essere di nuovo disponibile per l'utente, supera COMPONENT_ENABLED_STATE_DISABLED in setComponentEnabledSetting().

Il sistema imposta solo lo stato iniziale dell'oggetto Tile. Hai impostato Tile durante il resto del ciclo di vita.

Il sistema potrebbe applicare una tinta all'icona del riquadro e allo sfondo per rispecchiare lo stato del Tile oggetto. Tile oggetti impostati su STATE_ACTIVE sono i più scuri, con STATE_INACTIVE e STATE_UNAVAILABLE sempre più leggeri. La tonalità esatta è specifica per il produttore e la versione.

Figura 4. Esempi di un riquadro colorato per riflettere lo stato del riquadro (rispettivamente attivo, non attivo e non disponibile).

Aggiorna il tuo riquadro

Puoi aggiornare il tuo riquadro quando ricevi una richiamata al numero onStartListening(). A seconda della modalità, il riquadro può essere aggiornato almeno una volta fino a quando viene richiamato il numero onStopListening().

In modalità attiva, puoi aggiornare il tuo riquadro esattamente una volta prima di ricevere callback a onStopListening(). In modalità non attiva, puoi aggiornare il tuo riquadro come quante volte vuoi tra onStartListening() e onStopListening().

Nota: la modalità attiva ti consente di aggiornare il tuo riquadro a prescindere dal fatto che sia visibile all'utente o meno.

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

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

di Gemini Advanced.

Nota: l'icona e l'etichetta impostate nel file manifest dell'app sono i valori predefiniti visualizzato nel riquadro del riquadro Impostazioni rapide. Tuttavia, puoi chiamare il metodo Metodi setIcon() e setLabel() durante l'aggiornamento del riquadro per impostare i campi a nuovi valori.

Devi chiamare updateTile() per aggiornare il tuo riquadro una volta completata l'impostazione dell'oggetto Tile in base ai valori corretti. In questo modo il sistema analizzare i dati aggiornati dei riquadri e aggiornare la UI.

Kotlin

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

Java

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 metodo onClick().

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

Kotlin

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

Java

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();
}

Apri 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 un input aggiuntivo o consenso dell'utente.

Nota: isLocked() controlla se viene visualizzata la schermata di blocco dell'utente. Quando isLocked() restituisce true, showDialog() non mostra una finestra di dialogo visibile perché viene caricato nella schermata di blocco.

Lanciare un'attività

startActivityAndCollapse() avvia un'attività mentre comprimi il dal 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 da parte dell'utente, dovrebbe avviare un solo l'ultima risorsa. In alternativa, valuta la possibilità di utilizzare una finestra di dialogo o un pulsante di attivazione/disattivazione.

Se si tocca a lungo un riquadro, viene visualizzata la schermata Info app per l'utente. Per eseguire l'override questo comportamento e avviare invece 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 hanno i Intent.FLAG_ACTIVITY_NEW_TASK:

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

In alternativa, puoi aggiungere il flag nella sezione AndroidManifest.xml della sezione Sezione Activity.

Contrassegnare il riquadro come attivabile

Ti consigliamo di contrassegnare il riquadro come selezionabile se funziona principalmente come opzione a due stati (il comportamento più comune dei riquadri). Ciò consente di fornire informazioni sul comportamento del riquadro al sistema operativo e migliorare l'accessibilità generale.

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

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

Esegui solo azioni sicure su dispositivi bloccati in modo sicuro

Sui dispositivi bloccati, il riquadro potrebbe essere visualizzato nella parte superiore della schermata di blocco. Se il riquadro contiene informazioni sensibili, controlla il valore di isSecure() per determinare se il dispositivo è in stato sicuro e TileService modificare il proprio comportamento di conseguenza.

Se l'azione del riquadro può essere eseguita in sicurezza mentre il dispositivo è bloccato, usa startActivity() per avviare un'attività nella parte superiore della schermata di blocco.

Se l'azione del riquadro non è sicura, utilizza unlockAndRun() per chiedere all'utente di sbloccare il suo dispositivo. Se l'operazione ha esito positivo, il sistema esegue Runnable che passi in questo .

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 suo dispositivo fino a quando non trova il tuo riquadro.
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 Chiede agli utenti di aggiungere rapidamente il tuo riquadro direttamente al loro Impostazioni. Il prompt include il nome dell'applicazione, l'etichetta fornita, e icona.

Figura 5. Richiesta dell'API posizionamento delle impostazioni rapide.

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

Il callback contiene informazioni se il riquadro è stato aggiunto o meno, non aggiunto, se era già presente o se si è verificato un errore.

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

Il sistema può scegliere di interrompere l'elaborazione delle richieste per un determinato ComponentName se è stata rifiutata dall'utente un numero sufficiente di volte in precedenza. La l'utente viene determinato in base alla Context utilizzata per recuperare questo deve corrispondere all'utente corrente.

Nota: ti consigliamo di chiamare il numero requestAddTileService() per aumentare la rilevabilità del tuo riquadro e riduci il carico di lavoro per l'utente che deve aggiungere il tuo riquadro al riquadro Impostazioni rapide.