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

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

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

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

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

// [START get_device_information]
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!
let serialNumber = basicInfoTrait.attributes.serialNumber!
// [END get_device_information]

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

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

let lightConnectivity =
  dimmableLightDeviceType.metadata.sourceConnectivity
  .connectivityState

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

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

लाइव स्ट्रीम शुरू करने के लिए, सेशन डिस्क्रिप्शन प्रोटोकॉल (एसडीपी) स्ट्रिंग को 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
  }
}

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

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

TalkBack की सुविधा शुरू करने के लिए, 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)")
  }
}

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

कैमरे की रिकॉर्डिंग की सुविधा चालू करने के लिए, 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
    }
  }
}

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

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

• connectivityState के हिसाब से, कैमरा अब भी ऑनलाइन दिख सकता है. हालांकि, यह पर निर्भर करता है.
• लाइव स्ट्रीम को ऐक्सेस नहीं किया जा सकता. साथ ही, कैमरा किसी भी क्लाउड इवेंट का पता नहीं लगाता.

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

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

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
}

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

बैटरी से जुड़ी अलग-अलग सेटिंग को 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)
  }
}

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

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

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

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

डिवाइस की मौजूदा चार्जिंग की स्थिति (चार्ज हो रहा है, पूरी तरह से चार्ज हो गया है या चार्ज नहीं हो रहा है) की जानकारी पाने के लिए, PowerSource ट्रेट के 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
}

ऑडियो सेटिंग

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

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

डिवाइस के माइक्रोफ़ोन को चालू या बंद करने के लिए, CameraAvStreamManagementTrait ट्रेट के microphoneMuted एट्रिब्यूट की वैल्यू अपडेट करें. इसके लिए, डिवाइस में पहले से मौजूद 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
  }
}

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

डिवाइस के लिए ऑडियो रिकॉर्डिंग की सुविधा चालू या बंद करने के लिए, CameraAvStreamManagementTrait ट्रेट के recordingMicrophoneMuted एट्रिब्यूट को अपडेट करें. इसके लिए, पहले से मौजूद 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
  }
}

स्पीकर की आवाज़ कम या ज़्यादा करना

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

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

अन्य सेटिंग

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

नाइट विज़न मोड को चालू या बंद करना

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

// 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 का इस्तेमाल करके, CameraAvStreamManagementTrait ट्रेट के statusLightBrightness एट्रिब्यूट को अपडेट करें. इसके लिए, पहले से मौजूद setStatusLightBrightness फ़ंक्शन का इस्तेमाल करें:

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

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

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

व्यूपोर्ट को 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
}

डिवाइस के वेक-अप होने की सेंसिटिविटी को अडजस्ट करना

डिवाइस के वेक-अप सेंसर की संवेदनशीलता का इस्तेमाल, बैटरी बचाने के लिए किया जाता है. इसके लिए, डिवाइस की गतिविधि का पता लगाने की रेंज को कम किया जाता है. साथ ही, गतिविधि का पता चलने के बाद डिवाइस के वेक अप होने के समय को बढ़ाया जाता है.

Home API में, इसे डिवाइस के transportOptions में मौजूद triggerOptions की motionSensitivity प्रॉपर्टी का इस्तेमाल करके सेट किया जा सकता है. ये विकल्प, हर डिवाइस के लिए PushAvStreamTransportTrait ट्रेट में तय किए जाते हैं.

डिवाइस को जगाने की सुविधा के लिए, संवेदनशीलता को सिर्फ़ इन वैल्यू पर सेट किया जा सकता है:

• 1 = कम
• 5 = सामान्य
• 10 = ज़्यादा

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

modifyPushTransport कमांड के लिए, पूरे TransportOptionsStruct को पास करना ज़रूरी है. इसलिए, आपको मौजूदा कॉन्फ़िगरेशन से मौजूदा वैल्यू को पहले कॉपी करना होगा. इसके लिए, TransportOptionsStruct जनरेट करना लेख पढ़ें.

func setWakeUpSensitivity(to value: UInt8) async {
  do {
    let connection = try await getRecordingConnection()
    guard let connection,
      let transportOptions = connection.transportOptions
    else {
      // Error - Transport options not available
      return
    }

    guard transportOptions.triggerOptions.motionSensitivity != nil else {
      // Error - Motion sensitivity not available to be updated for this device
      return
    }

    try await pushAvStreamTransportTrait.modifyPushTransport(
      connectionID: connection.connectionID,
      transportOptions: self.getTransportOptions(
        transportOptions: transportOptions,
        wakeUpSensitivity: value,
        maxEventLength: nil
      )
    )

  } catch {
    // Error
  }
}

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

इवेंट की ज़्यादा से ज़्यादा अवधि का मतलब है कि कैमरा किसी इवेंट के लिए कितने समय तक क्लिप रिकॉर्ड करेगा. होम एपीआई के ज़रिए, इसे हर डिवाइस के लिए कॉन्फ़िगर किया जा सकता है. इसके लिए, Google Home app (GHA) के बराबर समयसीमा तय की जा सकती है. यह समयसीमा सेकंड के हिसाब से तय की जाती है:

• 10 सेकंड
• 15 सेकंड
• 30 सेकंड
• 60 सेकंड (एक मिनट)
• 120 सेकंड (दो मिनट)
• 180 सेकंड (3 मिनट)

Home API में, इसे डिवाइस के transportOptions में मौजूद triggerOptions की motionTimeControl प्रॉपर्टी का इस्तेमाल करके सेट किया जा सकता है. ये विकल्प, हर डिवाइस के लिए PushAvStreamTransportTrait ट्रेट में तय किए जाते हैं.

अपडेट करने के लिए, findTransport कमांड का इस्तेमाल करके, चालू रिकॉर्डिंग स्ट्रीम के लिए ट्रांसपोर्ट कॉन्फ़िगरेशन ढूंढें. इसके बाद, modifyPushTransport कमांड का इस्तेमाल करके, कॉन्फ़िगरेशन में इवेंट की नई अवधि की वैल्यू में बदलाव करें.

modifyPushTransport कमांड के लिए, पूरे TransportOptionsStruct को पास करना ज़रूरी है. इसलिए, आपको मौजूदा कॉन्फ़िगरेशन से मौजूदा वैल्यू को पहले कॉपी करना होगा. इसके लिए, TransportOptionsStruct जनरेट करना लेख पढ़ें.

func setMaxEventLength(to value: UInt32) async {
  do {
    let connection = try await getRecordingConnection()
    guard let connection,
      let transportOptions = connection.transportOptions
    else {
      // Error - Transport options not available
      return
    }

    guard transportOptions.triggerOptions.motionTimeControl != nil else {
      // Error - Motion time control not available to be updated for this device
      return
    }

    try await pushAvStreamTransportTrait.modifyPushTransport(
      connectionID: connection.connectionID,
      transportOptions: self.getTransportOptions(
        transportOptions: transportOptions,
        wakeUpSensitivity: nil,
        maxEventLength: value
      )
    )

  } catch {
    // Error
  }
}

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

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

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

डोरबेल की आवाज़ बदलने के लिए, सबसे पहले डिवाइस में इंस्टॉल की गई आवाज़ों की सूची पाएं. इसके लिए, ChimeTrait ट्रेट के 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
  }
}

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

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

किस तरह का बाहरी चाइम इंस्टॉल किया गया है, यह बताने के लिए 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 के ज़रिए कॉन्फ़िगर किया जा सकता है. यह अवधि सेकंड में होती है. अगर बाहरी डिवाइस में, सूचना की अवधि को सेट करने की सुविधा है, तो उपयोगकर्ता इसे कॉन्फ़िगर कर सकता है.

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

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

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

घंटी की आवाज़ वाली थीम चालू करना

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

किसी उपयोगकर्ता के लिए कौनसी चाइम थीम उपलब्ध हैं, यह देखने के लिए टाइमबॉक्स फ़िल्टर बनाएं. इसके बाद, इसका इस्तेमाल 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 <= currentDateTime
      && chimeTheme.endTimeSeconds ?? UInt64.max >= 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)
  }
}```