सेंसर की खास जानकारी

Android वाले ज़्यादातर डिवाइसों में पहले से सेंसर मौजूद होते हैं. ये सेंसर, मोशन, ओरिएंटेशन, और आस-पास के माहौल की अलग-अलग स्थितियों का पता लगाते हैं. ये सेंसर, सटीक और बेहतर रॉ डेटा उपलब्ध कराते हैं. ये तब काम के होते हैं, जब आपको डिवाइस की तीन-आयामी गति या पोज़िशनिंग को मॉनिटर करना हो या किसी डिवाइस के आस-पास के वातावरण में होने वाले बदलावों को मॉनिटर करना हो. उदाहरण के लिए, कोई गेम डिवाइस के गुरुत्वाकर्षण सेंसर से मिली रीडिंग को ट्रैक कर सकता है. इससे, उपयोगकर्ता के जटिल जेस्चर और मोशन का पता चलता है. जैसे, झुकना, हिलना, घुमाना या स्विंग करना. इसी तरह, मौसम की जानकारी देने वाला ऐप्लिकेशन, डिवाइस के तापमान सेंसर और नमी सेंसर का इस्तेमाल करके, डेउपॉइंट का हिसाब लगा सकता है और उसकी जानकारी दे सकता है. इसके अलावा, यात्रा से जुड़ा ऐप्लिकेशन, कम्पास के दिशा-सूचक की जानकारी देने के लिए, जियोमैग्नेटिक फ़ील्ड सेंसर और एक्सलरोमीटर का इस्तेमाल कर सकता है.

इस बारे में ज़्यादा जानने के लिए, यहां दिए गए लेख पढ़ें:

Android प्लैटफ़ॉर्म, सेंसर की तीन मुख्य कैटगरी के साथ काम करता है:

  • मोशन सेंसर

    ये सेंसर, तीन अक्षों के साथ-साथ, त्वरण और घुमाव की ताकतों को मेज़र करते हैं. इस कैटगरी में, एक्सलरोमीटर, गुरुत्वाकर्षण सेंसर, जाइरोस्कोप, और रोटेशनल वेक्टर सेंसर शामिल हैं.

  • पर्यावरण से जुड़े सेंसर

    ये सेंसर, आस-पास के वातावरण के अलग-अलग पैरामीटर को मेज़र करते हैं. जैसे, आस-पास के वातावरण का तापमान और दबाव, रोशनी, और नमी. इस कैटगरी में बैरोमीटर, फ़ोटोमीटर, और थर्मामीटर शामिल हैं.

  • पोज़िशन सेंसर

    ये सेंसर, किसी डिवाइस की जगह की जानकारी का पता लगाते हैं. इस कैटगरी में, ऑरिएंटेशन सेंसर और मैग्नेटोमीटर शामिल हैं.

Android सेंसर फ़्रेमवर्क का इस्तेमाल करके, डिवाइस पर मौजूद सेंसर ऐक्सेस किए जा सकते हैं. साथ ही, सेंसर का रॉ डेटा भी हासिल किया जा सकता है. सेंसर फ़्रेमवर्क में कई क्लास और इंटरफ़ेस होते हैं. इनकी मदद से, सेंसर से जुड़े कई तरह के काम किए जा सकते हैं. उदाहरण के लिए, सेंसर फ़्रेमवर्क का इस्तेमाल करके ये काम किए जा सकते हैं:

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

इस विषय में, Android प्लैटफ़ॉर्म पर उपलब्ध सेंसर के बारे में खास जानकारी दी गई है. इसमें सेंसर फ़्रेमवर्क के बारे में भी जानकारी दी गई है.

सेंसर के बारे में जानकारी

Android सेंसर फ़्रेमवर्क की मदद से, कई तरह के सेंसर ऐक्सेस किए जा सकते हैं. इनमें से कुछ सेंसर, हार्डवेयर पर आधारित होते हैं और कुछ सॉफ़्टवेयर पर. हार्डवेयर पर आधारित सेंसर, हैंडसेट या टैबलेट डिवाइस में बने फ़िज़िकल कॉम्पोनेंट होते हैं. ये सीधे तौर पर, पर्यावरण की खास विशेषताओं को मेज़र करके अपना डेटा इकट्ठा करते हैं. जैसे, त्वरण, भू-चुंबकीय क्षेत्र की तीव्रता या कोण में बदलाव. सॉफ़्टवेयर पर आधारित सेंसर, फ़िज़िकल डिवाइस नहीं होते. हालांकि, ये हार्डवेयर पर आधारित सेंसर की नकल करते हैं. सॉफ़्टवेयर पर आधारित सेंसर, एक या एक से ज़्यादा हार्डवेयर पर आधारित सेंसर से डेटा हासिल करते हैं. इन्हें कभी-कभी वर्चुअल सेंसर या सिंथेटिक सेंसर भी कहा जाता है. लीनियर ऐक्सेलरेशन सेंसर और गुरुत्वाकर्षण सेंसर, सॉफ़्टवेयर पर आधारित सेंसर के उदाहरण हैं. टेबल 1 में उन सेंसर के बारे में खास जानकारी दी गई है जो Android प्लैटफ़ॉर्म के साथ काम करते हैं.

Android वाले कुछ डिवाइसों में हर तरह का सेंसर नहीं होता. उदाहरण के लिए, ज़्यादातर हैंडसेट डिवाइसों और टैबलेट में एक्सलरोमीटर और मैग्नेटोमीटर होता है. हालांकि, कुछ ही डिवाइसों में बैरोमीटर या थर्मामीटर होता है. साथ ही, किसी डिवाइस में एक ही तरह के एक से ज़्यादा सेंसर हो सकते हैं. उदाहरण के लिए, किसी डिवाइस में दो गुरुत्वाकर्षण सेंसर हो सकते हैं. इनमें से हर सेंसर की रेंज अलग-अलग हो सकती है.

टेबल 1. Android प्लैटफ़ॉर्म पर काम करने वाले सेंसर टाइप.

सेंसर टाइप ब्यौरा इस्तेमाल के सामान्य उदाहरण
TYPE_ACCELEROMETER हार्डवेयर यह ऐक्सेलरेशन फ़ोर्स को मीटर/सेकंड2 में मेज़र करता है. यह फ़ोर्स, डिवाइस के तीनों फ़िज़िकल ऐक्सिस (x, y, और z) पर लागू होता है. इसमें गुरुत्वाकर्षण का फ़ोर्स भी शामिल है. मोशन डिटेक्शन (झटका, झुकाव वगैरह).
TYPE_AMBIENT_TEMPERATURE हार्डवेयर कमरे के तापमान को डिग्री सेल्सियस (°C) में मेज़र करता है. नीचे दिया गया नोट देखें. हवा के तापमान को मॉनिटर करना.
TYPE_GRAVITY सॉफ़्टवेयर या हार्डवेयर यह m/s2 में गुरुत्वाकर्षण के उस बल को मेज़र करता है जो डिवाइस पर तीनों फ़िज़िकल ऐक्सिस (x, y, z) पर लागू होता है. मोशन डिटेक्शन (झटका, झुकाव वगैरह).
TYPE_GYROSCOPE हार्डवेयर यह किसी डिवाइस के घूमने की दर को रेडियन/सेकंड में मेज़र करता है. यह दर, तीनों फ़िज़िकल ऐक्सिस (x, y, और z) के आस-पास होती है. रोटेशन का पता लगाना (घूमना, मुड़ना वगैरह).
TYPE_LIGHT हार्डवेयर यह आस-पास की रोशनी के लेवल (रोशनी) को lx में मेज़र करता है. स्क्रीन की चमक को कंट्रोल करना.
TYPE_LINEAR_ACCELERATION सॉफ़्टवेयर या हार्डवेयर यह ऐक्सेलरेशन फ़ोर्स को मीटर/सेकंड2 में मेज़र करता है. यह फ़ोर्स, डिवाइस के तीनों फ़िज़िकल ऐक्सिस (x, y, और z) पर लागू होता है. इसमें गुरुत्वाकर्षण का फ़ोर्स शामिल नहीं होता. किसी एक अक्ष के साथ त्वरण को मॉनिटर करना.
TYPE_MAGNETIC_FIELD हार्डवेयर यह तीनों फ़िज़िकल ऐक्सिस (x, y, z) के लिए, ambient geomagnetic field को मापता है. यह माप, 'माइक्रोटेस्ला' में होती है. कंपास बनाना.
TYPE_ORIENTATION सॉफ़्टवेयर यह डिवाइस के तीनों फ़िज़िकल ऐक्सिस (x, y, z) के आस-पास होने वाले रोटेशन की डिग्री को मेज़र करता है. एपीआई लेवल 3 के ज़रिए, किसी डिवाइस के लिए इनक्लाइनेशन मैट्रिक और रोटेशन मैट्रिक हासिल की जा सकती है. इसके लिए, गुरुत्वाकर्षण सेंसर और जियोमैग्नेटिक फ़ील्ड सेंसर का इस्तेमाल करना होगा. साथ ही, getRotationMatrix() तरीके का इस्तेमाल करना होगा. डिवाइस की जगह की जानकारी तय करना.
TYPE_PRESSURE हार्डवेयर यह एंबियंट एयर प्रेशर को hPa या mbar में मेज़र करता है. हवा के दबाव में होने वाले बदलावों पर नज़र रखना.
TYPE_PROXIMITY हार्डवेयर किसी डिवाइस की व्यू स्क्रीन के हिसाब से, किसी ऑब्जेक्ट की निकटता को सेंटीमीटर में मेज़र करता है. आम तौर पर, इस सेंसर का इस्तेमाल यह पता लगाने के लिए किया जाता है कि हैंडसेट को किसी व्यक्ति के कान के पास रखा गया है या नहीं. कॉल के दौरान फ़ोन की पोज़िशन.
TYPE_RELATIVE_HUMIDITY हार्डवेयर यह रिलेटिव एंबियंट ह्यूमिडिटी को प्रतिशत (%) में मेज़र करता है. डेउपॉइंट, कुल, और सापेक्ष आर्द्रता को मॉनिटर करना.
TYPE_ROTATION_VECTOR सॉफ़्टवेयर या हार्डवेयर डिवाइस के रोटेशन वेक्टर के तीन एलिमेंट उपलब्ध कराकर, डिवाइस के ओरिएंटेशन का आकलन करता है. मोशन और घुमाव की पहचान करने की सुविधा.
TYPE_TEMPERATURE हार्डवेयर डिवाइस के तापमान को डिग्री सेल्सियस (°C) में मापता है. इस सेंसर को लागू करने का तरीका, हर डिवाइस के हिसाब से अलग-अलग होता है. साथ ही, एपीआई लेवल 14 में इस सेंसर को TYPE_AMBIENT_TEMPERATURE सेंसर से बदल दिया गया था तापमान की निगरानी करना.

सेंसर फ़्रेमवर्क

Android सेंसर फ़्रेमवर्क का इस्तेमाल करके, इन सेंसर को ऐक्सेस किया जा सकता है और सेंसर का रॉ डेटा हासिल किया जा सकता है. सेंसर फ़्रेमवर्क, android.hardware पैकेज का हिस्सा है. इसमें ये क्लास और इंटरफ़ेस शामिल हैं:

SensorManager
सेंसर सेवा का इंस्टेंस बनाने के लिए, इस क्लास का इस्तेमाल किया जा सकता है. इस क्लास में, सेंसर को ऐक्सेस करने और उनकी सूची बनाने, सेंसर इवेंट के लिसनर को रजिस्टर करने और उनका रजिस्ट्रेशन रद्द करने, और ओरिएंटेशन की जानकारी पाने के कई तरीके दिए गए हैं. यह क्लास कई सेंसर कॉन्स्टेंट भी उपलब्ध कराती है, जिनका इस्तेमाल सेंसर की सटीक जानकारी देने, डेटा हासिल करने की दर सेट करने, और सेंसर को कैलिब्रेट करने के लिए किया जाता है.
Sensor
किसी खास सेंसर का इंस्टेंस बनाने के लिए, इस क्लास का इस्तेमाल किया जा सकता है. इस क्लास में कई तरह के तरीकों की जानकारी दी गई है. इनकी मदद से, किसी सेंसर की क्षमताओं का पता लगाया जा सकता है.
SensorEvent
सिस्टम इस क्लास का इस्तेमाल करके, सेंसर इवेंट ऑब्जेक्ट बनाता है. इससे सेंसर इवेंट के बारे में जानकारी मिलती है. सेंसर इवेंट ऑब्जेक्ट में यह जानकारी शामिल होती है: सेंसर का रॉ डेटा, इवेंट जनरेट करने वाले सेंसर का टाइप, डेटा की सटीक जानकारी, और इवेंट का टाइमस्टैंप.
SensorEventListener
इस इंटरफ़ेस का इस्तेमाल करके, दो कॉलबैक तरीके बनाए जा सकते हैं. इनसे सेंसर की वैल्यू बदलने या सेंसर की सटीक जानकारी में बदलाव होने पर, सूचनाएं (सेंसर इवेंट) मिलती हैं.

किसी सामान्य ऐप्लिकेशन में, सेंसर से जुड़े इन एपीआई का इस्तेमाल दो बुनियादी कामों के लिए किया जाता है:

  • सेंसर और सेंसर की क्षमताओं की पहचान करना

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

  • सेंसर इवेंट को मॉनिटर करना

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

सेंसर की उपलब्धता

सेंसर की उपलब्धता, डिवाइस के हिसाब से अलग-अलग होती है. साथ ही, यह Android वर्शन के हिसाब से भी अलग-अलग हो सकती है. ऐसा इसलिए है, क्योंकि Android सेंसर को प्लैटफ़ॉर्म के कई रिलीज़ के दौरान लॉन्च किया गया है. उदाहरण के लिए, Android 1.5 (एपीआई लेवल 3) में कई सेंसर पेश किए गए थे, लेकिन कुछ को लागू नहीं किया गया था. साथ ही, ये Android 2.3 (एपीआई लेवल 9) तक इस्तेमाल के लिए उपलब्ध नहीं थे. इसी तरह, Android 2.3 (एपीआई लेवल 9) और Android 4.0 (एपीआई लेवल 14) में कई सेंसर जोड़े गए थे. दो सेंसर बंद कर दिए गए हैं और उनकी जगह नए और बेहतर सेंसर लगाए गए हैं.

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

टेबल 2. प्लैटफ़ॉर्म के हिसाब से सेंसर की उपलब्धता.

सेंसर Android 4.0
(एपीआई लेवल 14)		 Android 2.3
(एपीआई लेवल 9)		 Android 2.2
(एपीआई लेवल 8)		 Android 1.5
(एपीआई लेवल 3)
TYPE_ACCELEROMETER हां हां हां हां
TYPE_AMBIENT_TEMPERATURE हां लागू नहीं लागू नहीं लागू नहीं
TYPE_GRAVITY हां हां लागू नहीं लागू नहीं
TYPE_GYROSCOPE हां हां लागू नहीं1 लागू नहीं1
TYPE_LIGHT हां हां हां हां
TYPE_LINEAR_ACCELERATION हां हां लागू नहीं लागू नहीं
TYPE_MAGNETIC_FIELD हां हां हां हां
TYPE_ORIENTATION हां2 हां2 हां2 हां
TYPE_PRESSURE हां हां लागू नहीं1 लागू नहीं1
TYPE_PROXIMITY हां हां हां हां
TYPE_RELATIVE_HUMIDITY हां लागू नहीं लागू नहीं लागू नहीं
TYPE_ROTATION_VECTOR हां हां लागू नहीं लागू नहीं
TYPE_TEMPERATURE हां2 हां हां हां

1 इस तरह का सेंसर, Android 1.5 (एपीआई लेवल 3) में जोड़ा गया था. हालांकि, यह Android 2.3 (एपीआई लेवल 9) तक इस्तेमाल के लिए उपलब्ध नहीं था.

2 यह सेंसर उपलब्ध है, लेकिन इसे बंद कर दिया गया है.

सेंसर और सेंसर की क्षमताओं की पहचान करना

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

किसी डिवाइस पर मौजूद सेंसर की पहचान करने के लिए, आपको सबसे पहले सेंसर सेवा का रेफ़रंस पाना होगा. इसके लिए, getSystemService() मेथड को कॉल करके और SENSOR_SERVICE आर्ग्युमेंट को पास करके, SensorManager क्लास का इंस्टेंस बनाया जाता है. उदाहरण के लिए:

Kotlin

private lateinit var sensorManager: SensorManager
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager

Java

private SensorManager sensorManager;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);

इसके बाद, getSensorList() तरीके को कॉल करके और TYPE_ALL कॉन्स्टेंट का इस्तेमाल करके, किसी डिवाइस पर मौजूद हर सेंसर की लिस्टिंग देखी जा सकती है. उदाहरण के लिए:

Kotlin

val deviceSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_ALL)

Java

List<Sensor> deviceSensors = sensorManager.getSensorList(Sensor.TYPE_ALL);

अगर आपको किसी खास टाइप के सभी सेंसर की सूची बनानी है, तो TYPE_ALL के बजाय किसी दूसरे कॉन्स्टेंट का इस्तेमाल किया जा सकता है. जैसे, TYPE_GYROSCOPE, TYPE_LINEAR_ACCELERATION या TYPE_GRAVITY.

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

Kotlin

private lateinit var sensorManager: SensorManager
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
if (sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null) {
    // Success! There's a magnetometer.
} else {
    // Failure! No magnetometer.
}

Java

private SensorManager sensorManager;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
if (sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null){
    // Success! There's a magnetometer.
} else {
    // Failure! No magnetometer.
}

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

किसी डिवाइस पर मौजूद सेंसर की सूची बनाने के अलावा, Sensor क्लास के पब्लिक तरीकों का इस्तेमाल करके, अलग-अलग सेंसर की क्षमताओं और एट्रिब्यूट का पता लगाया जा सकता है. यह सुविधा तब काम की होती है, जब आपको अपने ऐप्लिकेशन को किसी डिवाइस पर उपलब्ध सेंसर या सेंसर की सुविधाओं के आधार पर अलग-अलग तरीके से काम करने के लिए सेट करना हो. उदाहरण के लिए, सेंसर का रिज़ॉल्यूशन और मेज़रमेंट की ज़्यादा से ज़्यादा रेंज पाने के लिए, getResolution() और getMaximumRange() तरीकों का इस्तेमाल किया जा सकता है. सेंसर की बिजली की ज़रूरतों के बारे में जानने के लिए, getPower() तरीके का भी इस्तेमाल किया जा सकता है.

अगर आपको अपने ऐप्लिकेशन को मैन्युफ़ैक्चरर के अलग-अलग सेंसर या सेंसर के अलग-अलग वर्शन के लिए ऑप्टिमाइज़ करना है, तो सार्वजनिक तौर पर उपलब्ध दो तरीके खास तौर पर काम के हैं. उदाहरण के लिए, अगर आपके ऐप्लिकेशन को उपयोगकर्ता के झुकने और हिलने जैसे जेस्चर को मॉनिटर करना है, तो आपके पास डेटा फ़िल्टर करने के नियमों और ऑप्टिमाइज़ेशन का एक सेट बनाने का विकल्प है. यह सेट, उन नए डिवाइसों के लिए बनाया जा सकता है जिनमें किसी वेंडर का गुरुत्वाकर्षण सेंसर है. साथ ही, डेटा फ़िल्टर करने के नियमों और ऑप्टिमाइज़ेशन का एक और सेट, उन डिवाइसों के लिए बनाया जा सकता है जिनमें गुरुत्वाकर्षण सेंसर नहीं है और सिर्फ़ ऐक्सीलेरोमीटर है. नीचे दिए गए कोड सैंपल में बताया गया है कि ऐसा करने के लिए, getVendor() और getVersion() तरीकों का इस्तेमाल कैसे किया जा सकता है. इस सैंपल में, हम ऐसा गुरुत्वाकर्षण सेंसर खोज रहे हैं जिसका वेंडर Google LLC है और उसका वर्शन नंबर 3 है. अगर डिवाइस में वह सेंसर मौजूद नहीं है, तो हम ऐक्सेलेरोमीटर का इस्तेमाल करने की कोशिश करते हैं.

Kotlin

private lateinit var sensorManager: SensorManager
private var mSensor: Sensor? = null

...

sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager

if (sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY) != null) {
    val gravSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_GRAVITY)
    // Use the version 3 gravity sensor.
    mSensor = gravSensors.firstOrNull { it.vendor.contains("Google LLC") && it.version == 3 }
}
if (mSensor == null) {
    // Use the accelerometer.
    mSensor = if (sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null) {
        sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
    } else {
        // Sorry, there are no accelerometers on your device.
        // You can't play this game.
        null
    }
}

Java

private SensorManager sensorManager;
private Sensor mSensor;

...

sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
mSensor = null;

if (sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY) != null){
    List<Sensor> gravSensors = sensorManager.getSensorList(Sensor.TYPE_GRAVITY);
    for(int i=0; i<gravSensors.size(); i++) {
        if ((gravSensors.get(i).getVendor().contains("Google LLC")) &&
           (gravSensors.get(i).getVersion() == 3)){
            // Use the version 3 gravity sensor.
            mSensor = gravSensors.get(i);
        }
    }
}
if (mSensor == null){
    // Use the accelerometer.
    if (sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null){
        mSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
    } else{
        // Sorry, there are no accelerometers on your device.
        // You can't play this game.
    }
}

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

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

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

सेंसर इवेंट पर नज़र रखना

सेंसर के रॉ डेटा को मॉनिटर करने के लिए, आपको दो कॉलबैक तरीके लागू करने होंगे. ये तरीके SensorEventListener इंटरफ़ेस के ज़रिए दिखाए जाते हैं: onAccuracyChanged() और onSensorChanged(). Android सिस्टम इन तरीकों को तब कॉल करता है, जब:

  • सेंसर की सटीक जानकारी में बदलाव होता है.

    इस मामले में, सिस्टम onAccuracyChanged() तरीके को शुरू करता है. इससे आपको बदले गए Sensor ऑब्जेक्ट और सेंसर की नई सटीक जानकारी का रेफ़रंस मिलता है. सटीक होने की जानकारी, स्टेटस के इन चार कॉन्स्टेंट में से किसी एक से दी जाती है: SENSOR_STATUS_ACCURACY_LOW, SENSOR_STATUS_ACCURACY_MEDIUM, SENSOR_STATUS_ACCURACY_HIGH या SENSOR_STATUS_UNRELIABLE.

  • सेंसर से कोई नई वैल्यू मिलती है.

    इस मामले में, सिस्टम onSensorChanged() तरीके को शुरू करता है और आपको SensorEvent ऑब्जेक्ट उपलब्ध कराता है. SensorEvent ऑब्जेक्ट में, सेंसर के नए डेटा की जानकारी होती है. इसमें ये चीज़ें शामिल हैं: डेटा की सटीक जानकारी, डेटा जनरेट करने वाला सेंसर, डेटा जनरेट होने का टाइमस्टैंप, और सेंसर से रिकॉर्ड किया गया नया डेटा.

यहां दिए गए कोड में, लाइट सेंसर से मिले डेटा को मॉनिटर करने के लिए, onSensorChanged() तरीके का इस्तेमाल करने का तरीका बताया गया है. इस उदाहरण में, सेंसर का रॉ डेटा TextView में दिखाया गया है. इसे main.xml फ़ाइल में sensor_data के तौर पर तय किया गया है.

Kotlin

class SensorActivity : Activity(), SensorEventListener {
    private lateinit var sensorManager: SensorManager
    private var mLight: Sensor? = null

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)

        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        mLight = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)
    }

    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
        // Do something here if sensor accuracy changes.
    }

    override fun onSensorChanged(event: SensorEvent) {
        // The light sensor returns a single value.
        // Many sensors return 3 values, one for each axis.
        val lux = event.values[0]
        // Do something with this sensor value.
    }

    override fun onResume() {
        super.onResume()
        mLight?.also { light ->
            sensorManager.registerListener(this, light, SensorManager.SENSOR_DELAY_NORMAL)
        }
    }

    override fun onPause() {
        super.onPause()
        sensorManager.unregisterListener(this)
    }
}

Java

public class SensorActivity extends Activity implements SensorEventListener {
    private SensorManager sensorManager;
    private Sensor mLight;

    @Override
    public final void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        mLight = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
    }

    @Override
    public final void onAccuracyChanged(Sensor sensor, int accuracy) {
        // Do something here if sensor accuracy changes.
    }

    @Override
    public final void onSensorChanged(SensorEvent event) {
        // The light sensor returns a single value.
        // Many sensors return 3 values, one for each axis.
        float lux = event.values[0];
        // Do something with this sensor value.
    }

    @Override
    protected void onResume() {
        super.onResume();
        sensorManager.registerListener(this, mLight, SensorManager.SENSOR_DELAY_NORMAL);
    }

    @Override
    protected void onPause() {
        super.onPause();
        sensorManager.unregisterListener(this);
    }
}

इस उदाहरण में, registerListener() मेथड को लागू करने पर, डेटा में लगने वाला डिफ़ॉल्ट समय (SENSOR_DELAY_NORMAL) तय किया गया है. डेटा डिले (या सैंपलिंग रेट), उस इंटरवल को कंट्रोल करता है जिसमें onSensorChanged() कॉलबैक तरीके से, सेंसर इवेंट आपके ऐप्लिकेशन को भेजे जाते हैं. डिफ़ॉल्ट रूप से, डेटा में लगने वाला विलंब, स्क्रीन के ओरिएंटेशन में होने वाले सामान्य बदलावों को मॉनिटर करने के लिए सही होता है. इसमें 2,00,000 माइक्रोसेकंड का विलंब होता है. डेटा में होने वाली अन्य देर के बारे में भी बताया जा सकता है. जैसे, SENSOR_DELAY_GAME (20,000 माइक्रोसेकंड की देर), SENSOR_DELAY_UI (60,000 माइक्रोसेकंड की देर) या SENSOR_DELAY_FASTEST (0 माइक्रोसेकंड की देर). Android 3.0 (एपीआई लेवल 11) के बाद, देरी को माइक्रोसेकंड में एक सटीक वैल्यू के तौर पर भी बताया जा सकता है.

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

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

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

अलग-अलग सेंसर कॉन्फ़िगरेशन को मैनेज करना

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

किसी डिवाइस पर कोई सेंसर मौजूद है या नहीं, यह पक्का करने के लिए आपके पास दो विकल्प हैं:

  • रनटाइम के दौरान सेंसर का पता लगाएं और ज़रूरत के हिसाब से ऐप्लिकेशन की सुविधाओं को चालू या बंद करें.
  • खास सेंसर कॉन्फ़िगरेशन वाले डिवाइसों को टारगेट करने के लिए, Google Play के फ़िल्टर का इस्तेमाल करें.

हर विकल्प के बारे में नीचे दिए गए सेक्शन में बताया गया है.

रनटाइम के दौरान सेंसर का पता लगाना

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

Kotlin

private lateinit var sensorManager: SensorManager
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager

if (sensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE) != null) {
    // Success! There's a pressure sensor.
} else {
    // Failure! No pressure sensor.
}

Java

private SensorManager sensorManager;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
if (sensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE) != null){
    // Success! There's a pressure sensor.
} else {
    // Failure! No pressure sensor.
}

खास सेंसर कॉन्फ़िगरेशन को टारगेट करने के लिए, Google Play फ़िल्टर का इस्तेमाल करना

अगर आपको अपना ऐप्लिकेशन Google Play पर पब्लिश करना है, तो अपनी मेनिफ़ेस्ट फ़ाइल में <uses-feature> एलिमेंट का इस्तेमाल करें. इससे, आपके ऐप्लिकेशन को उन डिवाइसों से फ़िल्टर किया जा सकता है जिनमें आपके ऐप्लिकेशन के लिए सही सेंसर कॉन्फ़िगरेशन नहीं है. <uses-feature> एलिमेंट में कई हार्डवेयर डिस्क्रिप्टर होते हैं. इनकी मदद से, किसी खास सेंसर की मौजूदगी के आधार पर ऐप्लिकेशन फ़िल्टर किए जा सकते हैं. इन सेंसर की सूची बनाई जा सकती है: एक्सलरोमीटर, बैरोमीटर, कंपास (जियोमैग्नेटिक फ़ील्ड), जाइरोस्कोप, लाइट, और प्रॉक्सिमिटी. यहां मेनिफ़ेस्ट की एक ऐसी एंट्री का उदाहरण दिया गया है जो ऐसे ऐप्लिकेशन को फ़िल्टर करती है जिनमें ऐक्सीलेरोमीटर नहीं है:

<uses-feature android:name="android.hardware.sensor.accelerometer"
              android:required="true" />

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

आपको डिस्क्रिप्टर को android:required="true" पर सिर्फ़ तब सेट करना चाहिए, जब आपका ऐप्लिकेशन पूरी तरह से किसी खास सेंसर पर निर्भर हो. अगर आपका ऐप्लिकेशन किसी फ़ंक्शन के लिए सेंसर का इस्तेमाल करता है, लेकिन फिर भी सेंसर के बिना काम करता है, तो आपको सेंसर को <uses-feature> एलिमेंट में शामिल करना चाहिए. हालांकि, डिस्क्रिप्टर को android:required="false" पर सेट करें. इससे यह पक्का करने में मदद मिलती है कि डिवाइसों पर आपका ऐप्लिकेशन इंस्टॉल किया जा सके, भले ही उनमें वह सेंसर न हो. यह प्रोजेक्ट मैनेजमेंट का सबसे सही तरीका भी है. इससे आपको उन सुविधाओं पर नज़र रखने में मदद मिलती है जिनका इस्तेमाल आपके ऐप्लिकेशन में किया जाता है. ध्यान रखें कि अगर आपका ऐप्लिकेशन किसी खास सेंसर का इस्तेमाल करता है, लेकिन फिर भी सेंसर के बिना चलता है, तो आपको रनटाइम के दौरान सेंसर का पता लगाना चाहिए. साथ ही, ज़रूरत के हिसाब से ऐप्लिकेशन की सुविधाओं को बंद या चालू करना चाहिए.

सेंसर कोऑर्डिनेट सिस्टम

आम तौर पर, सेंसर फ़्रेमवर्क, डेटा वैल्यू दिखाने के लिए स्टैंडर्ड 3-ऐक्सिस कोऑर्डिनेट सिस्टम का इस्तेमाल करता है. ज़्यादातर सेंसर के लिए, डिवाइस के डिफ़ॉल्ट ओरिएंटेशन में होने पर, डिवाइस की स्क्रीन के हिसाब से निर्देशांक प्रणाली तय की जाती है (पहला चित्र देखें). जब किसी डिवाइस को उसके डिफ़ॉल्ट ओरिएंटेशन में रखा जाता है, तो X ऐक्सिस हॉरिज़ॉन्टल होता है और दाईं ओर होता है. Y ऐक्सिस वर्टिकल होता है और ऊपर होता है. साथ ही, Z ऐक्सिस स्क्रीन के सामने की ओर होता है. इस सिस्टम में, स्क्रीन के पीछे के निर्देशांकों की Z वैल्यू नेगेटिव होती है. इस निर्देशांक प्रणाली का इस्तेमाल इन सेंसर में किया जाता है:

पहली इमेज. किसी डिवाइस के हिसाब से निर्देशांक सिस्टम, जिसका इस्तेमाल सेंसर एपीआई करता है.

इस निर्देशांक प्रणाली के बारे में सबसे अहम बात यह समझना है कि डिवाइस की स्क्रीन के ओरिएंटेशन में बदलाव होने पर, अक्षों को बदला नहीं जाता. इसका मतलब है कि डिवाइस के हिलने-डुलने पर, सेंसर का निर्देशांक प्रणाली कभी नहीं बदलता. यह व्यवहार, OpenGL कोऑर्डिनेट सिस्टम के व्यवहार जैसा ही है.

एक और बात समझने वाली है कि आपके ऐप्लिकेशन को यह नहीं मानना चाहिए कि किसी डिवाइस का नैचुरल (डिफ़ॉल्ट) ओरिएंटेशन पोर्ट्रेट है. कई टैबलेट डिवाइसों के लिए, नेचुरल ओरिएंटेशन लैंडस्केप होता है. साथ ही, सेंसर कोऑर्डिनेट सिस्टम हमेशा डिवाइस के नैचुरल ओरिएंटेशन पर आधारित होता है.

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

ध्यान दें: कुछ सेंसर और तरीके, दुनिया के फ़्रेम ऑफ़ रेफ़रंस के हिसाब से काम करने वाले निर्देशांक सिस्टम का इस्तेमाल करते हैं. यह सिस्टम, डिवाइस के फ़्रेम ऑफ़ रेफ़रंस के हिसाब से काम नहीं करता. ये सेंसर और तरीके, ऐसा डेटा दिखाते हैं जो धरती के मुकाबले डिवाइस की गति या डिवाइस की पोज़िशन दिखाता है. ज़्यादा जानकारी के लिए, getOrientation() तरीका, getRotationMatrix() तरीका, ओरिएंटेशन सेंसर, और रोटेशन वेक्टर सेंसर देखें.

सेंसर की दर को सीमित करना

अगर आपका ऐप्लिकेशन Android 12 (एपीआई लेवल 31) या उसके बाद के वर्शन को टारगेट करता है, तो उपयोगकर्ताओं की संवेदनशील जानकारी को सुरक्षित रखने के लिए, सिस्टम कुछ मोशन सेंसर और पोज़िशन सेंसर से डेटा रीफ़्रेश करने की दर पर पाबंदी लगाता है. इस डेटा में, डिवाइस के एक्सलरोमीटर, जाइरोस्कोप, और जियोमैग्नेटिक फ़ील्ड सेंसर से रिकॉर्ड की गई वैल्यू शामिल होती हैं.

रीफ़्रेश रेट की सीमा इस बात पर निर्भर करती है कि सेंसर डेटा को कैसे ऐक्सेस किया जाता है:

  • अगर सेंसर इवेंट पर नज़र रखने के लिए, registerListener() तरीका इस्तेमाल किया जाता है, तो सेंसर सैंपलिंग रेट 200 हर्ट्ज़ तक सीमित होता है. यह बात registerListener() तरीके के सभी ओवरलोड किए गए वैरिएंट के लिए सही है.
  • अगर SensorDirectChannel क्लास का इस्तेमाल किया जाता है, तो सेंसर सैंपलिंग रेट RATE_NORMAL तक सीमित होता है. आम तौर पर, यह रेट 50 Hz होता है.

अगर आपके ऐप्लिकेशन को मोशन सेंसर का डेटा ज़्यादा दर से इकट्ठा करना है, तो आपको यहां दिए गए कोड स्निपेट में बताए गए तरीके से, HIGH_SAMPLING_RATE_SENSORS अनुमति का एलान करना होगा. अगर आपका ऐप्लिकेशन इस अनुमति का एलान किए बिना, गति सेंसर का डेटा ज़्यादा दर से इकट्ठा करने की कोशिश करता है, तो SecurityException गड़बड़ी दिखती है.

AndroidManifest.xml

<manifest ...>
    <uses-permission android:name="android.permission.HIGH_SAMPLING_RATE_SENSORS"/>
    <application ...>
        ...
    </application>
</manifest>

सेंसर को ऐक्सेस और इस्तेमाल करने के सबसे सही तरीके

सेंसर को लागू करते समय, इस सेक्शन में बताए गए दिशा-निर्देशों का पालन करना न भूलें. ये दिशा-निर्देश, सेंसर को ऐक्सेस करने और सेंसर डेटा हासिल करने के लिए, सेंसर फ़्रेमवर्क का इस्तेमाल करने वाले सभी लोगों के लिए सबसे सही तरीके हैं.

सिर्फ़ फ़ोरग्राउंड में सेंसर डेटा इकट्ठा करना

Android 9 (एपीआई लेवल 28) या उसके बाद के वर्शन वाले डिवाइसों पर, बैकग्राउंड में चल रहे ऐप्लिकेशन के लिए ये पाबंदियां लागू होती हैं:

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

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

सेंसर के लिसनर को अनरजिस्टर करना

सेंसर का इस्तेमाल करने के बाद या सेंसर की गतिविधि रुकने पर, सेंसर के लिसनर को रजिस्टर करना न भूलें. अगर कोई सेंसर लिसनर रजिस्टर है और उसकी गतिविधि रोक दी गई है, तो सेंसर डेटा इकट्ठा करना जारी रखेगा और बैटरी के संसाधनों का इस्तेमाल करेगा. ऐसा तब तक होगा, जब तक सेंसर को अनरजिस्टर नहीं कर दिया जाता. नीचे दिया गया कोड, किसी लिसनर को अनरजिस्टर करने के लिए onPause() तरीके का इस्तेमाल करने का तरीका दिखाता है:

Kotlin

private lateinit var sensorManager: SensorManager
...
override fun onPause() {
    super.onPause()
    sensorManager.unregisterListener(this)
}

Java

private SensorManager sensorManager;
...
@Override
protected void onPause() {
    super.onPause();
    sensorManager.unregisterListener(this);
}

ज़्यादा जानकारी के लिए, unregisterListener(SensorEventListener) देखें.

Android एम्युलेटर की मदद से टेस्ट करना

Android एमुलेटर में वर्चुअल सेंसर कंट्रोल का एक सेट शामिल होता है. इसकी मदद से, एक्सलरोमीटर, आस-पास के तापमान, मैग्नेटोमीटर, प्रॉक्सिमिटी, लाइट वगैरह जैसे सेंसर की जांच की जा सकती है.

एमुलेटर, SdkControllerSensor ऐप्लिकेशन चलाने वाले Android डिवाइस से कनेक्ट होता है. ध्यान दें कि यह ऐप्लिकेशन सिर्फ़ Android 4.0 (एपीआई लेवल 14) या इसके बाद के वर्शन वाले डिवाइसों पर उपलब्ध है. (अगर डिवाइस पर Android 4.0 वर्शन है, तो उसमें रिविज़न 2 इंस्टॉल होना चाहिए.) SdkControllerSensor ऐप्लिकेशन, डिवाइस के सेंसर में होने वाले बदलावों को मॉनिटर करता है और उन्हें एमुलेटर पर भेजता है. इसके बाद, एमुलेटर को आपके डिवाइस के सेंसर से मिली नई वैल्यू के आधार पर बदल दिया जाता है.

SdkControllerSensor ऐप्लिकेशन का सोर्स कोड यहां देखा जा सकता है:

$ your-android-sdk-directory/tools/apps/SdkController

अपने डिवाइस और एमुलेटर के बीच डेटा ट्रांसफ़र करने के लिए, यह तरीका अपनाएं:

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

  5. adb कमांड चलाएं:

    6. $ adb forward tcp:1968 tcp:1968
  6. एम्युलेटर शुरू करें. अब अपने डिवाइस को मूव करके, एमुलेटर में बदलाव लागू किए जा सकते हैं.

ध्यान दें: अगर आपके डिवाइस पर की गई हरकतें, एमुलेटर पर नहीं दिख रही हैं, तो पांचवें चरण से adb कमांड को फिर से चलाकर देखें.

ज़्यादा जानकारी के लिए, Android एमुलेटर की गाइड देखें.

onSensorChanged() तरीके को ब्लॉक न करें

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

अब काम न करने वाले तरीकों या सेंसर टाइप का इस्तेमाल न करें

कई तरीकों और कॉन्स्टेंट को बंद कर दिया गया है. खास तौर पर, TYPE_ORIENTATION सेंसर टाइप को बंद कर दिया गया है. ऑरिएंटेशन डेटा पाने के लिए, आपको इसके बजाय getOrientation() तरीके का इस्तेमाल करना चाहिए. इसी तरह, TYPE_TEMPERATURE सेंसर टाइप का इस्तेमाल बंद कर दिया गया है. Android 4.0 पर चलने वाले डिवाइसों पर, आपको TYPE_AMBIENT_TEMPERATURE सेंसर टाइप का इस्तेमाल करना चाहिए.

सेंसर का इस्तेमाल करने से पहले उनकी पुष्टि करना

किसी डिवाइस से डेटा हासिल करने से पहले, हमेशा इस बात की पुष्टि करें कि उस डिवाइस पर सेंसर मौजूद है या नहीं. अक्सर इस्तेमाल होने वाले सेंसर के मौजूद होने का मतलब यह नहीं है कि वह सेंसर मौजूद है. डिवाइस बनाने वाली कंपनियों को अपने डिवाइसों में कोई खास सेंसर देने की ज़रूरत नहीं है.

सेंसर में होने वाली देरी को ध्यान से चुनना

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

आगे बढ़ें
Motion sensors