Criar um app Android para casos relevantes

1. Olá!

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

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

O app de exemplo do Google Home para o Matter (GHSA para o Matter) apresenta as APIs Home Mobile SDK, permitindo que os usuários comissionem 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, bem como uma ferramenta para depurar e resolver problemas de interações com dispositivos Matter.

Atividades deste laboratório

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

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

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

O que é necessário

Antes de começar, conclua as seguintes etapas:

Você não precisa de um hub, como um Google Nest Hub (2a 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ê usará este arquivo ZIP codelab para criar uma amostra funcional.

Versões do codelab

A ramificação codelab é marcada com a versão 2.0.0 do app de exemplo. Para comparar suas atualizações à medida que trabalha em cada etapa, faça o download do código-fonte completo para esta versão.

Se você quiser clonar o repositório do GitHub, siga as instruções no README do app de exemplo (em inglês).

Dependências

Vamos orientar você sobre o código-fonte necessário para compartilhar e comissionar dispositivos, mas pode ser útil conhecer as dependências a seguir antes de começar. Observe que essas dependências são declaradas no arquivo libs.versions.toml e seu uso especificado no arquivo build.gradle.kts.

Código-fonte

A interface do usuário e a maioria das funcionalidades já foram criadas para você.

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

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

Cada arquivo é comentado com o bloco de código que você modificará, por exemplo:

// CODELAB: add commissioningFunction()

Isso permite que você localize rapidamente a seção correspondente no codelab.

3. Comissão para o Google

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

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

  • Os tecidos permitem que os dispositivos se comuniquem uns com os outros.
  • Os tecidos mantêm um conjunto compartilhado de credenciais exclusivas.
  • Os ecossistemas são responsáveis por emitir certificados raiz confiáveis e atribuir IDs de malha e de nó 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 comissionados para mais de uma malha (recurso multiadministrador).

Para comissionar um dispositivo, você precisará usar a API CommissioningClient. Uma chamada para .commissionDevice() retorna um IntentSender, que inicia a atividade adequada no Google Play Services:

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

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

Etapa 1: Acesso rápido às 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

Veja um exemplo básico que usa a API CommissioningClient para comissionar um dispositivo na fábrica do Google.

  1. O processo de comissionamento começa com a função commissionDevice(). Primeiro, um CommissioningRequest é definido. Com essa configuração padrão, os dispositivos são comissionados apenas para a estrutura local do Android.
  2. Matter é o ponto de entrada do SDK para dispositivos móveis do Google Home. Na próxima chamada, .getCommissioningClient recebe um CommissioningClient por this (atividade).
  3. .commissionDevice() aceita a CommissioningRequest.
  4. Por fim, .addOnSuccessListener é chamado para processar o CommissioningResult e iniciar a atividade do dispositivo de comissão 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 Fabric local do Android pode ser aproveitado pelas configurações do Android para simplificar o processo de comissionamento dos dispositivos para outros tecidos.

A seguir, você aprenderá a comissionar um dispositivo para um tecido de desenvolvimento.

Para ter 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 o Matter.

4. Comissão para uma malha de desenvolvimento

Os dispositivos podem ser comissionados para mais de um tecido. Para gerenciar pareamentos confiáveis, os dispositivos armazenam um FabricTable com vários participantes do FabricInfo, por exemplo:

  • Identificação do tecido
  • ID do nó atribuído pela malha ao dispositivo
  • ID do fornecedor
  • ID do Fabric
  • Credenciais operacionais do dispositivo

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

Serviços de comissionamento personalizados

Para comissionar a 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, precisará criar uma malha de desenvolvimento local e receber as credenciais operacionais para comissionar dispositivos. Nesse cenário, o app se torna um ecossistema único e independente que atribui aos dispositivos as credenciais de nó adequadas.

É possível informar ao SDK Google Home para dispositivos móveis que você quer comissionar dispositivos para seu próprio sistema, transmitindo um serviço personalizado para CommissioningRequest:

class CommissioningRequest {
  static CommissioningRequest.Builder builder();

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

    CommissioningRequest build();
  }
}

Nas próximas etapas, modificaremos a função commissionDevice() para usar um serviço personalizado. Também adicionaremos um Iniciador de atividades ao fragmento da página inicial e usaremos objetos LiveData para gerenciar o fluxo da API.

Etapa 1: criar um Iniciador de atividades do GPS

Primeiro, vamos criar um Activity Launcher 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: acione a ação de comissão do dispositivo

Nesta etapa, o usuário aciona o "Dispositivo de comissão". clicando no sinal "+" no canto inferior direito da tela inicial. Uma chamada é feita para commissionDevice().

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

Etapa 3: chamar a API

  1. Ainda no arquivo HomeScreen.kt na pasta java/com/google/homesampleapp/screens/home.
  2. Substitua o comentário // CODELAB: commissionDevice pelo seguinte commissionDeviceRequest. setCommissioningService vincula AppCommissioningService a uma instância de CommissioningService, retornada em uma função de callback. Quando você transmite um serviço personalizado, o SDK do Google Home para dispositivos móveis primeiro comissiona os dispositivos para a infraestrutura local do Android e, em seguida, envia o payload de integração de volta para o AppCommissioningService.
    val commissionDeviceRequest =
    CommissioningRequest.builder()
        .setCommissioningService(ComponentName(
            context, AppCommissioningService::class.java))
        .build()
  3. Chame .getCommissioningClient() e, em seguida, .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 comissionamento

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

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

Agora, temos que herdar o CommissioningService.Callback e fornecer a funcionalidade necessária para comissionar dispositivos para nosso aplicativo de exemplo. Veja um exemplo de 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: analisar o AppCommissioningService personalizado

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

Adicionamos as seguintes importações às APIs Home Mobile SDK:

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 do Kotlin.

Em seguida, vamos criar o construtor e configurar alguns itens, incluindo o commissioningServiceDelegate, que vamos usar para informar ao Google Play Services quando a ativação for concluída.

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 na estrutura de desenvolvimento do app, siga estas etapas:

  1. Abrir AppCommissioningService no app java/commissioning.
  2. Localize a função onCommissioningRequested(). Fornecemos uma mensagem de registro que mostra 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. Realize o comissionamento. Nesta 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 for 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 o comissionamento foi concluído. 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á pronto para comissionamento para nossa malha local, é hora de testá-lo. Escolha seu dispositivo Android e execute o app. Na tela inicial, toque em Adicionar dispositivo e conclua as etapas para comissionar seu dispositivo.

Quando o comissionamento for concluído, seu dispositivo agora será usado em dois tecidos: o tecido local do Android e o de desenvolvimento local. Cada malha tem seu próprio conjunto de credenciais e um ID de malha exclusivo de 64 bits.

6. Controlar dispositivos

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

Criamos algumas classes auxiliares para facilitar o acesso a clusters de dispositivos e o envio de comandos. Para saber mais, abra ClustersHelper no java/clusters. Este 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 de ativação/desativação para um dispositivo e depois 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 de comissionar um dispositivo, o payload retornado em CommissioningResult é adicionado ao DataStore. Isso dá ao app acesso a informações do dispositivo que podem ser usadas para enviar comandos.

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

No dispositivo, os pacotes são validados, descriptografados e enviados com um callback. As funções de callback incluem EndpointId, ClusterId e AttributeId, que podem ser acessados de 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 do Matter e o ClustersHelper para alternar 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 do 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")
    }

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 do Google Home Mobile permite comissionar dispositivos para a malha local do Android e também para uma estrutura de desenvolvimento para o app de exemplo. Esse é um exemplo de fluxo de vários administradores, em que os dispositivos podem ser comissionados para mais de uma malha.

Agora, você pode querer compartilhar dispositivos com ainda mais tecidos, especialmente se esta for uma família onde as pessoas têm suas próprias preferências quando se trata de aplicativos e plataformas.

O SDK do Google Home Mobile oferece essa funcionalidade na API ShareDeviceRequest, permitindo que você:

  1. Abra uma janela de comissionamento temporária para dispositivos.
  2. Mudar o estado dos dispositivos, permitindo que eles sejam comissionados para outro tecido.
  3. Controle seus dispositivos de outros apps e ecossistemas.

Nas próximas etapas, você vai usar o SDK do Google Home para dispositivos móveis para compartilhar dispositivos.

Etapa 1: criar um Iniciador de atividades do GPS

Assim como o Commissioning Activity Launcher que criamos quando encomendamos uma estrutura de desenvolvimento, criamos um Share Device Activity Launcher para gerenciar 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 abaixo 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 do dispositivo

Nesta etapa, o usuário aciona a opção "Compartilhar dispositivo". clicando no botão "Compartilhar" na tela do dispositivo. Uma chamada é feita ao deviceViewModel para abrir uma janela de pareamento para o 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 pelo ShareDeviceRequest. O DeviceDescriptor fornece informações específicas sobre o dispositivo, como o ID do fornecedor, o ID do produto e o deviceType. Neste exemplo, codificamos os valores.
    val shareDeviceRequest =
  ShareDeviceRequest.builder()
    .setDeviceDescriptor(DeviceDescriptor.builder().build())
    .setDeviceName("GHSAFM temp device name")
  3. Defina CommissioningWindow e parameters.
        .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 êxito da API commissioningClient.shareDevice() fornece o IntentSender a ser usado para iniciar o compartilhamento de atividade do dispositivo no Google Play Services.

  1. Para concluir a função shareDevice, adicione um addOnSuccessListener e um addOnFailureListener. Se tudo der certo, launch será chamado no shareDeviceLauncher para iniciar a atividade do GPS para compartilhamento do 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())
    }

Executar o app

Para compartilhar o dispositivo Matter com outros ecossistemas, você vai precisar ter outra plataforma instalada no 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 dispositivo Android, verifique se é possível compartilhar o dispositivo Matter. O app do comissário de destino é rotulado como GHSAFM-TC.

Seus dispositivos agora podem participar de três tecidos:

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

8. Próximas etapas

Parabéns

Parabéns! Você concluiu este codelab e aprendeu a comissionar e compartilhar dispositivos usando o SDK do Google Home para dispositivos móveis.

Se você tiver problemas com o app de exemplo, tente concluir as etapas para verificar o ambiente:

Se você tiver dúvidas sobre como usar o app de exemplo ou descobrir um bug no código, envie os 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: