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

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

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

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

  • मोशन सेंसर

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

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

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

  • जगह की जानकारी देने वाले सेंसर

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

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

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

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

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

Android सेंसर फ़्रेमवर्क की मदद से, कई तरह के सेंसर ऐक्सेस किए जा सकते हैं. इनमें से कुछ सेंसर, हार्डवेयर पर आधारित होते हैं और कुछ सॉफ़्टवेयर पर. हार्डवेयर पर आधारित सेंसर, हैंडसेट या टैबलेट डिवाइस में बने फ़िज़िकल कॉम्पोनेंट होते हैं. वे अपना डेटा सीधे पर्यावरण से जुड़े खास गुणों, जैसे कि त्वरण, जियोमैग्नेटिक फ़ील्ड की ताकत या कोणीय बदलाव को मापकर हासिल करते हैं. सॉफ़्टवेयर पर आधारित सेंसर, फ़िज़िकल डिवाइस नहीं होते. हालांकि, ये हार्डवेयर पर आधारित सेंसर की नकल करते हैं. सॉफ़्टवेयर पर आधारित सेंसर, एक या एक से ज़्यादा हार्डवेयर पर आधारित सेंसर से डेटा हासिल करते हैं. इन्हें कभी-कभी वर्चुअल सेंसर या सिंथेटिक सेंसर भी कहा जाता है. लीनियर ऐक्सेलरेशन सेंसर और गुरुत्वाकर्षण सेंसर, सॉफ़्टवेयर पर आधारित सेंसर के उदाहरण हैं. पहली टेबल में उन सेंसर की खास जानकारी दी गई है जो 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) के आस-पास रैड/s में रोटेशन की दर क्या है. रोटेशन का पता लगाना (घूमना, मुड़ना वगैरह).
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 की, आने वाले समय में काम करने की नीति के मुताबिक है.

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

सेंसर 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
    
  7. एम्युलेटर शुरू करें. अब अपने डिवाइस को एम्युलेटर पर ले जाकर, उसमें बदलाव किए जा सकेंगे.

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

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

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

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

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

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

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

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

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

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