Diese Seite wurde von der Cloud Translation API übersetzt.

Externe Geräte steuern

In Android 11 und höher können Nutzer mit der Funktion „Gerätesteuerung für den Schnellzugriff“ externe Geräte wie Lampen, Thermostate und Kameras schnell über eine Nutzeraktion in drei Schritten über einen Standard-Launcher aufrufen und steuern. Der Geräte-OEM wählt aus, welcher Launcher verwendet wird. Geräteaggregatoren wie Google Home und Drittanbieter-Apps können Geräte für die Anzeige in diesem Bereich bereitstellen. Auf dieser Seite wird beschrieben, wie Sie Gerätesteuerungen in diesem Bereich anzeigen und mit Ihrer Steuerungs-App verknüpfen.

Abbildung 1. Bereich für die Gerätesteuerung in der Android-Benutzeroberfläche.

Um diese Unterstützung hinzuzufügen, erstellen und deklarieren Sie eine ControlsProviderService. Erstelle die von deiner App unterstützten Steuerelemente basierend auf vordefinierten Steuerelementtypen und erstelle dann Publisher für diese Steuerelemente.

Benutzeroberfläche

Geräte werden unter Gerätesteuerung als Vorlagen-Widgets angezeigt. Es sind fünf Gerätesteuerungs-Widgets verfügbar, wie in der folgenden Abbildung dargestellt:

Umschalten	Über Schieberegler ein- und ausschalten	Bereich (kann nicht aktiviert oder deaktiviert werden)
Zustandsloser Schalter	Temperaturfeld (geschlossen)

Abbildung 2 Sammlung von Vorlagen-Widgets.

Wenn Sie ein Widget gedrückt halten, werden Sie zur App weitergeleitet, um weitere Einstellungen vorzunehmen. Sie können das Symbol und die Farbe für jedes Widget anpassen. Für eine optimale Nutzerfreundlichkeit sollten Sie jedoch das Standardsymbol und die Standardfarbe verwenden, wenn das Standardset zum Gerät passt.

Bild des geöffneten Widgets für den Temperaturbereich — **Abbildung 3**: Öffne das Temperatur-Widget.

Dienst erstellen

In diesem Abschnitt wird beschrieben, wie Sie die ControlsProviderService erstellen. Dieser Dienst teilt der Android-System-UI mit, dass Ihre App Geräte-Steuerelemente enthält, die im Bereich Geräte-Steuerelemente der Android-UI angezeigt werden müssen.

Für die ControlsProviderService-API sind Kenntnisse über reaktive Streams erforderlich, wie sie im GitHub-Projekt „Reactive Streams“ definiert und in den Java 9-Flow-Schnittstellen implementiert sind. Die API basiert auf den folgenden Konzepten:

Publisher:Ihre Anwendung ist der Publisher.
Abonnent:Die System-UI ist der Abonnent und kann eine Reihe von Steuerelementen vom Verlag oder Webpublisher anfordern.
Abo:Der Zeitraum, in dem der Publisher Updates an die System-UI senden kann. Entweder der Publisher oder der Abonnent kann dieses Fenster schließen.

Dienst deklarieren

In Ihrem App-Manifest muss ein Dienst deklariert werden, z. B. MyCustomControlService.

Der Dienst muss einen Intent-Filter für ControlsProviderService enthalten. Mit diesem Filter können Anwendungen Steuerelemente zur System-UI beitragen.

Außerdem benötigen Sie ein label, das in den Steuerelementen in der System-UI angezeigt wird.

Das folgende Beispiel zeigt, wie ein Dienst deklariert wird:

<service
    android:name="MyCustomControlService"
    android:label="My Custom Controls"
    android:permission="android.permission.BIND_CONTROLS"
    android:exported="true"
    >
    <intent-filter>
      <action android:name="android.service.controls.ControlsProviderService" />
    </intent-filter>
</service>

Erstellen Sie als Nächstes eine neue Kotlin-Datei mit dem Namen MyCustomControlService.kt und lassen Sie sie von ControlsProviderService() erben:

Kotlin

    class MyCustomControlService : ControlsProviderService() {
        ...
    }

Java

    public class MyCustomJavaControlService extends ControlsProviderService {
        ...
    }

Den richtigen Steuerungstyp auswählen

Die API bietet Builder-Methoden zum Erstellen der Steuerelemente. Um den Builder zu füllen, müssen Sie das Gerät bestimmen, das Sie steuern möchten, und festlegen, wie der Nutzer damit interagiert. Führen Sie die folgenden Schritte aus:

Wählen Sie den Gerätetyp aus, den das Steuerelement darstellt. Die Klasse DeviceTypes ist eine Aufzählung aller unterstützten Geräte. Der Typ wird verwendet, um die Symbole und Farben für das Gerät in der Benutzeroberfläche zu bestimmen.
Bestimmen Sie den für Nutzer sichtbaren Namen, den Gerätestandort (z. B. Küche) und andere UI-Textelemente, die mit dem Steuerelement verknüpft sind.
Wählen Sie die beste Vorlage für die Nutzerinteraktion aus. Steuerelementen wird über die Anwendung eine ControlTemplate zugewiesen. In dieser Vorlage wird dem Nutzer direkt der Steuerungsstatus sowie die verfügbaren Eingabemethoden angezeigt, also die ControlAction. In der folgenden Tabelle sind einige der verfügbaren Vorlagen und die von ihnen unterstützten Aktionen aufgeführt:

Vorlage	Aktion	Beschreibung
`ControlTemplate.getNoTemplateObject()`	`None`	Die Anwendung kann damit Informationen zum Steuerelement vermitteln, der Nutzer kann jedoch nicht damit interagieren.
`ToggleTemplate`	`BooleanAction`	Stellt ein Steuerelement dar, das zwischen den Status „Aktiviert“ und „Deaktiviert“ umgeschaltet werden kann. Das `BooleanAction`-Objekt enthält ein Feld, das sich ändert, um den angeforderten neuen Status darzustellen, wenn der Nutzer auf das Steuerelement tippt.
`RangeTemplate`	`FloatAction`	Stellt ein Schieberegler-Widget mit angegebenen Mindest-, Höchst- und Schrittwerten dar. Wenn der Nutzer mit dem Schieberegler interagiert, senden Sie ein neues `FloatAction`-Objekt mit dem aktualisierten Wert zurück an die Anwendung.
`ToggleRangeTemplate`	`BooleanAction, FloatAction`	Diese Vorlage ist eine Kombination aus `ToggleTemplate` und `RangeTemplate`. Es unterstützt Touch-Ereignisse sowie einen Schieberegler, z. B. zum Steuern dimmbarer Lampen.
`TemperatureControlTemplate`	`ModeAction, BooleanAction, FloatAction`	Mit dieser Vorlage werden nicht nur die vorherigen Aktionen gekapselt, sondern der Nutzer kann auch einen Modus festlegen, z. B. „Heizen“, „Kühlen“, „Heizen/Kühlen“, „Eco“ oder „Aus“.
`StatelessTemplate`	`CommandAction`	Wird verwendet, um ein Steuerelement anzugeben, das Touch-Funktionen bietet, dessen Status jedoch nicht bestimmt werden kann, z. B. eine IR-TV-Fernbedienung. Mit dieser Vorlage können Sie eine Routine oder ein Makro definieren, das eine Aggregation von Steuerungs- und Statusänderungen ist.

Anhand dieser Informationen können Sie die Steuerung erstellen:

Verwenden Sie die Builder-Klasse Control.StatelessBuilder, wenn der Status des Steuerelements unbekannt ist.
Verwenden Sie die Builder-Klasse Control.StatefulBuilder, wenn der Status des Steuerelements bekannt ist.

Wenn Sie beispielsweise eine intelligente Glühbirne und einen Thermostat steuern möchten, fügen Sie Ihrer MyCustomControlService die folgenden Konstanten hinzu:

Kotlin

    private const val LIGHT_ID = 1234
    private const val LIGHT_TITLE = "My fancy light"
    private const val LIGHT_TYPE = DeviceTypes.TYPE_LIGHT
    private const val THERMOSTAT_ID = 5678
    private const val THERMOSTAT_TITLE = "My fancy thermostat"
    private const val THERMOSTAT_TYPE = DeviceTypes.TYPE_THERMOSTAT
 
    class MyCustomControlService : ControlsProviderService() {
      ...
    }

Java

    public class MyCustomJavaControlService extends ControlsProviderService {
 
    private final int LIGHT_ID = 1337;
    private final String LIGHT_TITLE = "My fancy light";
    private final int LIGHT_TYPE = DeviceTypes.TYPE_LIGHT;
    private final int THERMOSTAT_ID = 1338;
    private final String THERMOSTAT_TITLE = "My fancy thermostat";
    private final int THERMOSTAT_TYPE = DeviceTypes.TYPE_THERMOSTAT;
 
    ...
    }

Publisher für die Steuerelemente erstellen

Nachdem Sie die Kontrollgruppe erstellt haben, benötigen Sie einen Publisher. Der Verlag oder Webpublisher informiert die System-UI über das Vorhandensein des Steuerelements. Die Klasse ControlsProviderService hat zwei Publisher-Methoden, die Sie in Ihrem Anwendungscode überschreiben müssen:

createPublisherForAllAvailable(): Erstellt ein Publisher für alle in Ihrer App verfügbaren Steuerelemente. Verwenden Sie Control.StatelessBuilder(), um Control-Objekte für diesen Publisher zu erstellen.
createPublisherFor(): Erstellt ein Publisher für eine Liste der angegebenen Steuerelemente, die durch ihre String-Kennungen identifiziert werden. Verwenden Sie Control.StatefulBuilder, um diese Control-Objekte zu erstellen, da der Publisher jedem Steuerelement einen Status zuweisen muss.

Publisher erstellen

Wenn Ihre App zum ersten Mal Steuerelemente in der System-UI veröffentlicht, kennt sie den Status der einzelnen Steuerelemente nicht. Das Abrufen des Status kann ein zeitaufwendiger Vorgang sein, der viele Hops im Netzwerk des Geräteanbieters umfasst. Verwenden Sie die Methode createPublisherForAllAvailable(), um dem System die verfügbaren Steuerelemente mitzuteilen. Bei dieser Methode wird die Builder-Klasse Control.StatelessBuilder verwendet, da der Status der einzelnen Steuerelemente unbekannt ist.

Sobald die Steuerelemente in der Android-Benutzeroberfläche angezeigt werden , kann der Nutzer Favoriten auswählen.

Wenn Sie Kotlin-Coroutinen verwenden möchten, um ein ControlsProviderService zu erstellen, fügen Sie Ihrem build.gradle eine neue Abhängigkeit hinzu:

Groovy

dependencies {
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-jdk9:1.6.4"
}

Kotlin

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-jdk9:1.6.4")
}

Nachdem Sie Ihre Gradle-Dateien synchronisiert haben, fügen Sie der Datei Service das folgende Snippet hinzu, um createPublisherForAllAvailable() zu implementieren:

Kotlin

    class MyCustomControlService : ControlsProviderService() {
 
      override fun createPublisherForAllAvailable(): Flow.Publisher =
          flowPublish {
              send(createStatelessControl(LIGHT_ID, LIGHT_TITLE, LIGHT_TYPE))
              send(createStatelessControl(THERMOSTAT_ID, THERMOSTAT_TITLE, THERMOSTAT_TYPE))
          }
 
      private fun createStatelessControl(id: Int, title: String, type: Int): Control {
          val intent = Intent(this, MainActivity::class.java)
              .putExtra(EXTRA_MESSAGE, title)
              .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
          val action = PendingIntent.getActivity(
              this,
              id,
              intent,
              PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
          )
 
          return Control.StatelessBuilder(id.toString(), action)
              .setTitle(title)
              .setDeviceType(type)
              .build()
      }
 
          override fun createPublisherFor(controlIds: List): Flow.Publisher {
           TODO()
        }
 
        override fun performControlAction(
            controlId: String,
            action: ControlAction,
            consumer: Consumer
        ) {
            TODO()
        }
    }

Java

    public class MyCustomJavaControlService extends ControlsProviderService {
 
        private final int LIGHT_ID = 1337;
        private final String LIGHT_TITLE = "My fancy light";
        private final int LIGHT_TYPE = DeviceTypes.TYPE_LIGHT;
        private final int THERMOSTAT_ID = 1338;
        private final String THERMOSTAT_TITLE = "My fancy thermostat";
        private final int THERMOSTAT_TYPE = DeviceTypes.TYPE_THERMOSTAT;
 
        private boolean toggleState = false;
        private float rangeState = 18f;
        private final Map<String, ReplayProcessor> controlFlows = new HashMap<>();
 
        @NonNull
        @Override
        public Flow.Publisher createPublisherForAllAvailable() {
            List controls = new ArrayList<>();
            controls.add(createStatelessControl(LIGHT_ID, LIGHT_TITLE, LIGHT_TYPE));
            controls.add(createStatelessControl(THERMOSTAT_ID, THERMOSTAT_TITLE, THERMOSTAT_TYPE));
            return FlowAdapters.toFlowPublisher(Flowable.fromIterable(controls));
        }
 
        @NonNull
        @Override
        public Flow.Publisher createPublisherFor(@NonNull List controlIds) {
            ReplayProcessor updatePublisher = ReplayProcessor.create();
 
            controlIds.forEach(control -> {
                controlFlows.put(control, updatePublisher);
                updatePublisher.onNext(createLight());
                updatePublisher.onNext(createThermostat());
            });
 
            return FlowAdapters.toFlowPublisher(updatePublisher);
        }
    }

Wische im Systemmenü nach unten und suche nach der Schaltfläche Gerätesteuerung (siehe Abbildung 4):

Ein Bild, das die System-UI für die Gerätesteuerung zeigt — **Abbildung 4**: Gerätesteuerung im Systemmenü

Wenn Sie auf Gerätesteuerung tippen, gelangen Sie zu einem zweiten Bildschirm, auf dem Sie Ihre App auswählen können. Nachdem Sie Ihre App ausgewählt haben, sehen Sie, wie durch den vorherigen Snippet ein benutzerdefiniertes Systemmenü mit Ihren neuen Steuerelementen erstellt wird (siehe Abbildung 5):

Ein Bild, das das Systemmenü mit einer Licht- und Thermostatsteuerung zeigt — **Abbildung 5:** Steuerelemente für Beleuchtung und Thermostat, die hinzugefügt werden sollen.

Implementieren Sie nun die Methode createPublisherFor() und fügen Sie Folgendes in Ihre Service ein:

Kotlin

    private val job = SupervisorJob()
    private val scope = CoroutineScope(Dispatchers.IO + job)
    private val controlFlows = mutableMapOf<String, MutableSharedFlow>()
 
    private var toggleState = false
    private var rangeState = 18f
 
    override fun createPublisherFor(controlIds: List): Flow.Publisher {
        val flow = MutableSharedFlow(replay = 2, extraBufferCapacity = 2)
 
        controlIds.forEach { controlFlows[it] = flow }
 
        scope.launch {
            delay(1000) // Retrieving the toggle state.
            flow.tryEmit(createLight())
 
            delay(1000) // Retrieving the range state.
            flow.tryEmit(createThermostat())
 
        }
        return flow.asPublisher()
    }
 
    private fun createLight() = createStatefulControl(
        LIGHT_ID,
        LIGHT_TITLE,
        LIGHT_TYPE,
        toggleState,
        ToggleTemplate(
            LIGHT_ID.toString(),
            ControlButton(
                toggleState,
                toggleState.toString().uppercase(Locale.getDefault())
            )
        )
    )
 
    private fun createThermostat() = createStatefulControl(
        THERMOSTAT_ID,
        THERMOSTAT_TITLE,
        THERMOSTAT_TYPE,
        rangeState,
        RangeTemplate(
            THERMOSTAT_ID.toString(),
            15f,
            25f,
            rangeState,
            0.1f,
            "%1.1f"
        )
    )
 
    private fun  createStatefulControl(id: Int, title: String, type: Int, state: T, template: ControlTemplate): Control {
        val intent = Intent(this, MainActivity::class.java)
            .putExtra(EXTRA_MESSAGE, "$title $state")
            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
        val action = PendingIntent.getActivity(
            this,
            id,
            intent,
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
        )
 
        return Control.StatefulBuilder(id.toString(), action)
            .setTitle(title)
            .setDeviceType(type)
            .setStatus(Control.STATUS_OK)
            .setControlTemplate(template)
            .build()
    }
 
    override fun onDestroy() {
        super.onDestroy()
        job.cancel()
    }

Java

    @NonNull
    @Override
    public Flow.Publisher createPublisherFor(@NonNull List controlIds) {
        ReplayProcessor updatePublisher = ReplayProcessor.create();
 
        controlIds.forEach(control -> {
            controlFlows.put(control, updatePublisher);
            updatePublisher.onNext(createLight());
            updatePublisher.onNext(createThermostat());
        });
 
        return FlowAdapters.toFlowPublisher(updatePublisher);
    }
 
    private Control createStatelessControl(int id, String title, int type) {
        Intent intent = new Intent(this, MainActivity.class)
                .putExtra(EXTRA_MESSAGE, title)
                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        PendingIntent action = PendingIntent.getActivity(
                this,
                id,
                intent,
                PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
        );
 
        return new Control.StatelessBuilder(id + "", action)
                .setTitle(title)
                .setDeviceType(type)
                .build();
    }
 
    private Control createLight() {
        return createStatefulControl(
                LIGHT_ID,
                LIGHT_TITLE,
                LIGHT_TYPE,
                toggleState,
                new ToggleTemplate(
                        LIGHT_ID + "",
                        new ControlButton(
                                toggleState,
                                String.valueOf(toggleState).toUpperCase(Locale.getDefault())
                        )
                )
        );
    }
 
    private Control createThermostat() {
        return createStatefulControl(
                THERMOSTAT_ID,
                THERMOSTAT_TITLE,
                THERMOSTAT_TYPE,
                rangeState,
                new RangeTemplate(
                        THERMOSTAT_ID + "",
                        15f,
                        25f,
                        rangeState,
                        0.1f,
                        "%1.1f"
                )
        );
    }
 
    private  Control createStatefulControl(int id, String title, int type, T state, ControlTemplate template) {
        Intent intent = new Intent(this, MainActivity.class)
                .putExtra(EXTRA_MESSAGE, "$title $state")
                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        PendingIntent action = PendingIntent.getActivity(
                this,
                id,
                intent,
                PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
        );
 
        return new Control.StatefulBuilder(id + "", action)
                .setTitle(title)
                .setDeviceType(type)
                .setStatus(Control.STATUS_OK)
                .setControlTemplate(template)
                .build();
    }

In diesem Beispiel enthält die Methode createPublisherFor() eine gefälschte Implementierung der Aufgaben, die Ihre App ausführen muss: mit Ihrem Gerät kommunizieren, um seinen Status abzurufen, und diesen Status an das System senden.

Die createPublisherFor()-Methode verwendet Kotlin-Coroutinen und -Flows, um die erforderliche Reactive Streams API zu erfüllen. Dazu wird Folgendes ausgeführt:

Erstellt einen Flow.
Wartet eine Sekunde.
Erstellt und gibt den Status der Smart-Glühbirne aus.
Wartet eine weitere Sekunde.
Erstellt und gibt den Status des Thermostats aus.

Aktionen verarbeiten

Die Methode performControlAction() signalisiert, wenn der Nutzer mit einem veröffentlichten Steuerelement interagiert. Die Art der gesendeten ControlAction bestimmt die Aktion. Führe die entsprechende Aktion für das angegebene Steuerelement aus und aktualisiere dann den Status des Geräts in der Android-Benutzeroberfläche.

Fügen Sie Folgendes zu Ihrem Service hinzu, um das Beispiel zu vervollständigen:

Kotlin

    override fun performControlAction(
        controlId: String,
        action: ControlAction,
        consumer: Consumer
    ) {
        controlFlows[controlId]?.let { flow ->
            when (controlId) {
                LIGHT_ID.toString() -> {
                    consumer.accept(ControlAction.RESPONSE_OK)
                    if (action is BooleanAction) toggleState = action.newState
                    flow.tryEmit(createLight())
                }
                THERMOSTAT_ID.toString() -> {
                    consumer.accept(ControlAction.RESPONSE_OK)
                    if (action is FloatAction) rangeState = action.newValue
                    flow.tryEmit(createThermostat())
                }
                else -> consumer.accept(ControlAction.RESPONSE_FAIL)
            }
        } ?: consumer.accept(ControlAction.RESPONSE_FAIL)
    }

Java

    @Override
    public void performControlAction(@NonNull String controlId, @NonNull ControlAction action, @NonNull Consumer consumer) {
        ReplayProcessor processor = controlFlows.get(controlId);
        if (processor == null) return;
 
        if (controlId.equals(LIGHT_ID + "")) {
            consumer.accept(ControlAction.RESPONSE_OK);
            if (action instanceof BooleanAction) toggleState = ((BooleanAction) action).getNewState();
            processor.onNext(createLight());
        }
        if (controlId.equals(THERMOSTAT_ID + "")) {
            consumer.accept(ControlAction.RESPONSE_OK);
            if (action instanceof FloatAction) rangeState = ((FloatAction) action).getNewValue()
            processor.onNext(createThermostat());
        }
    }

Öffnen Sie die App, rufen Sie das Menü Gerätesteuerung auf und sehen Sie sich die Steuerelemente für Ihre Lampe und Ihr Thermostat an.

Bild mit einer Licht- und Thermostatsteuerung — **Abbildung 6:** Steuerung von Beleuchtung und Thermostat

Externe Geräte steuern Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Benutzeroberfläche

Dienst erstellen

Dienst deklarieren

Kotlin

Java

Den richtigen Steuerungstyp auswählen

Kotlin

Java

Publisher für die Steuerelemente erstellen

Publisher erstellen

Groovy

Kotlin

Kotlin

Java

Kotlin

Java

Aktionen verarbeiten

Kotlin

Java

Externe Geräte steuern