Schnelleinstellungen sind Kacheln, die im Bereich Schnelleinstellungen angezeigt werden und Aktionen darstellen, auf die Nutzer tippen können, um wiederkehrende Aufgaben schnell auszuführen.
Ihre App kann Nutzern über die Klasse TileService eine benutzerdefinierte Kachel bereitstellen und ein Tile-Objekt verwenden, um den Status der Kachel zu verfolgen. Sie können beispielsweise eine Kachel erstellen, mit der Nutzer ein von Ihrer App bereitgestelltes VPN aktivieren oder deaktivieren können.
Entscheiden, wann eine Kachel erstellt werden soll
Wir empfehlen, Kacheln für bestimmte Funktionen zu erstellen, auf die Nutzer Ihrer Meinung nach oft zugreifen oder auf die sie schnellen Zugriff benötigen (oder beides). Die effektivsten Kacheln sind diejenigen, die beide dieser Eigenschaften erfüllen und schnellen Zugriff auf häufig ausgeführte Aktionen ermöglichen.
Sie könnten beispielsweise eine Kachel für eine Fitness-App erstellen, mit der Nutzer schnell eine Trainingseinheit starten können. Wir raten jedoch davon ab, eine Kachel für dieselbe App zu erstellen, mit der Nutzer ihren gesamten Trainingsverlauf einsehen können.
Um die Sichtbarkeit und Nutzerfreundlichkeit Ihrer Kachel zu verbessern, sollten Sie bestimmte Vorgehensweisen vermeiden:
Verwende keine Kacheln, um Apps zu starten. Verwende stattdessen eine App-Verknüpfung oder einen Standard-Launcher.
Vermeiden Sie die Verwendung von Kacheln für einmalige Nutzeraktionen. Verwenden Sie stattdessen eine App-Verknüpfung oder eine Benachrichtigung.
Vermeiden Sie es, zu viele Kacheln zu erstellen. Wir empfehlen maximal zwei pro App. Verwenden Sie stattdessen eine App-Verknüpfung.
Vermeiden Sie Kacheln, die Informationen anzeigen, aber für Nutzer nicht interaktiv sind. Verwende stattdessen eine Benachrichtigung oder ein Widget.
Kachel erstellen
Zum Erstellen einer Kachel musst du zuerst ein entsprechendes Kachelsymbol erstellen und dann die TileService in der Manifestdatei deiner App erstellen und deklarieren.
Das Beispiel für Schnelleinstellungen enthält ein Beispiel für das Erstellen und Verwalten einer Kachel.
Benutzerdefiniertes Symbol erstellen
Sie müssen ein benutzerdefiniertes Symbol angeben, das auf der Kachel im Bereich „Schnelleinstellungen“ angezeigt wird. Dieses Symbol fügen Sie hinzu, wenn Sie TileService deklarieren, wie im nächsten Abschnitt beschrieben. Das Symbol muss weiß mit transparentem Hintergrund sein, 24 × 24 dp groß sein und das Format VectorDrawable haben.
Erstellen Sie ein Symbol, das den Zweck Ihrer Kachel visuell darstellt. So können Nutzende leicht erkennen, ob Ihre Kachel ihren Anforderungen entspricht. Sie können beispielsweise ein Symbol einer Stoppuhr für eine Kachel für eine Fitness-App erstellen, mit der Nutzer eine Trainingseinheit starten können.
TileService erstellen und deklarieren
Erstellen Sie einen Dienst für Ihre Kachel, der die Klasse TileService erweitert.
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();
}
}
Du musst deine TileService in der Manifestdatei deiner App deklarieren. Fügen Sie den Namen und das Label Ihrer TileService, das im vorherigen Abschnitt erstellte benutzerdefinierte Symbol und die entsprechende Berechtigung hinzu.
<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>
TileService verwalten
Nachdem Sie TileService in Ihrem App-Manifest erstellt und deklariert haben, müssen Sie seinen Status verwalten.
TileService ist ein gebundener Dienst. Ihr TileService ist gebunden, wenn es von Ihrer Anwendung angefordert wird oder das System mit ihr kommunizieren muss. Ein typischer Lebenszyklus von gebundenen Diensten enthält die folgenden vier Callback-Methoden: onCreate(), onBind(), onUnbind() und onDestroy(). Diese Methoden werden vom System jedes Mal aufgerufen, wenn der Dienst in eine neue Lebenszyklusphase eintritt.
TileService-Lebenszyklus – Übersicht
Zusätzlich zu den Callbacks, die den Lebenszyklus des gebundenen Dienstes steuern, müssen Sie weitere Methoden implementieren, die für den Lebenszyklus TileService spezifisch sind. Diese Methoden können außerhalb von onCreate() und onDestroy() aufgerufen werden, da die Lebenszyklusmethoden Service und die Lebenszyklusmethoden TileService in zwei separaten asynchronen Threads aufgerufen werden.
Der Lebenszyklus TileService enthält die folgenden Methoden, die vom System immer dann aufgerufen werden, wenn Ihr TileService in eine neue Lebenszyklusphase eintritt:
onTileAdded(): Diese Methode wird nur aufgerufen, wenn der Nutzer Ihre Kachel zum ersten Mal hinzufügt und wenn der Nutzer die Kachel entfernt und noch einmal hinzufügt. Dies ist der beste Zeitpunkt für eine einmalige Initialisierung. Dies erfüllt jedoch möglicherweise nicht alle erforderlichen Initialisierungen.onStartListening()undonStopListening(): Diese Methoden werden immer dann aufgerufen, wenn Ihre App die Kachel aktualisiert. Sie werden häufig aufgerufen. DasTileServicebleibt zwischenonStartListening()undonStopListening()gebunden, sodass Ihre App die Kachel ändern und Updates senden kann.onTileRemoved(): Diese Methode wird nur aufgerufen, wenn der Nutzer die Kachel entfernt.
Wiedergabemodus auswählen
Dein TileService hört im Aktiv- oder Nicht-Aktiv-Modus zu. Wir empfehlen die Verwendung des Aktivmodus, den du im App-Manifest deklarieren musst. Andernfalls ist TileService der Standardmodus und muss nicht deklariert werden.
Gehen Sie nicht davon aus, dass sich TileService außerhalb des Methodenpaares onStartListening() und onStopListening() befindet.
Aktivmodus (empfohlen)
Verwenden Sie den Aktivmodus für einen TileService, der seinen Status in einem eigenen Prozess überwacht und überwacht. Ein TileService im Aktivmodus ist an onTileAdded(), onTileRemoved(), Tippereignisse und auf Anfrage vom App-Prozess gebunden.
Wir empfehlen den Aktivmodus, wenn TileService benachrichtigt wird, wenn der Kachelstatus durch einen eigenen Prozess aktualisiert werden soll. Aktive Kacheln schränken die Belastung des Systems ein, da sie nicht jedes Mal gebunden werden müssen, wenn die Schnelleinstellungen für den Nutzer sichtbar werden.
Die statische Methode TileService.requestListeningState() kann aufgerufen werden, um den Start des Überwachungsstatus anzufordern und einen Callback von onStartListening() zu erhalten.
Sie können den Aktivmodus deklarieren, indem Sie META_DATA_ACTIVE_TILE in die Manifestdatei Ihrer App aufnehmen.
<service ...>
<meta-data android:name="android.service.quicksettings.ACTIVE_TILE"
android:value="true" />
...
</service>
Inaktivmodus
Der nicht-aktive Modus ist der Standardmodus. Eine TileService befindet sich im inaktiven Modus, wenn sie immer dann gebunden wird, wenn die Kachel für den Nutzer sichtbar ist. Das bedeutet, dass TileService gelegentlich außerhalb seiner Kontrolle erstellt und gebunden werden kann. Sie kann auch ungebunden und gelöscht werden, wenn der Nutzer die Kachel nicht sieht.
Deine App erhält einen Callback von onStartListening(), nachdem der Nutzer die Schnelleinstellungen geöffnet hat. Sie können das Tile-Objekt zwischen onStartListening() und onStopListening() beliebig oft aktualisieren.
Du musst den nicht-aktiven Modus nicht deklarieren. Füge der Manifestdatei deiner App einfach META_DATA_ACTIVE_TILE hinzu.
Kachelstatus – Übersicht
Nachdem ein Nutzer Ihre Kachel hinzugefügt hat, befindet sie sich immer in einem der folgenden Status.
STATE_ACTIVE: Gibt an, ob das Gerät aktiviert oder aktiviert ist. Der Nutzer kann in diesem Status mit Ihrer Kachel interagieren.Bei einer Fitness-App-Kachel, mit der Nutzer beispielsweise eine Trainingseinheit mit zeitlicher Festlegung starten können, bedeutet
STATE_ACTIVE, dass der Nutzer eine Trainingssitzung gestartet hat und der Timer läuft.STATE_INACTIVE: Gibt an, dass der Status deaktiviert oder pausiert ist. Der Nutzer kann in diesem Status mit Ihrer Kachel interagieren.Um das Beispiel für die Kachel einer Fitness-App noch einmal zu verwenden, würde eine Kachel in
STATE_INACTIVEbedeuten, dass der Nutzer keine Trainingseinheit gestartet hat, die dies jedoch tun könnte, wenn er möchte.STATE_UNAVAILABLE: Weist auf einen vorübergehend nicht verfügbaren Status hin. In diesem Status kann der Nutzer nicht mit Ihrer Kachel interagieren.Eine Kachel in
STATE_UNAVAILABLEbedeutet beispielsweise, dass sie dem Nutzer derzeit aus irgendeinem Grund nicht zur Verfügung steht.
Das System legt nur den Anfangszustand des Tile-Objekts fest. Den Status des Tile-Objekts legen Sie für den Rest des Lebenszyklus fest.
Das System kann das Kachelsymbol und den Hintergrund färben, um den Status des Tile-Objekts widerzuspiegeln. Tile-Objekte, die auf STATE_ACTIVE gesetzt sind, sind am dunkelsten, wobei STATE_INACTIVE und STATE_UNAVAILABLE immer heller werden. Der genaue Farbton gilt
je nach Hersteller und Version.
Kachel aktualisieren
Du kannst deine Kachel aktualisieren, sobald du einen Callback von onStartListening() erhältst.
Je nach Modus der Kachel kann sie mindestens einmal aktualisiert werden, bis sie einen Callback von onStopListening() empfängt.
Im Aktivmodus können Sie Ihre Kachel genau einmal aktualisieren, bevor Sie einen Callback von onStopListening() erhalten. Im inaktiven Modus können Sie die Kachel zwischen onStartListening() und onStopListening() beliebig oft aktualisieren.
Sie können das Tile-Objekt abrufen, indem Sie getQsTile() aufrufen. Rufen Sie die folgenden Methoden auf, um bestimmte Felder des Tile-Objekts zu aktualisieren:
Sie müssen updateTile() aufrufen, um Ihre Kachel zu aktualisieren, sobald Sie die Felder des Tile-Objekts auf die richtigen Werte festgelegt haben. Dadurch parst das System die aktualisierten Kacheldaten und aktualisiert die 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();
}
Tippgesten
Nutzer können auf Ihre Kachel tippen, um eine Aktion auszulösen, wenn sich Ihre Kachel in STATE_ACTIVE oder STATE_INACTIVE befindet. Das System ruft dann den onClick()-Callback der App auf.
Sobald Ihre App einen Callback von onClick() empfängt, kann sie ein Dialogfeld oder eine Aktivität starten, Hintergrundarbeiten auslösen oder den Status der Kachel ändern.
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();
}
Dialogfeld öffnen
showDialog() minimiert die Schnelleinstellungen und zeigt ein Dialogfeld an.
Verwenden Sie ein Dialogfeld, um Ihrer Aktion Kontext hinzuzufügen, wenn zusätzliche Eingaben oder Nutzereinwilligungen erforderlich sind.
Aktivität starten
startActivityAndCollapse() startet eine Aktivität, während das Feld minimiert wird. Aktivitäten sind nützlich, wenn detailliertere Informationen als in einem Dialogfeld angezeigt werden sollen oder wenn Ihre Aktion sehr interaktiv ist.
Wenn Ihre App eine umfassende Nutzerinteraktion erfordert, sollte sie nur als letzte Option eine Aktivität starten. Verwenden Sie stattdessen ein Dialogfeld oder eine Ein/Aus-Schaltfläche.
Durch langes Tippen auf eine Kachel wird der Bildschirm App Info (App-Info) für den Nutzer angezeigt. Wenn Sie dieses Verhalten überschreiben und stattdessen eine Aktivität zum Festlegen von Einstellungen starten möchten, fügen Sie einer Ihrer Aktivitäten mit ACTION_QS_TILE_PREFERENCES ein <intent-filter> hinzu.
Kachel als ein-/ausschalten markieren
Wir empfehlen, Ihre Kachel als ein-/ausschaltbar zu kennzeichnen, wenn sie primär als Zwei-Zustandsschalter funktioniert (was das gängigste Verhalten von Kacheln ist). Dies hilft, dem Betriebssystem Informationen über das Verhalten der Kachel bereitzustellen und die allgemeine Zugänglichkeit zu verbessern.
Setze die TOGGLEABLE_TILE-Metadaten auf true, um deine Kachel als Umschaltbar zu markieren.
<service ...>
<meta-data android:name="android.service.quicksettings.TOGGLEABLE_TILE"
android:value="true" />
</service>
Nur sichere Aktionen auf Geräten ausführen, die sicher gesperrt sind
Auf gesperrten Geräten wird deine Kachel möglicherweise über dem Sperrbildschirm angezeigt. Wenn die Kachel vertrauliche Informationen enthält, prüfen Sie den Wert von isSecure(), um festzustellen, ob sich das Gerät in einem sicheren Zustand befindet. TileService sollte sein Verhalten entsprechend ändern.
Wenn die Aktion für das Kacheln sicher ausgeführt werden kann, während sie gesperrt ist, verwenden Sie startActivity(), um eine Aktivität über dem Sperrbildschirm zu starten.
Wenn die Kachelaktion unsicher ist, verwenden Sie unlockAndRun(), um den Nutzer aufzufordern, sein Gerät zu entsperren. Bei Erfolg führt das System das Runnable-Objekt aus, das Sie an diese Methode übergeben.
Nutzer auffordern, Ihre Kachel hinzuzufügen
Um Ihre Kachel manuell hinzuzufügen, müssen Nutzer mehrere Schritte ausführen:
- Wischen Sie nach unten, um die Schnelleinstellungen zu öffnen.
- Tippe auf die Schaltfläche „Bearbeiten“.
- Scrollen Sie durch alle Kacheln auf dem Gerät, bis die Person Ihre Kachel gefunden hat.
- Halte die Kachel gedrückt und ziehe sie in die Liste der aktiven Kacheln.
Der Nutzer kann die Kachel auch jederzeit verschieben oder entfernen.
Ab Android 13 können Sie die Methode requestAddTileService() verwenden, um Nutzern das Hinzufügen Ihrer Kachel zu einem Gerät erheblich zu erleichtern. Bei dieser Methode werden Nutzer aufgefordert, Ihre Kachel schnell direkt ihrem Schnelleinstellungen-Bereich hinzuzufügen. Die Eingabeaufforderung enthält den Namen der Anwendung, das angegebene Label und das Symbol.
public void requestAddTileService (
ComponentName tileServiceComponentName,
CharSequence tileLabel,
Icon icon,
Executor resultExecutor,
Consumer<Integer> resultCallback
)
Der Callback enthält Informationen darüber, ob die Kachel hinzugefügt oder nicht hinzugefügt wurde, ob sie bereits vorhanden war oder ob ein Fehler aufgetreten ist.
Überlegen Sie selbst, wann und wie oft Sie Nutzer auffordern sollten. Wir empfehlen, requestAddTileService() nur im Kontext aufzurufen, z. B. wenn der Nutzer zum ersten Mal mit einer Funktion interagiert, die Ihre Kachel unterstützt.
Das System kann die Verarbeitung von Anfragen für einen bestimmten ComponentName beenden, wenn er zuvor vom Nutzer bereits ausreichend abgelehnt wurde. Der Nutzer wird aus dem Context ermittelt, mit dem dieser Dienst abgerufen wurde. Er muss dem aktuellen Nutzer entsprechen.