Criar um app Android para casos relevantes

1. Olá

Criado com o objetivo de unificar os padrões de IoT, o Matter conecta dispositivos de casa inteligente em vários ecossistemas, como Google Home, Zigbee, Bluetooth Mesh, Z-Wave e muito mais.

Os dispositivos móveis são um ponto central de interação com dispositivos de casa inteligente. Se você quiser criar seus próprios apps Android para oferecer suporte a dispositivos Matter, podemos ajudar você a começar rapidamente.

O app de exemplo do Google Home para Matter (GHSA para Matter) mostra as APIs do SDK do Home para dispositivos móveis, permitindo que os usuários configurem e compartilhem dispositivos. Você também pode usar o app de exemplo como uma ferramenta de aprendizado para entender melhor os principais conceitos do Matter, além de uma ferramenta para depurar e resolver problemas de interações com dispositivos Matter.

Atividades deste laboratório

Neste codelab, você vai baixar o código-fonte do app de exemplo e aprender a usar o SDK Home Mobile para ativar e compartilhar dispositivos. Você também vai aprender a usar as bibliotecas de comissionamento e cluster do repositório do Matter (connectedhomeip).

Depois de baixar o app de exemplo, vamos analisar o código-fonte no Android Studio e implementar as seguintes APIs do SDK Home Mobile:

Você também vai aprender mais sobre conceitos de comissionamento, tecidos Matter e como controlar dispositivos Matter.

O que é necessário

Antes de começar, siga estas etapas:

Não é necessário um hub, como um Google Nest Hub (2ª geração), para comissionar e controlar dispositivos com o app de exemplo.

2. Começar a configuração

O app inicial do codelab está localizado na ramificação codelab. Para começar a trabalhar com o código-fonte do codelab, faça o download do arquivo ZIP.

Você vai usar esse arquivo ZIP codelab para criar uma amostra funcional.

Versões do codelab

A ramificação codelab está marcada com a versão 2.0.0 do app de exemplo. Para comparar suas atualizações à medida que você trabalha em cada etapa, baixe o código-fonte concluído desta versão.

Se quiser clonar o repositório do GitHub, siga as instruções no README do app de exemplo.

Dependências

Vamos orientar você pelo código-fonte necessário para compartilhar e ativar dispositivos, mas é útil conhecer as seguintes dependências antes de começar. Essas dependências são declaradas no arquivo libs.versions.toml e o uso delas é especificado no arquivo build.gradle.kts.

Código-fonte

A interface do usuário e a maior parte da funcionalidade já foram criadas para você.

Neste codelab, vamos adicionar a funcionalidade do Matter aos seguintes arquivos:

  • java/com/google/homesampleapp/commissioning/AppCommissioningService: permite comissionar dispositivos para a estrutura de desenvolvimento.
  • java/com/google/homesampleapp/screens/home/HomeScreen e java/com/google/homesampleapp/screens/home/HomeViewModel.kt: inclui a funcionalidade de ativação do SDK para dispositivos móveis do Google Home.
  • java/com/google/homesampleapp/screens/device/DeviceScreen e java/com/google/homesampleapp/screens/device/DeviceViewModel: inclui as chamadas da API Share Device.

Cada arquivo tem um comentário com o bloco de código que você vai modificar. Por exemplo:

// CODELAB: add commissioningFunction()

Assim, você pode localizar rapidamente a seção correspondente no codelab.

3. Comissão para o Google

Antes de controlar dispositivos e permitir que eles se comuniquem entre si no mesmo tecido, eles precisam ser comissionados por um comissário, que neste caso é este aplicativo de exemplo, o app Google Home de exemplo para Matter.

É importante entender os seguintes conceitos sobre o provisionamento do Matter:

  • As estruturas permitem que os dispositivos se comuniquem.
  • As fábricas mantêm um conjunto compartilhado de credenciais exclusivas.
  • Os ecossistemas são responsáveis por emitir certificados raiz confiáveis, atribuir IDs de estrutura e IDs de nós exclusivos. Um ecossistema é o serviço de back-end de um comissário, por exemplo, o Home Graph para o ecossistema do Google Home.
  • Os dispositivos podem ser provisionados para mais de uma estrutura (recurso de vários administradores).

Para comissionar um dispositivo, use a API CommissioningClient. Uma chamada para .commissionDevice() retorna um IntentSender, que inicia a atividade adequada nos serviços do Google Play:

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

Nas próximas seções, vamos analisar o código mínimo necessário para comissionar dispositivos na estrutura do Google.

Etapa 1: iniciador de atividades

Para processar o IntentSender do CommissioningClient, use um 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)
    }
}

Etapa 2: função de comissionamento

Confira um exemplo básico que usa a API CommissioningClient para provisionar um dispositivo no Google fabric.

  1. O processo de inclusão começa com a função commissionDevice(). Primeiro, um CommissioningRequest é definido. Com essa configuração padrão, os dispositivos são provisionados apenas para a estrutura local do Android.
  2. Matter é o ponto de entrada do SDK do Home para dispositivos móveis. Na próxima chamada, .getCommissioningClient recebe um CommissioningClient por this (Activity).
  3. O .commissionDevice() aceita o CommissioningRequest.
  4. Por fim, .addOnSuccessListener é chamado para processar o CommissioningResult e iniciar a atividade Comissionar dispositivo do Google Play Services (GPS).
private fun commissionDevice() {
    val request: CommissioningRequest = CommissioningRequest.builder().build()
    Matter.getCommissioningClient(this)
        .commissionDevice(request)
        .addOnSuccessListener { result ->
            commissioningLauncher.launch(IntentSenderRequest.Builder(result).build())
        }
}

O Local Android Fabric pode ser usado nas configurações do Android para simplificar o processo de comissionamento dos dispositivos em outros fabrics.

Em seguida, você vai aprender a comissionar um dispositivo em uma estrutura de desenvolvimento.

Para uma visão geral da interface do usuário durante o processo de comissionamento, consulte o Guia do app de exemplo do Google Home para Matter.

4. Comissionar um tecido de desenvolvimento

Os dispositivos podem ser comissionados para mais de uma estrutura. Para gerenciar pareamentos confiáveis, os dispositivos armazenam um FabricTable que contém vários membros FabricInfo. Por exemplo:

  • Identificação de tecido
  • ID do nó atribuído pelo fabric ao dispositivo.
  • ID do fornecedor
  • ID de fabricação
  • Credenciais operacionais do dispositivo

O gerente de domínio administrativo (ADM) define as credenciais da estrutura. No cenário anterior, o Google Play Services é o ecossistema que atua como uma autoridade certificadora (AC) raiz confiável. Quando você comissiona dispositivos para a estrutura local do Android, todos eles incluem o mesmo conjunto de credenciais e de CAs.

Serviços de comissionamento personalizados

Para fazer o comissionamento na estrutura local do Android, usamos os parâmetros padrão para criar o CommissioningRequest na API CommissioningClient:

val request: CommissioningRequest = CommissioningRequest.builder().build()

Se você quiser controlar e gerenciar novos dispositivos no seu app, crie uma estrutura de desenvolvimento local e obtenha as credenciais operacionais para comissionar dispositivos. Nesse cenário, seu app se torna um ecossistema único e independente que atribui aos dispositivos as credenciais de nó adequadas.

Você pode informar ao SDK do Home Mobile que quer comissionar dispositivos para sua própria estrutura passando um serviço personalizado para o CommissioningRequest:

class CommissioningRequest {
  static CommissioningRequest.Builder builder();

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

    CommissioningRequest build();
  }
}

Nas próximas etapas, vamos modificar a função commissionDevice() para usar um serviço personalizado. Também vamos adicionar um iniciador de atividade ao fragmento Home e usar objetos LiveData para gerenciar o fluxo da API.

Etapa 1: criar um iniciador de atividades do GPS

Primeiro, vamos criar um inicializador de atividades para processar o IntentSender da API CommissioningClient.

  1. Abra HomeScreen na pasta java/com/google/homesampleapp/screens/home/.
  2. Substitua o comentário // CODELAB: commissionDeviceLauncher definition pelo código a seguir para registrar e processar o resultado da atividade de comissionamento:
    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)
    }
  }

Etapa 2: acionar a ação de comissionamento do dispositivo

Nesta etapa, o usuário aciona a ação "Comissionar dispositivo" clicando no botão "+" no canto inferior direito da tela inicial. Em seguida, uma chamada é feita para commissionDevice().

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

Etapa 3: chamar a API

  1. Ainda em HomeScreen.kt na pasta java/com/google/homesampleapp/screens/home.
  2. Substitua o comentário // CODELAB: commissionDevice pelo seguinte commissionDeviceRequest. O setCommissioningService vincula AppCommissioningService a uma instância CommissioningService, retornada em uma função de callback. Quando você transmite um serviço personalizado, o SDK Home Mobile primeiro comissiona dispositivos para a estrutura local do Android e envia o payload de integração de volta ao AppCommissioningService.
    val commissionDeviceRequest =
    CommissioningRequest.builder()
        .setCommissioningService(ComponentName(
            context, AppCommissioningService::class.java))
        .build()
  3. Chame .getCommissioningClient() e depois .commissionDevice().
Matter.getCommissioningClient(context)
    .commissionDevice(commissionDeviceRequest)

Para concluir a função commissionDevice, adicione um addOnSuccessListener e um addOnFailureListener:

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

5. Criar um serviço de provisionamento

Na função commissionDevice(), solicitamos um CommissioningService da API CommissioningClient. Nesse fluxo, a API CommissioningClient comissiona dispositivos primeiro para a estrutura local do Android e depois retorna um callback que inclui o objeto CommissioningRequestMetadata:

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

Agora, precisamos herdar o CommissioningService.Callback e fornecer a funcionalidade necessária para comissionar dispositivos no nosso app de exemplo. Veja um exemplo de uma implementação básica do 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())
   }
 }

Etapa 1: conhecer o AppCommissioningService personalizado

Para ajudar você a começar, já definimos a estrutura básica da classe para nosso CommissioningService personalizado. Confira uma visão geral rápida da funcionalidade do serviço. Para acompanhar, abra AppCommissioningService em java/commissioning.

Adicionamos as seguintes importações para as APIs do SDK 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

O AppCommissioningService também inclui bibliotecas do repositório do Matter (connectedhomeip):

import com.google.homesampleapp.chip.ChipClient

Por fim, o serviço inclui importações para oferecer suporte ao Hilt e às corrotinas Kotlin.

Em seguida, criamos o construtor e configuramos algumas coisas, incluindo o commissioningServiceDelegate, que vamos usar para informar ao Google Play Services quando o provisionamento for concluído.

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

Agora é hora de adicionar as funções de comissionamento.

Etapa 2: substituir onCommissioningRequested

Para comissionar dispositivos para a estrutura de desenvolvimento do app, siga estas etapas:

  1. Abra AppCommissioningService no app java/commissioning.
  2. Localize a função onCommissioningRequested(). Fornecemos uma mensagem de registro que imprime o CommissioningRequestMetadata. Substitua o comentário // CODELAB: onCommissioningRequested() para iniciar a corrotina serviceScope e receber o deviceId.
    // Perform commissioning on custom fabric for the sample app.
serviceScope.launch {
  val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
  3. Faça o provisionamento. Para esta etapa, podemos transmitir as informações do dispositivo retornadas no objeto CommissioningRequestMetadata. O ChipClient usa essas informações de metadados para criar um canal seguro entre o app GHSA para Matter e seu 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. Use o commissioningServiceDelegate para informar ao Google Play Services que a ativação foi concluída. Em .sendCommissioningComplete(), transmita o 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")
    }
}

Executar o app

Agora que todo o código necessário está no lugar para comissionar nossa estrutura local, é hora de testá-lo. Escolha seu dispositivo Android e execute o app. Na tela inicial, toque em Adicionar dispositivo e siga as etapas para comissionar o dispositivo.

Quando o comissionamento for concluído, seu dispositivo vai participar de duas estruturas: a estrutura local do Android e a estrutura de desenvolvimento local. Cada tecido tem um conjunto próprio de credenciais e um ID exclusivo de 64 bits.

6. Controlar dispositivos

O provisionamento em uma estrutura de desenvolvimento permite usar as bibliotecas do repositório do Matter (connectedhomeip) para controlar dispositivos do app de exemplo.

Criamos algumas classes auxiliares para facilitar o acesso aos clusters de dispositivos e o envio de comandos. Para saber mais, abra ClustersHelper em java/clusters. Esse auxiliar Singleton importa as seguintes bibliotecas para acessar informações do dispositivo:

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

Podemos usar essa classe para receber o cluster On/Off de um dispositivo e chamar .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)
              }
            })
  }
}

Alternar um dispositivo

Depois que você comissiona um dispositivo, o payload retornado no CommissioningResult é adicionado ao DataStore. Isso dá ao nosso app acesso a informações do dispositivo que podemos usar para enviar comandos.

Os apps Matter são orientados por eventos. Quando a pilha Matter é inicializada, os serviços de cluster detectam mensagens recebidas. Depois que um dispositivo é comissionado, os clientes do Matter enviam comandos pelo canal operacional seguro estabelecido durante o comissionamento.

No dispositivo, os pacotes são validados, descriptografados e enviados com um callback. As funções de callback incluem EndpointId, ClusterId e AttributeId, acessíveis pelo attributePath. Por exemplo, este código pode ser implementado em um 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;
}

Nas próximas etapas, você vai usar o SDK Matter e ClustersHelper para ativar ou desativar um dispositivo.

  1. Acesse DeviceViewModel em java/screens/device.
  2. Localize a função updateDeviceStateOn.
  3. Substitua o comentário // CODELAB: toggle pelo código para chamar clustersHelper e atualize o repositório de dispositivos:
    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")
    }

Essa função é chamada em DeviceScreen:

// On/Off Switch click.
val onOnOffClick: (value: Boolean) -> Unit = { value ->
  deviceViewModel.updateDeviceStateOn(deviceUiModel!!, value)
}

Executar o app

Execute o app para recarregar as atualizações. Na tela inicial, ative e desative o dispositivo.

7. Compartilhar dispositivos com outros ecossistemas

O compartilhamento de um dispositivo é chamado de fluxo de vários administradores na especificação do Matter.

Nas etapas anteriores, aprendemos que o SDK Home Mobile permite comissionar dispositivos para a estrutura local do Android e também para uma estrutura de desenvolvimento do app de exemplo. Esse é um exemplo de fluxo multiadministrador, em que os dispositivos podem ser comissionados para mais de uma estrutura.

Agora, talvez você queira compartilhar dispositivos com ainda mais tecidos, principalmente se for uma casa em que as pessoas têm preferências próprias quando se trata de aplicativos e plataformas.

O SDK Home para dispositivos móveis oferece essa funcionalidade na API ShareDeviceRequest, permitindo que você:

  1. Abra uma janela de provisionamento temporário para dispositivos.
  2. Mude o estado dos seus dispositivos para que eles possam ser comissionados em outra estrutura.
  3. Controle seus dispositivos em outros apps e ecossistemas.

Nas próximas etapas, você vai usar o SDK Home Mobile para compartilhar dispositivos.

Etapa 1: criar um iniciador de atividades do GPS

Semelhante ao iniciador de atividades de comissionamento que criamos ao comissionar para uma estrutura de desenvolvimento, criamos um iniciador de atividades de compartilhamento de dispositivo para processar o IntentSender da API CommissioningClient.

  1. Abra DeviceScreen na pasta java/com/google/homesampleapp/screens/device/.
  2. Substitua o comentário // CODELAB: shareDeviceLauncher definition pelo código a seguir para registrar e processar o resultado da atividade .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)
  }
}

Etapa 2: acionar a ação de compartilhamento de dispositivo

Nesta etapa, o usuário aciona a ação "Compartilhar dispositivo" clicando no botão "Compartilhar" na tela do dispositivo. Em seguida, uma chamada é feita para o deviceViewModel para abrir uma janela de pareamento para compartilhamento de dispositivos.

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

Depois de abrir a janela de pareamento, o deviceViewModel comunica esse fato à interface. A comunicação entre o ViewModel e a interface é feita por 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

Ao ver a mudança no objeto StateFlow, o DeviceScreen faz a seguinte chamada:

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

Etapa 3: chamar a API

Agora é hora de iniciar uma tarefa de compartilhamento de dispositivo.

  1. Abra DeviceScreen.kt na pasta java/com/google/homesampleapp/screens/device/.
  2. Localize a função shareDevice(). Substitua o comentário // CODELAB: shareDevice por ShareDeviceRequest. O DeviceDescriptor fornece informações específicas sobre o dispositivo, como ID do fornecedor, ID do produto e deviceType. Neste exemplo, codificamos os valores.
    val shareDeviceRequest =
  ShareDeviceRequest.builder()
    .setDeviceDescriptor(DeviceDescriptor.builder().build())
    .setDeviceName("GHSAFM temp device name")
  3. Defina os 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. Chame .getCommissioningClient(), mas desta vez use a API .shareDevice().
    Matter.getCommissioningClient(context)
    .shareDevice(shareDeviceRequest)

O callback de sucesso da API commissioningClient.shareDevice() fornece o IntentSender a ser usado para iniciar a atividade de compartilhamento de dispositivo no Google Play Services.

  1. Para concluir a função shareDevice, adicione um addOnSuccessListener e um addOnFailureListener. Em caso de sucesso, launch é chamado em shareDeviceLauncher para iniciar a atividade de GPS para compartilhamento de dispositivos.
        .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())
    }

Executar o app

Para compartilhar seu dispositivo Matter com outros ecossistemas, você precisa ter outra plataforma instalada no seu dispositivo Android. Criamos outra instância do app de exemplo que você pode usar como o comissário de destino.

Depois de instalar o comissário de destino no seu dispositivo Android, verifique se é possível compartilhar o dispositivo Matter. O app comissário de destino é rotulado como GHSAFM-TC.

Agora, seus dispositivos podem participar de três estruturas:

  1. A estrutura local do Android.
  2. Sua estrutura de desenvolvimento (este app).
  3. Esse terceiro tecido com que você acabou de compartilhar o dispositivo.

8. Próximas etapas

Parabéns

Parabéns! Você concluiu este codelab e aprendeu a provisionar e compartilhar dispositivos usando o SDK Home Mobile.

Se você estiver com problemas no app de exemplo, siga as etapas para verificar seu ambiente:

Se você tiver dúvidas sobre como usar o app de exemplo ou encontrar um bug no código, envie problemas para o Issue Tracker no repositório do GitHub:

Para receber orientações oficiais do Google sobre questões técnicas, use o fórum para desenvolvedores de casa inteligente:

Para receber suporte técnico da comunidade, use a tag google-smart-home no Stack Overflow: