Compilar una app de Android para Matter

1. Bienvenido

Matter se diseñó con el objetivo de unificar los estándares de la IoT y conecta los dispositivos de casa inteligente de diversos ecosistemas, como Google Home, Zigbee, Bluetooth Mesh, Z-Wave y muchos más.

Los dispositivos móviles son un punto central de interacción 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, lo que les permite a los usuarios asignar 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 interacciones con dispositivos Matter y solucionar problemas relacionados con ellas.

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 asignar y compartir dispositivos. También aprenderás a usar bibliotecas de comisiones y clústeres del repositorio de Matter (connectedhomeip).

Después de que descargues 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 obtendrás más información sobre los conceptos de comisión, las telas de Matter y cómo controlar los dispositivos de Matter.

Requisitos

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

No necesitas un concentrador, por ejemplo, un Google Nest Hub (2a generación), para asignar 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 que funcione.

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 quieres clonar el repositorio de GitHub, sigue las instrucciones del archivo README de la app de ejemplo.

Dependencias

Te guiaremos a través del código fuente necesario para compartir y asignar dispositivos, pero puede ser útil tener en cuenta 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

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/com/google/homesampleapp/commissioning/AppCommissioningService: Te permite asignar dispositivos a la estructura de desarrollo.
  • java/com/google/homesampleapp/screens/home/HomeScreen y java/com/google/homesampleapp/screens/home/HomeViewModel.kt: Incluye la función de asignación 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()

De esta manera, podrás encontrar rápidamente la sección correspondiente en el codelab.

3. Comisión a Google

Para 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:

  • Los tejidos permiten que los dispositivos se comuniquen entre sí.
  • Las Fabrics mantienen un conjunto compartido de credenciales únicas.
  • Los ecosistemas son responsables de emitir certificados raíz confiables, asignar IDs de tejido y asignar IDs de nodos únicos. Un ecosistema es el servicio de backend de un comisionado, como Home Graph para el ecosistema de Google Home.
  • Los dispositivos se pueden encargar a más de un tejido (función de administrador múltiple).

Para encargar 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 siguientes secciones, revisaremos el código mínimo necesario para asignar dispositivos a la estructura de Google.

Paso 1: Selector de actividades

Para controlar el IntentSender de 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

Este es un ejemplo básico en el que se usa la API de CommissioningClient para asignar un dispositivo a la estructura de Google.

  1. El proceso de comisión comienza con la función commissionDevice(). Primero, se define un CommissioningRequest. Con esta configuración predeterminada, los dispositivos se realizan únicamente a la estructura local de Android.
  2. Matter es el punto de entrada del SDK de Home Mobile. En la próxima llamada, .getCommissioningClient obtiene un CommissioningClient de this (Activity).
  3. .commissionDevice() acepta CommissioningRequest.
  4. Por último, se llama a .addOnSuccessListener para procesar el CommissioningResult 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())
        }
}

Android Fabric local se puede aprovechar a través de la configuración de Android para simplificar el proceso de asignación de dispositivos a otras infraestructuras.

A continuación, aprenderás a asignar un dispositivo a un tejido de desarrollo.

Para obtener una descripción general de la interfaz de usuario durante el proceso de comisión, consulta la guía de Matter de la app de ejemplo de Google Home.

4. Comisión a un tejido de desarrollo

Los dispositivos se pueden realizar para más de un tejido. Para administrar las vinculaciones de confianza, los dispositivos almacenan una FabricTable que contiene varios miembros de FabricInfo, por ejemplo:

  • Identificación textil
  • Es el ID de nodo que la estructura asignó al dispositivo.
  • ID del proveedor
  • ID de Fabric
  • Credenciales operativas del dispositivo

El administrador de dominio administrativo (ADM) define las credenciales de tejido. En la situación 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 dispositivo incluye el mismo conjunto de credenciales de estructura y el mismo conjunto de AC.

Comisión de servicios personalizados

Para realizar la comisión a la estructura local de 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 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 las credenciales de nodo adecuadas a los dispositivos.

Para informar al SDK de Home Mobile SDK que quieres asignar dispositivos a tu propia estructura, pasa 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 actividades al fragmento de la pantalla principal 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 actividades para controlar IntentSender desde 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 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 activa el parámetro "Commission Device" acción haciendo clic en el signo "+" en la esquina 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 muestra en una función de devolución de llamada. Cuando pasas un servicio personalizado, el SDK de Home para dispositivos móviles primero asigna dispositivos a la estructura local de Android y, luego, envía la carga útil de integración a AppCommissioningService.
    val commissionDeviceRequest =
    CommissioningRequest.builder()
        .setCommissioningService(ComponentName(
            context, AppCommissioningService::class.java))
        .build()
  3. Llama a .getCommissioningClient() y, luego, llama 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 comisión

En la función commissionDevice(), solicitamos que obtuviéramos un CommissioningService de la API de CommissioningClient. En este flujo, la API de CommissioningClient primero asigna dispositivos a la estructura local de Android y, luego, muestra una devolución de llamada que incluye el objeto CommissioningRequestMetadata:

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

Ahora, tenemos que heredar el CommissioningService.Callback y proporcionar la funcionalidad necesaria para enviar 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 clases básica para nuestro CommissioningService personalizado. A continuación, presentamos una descripción general rápida 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 las corrutinas de Hilt y Kotlin.

A continuación, crearemos el constructor y configuraremos algunas cosas, incluida la commissioningServiceDelegate, que usaremos para informarle a los Servicios de Google Play cuando se complete la puesta en servicio.

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:

  1. Abrir 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. Realizar la puesta en marcha En este paso, podemos pasar la información del dispositivo que se muestra en el objeto CommissioningRequestMetadata. 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 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 tenemos todo el código requerido para realizar la comisión a 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 asignar el dispositivo.

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

6. Controla dispositivos

La comisión a un tejido de desarrollo te permite usar las bibliotecas del repositorio de Matter (connectedhomeip) para controlar dispositivos desde la app de ejemplo.

Creamos algunas clases auxiliares para facilitar el acceso a los clústeres del dispositivo y el envío de 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 activación/desactivación 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 asignar un dispositivo, la carga útil que se muestra en CommissioningResult se agrega a DataStore. Esto le da a nuestra app acceso a información del dispositivo que podemos usar para enviar comandos.

Las apps de Matter dependen de los 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 despachan 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, enciende y apaga tu dispositivo.

7. Cómo compartir dispositivos con otros ecosistemas

En la especificación de Matter, se conoce como flujo de administración múltiple.

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 encargar a más de una estructura.

Es posible que quieras compartir dispositivos con más telas, especialmente si se trata de una casa en la que las personas tienen sus preferencias en cuanto a aplicaciones y plataformas.

El SDK de Home Mobile proporciona esta funcionalidad en la API de ShareDeviceRequest, lo que te permite hacer lo siguiente:

  1. Abre un período de comisión temporal para los dispositivos.
  2. Cambia el estado de tus dispositivos para que se puedan poner en marcha en otra estructura.
  3. Controla 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 Selector de actividad de GPS

De manera similar al selector de actividad de comisión que creamos cuando le asignamos un tejido de desarrollo, creamos un selector de actividad de dispositivos compartidos 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 Compartir dispositivo

En este paso, el usuario activa la opción "Compartir dispositivo". acción haciendo clic en el botón “Compartir” botón en la pantalla del dispositivo. Luego, se realiza una llamada al 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 sincronización, deviceViewModel le 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 observa 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 para compartir dispositivos.

  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 DeviceDescriptor proporciona información específica sobre el dispositivo, como el ID de proveedor, el ID del producto y el tipo de dispositivo. En este ejemplo, los valores se codifican.
    val shareDeviceRequest =
  ShareDeviceRequest.builder()
    .setDeviceDescriptor(DeviceDescriptor.builder().build())
    .setDeviceName("GHSAFM temp device name")
  3. Establece la ventana 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()
  4. Llama a .getCommissioningClient(), solo que esta vez, usa la API de .shareDevice().
    Matter.getCommissioningClient(context)
    .shareDevice(shareDeviceRequest)

La devolución de llamada exitosa de la API de commissioningClient.shareDevice() proporciona el objeto IntentSender que se usará para iniciar la actividad del dispositivo compartido en los Servicios de Google Play.

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

Una vez que tengas el comisionado de destino instalado en tu dispositivo Android, verifica que puedes compartir tu dispositivo Matter. La app del comisionado objetivo está etiquetada como GHSAFM-TC.

Tus dispositivos ahora pueden participar en tres tejidos:

  1. La estructura local de Android.
  2. Tu tejido de desarrollo (esta app)
  3. Esta tercera tela 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 cómo usar la app de ejemplo o descubres un error de código, puedes enviar los problemas a la Herramienta de seguimiento de errores en el repositorio de GitHub:

Para obtener orientación oficial de Google sobre preguntas técnicas, visita el Foro de desarrolladores para la casa inteligente:

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