Utwórz aplikację na Androida o sprawach

1. Witamy

Standard Matter został stworzony z myślą o ujednoliceniu standardów IoT. Umożliwia on łączenie inteligentnych urządzeń domowych w różnych ekosystemach, takich jak Google Home, Zigbee, Bluetooth Mesh, Z-Wave i inne.

Urządzenia mobilne są głównym punktem interakcji z inteligentnymi urządzeniami domowymi. Jeśli chcesz tworzyć własne aplikacje na Androida obsługujące urządzenia Matter, pomożemy Ci szybko zacząć.

Przykładowa aplikacja Google Home dla Matter (GHSA dla Matter) prezentuje interfejsy API pakietu Home Mobile SDK, które umożliwiają użytkownikom wdrażanie urządzeń i udostępnianie ich. Możesz też używać przykładowej aplikacji jako narzędzia do nauki, aby lepiej zrozumieć kluczowe koncepcje Matter, a także jako narzędzia do debugowania i rozwiązywania problemów z interakcjami z urządzeniami Matter.

Jakie zadania wykonasz

W tym module dowiesz się, jak pobrać kod źródłowy przykładowej aplikacji i używać pakietu Home Mobile SDK do wdrażania i udostępniania urządzeń. Dowiesz się też, jak korzystać z bibliotek uruchamiania i klastrów z repozytorium Matter (connectedhomeip).

Po pobraniu przykładowej aplikacji sprawdzimy kod źródłowy w Android Studio i wdrożymy te interfejsy API pakietu Home Mobile SDK:

Dowiesz się też więcej o koncepcjach związanych z uruchamianiem, platformach Matter i sterowaniu urządzeniami Matter.

Czego potrzebujesz

Zanim zaczniesz, wykonaj te czynności:

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

2. Konfiguracja

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

Użyjesz tego codelabpliku ZIP do utworzenia działającego przykładu.

Wersje ćwiczeń

Gałąź codelab jest oznaczona wersją 2.0.0 przykładowej aplikacji. Aby porównać swoje zmiany w trakcie wykonywania poszczególnych kroków, możesz pobrać gotowy kod źródłowy tej wersji.

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

Zależności

Przeprowadzimy Cię przez kod źródłowy wymagany do udostępniania urządzeń i ich uruchamiania, ale przed rozpoczęciem pracy warto zapoznać się z tymi zależnościami: Pamiętaj, że 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 użytkownika i większość funkcji zostały już utworzone.

W tym ćwiczeniu dodamy funkcje Matter do tych plików:

  • java/com/google/homesampleapp/commissioning/AppCommissioningService: umożliwia włączanie urządzeń do środowiska deweloperskiego;
  • java/com/google/homesampleapp/screens/home/HomeScreen i java/com/google/homesampleapp/screens/home/HomeViewModel.kt: zawiera funkcję uruchamiania pakietu Home Mobile SDK.
  • 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 opatrzony komentarzem z blokiem kodu, który będziesz modyfikować, np.:

// CODELAB: add commissioningFunction()

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

3. Prowizja dla Google

Zanim będzie można sterować urządzeniami i umożliwić im komunikację ze sobą w ramach tej samej struktury, muszą one zostać skonfigurowane przez konfiguratora, którym w tym przypadku jest ta przykładowa aplikacja – Google Home Sample App for Matter.

Ważne jest, aby znać te pojęcia związane z wdrażaniem Matter:

  • Tkaniny umożliwiają urządzeniom komunikację między sobą.
  • Tkaniny utrzymują wspólny zestaw unikalnych danych logowania.
  • Ekosystemy odpowiadają za wydawanie zaufanych certyfikatów głównych, przypisywanie identyfikatorów tkaniny i przypisywanie unikalnych identyfikatorów węzłów. Ekosystem to usługa backendu komisarza, np. Home Graph w ekosystemie Google Home.
  • Urządzenia mogą być przypisane do więcej niż jednej sieci (funkcja wielu administratorów).

Aby uruchomić urządzenie, musisz użyć interfejsu CommissioningClient API. Wywołanie funkcji .commissionDevice() zwraca obiekt 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 przekazania urządzeń do Google.

Krok 1. Uruchamianie aktywności

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, który używa interfejsu CommissioningClient API do przekazywania urządzenia do sieci Google.

  1. Proces uruchamiania rozpoczyna się od funkcji commissionDevice(). Najpierw definiuje się CommissioningRequest. W tej konfiguracji domyślnej urządzenia są wdrażane tylko w lokalnej sieci Androida.
  2. Matter to punkt wejścia do pakietu Home Mobile SDK. W kolejnym wywołaniu .getCommissioningClient uzyskuje CommissioningClient przez this (Activity).
  3. .commissionDevice() akceptuje CommissioningRequest.
  4. Na koniec wywoływana jest funkcja .addOnSuccessListener, która przetwarza CommissioningResult i uruchamia aktywność Commission Device 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())
        }
}

Lokalną strukturę Androida można wykorzystać w ustawieniach Androida, aby uprościć proces przekazywania urządzeń do innych struktur.

Następnie dowiesz się, jak włączyć urządzenie w środowisku deweloperskim.

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

4. Zlecenie opracowania materiału

Urządzenia można przypisać do więcej niż jednej sieci. Aby zarządzać zaufanymi parami, urządzenia przechowują FabricTable zawierający różne FabricInfo, na przykład:

  • Rozpoznawanie tkanin
  • Identyfikator węzła przypisany do urządzenia przez sieć.
  • Identyfikator dostawcy
  • Identyfikator tkaniny
  • Poświadczenia operacyjne urządzenia

Menedżer domeny administracyjnej (ADM) określa dane logowania sieci. W poprzednim scenariuszu Usługi Google Play są ekosystemem, który pełni rolę zaufanego głównego urzędu certyfikacji. Gdy włączasz urządzenia w lokalnej sieci Androida, każde z nich zawiera ten sam zestaw danych uwierzytelniających sieci i ten sam zestaw urzędów certyfikacji.

Usługi uruchamiania niestandardowego

Aby zlecić wdrożenie w lokalnej strukturze Androida, użyliśmy parametrów domyślnych 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ą platformę deweloperską i uzyskać dane uwierzytelniające do obsługi urządzeń. W takim przypadku aplikacja staje się unikalnym, niezależnym ekosystemem, który przypisuje urządzeniom odpowiednie dane logowania węzła.

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

class CommissioningRequest {
  static CommissioningRequest.Builder builder();

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

    CommissioningRequest build();
  }
}

W kolejnych krokach zmodyfikujemy funkcję commissionDevice(), aby używała usługi niestandardowej. Dodamy też do fragmentu głównego narzędzie Activity Launcher i będziemy używać obiektów LiveData do zarządzania przepływem interfejsu API.

Krok 1. Utwórz narzędzie do uruchamiania aktywności GPS

Najpierw utwórzmy narzędzie do uruchamiania aktywności, które będzie obsługiwać 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łużyć wynik działania związanego z uruchomieniem:
    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. Wywołaj działanie związane z uruchomieniem urządzenia

W tym kroku użytkownik wywołuje działanie „Uruchom urządzenie”, klikając przycisk „+” w prawym dolnym rogu ekranu głównego. Następnie zostanie wykonane połączenie z numerem commissionDevice().

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

Krok 3. Wywołaj interfejs API

  1. Nadal w HomeScreen.kt w folderze java/com/google/homesampleapp/screens/home.
  2. Zastąp komentarz // CODELAB: commissionDevice tym komentarzem: commissionDeviceRequest. setCommissioningService wiąże AppCommissioningService z instancją CommissioningService, która jest zwracana w funkcji wywołania zwrotnego. Gdy przejdziesz do usługi niestandardowej, pakiet Home Mobile SDK najpierw włączy urządzenia do lokalnej struktury Androida, a następnie wyśle z powrotem do AppCommissioningService ładunek wprowadzający.
    val commissionDeviceRequest =
    CommissioningRequest.builder()
        .setCommissioningService(ComponentName(
            context, AppCommissioningService::class.java))
        .build()
  3. Zadzwoń pod numer .getCommissioningClient(), a potem pod numer .commissionDevice().
Matter.getCommissioningClient(context)
    .commissionDevice(commissionDeviceRequest)

Aby dokończyć funkcję commissionDevice, dodaj addOnSuccessListener i addOnFailureListener:

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

5. Tworzenie usługi uruchamiania

W funkcji commissionDevice() wysłaliśmy prośbę o pobranie CommissioningService z interfejsu CommissioningClient API. W tym procesie interfejs CommissioningClient API najpierw wdraża urządzenia w lokalnej strukturze Androida, a potem zwraca wywołanie zwrotne, które zawiera obiekt CommissioningRequestMetadata:

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

Teraz musimy odziedziczyć CommissioningService.Callback i zapewnić funkcjonalność wymaganą do uruchamiania urządzeń w naszej przykładowej aplikacji. Oto przykład podstawowej implementacji 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 już podstawową strukturę klasy dla naszej niestandardowej usługi CommissioningService. Oto krótkie omówienie funkcji usługi. Aby kontynuować, otwórz AppCommissioningService w java/commissioning.

Dodaliśmy te importy do 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.homesampleapp.chip.ChipClient

Usługa obejmuje też importy do obsługi Hilta i rutyn współbieżnych 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 procesu.

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

Teraz nadszedł czas na dodanie funkcji uruchamiania.

Krok 2. Zastąp metodę onCommissioningRequested

Aby przekazać urządzenia do środowiska deweloperskiego aplikacji, wykonaj te czynności:

  1. Otwórz: AppCommissioningService w aplikacji java/commissioning.
  2. Znajdź funkcję onCommissioningRequested(). Podaliśmy komunikat logu, który wyświetla wartość 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. Przeprowadź uruchomienie. W tym kroku możemy przekazać informacje o urządzeniu zwrócone w obiekcie CommissioningRequestMetadata. ChipClient wykorzystuje te metadane do utworzenia bezpiecznego kanału między aplikacją GHSA for Matter a 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. Użyj commissioningServiceDelegate, aby poinformować usługi Google Play, że proces uruchamiania został zakończony. 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")
    }
}

Uruchamianie aplikacji

Teraz, gdy mamy już cały wymagany kod do uruchomienia lokalnej sieci, czas go przetestować. Wybierz urządzenie z Androidem i uruchom aplikację. Na ekranie głównym kliknij Dodaj urządzenie i wykonaj czynności, aby skonfigurować urządzenie.

Po zakończeniu procesu uruchamiania urządzenie będzie uczestniczyć w 2 sieciach: lokalnej sieci Androida i lokalnej sieci deweloperskiej. Każda sieć ma własny zestaw danych logowania i unikalny 64-bitowy identyfikator sieci.

6. Sterowanie urządzeniami

Wprowadzanie do sieci deweloperskiej umożliwia korzystanie z bibliotek z repozytorium Matter (connectedhomeip) do sterowania urządzeniami z poziomu aplikacji przykładowej.

Utworzyliśmy kilka klas pomocniczych, aby ułatwić dostęp do klastrów urządzeń i wysyłanie poleceń. Więcej informacji znajdziesz w ClustersHelper w java/clusters. Ten pomocniczy element Singleton importuje te biblioteki, aby uzyskać dostęp do informacji o urządzeniu:

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

Możemy użyć tej klasy, aby uzyskać klaster włączania/wyłączania urządzenia, a następnie wywołać .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łączanie urządzenia

Po uruchomieniu urządzenia ładunek zwrócony w CommissioningResult zostanie dodany do DataStore. Dzięki temu nasza aplikacja ma dostęp do informacji o urządzeniu, 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ą przychodzących wiadomości. Po uruchomieniu urządzenia klienty Matter wysyłają polecenia przez bezpieczny kanał operacyjny, który został utworzony podczas uruchamiania urządzenia.

Na urządzeniu pakiety są weryfikowane, odszyfrowywane, a następnie wysyłane z wywołaniem zwrotnym. Funkcje wywołania zwrotnego obejmują EndpointId, ClusterId i AttributeId, do których można uzyskać dostęp z poziomu attributePath. Ten kod można na przykład wdrożyć 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 kolejnych krokach użyjesz 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 // CODELAB: toggle komentarz kodem, aby wywołać clustersHelper, a potem 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)
}

Uruchamianie aplikacji

Uruchom aplikację, aby ponownie wczytać aktualizacje. Włączaj i wyłączaj urządzenie na ekranie głównym.

7. Udostępnianie urządzeń innym ekosystemom

Udostępnianie urządzenia jest w specyfikacji Matter określane jako proces z wieloma administratorami.

Z poprzednich kroków wiesz, że pakiet Home Mobile SDK umożliwia wdrażanie urządzeń w lokalnej strukturze Androida, a także w strukturze deweloperskiej na potrzeby aplikacji przykładowej. Jest to przykład przepływu z wieloma administratorami, w którym urządzenia można wdrażać w więcej niż 1 strukturze.

Możesz teraz udostępniać urządzenia jeszcze większej liczbie osób, zwłaszcza jeśli w domu każdy ma własne preferencje dotyczące aplikacji i platform.

Pakiet Home Mobile SDK udostępnia tę funkcję w interfejsie ShareDeviceRequest API, który umożliwia:

  1. Otwórz tymczasowe okno uruchamiania urządzeń.
  2. Zmień stan urządzeń, aby można było je przypisać do innej sieci.
  3. sterować urządzeniami z innych aplikacji i ekosystemów;

W kolejnych krokach użyjesz pakietu Home Mobile SDK do udostępniania urządzeń.

Krok 1. Utwórz narzędzie do uruchamiania aktywności GPS

Podobnie jak w przypadku narzędzia Commissioning Activity Launcher, które utworzyliśmy podczas wdrażania w środowisku deweloperskim, utworzyliśmy narzędzie Share Device Activity Launcher do obsługi IntentSender z interfejsu CommissioningClient API.

  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łużyć 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. Wywołaj działanie udostępniania urządzenia

W tym kroku użytkownik wywołuje działanie „Udostępnij urządzenie”, klikając przycisk „Udostępnij” na ekranie urządzenia. Następnie zostanie wykonane połączenie z deviceViewModel, aby otworzyć okno parowania na potrzeby udostępniania urządzenia.

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

Po otwarciu okna parowania deviceViewModel informuje o tym interfejs. Komunikacja między ViewModel a interfejsem użytkownika 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

Gdy DeviceScreen zauważy zmianę w obiekcie StateFlow, wykona to wywołanie:

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

Krok 3. Wywołaj interfejs API

Teraz czas na rozpoczęcie zadania 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 kodem ShareDeviceRequest. DeviceDescriptor zawiera szczegółowe informacje o urządzeniu, takie jak identyfikator dostawcy, identyfikator produktu i typ urządzenia. W tym przykładzie wartości są zakodowane 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(), ale tym razem użyj interfejsu API .shareDevice().
    Matter.getCommissioningClient(context)
    .shareDevice(shareDeviceRequest)

Wywołanie zwrotne w przypadku powodzenia interfejsu commissioningClient.shareDevice() API udostępnia obiekt IntentSender, który służy do uruchamiania funkcji Udostępnianie aktywności na urządzeniu w usługach Google Play.

  1. Aby dokończyć funkcję shareDevice, dodaj addOnSuccessListener i addOnFailureListener. Jeśli operacja się powiedzie, na urządzeniu shareDeviceLauncher wywoływana jest funkcja launch, 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())
    }

Uruchamianie aplikacji

Aby udostępnić urządzenie Matter innym ekosystemom, musisz mieć na urządzeniu z Androidem zainstalowaną inną platformę. Utworzyliśmy kolejne wystąpienie aplikacji przykładowej, którego możesz użyć jako komisarza docelowego.

Po zainstalowaniu na urządzeniu z Androidem aplikacji docelowej sprawdź, czy możesz udostępnić urządzenie Matter. Aplikacja komisarza docelowego jest oznaczona etykietą GHSAFM-TC.

Urządzenia mogą teraz uczestniczyć w 3 rodzajach sieci:

  1. Lokalna struktura Androida.
  2. Twoje środowisko programistyczne (ta aplikacja).
  3. To trzecia usługa, której właśnie udostępniasz urządzenie.

8. Następne kroki

Gratulacje

Gratulacje! Udało Ci się ukończyć ten Codelab i dowiedzieć się, jak włączać urządzenia i udostępniać je za pomocą pakietu Home Mobile SDK.

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

Jeśli masz pytania dotyczące korzystania z przykładowej aplikacji lub znajdziesz błąd w kodzie, możesz zgłosić problem w narzędziu Issue Tracker w repozytorium GitHub:

Aby uzyskać oficjalne wskazówki od Google dotyczące kwestii technicznych, skorzystaj z Forum dla deweloperów inteligentnego domu:

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