Kamera-Geräteanleitung für iOS

Der Gerätetyp „Kamera“ wird mit zwei Attributen implementiert: PushAvStreamTransportTrait, das den Transport von Audio- und Videostreams über Push-basierte Protokolle übernimmt, und WebRtcLiveViewTrait, das die Möglichkeit bietet, Livestreams und Talkback zu steuern. Der Gerätetyp „Türklingel“ verwendet diese Merkmale auch für Implementierungen mit Kamerafunktionen.

Gerätetyp für Home-APIs Attribute Swift-Beispiel-App Anwendungsfall

Kamera

GoogleCameraDeviceType

home.matter.6006.types.0158

Ein Gerät, mit dem Standbilder oder Videos aufgenommen werden. Kameras können zugängliche Livestreams, bidirektionale Sprechfunktionen oder Erkennungsereignisse bieten.

 Erforderliche Attribute
     google PushAvStreamTransportTrait
     google WebRtcLiveViewTrait

 Kamera

Türklingel

GoogleDoorbellDeviceType

home.matter.6006.types.0113

Ein Gerät, das durch einen Knopf außerhalb einer Tür betätigt wird und ein akustisches und//oder visuelles Signal erzeugt, um die Aufmerksamkeit einer Person zu erregen, die sich auf der anderen Seite der Tür befindet. Türklingeln können barrierefreie Livestreams, Zweiwege-Audio oder Erkennungsereignisse bieten.

 Erforderliche Attribute
     google PushAvStreamTransportTrait
     google WebRtcLiveViewTrait

 Türklingel

Livestream starten

Wenn Sie einen Livestream starten möchten, senden Sie den SDP-String (Session Description Protocol) an die Methode startLiveView(offerSdp:)WebRtcLiveViewTraitstartLiveView(offerSdp:) des Traits WebRtcLiveViewTrait, die drei Werte zurückgibt:

  • Das SDP für die Sitzung.
  • Die Sitzungsdauer in Sekunden.
  • Die Sitzungs-ID, die zum Verlängern oder Beenden der Sitzung verwendet werden kann.
public func sendOffer(offerSdp: String) async throws 
-> (answerSdp: String, mediaSessionId: String, liveViewDuration: TimeInterval) 
{
  do {
    Logger.info("Sending StartLiveView command...")
    let response = try await liveViewTrait.startLiveView(
      offerSdp: offerSdp
    )
    Logger.info("Received StartLiveView response: \(response)")
    return (
      answerSdp: response.answerSdp,
      mediaSessionId: response.mediaSessionId,
      liveViewDuration: TimeInterval(response.liveSessionDurationSeconds)
    )
  } catch {
    Logger.error("Failed to send StartLiveView command: \(error)")
    throw error
  }
}

Livestream verlängern

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 {
    Logger.info("Extending live view...")
    let extendedDuration = try await liveViewTrait.extendLiveView(mediaSessionId: mediaSessionId)
    Logger.info("Extended live view for \(extendedDuration.liveSessionDurationSeconds) seconds.")
  } catch {
    Logger.error("Failed to extend live view: \(error)")
    throw error
  }
}

Aufzeichnungsfunktion aktivieren und deaktivieren

Um die Aufnahmefunktion der Kamera zu aktivieren, übergeben Sie TransportStatusEnum.Active an die Methode setTransportStatus(transportStatus:optionalArgsProvider:) des Traits PushAvStreamTransportTrait. Wenn Sie die Aufnahmefunktion deaktivieren möchten, übergeben Sie sie TransportStatusEnum.Inactive. Im folgenden Beispiel fassen wir diese Aufrufe in einem einzigen Aufruf zusammen, der ein Boolean verwendet, um die Aufnahmefunktion zu aktivieren oder zu deaktivieren:

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

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

Prüfen, ob die Aufzeichnungsfunktion aktiviert ist

Wenn Sie prüfen möchten, ob die Aufnahmefunktion einer Kamera aktiviert ist, sehen Sie nach, ob Verbindungen aktiv sind. Im folgenden Beispiel werden zwei Funktionen definiert, um dies zu tun:

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

TalkBack starten und beenden

Rufen Sie die Methode startTalkback(mediaSessionId:optionalArgsProvider:) des Trait WebRtcLiveViewTrait auf, um Talkback zu starten. Verwenden Sie stopTalkback(mediaSessionId:), um die Aufnahme zu beenden.

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