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

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

इसी विषय से जुड़े इन संसाधनों को देखें:

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

  • मोशन सेंसर

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

  • पर्यावरण सेंसर

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

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

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

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

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

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

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

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

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

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

सेंसर टाइप ब्यौरा सामान्य इस्तेमाल
TYPE_ACCELEROMETER हार्डवेयर यह सेंसर, डिवाइस पर लगने वाले ऐक्सलरेशन फ़ोर्स को m/s2 में मापता है. यह फ़ोर्स, डिवाइस के तीनों फ़िज़िकल ऐक्सिस (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 सॉफ़्टवेयर या हार्डवेयर यह m/s2 में ऐक्सलरेशन फ़ोर्स को मेज़र करता है. यह फ़ोर्स, डिवाइस पर तीनों फ़िज़िकल ऐक्सिस (x, y, और z) पर लगाया जाता है. इसमें गुरुत्वाकर्षण (ग्रैविटी) के फ़ोर्स को शामिल नहीं किया जाता. किसी एक ऐक्सिस पर ऐक्सलरेशन को मॉनिटर करना.
TYPE_MAGNETIC_FIELD हार्डवेयर यह सेंसर, तीनों फ़िज़िकल ऐक्सिस (x, y, z) के लिए, आस-पास के जियोमैग्नेटिक फ़ील्ड को μT में मापता है. कंपास बनाया जा रहा है.
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) में कई सेंसर जोड़े गए थे. दो सेंसर बंद कर दिए गए हैं. इनकी जगह नए और बेहतर सेंसर उपलब्ध कराए गए हैं.

दूसरी टेबल में, हर प्लैटफ़ॉर्म पर सेंसर की उपलब्धता के बारे में खास जानकारी दी गई है. सिर्फ़ चार प्लैटफ़ॉर्म की सूची दी गई है, क्योंकि सेंसर में बदलाव सिर्फ़ इन प्लैटफ़ॉर्म पर किए गए थे. जिन सेंसर को बंद कर दिया गया है वे अब भी बाद के प्लैटफ़ॉर्म पर उपलब्ध हैं. हालांकि, इसके लिए ज़रूरी है कि डिवाइस में सेंसर मौजूद हो. यह 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 Yes2 Yes2 Yes2 हां
TYPE_PRESSURE हां हां लागू नहीं1 लागू नहीं1
TYPE_PROXIMITY हां हां हां हां
TYPE_RELATIVE_HUMIDITY हां लागू नहीं लागू नहीं लागू नहीं
TYPE_ROTATION_VECTOR हां हां लागू नहीं लागू नहीं
TYPE_TEMPERATURE Yes2 हां हां हां

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 (API लेवल 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 में दिखाया गया है. 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);
    }
}

इस उदाहरण में, SENSOR_DELAY_NORMAL तरीके को लागू करते समय, डेटा के डिफ़ॉल्ट डिले (SENSOR_DELAY_NORMAL) के बारे में बताया गया है.registerListener() डेटा में देरी (या सैंपलिंग रेट) से यह कंट्रोल किया जाता है कि सेंसर इवेंट, आपके ऐप्लिकेशन को किस इंटरवल पर भेजे जाएं. ये इवेंट, 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 वैल्यू नेगेटिव होती है. इस कोऑर्डिनेट सिस्टम का इस्तेमाल इन सेंसर के लिए किया जाता है:

पहली इमेज. यह डिवाइस के हिसाब से कोऑर्डिनेट सिस्टम होता है. इसका इस्तेमाल Sensor API करता है.

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

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

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

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

सेंसर के लिए दर सीमित करने की सुविधा

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

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

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

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

AndroidManifest.xml

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

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

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

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

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

  • लगातार रिपोर्टिंग मोड का इस्तेमाल करने वाले सेंसर, जैसे कि ऐक्सलररोमीटर और जाइरोस्कोप को इवेंट नहीं मिलते.
  • on-change या one-shot रिपोर्टिंग मोड का इस्तेमाल करने वाले सेंसर को इवेंट नहीं मिलते.

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

सेंसर लिसनर का रजिस्ट्रेशन रद्द करना

सेंसर का इस्तेमाल पूरा होने या सेंसर की गतिविधि रुकने पर, सेंसर के लिसनर को अनरजिस्टर करना न भूलें. अगर कोई सेंसर लिसनर रजिस्टर किया गया है और उसकी गतिविधि रोक दी गई है, तो सेंसर डेटा इकट्ठा करता रहेगा और बैटरी के संसाधनों का इस्तेमाल करता रहेगा. ऐसा तब तक होगा, जब तक सेंसर को अनरजिस्टर नहीं किया जाता. यहां दिए गए कोड में, किसी लिसनर को अनरजिस्टर करने के लिए 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 Emulator की मदद से टेस्ट करना

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

इमुलेटर, Android डिवाइस से कनेक्ट होता है. इस डिवाइस पर SdkControllerSensor ऐप्लिकेशन चल रहा होता है. ध्यान दें कि यह ऐप्लिकेशन सिर्फ़ Android 4.0 (एपीआई लेवल 14) या इसके बाद के वर्शन वाले डिवाइसों पर उपलब्ध है. (अगर डिवाइस Android 4.0 पर काम कर रहा है, तो उसमें Revision 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 Emulator गाइड देखें.

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

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

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

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

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

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

सेंसर के डेटा को अपडेट होने में लगने वाले समय को ध्यान से चुनें

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

आगे बढ़ें
मोशन सेंसर