Créer des blocs "Réglages rapides" personnalisés pour votre application

Les réglages rapides sont des cartes affichées dans le panneau des réglages rapides. Elles représentent des actions que les utilisateurs peuvent appuyer pour effectuer rapidement des tâches récurrentes. Votre application peut fournir une carte personnalisée aux utilisateurs via la classe TileService et utiliser un objet Tile pour suivre l'état de la carte. Par exemple, vous pouvez créer une carte permettant aux utilisateurs d'activer ou de désactiver un VPN fourni par votre application.

Décider quand créer une carte

Nous vous recommandons de créer des cartes pour des fonctionnalités spécifiques auxquelles les utilisateurs doivent accéder souvent ou rapidement (ou les deux). Les cartes les plus efficaces sont celles qui correspondent à ces deux qualités, offrant un accès rapide aux actions fréquemment effectuées.

Par exemple, vous pouvez créer une carte pour une application de fitness qui permettra aux utilisateurs de démarrer rapidement une séance d'entraînement. Toutefois, nous vous déconseillons de créer une carte pour la même application qui permettrait aux utilisateurs de consulter l'intégralité de leur historique d'entraînements.

Pour améliorer la visibilité et la facilité d'utilisation de votre carte, nous vous recommandons d'éviter certaines pratiques:

• Évitez d'utiliser des cartes pour lancer une application. Utilisez plutôt un raccourci d'application ou un lanceur d'applications standard.

• Évitez d'utiliser des cartes pour des actions ponctuelles de l'utilisateur. Utilisez plutôt un raccourci d'application ou une notification.

• Évitez de créer trop de cartes. Nous vous recommandons de n'en utiliser que deux par application. Utilisez plutôt un raccourci d'application.

• Évitez d'utiliser des cartes qui affichent des informations, mais qui ne sont pas interactives pour les utilisateurs. Utilisez plutôt une notification ou un widget.

Créer votre carte

Pour créer une carte, vous devez d'abord créer une icône de carte appropriée, puis créer et déclarer votre TileService dans le fichier manifeste de votre application.

L'exemple de paramètres rapides montre comment créer et gérer un bloc.

Créer votre icône personnalisée

Vous devez fournir une icône personnalisée, qui s'affiche sur la carte dans le panneau "Réglages rapides". (Vous ajouterez cette icône lorsque vous déclarerez TileService, comme décrit dans la section suivante.) L'icône doit être de couleur blanche unie avec un arrière-plan transparent, mesurer 24 x 24 dp et prendre la forme d'un VectorDrawable.

Créez une icône qui donne un indice visuel sur l'objectif de votre carte. Cela permet aux utilisateurs de déterminer facilement si votre carte répond à leurs besoins. Par exemple, vous pouvez créer une icône de chronomètre pour une carte d'une application de remise en forme qui permet aux utilisateurs de démarrer une séance d'entraînement.

Créer et déclarer votre TileService

Créez un service pour votre carte qui étend 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();
  }
}

Déclarez votre TileService dans le fichier manifeste de votre application. Ajoutez le nom et le libellé de votre TileService, l'icône personnalisée que vous avez créée dans la section précédente et l'autorisation appropriée.

 <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>

Gérer votre TileService

Une fois que vous avez créé et déclaré votre TileService dans le fichier manifeste de votre application, vous devez gérer son état.

TileService est un service lié. Votre TileService est lié lorsqu'il est demandé par votre application ou si le système doit communiquer avec lui. Un cycle de vie de service lié typique contient les quatre méthodes de rappel suivantes : onCreate(), onBind(), onUnbind() et onDestroy(). Ces méthodes sont appelées par le système chaque fois que le service entre dans une nouvelle phase de cycle de vie.

Présentation du cycle de vie de TileService

En plus des rappels qui contrôlent le cycle de vie du service lié, vous devez implémenter d'autres méthodes spécifiques au cycle de vie de TileService. Ces méthodes peuvent être appelées en dehors de onCreate() et onDestroy(), car les méthodes de cycle de vie Service et les méthodes de cycle de vie TileService sont appelées dans deux threads asynchrones distincts.

Le cycle de vie de TileService contient les méthodes suivantes, qui sont appelées par le système chaque fois que votre TileService entre dans une nouvelle phase de cycle de vie:

• onTileAdded(): cette méthode n'est appelée que lorsque l'utilisateur ajoute votre carte pour la première fois, et si l'utilisateur la supprime et l'ajoute à nouveau. C'est le meilleur moment pour effectuer une initialisation ponctuelle. Toutefois, cela ne peut pas satisfaire toutes les initialisations nécessaires.

• onStartListening() et onStopListening(): ces méthodes sont appelées chaque fois que votre application met à jour la carte et sont appelées fréquemment. TileService reste lié entre onStartListening() et onStopListening(), ce qui permet à votre application de modifier la carte et de pousser des mises à jour.

• onTileRemoved(): cette méthode n'est appelée que si l'utilisateur supprime votre carte.

Sélectionner un mode d'écoute

Votre TileService écoute en mode actif ou non actif. Nous vous recommandons d'utiliser le mode actif, que vous devrez déclarer dans le fichier manifeste de l'application. Sinon, TileService est le mode standard et n'a pas besoin d'être déclaré.

Ne partez pas du principe que votre TileService réside en dehors de la paire de méthodes onStartListening() et onStopListening().

Mode Actif (recommandé)

Utilisez le mode actif pour un TileService qui écoute et surveille son état dans son propre processus. Un TileService en mode actif est lié à onTileAdded(), onTileRemoved(), aux événements de pression et lorsque le processus de l'application le demande.

Nous vous recommandons d'utiliser le mode actif si votre TileService est averti lorsque l'état de votre carte doit être mis à jour par son propre processus. Les cartes actives limitent la pression sur le système, car elles n'ont pas besoin d'être liées chaque fois que le panneau des paramètres rapides devient visible pour l'utilisateur.

La méthode statique TileService.requestListeningState() peut être appelée pour demander le début de l'état d'écoute et recevoir un rappel vers onStartListening().

Vous pouvez déclarer le mode actif en ajoutant META_DATA_ACTIVE_TILE au fichier manifeste de votre application.

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

Mode non actif

Le mode non actif est le mode standard. Un TileService est en mode non actif s'il est lié chaque fois que votre carte est visible par l'utilisateur. Cela signifie que votre TileService peut être créé et lié à nouveau à des moments qui ne sont pas sous son contrôle. Il peut également être dissocié et détruit lorsque l'utilisateur ne consulte pas la carte.

Votre application reçoit un rappel vers onStartListening() une fois que l'utilisateur ouvre son panneau de paramètres rapides. Vous pouvez mettre à jour votre objet Tile autant de fois que vous le souhaitez entre onStartListening() et onStopListening().

Vous n'avez pas besoin de déclarer le mode non actif. Il vous suffit de ne pas ajouter META_DATA_ACTIVE_TILE au fichier manifeste de votre application.

Présentation des états des cartes

Une fois qu'un utilisateur a ajouté votre carte, elle se trouve toujours dans l'un des états suivants.

• STATE_ACTIVE: indique un état activé. L'utilisateur peut interagir avec votre carte dans cet état.

  Par exemple, pour une carte d'application de fitness qui permet aux utilisateurs de lancer une séance d'entraînement chronométrée, STATE_ACTIVE signifie que l'utilisateur a lancé une séance d'entraînement et que le minuteur est en cours.

• STATE_INACTIVE: indique un état "Désactivé" ou "Mis en veille". L'utilisateur peut interagir avec votre carte dans cet état.

  Pour reprendre l'exemple de la carte d'application de fitness, une carte dans STATE_INACTIVE signifie que l'utilisateur n'a pas lancé de session d'entraînement, mais qu'il pourrait le faire s'il le souhaitait.

• STATE_UNAVAILABLE: indique un état temporairement indisponible. L'utilisateur ne peut pas interagir avec votre carte dans cet état.

  Par exemple, une carte dans STATE_UNAVAILABLE signifie que l'utilisateur ne peut pas y accéder pour une raison quelconque.

Le système ne définit que l'état initial de votre objet Tile. Vous définissez l'état de l'objet Tile tout au long du reste de son cycle de vie.

Le système peut teinter l'icône et l'arrière-plan de la carte pour refléter l'état de votre objet Tile. Les objets Tile définis sur STATE_ACTIVE sont les plus sombres, tandis que STATE_INACTIVE et STATE_UNAVAILABLE sont de plus en plus clairs. La teinte exacte est spécifique au fabricant et à la version.

Mettre à jour votre carte

Vous pouvez modifier votre carte une fois que vous avez reçu un rappel vers onStartListening(). Selon le mode de la carte, votre carte peut être mise à jour au moins une fois jusqu'à ce qu'elle reçoive un rappel vers onStopListening().

En mode actif, vous pouvez modifier votre carte exactement une fois avant de recevoir un rappel vers onStopListening(). En mode non actif, vous pouvez mettre à jour votre carte autant de fois que vous le souhaitez entre onStartListening() et onStopListening().

Vous pouvez récupérer votre objet Tile en appelant getQsTile(). Pour mettre à jour des champs spécifiques de votre objet Tile, appelez les méthodes suivantes:

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

Vous devez appeler updateTile() pour mettre à jour votre carte une fois que vous avez défini les champs de l'objet Tile sur les valeurs appropriées. Le système analysera alors les données de carte mises à jour et mettra à jour l'UI.

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

Gérer les gestes d'appui

Les utilisateurs peuvent appuyer sur votre carte pour déclencher une action si elle se trouve dans STATE_ACTIVE ou STATE_INACTIVE. Le système appelle ensuite le rappel onClick() de votre application.

Une fois que votre application reçoit un rappel vers onClick(), elle peut lancer une boîte de dialogue ou une activité, déclencher une tâche en arrière-plan ou modifier l'état de votre carte.

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

Lancer une boîte de dialogue

showDialog() : réduit le panneau de configuration rapide et affiche une boîte de dialogue. Utilisez une boîte de dialogue pour ajouter du contexte à votre action si elle nécessite une entrée ou une autorisation supplémentaire de l'utilisateur.

Lancer une activité

startActivityAndCollapse() lance une activité tout en réduisant le panneau. Les activités sont utiles si vous devez afficher des informations plus détaillées qu'une boîte de dialogue ou si votre action est très interactive.

Si votre application nécessite une interaction utilisateur importante, elle ne doit lancer une activité qu'en dernier recours. Pensez plutôt à utiliser une boîte de dialogue ou un bouton d'activation/de désactivation.

Si l'utilisateur appuie de manière prolongée sur une vignette, l'écran Informations sur l'application s'affiche. Pour remplacer ce comportement et lancer une activité pour définir les préférences, ajoutez un <intent-filter> à l'une de vos activités avec ACTION_QS_TILE_PREFERENCES.

À partir de l'API Android 28, PendingIntent doit disposer de Intent.FLAG_ACTIVITY_NEW_TASK:

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

Vous pouvez également ajouter l'option dans AndroidManifest.xml dans la section Activity spécifique.

Marquer votre carte comme pouvant être activée/désactivée

Nous vous recommandons de marquer votre carte comme pouvant être activée/désactivée si elle fonctionne principalement comme un bouton à deux états (ce qui est le comportement le plus courant des cartes). Cela permet de fournir des informations sur le comportement de la carte au système d'exploitation et d'améliorer l'accessibilité globale.

Définissez les métadonnées TOGGLEABLE_TILE sur true pour indiquer que votre carte peut être activée/désactivée.

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

Effectuer uniquement des actions sécurisées sur des appareils verrouillés de manière sécurisée

Votre carte peut s'afficher au-dessus de l'écran de verrouillage sur les appareils verrouillés. Si la carte contient des informations sensibles, vérifiez la valeur de isSecure() pour déterminer si l'appareil est dans un état sécurisé. Votre TileService doit modifier son comportement en conséquence.

Si l'action de la carte peut être effectuée en toute sécurité lorsque l'écran est verrouillé, utilisez startActivity() pour lancer une activité au-dessus de l'écran de verrouillage.

Si l'action de la carte n'est pas sécurisée, utilisez unlockAndRun() pour inviter l'utilisateur à déverrouiller son appareil. Si l'opération réussit, le système exécute l'objet Runnable que vous transmettez à cette méthode.

Inviter l'utilisateur à ajouter votre carte

Pour ajouter manuellement votre carte, les utilisateurs doivent suivre plusieurs étapes:

1. Balayez l'écran vers le bas pour ouvrir le panneau Réglages rapides.
2. Appuyez sur le bouton de modification.
3. Faites défiler toutes les cartes de l'appareil jusqu'à ce qu'il trouve la vôtre.
4. Appuyez de manière prolongée sur votre carte, puis faites-la glisser vers la liste des cartes actives.

L'utilisateur peut également déplacer ou supprimer votre carte à tout moment.

À partir d'Android 13, vous pouvez utiliser la méthode requestAddTileService() pour faciliter l'ajout de votre carte à un appareil. Cette méthode invite les utilisateurs à ajouter rapidement votre carte directement à leur panneau de paramètres rapides. L'invite inclut le nom de l'application, le libellé fourni et l'icône.

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

Le rappel contient des informations indiquant si la carte a été ajoutée ou non, si elle était déjà présente ou si une erreur s'est produite.

Décidez de quand et à quelle fréquence envoyer des requêtes aux utilisateurs en fonction de votre propre discrétion. Nous vous recommandons de n'appeler requestAddTileService() que dans un contexte, par exemple lorsque l'utilisateur interagit pour la première fois avec une fonctionnalité que votre carte facilite.

Le système peut choisir d'arrêter de traiter les requêtes pour un ComponentName donné si l'utilisateur l'a refusé suffisamment de fois auparavant. L'utilisateur est déterminé à partir de l'Context utilisé pour récupérer ce service. Il doit correspondre à l'utilisateur actuel.