Eine Android-App für wirklich relevante Apps

1. Willkommen

Matter wurde zur Vereinheitlichung von IoT-Standards entwickelt und verbindet Smart-Home-Geräte aus verschiedenen Plattformen wie Google Home, Zigbee, Bluetooth Mesh oder Z-Wave.

Mobilgeräte sind ein zentraler Interaktionspunkt mit Smart-Home-Geräten. Wenn du eigene Android-Apps zur Unterstützung von Matter-Geräten erstellen möchtest, können wir dir helfen, schnell loszulegen.

In der Google Home Sample App for Matter (GHSA für Matter) werden die Home Mobile SDK APIs präsentiert, mit denen Nutzer Geräte in Betrieb nehmen und teilen können. Du kannst die Beispiel-App auch als Lerntool verwenden, um die wichtigsten Matter-Konzepte besser zu verstehen, sowie als Tool zur Fehlerbehebung bei Interaktionen mit Matter-Geräten.

Aufgaben

In diesem Codelab laden Sie den Quellcode für die Beispiel-App herunter und erfahren, wie Sie mit dem Home Mobile SDK Geräte in Betrieb nehmen und gemeinsam nutzen. Außerdem erfahren Sie, wie Sie Inbetriebnahme- und Clusterbibliotheken aus dem Matter-Repository (connectedhomeip) verwenden.

Nachdem Sie die Beispiel-App heruntergeladen haben, überprüfen wir den Quellcode in Android Studio und implementieren die folgenden Home Mobile SDK APIs:

Außerdem erfährst du mehr über Inbetriebnahmekonzepte, Matter-Strukturen und die Steuerung von Matter-Geräten.

Voraussetzungen

Führen Sie zuerst die folgenden Schritte aus:

Sie benötigen keinen Hub, z. B. Google Nest Hub (2. Generation), um Geräte mit der Beispiel-App in Betrieb zu nehmen und zu steuern.

2. Einrichten

Die Codelab-Starter-App befindet sich im Zweig codelab. Wenn Sie mit dem Codelab-Quellcode arbeiten möchten, können Sie die ZIP-Datei herunterladen.

Sie verwenden diese codelab-ZIP-Datei, um ein funktionierendes Beispiel zu erstellen.

Codelab-Versionen

Der codelab-Branch ist mit dem Release 2.0.0 der Beispiel-App getaggt. Um Ihre Aktualisierungen während der einzelnen Schritte zu vergleichen, können Sie den fertigen Quellcode für diese Version herunterladen.

Wenn Sie das GitHub-Repository klonen möchten, folgen Sie der Anleitung in der README-Datei der Beispiel-App.

Abhängigkeiten

Wir führen Sie durch den Quellcode, der für die Freigabe und Inbetriebnahme von Geräten erforderlich ist. Es kann jedoch hilfreich sein, die folgenden Abhängigkeiten zu kennen, bevor Sie beginnen. Beachten Sie, dass diese Abhängigkeiten in der Datei libs.versions.toml und ihre Verwendung in der Datei build.gradle.kts angegeben sind.

Quellcode

Die Benutzeroberfläche und die meisten Funktionen wurden bereits für Sie erstellt.

In diesem Codelab fügen wir den folgenden Dateien die Matter-Funktion hinzu:

  • java/com/google/homesampleapp/commissioning/AppCommissioningService: ermöglicht die Inbetriebnahme von Geräten für die Entwicklungsstruktur
  • java/com/google/homesampleapp/screens/home/HomeScreen und java/com/google/homesampleapp/screens/home/HomeViewModel.kt: enthalten die Inbetriebnahmefunktion für das Home Mobile SDK
  • java/com/google/homesampleapp/screens/device/DeviceScreen und java/com/google/homesampleapp/screens/device/DeviceViewModel: enthält die API-Aufrufe zum Teilen von Geräten

Jede Datei enthält einen Kommentar mit dem Codeblock, den Sie ändern werden. Zum Beispiel:

// CODELAB: add commissioningFunction()

So finden Sie im Codelab schnell den entsprechenden Abschnitt.

3. Provision gegenüber Google

Bevor Sie Geräte steuern und ihnen ermöglichen können, mit demselben System zu kommunizieren, müssen sie von einem zuständigen Beauftragten in Auftrag gegeben werden. In diesem Fall handelt es sich um diese Beispiel-App, die Google Home Sample App für Matter.

Es ist wichtig, die folgenden Konzepte zur Inbetriebnahme von Matter zu verstehen:

  • Fabrics ermöglichen es Geräten, miteinander zu kommunizieren.
  • Fabrics verwenden einen gemeinsamen Satz eindeutiger Anmeldedaten.
  • Ökosysteme sind dafür verantwortlich, vertrauenswürdige Root-Zertifikate auszustellen, Fabric-IDs und eindeutige Knoten-IDs zuzuweisen. Ein System ist der Backend-Dienst eines Auftraggebers, z. B. der Home Graph für die Google Home-Plattform.
  • Geräte können für mehr als ein Netzwerk in Betrieb genommen werden (Funktion für mehrere Administratoren).

Um ein Gerät in Betrieb zu nehmen, müssen Sie die CommissioningClient API verwenden. Bei einem Aufruf von .commissionDevice() wird ein IntentSender-Element zurückgegeben, das die entsprechende Aktivität in den Google Play-Diensten startet:

interface CommissioningClient {
  Task<IntentSender> commissionDevice(CommissioningRequest request);
}

In den nächsten Abschnitten sehen wir uns den Mindestcode an, der erforderlich ist, um Geräte auf dem Google-Fabric in Betrieb zu nehmen.

Schritt 1: Aktivitätsübersicht

Zur Verarbeitung des IntentSender aus dem CommissioningClient können Sie einen ActivityResultLauncher verwenden:

val commissioningLauncher = registerForActivityResult(
    StartIntentSenderForResult()
) { result: ActivityResult ->
    if (result.resultCode == RESULT_OK) {
        Timber.d(TAG, "Commissioning succeeded.")
    } else {
        Timber.d(TAG, "Commissioning failed. " + result.resultCode)
    }
}

Schritt 2: Inbetriebnahmefunktion

Hier ist ein einfaches Beispiel, bei dem die CommissioningClient API verwendet wird, um ein Gerät auf dem Google-Fabric in Betrieb zu nehmen.

  1. Die Inbetriebnahme beginnt mit der Funktion commissionDevice(). Zuerst wird ein CommissioningRequest definiert. Bei dieser Standardkonfiguration werden Geräte nur für die lokale Android-Struktur in Betrieb genommen.
  2. Matter ist der Einstiegspunkt für das Home Mobile SDK. Im nächsten Aufruf ruft .getCommissioningClient einen CommissioningClient nach this (Aktivität) ab.
  3. .commissionDevice() akzeptiert CommissioningRequest.
  4. Und schließlich wird .addOnSuccessListener aufgerufen, um CommissioningResult zu verarbeiten und die Aktivität „Google Play Services (GPS)“ zum Provisionsgerät zu starten.
private fun commissionDevice() {
    val request: CommissioningRequest = CommissioningRequest.builder().build()
    Matter.getCommissioningClient(this)
        .commissionDevice(request)
        .addOnSuccessListener { result ->
            commissioningLauncher.launch(IntentSenderRequest.Builder(result).build())
        }
}

Die lokale Android-Struktur kann über die Android-Einstellungen genutzt werden, um die Inbetriebnahme der Geräte auf anderen Fabrics zu vereinfachen.

Als Nächstes erfahren Sie, wie Sie ein Gerät für eine Entwicklungs-Fabric in Auftrag geben.

Eine Übersicht über die Benutzeroberfläche während der Inbetriebnahme finden Sie in der Google Home-Beispiel-App für Matter.

4. Provision für eine Entwicklungsstruktur

Geräte können für mehr als ein Netzwerk in Auftrag gegeben werden. Zur Verwaltung vertrauenswürdiger Kopplungen speichern Geräte eine FabricTable mit verschiedenen FabricInfo-Mitgliedern, z. B.:

  • Textilerkennung
  • Knoten-ID, die dem Gerät von der Struktur zugewiesen wird
  • Anbieter-ID
  • Fabric-ID
  • Betriebliche Anmeldedaten des Geräts

Der administrative Domain Manager (ADM) definiert Fabric-Anmeldedaten. Im vorherigen Szenario sind Google Play-Dienste das System, das als vertrauenswürdige Root-Zertifizierungsstelle fungiert. Wenn Sie Geräte für das lokale Android-Fabric in Betrieb nehmen, enthält jedes Gerät die gleichen Anmeldedaten und die gleichen Zertifizierungsstellen.

Kundenspezifische Inbetriebnahme

Für die Inbetriebnahme der lokalen Android-Struktur haben wir die Standardparameter verwendet, um die CommissioningRequest in der CommissioningClient API zu erstellen:

val request: CommissioningRequest = CommissioningRequest.builder().build()

Wenn Sie neue Geräte über Ihre App steuern und verwalten möchten, müssen Sie eine lokale Entwicklungsstruktur erstellen und die operativen Anmeldedaten für die Inbetriebnahme von Geräten abrufen. In diesem Szenario wird Ihre App zu einem einzigartigen, unabhängigen System, das Geräten die entsprechenden Knotenanmeldedaten zuweist.

Sie können das Home Mobile SDK darüber informieren, dass Sie Geräte auf Ihrem eigenen Stoff in Betrieb nehmen möchten, indem Sie einen benutzerdefinierten Dienst an die CommissioningRequest übergeben:

class CommissioningRequest {
  static CommissioningRequest.Builder builder();

  class Builder {
    Builder setCommissioningService(@Nullable ComponentName commissioningService);

    CommissioningRequest build();
  }
}

In den nächsten Schritten ändern wir die commissionDevice()-Funktion, um einen benutzerdefinierten Dienst zu verwenden. Außerdem fügen wir dem Home-Fragment einen Aktivitäts-Launcher hinzu und verwenden LiveData-Objekte zur Verwaltung des API-Ablaufs.

Schritt 1: GPS-Aktivitäts-Launcher erstellen

Erstellen wir zuerst einen Activity Launcher, um den IntentSender aus der CommissioningClient API zu verarbeiten.

  1. Öffnen Sie „HomeScreen“ im Ordner „java/com/google/homesampleapp/screens/home/“.
  2. Ersetzen Sie den Kommentar // CODELAB: commissionDeviceLauncher definition durch den folgenden Code, um das Ergebnis der Inbetriebnahmeaktivität zu registrieren und zu verarbeiten:
    val commissionDeviceLauncher =
  rememberLauncherForActivityResult(
    contract = ActivityResultContracts.StartIntentSenderForResult()
  ) { result ->
    // Commission Device Step 5.
    // The Commission Device activity in GPS (step 4) has completed.
    val resultCode = result.resultCode
    if (resultCode == Activity.RESULT_OK) {
      Timber.d("CommissionDevice: Success")
      // We let the ViewModel know that GPS commissioning has completed successfully.
      // The ViewModel knows that we still need to capture the device name and will\
      // update UI state to trigger the NewDeviceAlertDialog.
      homeViewModel.gpsCommissioningDeviceSucceeded(result)
    } else {
      homeViewModel.commissionDeviceFailed(resultCode)
    }
  }

Schritt 2: Aktion für das Provisionsgerät auslösen

In diesem Schritt löst der Nutzer das „Provisionsgerät“ aus indem Sie auf das Pluszeichen (+) unten rechts auf dem Startbildschirm. Daraufhin wird commissionDevice() angerufen.

val onCommissionDevice = {
  ...
  commissionDevice(activity!!.applicationContext, commissionDeviceLauncher)
}

Schritt 3: API aufrufen

  1. Du befindest dich weiterhin in „HomeScreen.kt“ im Ordner „java/com/google/homesampleapp/screens/home“.
  2. Ersetzen Sie den Kommentar // CODELAB: commissionDevice durch den folgenden commissionDeviceRequest. setCommissioningService bindet AppCommissioningService an eine CommissioningService-Instanz, die in einer Callback-Funktion zurückgegeben wird. Wenn du einen benutzerdefinierten Dienst übergibst, nimmt das Home Mobile SDK zuerst Geräte auf dem lokalen Android-Fabric in Betrieb und sendet dann die Onboarding-Nutzlast zurück an AppCommissioningService.
    val commissionDeviceRequest =
    CommissioningRequest.builder()
        .setCommissioningService(ComponentName(
            context, AppCommissioningService::class.java))
        .build()
  3. Rufen Sie zuerst .getCommissioningClient() und dann .commissionDevice() auf.
Matter.getCommissioningClient(context)
    .commissionDevice(commissionDeviceRequest)

Fügen Sie zum Ausführen der commissionDevice-Funktion addOnSuccessListener und addOnFailureListener hinzu:

    .addOnSuccessListener { result ->
      commissionDeviceLauncher.launch(IntentSenderRequest.Builder(result).build())
    }
    .addOnFailureListener { error ->
      Timber.e(error)
    }

5. Inbetriebnahmedienst einrichten

Mit der Funktion commissionDevice() wurde der Abruf eines CommissioningService von der CommissioningClient API angefordert. Bei diesem Ablauf beauftragt die CommissioningClient API zuerst Geräte für das lokale Android-Fabric und gibt dann einen Callback zurück, der das CommissioningRequestMetadata-Objekt enthält:

public interface CommissioningService {
interface Callback {
    void onCommissioningRequested(CommissioningRequestMetadata metadata);
  }
}

Jetzt müssen wir den CommissioningService.Callback übernehmen und die erforderliche Funktionalität bereitstellen, um Geräte für unsere Beispiel-App in Betrieb zu nehmen. Hier ein Beispiel für eine grundlegende Implementierung von CommissioningService:

class MatterCommissioningService : Service(), CommissioningService.Callback {
   private val commissioningServiceDelegate =
     CommissioningService.Builder(this)
       .setCallback(this)
       .build()

   override fun onBind(intent: Intent) = commissioningServiceDelegate.asBinder()

   override fun onCommissioningRequested(metadata: CommissioningRequestMetadata) {
     // perform commissioning

     commissioningServiceDelegate
       .sendCommissioningComplete(CommissioningCompleteMetadata.builder().build())
   }
 }

Schritt 1: Benutzerdefinierten AppCommissioningService ausprobieren

Um Ihnen den Einstieg zu erleichtern, haben wir bereits die grundlegende Klassenstruktur für unseren benutzerdefinierten CommissioningService definiert. Hier ist eine kurze Übersicht über die Funktionen des Dienstes. Wenn du mitmachen möchtest, öffne AppCommissioningService in java/commissioning.

Wir haben die folgenden Importe für die Home Mobile SDK APIs hinzugefügt:

import com.google.android.gms.home.matter.commissioning.CommissioningCompleteMetadata
import com.google.android.gms.home.matter.commissioning.CommissioningRequestMetadata
import com.google.android.gms.home.matter.commissioning.CommissioningService

AppCommissioningService enthält auch Bibliotheken aus dem Matter-Repository (connectedhomeip):

import com.google.homesampleapp.chip.ChipClient

Der Dienst umfasst außerdem Importe zur Unterstützung von Hilt und Kotlin-Koroutinen.

Als Nächstes erstellen wir den Konstruktor und richten einige Dinge ein, einschließlich der commissioningServiceDelegate, die wir verwenden, um die Google Play-Dienste zu informieren, wenn die Inbetriebnahme abgeschlossen ist.

private lateinit var commissioningServiceDelegate: CommissioningService
...
commissioningServiceDelegate = CommissioningService.Builder(this).setCallback(this).build()

Jetzt ist es an der Zeit, die Inbetriebnahmefunktionen hinzuzufügen.

Schritt 2: onCommissioningRequested überschreiben

Führen Sie die folgenden Schritte aus, um Geräte für die Entwicklungsstruktur der App in Betrieb zu nehmen:

  1. AppCommissioningService in java/commissioning öffnen.
  2. Suchen Sie die Funktion onCommissioningRequested(). Wir haben eine Lognachricht bereitgestellt, die das CommissioningRequestMetadata ausgibt. Ersetzen Sie den Kommentar // CODELAB: onCommissioningRequested(), um die Koroutine serviceScope zu starten und die deviceId abzurufen.
    // Perform commissioning on custom fabric for the sample app.
serviceScope.launch {
  val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
  3. Führen Sie die Inbetriebnahme durch. In diesem Schritt können wir die im Objekt CommissioningRequestMetadata zurückgegebenen Geräteinformationen übergeben. Die ChipClient erstellt anhand dieser Metadaten einen sicheren Kanal zwischen der GHSA for Matter-App und Ihrem Gerät.
    try {
  Timber.d(
      "Commissioning: App fabric -> ChipClient.establishPaseConnection(): deviceId [${deviceId}]")
  chipClient.awaitEstablishPaseConnection(
      deviceId,
      metadata.networkLocation.ipAddress.hostAddress!!,
      metadata.networkLocation.port,
      metadata.passcode)
  Timber.d(
      "Commissioning: App fabric -> ChipClient.commissionDevice(): deviceId [${deviceId}]")
  chipClient.awaitCommissionDevice(deviceId, null)
} catch (e: Exception) {
  Timber.e(e, "onCommissioningRequested() failed")
  // No way to determine whether this was ATTESTATION_FAILED or DEVICE_UNREACHABLE.
  commissioningServiceDelegate
      .sendCommissioningError(CommissioningError.OTHER)
      .addOnSuccessListener {
        Timber.d(
            "Commissioning: commissioningServiceDelegate.sendCommissioningError() succeeded")
      }
      .addOnFailureListener { e2 ->
        Timber.e(e2, "Commissioning: commissioningServiceDelegate.sendCommissioningError() failed")
      }
  return@launch
}
  4. Verwende commissioningServiceDelegate, um den Google Play-Diensten mitzuteilen, dass die Inbetriebnahme abgeschlossen ist. Übergeben Sie in .sendCommissioningComplete() den Parameter CommissioningCompleteMetadata.
    commissioningServiceDelegate
    .sendCommissioningComplete(
        CommissioningCompleteMetadata.builder().setToken(deviceId.toString()).build())
    .addOnSuccessListener {
      Timber.d("Commissioning: commissioningServiceDelegate.sendCommissioningComplete() succeeded")
    }
    .addOnFailureListener { e ->
      Timber.e(e, "Commissioning: commissioningServiceDelegate.sendCommissioningComplete() failed")
    }
}

Anwendung ausführen

Da nun der gesamte erforderliche Code für die Inbetriebnahme auf unserer lokalen Textilabdeckung vorhanden ist, ist es an der Zeit, ihn zu testen. Wählen Sie Ihr Android-Gerät aus und führen Sie die App aus. Tippen Sie auf dem Startbildschirm auf Gerät hinzufügen und führen Sie die Schritte zur Inbetriebnahme Ihres Geräts aus.

Wenn die Inbetriebnahme abgeschlossen ist, besteht Ihr Gerät jetzt aus zwei Strukturen: dem lokalen Android-Fabric und dem lokalen Entwicklungs-Fabric. Jede Struktur hat eigene Anmeldedaten und eine eindeutige 64-Bit-Fabric-ID.

6. Geräte steuern

Bei der Inbetriebnahme in einer Entwicklungsstruktur können Sie die Bibliotheken aus dem Matter-Repository (connectedhomeip) verwenden, um Geräte über die Beispiel-App zu steuern.

Wir haben einige Hilfsklassen erstellt, um den Zugriff auf Gerätecluster und das Senden von Befehlen zu vereinfachen. Öffne ClustersHelper in java/clusters, um weitere Informationen zu erhalten. Dieses Singleton-Hilfsprogramm importiert die folgenden Bibliotheken, um auf Geräteinformationen zuzugreifen:

import chip.devicecontroller.ChipClusters
import chip.devicecontroller.ChipStructs

Mit dieser Klasse können wir den An-/Aus-Cluster für ein Gerät abrufen und dann .toggle aufrufen:

suspend fun toggleDeviceStateOnOffCluster(deviceId: Long, endpoint: Int) {
  Timber.d("toggleDeviceStateOnOffCluster())")
  val connectedDevicePtr =
      try {
        chipClient.getConnectedDevicePointer(deviceId)
      } catch (e: IllegalStateException) {
        Timber.e("Can't get connectedDevicePointer.")
        return
      }
  return suspendCoroutine { continuation ->
    getOnOffClusterForDevice(connectedDevicePtr, endpoint)
        .toggle(
            object : ChipClusters.DefaultClusterCallback {
              override fun onSuccess() {
                continuation.resume(Unit)
              }
              override fun onError(ex: Exception) {
                Timber.e("readOnOffAttribute command failure: $ex")
                continuation.resumeWithException(ex)
              }
            })
  }
}

Gerät aktivieren/deaktivieren

Nachdem Sie ein Gerät in Betrieb genommen haben, wird die im CommissioningResult zurückgegebene Nutzlast dem DataStore hinzugefügt. Dadurch erhält unsere App Zugriff auf Geräteinformationen, die wir zum Senden von Befehlen verwenden können.

Matter-Apps sind ereignisgesteuert. Wenn der Matter-Stack initialisiert wird, warten Clusterdienste auf eingehende Nachrichten. Sobald ein Gerät in Betrieb genommen wurde, senden Matter-Clients Befehle über den sicheren Betriebskanal, der bei der Geräteinbetriebnahme festgelegt wurde.

Auf dem Gerät werden Pakete validiert, entschlüsselt und dann mit einem Callback gesendet. Callback-Funktionen umfassen die EndpointId, die ClusterId und die AttributeId, auf die über attributePath zugegriffen werden kann. Dieser Code kann beispielsweise auf einem Matter-Gerät implementiert werden:

void MatterPostAttributeChangeCallback(const chip::app::ConcreteAttributePath & attributePath, uint8_t mask, uint8_t type,
                                       uint16_t size, uint8_t * value)
{
    // handle callback
    ClusterId clusterId     = attributePath.mClusterId;
    AttributeId attributeId = attributePath.mAttributeId;
}

In den nächsten Schritten verwendest du das Matter SDK und ClustersHelper, um ein Gerät ein- oder auszuschalten.

  1. DeviceViewModel in java/screens/device aufrufen.
  2. Suchen Sie die Funktion updateDeviceStateOn.
  3. Ersetzen Sie den Kommentar // CODELAB: toggle durch den Code zum Aufrufen von clustersHelper und aktualisieren Sie dann das Geräte-Repository:
    Timber.d("Handling real device")
    try {
      clustersHelper.setOnOffDeviceStateOnOffCluster(deviceUiModel.device.deviceId, isOn, 1)
      devicesStateRepository.updateDeviceState(deviceUiModel.device.deviceId, true, isOn)
    } catch (e: Throwable) {
      Timber.e("Failed setting on/off state")
    }

Diese Funktion wird von DeviceScreen aus aufgerufen:

// On/Off Switch click.
val onOnOffClick: (value: Boolean) -> Unit = { value ->
  deviceViewModel.updateDeviceStateOn(deviceUiModel!!, value)
}

Anwendung ausführen

Führe die App aus, um deine Änderungen neu zu laden. Schalten Sie Ihr Gerät auf dem Startbildschirm ein und aus.

7. Geräte gemeinsam mit anderen Systemen nutzen

Die gemeinsame Nutzung eines Geräts wird in der Matter-Spezifikation als Vorgang für mehrere Administratoren bezeichnet.

In den vorherigen Schritten haben wir erfahren, dass das Home Mobile SDK es ermöglicht, Geräte für das Local Android Fabric und auch für ein Entwicklungs-Fabric für die Beispiel-App in Betrieb zu nehmen. Dies ist ein Beispiel für einen Multi-Admin-Ablauf, bei dem Geräte für mehr als ein Fabric in Betrieb genommen werden können.

Vielleicht möchten Sie jetzt Geräte mit noch mehr Stoffen gemeinsam nutzen, besonders wenn dies ein Haushalt ist, in dem die Menschen ihre eigenen Vorlieben in Bezug auf Anwendungen und Plattformen haben.

Das Home Mobile SDK bietet diese Funktion in der ShareDeviceRequest API für folgende Aktionen:

  1. Öffnen Sie ein vorübergehendes Inbetriebnahmefenster für Geräte.
  2. Ändern Sie den Status Ihrer Geräte, damit sie auf einem anderen Fabric in Auftrag gegeben werden können.
  3. Du kannst deine Geräte über andere Apps und Plattformen steuern.

In den nächsten Schritten verwendest du das Home Mobile SDK, um Geräte gemeinsam zu nutzen.

Schritt 1: GPS-Aktivitäts-Launcher erstellen

Ähnlich wie beim Start einer Inbetriebnahmeaktivität, den wir bei der Inbetriebnahme einer Entwicklungsstruktur erstellt haben, haben wir einen Launcher zur Freigabe der Geräteaktivität erstellt, um die IntentSender von der CommissioningClient API zu verarbeiten.

  1. Öffnen Sie „DeviceScreen“ im Ordner „java/com/google/homesampleapp/screens/device/“.
  2. Ersetzen Sie den Kommentar // CODELAB: shareDeviceLauncher definition durch den folgenden Code, um das Ergebnis der .shareDevice()-Aktivität zu registrieren und zu verarbeiten:
    val shareDeviceLauncher = rememberLauncherForActivityResult(
  contract = ActivityResultContracts.StartIntentSenderForResult()
) { result ->
  // Commission Device Step 5.
  // The Share Device activity in GPS (step 4) has completed.
  val resultCode = result.resultCode
  if (resultCode == Activity.RESULT_OK) {
    deviceViewModel.shareDeviceSucceeded()
  } else {
    deviceViewModel.shareDeviceFailed(resultCode)
  }
}

Schritt 2: Aktion zum Teilen des Geräts auslösen

In diesem Schritt löst der Nutzer die Option „Gerät gemeinsam nutzen“ aus indem Sie auf die Schaltfläche „Teilen“ auf dem Gerätebildschirm. Daraufhin wird deviceViewModel angerufen, um ein Kopplungsfenster für die Gerätefreigabe zu öffnen.

// Share Device button click.
val onShareDevice: () -> Unit = remember {
 {
   deviceViewModel.openPairingWindow(deviceUiModel!!.device.deviceId)
 }
}

Nachdem das Kopplungsfenster erfolgreich geöffnet wurde, kommuniziert deviceViewModel dies an die UI. Die Kommunikation zwischen ViewModel und der Benutzeroberfläche erfolgt über StateFlow-Objekte.

// Communicate to the UI that the pairing window is open.
// UI can then launch the GPS activity for device sharing.
_pairingWindowOpenForDeviceSharing.value = true

Nach der Erkennung der Änderung am StateFlow-Objekt führt DeviceScreen den folgenden Aufruf aus:

shareDevice(activity!!.applicationContext, shareDeviceLauncher, deviceViewModel)

Schritt 3: API aufrufen

Jetzt ist es an der Zeit, eine Aufgabe zum Teilen des Geräts zu starten.

  1. Öffnen Sie „DeviceScreen.kt“ im Ordner „java/com/google/homesampleapp/screens/device/“.
  2. Suchen Sie die Funktion shareDevice(). Ersetzen Sie den Kommentar // CODELAB: shareDevice durch ShareDeviceRequest. Die DeviceDescriptor enthält spezifische Informationen zum Gerät, z. B. Anbieter-ID, Produkt-ID und deviceType. In diesem Beispiel haben wir die Werte hartcodiert.
    val shareDeviceRequest =
  ShareDeviceRequest.builder()
    .setDeviceDescriptor(DeviceDescriptor.builder().build())
    .setDeviceName("GHSAFM temp device name")
  3. Legen Sie CommissioningWindow und Parameter fest.
        .setCommissioningWindow(
        CommissioningWindow.builder()
            .setDiscriminator(Discriminator.forLongValue(DISCRIMINATOR))
            .setPasscode(SETUP_PIN_CODE)
            .setWindowOpenMillis(SystemClock.elapsedRealtime())
            .setDurationSeconds(OPEN_COMMISSIONING_WINDOW_DURATION_SECONDS.toLong())
            .build())
    .build()
  4. Rufen Sie .getCommissioningClient() auf. Verwenden Sie nur dieses Mal die .shareDevice() API.
    Matter.getCommissioningClient(context)
    .shareDevice(shareDeviceRequest)

Der Erfolgs-Callback der commissioningClient.shareDevice() API stellt den IntentSender bereit, mit dem die Freigabe von Geräteaktivitäten in den Google Play-Diensten gestartet werden kann.

  1. Fügen Sie zum Ausführen der shareDevice-Funktion addOnSuccessListener und addOnFailureListener hinzu. Bei Erfolg wird launch am shareDeviceLauncher aufgerufen, um die GPS-Aktivität für die Gerätefreigabe zu starten.
        .addOnSuccessListener { result ->
      Timber.d("ShareDevice: Success getting the IntentSender: result [${result}]")
      shareDeviceLauncher.launch(IntentSenderRequest.Builder(result).build())
    }
    .addOnFailureListener { error ->
      Timber.e(error)
      deviceViewModel.showMsgDialog("Share device failed", error.toString())
    }

Anwendung ausführen

Wenn du dein Matter-Gerät mit anderen Plattformen teilen möchtest, muss auf deinem Android-Gerät eine andere Plattform installiert sein. Wir haben eine weitere Instanz der Beispiel-App erstellt, die Sie als Target Commissioner verwenden können.

Sobald du das Ziel-Provisioner auf deinem Android-Gerät installiert hast, überprüfe, ob du dein Matter-Gerät teilen kannst. Die Ziel-Provisioner-App trägt das Label GHSAFM-TC.

Ihre Geräte können jetzt in drei Strukturen eingesetzt werden:

  1. Die lokale Android-Struktur
  2. Ihre Entwicklungsstruktur (diese App).
  3. Das dritte Fabric, mit dem Sie das Gerät gerade geteilt haben.

8. Nächste Schritte

Glückwunsch

Herzlichen Glückwunsch! Sie haben dieses Codelab erfolgreich abgeschlossen und gelernt, wie Sie Geräte mit dem Home Mobile SDK in Betrieb nehmen und freigeben.

Wenn Sie Probleme mit der Beispiel-App haben, führen Sie die Schritte zur Überprüfung Ihrer Umgebung aus:

Wenn Sie Fragen zur Verwendung der Beispiel-App haben oder einen Codefehler entdecken, können Sie Probleme an den Issue Tracker im GitHub-Repository senden:

Im Forum für Smart-Home-Entwickler erhältst du offizielle Hilfe von Google bei technischen Fragen:

Verwenden Sie das Tag google-smart-home auf Stack Overflow, um technischen Support von der Community zu erhalten: