Compilar una app de Android para Matter

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:

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.

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 y java/screens/home/HomeViewModel.kt: Incluye la funcionalidad de comisión del SDK de Home Mobile.
  • java/screens/device/DeviceScreen y java/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.

  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 envían únicamente a la estructura local de Android.
  2. Matter es el punto de entrada para el SDK de Home Mobile. En la siguiente llamada, .getCommissioningClient obtiene un CommissioningClient de this (Activity).
  3. .commissionDevice() acepta las 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())
        }
}

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.

  1. Abre HomeScreen en la carpeta java/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 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

  1. Todavía en HomeScreen.kt en la carpeta java/screens/home/.
  2. Reemplaza el comentario // CODELAB: commissionDevice con la 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 Mobile primero asigna los 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, 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:

  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 deviceId.
    // Perform commissioning on custom fabric for the sample app.
    serviceScope.launch {
      val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
    
  3. 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
    }
    
  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 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.

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

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:

  1. Abre un período de asignación temporal para los dispositivos.
  2. Cambia el estado de tus dispositivos para que se puedan asignar a otra estructura.
  3. 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.

  1. Abre DeviceScreen en la carpeta java/screens/device/.
  2. 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.

  1. Abre DeviceScreen.kt en la carpeta java/screens/device/.
  2. Ubica la función shareDevice(). Reemplaza el comentario // CODELAB: shareDevice por ShareDeviceRequest. 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")
    
  3. 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()
    
  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 elemento IntentSender que se utilizará 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 se ejecuta de forma correcta, se llama a launch en shareDeviceLauncher 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:

  1. La estructura local de Android
  2. Tu estructura de desarrollo (esta app).
  3. 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: