Utwórz aplikację na Androida o sprawach

1. Witamy

Aplikacja Matter powstała z myślą o ujednoliceniu standardów IoT, dlatego łą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 tworzyć własne aplikacje na Androida do obsługi urządzeń ze standardem Matter, możemy Ci pomóc szybko rozpocząć pracę.

Przykładowa aplikacja Google Home dla standardu Matter przedstawia interfejsy API pakietu Home Mobile SDK, które umożliwiają użytkownikom korzystanie z urządzeń i ich udostępnianie. Możesz też użyć tej aplikacji jako narzędzia do nauki, aby lepiej zrozumieć kluczowe pojęcia standardu Matter, a także narzędzia do debugowania i rozwiązywania problemów z interakcjami na urządzeniach Matter.

Jakie zadania wykonasz

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

Gdy pobierzesz przykładową aplikację, sprawdzimy jej kod źródłowy w Android Studio i wdrożymy te interfejsy API pakietu Home Mobile SDK:

Poznasz też zagadnienia związane ze zlecaniem, tkaniny Matter i sterowanie urządzeniami Matter.

Czego potrzebujesz

Zanim zaczniesz, wykonaj te czynności:

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

2. Konfiguracja

Aplikacja startowa do ćwiczeń z programowania znajduje się w gałęzi codelab. Aby rozpocząć pracę z kodem źródłowym ćwiczeń z programowania, możesz pobrać plik ZIP.

Użyj tego pliku ZIP codelab do utworzenia działającego przykładu.

Wersje ćwiczeń z programowania

Gałąź codelab jest oznaczona tagiem wersji 2.0.0 przykładowej aplikacji. Aby porównywać aktualizacje w trakcie wykonywania poszczególnych kroków, możesz pobrać kompletny kod źródłowy tej wersji.

Jeśli chcesz sklonować repozytorium GitHub, postępuj zgodnie z instrukcjami z artykułu README przykładowej aplikacji.

Zależności

Przeprowadzimy Cię przez kod źródłowy wymagany do udostępniania urządzeń i prowizowania ich, ale zanim zaczniesz z nich korzystać, warto wiedzieć o tych zależnościach. Pamiętaj, że te zależności są zadeklarowane w pliku libs.versions.toml, a ich wykorzystanie jest określone w pliku build.gradle.kts

Kod źródłowy

Interfejs i większość funkcji zostały już utworzone.

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

  • java/commissioning/AppCommissioningService: umożliwia zlecanie urządzeń w środowisku programistycznym
  • java/screens/home/HomeScreen i java/screens/home/HomeViewModel.kt: obejmuje funkcję uruchamiania pakietu SDK Home Mobile SDK
  • java/screens/device/DeviceScreen i java/screens/device/DeviceViewModel: obejmuje wywołania interfejsu Share Device API

Każdy plik jest komentowany blokiem kodu, który chcesz zmodyfikować, 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 zezwalać im na komunikowanie się ze sobą w tej samej tkaninie, musi zostać zlecone przez komisarza – w tym przypadku jest to przykładowa aplikacja Google Home Sample dla Matter.

Należy znać następujące pojęcia dotyczące zlecania standardu Matter:

  • Tkaniny pozwalają urządzeniom komunikować się ze sobą.
  • Fabrics utrzymuje 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 świadcząca usługi świadczone przez komisarza. Przykładem może być Home Graph w przypadku ekosystemu Google Home.
  • Urządzenia można zlecać w przypadku więcej niż jednej tkaniny (funkcja z obsługą wielu administratorów).

Aby uruchomić zlecenie urządzenia, należy użyć interfejsu CommissioningClient API. Wywołanie .commissionDevice() zwraca intencję IntentSender, która uruchamia odpowiednie działanie w Usługach Google Play:

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

W kolejnych sekcjach omówimy minimalny kod wymagany do przekazywania urządzeń do tkaniny Google.

Krok 1. Menu z aplikacjami

Aby obsłużyć IntentSender z CommissioningClient, możesz użyć elementu 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 uruchamiania

Oto podstawowy przykład, w którym interfejs API CommissioningClient służy do zlecania urządzenia w sztuce Google.

  1. Proces wprowadzania na rynek zaczyna się od funkcji commissionDevice(). Najpierw zdefiniowany jest element CommissioningRequest. W tej konfiguracji domyślnej urządzenia są zamawiane tylko w lokalnej tkaninie Androida.
  2. Matter to punkt wejścia pakietu SDK Home Mobile. W następnej rozmowie .getCommissioningClient uzyskuje zlecenie klienta na platformie this (działanie).
  3. .commissionDevice() akceptuje CommissioningRequest.
  4. Na koniec firma .addOnSuccessListener otrzymała prośbę o przetworzenie CommissioningResult i uruchomienie aktywności na urządzeniu prowizji w Usługach 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())
        }
}

Usługę Local Android Fabric można wykorzystać w ustawieniach Androida, aby uprościć proces uruchamiania urządzeń w innych tkaninach.

W dalszej kolejności dowiesz się, jak zlecić urządzenie w tkanin programistycznej.

Omówienie interfejsu użytkownika podczas procesu uruchamiania znajdziesz w przewodniku po przykładowej aplikacji Google Home na potrzeby standardu Matter.

4. Prowizja od strony programistycznej

Urządzenia można zlecać dla więcej niż 1 tkaniny. Aby zarządzać zaufanymi parami, urządzenia przechowują element FabricTable zawierający różnych użytkowników FabricInfo, na przykład:

  • Identyfikacja tkaniny
  • Identyfikator węzła przypisany przez tkaninę do urządzenia
  • Identyfikator dostawcy
  • Identyfikator tkaniny
  • Dane uwierzytelniające operacyjne urządzenia

Administracyjny menedżer domeny (ADM) definiuje dane logowania do sieci szkieletowej. W poprzednim scenariuszu Usługi Google Play to ekosystem działający jako zaufany główny urząd certyfikacji (CA). Gdy przekażesz urządzenia do lokalnej tkaniny systemu Android, każde urządzenie będzie miało ten sam zestaw danych logowania do sieci tkanin i ten sam zestaw urzędów certyfikacji.

Niestandardowe usługi serwisowe

Aby zrealizować zlecenie na rzecz lokalnej tkaniny na Androida, użyliśmy domyślnych parametrów do utworzenia 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ą tkaninę programistyczną i uzyskać dane uwierzytelniające do zarządzania urządzeniami. W takim przypadku aplikacja staje się unikalnym, niezależnym ekosystemem, który przypisuje do urządzeń odpowiednie dane logowania do węzła.

Możesz poinformować pakiet SDK Home Mobile, że chcesz zlecać urządzenia we własnej szkieletie, przekazując do interfejsu CommissioningRequest usługę niestandardową:

class CommissioningRequest {
  static CommissioningRequest.Builder builder();

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

    CommissioningRequest build();
  }
}

W następnych krokach zmodyfikujemy funkcję commissionDevice(), aby używała usługi niestandardowej. Dodamy też do fragmentu strony głównej Menu z aplikacjami do aktywności i użyjemy obiektów LiveData do zarządzania przepływem danych w interfejsie API.

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

Najpierw utwórzmy Menu z aplikacjami do obsługi poleceń IntentSender z interfejsu CommissioningClient API.

  1. Otwórz plik HomeScreen w folderze java/screens/home/.
  2. Zastąp komentarz // CODELAB: commissionDeviceLauncher definition tym kodem, aby zarejestrować i przetwarzać wynik działania polegającego na zleceniu:
    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. Aktywuj działanie urządzenia objęte prowizją

W tym kroku użytkownik aktywuje działanie „Urządzenie do przesyłania prowizji”, klikając przycisk „+” w prawym dolnym rogu ekranu głównego. Następnie nawiązujemy połączenie pod numer commissionDevice().

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

Krok 3. Wywołaj interfejs API

  1. Pozostają w folderze HomeScreen.kt w folderze java/screens/home/.
  2. Zastąp komentarz // CODELAB: commissionDevice następującym komentarzem commissionDeviceRequest. setCommissioningService wiąże AppCommissioningService z instancją CommissioningService, która została zwrócona w ramach funkcji wywołania zwrotnego. Gdy przekażesz usługę niestandardową, pakiet SDK Home Mobile najpierw przekieruje urządzenia do lokalnej sieci szkieletowej Androida, a następnie prześle ładunek powitalny z powrotem do: AppCommissioningService.
    val commissionDeviceRequest =
    CommissioningRequest.builder()
        .setCommissioningService(ComponentName(
            context, AppCommissioningService::class.java))
        .build()
  3. Zadzwoń pod numer .getCommissioningClient(), a następnie zadzwoń pod numer .commissionDevice().
Matter.getCommissioningClient(context)
    .commissionDevice(commissionDeviceRequest)

Aby zakończyć działanie funkcji commissionDevice, dodaj addOnSuccessListener i addOnFailureListener:

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

5. Tworzenie usługi CommissioningService

Funkcja commissionDevice() zażądała pobrania usługi CommissioningService z interfejsu CommissioningClient API. W tym procesie interfejs CommissioningClient API najpierw przydziela urządzenia do lokalnej tkaniny na Androida, a potem zwraca wywołanie zwrotne zawierające obiekt CommissioningRequestMetadata:

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

Teraz musimy odziedziczyć usługę CommissioningService.Callback i udostępnić funkcje niezbędne do obsługi 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. Zapoznaj się z niestandardową usługą AppCommissioningService

Aby ułatwić Ci rozpoczęcie pracy, zdefiniowaliśmy podstawową strukturę klas dla naszej niestandardowej usługi CommissioningService. Poniżej znajduje się krótki przegląd funkcji tej usługi. Aby kontynuować, otwórz aplikację AppCommissioningService w aplikacji java/commissioning.

Dodaliśmy następujące operacje importu dla interfejsów API pakietu 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 zawiera też biblioteki z repozytorium Matter (connectedhomeip):

import com.google.home_sample_app_for_matter.chip.ChipClient

Usługa obejmuje też operacje importu na potrzeby współprogramów Hilt i Kotlin.

Następnie tworzymy konstruktor i konfigurujemy kilka elementów, w tym commissioningServiceDelegate, którego użyjemy, aby poinformować Usługi Google Play o zakończeniu realizacji zlecenia.

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

Teraz czas na dodanie funkcji zlecania.

Krok 2. Zastąp żądanie w sprawie zamówionych usług

Aby przesłać urządzenia do aplikacji deweloperskiej aplikacji, wykonaj te czynności:

  1. Otwórz: AppCommissioningService w aplikacji java/commissioning.
  2. Znajdź funkcję onCommissioningRequested(). Dostępny jest komunikat logu wraz z plikiem CommissioningRequestMetadata. Zastąp komentarz // CODELAB: onCommissioningRequested(), aby uruchomić współprogram serviceScope i uzyskać deviceId.
    // Perform commissioning on custom fabric for the sample app.
serviceScope.launch {
  val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
  3. Uruchomienie. Na tym etapie możemy przekazać informacje o urządzeniu zwrócone w obiekcie CommissioningRequestMetadata. ChipClient wykorzystuje te informacje o metadanych do tworzenia bezpiecznego kanału między aplikacją GHSA for 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. Aby poinformować Usługi Google Play, że ukończono wdrażanie, użyj commissioningServiceDelegate. W .sendCommissioningComplete(): dodaj 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ę

Teraz gdy masz już cały wymagany kod i możesz zlecić usługę naszej lokalnej tkaninie, nadszedł czas na jego przetestowanie. Wybierz urządzenie z Androidem i uruchom aplikację. Na ekranie głównym kliknij Dodaj urządzenie i postępuj zgodnie z instrukcjami, aby udostępnić urządzenie do użytku.

Po zakończeniu zlecania urządzenie jest sprzedawane w 2 materiałach: lokalnej tkaninie Androida i tkanin dla lokalnych programistów. Każda tkanina ma własny zestaw danych logowania i unikalny 64-bitowy identyfikator tkaniny.

6. Sterowanie urządzeniami

Zamówienie tkanin programistycznych pozwala używać bibliotek z repozytorium spraw (connectedhomeip) do sterowania urządzeniami z przykładowej aplikacji.

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

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

Możemy użyć tych zajęć, aby skonfigurować klaster włączania i wyłączania dla urządzenia, a następnie zadzwonić pod numer .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 elemencie CommissioningResult jest dodawany do DataStore. Daje to aplikacji dostęp do informacji z urządzenia, których możemy używać do wysyłania poleceń.

Aplikacje Matter są oparte na zdarzeniach. Po zainicjowaniu stosu Matter usługi klastra nasłuchują wiadomości przychodzących. Po uruchomieniu urządzenia klienci Matter wysyłają polecenia przez bezpieczny kanał operacyjny utworzony podczas uruchamiania urządzenia.

Na urządzeniu pakiety są weryfikowane, odszyfrowywane, a następnie wysyłane w ramach wywołania zwrotnego. Do funkcji wywołania zwrotnego należą parametry EndpointId, ClusterId oraz AttributeId dostępne z poziomu interfejsu attributePath. Ten kod można zaimplementować na przykład na urządzeniu 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 SDK Matter i ClustersHelper, aby przełączać urządzenie.

  1. Przejdź do DeviceViewModel w java/screens/device.
  2. Znajdź funkcję updateDeviceStateOn.
  3. Zastąp komentarz // CODELAB: toggle kodem wywołującym metodę 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. Na ekranie głównym możesz włączać i wyłączać urządzenie.

7. Udostępniaj urządzenia innym ekosystemom

W specyfikacji standard Matter udostępnienie urządzenia jest określane jako proces z wieloma administratorami.

W poprzednich krokach dowiedzieliśmy się, że pakiet SDK do aplikacji mobilnych pozwala zamawiać urządzenia do lokalnej tkaniny systemu Android, a także do tkanin programistycznych dla przykładowej aplikacji. Jest to przykład przepływu pracy wielu administratorów, w którym urządzenia można zlecać w więcej niż jednej tkaninie.

Teraz być może będziesz chcieć udostępniać urządzenia jeszcze większej liczbie tkanin, zwłaszcza jeśli w tym domu użytkownicy mają własne preferencje dotyczące aplikacji i platform.

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

  1. Otwórz tymczasowe okno uruchamiania urządzeń.
  2. Możesz zmieniać stan urządzeń, umożliwiając ich zlecenie w innej tkaninie.
  3. Steruj urządzeniami za pomocą innych aplikacji i ekosystemów.

W następnych krokach do udostępniania urządzeń użyjesz pakietu SDK do urządzeń mobilnych.

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

Podobnie jak w przypadku programu uruchamiającego działania związane z przekazywaniem, który utworzyliśmy na zamówienie materiału programistycznego, opracowaliśmy także Menu z aplikacjami na potrzeby udostępniania aktywności na urządzeniu do obsługi aplikacji IntentSender z interfejsu API CommissioningClient.

  1. Otwórz plik DeviceScreen w folderze java/screens/device/.
  2. Zastąp komentarz // CODELAB: shareDeviceLauncher definition tym kodem, aby zarejestrować i obsługiwać wynik dotyczący aktywności w .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 działanie „Udostępnij urządzenie”, klikając przycisk „Udostępnij” na ekranie urządzenia. Następnie nawiążemy połączenie z numerem deviceViewModel, aby otworzyć okno parowania na potrzeby udostępnienia urządzenia.

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

Po pomyślnym otwarciu okna porównywania, deviceViewModel przekazuje ten fakt do interfejsu. 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 obiektu StateFlow DeviceScreen wykonuje to wywołanie:

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

Krok 3. Wywołaj interfejs API

Czas rozpocząć zadanie związane z udostępnianiem urządzenia.

  1. Otwórz plik DeviceScreen.kt w folderze java/screens/device/.
  2. Znajdź funkcję shareDevice(). Zastąp komentarz // CODELAB: shareDevice komentarzem ShareDeviceRequest. DeviceDescriptor zawiera konkretne informacje o urządzeniu, takie jak identyfikator dostawcy, identyfikator produktu i typ urządzenia. W tym przykładzie wartości są na stałe zakodowane.
    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 commissioningClient.shareDevice() API udostępnia obiekt IntentSender służący do uruchamiania aktywności na urządzeniu w Usługach Google Play.

  1. Aby dokończyć działanie funkcji shareDevice, dodaj addOnSuccessListener i addOnFailureListener. Po zakończeniu operacji aplikacja launch zostaje wywołana 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 ze standardem Matter innym ekosystemom, musisz mieć zainstalowaną inną platformę na urządzeniu z Androidem. Utworzyliśmy kolejne wystąpienie przykładowej aplikacji, którego możesz użyć jako docelowego komisarza.

Gdy na urządzeniu z Androidem będzie zainstalowany docelowy komisarz, sprawdź, czy możesz udostępnić urządzenie Matter. Docelowa aplikacja komisji jest oznaczona etykietą GHSAFM-TC.

Twoje urządzenia mogą być teraz wyświetlane w 3 tkaninach:

  1. Lokalna tkanina Androida
  2. Twoja tkanina programowa (ta aplikacja).
  3. To trzecia tkanina, której właśnie udostępniasz urządzenie.

8. Dalsze kroki

Gratulacje

Gratulujemy! Udało Ci się ukończyć ćwiczenia z programowania oraz nauczyć się, jak zamawiać urządzenia i udostępniać je za pomocą pakietu SDK do urządzeń mobilnych.

Jeśli masz problemy z przykładową aplikacją, wykonaj te czynności, aby zweryfikować swoje środowisko:

Jeśli masz pytania dotyczące korzystania z przykładowej aplikacji lub znajdujesz błąd w kodzie, możesz zgłosić problemy za pomocą narzędzia Issue Tracker, które znajduje się w repozytorium GitHub:

Jeśli chcesz uzyskać od Google oficjalne wskazówki dotyczące pytań technicznych, odwiedź forum dla deweloperów związanych z inteligentnymi domami:

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