Guía del dispositivo Chime para Android

El tipo de dispositivo fundamental de Chime se puede implementar con el rasgo estándar basado en Matter com.google.home.matter.standard.Chime o con la versión personalizada del rasgo de Google, com.google.home.google.Chime, que, además de las capacidades especificadas en el estándar Matter, admite timbres externos. Un dispositivo de campanilla también puede implementar el rasgo Identify, que proporciona un medio para identificar el dispositivo de campanilla por la vista o el sonido.

Siempre verifica la compatibilidad de los atributos y los comandos de un dispositivo antes de usar cualquier función o intentar actualizar atributos. Consulta Cómo controlar dispositivos enAndroid para obtener más información.

Obtén información básica sobre un dispositivo

   Implementado en la app de ejemplo para Android   

El rasgo BasicInformation incluye información como el nombre del proveedor, el ID del proveedor, el ID del producto, el nombre del producto (incluida la información del modelo) y la versión de software de un dispositivo:

// Get device basic information. All general information traits are on the RootNodeDevice type.
    device.type(RootNodeDevice).first().standardTraits.basicInformation?.let { basicInformation ->
        println("vendorName ${basicInformation.vendorName}")
        println("vendorId ${basicInformation.vendorId}")
        println("productId ${basicInformation.productId}")
        println("productName ${basicInformation.productName}")
        println("softwareVersion ${basicInformation.softwareVersion}")
    }

Compatibilidad con cargas multipartes

Un timbre puede estar compuesto por varios tipos de dispositivos, incluido un Chime y, de manera opcional, una bocina. Además, algunos timbres incorporan un Thread Border Router (TBR). Para garantizar la mayor compatibilidad posible, las apps de las APIs de Home que controlan los timbres deben escribirse de manera que admitan dispositivos de timbre de varias partes. Consulta Dispositivos multipartes para obtener más información.

Cada dispositivo de campanilla de varias partes debe estar representado en la app por una sola tarjeta. El dispositivo Chime debe ser el dispositivo principal, y la bocina secundaria debe ser una parte del Chime.

El volumen de la bocina debe aparecer como un parámetro de configuración principal de un dispositivo Chime.

Asignación de OnOff

En el caso de una campanilla con los tipos de dispositivo Timbre y Bocina, un botón de encendido y apagado en una app de control debe asignarse al atributo Enabled de la campanilla.

Según la especificación de la biblioteca de dispositivos de Matter, establecer el atributo Enabled del rasgo Chime en False puede, además de inhabilitar el timbre, actuar como un interruptor de silencio global que suprime todos los indicadores visuales y audibles.

Asistencia para la automatización

Como se mencionó anteriormente, debido a que un ChimeDevice puede tener varias partes, se recomienda a los desarrolladores que traten todos los sonidos como dispositivos multipartes, y esto sigue siendo cierto en el caso de las automatizaciones que usan sonidos.

Las campanillas se pueden usar en activadores y acciones de automatización.

Cualquier dispositivo componente que se encuentre debajo del dispositivo principal de Chime y que se use en la automatización debe hacer referencia a un AutomationPartPath.

La siguiente automatización muestra cómo crear una automatización con un timbre de varias partes que implementa el rasgo Chime y un Speaker. La automatización se activa cuando se abre la puerta principal:

import com.google.home.automation.automation
import com.google.home.automation.greaterThan
import com.google.home.google.GoogleDoorDevice
import com.google.home.google.OpenClose
import com.google.home.matter.standard.ChimeDevice
import com.google.home.matter.standard.Chime
// ...

// Fetch devices
val devices = homeManager.devices()

// Fetch devices using the multipart device model.
val multipartDevices = homeManager.devices(enableMultipartDevices = true)

val doorDevice = devices.first() {
  it.has(GoogleDoorDevice) &&
  it.has(OpenClose)
}

// Obtain a reference to the chime device.
val chime = multipartDevices.first() {
  it.has(ChimeDevice) &&
  it.has(Chime)
}

// Extract the AutomationPartPath for the specific Chime part
val chimePartPath = chime.automationPart(chime.part(ChimeDevice).first())!!

// Build the automation
val chimeAutomation = automation {
  sequential {
    val doorOpenClose = stateReader<_>(doorDevice, GoogleDoorDevice, OpenClose)
    // Starter: When the door state changes
    val starterNode = starter<_>(doorDevice, GoogleDoorDevice, OpenClose)
    condition {
     expression = doorOpenClose.openPercent greaterThan(0)
    }
    // Action: Play a chime sound
    action(chimePartPath) {
      command(Chime.playChimeSound())
    }
  }
}

Consulta Automatizaciones de dispositivos multipartes para obtener más información sobre las automatizaciones que usan dispositivos multipartes.

Cómo verificar la conectividad de un dispositivo

En realidad, la conectividad de un dispositivo se verifica a nivel del tipo de dispositivo, ya que algunos dispositivos admiten varios tipos de dispositivos. El estado que se devuelve es una combinación de los estados de conectividad de todos los rasgos del dispositivo.

val lightConnectivity = dimmableLightDevice.metadata.sourceConnectivity.connectivityState

Se puede observar un estado de PARTIALLY_ONLINE en el caso de tipos de dispositivos mixtos cuando no hay conectividad a Internet. Es posible que los rasgos estándar de Matter sigan en línea debido al enrutamiento local, pero los rasgos basados en la nube estarán sin conexión.

Obtén la dirección IP del dispositivo

Para encontrar la dirección IP del dispositivo, usa el atributo networkInterfaces del rasgo GeneralDiagnostics. Las direcciones se devuelven como arrays de bytes, que puedes formatear como cadenas IPv4 o IPv6 estándar:

val ipAddresses =
  trait.networkInterfaces?.flatMap { networkInterface ->
    (networkInterface.ipv4Addresses + networkInterface.ipv6Addresses).mapNotNull { bytes ->
      try {
        java.net.InetAddress.getByAddress(bytes).hostAddress
      } catch (e: java.net.UnknownHostException) {
        null
      }
    }
  } ?: emptyList()