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

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 सॉफ़्टवेयर या हार्डवेयर रफ़्तार की दर को 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) में मापा जाता है. यह सेंसर हर डिवाइस पर अलग-अलग तरह से लागू होता है इस सेंसर को 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) में कई सेंसर लॉन्च किए गए. दो सेंसर बंद कर दिए गए हैं. उनकी जगह नए और बेहतर सेंसर लगा दिए गए हैं.

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

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

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

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

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

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

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 Emulator में वर्चुअल सेंसर कंट्रोल का एक सेट होता है, जो सेंसर की जांच की जा सकती है, जैसे कि एक्सलरोमीटर, आस-पास का तापमान, मैग्नेटोमीटर, निकटता, रोशनी वगैरह.

एम्युलेटर, ऐसे Android डिवाइस के कनेक्शन का इस्तेमाल करता है जिस पर SdkControllerSensor है. ध्यान दें कि यह ऐप्लिकेशन सिर्फ़ 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 सेंसर टाइप को बंद कर दिया गया है. आपको Google Ads API का इस्तेमाल करना चाहिए इसके बजाय, डिवाइसों पर TYPE_AMBIENT_TEMPERATURE सेंसर टाइप जो Android 4.0 पर चल रहे हैं.

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

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

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

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

आगे बढ़ें
Motion sensors