Anleitung für Türklingelgeräte für iOS

Der Gerätetyp „Türklingel“ wird mit drei Attributen implementiert: PushAvStreamTransportTrait, das die Übertragung von Audio- und Videostreams über Push-basierte Protokolle übernimmt, WebRtcLiveViewTrait, das die Steuerung von Livestreams und Talkback ermöglicht, und CameraSnapshotTrait, das im Cache gespeicherte Vorschauschnappschüsse und Live-Schnappschüsse bereitstellt.

Prüfe immer, ob ein Gerät die Attribute und Befehle unterstützt, bevor du Funktionen verwendest oder versuchst, Attribute zu aktualisieren. Weitere Informationen findest du unter Geräte aufiOSsteuern.

Grundlegende Informationen zu einem Gerät abrufen

   In der Beispiel-App für iOS implementiert   

Das Attribut BasicInformation enthält Informationen wie den Namen des Anbieters, die Anbieter-ID, die Produkt-ID, den Produktnamen (einschließlich Modellinformationen) und die Softwareversion für ein Gerät:

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!

Seriennummer abrufen

   In der Beispiel-App für iOS implementiert   

Verwende den Befehl GetSerialNumber des Attributs ExtendedBasicInformation, um die Seriennummer des Geräts abzurufen. Im Beispiel wird die Seriennummer in einer Variablen namens serialNumber gespeichert:

// Assuming extendedBasicInformationTrait: Google.ExtendedBasicInformationTrait
let response = try await extendedBasicInformationTrait.getSerialNumber()
let serialNumber = response.serialNumber

Kurzantworten

Mit der Funktion „Kurzantworten“ können Nutzer eine vordefinierte Nachricht an eine Türklingel senden.

Diese Funktion ist nur auf Türklingeln verfügbar. Die Liste der vordefinierten Nachrichten ist für die Partner-App verfügbar, die sie dem Nutzer zur Auswahl anbieten kann. Vordefinierte Nachrichten können nicht von Nutzern bearbeitet werden.

Kurzantworten werden über das Attribut PresetMessage implementiert.

Voreingestellte Nachricht abspielen

Wenn Sie eine voreingestellte Nachricht abspielen möchten, rufen Sie die Methode playPresetMessage auf und übergeben Sie einen der Stringwerte aus dem Attribut availablePhraseTypes.

import GoogleHomeSDK
import GoogleHomeTypes

func playDoorbellPresetMessage(device: HomeDevice, phraseTypeString: String) async {
    // 1. Retrieve the GoogleDoorbellDeviceType helper on the device
    guard let doorbellDeviceType = await device.types.get(GoogleDoorbellDeviceType.self) else {
        print("This device is not a Google Doorbell or is currently uninitialized.")
        return
    }

    // 2. Extract the Google.PresetMessageTrait
    guard let presetMessageTrait = doorbellDeviceType.traits[Google.PresetMessageTrait.self] else {
        print("PresetMessageTrait is not supported on this device.")
        return
    }

    // 3. (Optional) Check available phrase types supported by the device
    if let availablePhrases = presetMessageTrait.attributes.availablePhraseTypes {
        let phraseTypeNames = availablePhrases.map { $0.phraseType }
        print("Supported quick response phrases: \(phraseTypeNames)")
    }

    // 4. Send the playPresetMessage command asynchronously
    do {
        try await presetMessageTrait.playPresetMessage(phraseType: phraseTypeString)
        print("Preset message successfully requested.")
    } catch {
        print("SDK error occurred playing preset message: \(error)")
    }
}

Gesprochene Sprache festlegen

Gesprochene Sprache festlegen

Mit der Methode setActiveLocale des Attributs LocalizationConfiguration kannst du die aktive gesprochene Sprache eines Geräts auf eine bestimmte Sprache festlegen (z. B. „de_DE“).

// Setting the active language
// Assuming localizationConfigurationTrait: Matter.LocalizationConfigurationTrait
let selectedLocale = "en_US"
try await localizationConfigurationTrait.update {
    $0.setActiveLocale(selectedLocale)
}

Letzten Zeitpunkt des Cloud-Kontakts des Geräts abrufen

Wenn Sie herausfinden möchten, wann das Gerät zuletzt Kontakt mit der Cloud hatte, verwenden Sie das Attribut lastContactTimestamp des Attributs ExtendedGeneralDiagnostics:

if let lastContactTimeStamp = extendedGeneralDiagnosticsTrait.attributes.lastContactTimestamp {
  self.lastContactTime = Date(timeIntervalSince1970: Double(lastConnectedTimeStamp))
}

Einstellungen für die Kamerahalterung

Das Attribut Mount enthält Einstellungen und Statusinformationen zur Kamerahalterung. Sie können Attribute wie den Bereitstellungsstatus, den Erkennungstyp und den Namen des Bereitstellungstyps lesen. Außerdem können Sie das Attribut Mount verwenden, um die Standardkonfiguration des Bereitstellungstyps zu überschreiben.

// 1. Get the Mount trait
guard let mountTrait = deviceType.traits[Google.MountTrait.self] else {
  print("Mount trait not supported or configured on this device.")
  return
}

// 2. Read the current mount state, detection type, and type name
let mountState         = mountTrait.attributes.mountState         // Type: Google.MountTrait.MountStateEnum?
let mountDetectionType = mountTrait.attributes.mountDetectionType // Type: Google.MountTrait.MountDetectionTypeEnum?
let mountTypeName      = mountTrait.attributes.mountTypeName      // Type: String?

// 3. Update the mount type override
try await mountTrait.update { mutableTrait in
  mutableTrait.setMountTypeOverride(.official)
}

Verbindung eines Geräts prüfen

Die Konnektivität eines Geräts wird auf der Ebene des Gerätetyps geprüft, da einige Geräte mehrere Gerätetypen unterstützen. Der zurückgegebene Status ist eine Kombination der Verbindungsstatus aller Attribute auf diesem Gerät.

let doorbellConnectivity = doorbellDeviceType.metadata.sourceConnectivity.connectivityState

Der Status partiallyOnline kann bei gemischten Gerätetypen auftreten, wenn keine Internetverbindung besteht. Matter-Standard-Traits sind aufgrund des lokalen Routings möglicherweise noch online, cloudbasierte Traits sind jedoch offline.

IP-Adresse des Geräts abrufen

Verwenden Sie das Attribut networkInterfaces von GeneralDiagnosticsTrait, um die IP-Adresse des Geräts zu ermitteln. Die Adressen werden als Data-Objekte zurückgegeben, die Sie mit dem Network-Framework in IPv4- oder IPv6-Standardstrings formatieren können:

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
}

Livestream starten

   In der Beispiel-App für iOS implementiert   

Wenn du einen Livestream starten möchtest, sende den SDP-String (Session Description Protocol) an die Methode startLiveView(offerSdp:) des Attributs WebRtcLiveViewTrait. Diese Methode gibt drei Werte zurück:

• Das SDP für die Sitzung.
• Die Sitzungsdauer in Sekunden.
• Die Sitzungs-ID, mit der die Sitzung verlängert oder beendet werden kann.

public func sendOffer(offerSdp: String) async throws
-> (answerSdp: String, mediaSessionId: String, liveViewDuration: TimeInterval)
{
  do {
    // Sending StartLiveView command
    let response = try await liveViewTrait.startLiveView(
      offerSdp: offerSdp
    )
    // Received StartLiveView response
    return (
      answerSdp: response.answerSdp,
      mediaSessionId: response.mediaSessionId,
      liveViewDuration: TimeInterval(response.liveSessionDurationSeconds)
    )
  } catch {
    // Failed to send StartLiveView command
    throw error
  }
}

Livestream verlängern

   In der Beispiel-App für iOS implementiert   

Livestreams haben eine voreingestellte Dauer, nach der sie ablaufen. Wenn Sie die Dauer eines aktiven Streams verlängern möchten, senden Sie eine Verlängerungsanfrage mit der Methode extendLiveView(mediaSessionId:optionalArgsProvider:):

public func extendLiveView(mediaSessionId: String) async throws {
  do {
    // Extending live view
    let extendedDuration = try await liveViewTrait.extendLiveView(mediaSessionId: mediaSessionId)
  } catch {
    // Failed to extend live view
    throw error
  }
}

TalkBack starten und beenden

   In der Beispiel-App für iOS implementiert   

Wenn Sie TalkBack starten möchten, rufen Sie die Methode startTalkback(mediaSessionId:optionalArgsProvider:) des Attributs WebRtcLiveViewTrait auf. Verwenden Sie stopTalkback(mediaSessionId:), um die Wiedergabe zu beenden.

public func toggleTwoWayTalk(isOn: Bool, mediaSessionId: String) async throws {
  do {
    if isOn {
      try await liveViewTrait.startTalkback(mediaSessionId: mediaSessionId)
    } else {
      try await liveViewTrait.stopTalkback(mediaSessionId: mediaSessionId)
    }
  } catch {
    throw HomeError.commandFailed("Failed to toggle twoWayTalk: \(error)")
  }
}

Livestream verwalten

   In der Beispiel-App für iOS implementiert   

Das Anpassen der Livestream-Qualität ist nützlich, um die Bandbreitennutzung basierend auf dem Anzeigekontext des Clients zu optimieren. Beispielsweise kann zu einer niedrigeren Auflösung gewechselt werden, wenn eine kleinere Vorschaukachel, eine Rasteransicht oder der Bild-im-Bild-Modus angezeigt wird.

Wenn du die Qualität dynamisch mit dem Attribut WebRtcLiveView änderst, wird die Auflösung der aktiven Livestream-Sitzung auf einem bestimmten Client verwaltet. Dies ist nicht dasselbe wie die Konfiguration einer geräteweiten Einstellung für die Bandbreitennutzung direkt auf dem Gerät, die sich auf alle gleichzeitigen Zuschauer und die Qualität der in der Cloud gespeicherten Videoaufnahmen auswirken würde.

Das folgende Beispiel zeigt, wie du die Livestream-Qualität für ein Gerät abrufen und aktualisieren kannst:

• Unterstützte Qualitätsoptionen abrufen: Rufe die verfügbaren Streamingauflösungen ab, die vom Gerät unterstützt werden. Der Code fragt das Attribut WebRtcLiveView ab, um die unterstützten Streamqualitäten als Liste von QualityHint-Werten (z. B. .sd, .hd, .fhd, .qhd oder .uhd) mithilfe der Property supportedQualityHints verfügbar zu machen.

• Livestream-Qualität ändern: Wende eine ausgewählte QualityHint an, um die Streaming-Auflösung des aktiven Livestreams zu ändern (z. B. von Standard Definition zu High Definition). Die Funktion updateQualityHint verwendet die Methode changeLiveViewQuality des Attributs WebRtcLiveView, um die ausgewählte QualityHint-Konfiguration auf die aktive Mediensitzung anzuwenden.

public var supportedQualityHints: [Google.WebRtcLiveViewTrait.QualityHint] {
  return liveViewTrait?.attributes.supportedQualityHints ?? []
}

public func updateQualityHint(
  liveViewTrait: Google.WebRtcLiveViewTrait,
  hint: Google.WebRtcLiveViewTrait.QualityHint,
  mediaSessionId: String
) async {
  do {
    _ = try await liveViewTrait.changeLiveViewQuality(
      mediaSessionId: mediaSessionId,
      qualityHint: hint
    )
  } catch {
    // error
  }
}

Aufzeichnungsfunktion aktivieren und deaktivieren

Wenn du die Aufnahmefunktion der Kamera aktivieren möchtest, übergib TransportStatusEnum.Active an die Methode setTransportStatus(transportStatus:optionalArgsProvider:) des Traits PushAvStreamTransportTrait. Wenn Sie die Aufzeichnungsfunktion deaktivieren möchten, übergeben Sie TransportStatusEnum.Inactive. Im folgenden Beispiel werden diese Aufrufe in einem einzigen Aufruf zusammengefasst, bei dem ein Boolean verwendet wird, um die Aufnahmefunktion ein- oder auszuschalten:

public func toggleIsRecording(isOn: Bool) {
  self.uiState = .loading

  guard let pushAvStreamTransportTrait else {
    // PushAvStreamTransportTrait not found.
    return
  }
  Task {
    do {
      try await pushAvStreamTransportTrait.setTransportStatus(
        transportStatus: isOn ? .active : .inactive)
      if isOn {
        do {
          self.player = try self.createWebRtcPlayer()
        } catch {
          // Failed to initialize WebRtcPlayer
          self.uiState = .disconnected
          return
        }
        await self.player?.initialize()
        self.uiState = .live
      } else {
        self.player = nil
        self.uiState = .off
      }
    } catch {
      // Failed to toggle onOff
    }
  }
}

Das Aktivieren oder Deaktivieren der Aufnahmefunktion der Kamera entspricht dem Ein- oder Ausschalten des Kameravideos. Wenn das Video einer Kamera eingeschaltet ist, zeichnet sie auf (für Ereignisse und zugehörige Clips).

Wenn die Aufnahmefunktion deaktiviert ist (die Kamera ist ausgeschaltet):

• Die Kamera kann gemäß dem connectivityState des Gerätetyps weiterhin als online angezeigt werden.
• Auf den Livestream kann nicht zugegriffen werden und die Kamera erkennt keine Cloud-Ereignisse.

Prüfen, ob die Aufzeichnungsfunktion aktiviert ist

Wenn du wissen möchtest, ob die Aufnahmefunktion einer Kamera aktiviert ist, prüfe, ob Verbindungen aktiv sind. Im folgenden Beispiel werden dazu zwei Funktionen definiert:

public func isDeviceRecording() -> Bool {
  guard let pushAvStreamTransportTrait else {
    // PushAvStreamTransportTrait not found.
    return false
  }
  guard
    let hasActiveConnection =
      pushAvStreamTransportTrait
      .attributes
      .currentConnections?
      .contains(where: { $0.transportStatus == .active })
  else {
    return false
  }
  return hasActiveConnection
}

Kamera-Snapshots abrufen

   In der Beispiel-App für iOS implementiert   

Verwende das Attribut CameraSnapshot, um statische Bild-Snapshots von einer Kamera abzurufen. Diese Snapshots sind in verschiedenen Szenarien hilfreich:

• Als Platzhalter-Kachel in der Benutzeroberfläche, während ein WebRTC-Livestream geladen wird.
• Als statisches Vorschaubild, das bei Nutzerinteraktion zu einem Livestream wird.
• Als Hintergrund-Canvas zum Zeichnen und Konfigurieren benutzerdefinierter Alarmbereiche.

Das Attribut CameraSnapshot bietet zwei Möglichkeiten, Snapshots abzurufen, je nachdem, ob du einen im Cache gespeicherten Snapshot für schnelles Rendering oder einen On-Demand-Live-Snapshot benötigst.

Snapshot einer im Cache gespeicherten Vorschau abrufen

Ein Vorschauschnappschuss ist ein im Cache gespeichertes Bild, das das SDK abrufen kann, ohne die Kamera zu aktivieren. Dies ist die schnellste Methode, um ein statisches Bild abzurufen, und eignet sich ideal für Kameraübersichtsseiten oder Dashboard-Raster.

Wenn du den Vorschauschnappschuss abrufen möchtest, lies das Attribut preview_image_url:

guard let cameraSnapshotTrait = deviceType.traits[
  Google.CameraSnapshotTrait.self
] else {
  print("CameraSnapshot trait not supported on this device.")
  return
}

if let previewImageUrlString = cameraSnapshotTrait
  .attributes.preview_image_url,
   let url = URL(string: previewImageUrlString) {
  // Load the preview image from the URL
}

Je nach Kamerakonfiguration und Aktivität verweist die Vorschau-URL auf ein im Cache gespeichertes Bild, das aus aktuellen Videoaufnahmen (dem ersten I-Frame des neuesten Videofragments) generiert wurde, oder auf eine Momentaufnahme, die regelmäßig von der Kamera hochgeladen wird.

Um die Aktualität des Bildes anzugeben, bettet die Google Home-Cloud einen X-Home-Image-Captured-At-Header im bereitgestellten JPEG-/PNG-Bild ein, der im UTC-Format formatiert ist. Sie können diesen Header auf der Clientseite parsen, um das Alter des Snapshots in einer App anzuzeigen.

On-Demand-Live-Snapshot abrufen

Für User Journeys, die den aktuellen Livestream der Kamera erfordern, z. B. das Einrichten von Alarmbereichen, kannst du einen Live-Snapshot anfordern. Wenn du einen Live-Snapshot auslöst, wird die Kamera aktiviert, nimmt ein neues Bild auf und lädt es in die Cloud hoch.

Verwenden Sie den Befehl getLiveSnapshot(), um einen Live-Snapshot anzufordern:

do {
  let response = try await cameraSnapshotTrait.getLiveSnapshot()
  let snapshotUrlString = response.snapshot_url

  if let url = URL(string: snapshotUrlString) {
    // Load the live snapshot image from the URL
  }
} catch {
  print("Failed to get live snapshot: \(error)")
}

Snapshot-Anfragen authentifizieren

   In der Beispiel-App für iOS implementiert   

Alle Snapshot-URLs verweisen auf sichere Medien und erfordern ein OAuth 2.0-Token für den Bereich der Home APIs v2. Zum Herunterladen und Rendern der Bilder muss das OAuth-Token als Inhabertoken in den Authorization-Header Ihrer HTTP-Anfrage eingefügt werden.

Das folgende Beispiel zeigt, wie Sie eine sichere Netzwerkanfrage zum Herunterladen eines Snapshots konfigurieren:

import UIKit

func loadSnapshotImage(from url: URL, home: Home) async -> UIImage? {
  do {
    // 1. Retrieve the OAuth access token from the Home APIs SDK
    let (accessToken, _) = try await home.permissions.authorization()

    // 2. Configure the HTTP GET request with the Bearer token
    var request = URLRequest(url: url)
    request.setValue(
      "Bearer \(accessToken)",
      forHTTPHeaderField: "Authorization"
    )

    // 3. Fetch the image data
    let (data, _) = try await URLSession.shared.data(for: request)
    return UIImage(data: data)
  } catch {
    print("Error loading snapshot image: \(error)")
    return nil
  }
}

Akkueinstellungen

Über die Home APIs können verschiedene Akkueinstellungen gesteuert werden.

Einstellung für die Akkunutzung festlegen

Mit der Energiebilanz kannst du den Kompromiss zwischen Akkulaufzeit und Leistung für ein Gerät konfigurieren. Sie können verschiedene Akkuprofile erstellen, z. B. „Erweitert“, „Ausgewogen“ und „Leistung“, und zwischen ihnen wechseln.

Diese Funktion wird durch Aktualisieren des Attributs currentEnergyBalance des Attributs EnergyPreference implementiert. Das Attribut akzeptiert einen Ganzzahlindex, der einem bestimmten Profil entspricht, das in der energyBalances-Liste des Geräts definiert ist (z. B. 0 für EXTENDED, 1 für BALANCED und 2 für PERFORMANCE).

Der Wert null für currentEnergyBalance gibt an, dass das Gerät ein benutzerdefiniertes Profil verwendet. Dies ist ein schreibgeschützter Status.

Im Folgenden finden Sie ein Beispiel für eine Struktur, die das Attribut currentEnergyBalance verwendet, gefolgt vom eigentlichen Code-Snippet, das das Attribut verwendet.

// Example energyBalances list
{
  "energy_balances": [
    {
      "step": 0,
      "label": "EXTENDED"
    },
    {
      "step": 50,
      "label": "BALANCED"
    },
    {
      "step": 100,
      "label": "PERFORMANCE"
    }
  ]
}

private func setBatteryUsage(to option: UInt8) async throws {
  _ = try await energyPreferenceTrait.update {
    $0.setCurrentEnergyBalance(option)
  }
}

Automatischen Energiesparmodus aktivieren

   In der Beispiel-App für iOS implementiert   

Aktualisieren Sie zum Konfigurieren dieser Funktion das Attribut currentLowPowerModeSensitivity des Attributs EnergyPreference. Dieses Attribut verwendet einen Index, um eine Empfindlichkeitsstufe auszuwählen, wobei 0 normalerweise für Disabled und 1 für Enabled oder Automatic steht.

private func setAutoBatterySaver(to value: Bool) async throws {
  _ = try await energyPreferenceTrait.update {
    $0.setCurrentLowPowerModeSensitivity(value ? 1 : 0)
  }
}

Akkuladestatus abrufen

   In der Beispiel-App für iOS implementiert   

Verwende das Attribut batChargeState des Attributs PowerSource, um den aktuellen Ladestatus des Geräts abzurufen (wird geladen, vollständig geladen oder wird nicht geladen).

self.chargingState = powerSourceTrait.attributes.batChargeState

var description: String
switch self.chargingState {
case .isCharging:
  description = "Charging"
case .isAtFullCharge:
  description = "Full"
case .isNotCharging:
  description = "Not Charging"
default:
  description = "Unknown"
}

Akkustand abrufen

Verwende das Attribut batChargeLevel des Traits PowerSource, um den aktuellen Akkustand abzurufen. Die Stufe ist entweder OK, Warning (niedrig) oder Critical.

self.batteryLevel = powerSourceTrait.attributes.batChargeLevel

var description: String
switch self.batteryLevel {
case .ok:
  description = "OK"
case .warning:
  description = "Warning"
case .critical:
  description = "Critical"
default:
  description = "Unknown"
}

Stromquelle abrufen

Verwende die Attribute BatPresent und wiredPresent des Traits PowerSource, um die Stromquelle des Geräts zu ermitteln.

if powerSourceTrait.attributes.wiredPresent ?? false {
  self.powerSourceType = .wired
} else if powerSourceTrait.attributes.batPresent ?? false {
  self.powerSourceType = .battery
} else {
  self.powerSourceType = nil
}

Prüfen, ob die Batterie ausgetauscht werden muss

Das Attribut batReplaceability gibt an, ob der Akku nicht austauschbar, vom Nutzer austauschbar oder im Werk austauschbar ist.

Wenn die Batterie austauschbar ist, gibt das Attribut batReplacementNeeded des Traits PowerSource an, ob die Batterie ausgetauscht werden muss.

// Get the battery replacement status
var batteryStatus = powerSourceTrait.attributes.batReplacementNeeded

if batteryStatus {
  print("Replace the battery.")
}

Wenn der Akku vom Nutzer ausgetauscht werden kann, wird er im batReplacementDescription beschrieben, einschließlich Informationen wie Formfaktor, chemische Zusammensetzung und bevorzugter Hersteller.

Audioeinstellungen

Über die Home APIs können verschiedene Audioeinstellungen gesteuert werden.

Mikrofon ein- und ausschalten

Wenn du das Mikrofon des Geräts ein- oder ausschalten möchtest, aktualisiere das Attribut microphoneMuted des Attributs CameraAvStreamManagementTrait mit der integrierten Funktion setMicrophoneMuted:

// Turn the device's microphone on or off
func setMicrophone(on: Bool) async {
  do {
    _ = try await self.cameraAvStreamManagementTrait?.update {
      $0.setMicrophoneMuted(!on)
    }
  } catch {
    // Error
  }
}

Audioaufnahme ein- oder ausschalten

Wenn du die Audioaufnahme für das Gerät aktivieren oder deaktivieren möchtest, aktualisiere das Attribut recordingMicrophoneMuted des Attributs CameraAvStreamManagementTrait mit der integrierten Funktion setRecordingMicrophoneMuted:

// Turn audio recording on or off for the device
func setAudioRecording(on: Bool) async {
  do {
    _ = try await self.cameraAvStreamManagementTrait?.update {
      $0.setRecordingMicrophoneMuted(!on)
    }
  } catch {
    // Error
  }
}

Lautstärke des Lautsprechers anpassen

Wenn du die Lautsprecherlautstärke des Geräts anpassen möchtest, aktualisiere das Attribut speakerVolumeLevel des Attributs CameraAvStreamManagementTrait mit der integrierten Funktion setSpeakerVolumeLevel:

// Adjust the camera speaker volume
func setSpeakerVolume(to value: UInt8) async {
  do {
    _ = try await cameraAvStreamManagementTrait.update {
      $0.setSpeakerVolumeLevel(value)
    }
  } catch {
    // Error
  }
}

Einstellungen für Alarmbereiche

   In der Beispiel-App für iOS implementiert   

Das Attribut ZoneManagement bietet eine Schnittstelle zum Verwalten benutzerdefinierter Alarmbereiche auf Kamera- und Türklingelgeräten. Diese Bereiche werden verwendet, um die Ereigniserkennung (z. B. Bewegungen von Personen oder Fahrzeugen) auf bestimmte Bereiche im Sichtfeld des Geräts zu beschränken.

Alarmbereiche werden vom Nutzer in einer Partner-App konfiguriert. Er kann Bereiche über bestimmte Bereiche im Sichtfeld der Kamera zeichnen. Diese benutzerdefinierten Zonen werden dann in die von diesem Attribut verwendeten Strukturen übersetzt. Weitere Informationen zur Funktionsweise von Alarmbereichen findest du unter Alarmbereiche einrichten und verwenden.

Alarmbereiche werden normalerweise mit zweidimensionalen kartesischen Koordinaten definiert. Das Attribut stellt die TwoDCartesianVertexStruct für Eckpunkte und die TwoDCartesianZoneStruct für die Zonendefinition (Name, Eckpunkte, Farbe und Verwendung) bereit.

Alarmbereiche prüfen

Wenn du Alarmbereiche anzeigen lassen möchtest, prüfe das Attribut zones des Merkmals ZoneManagement.

let zoneManagementTrait: Google.ZoneManagementTrait

self.zones = zoneManagementTrait.attributes.zones ?? []

Alarmbereich hinzufügen

Verwenden Sie zum Erstellen einer neuen Zone den Befehl createTwoDCartesianZone. Dieser Befehl verwendet ein TwoDCartesianZoneStruct, das den Namen, die Eckpunkte, die Farbe und die Verwendung der Zone definiert.

Im folgenden Beispiel wird gezeigt, wie Sie einen Bereich namens „Veranda“ mit vier Eckpunkten erstellen, der lachsfarben (#F439A0) ist und für die Bewegungserkennung verwendet wird.

import GoogleHomeSDK
import GoogleHomeTypes

func createFrontPorchZone(trait: Google.ZoneManagementTrait) async {
  // 1. Define the vertices for the zone (2D Cartesian coordinates)
  // Values are UInt16, typically scaled to the device's twoDCartesianMax.
  let vertices = [
    Google.ZoneManagementTrait.TwoDCartesianVertexStruct(x = 260, y = 422),
    Google.ZoneManagementTrait.TwoDCartesianVertexStruct(x = 1049, y = 0),
    Google.ZoneManagementTrait.TwoDCartesianVertexStruct(x = 2048, y = 0),
    Google.ZoneManagementTrait.TwoDCartesianVertexStruct(x = 2048, y = 950),
    Google.ZoneManagementTrait.TwoDCartesianVertexStruct(x = 1630, y = 1349),
    Google.ZoneManagementTrait.TwoDCartesianVertexStruct(x = 880, y = 2048),
    Google.ZoneManagementTrait.TwoDCartesianVertexStruct(x = 0, y = 2048),
    Google.ZoneManagementTrait.TwoDCartesianVertexStruct(x = 638, y = 1090)
  ]

  // 2. Define the zone structure using the given SDK struct
  let newZone = Google.ZoneManagementTrait.TwoDCartesianZoneStruct(
    name: "Front Porch",
    use: [.motion], // ZoneUseEnum.motion
    vertices: vertices,
    // Color is a hex string (for example, Salmon/Pink)
    color: "#F439A0"
  )

  do {
    // 3. Execute the raw command to add the zone to the device
    // This returns the created zone's ID (UInt16).
    var newZoneID = try await trait.createTwoDCartesianZone(zone: newZone)
  } catch {
    // Error
  }
}

Alarmbereich aktualisieren

Verwenden Sie zum Aktualisieren einer vorhandenen Zone den Befehl updateTwoDCartesianZone. Für diesen Befehl sind die zoneId und die aktualisierte TwoDCartesianZoneStruct erforderlich.

let zoneManagementTrait: Google.ZoneManagementTrait
let zoneID: UInt16
let zone: Google.ZoneManagementTrait.TwoDCartesianZoneStruct

do {
  _ = try await zoneManagementTrait.updateTwoDCartesianZone(
        zoneID: zoneID, zone: zone)
} catch {
  // Error
}

Alarmbereich löschen

Verwenden Sie zum Entfernen einer Zone den Befehl removeZone mit der spezifischen zoneId.

let zoneManagementTrait: Google.ZoneManagementTrait
let zoneID: UInt16

do {
  _ = try await zoneManagementTrait.removeZone(zoneID: zoneID)
} catch {
  // Error
}

Geräuschereignis-Trigger

Das Attribut AvStreamAnalysis bietet eine Schnittstelle zum Verwalten von Auslösern für die Ereigniserkennung auf Kamera- und Türklingelgeräten. Während bildbasierte Auslöser (z. B. Personen oder Fahrzeuge) zonenspezifisch sein können, sind geräuschbezogene Auslöser in der Regel Konfigurationen auf Geräteebene.

Die folgenden Triggertypen sind für die Geräuscherkennung mit dem EventTriggerTypeEnum verfügbar:

Status der Geräuscherkennung prüfen

Wenn du den aktuellen Status der Geräuscherkennung anzeigen möchtest, musst du prüfen, was das Gerät unterstützt und was von der Gerätehardware aktiviert wird. Die beiden zu prüfenden Attribute sind:

• supportedEventTriggers
• enabledEventTriggers

In der iOS-Entwicklung greifen Sie normalerweise auf das AvStreamAnalysis-Trait des Geräts zu, um diese Attribute zu lesen.

// Example struct to store event triggers
public struct EventTrigger: Equatable {
  public var id: Google.AvStreamAnalysisTrait.EventTriggerTypeEnum
  public var enabled: Bool
}

let avStreamAnalysisTrait: Google.AvStreamAnalysisTrait

let possibleEventTriggers = avStreamAnalysisTrait.attributes.supportedEventTriggers ?? []
let enabledEventTriggers = avStreamAnalysisTrait.attributes.enabledEventTriggers ?? []

let eventTriggers [EventTrigger] = []
for trigger in possibleEventTriggers {
  self.eventTriggers.append(
    EventTrigger(
      id: trigger,
      enabled: enabledEventTriggers.contains(trigger)
    )
  )
}

Satz aktivierter Trigger aktualisieren

Verwenden Sie den Befehl SetOrUpdateEventDetectionTriggers, um die Gruppe der aktivierten Trigger zu aktualisieren. Dieser Befehl akzeptiert eine Liste von EventTriggerEnablement-Strukturen.

// Example struct to store event triggers
public struct EventTrigger: Equatable {
  public var id: Google.AvStreamAnalysisTrait.EventTriggerTypeEnum
  public var enabled: Bool
}

let avStreamAnalysisTrait: Google.AvStreamAnalysisTrait
let eventTriggers: [EventTrigger]

let enabledEventTriggers = eventTriggers.map {
  Google.AvStreamAnalysisTrait.EventTriggerEnablement(
    eventTriggerType: $0.id,
    enablementStatus: $0.enabled ? .enabled : .disabled
  )
}

try await avStreamAnalysisTrait.setOrUpdateEventDetectionTriggers(
  eventTriggerEnablements: enabledEventTriggers
)

Aufnahmemodi

   In der Beispiel-App für iOS implementiert   

Das Attribut RecordingMode bietet eine Schnittstelle zum Verwalten des Verhaltens bei der Video- und Bildaufzeichnung auf Kamera- und Türklingelgeräten. Nutzer können zwischen der Aufzeichnung rund um die Uhr, dem ereignisbasierten Videoverlauf oder der vollständigen Deaktivierung der Aufzeichnung (nur Live-Ansicht) wählen.

RecordingModeEnum definiert die verfügbaren Aufzeichnungsstrategien:

Aufnahmemodi prüfen

Wenn du die aktuelle Aufzeichnungskonfiguration anzeigen möchtest, prüfe die Attribute des Traits RecordingMode:

• supportedRecordingModes – Alle potenziellen Modi
• availableRecordingModes – Auswählbare Modi
• selectedRecordingMode: Der aktive Modus

// Example struct to store recording modes.
public struct RecordingMode: Hashable {
  public let id: UInt8
  public let mode: Google.RecordingModeTrait.RecordingModeEnum
}

let recordingModeTrait: Google.RecordingModeTrait

if let availableRecordingModes = recordingModeTrait.attributes.availableRecordingModes,
   let supportedRecordingModes = recordingModeTrait.attributes.supportedRecordingModes,
   let selectedRecordingMode = recordingModeTrait.attributes.selectedRecordingMode {

  var recordingModes: [RecordingMode] = []

  for recordingModeId in availableRecordingModes {
    guard Int(recordingModeId) < supportedRecordingModes.count,
          Int(recordingModeId) >= 0 else {
      // Out of bounds error
    }

    recordingModes.append(
      RecordingMode(
        id: recordingModeId,
        mode: supportedRecordingModes[Int(recordingModeId)].recordingMode,
      )
    )
  }
}

Aufnahmemodus ändern

Prüfen Sie vor dem Aktualisieren, ob der ausgewählte Index aus dem Attribut supportedRecordingModes im Attribut availableRecordingModes vorhanden ist.

Verwenden Sie zum Aktualisieren des ausgewählten Modus die Funktion setSelectedRecordingMode und übergeben Sie den Index des ausgewählten Modus:

let recordingModeTrait: Google.RecordingModeTrait
let recordingModeID: UInt8

_ = try await recordingModeTrait.update {
  $0.setSelectedRecordingMode(recordingModeID)
}

Weitere Einstellungen

Über die Home APIs können verschiedene andere Einstellungen gesteuert werden.

Nachtsichtmodus aktivieren oder deaktivieren

Wenn du den Nachtsichtmodus für die Kamera ein- oder ausschalten möchtest, verwende TriStateAutoEnum, um das Attribut nightVision des Merkmals CameraAvStreamManagementTrait mit der integrierten Funktion setNightVision zu aktualisieren:

// Turn night vision on or off
func setNightVision(
  to value: Google.CameraAvStreamManagementTrait.TriStateAutoEnum
) async {
  do {
    _ = try await cameraAvStreamManagementTrait.update {
      $0.setNightVision(value)
    }
  } catch {
    // Error
  }
}

Helligkeit der Status-LED ändern

Wenn du die Helligkeit der Status-LED ändern möchtest, verwende ThreeLevelAutoEnum, um das Attribut statusLightBrightness des Merkmals CameraAvStreamManagementTrait mit der integrierten Funktion setStatusLightBrightness zu aktualisieren:

// Set the LED brightness
func setStatusLightBrightness(
  to value: Google.CameraAvStreamManagementTrait.ThreeLevelAutoEnum
) async {
  do {
    _ = try await cameraAvStreamManagementTrait.update {
      $0.setStatusLightBrightness(value)
    }
  } catch {
    // Error
  }
}

Kamera-Darstellungsbereich ändern

Das Sichtfeld der Kamera entspricht der Funktion „Zoomen und zuschneiden“, die im Hilfeartikel Video der Nest-Kamera zoomen und optimieren beschrieben wird.

Der Darstellungsbereich wird in einem ViewportStruct definiert, das vier Werte enthält, die als Koordinaten des Darstellungsbereichs verwendet werden. Die Koordinaten sind so definiert:

(x1,y1) -- (x2,y1)
   |          |
(x1,y2) -- (x2,y2)

Die Werte für ViewportStruct hängen von der Benutzeroberfläche und der Kameraimplementierung einer App ab. Auf einer sehr einfachen Ebene aktualisierst du das Attribut viewport des Attributs CameraAvStreamManagementTrait mit einem ViewportStruct, um den Darstellungsbereich des Kameravideos festzulegen. Verwende dazu die integrierte Funktion setViewport.

func setCrop(x1: UInt16, y1: UInt16, x2: UInt16, y2: UInt16) {

  let viewport = Google.CameraAvStreamManagementTrait.ViewportStruct(
    x1: x1,
    y1: y1,
    x2: x2,
    y2: y2
  )

  Task {
    do {
      try await cameraAvStreamManagementTrait.update {
        $0.setViewport(viewport)
      }
    } catch {
      // Error
    }
  }

}

TransportOptionsStruct generieren

Für einige Einstellungen müssen Attribute in einer TransportOptionsStruct geändert werden, die dann an die Transportoptionen einer Streamingverbindung übergeben wird. In Swift muss diese Struktur generiert werden, bevor Attribute aktualisiert werden können.

Verwenden Sie diese Hilfsfunktion, um die Struktur für die folgenden Einstellungsänderungen zu generieren:

• Empfindlichkeit für die Beendigung des Ruhemodus anpassen
• Maximale Ereignisdauer anpassen

func getTransportOptions(
  transportOptions: Google.PushAvStreamTransportTrait.TransportOptionsStruct,
  wakeUpSensitivity: UInt8?,
  maxEventLength: UInt32?
) async throws
  -> Google.PushAvStreamTransportTrait.TransportOptionsStruct
{

  var newMotionTimeControl:
    Google.PushAvStreamTransportTrait.TransportMotionTriggerTimeControlStruct? = nil
  if let maxEventLength {
    guard let motionTimeControl = transportOptions.triggerOptions.motionTimeControl else {
      throw HomeError.failedPrecondition(
        // Error - cannot update max event length without motion time control
    }
    newMotionTimeControl =
      Google.PushAvStreamTransportTrait.TransportMotionTriggerTimeControlStruct(
        initialDuration: motionTimeControl.initialDuration,
        augmentationDuration: motionTimeControl.augmentationDuration,
        maxDuration: maxEventLength,
        blindDuration: motionTimeControl.blindDuration
      )
  }

  return Google.PushAvStreamTransportTrait.TransportOptionsStruct(
    streamUsage: .recording,
    videoStreamID: nil,
    audioStreamID: nil,
    tlsEndpointID: transportOptions.tlsEndpointID,
    url: transportOptions.url,
    triggerOptions: Google.PushAvStreamTransportTrait.TransportTriggerOptionsStruct(
      triggerType: .motion,
      motionZones: nil,
      motionSensitivity: wakeUpSensitivity,
      motionTimeControl: newMotionTimeControl,
      maxPreRollLen: nil
    ),
    ingestMethod: .cmafIngest,
    containerOptions: Google.PushAvStreamTransportTrait.ContainerOptionsStruct(
      containerType: .cmaf,
      cmafContainerOptions: nil
    ),
    expiryTime: nil
  )
}

private func getRecordingConnection() async throws
  -> Google.PushAvStreamTransportTrait.TransportConfigurationStruct?
{
  guard let pushAvStreamTransportTrait else {
    // Error - PushAvStreamTransport trait not available
    return nil
  }

  let connections = try await pushAvStreamTransportTrait.findTransport().transportConfigurations

  for connection in connections {
    guard let transportOptions = connection.transportOptions,
      transportOptions.streamUsage == .recording
    else {
      continue
    }

    return connection
  }

  return nil
}

Analysen aktivieren oder deaktivieren

Für jedes Gerät kann einzeln festgelegt werden, ob detaillierte Analysedaten an die Google Home-Cloud gesendet werden sollen (siehe Cloud Monitoring für Home APIs).

Wenn Sie die Analyse für ein Gerät aktivieren möchten, setzen Sie das Attribut analyticsEnabled) von ExtendedGeneralDiagnosticsTrait auf true. Wenn du analyticsEnabled festlegst, wird eine andere Property, logUploadEnabled, automatisch auf true gesetzt. Dadurch können die Analyseloggdateien in die Google Home-Cloud hochgeladen werden.

// Enable analytics
_ = try await extendedGeneralDiagnosticsTrait.update {
  $0.setAnalyticsEnabled(true)
}

// Disable analytics
_ = try await extendedGeneralDiagnosticsTrait.update {
  $0.setAnalyticsEnabled(false)
}

Transport- und Aufzeichnungskonfigurationen

In diesem Abschnitt werden die Einstellungen für die Qualität des Kamerastreams und die Ereignisauslösung behandelt. Diese Einstellungen werden über das Attribut PushAvStreamTransport verwaltet.

Transporteinstellungen lesen

In diesem Abschnitt wird gezeigt, wie du die aktuelle Konfiguration einer Kamera oder Türklingel abrufst. Es ruft das Attribut PushAvStreamTransport ab, sucht die für die Aufzeichnung verwendete Verbindung und extrahiert dann die aktuellen Werte für die Bandbreitenqualität, die Empfindlichkeit für die Beendigung des Ruhemodus und die maximale Ereignislänge.

// Assuming access to
// var pushAvStreamTransportTrait: Google.PushAvStreamTransportTrait
let connections = try await pushAvStreamTransportTrait.findTransport().transportConfigurations

// Locate the connection designated for recording
let recordingConnection = connections.first { connection in
    guard let transportOptions = connection.transportOptions else { return false }
    return transportOptions.streamUsage == .recording
}

let options = recordingConnection?.transportOptions

// 1. Bandwidth Quality (Video Stream ID)
let videoStreamId = options?.videoStreamID

// 2. Wake-up Sensitivity (Motion Sensitivity)
let wakeUpSensitivity = options?.triggerOptions.motionSensitivity

// 3. Max Event Length (Motion Trigger Time Control)
let maxEventLength = options?.triggerOptions.motionTimeControl?.maxDuration

Transporteinstellungen aktualisieren

In diesem Abschnitt wird beschrieben, wie Sie die Transporteinstellungen ändern. Es wird ein neues TransportOptionsStruct mit den neuen Werten erstellt und dann der Befehl modifyPushTransport verwendet, um diese aktualisierten Einstellungen an das Gerät zurückzusenden und auf die im vorherigen Schritt gefundene Aufzeichnungsverbindung anzuwenden.

Verwenden Sie zum Ändern dieser Einstellungen den Befehl modifyPushTransport mit einem TransportOptionsStruct.

// Example: Updating to Max Quality and 30s duration
let currentOptions = recordingConnection!.transportOptions!
let newOptions = Google.PushAvStreamTransportTrait.TransportOptionsStruct(
    streamUsage: .recording,
    videoStreamID: 2, // Max Quality
    tlsEndpointID: currentOptions.tlsEndpointID,
    url: currentOptions.url,
    triggerOptions: Google.PushAvStreamTransportTrait.TransportTriggerOptionsStruct(
        triggerType: .motion,
        motionSensitivity: 5, // Medium
        motionTimeControl: Google.PushAvStreamTransportTrait.TransportMotionTriggerTimeControlStruct(
            initialDuration: currentOptions.triggerOptions.motionTimeControl?.initialDuration ?? 10,
            augmentationDuration: currentOptions.triggerOptions.motionTimeControl?.augmentationDuration ?? 5,
            maxDuration: 30,
            blindDuration: currentOptions.triggerOptions.motionTimeControl?.blindDuration ?? 0
        )
    ),
    ingestMethod: currentOptions.ingestMethod,
    containerOptions: currentOptions.containerOptions
)

try await pushAvStreamTransportTrait.modifyPushTransport(
    connectionID: recordingConnection!.connectionID,
    transportOptions: newOptions
)

Bandbreitenqualität bestimmen

Das Attribut videoStreamId des TransportOptionsStruct entspricht einer bestimmten Videostream-Konfiguration.

Die unterstützten Videostreams finden Sie im Attribut allocatedVideoStreams, das eine Liste von VideoStreamStructs ist. aus dem Attribut CameraAvStreamManagement für das Gerät.

Empfindlichkeit für die Beendigung des Ruhemodus anpassen

Das Attribut motionSensitivity von TransportTriggerOptionsStruct entspricht den folgenden Werten:

Maximale Ereignisdauer anpassen

Das Attribut maxDuration von TransportMotionTriggerTimeControlStruct entspricht den folgenden UInt32-Dauern (in Sekunden):

• 10, 15, 30, 60, 120, 180

Einstellungen für die Glocke

Über die Home APIs können verschiedene Einstellungen für die Glocke der Türklingel gesteuert werden.

Glockenton ändern

Wenn du den Klingelton der Türklingel ändern möchtest, rufe zuerst die Liste der auf dem Gerät installierten Klingeltöne mit dem Attribut installedChimeSounds des Attributs ChimeTrait ab:

doorbellChimeTrait.attributes.installedChimeSounds?.compactMap { chimeSound in
  return chimeSound.chimeID, chimeSound.name
}

Aktualisieren Sie dann das Attribut selectedChime des Merkmals ChimeTrait mit der integrierten Funktion setSelectedChime:

func setDoorbellChime(chimeID: UInt8) async {
  do {
    _ = try await doorbellChimeTrait.update {
      $0.setSelectedChime(chimeID)
    }
  } catch {
    // Error
  }
}

Externe Glocke verwenden

   In der Beispiel-App für iOS implementiert   

Die Türklingel kann so konfiguriert werden, dass sie eine externe Glocke verwendet, z. B. eine mechanische Glocke, die im Haus installiert ist. Dies sollte während der Installation der Türklingel konfiguriert werden, um mögliche Schäden an der externen Glocke zu vermeiden.

Wenn du angeben möchtest, welche Art von externer Glocke installiert ist, verwende ExternalChimeType, um das Attribut externalChime des Merkmals ChimeTrait mit der integrierten Funktion setExternalChime zu aktualisieren:

// Indicate the external chime is mechanical
func setExternalChime(to value: Google.ChimeTrait.ExternalChimeType) async {
  do {
    _ = try await doorbellChimeTrait.update {
      $0.setExternalChime(value)
    }
  } catch {
    // Error
  }
}

Dauer der externen Glocke ändern

Die Dauer, für die eine externe Glocke läutet, kann über die Home APIs in Sekunden konfiguriert werden. Wenn die externe Glocke eine Glockendauer unterstützt, kann der Nutzer diese konfigurieren.

Der hier festgelegte Wert hängt von den Spezifikationen der externen Glocke selbst und der empfohlenen Dauer des Glockentons ab.

Wenn du die Dauer der externen Glocke ändern möchtest, aktualisiere das Attribut externalChimeDurationSeconds des Attributs ChimeTrait mit der integrierten Funktion setExternalChimeDurationSeconds:

// Change the external chime duration
func setExternalChimeDuration(to value: UInt16) async {
  do {
    _ = try await doorbellChimeTrait.update {
      $0.setExternalChimeDuration(value)
    }
  } catch {
    // Error
  }
}

Glockenthema aktivieren

   In der Beispiel-App für iOS implementiert   

Bei einigen Türklingeln sind bestimmte Glocken möglicherweise nur für eine begrenzte Zeit verfügbar. Zum Beispiel Glocken für Feiertage. Diese werden als Glockenthemen bezeichnet.

Wenn du sehen möchtest, welche Glockentöne für einen Nutzer verfügbar sind, erstelle einen Zeitfensterfilter und verwende ihn, um die Ergebnisse des Befehls getAvailableThemes aus dem Trait ChimeThemes zu filtern. Daraufhin wird eine Liste der verfügbaren Designs mit den entsprechenden Namen zurückgegeben.

Das folgende Beispiel zeigt, wie die Liste gefiltert wird. Ein Design gilt als aktiv, wenn die aktuelle Zeit zwischen der Start- und Endzeit liegt (die Werte startTimeSeconds bzw. endTimeSeconds). Wenn keine Startzeit festgelegt ist, gilt sie von Anfang an als aktiv. Wenn kein Endzeitpunkt festgelegt ist, bleibt sie auf unbestimmte Zeit aktiv. Wenn beide fehlen, ist das Design immer aktiv.

let chimeThemes = try await chimeThemeTrait.getAvailableThemes().themes

if !chimeThemes.isEmpty {
  var chimeThemeSettings = []
  for chimeTheme in chimeThemes {
    let currentDateTime = UInt64(Date().timeIntervalSince1970)

    // Only show chime themes that are active.
    if chimeTheme.startTimeSeconds ?? 0 <= currentDateTime
      && chimeTheme.endTimeSeconds ?? UInt64.max >= currentDateTime
    {
      self.chimeThemeSettings.append(chimeTheme.name)
    }
  }
}

Wenn Sie den Namen des gewünschten Designs haben, z. B. Christmas, können Sie es mit der Funktion setSelectedTimeboxedThemeName() für das Attribut ChimeThemes ChimeThemes auswählen.

private func setChimeTheme(to value: String) async throws {
  _ = try await chimeThemeTrait.update {
    $0.setSelectedTimeboxedThemeName(value)
  }
}

Einstellungen für Benachrichtigungen über Besucher

Mit dem Home APIs-Trait VisitorAnnouncement kannst du die Einstellungen für Benachrichtigungen über Besucher für Türklingeln abfragen und verwalten. Dieses Attribut steuert, ob die Anwesenheit eines Besuchers auf Google Smart Speakern oder Smart Displays angesagt wird, wenn jemand an der Tür klingelt.

Im folgenden Beispiel wird gezeigt, wie Sie prüfen, ob Benachrichtigungen über Besucher aktiviert sind, und wie Sie diese Einstellung aktualisieren:

let visitorAnnouncementsEnabled: Bool = visitorAnnouncementTrait.attributes.visitorAnnouncementsEnabled

let value: Bool
_ = try await self.visitorAnnouncementTrait?.update {
  $0.setVisitorAnnouncementsEnabled(value)
}

Gerät außer Betrieb nehmen

Wenn du eine Türklingel aus einem Gebäude entfernen möchtest, rufe device.decommission() auf. Bei der Außerbetriebnahme wird dem Nutzer ein von Google verwalteter Bestätigungsbildschirm angezeigt, auf dem er darauf hingewiesen wird, dass der gesamte aufgezeichnete lückenlose Videoverlauf, der Ereignisverlauf, die Clips und die Daten der Gesichterdatenbank im gesamten Gebäude dauerhaft gelöscht werden.

Eine ausführliche Anleitung und Codebeispiele finden Sie unter Gerät entfernen.