Guide de l'appareil Chime pour iOS

Le type d'appareil Chime fondamental peut être implémenté à l'aide de la version standard Matter.ChimeTrait basée sur Matter ou de la version personnalisée de Google, Google.ChimeTrait, 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 Matter.IdentifyTrait, 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 suriOS.

Obtenir des informations de base sur un appareil

   Implémenté dans l'application exemple pour iOS   

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 :

let vendorName = basicInfoTrait.attributes.vendorName!
let vendorID = basicInfoTrait.attributes.vendorID!
let productID = basicInfoTrait.attributes.productID!
let productName = basicInfoTrait.attributes.productName!
let softwareVersion = basicInfoTrait.attributes.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 ChimeDeviceType peut comporter plusieurs parties, les développeurs sont encouragés à traiter toutes les sonneries comme des appareils multiparties. 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 appareil faisant partie d'un appareil carillon parent et 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 GoogleHomeSDK
import GoogleHomeTypes

typealias ChimeTrait = Matter.ChimeTrait
typealias OpenCloseTrait = Google.OpenCloseTrait

// Fetch devices using the multipart device model.
let multipartDevices = try await home.devices(enableMultipartDevices: true).list()

guard let chimeParentDevice = multipartDevices.first(where: {
  $0.types.contains(ChimeDeviceType.self)
}) else { return }

guard let doorDevice = multipartDevices.first(where: {
  $0.types.contains(GoogleDoorDeviceType.self)
}) else { return }

// Extract the AutomationPartPath for the specific Chime part
guard let chimeType = await chimeParentDevice.types.get(ChimeDeviceType.self),
  let chimePartPath = chimeParentDevice.automationPart(chimeType) else {
  return
}

let starterNode = starter(doorDevice, GoogleDoorDeviceType.self, OpenCloseTrait.self)

let doorOpenClose = stateReader(doorDevice, GoogleDoorDeviceType.self, OpenCloseTrait.self)

// Build the automation
let chimeAutomation = automation(
  name: "Multipart Chime Demo",
  description: "Activate the chime when the door is opened"
) {
starterNode
condition {
  starterNode.openPercent.unwrapOptional().greaterThan(0)
}
  // Action: Play a chime sound
  action(chimePartPath) {
    ChimeTrait.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.

let lightConnectivity =
  dimmableLightDeviceType.metadata.sourceConnectivity
  .connectivityState

L'état partiallyOnline peut s'afficher en cas de types d'appareils mixtes lorsqu'il n'y a pas de connexion 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 de GeneralDiagnosticsTrait. Les adresses sont renvoyées sous forme d'objets Data, que vous pouvez mettre au format de chaînes IPv4 ou IPv6 standard à l'aide du framework Network :

func getIpAddresses(trait: Matter.GeneralDiagnosticsTrait) -> [String] {
  let interfaces = trait.attributes.networkInterfaces ?? []
  var ipAddresses: [String] = []

  for interface in interfaces {
    for data in interface.iPv4Addresses {
      if let ipv4 = IPv4Address(data) {
        ipAddresses.append(String(describing: ipv4))
      }
    }
    for data in interface.iPv6Addresses {
      if let ipv6 = IPv6Address(data) {
        ipAddresses.append(String(describing: ipv6))
      }
    }
  }

  return ipAddresses
}