इस पेज का अनुवाद Cloud Translation API से किया गया है.

बाहरी डिवाइसों को कंट्रोल करना

Android 11 और उसके बाद के वर्शन में, क्विक ऐक्सेस डिवाइस कंट्रोल की सुविधा उपयोगकर्ता को लाइट जैसे बाहरी डिवाइसों को तुरंत देखने और कंट्रोल करने की सुविधा देता है, और साथ ही उपयोगकर्ता की क्षमता के आधार पर तीन इंटरैक्शन के बाद कैमरे और थर्मोस्टैट का इस्तेमाल कर सकते हैं डिफ़ॉल्ट लॉन्चर. डिवाइस का OEM यह चुनता है कि कौनसा लॉन्चर इस्तेमाल करना है. डिवाइस एग्रीगेटर—जैसे, Google Home और तीसरे पक्ष के वेंडर ऐप्लिकेशन इस जगह में डिसप्ले के लिए डिवाइस उपलब्ध कराएं. इस पेज में बताया गया है कि इस स्पेस में डिवाइस कंट्रोल जोड़े जा सकते हैं. साथ ही, इन्हें अपने कंट्रोल ऐप्लिकेशन से जोड़ा जा सकता है.

पहली इमेज. Android यूज़र इंटरफ़ेस (यूआई) में डिवाइस कंट्रोल स्पेस.

यह सहायता जोड़ने के लिए, ControlsProviderService बनाएं और उसका एलान करें. अपनी ऑडियंस के लिए पहले से तय कंट्रोल टाइप के आधार पर, आपके ऐप्लिकेशन के साथ काम करता है. इसके बाद, इन कंट्रोल के लिए, पब्लिशर के लिए कुछ ज़रूरी शर्तें पूरी करते हैं.

उपयोगकर्ता इंटरफ़ेस

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

टॉगल करें	स्लाइडर की मदद से टॉगल करें	रेंज (इसे टॉगल करके चालू या बंद नहीं किया जा सकता)
स्टेटलेस टॉगल	तापमान पैनल (बंद है)

दूसरी इमेज. टेंप्लेट वाले विजेट का कलेक्शन.

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

तापमान पैनल विजेट (खुला हुआ) दिखाने वाली इमेज — **तीसरा डायग्राम.** तापमान पैनल विजेट खोलें.

सेवा बनाना

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

ControlsProviderService एपीआई, प्रतिक्रिया वाली स्ट्रीम को समझना चाहता है, क्योंकि Reactive Streams GitHub में तय किया गया है प्रोजेक्ट और Java 9 फ़्लो में लागू किया जाता है इंटरफ़ेस के रूप में दिखाया जाता है. एपीआई को इन कॉन्सेप्ट के आधार पर बनाया गया है:

प्रकाशक: आपका ऐप्लिकेशन, प्रकाशक है.
सदस्य: सिस्टम का यूज़र इंटरफ़ेस (यूआई), सदस्य है और यह नंबर का अनुरोध कर सकता है कंट्रोल मिलता है.
सदस्यता: वह समयसीमा जिसके दौरान पब्लिशर, सिस्टम यूज़र इंटरफ़ेस (यूआई) में अपडेट भेज सकता है. पब्लिशर या सदस्य, दोनों में से कोई भी इस विंडो को बंद कर सकता है.

सेवा का एलान करना

आपके ऐप्लिकेशन को किसी सेवा की जानकारी देना ज़रूरी है. जैसे, MyCustomControlService की जानकारी मेनिफ़ेस्ट फ़ाइल में मौजूद सभी दस्तावेज़ शामिल हैं.

सेवा में ControlsProviderService के लिए इंटेंट फ़िल्टर शामिल होना चाहिए. इस फ़िल्टर की मदद से, ऐप्लिकेशन सिस्टम यूज़र इंटरफ़ेस (यूआई) में कंट्रोल जोड़ सकते हैं.

आपको एक label भी चाहिए, जो सिस्टम यूज़र इंटरफ़ेस (यूआई) के कंट्रोल में दिखता है.

यहां दिए गए उदाहरण में, किसी सेवा का एलान करने का तरीका बताया गया है:

<service
    android:name="MyCustomControlService"
    android:label="My Custom Controls"
    android:permission="android.permission.BIND_CONTROLS"
    android:exported="true"
    >
    <intent-filter>
      <action android:name="android.service.controls.ControlsProviderService" />
    </intent-filter>
</service>

इसके बाद, MyCustomControlService.kt नाम की नई Kotlin फ़ाइल बनाएं और इसे ControlsProviderService() को आगे बढ़ाएं:

Kotlin

    class MyCustomControlService : ControlsProviderService() {
        ...
    }

Java

    public class MyCustomJavaControlService extends ControlsProviderService {
        ...
    }

कंट्रोल का सही टाइप चुनना

एपीआई, कंट्रोल बनाने के लिए बिल्डर तरीके उपलब्ध कराता है. को पॉप्युलेट करने के लिए बिल्डर, वह डिवाइस तय करें जिसे आपको कंट्रोल करना है. साथ ही, यह भी तय करें कि उपयोगकर्ता कैसे इंटरैक्ट करे उसके साथ. यह तरीका अपनाएं:

कंट्रोल से जिस तरह का डिवाइस दिखाया जा रहा है उसे चुनें. कॉन्टेंट बनाने DeviceTypes क्लास काम करने वाले सभी डिवाइसों की सूची. टाइप का इस्तेमाल, यूज़र इंटरफ़ेस (यूआई) में डिवाइस के आइकॉन और रंग तय करने के लिए किया जाता है.
उपयोगकर्ता के सामने दिखने वाला नाम, डिवाइस की जगह की जानकारी—उदाहरण के लिए, किचन—और कंट्रोल से जुड़े अन्य यूज़र इंटरफ़ेस (यूआई) टेक्स्ट एलिमेंट तय करें.
उपयोगकर्ता इंटरैक्शन की सुविधा देने के लिए सबसे सही टेंप्लेट चुनें. कंट्रोल, असाइन किए गए ControlTemplate से हटा दें. यह टेंप्लेट, उपयोगकर्ता को सीधे तौर पर कंट्रोल की स्थिति के साथ-साथ, इनपुट के उपलब्ध तरीकों को दिखाता है. जैसे, ControlAction. यहां दी गई टेबल में, उपलब्ध कुछ टेंप्लेट और उन पर की जा सकने वाली कार्रवाइयों के बारे में बताया गया है:

टेंप्लेट	कार्रवाई	ब्यौरा
`ControlTemplate.getNoTemplateObject()`	`None`	ऐप्लिकेशन इसका इस्तेमाल कंट्रोल के बारे में जानकारी देने के लिए कर सकता है, हालांकि, उपयोगकर्ता इससे इंटरैक्ट नहीं कर सकता.
`ToggleTemplate`	`BooleanAction`	ऐसे कंट्रोल को दिखाता है जिसे चालू और बंद की स्थितियों के बीच स्विच किया जा सकता है. `BooleanAction` ऑब्जेक्ट में ऐसा फ़ील्ड है जो बदलता है जब उपयोगकर्ता कंट्रोल पर टैप करेगा, तब अनुरोध की गई नई स्थिति को दिखाया जाएगा.
`RangeTemplate`	`FloatAction`	यह स्लाइडर विजेट दिखाता है, जिसमें कम से कम, ज़्यादा से ज़्यादा, और चरण की वैल्यू तय की गई है. जब उपयोगकर्ता स्लाइडर के साथ इंटरैक्ट करता है, तो अपडेट की गई वैल्यू के साथ, ऐप्लिकेशन को एक नया `FloatAction` ऑब्जेक्ट भेजें.
`ToggleRangeTemplate`	`BooleanAction, FloatAction`	यह टेंप्लेट, `ToggleTemplate` और `RangeTemplate`. यह सुविधा, टच इवेंट के साथ-साथ, स्लाइडर का इस्तेमाल करती है. जैसे कि रोशनी कम की जा सकने वाली लाइटों को कंट्रोल करना.
`TemperatureControlTemplate`	`ModeAction, BooleanAction, FloatAction`	पहले की कार्रवाइयों को शामिल करने के अलावा, यह टेंप्लेट आपको उपयोगकर्ता ने कोई मोड सेट किया हो, जैसे कि गर्मी, ठंडा, गर्म/ठंडा, ईको या बंद.
`StatelessTemplate`	`CommandAction`	इसका इस्तेमाल ऐसे कंट्रोल के बारे में बताने के लिए किया जाता है जो टच क्षमता उपलब्ध कराता है, लेकिन जिसकी स्थिति निर्धारित नहीं किया जा सकता, जैसे कि IR टेलीविज़न रिमोट. इस टेंप्लेट का इस्तेमाल, किसी रूटीन या मैक्रो को तय करने के लिए किया जा सकता है. यह कंट्रोल और स्टेटस में हुए बदलावों का एग्रीगेशन होता है.

इस जानकारी की मदद से, यह कंट्रोल बनाया जा सकता है:

जब कंट्रोल की स्थिति की जानकारी न हो, तो Control.StatelessBuilder बिल्डर क्लास का इस्तेमाल करें.
इसका इस्तेमाल करें Control.StatefulBuilder बिल्डर क्लास को तब सेट करता है, जब कंट्रोल की स्थिति का पता चलता है.

उदाहरण के लिए, स्मार्ट लाइट बल्ब और थर्मोस्टैट को कंट्रोल करने के लिए, यह जानकारी जोड़ें आपके MyCustomControlService के लिए स्थिरांक:

Kotlin

    private const val LIGHT_ID = 1234
    private const val LIGHT_TITLE = "My fancy light"
    private const val LIGHT_TYPE = DeviceTypes.TYPE_LIGHT
    private const val THERMOSTAT_ID = 5678
    private const val THERMOSTAT_TITLE = "My fancy thermostat"
    private const val THERMOSTAT_TYPE = DeviceTypes.TYPE_THERMOSTAT
 
    class MyCustomControlService : ControlsProviderService() {
      ...
    }

Java

    public class MyCustomJavaControlService extends ControlsProviderService {
 
    private final int LIGHT_ID = 1337;
    private final String LIGHT_TITLE = "My fancy light";
    private final int LIGHT_TYPE = DeviceTypes.TYPE_LIGHT;
    private final int THERMOSTAT_ID = 1338;
    private final String THERMOSTAT_TITLE = "My fancy thermostat";
    private final int THERMOSTAT_TYPE = DeviceTypes.TYPE_THERMOSTAT;
 
    ...
    }

कंट्रोल के लिए पब्लिशर बनाएं

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

createPublisherForAllAvailable(): आपके ऐप्लिकेशन में उपलब्ध सभी कंट्रोल के लिए, Publisher बनाता है. इस पब्लिशर के लिए Control ऑब्जेक्ट बनाने के लिए, Control.StatelessBuilder() का इस्तेमाल करें.
createPublisherFor(): यह दिए गए कंट्रोल की सूची के लिए, Publisher बनाता है, जिसकी पहचान उनके स्ट्रिंग आइडेंटिफ़ायर से की जाती है. इसके लिए Control.StatefulBuilder का इस्तेमाल करें ये Control ऑब्जेक्ट बना सकते हैं, क्योंकि पब्लिशर को हर कंट्रोल के लिए.

पब्लिशर बनाना

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

Android यूज़र इंटरफ़ेस (यूआई) में कंट्रोल दिखने के बाद, उपयोगकर्ता अपने पसंदीदा कंट्रोल चुन सकता है.

ControlsProviderService बनाने के लिए Kotlin कोरूटीन का इस्तेमाल करने के लिए, अपने build.gradle में एक नई डिपेंडेंसी जोड़ें:

Groovy

dependencies {
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-jdk9:1.6.4"
}

Kotlin

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-jdk9:1.6.4")
}

Gradle फ़ाइलों को सिंक करने के बाद, createPublisherForAllAvailable() को लागू करने के लिए, अपने Service में यह स्निपेट जोड़ें:

Kotlin

    class MyCustomControlService : ControlsProviderService() {
 
      override fun createPublisherForAllAvailable(): Flow.Publisher =
          flowPublish {
              send(createStatelessControl(LIGHT_ID, LIGHT_TITLE, LIGHT_TYPE))
              send(createStatelessControl(THERMOSTAT_ID, THERMOSTAT_TITLE, THERMOSTAT_TYPE))
          }
 
      private fun createStatelessControl(id: Int, title: String, type: Int): Control {
          val intent = Intent(this, MainActivity::class.java)
              .putExtra(EXTRA_MESSAGE, title)
              .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
          val action = PendingIntent.getActivity(
              this,
              id,
              intent,
              PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
          )
 
          return Control.StatelessBuilder(id.toString(), action)
              .setTitle(title)
              .setDeviceType(type)
              .build()
      }
 
          override fun createPublisherFor(controlIds: List): Flow.Publisher {
           TODO()
        }
 
        override fun performControlAction(
            controlId: String,
            action: ControlAction,
            consumer: Consumer
        ) {
            TODO()
        }
    }

Java

    public class MyCustomJavaControlService extends ControlsProviderService {
 
        private final int LIGHT_ID = 1337;
        private final String LIGHT_TITLE = "My fancy light";
        private final int LIGHT_TYPE = DeviceTypes.TYPE_LIGHT;
        private final int THERMOSTAT_ID = 1338;
        private final String THERMOSTAT_TITLE = "My fancy thermostat";
        private final int THERMOSTAT_TYPE = DeviceTypes.TYPE_THERMOSTAT;
 
        private boolean toggleState = false;
        private float rangeState = 18f;
        private final Map<String, ReplayProcessor> controlFlows = new HashMap<>();
 
        @NonNull
        @Override
        public Flow.Publisher createPublisherForAllAvailable() {
            List controls = new ArrayList<>();
            controls.add(createStatelessControl(LIGHT_ID, LIGHT_TITLE, LIGHT_TYPE));
            controls.add(createStatelessControl(THERMOSTAT_ID, THERMOSTAT_TITLE, THERMOSTAT_TYPE));
            return FlowAdapters.toFlowPublisher(Flowable.fromIterable(controls));
        }
 
        @NonNull
        @Override
        public Flow.Publisher createPublisherFor(@NonNull List controlIds) {
            ReplayProcessor updatePublisher = ReplayProcessor.create();
 
            controlIds.forEach(control -> {
                controlFlows.put(control, updatePublisher);
                updatePublisher.onNext(createLight());
                updatePublisher.onNext(createThermostat());
            });
 
            return FlowAdapters.toFlowPublisher(updatePublisher);
        }
    }

सिस्टम मेन्यू से नीचे की ओर स्वाइप करें और यहां दिख रहे डिवाइस कंट्रोल बटन का पता लगाएं चौथी इमेज:

डिवाइस कंट्रोल के लिए सिस्टम यूज़र इंटरफ़ेस (यूआई) दिखाने वाली इमेज — **चौथी इमेज.** सिस्टम मेन्यू में डिवाइस कंट्रोल.

डिवाइस कंट्रोल पर टैप करने से, आपको दूसरी स्क्रीन पर ले जाया जाता है. यहां अपना ऐप्लिकेशन चुना जा सकता है. ऐप्लिकेशन चुनने के बाद, आपको पता चलता है कि पिछले स्निपेट ने आपके नए कंट्रोल दिखाने के लिए, कस्टम सिस्टम मेन्यू कैसे बनाया है. इसकी जानकारी, पांचवें चित्र में दी गई है:

लाइट और थर्मोस्टैट कंट्रोल वाले सिस्टम मेन्यू को दिखाने वाली इमेज — **पांचवीं इमेज.** लाइट और थर्मोस्टैट के कंट्रोल जोड़े जा सकते हैं.

अब createPublisherFor() तरीके को लागू करें. साथ ही, इन्हें अपने Service:

Kotlin

    private val job = SupervisorJob()
    private val scope = CoroutineScope(Dispatchers.IO + job)
    private val controlFlows = mutableMapOf<String, MutableSharedFlow>()
 
    private var toggleState = false
    private var rangeState = 18f
 
    override fun createPublisherFor(controlIds: List): Flow.Publisher {
        val flow = MutableSharedFlow(replay = 2, extraBufferCapacity = 2)
 
        controlIds.forEach { controlFlows[it] = flow }
 
        scope.launch {
            delay(1000) // Retrieving the toggle state.
            flow.tryEmit(createLight())
 
            delay(1000) // Retrieving the range state.
            flow.tryEmit(createThermostat())
 
        }
        return flow.asPublisher()
    }
 
    private fun createLight() = createStatefulControl(
        LIGHT_ID,
        LIGHT_TITLE,
        LIGHT_TYPE,
        toggleState,
        ToggleTemplate(
            LIGHT_ID.toString(),
            ControlButton(
                toggleState,
                toggleState.toString().uppercase(Locale.getDefault())
            )
        )
    )
 
    private fun createThermostat() = createStatefulControl(
        THERMOSTAT_ID,
        THERMOSTAT_TITLE,
        THERMOSTAT_TYPE,
        rangeState,
        RangeTemplate(
            THERMOSTAT_ID.toString(),
            15f,
            25f,
            rangeState,
            0.1f,
            "%1.1f"
        )
    )
 
    private fun  createStatefulControl(id: Int, title: String, type: Int, state: T, template: ControlTemplate): Control {
        val intent = Intent(this, MainActivity::class.java)
            .putExtra(EXTRA_MESSAGE, "$title $state")
            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
        val action = PendingIntent.getActivity(
            this,
            id,
            intent,
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
        )
 
        return Control.StatefulBuilder(id.toString(), action)
            .setTitle(title)
            .setDeviceType(type)
            .setStatus(Control.STATUS_OK)
            .setControlTemplate(template)
            .build()
    }
 
    override fun onDestroy() {
        super.onDestroy()
        job.cancel()
    }

Java

    @NonNull
    @Override
    public Flow.Publisher createPublisherFor(@NonNull List controlIds) {
        ReplayProcessor updatePublisher = ReplayProcessor.create();
 
        controlIds.forEach(control -> {
            controlFlows.put(control, updatePublisher);
            updatePublisher.onNext(createLight());
            updatePublisher.onNext(createThermostat());
        });
 
        return FlowAdapters.toFlowPublisher(updatePublisher);
    }
 
    private Control createStatelessControl(int id, String title, int type) {
        Intent intent = new Intent(this, MainActivity.class)
                .putExtra(EXTRA_MESSAGE, title)
                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        PendingIntent action = PendingIntent.getActivity(
                this,
                id,
                intent,
                PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
        );
 
        return new Control.StatelessBuilder(id + "", action)
                .setTitle(title)
                .setDeviceType(type)
                .build();
    }
 
    private Control createLight() {
        return createStatefulControl(
                LIGHT_ID,
                LIGHT_TITLE,
                LIGHT_TYPE,
                toggleState,
                new ToggleTemplate(
                        LIGHT_ID + "",
                        new ControlButton(
                                toggleState,
                                String.valueOf(toggleState).toUpperCase(Locale.getDefault())
                        )
                )
        );
    }
 
    private Control createThermostat() {
        return createStatefulControl(
                THERMOSTAT_ID,
                THERMOSTAT_TITLE,
                THERMOSTAT_TYPE,
                rangeState,
                new RangeTemplate(
                        THERMOSTAT_ID + "",
                        15f,
                        25f,
                        rangeState,
                        0.1f,
                        "%1.1f"
                )
        );
    }
 
    private  Control createStatefulControl(int id, String title, int type, T state, ControlTemplate template) {
        Intent intent = new Intent(this, MainActivity.class)
                .putExtra(EXTRA_MESSAGE, "$title $state")
                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        PendingIntent action = PendingIntent.getActivity(
                this,
                id,
                intent,
                PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
        );
 
        return new Control.StatefulBuilder(id + "", action)
                .setTitle(title)
                .setDeviceType(type)
                .setStatus(Control.STATUS_OK)
                .setControlTemplate(template)
                .build();
    }

इस उदाहरण में, createPublisherFor() तरीके में आपके ऐप्लिकेशन के लिए ज़रूरी काम को गलत तरीके से लागू किया गया है: डिवाइस की स्थिति जानने के लिए उससे संपर्क करना और उस स्थिति को सिस्टम को भेजना.

createPublisherFor() तरीका, Kotlin कोरूटीन का इस्तेमाल करता है और फ़्लो की मदद से ऐसा किया जाता है ज़रूरी Reactive Streams API को हटाने के लिए ये काम करें:

यह Flow बनाता है.
एक सेकंड इंतज़ार करता है.
स्मार्ट लाइट की स्थिति बनाता और उसे दिखाता है.
थोड़ी देर और इंतज़ार करें.
थर्मोस्टैट की स्थिति बनाता और उसे भेजता है.

कार्रवाइयां मैनेज करना

जब उपयोगकर्ता, किसी डिवाइस से इंटरैक्ट करता है, तो performControlAction() तरीका पब्लिश करने के लिए कंट्रोल. भेजे गए ControlAction के टाइप से कार्रवाई तय होती है. दिए गए कंट्रोल के लिए सही कार्रवाई करें. इसके बाद, Android यूज़र इंटरफ़ेस (यूआई) में डिवाइस की स्थिति अपडेट करें.

उदाहरण को पूरा करने के लिए, अपने Service में यह जोड़ें:

Kotlin

    override fun performControlAction(
        controlId: String,
        action: ControlAction,
        consumer: Consumer
    ) {
        controlFlows[controlId]?.let { flow ->
            when (controlId) {
                LIGHT_ID.toString() -> {
                    consumer.accept(ControlAction.RESPONSE_OK)
                    if (action is BooleanAction) toggleState = action.newState
                    flow.tryEmit(createLight())
                }
                THERMOSTAT_ID.toString() -> {
                    consumer.accept(ControlAction.RESPONSE_OK)
                    if (action is FloatAction) rangeState = action.newValue
                    flow.tryEmit(createThermostat())
                }
                else -> consumer.accept(ControlAction.RESPONSE_FAIL)
            }
        } ?: consumer.accept(ControlAction.RESPONSE_FAIL)
    }

Java

    @Override
    public void performControlAction(@NonNull String controlId, @NonNull ControlAction action, @NonNull Consumer consumer) {
        ReplayProcessor processor = controlFlows.get(controlId);
        if (processor == null) return;
 
        if (controlId.equals(LIGHT_ID + "")) {
            consumer.accept(ControlAction.RESPONSE_OK);
            if (action instanceof BooleanAction) toggleState = ((BooleanAction) action).getNewState();
            processor.onNext(createLight());
        }
        if (controlId.equals(THERMOSTAT_ID + "")) {
            consumer.accept(ControlAction.RESPONSE_OK);
            if (action instanceof FloatAction) rangeState = ((FloatAction) action).getNewValue()
            processor.onNext(createThermostat());
        }
    }

ऐप्लिकेशन चलाएं, डिवाइस कंट्रोल मेन्यू को ऐक्सेस करें, और अपनी रोशनी और थर्मोस्टैट के कंट्रोल.

लाइट और थर्मोस्टैट को कंट्रोल करने वाली इमेज — **छठी इमेज.** लाइट और थर्मोस्टैट कंट्रोल.