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

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

यहां दिए गए मिलते-जुलते संसाधनों को देखें:

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

  • मोशन सेंसर

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

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

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

  • जगह बताने वाले सेंसर

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

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

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

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

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

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

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

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

सेंसर टाइप ब्यौरा सामान्य इस्तेमाल
TYPE_ACCELEROMETER हार्डवेयर किसी डिवाइस पर लगने वाले उस ऐक्सलरेशन बल को m/s2 में मापता है जिस पर गुरुत्वाकर्षण बल समेत तीनों भौतिक अक्ष (x, y, और z) . मोशन डिटेक्शन (झटका, झुकाव वगैरह).
TYPE_AMBIENT_TEMPERATURE हार्डवेयर कमरे के तापमान को डिग्री सेल्सियस (°C) में मेज़र करता है. नीचे दिया गया नोट देखें. हवा के तापमान की निगरानी करना.
TYPE_GRAVITY सॉफ़्टवेयर या हार्डवेयर यह m/s2 में गुरुत्वाकर्षण के उस बल को मेज़र करता है जो डिवाइस पर तीनों फ़िज़िकल ऐक्सिस (x, y, z) पर लागू होता है. मोशन डिटेक्शन (झटका, झुकाव वगैरह).
TYPE_GYROSCOPE हार्डवेयर तीन में से हर एक के आस-पास रेड/s में डिवाइस के रोटेशन की दर को मापता है फ़िज़िकल ऐक्सिस (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) में मेज़र करता है. यह सेंसर हर डिवाइस पर अलग-अलग तरह से लागू होता है इस सेंसर को TYPE_AMBIENT_TEMPERATURE सेंसर से बदल दिया गया है एपीआई लेवल 14 तापमान की निगरानी करना.

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

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

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

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

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

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

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

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

KotlinJava
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.
}
 
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 है. अगर डिवाइस में वह सेंसर मौजूद नहीं है, तो हम एक्सलरोमीटर.

KotlinJava
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
    }
}
 
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 के तौर पर तय किया गया है.

KotlinJava
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)
    }
}
 
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 (API) से लेवल 11), तो देरी को भी पूरी वैल्यू (माइक्रोसेकंड में) के तौर पर बताया जा सकता है.

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

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

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

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

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

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

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

इन सेक्शन में, हर विकल्प के बारे में बताया गया है.

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

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

KotlinJava
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.
}
 
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" पर सेट करें. इससे यह पक्का करने में मदद मिलती है कि डिवाइस आपके ऐप्लिकेशन को इंस्टॉल कर सकते हैं भले ही उनमें वह सेंसर न हो. यह प्रोजेक्ट मैनेजमेंट का सबसे सही तरीका भी है. इससे आपको उन सुविधाओं पर नज़र रखने में मदद मिलती है जिनका इस्तेमाल आपके ऐप्लिकेशन में किया जाता है. ध्यान रखें कि अगर आपका ऐप्लिकेशन किसी खास सेंसर का इस्तेमाल करता है, लेकिन फिर भी सेंसर के बिना चलता है, तो आपको रनटाइम के दौरान सेंसर का पता लगाना चाहिए. साथ ही, ऐप्लिकेशन की सुविधाओं को ज़रूरत के हिसाब से बंद या चालू करना चाहिए.

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

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

पहली इमेज. कोऑर्डिनेट सिस्टम (किसी डिवाइस के हिसाब से) जिसका इस्तेमाल सेंसर करता है एपीआई.

इस निर्देशांक प्रणाली के बारे में सबसे अहम बात यह समझना है कि डिवाइस की स्क्रीन के ओरिएंटेशन में बदलाव होने पर, अक्षों को बदला नहीं जाता. इसका मतलब है कि डिवाइस के हिलने-डुलने पर, सेंसर का निर्देशांक प्रणाली कभी नहीं बदलता. यह 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) या उसके बाद के वर्शन वाले डिवाइसों पर, बैकग्राउंड में ये पाबंदियां हैं:

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

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

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

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

KotlinJava
private lateinit var sensorManager: SensorManager
...
override fun onPause() {
    super.onPause()
    sensorManager.unregisterListener(this)
}
 
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. एम्युलेटर को चालू करें. अब आपको अपने डिवाइस को घुमाकर, एमुलेटर में बदलाव करने की सुविधा मिल जाएगी.

ध्यान दें: अगर आपने अपनी फ़िज़िकल डिवाइस एम्युलेटर में बदलाव नहीं कर रहा है. इसलिए, फिर से चरण 5 से adb निर्देश दिया.

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

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

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

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

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

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

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

सेंसर के दिखने का समय ध्यान से चुनें

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

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