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

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

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

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

   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 के लिए सैंपल के तौर पर मिले ऐप्लिकेशन में लागू किया गया   

टॉकबैक शुरू करने के लिए, 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 ट्रेट के 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
    }
}

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

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

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

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

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

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

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

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

// 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 हेडर में, धारक टोकन के तौर पर शामिल किया जाना चाहिए.

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

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 trait के 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 API की मदद से, ऑडियो की अलग-अलग सेटिंग कंट्रोल की जा सकती हैं.

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

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

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

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

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

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

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

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

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

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

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

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

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

आम तौर पर, ऐक्टिविटी ज़ोन को 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)
}

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

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

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

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

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

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

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

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

• supportedEventTriggers
• enabledEventTriggers

Kotlin Flows का इस्तेमाल करके 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 से, रिकॉर्डिंग की उपलब्ध रणनीतियां तय होती हैं:

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

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

• supportedRecordingModes - सभी संभावित मोड
• availableRecordingModes - चुने जा सकने वाले मोड
• selectedRecordingMode - ऐक्टिव मोड

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

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

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

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

हर डिवाइस, 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 trait से.

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

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

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

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

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

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

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

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