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

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

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

• मोशन सेंसर

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

• एनवायरमेंटल सेंसर

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

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

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

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

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

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

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

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

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

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

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

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 1.5 (एपीआई लेवल 3) में जोड़ा गया था, लेकिन यह Android 2.3 (एपीआई लेवल 9) तक इस्तेमाल के लिए उपलब्ध नहीं था.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

हर विकल्प के बारे में यहां बताया गया है.

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

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

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

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

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

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

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

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

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

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 Emulator की मदद से टेस्ट करना

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

एम्युलेटर, 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 कमांड चलाएं:

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