Android के लिए, दरवाज़े की घंटी वाले डिवाइस से जुड़ी गाइड

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

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

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

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

// Get device basic information. All general information traits are on the RootNodeDevice type.
    device.type(RootNodeDevice).first().standardTraits.basicInformation?.let { basicInformation ->
        println("vendorName ${basicInformation.vendorName}")
        println("vendorId ${basicInformation.vendorId}")
        println("productId ${basicInformation.productId}")
        println("productName ${basicInformation.productName}")
        println("softwareVersion ${basicInformation.softwareVersion}")
        println("serialNumber ${basicInformation.serialNumber}")
    }

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

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

val lightConnectivity = dimmableLightDevice.metadata.sourceConnectivity.connectivityState

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

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

लाइव स्ट्रीम शुरू करने के लिए, Session Description Protocol (SDP) स्ट्रिंग को WebRtcLiveView ट्रेट के startLiveView() तरीके पर भेजें. इससे WebRtcLiveViewTrait.StartLiveViewCommand.Response मिलता है, जिसमें ये तीन वैल्यू होती हैं:

• सेशन के लिए एसडीपी.
• सत्र की अवधि, सेकंड में.
• सेशन आईडी, जिसका इस्तेमाल सेशन को बढ़ाने या खत्म करने के लिए किया जा सकता है.

suspend fun getWebRtcLiveViewTrait(cameraDevice: HomeDevice) {
 return cameraDevice.type(GoogleDoorbellDevice).trait(WebRtcLiveView).first {
    it?.metadata?.sourceConnectivity?.connectivityState == ConnectivityState.ONLINE
  }

}

// Start the live view
suspend fun startCameraStream(trait: WebRtcLiveView, offerSdp: String) {
  val response = trait.startLiveView(offerSdp)
  // Response contains three fields (see below)
  return response
}
  ...

// This is used to manage the WebRTC connection
val peerConnection: RTCPeerConnection = ...

   ...

val startResponse = startCameraStream(sdp)
val answerSdp = startResponse?.answerSdp
val sessionDuration = startResponse?.liveSessionDurationSeconds
val mediaSessionId = startResponse?.mediaSessionId

peerConnection.setRemoteDescription(SessionDescription.Type.ANSWER,
                                    answerSdp)

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

लाइव स्ट्रीम की अवधि पहले से तय होती है. इसके बाद, वे खत्म हो जाती हैं. चालू स्ट्रीम की अवधि बढ़ाने के लिए, WebRtcLiveView.extendLiveView() तरीके का इस्तेमाल करके, अवधि बढ़ाने का अनुरोध करें:

// Assuming camera stream has just been started
suspend fun scheduleExtension(trait: WebRtcLiveView, mediaSessionId: String, liveSessionDurationSeconds: UShort ) {
  delay(liveSessionDurationSeconds - BUFFER_SECONDS * 1000)
  val response = trait.extendLiveView(mediaSessionId)
  // returns how long the session will be live for
  return response.liveSessionDurationSeconds
}

TalkBack को चालू और बंद करना

TalkBack की सुविधा शुरू करने के लिए, WebRtcLiveView ट्रेट के startTalkback() तरीके को कॉल करें. इसे बंद करने के लिए, stopTalkback() का इस्तेमाल करें.

// Make sure camera stream is on
suspend fun setTalkback(isOn: Boolean, trait: WebRtcLiveView, mediaSessionId: String) {
  if(isOn) {
    trait.startTalkback(mediaSessionId)
  } else {
    trait.stopTalkback(mediaSessionId)
  }
}

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

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

// Start or stop recording for all connections.
suspend fun setCameraRecording(trait: PushAvStreamTransport, isOn: Boolean) {
  if(isOn) {
    trait.setTransportStatus(TransportStatusEnum.Active)
  } else {
    trait.setTransportStatus(TransportStatusEnum.Inactive)
  }
}

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

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

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

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

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

// Get the on/off state
suspend fun onOffState(pushAvStreamTransport: PushAvStreamTransport) {
  return pushAvStreamTransport
    .currentConnections?.any { it.transportStatus == TransportStatusEnum.Active } ?: false
}

// Check if the camera's recording capability is enabled
fun PushAvStreamTransport.recordModeActive(): Boolean {
  return currentConnections?.any { it.transportStatus == TransportStatusEnum.Active } ?: false
}

जांच करने का एक और तरीका है. इसके लिए, प्रेडिकेट के साथ findTransport() फ़ंक्शन का इस्तेमाल करें:

// Fetch the current connections
suspend fun queryRecordModeState(trait: PushAvStreamTransport) {
  return trait.findTransport().let {
      it.transportConfigurations.any { it.transportStatus == TransportStatusEnum.Active
    }
}

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

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

// The index parameter must be within the UByte range (0-255).
suspend fun setEnergyBalance(trait: EnergyPreference, index: Int) {
  trait.update { setCurrentEnergyBalance(index.toUByte()) }
}

// Setting the battery usage to more recording ie performance
setEnergyBalance(energyPreference, 2)

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

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

suspend fun setAutomaticBatterySaver(enable: Boolean, trait: EnergyPreference) {
  // 0 is Disabled, 1 is Enabled
  val value = if (enable) 1.toUByte() else 0.toUByte()
  trait.update { setCurrentLowPowerModeSensitivity(value) }
}

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

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

// Get the battery charging state
val batteryChargeState = powerSource.batChargeState

when (batteryChargeState) {
    PowerSourceTrait.BatChargeStateEnum.IsCharging -> "Charging"
    PowerSourceTrait.BatChargeStateEnum.IsAtFullCharge -> "Full"
    PowerSourceTrait.BatChargeStateEnum.IsNotCharging -> "Not Charging"
    else -> "Unknown"
}

बैटरी लेवल की जानकारी पाना

बैटरी का मौजूदा लेवल पाने के लिए, PowerSource ट्रेट के batChargeLevel एट्रिब्यूट का इस्तेमाल करें. यह लेवल OK, Warning (कम) या Critical में से कोई एक है.

// Get the battery charge level
val batteryLevel = powerSourceTrait.batChargeLevel

when (batteryLevel) {
    PowerSourceTrait.BatChargeLevelEnum.OK -> "OK"
    PowerSourceTrait.BatChargeLevelEnum.Warning -> "Warning"
    PowerSourceTrait.BatChargeLevelEnum.Critical -> "Critical"
    else -> "Unknown"
}

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

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

  val trait: PowerSource
  val isWired = trait.wiredPresent
  val hasBattery = trait.batPresent

ऑडियो सेटिंग

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

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

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

// Turn the device's microphone on or off
suspend fun turnOffMicrophone(disableMicrophone: Boolean, trait: CameraAvStreamManagement) {
  trait.update { setMicrophoneMuted(disableMicrophone) }
}

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

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

// Turn audio recording on or off for the device
suspend fun turnOffAudioRecording(disableAudioRecording: Boolean, trait: CameraAvStreamManagement) {
  trait.update { setRecordingMicrophoneMuted(disableAudioRecording) }
}

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

डिवाइस के स्पीकर का वॉल्यूम घटाने या बढ़ाने के लिए, CameraAvStreamManagement ट्रेट के speakerVolumeLevel एट्रिब्यूट को अपडेट करें. इसके लिए, setSpeakerVolumeLevel Kotlin फ़ंक्शन का इस्तेमाल करें:

// Adjust the camera speaker volume
suspend fun adjustSpeakerVolume(volume: Int, trait: CameraAvStreamManagement) {
  trait.update { setSpeakerVolumeLevel(volume.toUbyte()) }
}

अन्य सेटिंग

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

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

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

// Turn night vision on
cameraAvStreamManagement.update {
  setNightVision(CameraAvStreamManagementTrait.TriStateAutoEnum.On)
}

// Turn night vision off
CameraAvStreamManagement.update {
  setNightVision(CameraAvStreamManagementTrait.TriStateAutoEnum.Off)
}

स्टेटस एलईडी की चमक बदलना

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

// Set the LED brightness to high
cameraAvStreamManagement.update {
  setStatusLightBrightness(CameraAvStreamManagementTrait.ThreeLevelAutoEnum.High)
}

// Set the LED brightness to low
cameraAvStreamManagement.update {
  setStatusLightBrightness(CameraAvStreamManagementTrait.ThreeLevelAutoEnum.Low)
}

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

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

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

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

ViewportStruct के लिए वैल्यू तय करना, ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) और कैमरे को लागू करने के तरीके पर निर्भर करता है. कैमरे के वीडियो का व्यूपोर्ट सेट करने के लिए, CameraAvStreamManagement ट्रेट के viewport एट्रिब्यूट को ViewportStruct से अपडेट करें. इसके लिए, setViewport Kotlin फ़ंक्शन का इस्तेमाल करें:

cameraAvStreamManagement
  .update { setViewport(
    CameraAvStreamManagementTrait.ViewportStruct(
      x1 = horizontalRange.rangeStart.roundToInt().toUShort(),
      x2 = horizontalRange.rangeEnd.roundToInt().toUShort(),
      y1 = verticalRange.rangeStart.roundToInt().toUShort(),
      y2 = verticalRange.rangeEnd.roundToInt().toUShort(),
    )
) }

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

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

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

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

• 1 = कम
• 5 = मीडियम
• 10 = ज़्यादा

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

// Create a struct with the new wake-up sensitivity
val toUpdate =  TransportOptionsStruct(
  triggerOptions =
    TransportTriggerOptionsStruct(
      motionSensitivity =
        OptionalValue.present(wakeUpSensitivity.toUByte())
    )
  )

// Get the configurations for active connections
val connections  = pushAvStreamTransport.findTransport().transportConfigurations
  // Update all recording streams with the new transport options.
  for (connection in connections) {
    if (connection.transportOptions.getOrNull()?.streamUsage == StreamUsageEnum.Recording) {
      trait.modifyPushTransport(
        connectionId = connection.connectionId,
        transportOptions = toUpdate,
      )
    }
  }

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

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

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

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

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

// Create a struct with the new max event length
// where maxDuration is the length in seconds
val toUpdate =  TransportOptionsStruct(
  triggerOptions =
    TransportTriggerOptionsStruct(
      motionTimeControl =
        OptionalValue.present(
          TransportMotionTriggerTimeControlStruct(maxDuration = it.toUInt())
        )
    )
  )

// Get the configurations for active connections
val connections  = pushAvStreamTransport.findTransport().transportConfigurations
  // Update all recording streams with the new transport options.
  for (connection in connections) {
    if (connection.transportOptions.getOrNull()?.streamUsage == StreamUsageEnum.Recording) {
      trait.modifyPushTransport(
        connectionId = connection.connectionId,
        transportOptions = toUpdate,
      )
    }
  }

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

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

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

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

// Get a list of chimes and identify the currently selected one
private val doorbellChimeTraitFlow: Flow =
    device.traitFromType(Chime, GoogleDoorbellDevice)
val chimeSounds = doorbellChimeTraitFlow.first().installedChimeSounds ?: emptyList()

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

// Set the chime using the chimeId from the installed list
chimeSounds.firstOrNull { it.name == name }?.let { setSelectedChime(it.chimeId) }

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

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

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

// Indicate the external chime is mechanical
chime.update {
  setExternalChime(ChimeTrait.ExternalChimeType.Mechanical)
}

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

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

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

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

// Change the external chime duration
chime.update {
  setExternalChimeDurationSeconds(newDuration.toUShort())
}

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

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

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

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

// Get themes from the ChimeThemes trait
fun List<ChimeThemesTrait.ThemeStruct>.filterTimeboxedThemes():
    List<ChimeThemesTrait.ThemeStruct> {
  val now = timeSource.instant().epochSecond.toULong()
  return filter { chimeStruct: ChimeThemesTrait.ThemeStruct ->
    val startTime: ULong = chimeStruct.startTimeSeconds.getOrNull() ?: 0UL
    val endTime: ULong = chimeStruct.endTimeSeconds.getOrNull() ?: MAX_VALUE
    startTime <= now && now <= endTime
  }
}

val availableThemes =
  doorbellChimeThemesTraitFlow
    .first()
    .getAvailableThemes()
    .themes
    .filterTimeboxedThemes()

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

// Select a theme using the ChimeThemes trait
val themeToSelect = "Christmas"
if (themeToSelect in availableThemeNames) {
  doorbellChimeThemesTraitFlow.first().setSelectedTimeboxedThemeName(themeToSelect)
}