Utwórz aplikację na Androida o sprawach

1. Witamy

Matter ma na celu ujednolicenie standardów IoT. Łączy inteligentne urządzenia domowe w różnych ekosystemach, takich jak Google Home, Zigbee, Bluetooth Mesh czy Z-Wave.

Urządzenia mobilne stanowią centralny punkt interakcji z inteligentnymi urządzeniami domowymi. Jeśli chcesz utworzyć własne aplikacje na Androida do obsługi urządzeń Matter, możemy Ci pomóc szybko rozpocząć.

Przykładowa aplikacja Google Home dla standardu Matter (GHSA dla Matter) zawiera interfejsy API pakietu Home Mobile SDK, które umożliwiają użytkownikom uruchamianie i udostępnianie urządzeń. Przykładowa aplikacja może służyć też jako narzędzie do nauki, które pozwala lepiej zrozumieć kluczowe pojęcia Matter, a także do debugowania i rozwiązywania problemów z interakcjami z urządzeniami Matter.

Jakie zadania wykonasz

W ramach tego ćwiczenia w Codelabs pobierzesz kod źródłowy przykładowej aplikacji i dowiesz się, jak używać pakietu SDK Home Mobile do uruchamiania i udostępniania urządzeń. Dowiesz się też, jak korzystać z biblioteki uruchamiania i bibliotek klastra z repozytorium Matter (connectedhomeip).

Gdy pobierzesz przykładową aplikację, sprawdzimy kod źródłowy w Android Studio i zaimplementujemy te interfejsy API Mobile SDK:

Poznasz też zagadnienia związane ze zleceniem, tkaninami Matter i sterowanie urządzeniami w standardzie Matter.

Czego potrzebujesz

Zanim zaczniesz, wykonaj te czynności:

Za pomocą przykładowej aplikacji nie potrzebujesz centrum, np. Google Nest Hub (2 generacji), aby uruchamiać urządzenia i sterować nimi.

2. Konfiguracja

Aplikacja startowa w Codelabs znajduje się w gałęzi codelab. Aby zacząć korzystać z kodu źródłowego ćwiczeń z programowania, możesz pobrać plik ZIP.

Użyjesz tego pliku ZIP codelab, aby utworzyć działającą próbkę.

Wersje ćwiczeń z programowania

Gałąź codelab jest oznaczona tagiem wersji 2.0.0 przykładowej aplikacji. Aby porównać aktualizacje na każdym etapie, możesz pobrać kompletny kod źródłowy tej wersji.

Jeśli chcesz skopiować repozytorium GitHub, postępuj zgodnie z instrukcjami podanymi w przykładowej aplikacji README.

Zależności

Przeprowadzimy Cię przez kod źródłowy urządzeń wymaganych do udostępniania i prowadzenia urządzeń, ale najpierw warto poznać następujące zależności. Te zależności są zadeklarowane w pliku libs.versions.toml, a ich użycie jest określone w pliku build.gradle.kts.

Kod źródłowy

Interfejs i większość funkcji zostały już dla Ciebie skonstruowane.

W ramach tego ćwiczenia w Codelabs dodamy funkcję Matter do tych plików:

  • java/com/google/homesampleapp/commissioning/AppCommissioningService: umożliwia zlecanie urządzeń w tkaninie deweloperskiej
  • java/com/google/homesampleapp/screens/home/HomeScreen i java/com/google/homesampleapp/screens/home/HomeViewModel.kt: obejmuje funkcję uruchomienia mobilnego pakietu SDK Home.
  • java/com/google/homesampleapp/screens/device/DeviceScreen i java/com/google/homesampleapp/screens/device/DeviceViewModel: obejmuje wywołania interfejsu Share Device API

Każdy plik jest skomentowany blokiem kodu, który będziesz modyfikować, na przykład:

// CODELAB: add commissioningFunction()

Dzięki temu możesz szybko znaleźć odpowiednią sekcję w ćwiczeniach z programowania.

3. Prowizja dla Google

Zanim będzie można sterować urządzeniami i zezwolić im na komunikowanie się ze sobą w tej samej sieci szkieletowej, muszą one zostać zlecone przez komisarza – w tym przypadku jest to przykładowa aplikacja – Google Home Sample App for Matter.

Znajomość następujących pojęć związanych z uruchamianiem spraw związanych ze standardem Matter:

  • Tkaniny umożliwiają urządzeniom komunikację ze sobą.
  • Tkaniny obsługują wspólny zestaw unikalnych danych logowania.
  • Ekosystemy odpowiadają za wystawianie zaufanych certyfikatów głównych, przypisywanie identyfikatorów tkanin oraz przypisywanie unikalnych identyfikatorów węzłów. Ekosystem to usługa backendu dla komisarza – na przykład Home Graph w ekosystemie Google Home.
  • Urządzenia można zlecać dla więcej niż 1 tkanin (funkcja dla wielu administratorów).

Aby uruchomić urządzenie, musisz użyć interfejsu CommissioningClient API. Wywołanie .commissionDevice() zwraca element IntentSender, który uruchamia odpowiednią aktywność w Usługach Google Play:

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

W kolejnych sekcjach omówimy minimalny kod wymagany do zwrócenia urządzeń do szkieletu Google.

Krok 1. Program uruchamiający aktywność

Do obsługi polecenia IntentSender z CommissioningClient możesz użyć rozszerzenia ActivityResultLauncher:

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

Krok 2. Funkcja prowizji

Oto podstawowy przykład, który korzysta z interfejsu CommissioningClient API do zlecania urządzenia w tkaniny Google.

  1. Proces uruchamiania zaczyna się od funkcji commissionDevice(). Po pierwsze, zdefiniowany jest CommissioningRequest. W przypadku tej konfiguracji domyślnej urządzenia są udostępniane tylko w ramach lokalnej sieci szkieletowej dla Androida.
  2. Punktem wejścia dla mobilnego pakietu SDK na urządzenia mobilne jest Matter. W następnym wywołaniu .getCommissioningClient uzyskuje klienta korzystających z funkcji Prowizje od this (Activity).
  3. .commissionDevice() akceptuje CommissioningRequest.
  4. Na koniec .addOnSuccessListener otrzymuje funkcję przetwarzania danych CommissioningResult i uruchamiania aktywności na urządzeniu prowizyjnym usług Google Play (GPS).
private fun commissionDevice() {
    val request: CommissioningRequest = CommissioningRequest.builder().build()
    Matter.getCommissioningClient(this)
        .commissionDevice(request)
        .addOnSuccessListener { result ->
            commissioningLauncher.launch(IntentSenderRequest.Builder(result).build())
        }
}

Lokalna tkanina Android Fabric można wykorzystać w ustawieniach Androida, aby uprościć proces wdrażania urządzeń w innych tkaninach.

Następnie nauczysz się, jak zamówić urządzenie do tkaniny deweloperskiej.

Omówienie interfejsu użytkownika na etapie uruchamiania znajdziesz w przewodniku Google Home Sample App for Matter.

4. Prowizja dla tkaniny programistycznej

Urządzenia można zamówić dla więcej niż 1 tkaniny. Aby zarządzać zaufanymi parami, urządzenia przechowują identyfikator FabricTable zawierający różnych członków grupy FabricInfo, na przykład:

  • Identyfikacja tkanin
  • Identyfikator węzła przypisany do urządzenia przez tkaninę
  • Identyfikator dostawcy
  • Identyfikator tkaniny
  • Dane logowania do operacji na urządzeniu

Administracyjny menedżer domeny (ADM) definiuje własne dane logowania. W poprzednim scenariuszu Usługi Google Play to ekosystem, który działa jak zaufany główny urząd certyfikacji. Gdy zlecasz użycie urządzeń w lokalnej sieci szkieletowej na Androida, każde urządzenie ma ten sam zestaw danych logowania do tkanin oraz ten sam zestaw urzędów certyfikacji.

Niestandardowe usługi prowizji

Aby utworzyć prowizję dla lokalnej tkaniny Androida, użyliśmy parametrów domyślnych do utworzenia obiektu CommissioningRequest w interfejsie CommissioningClient API:

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

Jeśli chcesz sterować nowymi urządzeniami i nimi zarządzać z poziomu aplikacji, musisz utworzyć lokalną sieć szkieletową dla programistów i uzyskać dane logowania na potrzeby prowizji dla urządzeń. W takim przypadku aplikacja staje się unikalnym, niezależnym ekosystemem, który przypisuje urządzeniom odpowiednie dane logowania do węzła.

Możesz poinformować pakiet Home Mobile SDK, że chcesz zlecić urządzenia dla swojej własnej tkaniny, przesyłając do CommissioningRequest usługę niestandardową:

class CommissioningRequest {
  static CommissioningRequest.Builder builder();

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

    CommissioningRequest build();
  }
}

W następnych krokach zmienimy funkcję commissionDevice() tak, aby korzystała z usługi niestandardowej. Do fragmentu strony głównej dodamy również program uruchamiający aktywność i będziemy używać obiektów LiveData do zarządzania przepływem interfejsu API.

Krok 1. Utwórz program uruchamiający aktywność GPS

Najpierw utwórzmy program uruchamiający aktywność do obsługi funkcji IntentSender z interfejsu CommissioningClient API.

  1. Otwórz plik HomeScreen w folderze java/com/google/homesampleapp/screens/home/.
  2. Zastąp komentarz // CODELAB: commissionDeviceLauncher definition tym kodem, aby zarejestrować i obsługiwać wynik działania związanego z uruchamianiem:
    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)
    }
  }

Krok 2. Uruchom działanie dotyczące urządzenia Prowizje

W tym kroku użytkownik aktywuje „urządzenie do prowizji” klikając przycisk „+”, w prawym dolnym rogu ekranu głównego. Następnie zostanie nawiązane połączenie z numerem commissionDevice().

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

Krok 3. Wywołaj interfejs API

  1. Nadal jestem w: HomeScreen.kt w folderze java/com/google/homesampleapp/screens/home.
  2. Zastąp komentarz // CODELAB: commissionDevice następującym: commissionDeviceRequest. setCommissioningService łączy AppCommissioningService z wystąpieniem CommissioningService zwróconym w funkcji wywołania zwrotnego. Gdy przekażesz usługę niestandardową, pakiet SDK Home Mobile najpierw zleci urządzenia do lokalnej sieci szkieletowej na Androida, a potem wyśle dane wprowadzające z powrotem do AppCommissioningService.
    val commissionDeviceRequest =
    CommissioningRequest.builder()
        .setCommissioningService(ComponentName(
            context, AppCommissioningService::class.java))
        .build()
  3. Zadzwoń pod numer .getCommissioningClient(), a potem .commissionDevice().
Matter.getCommissioningClient(context)
    .commissionDevice(commissionDeviceRequest)

Aby uzupełnić funkcję commissionDevice, dodaj addOnSuccessListener i addOnFailureListener:

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

5. Tworzenie usługi przekazywania

W funkcji commissionDevice() poprosiliśmy o pobranie usługi CommissioningService z interfejsu CommissioningClient API. W tym procesie interfejs CommissioningClient API najpierw przekazuje urządzenia do lokalnej sieci szkieletowej na Androida, a potem zwraca wywołanie zwrotne zawierające obiektCommissioningRequestMetadata:

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

Teraz musimy odziedziczyć funkcję CommissioningService.Callback i udostępnić funkcję wymaganą do uruchamiania urządzeń w naszej przykładowej aplikacji. Oto przykład podstawowej implementacji usługi 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())
   }
 }

Krok 1. Poznaj niestandardową usługę AppCommissioningService

Aby ułatwić Ci rozpoczęcie pracy, zdefiniowaliśmy już podstawową strukturę klas dla niestandardowej usługi CommissioningService. Oto krótkie omówienie funkcji tej usługi. Aby kontynuować, otwórz AppCommissioningService w aplikacji java/commissioning.

Dodaliśmy te elementy do zaimportowania interfejsów API Home Mobile SDK:

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 obejmuje też biblioteki z repozytorium Matter (connectedhomeip):

import com.google.homesampleapp.chip.ChipClient

Usługa obejmuje również importy do obsługi współrzędnych Hilt i Kotlin.

Następnie tworzymy konstruktor i konfigurujemy kilka elementów, w tym element commissioningServiceDelegate, za pomocą którego będziemy powiadamiać Usługi Google Play o zakończeniu uruchomienia.

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

Teraz dodaj funkcje uruchamiania.

Krok 2. Zastąp onCommissioning requested

Aby uruchomić urządzenia w tkaniny deweloperskiej aplikacji, wykonaj te czynności:

  1. Otwórz: AppCommissioningService w aplikacji java/commissioning.
  2. Znajdź funkcję onCommissioningRequested(). Udostępniliśmy komunikat dziennika, który zawiera CommissioningRequestMetadata. Zastąp komentarz // CODELAB: onCommissioningRequested(), aby rozpocząć procedurę serviceScope i uzyskać deviceId.
    // Perform commissioning on custom fabric for the sample app.
serviceScope.launch {
  val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
  3. Wykonaj wdrożenie. Na tym etapie możemy przekazać informacje o urządzeniu zwrócone w obiekcieCommissioningRequestMetadata. ChipClient wykorzystuje te metadane do utworzenia bezpiecznego kanału między aplikacją GHSA dla Matter a Twoim urządzeniem.
    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. commissioningServiceDelegate umożliwia powiadomienie Usług Google Play o zakończeniu uruchomienia. W .sendCommissioningComplete() przekaż 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")
    }
}

Uruchom aplikację

Skoro masz już wszystkie wymagane fragmenty kodu, aby zlecić zamówienie do naszej lokalnej tkaniny, czas ją przetestować. Wybierz urządzenie z Androidem i uruchom aplikację. Na ekranie głównym kliknij Dodaj urządzenie i postępuj zgodnie z instrukcjami, aby włączyć urządzenie.

Po zakończeniu realizacji zamówienia urządzenie będzie miało 2 materiały: lokalną tkaninę na Androida i tkaninę lokalną. Każda tkanina ma własny zestaw danych uwierzytelniających i unikalny, 64-bitowy identyfikator.

6. Steruj urządzeniami

Przekazywanie do tkaniny deweloperskiej umożliwia używanie bibliotek z repozytorium sprawy (connectedhomeip) do sterowania urządzeniami z przykładowej aplikacji.

Aby ułatwić dostęp do klastrów urządzeń i wysyłanie poleceń, utworzyliśmy klasy pomocnicze. Aby dowiedzieć się więcej, otwórz ClustersHelper w aplikacji java/clusters. Ten pomocnik usługi Singleton importuje następujące biblioteki, aby uzyskać dostęp do informacji o urządzeniu:

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

Przy użyciu tych zajęć możemy uzyskać informacje o klastrze włączania i wyłączania dla urządzenia, a następnie wywołamy funkcję .toggle:

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

Przełącz urządzenie

Po zleceniu urządzenia ładunek zwrócony w parametrze CommissioningResult jest dodawany do magazynu danych. Dzięki temu aplikacja uzyskuje dostęp do informacji z urządzenia, za pomocą których możemy wysyłać polecenia.

Aplikacje Matter opierają się na zdarzeniach. Po zainicjowaniu stosu Matter usługi klastra nasłuchują wiadomości przychodzących. Po udostępnieniu urządzenia klienci Matter wysyłają polecenia do bezpiecznego kanału operacyjnego, który został utworzony podczas uruchamiania urządzenia.

Pakiety są weryfikowane, odszyfrowywane na urządzeniu i wysyłane z wywołaniem zwrotnym. Funkcje wywołania zwrotnego obejmują EndpointId, ClusterId oraz AttributeId, które są dostępne z poziomu attributePath. Na przykład ten kod można zaimplementować na urządzeniu ze standardem Matter:

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

W następnych krokach będziesz używać pakietu Matter SDK i ClustersHelper do przełączania urządzeń.

  1. Przejdź do DeviceViewModel w java/screens/device.
  2. Znajdź funkcję updateDeviceStateOn.
  3. Zastąp komentarz // CODELAB: toggle kodem wywołujący clustersHelper, a następnie zaktualizuj repozytorium urządzenia:
    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")
    }

Ta funkcja jest wywoływana z DeviceScreen:

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

Uruchom aplikację

Uruchom aplikację, aby ponownie załadować aktualizacje. Włącz lub wyłącz urządzenie na ekranie głównym.

7. Udostępnianie urządzeń innym ekosystemom

W specyfikacji Matter udostępnianie urządzenia jest określane jako proces przez wielu administratorów.

W poprzednich krokach dowiedzieliśmy się, że pakiet SDK do urządzeń mobilnych dla urządzeń mobilnych umożliwia zlecanie urządzeń w lokalnej sieci szkieletowej na Androida oraz w tkaniny programistycznej na potrzeby przykładowej aplikacji. To przykład przepływu dla wielu administratorów, w ramach którego urządzenia można zamówić do więcej niż 1 składnicy.

Teraz możesz udostępniać urządzenia z jeszcze większą liczbą tkanin, zwłaszcza jeśli jest to dom, w którym ludzie mają własne preferencje dotyczące aplikacji i platform.

Pakiet Home Mobile SDK udostępnia tę funkcję w interfejsie ShareDeviceRequest API, dzięki czemu możesz:

  1. Otwórz tymczasowe okno uruchomienia dla urządzeń.
  2. Zmień stan urządzeń, aby można było je zamówić do innej sieci szkieletowej.
  3. Steruj urządzeniami za pomocą innych aplikacji i ekosystemów.

W następnych krokach będziesz udostępniać urządzenia przy użyciu pakietu SDK Home Mobile SDK.

Krok 1. Utwórz program uruchamiający aktywność GPS

Podobnie jak w przypadku programu uruchamiającego aktywność, który stworzyliśmy podczas zlecania usługi programistycznej, stworzyliśmy program uruchamiający udostępnianie aktywności na urządzeniu do obsługi funkcji IntentSender w interfejsie API CommissioningClient.

  1. Otwórz plik DeviceScreen w folderze java/com/google/homesampleapp/screens/device/.
  2. Zastąp komentarz // CODELAB: shareDeviceLauncher definition tym kodem, aby zarejestrować i obsługiwać wynik działania .shareDevice():
    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)
  }
}

Krok 2. Uruchom działanie udostępniania urządzenia

W tym kroku użytkownik aktywuje funkcję „Udostępnianie urządzenia”. klikając przycisk „Udostępnij”, na ekranie urządzenia. Następuje nawiązanie połączenia z numerem deviceViewModel w celu otwarcia okna parowania w celu udostępnienia urządzenia.

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

Po udanym otwarciu okna analizy deviceViewModel przekazuje tę informację do interfejsu użytkownika. Komunikacja między interfejsem ViewModel a interfejsem odbywa się za pomocą obiektów StateFlow.

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

Po zobaczeniu zmiany w obiekcie StateFlow DeviceScreen wykonuje to wywołanie:

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

Krok 3. Wywołaj interfejs API

Teraz czas rozpocząć zadanie udostępniania urządzenia.

  1. Otwórz plik DeviceScreen.kt w folderze java/com/google/homesampleapp/screens/device/.
  2. Znajdź funkcję shareDevice(). Zastąp komentarz // CODELAB: shareDevice komentarzem ShareDeviceRequest. Pole DeviceDescriptor zawiera szczegółowe informacje o urządzeniu, takie jak identyfikator dostawcy, identyfikator produktu i typ urządzenia. W tym przykładzie ustawiamy je na stałe.
    val shareDeviceRequest =
  ShareDeviceRequest.builder()
    .setDeviceDescriptor(DeviceDescriptor.builder().build())
    .setDeviceName("GHSAFM temp device name")
  3. Ustaw CommissioningWindow i parametry.
        .setCommissioningWindow(
        CommissioningWindow.builder()
            .setDiscriminator(Discriminator.forLongValue(DISCRIMINATOR))
            .setPasscode(SETUP_PIN_CODE)
            .setWindowOpenMillis(SystemClock.elapsedRealtime())
            .setDurationSeconds(OPEN_COMMISSIONING_WINDOW_DURATION_SECONDS.toLong())
            .build())
    .build()
  4. Wywołaj .getCommissioningClient(), tylko tym razem, użyj interfejsu API .shareDevice().
    Matter.getCommissioningClient(context)
    .shareDevice(shareDeviceRequest)

Pomyślne wywołanie zwrotne interfejsu API commissioningClient.shareDevice() przekazuje nadawcy intencji, z której może skorzystać, aby uruchomić udostępnianie aktywności urządzenia w Usługach Google Play.

  1. Aby uzupełnić funkcję shareDevice, dodaj addOnSuccessListener i addOnFailureListener. Po udanym działaniu funkcja launch zostaje wywołana na urządzeniu shareDeviceLauncher, aby uruchomić aktywność GPS na potrzeby udostępniania urządzenia.
        .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())
    }

Uruchom aplikację

Aby udostępnić urządzenie Matter w innych ekosystemach, na urządzeniu z Androidem musisz mieć zainstalowaną inną platformę. Utworzyliśmy kolejną instancję przykładowej aplikacji, której możesz użyć jako docelowego komisarza.

Po zainstalowaniu na urządzeniu z Androidem usługi komisarza docelowego sprawdź, czy możesz udostępnić urządzenie ze standardem Matter. Aplikacja komisarza ds. kierowania ma etykietę GHSAFM-TC.

Twoje urządzenia mogą teraz korzystać z 3 tkanin:

  1. Tkanina Lokalna Android.
  2. Tkanina programistyczna (ta aplikacja).
  3. Trzecia tkanina, której właśnie udostępniasz urządzenie.

8. Następne kroki

Gratulacje

Gratulacje. To ćwiczenie z programowania zostało ukończone. Wiesz już, jak udostępniać urządzenia i udostępniać je za pomocą pakietu SDK Home Mobile.

Jeśli masz problemy z aplikacją próbną, wykonaj te czynności, aby zweryfikować swoje środowisko:

Jeśli masz pytania dotyczące korzystania z przykładowej aplikacji lub odkryjesz błąd kodu, możesz zgłosić problemy do narzędzia Issue Tracker w repozytorium GitHub:

Aby uzyskać oficjalne wskazówki od Google w kwestiach technicznych, odwiedź forum dla deweloperów dotyczące inteligentnego domu:

Aby uzyskać pomoc techniczną od społeczności, użyj tagu google-smart-home na stronie Stack Overflow: