Android के लिए कैमरा डिवाइस गाइड

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

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

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

कैमरा

GoogleCameraDevice

home.matter.6006.types.0158

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

 ज़रूरी एट्रिब्यूट
     google PushAvStreamTransport
     google 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}")
    }

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

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

val basicInfo: ExtendedBasicInformation = device.getTrait(ExtendedBasicInformation)
val serialNumber = basicInfo.getSerialNumber().serialNumber

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

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

fun getLastContactTimeStamp(trait: ExtendedGeneralDiagnostics): java.time.Instant {
  val timestamp = trait.lastContactTimestamp
  return Instant.ofEpochSecond(timestamp.toLong())
}

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

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

// Get the Mount trait
val mountTrait: Mount = device.getTrait(Mount)

// Read the current mount state and detection type
val mountState = mountTrait.mountState
val mountDetectionType = mountTrait.mountDetectionType

// Read the current mount type name
val mountTypeName = mountTrait.mountTypeName

// Update the mount type override
mountTrait.update {
  setMountTypeOverride(MountTrait.MountTypeOverrideEnum.Official)
}

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

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

val cameraConnectivity = cameraDevice.metadata.sourceConnectivity.connectivityState

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

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

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

val ipAddresses =
  trait.networkInterfaces?.flatMap { networkInterface ->
    (networkInterface.ipv4Addresses + networkInterface.ipv6Addresses).mapNotNull { bytes ->
      try {
        java.net.InetAddress.getByAddress(bytes).hostAddress
      } catch (e: java.net.UnknownHostException) {
        null
      }
    }
  } ?: emptyList()

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

   Android के लिए सैंपल ऐप्लिकेशन में लागू किया गया   

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

  • सेशन के लिए एसडीपी.
  • सेकंड में सेशन कितनी देर चला.
  • यह सेशन आईडी है. इसका इस्तेमाल सेशन को बढ़ाने या खत्म करने के लिए किया जा सकता है.
suspend fun getWebRtcLiveViewTrait(cameraDevice: HomeDevice) {
 return cameraDevice.type(GoogleCameraDevice).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)

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

   Android के लिए सैंपल ऐप्लिकेशन में लागू किया गया   

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

   Android के लिए सैंपल ऐप्लिकेशन में लागू किया गया   

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

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

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

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

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

  • सपोर्ट किए गए क्वालिटी के विकल्प वापस पाएं: डिवाइस पर उपलब्ध स्ट्रीमिंग रिज़ॉल्यूशन पाएं. यह कोड, डिवाइस टाइप फ़्लो पर WebRtcLiveView ट्रेट के supportedQualityHints एट्रिब्यूट के बारे में क्वेरी करता है. साथ ही, काम करने वाली क्वालिटी को StateFlow के तौर पर दिखाता है. इसमें QualityHint वैल्यू (जैसे कि QUALITY_HINT_SD, QUALITY_HINT_HD, QUALITY_HINT_FHD, QUALITY_HINT_QHD या QUALITY_HINT_UHD) की सूची होती है.

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

// Assuming you have a HomeDevice instance 'device'
val availableQualityHints: StateFlow<List> =
    device.type(GoogleCameraDevice)
        .trait(WebRtcLiveView)
        .map { trait -> 
            trait?.supportedQualityHints ?: emptyList() 
        }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(), emptyList())

// Assuming you have a HomeDevice instance 'device'
suspend fun changeQuality(mediaSessionId: String, qualityHint: QualityHint) {
    // Get the trait from the device
    val trait = device.type(GoogleCameraDevice).trait(WebRtcLiveView).first() ?: return
    try {
        trait.changeLiveViewQuality(mediaSessionId, qualityHint)
    } catch (e: Exception) {
        // Handle error
    }
}

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

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

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

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

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

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

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

कैमरे के स्नैपशॉट वापस पाना

   Android के लिए सैंपल ऐप्लिकेशन में लागू किया गया   

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

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

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

कैश की गई झलक का स्नैपशॉट पाना

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

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

// Get a flow of the CameraSnapshot trait
val cameraSnapshotFlow: Flow<CameraSnapshot?> = cameraDevice
  .type(GoogleCameraDevice)
  .trait(CameraSnapshot)

// Get the current trait state
val cameraSnapshot = cameraSnapshotFlow.firstOrNull()
if (cameraSnapshot != null) {
  val previewImageUrl = cameraSnapshot.previewImageUrl
  // Load the preview image from the URL
} else {
  // CameraSnapshot trait not supported on this device
}

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

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

लाइव स्नैपशॉट ऑन-डिमांड पाना

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

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

try {
  val response = cameraSnapshot.getLiveSnapshot()
  val snapshotUrl = response.snapshotUrl
  // Load the live snapshot image from the URL
} catch (e: Exception) {
  Log.e("CameraSnapshot", "Failed to get live snapshot: ${e.message}")
}

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

   Android के लिए सैंपल ऐप्लिकेशन में लागू किया गया   

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

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

import android.graphics.Bitmap
import android.graphics.BitmapFactory
import java.io.IOException
import java.net.HttpURLConnection
import java.net.URL
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

/**
 * Downloads a snapshot from a URL using an OAuth access token.
 */
suspend fun loadSnapshotImage(urlString: String, oauthToken: String): Bitmap? =
  withContext(Dispatchers.IO) {
    var connection: HttpURLConnection? = null
    try {
      val url = URL(urlString)
      connection = url.openConnection() as HttpURLConnection
      // 1. Configure the HTTP GET request with the Bearer token
      connection.setRequestProperty("Authorization", "Bearer $oauthToken")

      // 2. Fetch the image data
      if (connection.responseCode == HttpURLConnection.HTTP_OK) {
        connection.inputStream.use { inputStream ->
          BitmapFactory.decodeStream(inputStream)
        }
      } else {
        null
      }
    } catch (e: IOException) {
      e.printStackTrace()
      null
    } finally {
      connection?.disconnect()
    }
  }

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

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

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

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

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

// Get the battery replacement status
val batteryStatus = powerSourceTrait.batReplacementNeeded

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

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

ऑडियो सेटिंग

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

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

   Android के लिए सैंपल ऐप्लिकेशन में लागू किया गया   

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

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

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

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

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

// 1. Obtain the trait flow from the device
private val zoneManagementFlow: Flow =
  device.type(CAMERA_TYPE).flatMapLatest { it.trait(ZoneManagement) }

// 2. Map the flow to the list of zone structures
val activityZones: Flow<List<ZoneManagementTrait.ZoneInformationStruct>> =
  zoneManagementFlow.map { trait ->
    trait.zones ?: emptyList()
  }

गतिविधि का ज़ोन जोड़ना

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

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

import com.google.home.google.ZoneManagement
import com.google.home.google.ZoneManagementTrait
import com.google.home.matter.serialization.OptionalValue

/**
 * Creates a custom activity zone named "Front Porch" with a salmon color
 * configured for motion detection.
 */
suspend fun createFrontPorchZone(zoneManagement: ZoneManagement) {
  // 1. Define the vertices for the zone (2D Cartesian coordinates)
  // Values are typically scaled to a maximum defined by the device's twoDCartesianMax attribute.
  val vertices =
    listOf(
      ZoneManagementTrait.TwoDCartesianVertexStruct(x = 260u, y = 422u),
      ZoneManagementTrait.TwoDCartesianVertexStruct(x = 1049u, y = 0u),
      ZoneManagementTrait.TwoDCartesianVertexStruct(x = 2048u, y = 0u),
      ZoneManagementTrait.TwoDCartesianVertexStruct(x = 2048u, y = 950u),
      ZoneManagementTrait.TwoDCartesianVertexStruct(x = 1630u, y = 1349u),
      ZoneManagementTrait.TwoDCartesianVertexStruct(x = 880u, y = 2048u),
      ZoneManagementTrait.TwoDCartesianVertexStruct(x = 0u, y = 2048u),
      ZoneManagementTrait.TwoDCartesianVertexStruct(x = 638u, y = 1090u)
    )

  // 2. Define the zone structure
  val newZone =
    ZoneManagementTrait.TwoDCartesianZoneStruct(
      name = "Front Porch",
      vertices = vertices,
      // Usage defines what the zone filters (for example, Motion, Person, Vehicle)
      use = listOf(ZoneManagementTrait.ZoneUseEnum.Motion),
      // Color is typically a hex string (for example, Salmon/Pink)
      color = OptionalValue.present("#F439A0")
    )

  try {
    // 3. Execute the command to add the zone to the device
    zoneManagement.createTwoDCartesianZone(newZone)
    println("Successfully created activity zone.")
  } catch (e: Exception) {
    // Handle potential HomeException or Timeout
    println("Failed to create activity zone: ${e.message}")
  }
}

गतिविधि वाले ज़ोन को अपडेट करना

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

private suspend fun ZoneManagement.updateZone(
  zoneId: UShort,
  zone: ZoneManagementTrait.TwoDCartesianZoneStruct
) {
  // Execute the command to update the zone
  this.updateTwoDCartesianZone(zoneId = zoneId, zone = zone)
}

गतिविधि ज़ोन मिटाना

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

private suspend fun ZoneManagement.deleteZone(zoneId: UShort) {
  // Execute the command to remove the zone
  this.removeZone(zoneId = zoneId)
}

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

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

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

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

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

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

Kotlin फ़्लो का इस्तेमाल करके Android डेवलपमेंट में, आम तौर पर HomeDevice से AvStreamAnalysis ट्रेट को देखा जाता है.

// Example structure to store the
data class EventTriggerAttribute(val type: EventTriggerTypeEnum, val enabled: Boolean)

// 1. Obtain the trait flow from the device
private val avStreamAnalysisFlow: Flow<AvStreamAnalysis> =
  device.traitFromType(AvStreamAnalysis, CAMERA_TYPES.first { device.has(it) })

// 2. Map the flow to a list of sound event attributes
val soundEventTriggersState: Flow<List<EventTriggerAttribute>> =
  avStreamAnalysisFlow.map { trait ->
    // Get raw lists from the trait attributes
    val supported = trait.supportedEventTriggers ?: emptyList()
    val enabled = trait.enabledEventTriggers ?: emptyList()

    // Define sound-specific triggers to filter for
    val soundTypes = setOf(
      EventTriggerTypeEnum.Sound,
      EventTriggerTypeEnum.PersonTalking,
      EventTriggerTypeEnum.DogBark,
      EventTriggerTypeEnum.GlassBreak,
      EventTriggerTypeEnum.SmokeAlarm,
      EventTriggerTypeEnum.CoAlarm,
    )

    // Filter and associate status
    supported
      .filter { soundTypes.contains(it) }
      .map { type ->
        EventTriggerAttribute(
          type = type,
          enabled = enabled.contains(type)
        )
      }
  }

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

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

private suspend fun AvStreamAnalysis.updateEventTriggers(
  eventTriggers: List<EventTriggerAttribute>
) {
  val toUpdate = eventTriggers.map {
    EventTriggerEnablement(
      eventTriggerType = it.type,
      enablementStatus = if (it.enabled) {
        EnablementStatusEnum.Enabled
      } else {
        EnablementStatusEnum.Disabled
      },
    )
  }

  // Execute the command on the device
  setOrUpdateEventDetectionTriggers(toUpdate)
}

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

   Android के लिए सैंपल ऐप्लिकेशन में लागू किया गया   

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

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

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

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

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

// 1. Obtain the trait flow from the device
private val recordingModeTraitFlow: Flow =
    device.traitFromType(RecordingMode, CAMERA_TYPES.first { device.has(it) })

// 2. Map the flow to recording mode options
data class RecordingModeOptions(
    val recordingMode: RecordingModeTrait.RecordingModeEnum,
    val index: Int,
    val available: Boolean,
    val readableString: String,
)

private val recordingModeOptions: Flow<List> =
    recordingModeTraitFlow.map { trait ->
        val supported = trait.supportedRecordingModes?.map { it.recordingMode } ?: emptyList()
        val available = trait.availableRecordingModes?.map { it.toInt() } ?: emptyList()

        supported.withIndex().map { (index, mode) ->
            RecordingModeOptions(
                recordingMode = mode,
                index = index,
                available = available.contains(index),
                readableString = mode.toReadableString(),
            )
        }
    }

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

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

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

private suspend fun RecordingMode.updateRecordingMode(index: Int) {
    // Execute the command to update the selected mode
    this.setSelectedRecordingMode(index.toUByte())
}

अन्य सेटिंग

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

इमेज का ओरिएंटेशन बदलना

कैमरे की इमेज (वीडियो) के ओरिएंटेशन को घुमाया जा सकता है. वीडियो को सिर्फ़ 180 डिग्री पर घुमाया जा सकता है.

कैमरे की इमेज का ओरिएंटेशन बदलने के लिए, पहले से मौजूद setImageRotation Kotlin फ़ंक्शन का इस्तेमाल करके, CameraAvStreamManagement ट्रेट के imageRotation एट्रिब्यूट को अपडेट करें:

// Change the camera's image orientation
val isRotated = false

cameraAvStreamManagement.update { setImageRotation(if (isRotated) 180.toUShort() else 0.toUShort()) }

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

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

// 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 कैमरे के वीडियो को ज़ूम और बेहतर बनाना सहायता लेख में बताई गई ज़ूम और क्रॉप करने की सुविधा की तरह ही होता है.

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

Analytics को चालू या बंद करना

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

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

// Enable analytics
extendedGeneralDiagnostics.update {
  setAnalyticsEnabled(true)
}

// Disable analytics
extendedGeneralDiagnostics.update {
  setAnalyticsEnabled(false)
}

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

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

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

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

val trait: PushAvStreamTransport = device.getTrait(PushAvStreamTransport)
val connections = trait.findTransport().transportConfigurations

// Locate the connection designated for recording
val recordingConnection = connections.firstOrNull {
    it.transportOptions.getOrNull()?.streamUsage == StreamUsageEnum.Recording
}

val options = recordingConnection?.transportOptions?.getOrNull()

// 1. Bandwidth Quality (Video Stream ID)
val videoStreamId = options?.videoStreamId?.getOrNull()

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

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

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

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

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

val toUpdate = TransportOptionsStruct(
    videoStreamId = OptionalValue.present(2u), // e.g., Max Quality
    triggerOptions = TransportTriggerOptionsStruct(
        motionSensitivity = OptionalValue.present(5u), // e.g., Medium
        motionTimeControl = OptionalValue.present(
            TransportMotionTriggerTimeControlStruct(maxDuration = 30u)
        )
    )
)

if (recordingConnection != null) {
    trait.modifyPushTransport(
        connectionId = recordingConnection.connectionId,
        transportOptions = toUpdate
    )
}

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

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

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

डिवाइस को चालू करने की सुविधा की सेंसिटिविटी को अडजस्ट करना

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

लेबल वैल्यू (UByte)
कम 1u
मीडियम 5u
ज़्यादा 10u

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

TransportMotionTriggerTimeControlStruct की maxDuration प्रॉपर्टी, यहां दी गई अवधि (सेकंड में) के बराबर होती है:

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

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

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

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