Criar um app Android para casos relevantes

1. Boas-vindas

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 de interação central com dispositivos de casa inteligente. Se quiser criar seus próprios apps Android compatíveis com dispositivos Matter, podemos ajudar você a começar rapidamente.

O app de exemplo Google Home para Matter (GHSA for Matter) mostra 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 e uma ferramenta para depurar e resolver problemas de interações com os dispositivos.

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 Mobile para comissionar e compartilhar dispositivos. Você também aprenderá a usar bibliotecas de comissionamento e de Cluster do repositório do Matter (connectedhomeip).

Depois que você fizer o download do app de exemplo, revisaremos o código-fonte no Android Studio e implementaremos as seguintes APIs Home Mobile SDK:

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

O que é necessário

Antes de começar, conclua as etapas a seguir:

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ê vai usar este arquivo ZIP codelab para criar uma amostra funcional.

Versões de codelab

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

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

Dependências

Orientaremos você pelo 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 o uso delas é 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 do Matter aos seguintes arquivos:

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

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

// CODELAB: add commissioningFunction()

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

3. Comissão para o Google

Antes de você controlar os dispositivos e permitir que eles se comuniquem entre si na mesma malha, eles precisam ser encomendados por um comissário, que, neste caso, é este aplicativo de exemplo, o app de exemplo 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, atribuir IDs de malha e IDs de nós exclusivos. Um ecossistema é o serviço back-end de um encarregado, por exemplo, o Home Graph para o ecossistema do Google Home.
  • Os dispositivos podem ser encomendados para mais de um malha (recurso multiadministrador).

Para comissionar um dispositivo, é necessário 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, vamos aprender sobre o código mínimo necessário para comissionar dispositivos no Fabric do Google.

Etapa 1: tela de início 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 comissionar um dispositivo no Fabric 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 malha local do Android.
  2. O Matter é o ponto de entrada do SDK do Google 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, o .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 Android Fabric local pode ser aproveitado pelas configurações do Android para simplificar o processo de comissionamento dos dispositivos em outros tecidos.

A seguir, você aprenderá como comissionar um dispositivo em um tecido de desenvolvimento.

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

4. Comissão em um tecido de desenvolvimento

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

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

O gerenciador de domínios administrativos (ADM, na sigla em inglês) define as credenciais de malha. No cenário anterior, o Google Play Services é o ecossistema que atua como uma autoridade de certificação (CA) raiz confiável. Quando você comissiona os dispositivos no Fabric local do Android, cada dispositivo inclui o mesmo conjunto de credenciais de malha e o mesmo conjunto de ACs.

Serviços de comissionamento personalizados

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

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

Se quiser controlar e gerenciar novos dispositivos pelo app, é preciso criar uma malha de desenvolvimento local e receber as credenciais operacionais para os dispositivos de comissão. Nesse cenário, o app se torna um ecossistema exclusivo e independente que atribui as credenciais de nó apropriadas aos dispositivos.

É possível informar o SDK do Google Home Mobile que você gostaria de comissionar dispositivos no seu próprio tecido transmitindo 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, modificaremos a função commissionDevice() para usar um serviço personalizado. Também adicionaremos um inicializador de atividades ao fragmento da página inicial e usaremos objetos LiveData para gerenciar o fluxo da API.

Etapa 1: criar um inicializador de atividades de GPS

Primeiro, vamos criar um acesso rápido de atividades para processar o IntentSender da API CommissioningClient.

  1. Abra HomeScreen na pasta java/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 comissão do dispositivo

Nesta etapa, o usuário aciona a ação "Commission Device" 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 no HomeScreen.kt, na pasta java/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 Home Mobile primeiro comissiona os dispositivos para o tecido local do Android e depois 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 CommissioningService

Na função commissionDevice(), solicitamos um CommissioningService da API CommissioningClient. Nesse fluxo, a API CommissioningClient primeiro encomenda os dispositivos à malha local do Android e, em seguida, 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. Confira 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: explorar o AppCommissioningService personalizado

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

Adicionamos as seguintes importações para as 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.home_sample_app_for_matter.chip.ChipClient

Por fim, o serviço inclui importações para oferecer suporte a corrotinas do Hilt e Kotlin.

Em seguida, vamos criar o construtor e configurar alguns itens, incluindo o commissioningServiceDelegate, que vamos usar para informar ao Google Play Services quando o comissionamento 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 na malha 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. Realizar o comissionamento. 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 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 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á em vigor para comissionar nosso tecido 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 estiver concluído, seu dispositivo terá dois componentes: o tecido local do Android e o tecido de desenvolvimento local. Cada malha tem o 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 que você use as bibliotecas do repositório do Matter (connectedhomeip) para controlar os dispositivos pelo 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 conseguir o cluster de ativação/desativação de um dispositivo e, em seguida, 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)
              }
            })
  }
}

Ativar/desativar um dispositivo

Depois de encomendar um dispositivo, o payload retornado no 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 do 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.

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 por 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, ligue e desligue seu dispositivo.

7. Compartilhar dispositivos com outros ecossistemas

O compartilhamento de um dispositivo é chamado de fluxo multiadministrador na especificação do Matter.

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

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

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

  1. Abre uma janela de comissionamento temporária para os dispositivos.
  2. Mude o estado dos dispositivos, permitindo que eles sejam encomendados para outro tecido.
  3. Controle seus dispositivos em outros apps e ecossistemas.

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

Etapa 1: criar um inicializador de atividades de GPS

De forma parecida com o inicializador de atividades de comissionamento que criamos quando encomendamos para um malha de desenvolvimento, criamos um inicializador de atividades do dispositivo compartilhado para lidar com o IntentSender da API CommissioningClient.

  1. Abra DeviceScreen na pasta java/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 ação "Share Device" (Compartilhar dispositivo) clicando no botão "Share" (Compartilhar) na tela do dispositivo. Uma chamada é feita para o deviceViewModel para abrir uma janela de pareamento para compartilhamento de dispositivos.

// Share Device button click.
val onShareDevice: () -> Unit = {
 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 perceber 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/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, do produto e o deviceType. Neste exemplo, os valores foram codificados.
    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(), só que desta vez, use a API .shareDevice().
    Matter.getCommissioningClient(context)
    .shareDevice(shareDeviceRequest)

O callback da API commissioningClient.shareDevice() fornece o IntentSender para iniciar a Atividade do dispositivo compartilhada no Google Play Services.

  1. Para concluir a função shareDevice, adicione addOnSuccessListener e addOnFailureListener. Se tudo der certo, launch vai ser chamado em 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ê precisa ter outra plataforma instalada no seu dispositivo Android. Criamos outra instância do aplicativo 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 você pode compartilhar o dispositivo Matter. O app do comissário desejado tem o rótulo GHSAFM-TC.

Seus dispositivos agora podem participar de três tecidos:

  1. A malha do Android local.
  2. Sua malha 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 comissionar e compartilhar dispositivos usando o SDK Home para dispositivos móveis.

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

Se você tiver dúvidas sobre como usar o app de exemplo ou descobrir um bug de 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: