Guide de l'appareil Chime pour Android

Le type d'appareil Chime fondamental peut être implémenté à l'aide du trait standard basé sur Matter, com.google.home.matter.standard.Chime, ou de la propre version personnalisée de Google du trait, com.google.home.google.Chime, qui, en plus des fonctionnalités spécifiées dans la norme Matter, prend en charge les carillons externes. Un appareil de carillon peut également implémenter le trait Identify, qui permet d'identifier l'appareil de carillon visuellement ou par le son.

Assurez-vous toujours qu'un appareil prend en charge les attributs et les commandes nécessaires avant d'utiliser une fonctionnalité ou de tenter de mettre à jour des attributs. Pour en savoir plus, consultez Contrôler les appareils surAndroid.

Obtenir des informations de base sur un appareil

   Implémenté dans l'application exemple pour Android   

Le trait BasicInformation inclut des informations telles que le nom du fournisseur, son ID, l'ID du produit, le nom du produit (y compris les informations sur le modèle) et la version logicielle d'un appareil :

// 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}")
    }

Compatibilité avec les fichiers multiparties

Une sonnerie peut être composée de plusieurs types d'appareils, y compris un appareil Chime et, éventuellement, une enceinte. De plus, certaines sonneries intègrent un Thread Border Router (TBR). Pour assurer la prise en charge la plus large possible, les applications d'API Home qui contrôlent les carillons doivent être écrites pour s'adapter aux appareils à carillon multipartite. Pour en savoir plus, consultez Appareils multipièces.

Chaque appareil de carillon multipartite doit être représenté dans l'application par une seule carte. L'appareil Chime doit être l'appareil principal, et un haut-parleur enfant doit être une partie sous le Chime.

Le volume du haut-parleur doit apparaître comme un paramètre principal d'un appareil Chime.

Mappage OnOff

Pour une sonnette avec les types d'appareil "Sonnette" et "Enceinte", un bouton "On/Off" dans une application de contrôle doit être associé à l'attribut Enabled de la sonnette.

Conformément à la spécification de la bibliothèque d'appareils Matter, la définition de l'attribut Enabled du trait Chime sur False peut, en plus de désactiver le carillon, agir comme un bouton de désactivation du son global qui supprime tous les indicateurs sonores et visuels.

Assistance pour l'automatisation

Comme indiqué précédemment, étant donné qu'un ChimeDevice peut comporter plusieurs parties, les développeurs sont encouragés à traiter toutes les sonneries comme des appareils multiparties, et cela reste vrai dans le cas des automatisations qui utilisent des sonneries.

Les carillons peuvent être utilisés dans les déclencheurs et les actions d'automatisation.

Tout composant d'un appareil Chime parent utilisé dans l'automatisation doit être référencé à l'aide d'un AutomationPartPath.

L'automatisation suivante montre comment créer une automatisation avec un carillon multipartie qui implémente le trait Chime ainsi qu'un haut-parleur. L'automatisation est déclenchée lorsque la porte d'entrée est ouverte :

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())
    }
  }
}

Pour en savoir plus sur les automatisations utilisant des appareils multipartites, consultez Automatisations d'appareils multipartites.

Vérifier la connectivité d'un appareil

La connectivité d'un appareil est en fait vérifiée au niveau du type d'appareil, car certains appareils sont compatibles avec plusieurs types d'appareils. L'état renvoyé est une combinaison des états de connectivité de tous les traits de cet appareil.

val lightConnectivity = dimmableLightDevice.metadata.sourceConnectivity.connectivityState

Un état PARTIALLY_ONLINE peut être observé dans le cas de types d'appareils mixtes en l'absence de connectivité Internet. Les traits standards Matter peuvent toujours être en ligne en raison du routage local, mais les traits basés sur le cloud seront hors connexion.

Obtenir l'adresse IP de l'appareil

Pour trouver l'adresse IP de l'appareil, utilisez l'attribut networkInterfaces du trait GeneralDiagnostics. Les adresses sont renvoyées sous forme de tableaux d'octets, que vous pouvez mettre en forme en chaînes IPv4 ou IPv6 standards :

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()