1. Bienvenida
Matter, creado con el objetivo de unificar los estándares de IoT, conecta dispositivos de casa inteligente en varios ecosistemas, como Google Home, Zigbee, Bluetooth Mesh, Z-Wave, entre otros.
Los dispositivos móviles son el punto de interacción central con los dispositivos de casa inteligente. Si quieres compilar tus propias apps para Android compatibles con dispositivos Matter, podemos ayudarte a comenzar rápidamente.
La app de ejemplo de Google Home para Matter (GHSA para Matter) muestra las APIs del SDK de Home Mobile, que permiten a los usuarios delegar y compartir dispositivos. También puedes usar la app de ejemplo como herramienta de aprendizaje para comprender mejor los conceptos clave de Matter, así como como herramienta para depurar y solucionar problemas de interacciones con dispositivos Matter.
Actividades
En este codelab, descargarás el código fuente para la app de ejemplo y aprenderás a usar el SDK de Home Mobile para asignar y compartir dispositivos. También aprenderás a usar las comisiones y las bibliotecas de clústeres del repositorio de Matter (connectedhomeip
).
Después de descargar la app de ejemplo, revisaremos el código fuente en Android Studio y, luego, implementaremos las siguientes APIs del SDK de Home para dispositivos móviles:
También obtendrás más información sobre los conceptos de comisión, las estructuras de Matter y cómo controlar los dispositivos Matter.
Requisitos
Antes de comenzar, asegúrate de completar los siguientes pasos:
- Consulta la Guía de ejemplo de la app de Google Home para Matter.
- Descarga Android Studio.
- Tener un dispositivo con Android O (8.1, nivel de API 27) o una versión posterior disponible para realizar pruebas Para asegurarte de que tu dispositivo cuente con la asistencia más reciente de Matter, consulta la guía Verifica módulos y servicios de Matter.
- Usar dispositivos Matter con funciones de encendido y apagado Para minimizar los problemas del entorno, te recomendamos que uses el dispositivo virtual de Matter (MVD) para comenzar. Si alguna vez tienes problemas, será mucho más fácil investigar si la app de ejemplo se usa con el MVD. Aquí presentamos otras opciones:
- Compila un dispositivo virtual de Matter con la app de
rootnode_dimmablelight_bCwGYSDpoe
. Cuando crees una integración de Matter en la consola para desarrolladores de Home, usa0xFFF1
como el ID del proveedor y0x8000
como el ID del producto. - Crea un dispositivo Espressif con el
all-clusters-app
. Cuando crees una integración de Matter en la consola para desarrolladores de Home, usa0xFFF1
como el ID del proveedor y0x8001
como el ID del producto.
- Compila un dispositivo virtual de Matter con la app de
- Consulta cómo configurar los Servicios de Google Play.
No necesitas una unidad central, por ejemplo, un Google Nest Hub (2a generación) para encargar y controlar dispositivos con la app de ejemplo.
2. Prepárate
La app de partida del codelab se encuentra en la rama codelab
. Para comenzar a trabajar con el código fuente del codelab, puedes descargar el archivo ZIP.
Usarás este archivo ZIP codelab
para compilar una muestra funcional.
Versiones del codelab
La rama codelab
está etiquetada con la versión 2.0.0 de la app de ejemplo. Para comparar las actualizaciones a medida que avanzas en cada paso, puedes descargar el código fuente completo de esta versión.
Si deseas clonar el repositorio de GitHub, sigue las instrucciones en el archivo README de la app de ejemplo.
Dependencias
Te guiaremos a través del código fuente necesario para compartir y comisionar dispositivos, pero podría resultar útil conocer las siguientes dependencias antes de comenzar. Ten en cuenta que estas dependencias se declaran en el archivo libs.versions.toml y su uso se especifica en el archivo build.gradle.kts.
- SDK de Home Mobile
- Bibliotecas del SDK de Matter:
- Jetpack Compose La IU se implementa por completo con Compose.
- Material Design Para obtener más información, consulta MDC-103 Android: Temas de Material con color, elevación y tipo (Kotlin) y Material Theme Builder.
- Proto Datastore, que se usa para conservar datos de apps Los repositorios y serializadores de Datastore se almacenan en
java/data
, incluidos los esquemas para los dispositivos y las preferencias del usuario. Para obtener más información sobre DataStore, consulta Cómo trabajar con Proto DataStore. - Hilt para conservar datos y admitir la inserción de dependencias.
Código fuente
La interfaz de usuario y la mayoría de las funciones ya están creadas para ti.
En este codelab, agregaremos la funcionalidad de Matter a los siguientes archivos:
java/commissioning/AppCommissioningService
: Te permite asignar dispositivos a la estructura de desarrollo.java/screens/home/HomeScreen
yjava/screens/home/HomeViewModel.kt
: Incluye la funcionalidad de comisión del SDK de Home Mobile.java/screens/device/DeviceScreen
yjava/screens/device/DeviceViewModel
: Incluyen las llamadas a la API de Share Device.
Cada archivo se comenta con el bloque de código que modificarás, por ejemplo:
// CODELAB: add commissioningFunction()
De esta manera, podrás encontrar rápidamente la sección correspondiente en el codelab.
3. Comisión para Google
Antes de que puedas controlar los dispositivos y permitir que se comuniquen entre sí dentro de la misma estructura, deben ser encargados por un comisionado, que en este caso es esta aplicación de ejemplo, la app de ejemplo de Google Home para Matter.
Es importante comprender los siguientes conceptos sobre la comisión de Matter:
- Las telas permiten que los dispositivos se comuniquen entre sí.
- Las telas mantienen un conjunto compartido de credenciales únicas.
- Los ecosistemas son responsables de emitir certificados raíz de confianza, asignar IDs de estructura y asignar IDs de nodo únicos. Un ecosistema es el servicio de backend de un comisionado, por ejemplo, Home Graph para el ecosistema de Google Home.
- Los dispositivos se pueden asignar a más de una estructura (función de administrador múltiple).
Debes usar la API de CommissioningClient para asignar un dispositivo. Una llamada a .commissionDevice()
muestra un IntentSender, que inicia la actividad correspondiente en los Servicios de Google Play:
interface CommissioningClient { Task<IntentSender> commissionDevice(CommissioningRequest request); }
En las siguientes secciones, repasaremos el código mínimo necesario para asignar dispositivos a la estructura de Google.
Paso 1: Selector de actividades
Para controlar el IntentSender
desde CommissioningClient
, puedes usar un 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) } }
Paso 2: Función de comisión
A continuación, te mostramos un ejemplo básico en el que se usa la API de CommissioningClient para asignar un dispositivo a la estructura de Google.
- El proceso de comisión comienza con la función
commissionDevice()
. Primero, se define unCommissioningRequest
. Con esta configuración predeterminada, los dispositivos se envían únicamente a la estructura local de Android. Matter
es el punto de entrada para el SDK de Home Mobile. En la siguiente llamada,.getCommissioningClient
obtiene un CommissioningClient dethis
(Activity)..commissionDevice()
acepta lasCommissioningRequest
.- Por último, se llama a
.addOnSuccessListener
para procesar elCommissioningResult
e iniciar la actividad de dispositivos de comisión de los Servicios de 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()) } }
Puedes aprovechar la Fabricación local de Android a través de la configuración de Android para simplificar el proceso de puesta en marcha de sus dispositivos para otras estructuras.
A continuación, aprenderás a asignar un dispositivo a una estructura de desarrollo.
Para obtener una descripción general de la interfaz de usuario durante el proceso de asignación, consulta la guía de ejemplo de la app de Google Home para Matter.
4. Comisión a un tejido de desarrollo
Los dispositivos se pueden encargar a más de una estructura. Para administrar la vinculación de confianza, los dispositivos almacenan un FabricTable
que contiene varios miembros de FabricInfo
, por ejemplo:
- Identificación de Fabric
- El ID de nodo que la tela asignó al dispositivo
- ID del proveedor
- ID de Fabric
- Credenciales operativas del dispositivo
El administrador de dominio administrativo (ADM) define las credenciales de la estructura. En el escenario anterior, los Servicios de Google Play son el ecosistema que actúa como una autoridad de certificación raíz (AC) confiable. Cuando asignas dispositivos a la estructura local de Android, cada uno incluye el mismo conjunto de credenciales de la estructura y el mismo conjunto de AC.
Servicios de comisión personalizada
Para realizar la comisión local de Android, usamos los parámetros predeterminados a fin de compilar el CommissioningRequest
en la API de CommissioningClient:
val request: CommissioningRequest = CommissioningRequest.builder().build()
Si quieres controlar y administrar dispositivos nuevos desde tu app, debes crear una estructura de desarrollo local y obtener las credenciales operativas para asignar dispositivos. En esta situación, tu app se convierte en un ecosistema independiente y único que asigna a los dispositivos las credenciales de nodo adecuadas.
Puedes informar al SDK de Home Mobile que quieres asignar dispositivos a tu propia estructura pasando un servicio personalizado a CommissioningRequest:
class CommissioningRequest { static CommissioningRequest.Builder builder(); class Builder { Builder setCommissioningService(@Nullable ComponentName commissioningService); CommissioningRequest build(); } }
En los próximos pasos, modificaremos la función commissionDevice()
para usar un servicio personalizado. También agregaremos un Selector de actividad al fragmento de Home y usaremos objetos LiveData para administrar el flujo de la API.
Paso 1: Crea un Selector de actividad de GPS
Primero, crearemos un Selector de actividad para controlar el IntentSender
desde la API de CommissioningClient.
- Abre
HomeScreen
en la carpetajava/screens/home/
. - Reemplaza el comentario
// CODELAB: commissionDeviceLauncher definition
por el siguiente código para registrar y controlar el resultado de la actividad de comisión: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) } }
Paso 2: Activa la acción de dispositivo de comisión
En este paso, el usuario debe hacer clic en el botón "+" en la parte inferior derecha de la pantalla principal para activar la acción "Commission Device". Luego, se realiza una llamada a commissionDevice()
.
val onCommissionDevice = { ... commissionDevice(activity!!.applicationContext, commissionDeviceLauncher) }
Paso 3: Llama a la API
- Todavía en
HomeScreen.kt
en la carpetajava/screens/home/
. - Reemplaza el comentario
// CODELAB: commissionDevice
con la siguientecommissionDeviceRequest
.setCommissioningService
vinculaAppCommissioningService
a una instancia deCommissioningService
, que se muestra en una función de devolución de llamada. Cuando pasas un servicio personalizado, el SDK de Home Mobile primero asigna los dispositivos a la estructura local de Android y, luego, envía la carga útil de integración aAppCommissioningService
.val commissionDeviceRequest = CommissioningRequest.builder() .setCommissioningService(ComponentName( context, AppCommissioningService::class.java)) .build()
- Llama a
.getCommissioningClient()
y, luego, a.commissionDevice()
.
Matter.getCommissioningClient(context) .commissionDevice(commissionDeviceRequest)
Para completar nuestra función commissionDevice
, agrega addOnSuccessListener
y addOnFailureListener
:
.addOnSuccessListener { result -> commissionDeviceLauncher.launch(IntentSenderRequest.Builder(result).build()) } .addOnFailureListener { error -> Timber.e(error) }
5. Crea un CommissioningService
En la función commissionDevice()
, solicitamos obtener un CommissioningService de la API de CommissioningClient. En este flujo, la API de CommissioningClient asigna dispositivos a la estructura local de Android primero y, luego, muestra una devolución de llamada que incluye el objeto CommissioningRequestMetadata:
public interface CommissioningService { interface Callback { void onCommissioningRequested(CommissioningRequestMetadata metadata); } }
Ahora, debemos heredar CommissioningService.Callback y proporcionar la funcionalidad necesaria para asignar dispositivos a nuestra app de ejemplo. Este es un ejemplo de una implementación básica de 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()) } }
Paso 1: Explora el AppCommissioningService personalizado
Para ayudarte a comenzar, ya definimos la estructura de clase básica de nuestro CommissioningService personalizado. A continuación, presentamos una descripción general rápida de la función del servicio. Para continuar, abre AppCommissioningService
en java/commissioning
.
Agregamos las siguientes importaciones para las APIs del SDK de Home Mobile:
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
también incluye bibliotecas del repositorio de Matter (connectedhomeip
):
import com.google.home_sample_app_for_matter.chip.ChipClient
Por último, el servicio incluye importaciones para admitir corrutinas de Hilt y Kotlin.
A continuación, creamos el constructor y configuramos algunas opciones, incluida la commissioningServiceDelegate
, que usaremos para informar a los Servicios de Google Play cuando se complete la comisión.
private lateinit var commissioningServiceDelegate: CommissioningService ... commissioningServiceDelegate = CommissioningService.Builder(this).setCallback(this).build()
Ahora es el momento de agregar las funciones de comisión.
Paso 2: Anula onCommissioningRequested
Para asignar dispositivos a la estructura de desarrollo de la app, completa los siguientes pasos:
- Abrir
AppCommissioningService
enjava/commissioning
. - Ubica la función
onCommissioningRequested()
. Proporcionamos un mensaje de registro que imprime elCommissioningRequestMetadata
. Reemplaza el comentario// CODELAB: onCommissioningRequested()
para iniciar la corrutinaserviceScope
y obtenerdeviceId
.// Perform commissioning on custom fabric for the sample app. serviceScope.launch { val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
- Realiza la asignación. Para este paso, podemos pasar la información del dispositivo que se muestra en el objeto CommissioningRequestMetadata. El
ChipClient
usa esta información de metadatos para crear un canal seguro entre la GHSA para la app de Matter y tu dispositivo.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 }
- Usa el
commissioningServiceDelegate
para informar a los Servicios de Google Play que se completó la comisión. En.sendCommissioningComplete()
, pasa 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") }
Ejecuta la app
Ahora que todo el código necesario está listo para la comisión local, es momento de probarlo. Elige tu dispositivo Android y ejecuta la app. En la pantalla principal, presiona Agregar dispositivo y completa los pasos para ponerlo en práctica.
Cuando se completa la comisión, tu dispositivo participa en dos estructuras: la estructura local de Android y la de desarrollo local. Cada tejido tiene su propio conjunto de credenciales y un ID de tejido único de 64 bits.
6. Controla dispositivos
La comisión a una estructura de desarrollo te permite usar las bibliotecas del repositorio de Matter (connectedhomeip
) para controlar los dispositivos de la app de ejemplo.
Creamos algunas clases auxiliares para que sea más fácil acceder a los clústeres del dispositivo y enviar comandos. Para obtener más información, abre ClustersHelper
en java/clusters
. Este ayudante de singleton importa las siguientes bibliotecas para acceder a la información del dispositivo:
import chip.devicecontroller.ChipClusters import chip.devicecontroller.ChipStructs
Podemos usar esta clase para obtener el clúster de encendido o apagado de un dispositivo y, luego, llamar 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) } }) } }
Activa o desactiva un dispositivo
Después de poner en marcha un dispositivo, la carga útil que se muestra en el CommissioningResult se agrega a DataStore. De esta manera, la app podrá acceder a la información del dispositivo que podemos usar para enviar comandos.
Las apps de Matter están controladas por eventos. Cuando se inicializa la pila de Matter, los servicios del clúster escuchan los mensajes entrantes. Una vez que se pone en marcha un dispositivo, los clientes de Matter envían comandos a través del canal operativo seguro que se estableció durante la puesta en marcha del dispositivo.
En el dispositivo, los paquetes se validan, se desencriptan y luego se envían con una devolución de llamada. Las funciones de devolución de llamada incluyen EndpointId, ClusterId y AttributeId, a los que se puede acceder desde attributePath
. Por ejemplo, este código se puede implementar en un dispositivo 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; }
En los próximos pasos, usarás el SDK de Matter y ClustersHelper
para activar o desactivar un dispositivo.
- Ve a
DeviceViewModel
enjava/screens/device
. - Ubica la función
updateDeviceStateOn
. - Reemplaza el comentario
// CODELAB: toggle
con el código para llamar aclustersHelper
y, luego, actualiza el repositorio del dispositivo: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") }
Esta función se llama desde DeviceScreen
:
// On/Off Switch click. val onOnOffClick: (value: Boolean) -> Unit = { value -> deviceViewModel.updateDeviceStateOn(deviceUiModel!!, value) }
Ejecuta la app
Ejecuta la app para volver a cargar las actualizaciones. En la pantalla principal, enciende y apaga el dispositivo.
7. Cómo compartir dispositivos con otros ecosistemas
Compartir un dispositivo se conoce como flujo de administración múltiple en la especificación de Matter.
En los pasos anteriores, aprendimos que el SDK de Home Mobile permite asignar dispositivos a la estructura local de Android y también a una estructura de desarrollo para la app de ejemplo. Este es un ejemplo de flujo de varios administradores, en el que los dispositivos se pueden asignar a más de una estructura.
Es posible que quieras compartir dispositivos con más telas, especialmente si es una familia en la que las personas tienen sus propias preferencias cuando se trata de aplicaciones y plataformas.
El SDK de Home Mobile proporciona esta funcionalidad en la API de ShareDeviceRequest, lo que te permite hacer lo siguiente:
- Abre un período de asignación temporal para los dispositivos.
- Cambia el estado de tus dispositivos para que se puedan asignar a otra estructura.
- Controla tus dispositivos de otras apps y ecosistemas.
En los próximos pasos, usarás el SDK de Home Mobile para compartir dispositivos.
Paso 1: Crea un Selector de actividad de GPS
De manera similar al selector de actividad de comisión que creamos cuando encargábamos una estructura de desarrollo, creamos un Launcher de actividad del dispositivo compartido para controlar el IntentSender
de la API de CommissioningClient.
- Abre
DeviceScreen
en la carpetajava/screens/device/
. - Reemplaza el comentario
// CODELAB: shareDeviceLauncher definition
por el siguiente código para registrar y controlar el resultado de la actividad de.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) } }
Paso 2: Activa la acción para compartir dispositivos
En este paso, el usuario hará clic en el botón "Compartir" de la pantalla del dispositivo para activar la acción "Compartir dispositivo". Luego, se realiza una llamada a deviceViewModel
para abrir una ventana de vinculación y compartir el dispositivo.
// Share Device button click. val onShareDevice: () -> Unit = { deviceViewModel.openPairingWindow(deviceUiModel!!.device.deviceId) }
Después de abrir correctamente la ventana de sincronización, deviceViewModel
comunica ese hecho a la IU. La comunicación entre ViewModel
y la IU se realiza a través de objetos StateFlow
.
// Communicate to the UI that the pairing window is open. // UI can then launch the GPS activity for device sharing. _pairingWindowOpenForDeviceSharing.value = true
Cuando se ve el cambio en el objeto StateFlow, DeviceScreen realiza la siguiente llamada:
shareDevice(activity!!.applicationContext, shareDeviceLauncher, deviceViewModel)
Paso 3: Llama a la API
Ahora es momento de iniciar una tarea para compartir el dispositivo.
- Abre
DeviceScreen.kt
en la carpetajava/screens/device/
. - Ubica la función
shareDevice()
. Reemplaza el comentario// CODELAB: shareDevice
porShareDeviceRequest
.DeviceDescriptor
proporciona información específica sobre el dispositivo, como su ID del proveedor, ID del producto y deviceType. En este ejemplo, los valores se codifican de forma rígida.val shareDeviceRequest = ShareDeviceRequest.builder() .setDeviceDescriptor(DeviceDescriptor.builder().build()) .setDeviceName("GHSAFM temp device name")
- Configura CommissioningWindow y los parámetros.
.setCommissioningWindow( CommissioningWindow.builder() .setDiscriminator(Discriminator.forLongValue(DISCRIMINATOR)) .setPasscode(SETUP_PIN_CODE) .setWindowOpenMillis(SystemClock.elapsedRealtime()) .setDurationSeconds(OPEN_COMMISSIONING_WINDOW_DURATION_SECONDS.toLong()) .build()) .build()
- Llama a
.getCommissioningClient()
, pero esta vez usa la API de.shareDevice()
.Matter.getCommissioningClient(context) .shareDevice(shareDeviceRequest)
La devolución de llamada de éxito de la API de commissioningClient.shareDevice()
proporciona el elemento IntentSender que se utilizará para iniciar la actividad del dispositivo compartido en los Servicios de Google Play.
- Para completar nuestra función
shareDevice
, agrega unaddOnSuccessListener
y unaddOnFailureListener
. Si se ejecuta de forma correcta, se llama alaunch
enshareDeviceLauncher
a fin de iniciar la actividad GPS para compartir el dispositivo..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()) }
Ejecuta la app
Para compartir tu dispositivo Matter con otros ecosistemas, deberás tener instalada otra plataforma en tu dispositivo Android. Creamos otra instancia de la app de ejemplo que puedes usar como comisión de destino.
Una vez que hayas instalado el encargado de destino en tu dispositivo Android, verifica que puedas compartir tu dispositivo Matter. La app del comisionado objetivo está etiquetada como GHSAFM-TC.
Tus dispositivos ahora pueden participar en tres estructuras:
- La estructura local de Android
- Tu estructura de desarrollo (esta app).
- Esta tercera estructura con la que acabas de compartir el dispositivo.
8. Próximos pasos
Felicitaciones
¡Felicitaciones! Completaste correctamente este codelab y aprendiste a asignar y compartir dispositivos con el SDK de Home Mobile.
Si tienes problemas con la app de ejemplo, intenta completar los pasos para verificar tu entorno:
Si tienes preguntas sobre el uso de la app de ejemplo o descubres un error de código, puedes enviar problemas a la Herramienta de seguimiento de errores en el repositorio de GitHub:
Para obtener orientación oficial de Google sobre preguntas técnicas, consulta el foro de desarrolladores de casas inteligentes:
Para obtener asistencia técnica de la comunidad, usa la etiqueta google-smart-home
en Stack Overflow: