iOS के लिए डोरबेल डिवाइस गाइड

दरवाज़े की घंटी वाले डिवाइस टाइप को तीन विशेषताओं का इस्तेमाल करके लागू किया जाता है: PushAvStreamTransportTrait, यह पुश-आधारित प्रोटोकॉल का इस्तेमाल करके, ऑडियो और वीडियो स्ट्रीम को मैनेज करता है, WebRtcLiveViewTrait, यह लाइव स्ट्रीम और टॉकबैक को कंट्रोल करने की सुविधा देता है, और CameraSnapshotTrait, यह कैश मेमोरी में सेव किए गए स्नैपशॉट की झलक और लाइव स्नैपशॉट कैप्चर करने की सुविधा देता है.

किसी भी सुविधा का इस्तेमाल करने या एट्रिब्यूट को अपडेट करने से पहले, हमेशा यह देख लें कि डिवाइस के लिए एट्रिब्यूट और निर्देश काम करते हैं या नहीं. ज़्यादा जानकारी के लिए, iOSपर डिवाइसों को कंट्रोल करना लेख पढ़ें.

Home APIs के लिए डिवाइस टाइप Traits Swift सैंपल ऐप्लिकेशन इस्तेमाल का उदाहरण

दरवाज़े की घंटी

GoogleDoorbellDeviceType

home.matter.6006.types.0113

दरवाज़े के बाहर लगे बटन से चालू होने वाला डिवाइस, जो आवाज़ और/या विज़ुअल सिग्नल देता है. इसका इस्तेमाल, दरवाज़े के दूसरी तरफ़ मौजूद किसी व्यक्ति का ध्यान खींचने के लिए किया जाता है. दरवाज़े की घंटियों में, लाइव स्ट्रीम को ऐक्सेस करने, दोनों तरफ़ से बातचीत करने या गतिविधियों का पता लगाने की सुविधा हो सकती है.

 ज़रूरी ट्रेट
     google PushAvStreamTransportTrait
     google WebRtcLiveViewTrait

 दरवाज़े की घंटी

किसी डिवाइस के बारे में बुनियादी जानकारी पाना

   iOS के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

BasicInformation ट्रेट में, किसी डिवाइस के लिए वेंडर का नाम, वेंडर आईडी, प्रॉडक्ट आईडी, प्रॉडक्ट का नाम (इसमें मॉडल की जानकारी शामिल होती है), और सॉफ़्टवेयर के वर्शन जैसी जानकारी शामिल होती है:

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!

सीरियल नंबर पाना

   iOS के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

डिवाइस का सीरियल नंबर पाने के लिए, ExtendedBasicInformation ट्रेट के GetSerialNumber कमांड का इस्तेमाल करें. इस उदाहरण में, सीरियल नंबर को serialNumber नाम के वैरिएबल में सेव करने का तरीका बताया गया है:

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

पहले से तैयार जवाब

पहले से तैयार जवाब की सुविधा से, उपयोगकर्ता दरवाज़े की घंटी वाले डिवाइस पर पहले से तैयार मैसेज भेज सकता है.

यह सुविधा सिर्फ़ दरवाज़े की घंटी वाले डिवाइसों पर उपलब्ध है. पहले से तय किए गए मैसेज की सूची, पार्टनर ऐप्लिकेशन के लिए उपलब्ध होती है. पार्टनर ऐप्लिकेशन, उपयोगकर्ता को इनमें से कोई मैसेज चुनने का विकल्प दे सकता है. पहले से तय किए गए मैसेज में उपयोगकर्ता बदलाव नहीं कर सकते.

पहले से तैयार जवाब की सुविधा को PresetMessage ट्रेट की मदद से लागू किया जाता है.

पहले से सेट किया गया कोई मैसेज चलाना

पहले से सेट किया गया कोई मैसेज चलाने के लिए, playPresetMessage तरीके को कॉल करें. इसके लिए, उसे 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)")
    }
}

बोली जाने वाली भाषा सेट करना

बोली जाने वाली भाषा सेट करना

LocalizationConfiguration trait के setActiveLocale method का इस्तेमाल करके, डिवाइस पर बोली जाने वाली भाषा को किसी खास भाषा (उदाहरण के लिए, "en_US") पर सेट करें.

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

डिवाइस के क्लाउड संपर्क का सबसे हाल का समय पाना

डिवाइस ने पिछली बार क्लाउड से कब संपर्क किया था, यह जानने के लिए ExtendedGeneralDiagnostics ट्रेट के lastContactTimestamp एट्रिब्यूट का इस्तेमाल करें:

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

कैमरा माउंट टाइप की सेटिंग

Mount trait में, कैमरे को माउंट करने की सेटिंग और स्थिति की जानकारी शामिल होती है. माउंट की स्थिति, पहचान का टाइप, और माउंट के टाइप का नाम जैसे एट्रिब्यूट पढ़े जा सकते हैं. इसके अलावा, Mount trait का इस्तेमाल करके, माउंट टाइप के डिफ़ॉल्ट कॉन्फ़िगरेशन को बदला जा सकता है.

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

किसी डिवाइस के लिए कनेक्टिविटी की जांच करना

किसी डिवाइस की कनेक्टिविटी की जांच, डिवाइस टाइप के लेवल पर की जाती है. ऐसा इसलिए, क्योंकि कुछ डिवाइसों पर कई तरह के डिवाइस टाइप काम करते हैं. डिवाइस की स्थिति, उस डिवाइस पर मौजूद सभी विशेषताओं के लिए कनेक्टिविटी की स्थितियों का कॉम्बिनेशन होती है.

let doorbellConnectivity = doorbellDeviceType.metadata.sourceConnectivity.connectivityState

इंटरनेट कनेक्शन न होने पर, अलग-अलग तरह के डिवाइसों के मामले में partiallyOnline की स्थिति देखी जा सकती है. लोकल रूटिंग की वजह से, Matter के स्टैंडर्ड ट्रेट अब भी ऑनलाइन हो सकते हैं. हालांकि, क्लाउड-आधारित ट्रेट ऑफ़लाइन होंगे.

डिवाइस का आईपी पता पाना

डिवाइस का आईपी पता ढूंढने के लिए, GeneralDiagnosticsTrait के networkInterfaces एट्रिब्यूट का इस्तेमाल करें. पते, Data ऑब्जेक्ट के तौर पर दिखाए जाते हैं. इन्हें Network फ़्रेमवर्क का इस्तेमाल करके, स्टैंडर्ड IPv4 या IPv6 स्ट्रिंग में फ़ॉर्मैट किया जा सकता है:

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
}

लाइव स्ट्रीम शुरू करना

   iOS के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

लाइव स्ट्रीम शुरू करने के लिए, सेशन डिस्क्रिप्शन प्रोटोकॉल (एसडीपी) स्ट्रिंग को WebRtcLiveViewTrait ट्रेट के startLiveView(offerSdp:) तरीके पर भेजें. इससे तीन वैल्यू मिलती हैं:

  • सेशन के लिए एसडीपी.
  • सेशन कितनी देर चला, सेकंड में.
  • सेशन आईडी, जिसका इस्तेमाल सेशन को बढ़ाने या खत्म करने के लिए किया जा सकता है.
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
  }
}

लाइव स्ट्रीम की अवधि बढ़ाना

   iOS के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

लाइव स्ट्रीम की अवधि पहले से तय होती है. इसके बाद, वे खत्म हो जाती हैं. किसी चालू स्ट्रीम की अवधि बढ़ाने के लिए, 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 को चालू और बंद करना

   iOS के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

टॉकबैक शुरू करने के लिए, WebRtcLiveViewTrait ट्रेट के startTalkback(mediaSessionId:optionalArgsProvider:) तरीके को कॉल करें. रिकॉर्डिंग बंद करने के लिए, stopTalkback(mediaSessionId:) का इस्तेमाल करें.

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

लाइव स्ट्रीम मैनेज करना

   iOS के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

लाइव स्ट्रीम की क्वालिटी में बदलाव करने से, बैंडविड्थ के इस्तेमाल को ऑप्टिमाइज़ करने में मदद मिलती है. यह बदलाव, क्लाइंट के देखने के कॉन्टेक्स्ट के हिसाब से किया जाता है. उदाहरण के लिए, छोटी झलक वाली टाइल, ग्रिड वाला व्यू या पिक्चर में पिक्चर मोड दिखाते समय, कम रिज़ॉल्यूशन पर स्विच करना.

WebRtcLiveView ट्रेट का इस्तेमाल करके, डाइनैमिक तौर पर क्वालिटी बदलने से, किसी क्लाइंट पर चल रहे लाइव स्ट्रीम सेशन के रिज़ॉल्यूशन को मैनेज किया जाता है. यह डिवाइस पर सीधे तौर पर, डिवाइस के लिए बैंडविड्थ के इस्तेमाल की सेटिंग को कॉन्फ़िगर करने जैसा नहीं है. इससे, एक साथ वीडियो देखने वाले सभी लोगों और क्लाउड में सेव की गई वीडियो रिकॉर्डिंग की क्वालिटी पर असर पड़ेगा.

यहां दिए गए उदाहरण में, किसी डिवाइस के लिए लाइव स्ट्रीम की क्वालिटी को वापस पाने और उसे अपडेट करने का तरीका बताया गया है:

  • वीडियो क्वालिटी के उपलब्ध विकल्प पाना: डिवाइस पर, स्ट्रीमिंग के लिए उपलब्ध रिज़ॉल्यूशन की जानकारी पाना. कोड, WebRtcLiveView विशेषता के बारे में क्वेरी करता है, ताकि स्ट्रीम की जा सकने वाली क्वालिटी को QualityHint वैल्यू की सूची के तौर पर दिखाया जा सके. जैसे, .sd, .hd, .fhd, .qhd या .uhd. इसके लिए, supportedQualityHints प्रॉपर्टी का इस्तेमाल किया जाता है.

  • लाइव स्ट्रीम की क्वालिटी बदलें: चालू लाइव स्ट्रीम के रिज़ॉल्यूशन को बदलने के लिए, चुनी गई QualityHint लागू करें. उदाहरण के लिए, स्टैंडर्ड डेफ़िनिशन से हाई डेफ़िनिशन पर स्विच करना. updateQualityHint फ़ंक्शन, WebRtcLiveView ट्रेट के changeLiveViewQuality तरीके का इस्तेमाल करता है, ताकि चुने गए QualityHint कॉन्फ़िगरेशन को चालू मीडिया सेशन पर लागू किया जा सके.

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

रिकॉर्डिंग की सुविधा को चालू और बंद करना

कैमरे की रिकॉर्डिंग की सुविधा चालू करने के लिए, PushAvStreamTransportTrait ट्रेट के setTransportStatus(transportStatus:optionalArgsProvider:) मेथड में TransportStatusEnum.Active पास करें. रिकॉर्डिंग की सुविधा बंद करने के लिए, TransportStatusEnum.Inactive पास करें. यहां दिए गए उदाहरण में, हम इन कॉल को एक ही कॉल में रैप करते हैं. इसमें रिकॉर्डिंग की सुविधा को टॉगल करने के लिए, Boolean का इस्तेमाल किया जाता है:

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

कैमरे की रिकॉर्डिंग की सुविधा को चालू या बंद करना, कैमरे के वीडियो को चालू या बंद करने जैसा ही है. जब कैमरे का वीडियो चालू होता है, तो वह रिकॉर्डिंग कर रहा होता है. ऐसा इवेंट और उनसे जुड़ी क्लिप के लिए किया जाता है.

रिकॉर्डिंग की सुविधा बंद होने पर (कैमरे का वीडियो बंद होने पर):

देखें कि रिकॉर्डिंग की सुविधा चालू है या नहीं

कैमरे की रिकॉर्डिंग की सुविधा चालू है या नहीं, यह पता करने के लिए देखें कि कोई कनेक्शन चालू है या नहीं. यहां दिए गए उदाहरण में, ऐसा करने के लिए दो फ़ंक्शन के बारे में बताया गया है:

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
}

कैमरे से लिए गए स्नैपशॉट वापस पाना

   iOS के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

कैमरे से स्टैटिक इमेज के स्नैपशॉट पाने के लिए, CameraSnapshot ट्रेट का इस्तेमाल करें. ये स्नैपशॉट कई स्थितियों में काम आते हैं:

  • WebRTC लाइव स्ट्रीम लोड होने के दौरान, यूज़र इंटरफ़ेस (यूआई) में प्लेसहोल्डर टाइल के तौर पर.
  • स्टैटिक प्रीव्यू इमेज के तौर पर, जो उपयोगकर्ता के इंटरैक्शन पर लाइव स्ट्रीम में अपग्रेड हो जाती है.
  • कस्टम ऐक्टिविटी ज़ोन को ड्रॉ और कॉन्फ़िगर करने के लिए, बैकग्राउंड कैनवस के तौर पर.

CameraSnapshot trait, स्नैपशॉट को फ़ेच करने के दो तरीके उपलब्ध कराता है. यह इस बात पर निर्भर करता है कि आपको तेज़ी से रेंडर करने के लिए, कैश मेमोरी में सेव किया गया स्नैपशॉट चाहिए या मांग पर लाइव स्नैपशॉट चाहिए.

कैश मेमोरी में सेव की गई झलक का स्नैपशॉट पाना

झलक का स्नैपशॉट, कैश मेमोरी में सेव की गई इमेज होती है. इसे एसडीके, कैमरे को चालू किए बिना वापस पा सकता है. यह स्टैटिक इमेज फ़ेच करने का सबसे तेज़ तरीका है. यह कैमरे की खास जानकारी देने वाले पेजों या डैशबोर्ड ग्रिड के लिए सबसे सही है.

झलक का स्नैपशॉट पाने के लिए, preview_image_url trait एट्रिब्यूट को पढ़ें:

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
}

कैमरे के कॉन्फ़िगरेशन और गतिविधि के आधार पर, झलक का यूआरएल, हाल ही के वीडियो फ़ुटेज (नए वीडियो फ़्रैगमेंट का पहला आई-फ़्रेम) से जनरेट की गई कैश मेमोरी में सेव की गई इमेज या कैमरे से समय-समय पर अपलोड किए गए स्नैपशॉट पर ले जाता है.

इमेज कितनी नई है, यह बताने के लिए Google Home क्लाउड, JPEG/PNG इमेज में X-Home-Image-Captured-At हेडर को एम्बेड करता है. यह इमेज, यूटीसी फ़ॉर्मैट में होती है. इस हेडर को क्लाइंट-साइड पर पार्स किया जा सकता है, ताकि ऐप्लिकेशन में स्नैपशॉट की उम्र दिखाई जा सके.

मांग पर लाइव स्नैपशॉट पाना

उपयोगकर्ता की ऐसी गतिविधियों के लिए जिनमें कैमरे के मौजूदा लाइव व्यू की ज़रूरत होती है, जैसे कि ऐक्टिविटी ज़ोन सेट अप करना, लाइव स्नैपशॉट का अनुरोध किया जा सकता है. लाइव स्नैपशॉट ट्रिगर करने पर, कैमरे को चालू होने, नया फ़्रेम कैप्चर करने, और उसे क्लाउड पर अपलोड करने का निर्देश मिलता है.

लाइव स्नैपशॉट का अनुरोध करने के लिए, getLiveSnapshot() कमांड का इस्तेमाल करें:

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

स्नैपशॉट के अनुरोधों की पुष्टि करना

   iOS के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

सभी स्नैपशॉट यूआरएल, सुरक्षित मीडिया पर ले जाते हैं. साथ ही, Home APIs v2 के दायरे के लिए, OAuth 2.0 टोकन की ज़रूरत होती है. इमेज डाउनलोड और रेंडर करने के लिए, OAuth टोकन को आपके एचटीटीपी अनुरोध के Authorization हेडर में, धारक टोकन के तौर पर शामिल किया जाना चाहिए.

यहां दिए गए उदाहरण में, स्नैपशॉट डाउनलोड करने के लिए, नेटवर्क के सुरक्षित अनुरोध को कॉन्फ़िगर करने का तरीका बताया गया है:

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

बैटरी की सेटिंग

Home API की मदद से, बैटरी की अलग-अलग सेटिंग कंट्रोल की जा सकती हैं.

बैटरी खर्च की सेटिंग सेट करना

एनर्जी बैलेंस सेट करने से, किसी डिवाइस की बैटरी लाइफ़ और परफ़ॉर्मेंस के बीच संतुलन बनाया जा सकता है. आपके पास बैटरी के लिए अलग-अलग प्रोफ़ाइलें बनाने का विकल्प होता है. जैसे, "एक्सटेंडेड", "बैलेंस्ड", और "परफ़ॉर्मेंस". साथ ही, आपके पास इन प्रोफ़ाइलों के बीच स्विच करने का विकल्प भी होता है.

इस सुविधा को लागू करने के लिए, EnergyPreference ट्रेट के currentEnergyBalance एट्रिब्यूट को अपडेट किया जाता है. इस एट्रिब्यूट में, पूर्णांक इंडेक्स का इस्तेमाल किया जाता है. यह इंडेक्स, डिवाइस की energyBalances सूची में मौजूद किसी खास प्रोफ़ाइल से जुड़ा होता है. उदाहरण के लिए, EXTENDED के लिए 0, BALANCED के लिए 1, और PERFORMANCE के लिए 2.

currentEnergyBalance के लिए null वैल्यू से पता चलता है कि डिवाइस, कस्टम प्रोफ़ाइल का इस्तेमाल कर रहा है. यह सिर्फ़ रीड-ओनली मोड है.

यहां उस स्ट्रक्चर का उदाहरण दिया गया है जिसका इस्तेमाल currentEnergyBalance एट्रिब्यूट करेगा. इसके बाद, उस कोड स्निपेट का उदाहरण दिया गया है जो इस एट्रिब्यूट का इस्तेमाल करता है.

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

बैटरी सेवर मोड अपने-आप चालू होने की सुविधा चालू करना

   iOS के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

इस सुविधा को कॉन्फ़िगर करने के लिए, EnergyPreference ट्रेट के currentLowPowerModeSensitivity एट्रिब्यूट को अपडेट करें. यह एट्रिब्यूट, संवेदनशीलता का लेवल चुनने के लिए इंडेक्स का इस्तेमाल करता है. इसमें 0 आम तौर पर Disabled को दिखाता है और 1, Enabled या Automatic को दिखाता है.

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

बैटरी चार्ज होने की स्थिति की जानकारी पाना

   iOS के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

डिवाइस के चार्ज होने की मौजूदा स्थिति (चार्ज हो रहा है, पूरी तरह चार्ज हो गया है या चार्ज नहीं हो रहा है) जानने के लिए, PowerSource trait के batChargeState एट्रिब्यूट का इस्तेमाल करें.

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

बैटरी लेवल देखना

बैटरी का मौजूदा लेवल जानने के लिए, PowerSource ट्रेट के batChargeLevel एट्रिब्यूट का इस्तेमाल करें. लेवल OK, Warning (कम) या 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"
}

पावर सोर्स की जानकारी पाना

डिवाइस किस पावर सोर्स का इस्तेमाल कर रहा है, यह जानने के लिए PowerSource ट्रेट के BatPresent और wiredPresent एट्रिब्यूट का इस्तेमाल करें.

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

देखें कि बैटरी बदलने की ज़रूरत है या नहीं

batReplaceability एट्रिब्यूट से पता चलता है कि बैटरी को बदला नहीं जा सकता, उपयोगकर्ता बदल सकता है या फ़ैक्ट्री में बदला जा सकता है.

अगर बैटरी बदली जा सकती है, तो PowerSource ट्रेट का batReplacementNeeded एट्रिब्यूट आपको बताता है कि बैटरी बदलने की ज़रूरत है या नहीं.

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

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

अगर बैटरी को उपयोगकर्ता बदल सकता है, तो batReplacementDescription में बैटरी के बारे में जानकारी दी जाती है. जैसे, फ़ॉर्म फ़ैक्टर, केमिस्ट्री, और पसंदीदा मैन्युफ़ैक्चरर.

ऑडियो सेटिंग

Home API की मदद से, ऑडियो की अलग-अलग सेटिंग कंट्रोल की जा सकती हैं.

माइक्रोफ़ोन को चालू या बंद करना

डिवाइस के माइक्रोफ़ोन को चालू या बंद करने के लिए, पहले से मौजूद setMicrophoneMuted फ़ंक्शन का इस्तेमाल करके, CameraAvStreamManagementTrait trait के microphoneMuted एट्रिब्यूट को अपडेट करें:

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

ऑडियो रिकॉर्डिंग की सुविधा को चालू या बंद करना

डिवाइस के लिए ऑडियो रिकॉर्डिंग की सुविधा को चालू या बंद करने के लिए, पहले से मौजूद setRecordingMicrophoneMuted फ़ंक्शन का इस्तेमाल करके, CameraAvStreamManagementTrait ट्रेट के recordingMicrophoneMuted एट्रिब्यूट को अपडेट करें:

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

स्पीकर की आवाज़ अडजस्ट करना

डिवाइस के स्पीकर की आवाज़ को अडजस्ट करने के लिए, पहले से मौजूद setSpeakerVolumeLevel फ़ंक्शन का इस्तेमाल करके, CameraAvStreamManagementTrait ट्रेट के speakerVolumeLevel एट्रिब्यूट को अपडेट करें:

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

ऐक्टिविटी ज़ोन की सेटिंग

   iOS के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

ZoneManagement trait provides an interface for managing custom regions of interest (ऐक्टिविटी ज़ोन) on camera and doorbell devices. इन ज़ोन का इस्तेमाल, डिवाइस के फ़ील्ड ऑफ़ व्यू (कैमरे से दिख रहा व्यू) में मौजूद खास इलाकों में, इवेंट की पहचान करने की सुविधा (जैसे, किसी व्यक्ति या वाहन की गतिविधि) को फ़िल्टर करने के लिए किया जाता है.

उपयोगकर्ता, पार्टनर ऐप्लिकेशन में ऐक्टिविटी ज़ोन कॉन्फ़िगर करते हैं. इससे वे कैमरे के फ़ील्ड ऑफ़ व्यू में, खास जगहों पर ज़ोन बना सकते हैं. इसके बाद, उपयोगकर्ता के तय किए गए इन ज़ोन को इस विशेषता के इस्तेमाल किए जाने वाले स्ट्रक्चर में बदल दिया जाता है. ऐक्टिविटी ज़ोन की सुविधा के काम करने के तरीके के बारे में ज़्यादा जानने के लिए, ऐक्टिविटी ज़ोन सेट अप करना और उनका इस्तेमाल करना लेख पढ़ें.

आम तौर पर, ऐक्टिविटी ज़ोन को 2D कार्टेशियन कोऑर्डिनेट का इस्तेमाल करके तय किया जाता है. यह विशेषता, वर्टिसेस के लिए TwoDCartesianVertexStruct और ज़ोन की परिभाषा (नाम, वर्टिसेस, रंग, और इस्तेमाल) के लिए TwoDCartesianZoneStruct उपलब्ध कराती है.

ऐक्टिविटी ज़ोन की जांच करना

ऐक्टिविटी ज़ोन दिखाने के लिए, ZoneManagement ट्रेट का zones एट्रिब्यूट देखें.

let zoneManagementTrait: Google.ZoneManagementTrait

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

कोई ऐक्टिविटी ज़ोन जोड़ना

नया ज़ोन बनाने के लिए, createTwoDCartesianZone कमांड का इस्तेमाल करें. यह निर्देश TwoDCartesianZoneStruct लेता है, जिससे ज़ोन का नाम, वर्टिसेस, रंग, और इस्तेमाल तय होता है.

यहां दिए गए उदाहरण में, "Front Porch" नाम का ज़ोन बनाने का तरीका बताया गया है. इसमें चार वर्टिसेस हैं, जिनका रंग सैल्मन (#F439A0) है. साथ ही, इसका इस्तेमाल हलचल का पता लगाने वाली सुविधा के लिए किया जाता है.

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

किसी ऐक्टिविटी ज़ोन को अपडेट करना

किसी मौजूदा ज़ोन को अपडेट करने के लिए, updateTwoDCartesianZone कमांड का इस्तेमाल करें. इस निर्देश के लिए, zoneId और अपडेट किया गया TwoDCartesianZoneStruct ज़रूरी है.

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

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

किसी ऐक्टिविटी ज़ोन को मिटाना

किसी ज़ोन को हटाने के लिए, किसी खास zoneId के साथ removeZone कमांड का इस्तेमाल करें.

let zoneManagementTrait: Google.ZoneManagementTrait
let zoneID: UInt16

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

साउंड इवेंट ट्रिगर

AvStreamAnalysis ट्रेट, कैमरे और दरवाज़े की घंटी वाले डिवाइसों पर, गतिविधि का पता लगाने वाले ट्रिगर को मैनेज करने के लिए एक इंटरफ़ेस उपलब्ध कराता है. विज़न-आधारित ट्रिगर (जैसे, लोग या वाहन) ज़ोन-स्पेसिफ़िक हो सकते हैं. वहीं, आवाज़ से जुड़े ट्रिगर आम तौर पर डिवाइस-लेवल कॉन्फ़िगरेशन होते हैं.

EventTriggerTypeEnum की मदद से, आवाज़ का पता लगाने के लिए ये ट्रिगर उपलब्ध हैं:

मोड Enum वैल्यू जानकारी
आवाज़ Sound सामान्य आवाज़ का पता लगाना.
बातचीत करने की आवाज़ PersonTalking यह बोली की पहचान करता है.
कुत्ते के भौंकने की आवाज़ DogBark कुत्ते के भौंकने की आवाज़ का पता लगाता है.
कांच टूटने की आवाज़ GlassBreak कांच टूटने की आवाज़ का पता लगाता है.
धुएं का अलार्म SmokeAlarm यह स्मोक अलार्म का पता लगाता है. आम तौर पर, इसे T3 ऑडिबल पैटर्न से पहचाना जाता है. इसमें तीन छोटी बीप के बाद एक पॉज़ होता है.
कार्बन मोनोऑक्साइड का अलार्म CoAlarm यह कार्बन मोनोऑक्साइड (सीओ) के अलार्म का पता लगाता है. आम तौर पर, इसे T4 ऑडिबल पैटर्न से पहचाना जाता है. इसमें चार छोटी बीप के बाद एक पॉज़ होता है.

आवाज़ का पता लगाने की सुविधा का स्टेटस देखना

उपयोगकर्ता को आवाज़ का पता लगाने की सुविधा की मौजूदा स्थिति दिखाने के लिए, आपको यह देखना होगा कि डिवाइस पर कौनसी सुविधा काम करती है और डिवाइस के हार्डवेयर में कौनसी सुविधा चालू है. इन दो एट्रिब्यूट की जांच करें:

iOS डेवलपमेंट में, इन एट्रिब्यूट को पढ़ने के लिए, आम तौर पर डिवाइस से AvStreamAnalysis ट्रेट को ऐक्सेस किया जाता है.

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

चालू किए गए ट्रिगर के सेट को अपडेट करना

चालू किए गए ट्रिगर के सेट को अपडेट करने के लिए, SetOrUpdateEventDetectionTriggers कमांड का इस्तेमाल करें. यह कमांड, EventTriggerEnablement स्ट्रक्चर की सूची लेता है.

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

रिकॉर्डिंग मोड

   iOS के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

RecordingMode ट्रेट, कैमरे और दरवाज़े की घंटी वाले डिवाइसों पर वीडियो और इमेज रिकॉर्डिंग की सुविधा को मैनेज करने के लिए इंटरफ़ेस उपलब्ध कराता है. इससे उपयोगकर्ता, लगातार रिकॉर्ड करने की सुविधा, इवेंट के हिसाब से रिकॉर्डिंग करने की सुविधा या रिकॉर्डिंग की सुविधा को पूरी तरह से बंद करने (सिर्फ़ लाइव व्यू) में से कोई एक विकल्प चुन सकते हैं.

RecordingModeEnum से, रिकॉर्डिंग की उपलब्ध रणनीतियां तय होती हैं:

मोड Enum वैल्यू जानकारी
बंद है Disabled रिकॉर्डिंग की सुविधा पूरी तरह से बंद है. इसका इस्तेमाल मुख्य रूप से लेगसी डिवाइसों में किया जाता है.
सीवीआर (लगातार वीडियो रिकॉर्ड होने की सुविधा) Cvr वीडियो को हर समय रिकॉर्ड किया जाता है. सदस्यता लेना ज़रूरी है (उदाहरण के लिए, Google Home Premium.
ईबीआर (इवेंट के हिसाब से रिकॉर्डिंग) Ebr रिकॉर्डिंग, इवेंट (व्यक्ति, गतिविधि) से ट्रिगर होती है. वीडियो की अवधि, इवेंट की अवधि और सदस्यता पर निर्भर करती है.
ETR (इवेंट ट्रिगर होने पर रिकॉर्डिंग) Etr इवेंट की वजह से ट्रिगर हुई छोटी झलक वाली रिकॉर्डिंग (उदाहरण के लिए, 10 सेकंड).
लाइव व्यू LiveView रिकॉर्डिंग की सुविधा बंद है, लेकिन उपयोगकर्ता अब भी लाइव स्ट्रीम को ऐक्सेस कर सकते हैं.
स्टिल इमेज Images इवेंट होने पर, वीडियो के बजाय स्नैपशॉट रिकॉर्ड किए जाते हैं.

रिकॉर्डिंग मोड देखना

मौजूदा रिकॉर्डिंग कॉन्फ़िगरेशन दिखाने के लिए, RecordingMode ट्रेट के एट्रिब्यूट देखें:

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

रिकॉर्डिंग मोड बदलना

अपडेट करने से पहले, पक्का करें कि supportedRecordingModes एट्रिब्यूट से चुना गया इंडेक्स, availableRecordingModes एट्रिब्यूट में मौजूद हो.

चुने गए मोड को अपडेट करने के लिए, setSelectedRecordingMode फ़ंक्शन का इस्तेमाल करें. साथ ही, चुने गए मोड का इंडेक्स पास करें:

let recordingModeTrait: Google.RecordingModeTrait
let recordingModeID: UInt8

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

अन्य सेटिंग

Home API की मदद से, कई अन्य सेटिंग कंट्रोल की जा सकती हैं.

नाइट विज़न की सुविधा को चालू या बंद करना

कैमरे के लिए नाइट विज़न की सुविधा को चालू या बंद करने के लिए, TriStateAutoEnum का इस्तेमाल करें. इससे, पहले से मौजूद setNightVision फ़ंक्शन का इस्तेमाल करके, CameraAvStreamManagementTrait ट्रेट के nightVision एट्रिब्यूट को अपडेट किया जा सकेगा:

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

स्टेटस एलईडी की रोशनी को कम या ज़्यादा करना

स्टेटस एलईडी की रोशनी को कम या ज़्यादा करने के लिए, ThreeLevelAutoEnum का इस्तेमाल करें. इससे, पहले से मौजूद setStatusLightBrightness फ़ंक्शन का इस्तेमाल करके, CameraAvStreamManagementTrait ट्रेट के statusLightBrightness एट्रिब्यूट को अपडेट किया जा सकता है:

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

कैमरे का व्यूपोर्ट बदलना

कैमरे का व्यूपोर्ट, ज़ूम और काट-छांट करने की सुविधा जैसा ही होता है. इसके बारे में, Nest कैमरे से ज़ूम करना और वीडियो की क्वालिटी बेहतर बनाना सहायता लेख में बताया गया है.

व्यूपोर्ट को ViewportStruct में तय किया जाता है. इसमें चार वैल्यू होती हैं, जिनका इस्तेमाल व्यूपोर्ट के निर्देशांक के तौर पर किया जाता है. कोऑर्डिनेट को इस तरह से तय किया जाता है:

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

ViewportStruct की वैल्यू तय करना, ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) और कैमरे के सेटअप पर निर्भर करता है. कैमरे के वीडियो का व्यूपोर्ट सेट करने के लिए, CameraAvStreamManagementTrait विशेषता के viewport एट्रिब्यूट को ViewportStruct से अपडेट करें. इसके लिए, पहले से मौजूद 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 जनरेट करना

कुछ सेटिंग के लिए, TransportOptionsStruct में प्रॉपर्टी में बदलाव करना ज़रूरी है. इसके बाद, इसे स्ट्रीमिंग कनेक्शन के ट्रांसपोर्ट विकल्पों में पास किया जाता है. Swift के लिए, किसी भी प्रॉपर्टी को अपडेट करने से पहले, यह स्ट्रक्चर जनरेट करना ज़रूरी है.

इस हेल्पर फ़ंक्शन का इस्तेमाल करके, स्ट्रक्चर जनरेट करें. इसका इस्तेमाल, सेटिंग में किए जाने वाले इन बदलावों के लिए किया जा सकता है:

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
}

ऐनलिटिक्स की सुविधा को चालू या बंद करना

हर डिवाइस, Google Home क्लाउड को ज़्यादा जानकारी वाला आंकड़े का डेटा भेजने के लिए, अलग-अलग ऑप्ट-इन कर सकता है. इसके लिए, Home API के लिए क्लाउड मॉनिटरिंग देखें.

किसी डिवाइस के लिए आंकड़े इकट्ठा करने की सुविधा चालू करने के लिए, ExtendedGeneralDiagnosticsTrait की analyticsEnabled) प्रॉपर्टी को true पर सेट करें. analyticsEnabled को सेट करने पर, एक अन्य प्रॉपर्टी, logUploadEnabled, अपने-आप true पर सेट हो जाती है. इससे Google Home क्लाउड पर, आंकड़ों की लॉग फ़ाइलें अपलोड की जा सकती हैं.

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

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

ट्रांसपोर्ट और रिकॉर्डिंग कॉन्फ़िगरेशन

इस सेक्शन में, कैमरे से स्ट्रीम किए गए वीडियो की क्वालिटी और इवेंट ट्रिगर करने से जुड़ी सेटिंग के बारे में बताया गया है. इन सेटिंग को PushAvStreamTransport ट्रेट से मैनेज किया जाता है.

ट्रांसपोर्ट की सेटिंग पढ़ें

इस सेक्शन में, कैमरे या दरवाज़े की घंटी वाले डिवाइस से मौजूदा कॉन्फ़िगरेशन को वापस पाने का तरीका बताया गया है. यह PushAvStreamTransport विशेषता को फ़ेच करता है और रिकॉर्डिंग के लिए इस्तेमाल किए गए कनेक्शन का पता लगाता है. इसके बाद, यह बैंडविड्थ की क्वालिटी, कैमरे के सेंसर की संवेदनशीलता, और इवेंट की ज़्यादा से ज़्यादा अवधि की मौजूदा वैल्यू को फ़ेच करता है.

// 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

ट्रांसपोर्ट की सेटिंग अपडेट करना

इस सेक्शन में, ट्रांसपोर्ट की सेटिंग बदलने का तरीका बताया गया है. यह नई वैल्यू वाला एक नया TransportOptionsStruct बनाता है. इसके बाद, modifyPushTransport कमांड का इस्तेमाल करके, इन अपडेट की गई सेटिंग को डिवाइस पर वापस भेजता है. साथ ही, इन्हें पिछले चरण में मिले रिकॉर्डिंग कनेक्शन पर लागू करता है.

इन सेटिंग में बदलाव करने के लिए, TransportOptionsStruct के साथ modifyPushTransport कमांड का इस्तेमाल करें.

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

बैंडविड्थ की क्वालिटी का पता लगाना

TransportOptionsStruct की videoStreamId प्रॉपर्टी, वीडियो स्ट्रीम के किसी खास कॉन्फ़िगरेशन से जुड़ी होती है.

इस्तेमाल की जा सकने वाली वीडियो स्ट्रीम पाने के लिए, allocatedVideoStreams एट्रिब्यूट देखें. यह VideoStreamStructs की सूची है. डिवाइस के लिए CameraAvStreamManagement trait से.

डिवाइस के सेंसर की संवेदनशीलता को अडजस्ट करना

TransportTriggerOptionsStruct की motionSensitivity प्रॉपर्टी, इन वैल्यू से मेल खाती है:

लेबल वैल्यू (UInt8)
कम 1
मीडियम 5
उच्च 10

इवेंट की ज़्यादा से ज़्यादा अवधि अडजस्ट करना

TransportMotionTriggerTimeControlStruct की maxDuration प्रॉपर्टी, UInt32 की इन अवधियों (सेकंड में) से मेल खाती है:

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

घंटी की सेटिंग

Home API की मदद से, दरवाज़े की घंटी की अलग-अलग सेटिंग कंट्रोल की जा सकती हैं.

घंटी की आवाज़ बदलना

दरवाज़े की घंटी की आवाज़ बदलने के लिए, सबसे पहले डिवाइस में इंस्टॉल की गई घंटी की आवाज़ों की सूची देखें. इसके लिए, ChimeTrait trait के installedChimeSounds एट्रिब्यूट का इस्तेमाल करें:

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

इसके बाद, पहले से मौजूद setSelectedChime फ़ंक्शन का इस्तेमाल करके, ChimeTrait ट्रेट के selectedChime एट्रिब्यूट को अपडेट करें:

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

बाहरी चाइम का इस्तेमाल करना

   iOS के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

दरवाज़े की घंटी को इस तरह कॉन्फ़िगर किया जा सकता है कि वह बाहरी घंटी का इस्तेमाल करे. जैसे, घर के अंदर लगी मैकेनिकल घंटी. दरवाज़े की घंटी इंस्टॉल करते समय इसे कॉन्फ़िगर किया जाना चाहिए, ताकि बाहरी घंटी को नुकसान न पहुंचे.

किस तरह की बाहरी घंटी इंस्टॉल की गई है, यह बताने के लिए ExternalChimeType का इस्तेमाल करें. इससे, पहले से मौजूद setExternalChime फ़ंक्शन का इस्तेमाल करके, ChimeTrait ट्रेट के externalChime एट्रिब्यूट को अपडेट किया जा सकेगा:

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

बाहरी घंटी बजने की अवधि बदलना

Home API की मदद से, यह कॉन्फ़िगर किया जा सकता है कि बाहरी चाइम कितने सेकंड तक बजेगी. अगर बाहरी चाइम में, चाइम की अवधि सेट करने की सुविधा है, तो उपयोगकर्ता इसे कॉन्फ़िगर कर सकता है.

यहां सेट की गई वैल्यू, बाहरी घंटी की खास बातों और घंटी बजने की सुझाई गई अवधि पर निर्भर करती है.

बाहरी घंटी बजने की अवधि बदलने के लिए, पहले से मौजूद setExternalChimeDurationSeconds फ़ंक्शन का इस्तेमाल करके, ChimeTrait विशेषता के externalChimeDurationSeconds एट्रिब्यूट को अपडेट करें:

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

चाइम थीम चालू करना

   iOS के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

कुछ दरवाज़े की घंटियों में ऐसी घंटियाँ हो सकती हैं जो उपयोगकर्ताओं के लिए सिर्फ़ सीमित समय के लिए उपलब्ध हों. उदाहरण के लिए, छुट्टियों के हिसाब से अलग-अलग तरह की घंटियां. इन्हें चाइम थीम कहा जाता है.

किसी उपयोगकर्ता के लिए कौनसी चाइम थीम उपलब्ध हैं, यह देखने के लिए टाइमबॉक्स फ़िल्टर बनाएं. इसके बाद, ChimeThemes ट्रेट के getAvailableThemes कमांड के नतीजों को फ़िल्टर करने के लिए, इस फ़िल्टर का इस्तेमाल करें. इससे उपलब्ध थीम की सूची दिखती है. इसमें थीम के नाम भी शामिल होते हैं.

यहां दिए गए उदाहरण में, सूची को फ़िल्टर करने का तरीका बताया गया है. किसी थीम को तब चालू माना जाता है, जब मौजूदा समय उसके शुरू और खत्म होने के समय के बीच का हो. इसके लिए, क्रमशः startTimeSeconds और endTimeSeconds वैल्यू का इस्तेमाल किया जाता है. अगर शुरू होने का समय सेट नहीं किया गया है, तो उसे शुरुआत से ही चालू माना जाता है. अगर खत्म होने का समय सेट नहीं किया जाता है, तो यह अनिश्चित समय तक चालू रहता है. अगर दोनों मौजूद नहीं हैं, तो थीम हमेशा चालू रहती है.

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 &lt;= currentDateTime
      &amp;&amp; chimeTheme.endTimeSeconds ?? UInt64.max &gt;= currentDateTime
    {
      self.chimeThemeSettings.append(chimeTheme.name)
    }
  }
}

अपनी पसंद की थीम का नाम मिलने के बाद, जैसे कि Christmas, ChimeThemes ChimeThemes ट्रेट पर setSelectedTimeboxedThemeName() फ़ंक्शन का इस्तेमाल करके उसे चुना जा सकता है.

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

विज़िटर की सूचना देने की सुविधा की सेटिंग

Home API के VisitorAnnouncement ट्रेट का इस्तेमाल करके, दरवाज़े की घंटियों के लिए, विज़िटर की सूचना देने वाली सेटिंग के बारे में क्वेरी की जा सकती है और उन्हें मैनेज किया जा सकता है. इस trait से यह कंट्रोल किया जाता है कि जब कोई व्यक्ति दरवाज़े की घंटी बजाए, तो Google के स्मार्ट स्पीकर या डिसप्ले पर विज़िटर की मौजूदगी की सूचना दी जाए या नहीं.

यहां दिए गए उदाहरण में, विज़िटर की सूचनाएं पाने की सुविधा चालू है या नहीं, यह देखने का तरीका बताया गया है. साथ ही, इस सेटिंग को अपडेट करने का तरीका भी बताया गया है:

let visitorAnnouncementsEnabled: Bool = visitorAnnouncementTrait.attributes.visitorAnnouncementsEnabled

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

किसी डिवाइस को बंद करना

किसी स्ट्रक्चर से दरवाज़े की घंटी को हटाने के लिए, device.decommission() पर कॉल करें. डिवाइस को हटाने पर, उपयोगकर्ता को Google की ओर से मैनेज की जाने वाली पुष्टि करने वाली स्क्रीन दिखती है. इस स्क्रीन पर चेतावनी दी जाती है कि लगातार रिकॉर्ड किए गए वीडियो, गतिविधियों की वीडियो रिकॉर्डिंग का इतिहास, क्लिप, और जाने-पहचाने चेहरों की जानकारी वाली लाइब्रेरी का डेटा, स्ट्रक्चर से हमेशा के लिए मिटा दिया जाएगा.

ज़्यादा जानकारी वाले निर्देशों और कोड के उदाहरणों के लिए, किसी डिवाइस को हटाना लेख पढ़ें.