Compilar una app de Android para Matter

1. Te damos la bienvenida

Creado con el objetivo de unificar los estándares de IoT, Matter conecta dispositivos inteligentes para la casa en varios ecosistemas, como Google Home, Zigbee, Bluetooth Mesh, Z-Wave y muchos más.

Los dispositivos móviles son un punto de interacción central con los dispositivos inteligentes para la casa. Si quieres compilar tus propias apps para Android que admitan 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, lo que permite a los usuarios poner en servicio 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 para depurar y solucionar problemas de interacciones con dispositivos Matter.

Actividades

En este codelab, descargarás el código fuente de la app de ejemplo y aprenderás a usar el SDK de Home Mobile para habilitar y compartir dispositivos. También aprenderás a usar las bibliotecas de puesta en marcha y 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 Mobile:

También aprenderás más sobre los conceptos de puesta en marcha, las estructuras de Matter y cómo controlar los dispositivos Matter.

Requisitos

Antes de comenzar, asegúrate de completar los siguientes pasos:

No necesitas una unidad central, por ejemplo, un Google Nest Hub (2ª gen.), para poner en funcionamiento 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 codelab ZIP para compilar una muestra de trabajo.

Versiones de codelabs

La rama codelab se etiquetó con la versión 2.0.0 de la app de ejemplo. Para comparar tus 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 README de la app de ejemplo.

Dependencias

Te guiaremos por el código fuente necesario para compartir y encargar dispositivos, pero puede ser útil que conozcas 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.

Código fuente

Ya se creó la interfaz de usuario y la mayoría de las funciones.

En este codelab, agregaremos la funcionalidad de Matter a los siguientes archivos:

  • java/com/google/homesampleapp/commissioning/AppCommissioningService: Te permite comisionar dispositivos en la estructura de desarrollo.
  • java/com/google/homesampleapp/screens/home/HomeScreen y java/com/google/homesampleapp/screens/home/HomeViewModel.kt: Incluyen la funcionalidad de puesta en servicio del SDK de Home para dispositivos móviles
  • java/com/google/homesampleapp/screens/device/DeviceScreen y java/com/google/homesampleapp/screens/device/DeviceViewModel: Incluye las llamadas a la API de Share Device

Cada archivo tiene comentarios con el bloque de código que modificarás, por ejemplo:

// CODELAB: add commissioningFunction()

Esto te permite ubicar 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, un comisionado debe ponerlos en funcionamiento, 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 puesta en servicio de Matter:

  • Los fabrics permiten que los dispositivos se comuniquen entre sí.
  • Los fabrics 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 comisionista, por ejemplo, Home Graph para el ecosistema de Google Home.
  • Los dispositivos se pueden poner en servicio en más de un tejido (función de varios administradores).

Para poner en servicio un dispositivo, deberás usar la API de CommissioningClient. Una llamada a .commissionDevice() devuelve un IntentSender, que inicia la actividad adecuada en los Servicios de Google Play:

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

En las próximas secciones, analizaremos el código mínimo necesario para habilitar dispositivos en la estructura de Google.

Paso 1: Activity Launcher

Para controlar el IntentSender del 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 puesta en marcha

Este es un ejemplo básico que usa la API de CommissioningClient para habilitar un dispositivo en la estructura de Google.

  1. El proceso de puesta en marcha comienza con la función commissionDevice(). Primero, se define un CommissioningRequest. Con esta configuración predeterminada, los dispositivos solo se habilitan para la estructura de Android local.
  2. Matter es el punto de entrada del SDK de Home para dispositivos móviles. En la siguiente llamada, .getCommissioningClient obtiene un CommissioningClient por this (Activity).
  3. .commissionDevice() acepta el CommissioningRequest.
  4. Por último, se llama a .addOnSuccessListener para procesar el CommissioningResult y, luego, se inicia la actividad Commission Device 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())
        }
}

La estructura local de Android se puede aprovechar a través de la configuración de Android para simplificar el proceso de puesta en servicio de sus dispositivos en otras estructuras.

A continuación, aprenderás a encargar un dispositivo para una estructura de desarrollo.

Para obtener una descripción general de la interfaz de usuario durante el proceso de puesta en marcha, consulta la Guía de la app de ejemplo de Google Home para Matter.

4. Asignación de credenciales a un entorno de desarrollo

Los dispositivos se pueden poner en servicio en más de un tejido. Para administrar los vinculaciones de confianza, los dispositivos almacenan un objeto FabricTable que contiene varios miembros FabricInfo, por ejemplo:

  • Identificación de la tela
  • Es el ID de nodo que la estructura asigna 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 la situación anterior, los Servicios de Google Play son el ecosistema que actúa como una autoridad certificadora (CA) raíz de confianza. Cuando pones en servicio dispositivos en la estructura local de Android, cada dispositivo incluye el mismo conjunto de credenciales de estructura y el mismo conjunto de entidades certificadoras.

Servicios de puesta en marcha personalizados

Para encargar la estructura de Local Android, usamos los parámetros predeterminados para 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 un tejido de desarrollo local y obtener las credenciales operativas para poner en funcionamiento los dispositivos. En esta situación, tu app se convierte en un ecosistema único e independiente que asigna a los dispositivos las credenciales de nodo adecuadas.

Puedes informar al SDK de Home Mobile que deseas comisionar 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 siguientes pasos, modificaremos la función commissionDevice() para usar un servicio personalizado. También agregaremos un selector de actividades al fragmento Home y usaremos objetos LiveData para administrar el flujo de la API.

Paso 1: Crea un GPS Activity Launcher

Primero, creemos un selector de actividad para controlar el IntentSender de la API de CommissioningClient.

  1. Abre HomeScreen en la carpeta java/com/google/homesampleapp/screens/home/.
  2. Reemplaza el comentario // CODELAB: commissionDeviceLauncher definition por el siguiente código para registrar y controlar el resultado de la actividad de puesta en marcha:
    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 del dispositivo de comisión

En este paso, el usuario activa la acción "Commission Device" haciendo clic en el botón "+" que se encuentra en la parte inferior derecha de la pantalla principal. Luego, se realiza una llamada a commissionDevice().

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

Paso 3: Llama a la API

  1. Aún en HomeScreen.kt en la carpeta java/com/google/homesampleapp/screens/home
  2. Reemplaza el comentario // CODELAB: commissionDevice por el siguiente commissionDeviceRequest. setCommissioningService vincula AppCommissioningService a una instancia de CommissioningService, que se devuelve en una función de devolución de llamada. Cuando pasas un servicio personalizado, el SDK de Home Mobile primero comisiona los dispositivos en la estructura local de Android y, luego, envía la carga útil de incorporación a AppCommissioningService.
    val commissionDeviceRequest =
    CommissioningRequest.builder()
        .setCommissioningService(ComponentName(
            context, AppCommissioningService::class.java))
        .build()
  3. Llama a .getCommissioningClient() y, luego, a .commissionDevice().
Matter.getCommissioningClient(context)
    .commissionDevice(commissionDeviceRequest)

Para completar nuestra función commissionDevice, agrega un addOnSuccessListener y un addOnFailureListener:

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

5. Crea un servicio de puesta en marcha

En la función commissionDevice(), solicitamos obtener un CommissioningService de la API de CommissioningClient. En este flujo, la API de CommissioningClient primero pone en servicio los dispositivos en la estructura local de Android y, luego, devuelve 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 poner en servicio dispositivos en nuestra app de ejemplo. A continuación, se muestra 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 para nuestro CommissioningService personalizado. A continuación, se incluye una breve descripción general de la funcionalidad 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.homesampleapp.chip.ChipClient

Por último, el servicio incluye importaciones para admitir Hilt y corrutinas de Kotlin.

A continuación, creamos el constructor y configuramos algunas cosas, incluido el 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 momento de agregar las funciones de puesta en marcha.

Paso 2: Anula onCommissioningRequested

Para habilitar dispositivos en la estructura de desarrollo de la app, completa los siguientes pasos:

  1. Abre AppCommissioningService en java/commissioning.
  2. Ubica la función onCommissioningRequested(). Proporcionamos un mensaje de registro que imprime el CommissioningRequestMetadata. Reemplaza el comentario // CODELAB: onCommissioningRequested() para iniciar la corrutina serviceScope y obtener el deviceId.
    // Perform commissioning on custom fabric for the sample app.
serviceScope.launch {
  val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
  3. Realiza la puesta en marcha. Para este paso, podemos pasar la información del dispositivo que se devolvió en el objeto CommissioningRequestMetadata. El ChipClient usa esta información de metadatos para crear un canal seguro entre la app de GHSA para 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
}
  4. Usa 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 ya tenemos todo el código necesario para habilitar la comisión en nuestra estructura 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 poner en funcionamiento el dispositivo.

Cuando se complete la puesta en servicio, tu dispositivo participará en dos estructuras: la estructura local de Android y la estructura de desarrollo local. Cada estructura tiene su propio conjunto de credenciales y un ID de estructura único de 64 bits.

6. Controla dispositivos

La puesta en servicio en un tejido de desarrollo te permite usar las bibliotecas del repo de Matter (connectedhomeip) para controlar dispositivos desde la app de ejemplo.

Creamos algunas clases de asistente para facilitar el acceso a los clústeres de dispositivos y el envío de comandos. Para obtener más información, abre ClustersHelper en java/clusters. Este asistente 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/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)
              }
            })
  }
}

Cómo activar o desactivar un dispositivo

Después de que pones en servicio un dispositivo, la carga útil que se devuelve en CommissioningResult se agrega a DataStore. Esto le da a nuestra app acceso a la información del dispositivo que podemos usar para enviar comandos.

Las apps de Matter se basan en eventos. Cuando se inicializa la pila de Matter, los servicios de clúster escuchan los mensajes entrantes. Una vez que se pone en servicio un dispositivo, los clientes de Matter envían comandos a través del canal operativo seguro que se estableció durante la puesta en servicio 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.

  1. Ve a DeviceViewModel en java/screens/device.
  2. Ubica la función updateDeviceStateOn.
  3. Reemplaza el comentario // CODELAB: toggle por el código para llamar a clustersHelper 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")
    }

Se llama a esta función 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 tus actualizaciones. En la pantalla principal, activa y desactiva el dispositivo.

7. Comparte dispositivos con otros ecosistemas

En la especificación de Matter, el uso compartido de un dispositivo se conoce como flujo de varios administradores.

En los pasos anteriores, aprendimos que el SDK de Home Mobile permite comisionar dispositivos en la estructura local de Android y también en 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 comisionar en más de una estructura.

Ahora, es posible que desees compartir dispositivos con aún más telas, especialmente si se trata de una casa en la que las personas tienen sus propias preferencias en cuanto a aplicaciones y plataformas.

El SDK de Home para dispositivos móviles proporciona esta funcionalidad en la API de ShareDeviceRequest, lo que te permite hacer lo siguiente:

  1. Abre una ventana de puesta en marcha temporal para los dispositivos.
  2. Cambia el estado de tus dispositivos para que se puedan poner en servicio en otra estructura.
  3. Controlar tus dispositivos desde otras apps y ecosistemas

En los próximos pasos, usarás el SDK de Home Mobile para compartir dispositivos.

Paso 1: Crea un GPS Activity Launcher

De manera similar al selector de actividades de puesta en servicio que creamos cuando pusimos en servicio un tejido de desarrollo, creamos un selector de actividades de uso compartido del dispositivo para controlar el IntentSender de la API de CommissioningClient.

  1. Abre DeviceScreen en la carpeta java/com/google/homesampleapp/screens/device/.
  2. Reemplaza el comentario // CODELAB: shareDeviceLauncher definition por el siguiente código para registrar y controlar el resultado de la actividad .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 el dispositivo

En este paso, el usuario activa la acción "Compartir dispositivo" haciendo clic en el botón "Compartir" en la pantalla del dispositivo. Luego, se realiza una llamada a deviceViewModel para abrir una ventana de vinculación para compartir el dispositivo.

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

Después de abrir correctamente la ventana de vinculación, deviceViewModel comunica ese hecho a la IU. La comunicación entre el 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 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 el momento de iniciar una tarea de compartir dispositivo.

  1. Abre DeviceScreen.kt en la carpeta java/com/google/homesampleapp/screens/device/.
  2. Ubica la función shareDevice(). Reemplaza el comentario // CODELAB: shareDevice por ShareDeviceRequest. El objeto DeviceDescriptor proporciona información específica sobre el dispositivo, como su ID de proveedor, ID de producto y tipo de dispositivo. En este ejemplo, codificamos los valores de forma rígida.
    val shareDeviceRequest =
  ShareDeviceRequest.builder()
    .setDeviceDescriptor(DeviceDescriptor.builder().build())
    .setDeviceName("GHSAFM temp device name")
  3. Establece los parámetros y CommissioningWindow.
        .setCommissioningWindow(
        CommissioningWindow.builder()
            .setDiscriminator(Discriminator.forLongValue(DISCRIMINATOR))
            .setPasscode(SETUP_PIN_CODE)
            .setWindowOpenMillis(SystemClock.elapsedRealtime())
            .setDurationSeconds(OPEN_COMMISSIONING_WINDOW_DURATION_SECONDS.toLong())
            .build())
    .build()
  4. 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 IntentSender que se usará para iniciar la actividad de Compartir dispositivo en los Servicios de Google Play.

  1. Para completar nuestra función shareDevice, agrega un addOnSuccessListener y un addOnFailureListener. Si la operación se realiza correctamente, se llama a launch en shareDeviceLauncher para iniciar la actividad de GPS para el uso compartido del 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 otra plataforma instalada en tu dispositivo Android. Creamos otra instancia de la app de ejemplo que puedes usar como comisionado objetivo.

Una vez que hayas instalado el comisionado de destino en tu dispositivo Android, verifica que puedas compartir tu dispositivo Matter. La app de comisionado de destino se etiqueta como GHSAFM-TC.

Ahora tus dispositivos pueden participar en tres estructuras:

  1. Es la estructura de Android local.
  2. Tu estructura de desarrollo (esta app).
  3. Esta es la tercera estructura que acabas de compartir con el dispositivo.

8. Próximos pasos

Felicitaciones

¡Felicitaciones! Completaste correctamente este codelab y aprendiste a habilitar 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, usa el foro de desarrolladores de Smart Home:

Para obtener asistencia técnica de la comunidad, usa la etiqueta google-smart-home en Stack Overflow: