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

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

ध्यान दें: Android 2.2 (एपीआई लेवल 8) में ओरिएंटेशन सेंसर की सुविधा बंद कर दी गई थी. साथ ही, Android 4.4W (एपीआई लेवल 20) में ओरिएंटेशन सेंसर टाइप की सुविधा बंद कर दी गई थी.

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

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

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

सेंसर सेंसर इवेंट का डेटा ब्यौरा माप की इकाइयां
TYPE_GAME_ROTATION_VECTOR SensorEvent.values[0] x-ऐक्सिस के साथ रोटेशन वेक्टर कॉम्पोनेंट (x * sin(θ/2)). बिना इकाई वाला
SensorEvent.values[1] y ऐक्सिस के साथ रोटेशन वेक्टर कॉम्पोनेंट (y * sin(θ/2)).
SensorEvent.values[2] z ऐक्सिस के साथ रोटेशन वेक्टर कॉम्पोनेंट (z * sin(θ/2)).
TYPE_GEOMAGNETIC_ROTATION_VECTOR SensorEvent.values[0] x-ऐक्सिस के साथ रोटेशन वेक्टर कॉम्पोनेंट (x * sin(θ/2)). बिना इकाई वाला
SensorEvent.values[1] y ऐक्सिस के साथ रोटेशन वेक्टर कॉम्पोनेंट (y * sin(θ/2)).
SensorEvent.values[2] z ऐक्सिस के साथ रोटेशन वेक्टर कॉम्पोनेंट (z * sin(θ/2)).
TYPE_MAGNETIC_FIELD SensorEvent.values[0] एक्स ऐक्सिस के साथ भूचुंबकीय फ़ील्ड की तीव्रता. μT
SensorEvent.values[1] y ऐक्सिस के साथ भूचुंबकीय फ़ील्ड की तीव्रता.
SensorEvent.values[2] z-ऐक्सिस के साथ भूचुंबकीय फ़ील्ड की तीव्रता.
TYPE_MAGNETIC_FIELD_UNCALIBRATED SensorEvent.values[0] X-ऐक्सिस पर, भू-चुंबकीय क्षेत्र की तीव्रता (हार्ड आयरन कैलिब्रेशन के बिना). μT
SensorEvent.values[1] y-ऐक्सिस पर, भू-चुंबकीय क्षेत्र की तीव्रता (हार्ड आयरन कैलिब्रेशन के बिना).
SensorEvent.values[2] z ऐक्सिस के साथ-साथ, जियोमैग्नेटिक फ़ील्ड की स्ट्रेंथ (हार्ड आयरन कैलिब्रेशन के बिना).
SensorEvent.values[3] x-ऐक्सिस पर आयरन बायस का अनुमान.
SensorEvent.values[4] y-ऐक्सिस के साथ आयरन बायस का अनुमान.
SensorEvent.values[5] ज़ेड ऐक्सिस के साथ आयरन बायस का अनुमान.
TYPE_ORIENTATION1 SensorEvent.values[0] ऐज़िमथ (z-ऐक्सिस के आस-पास का कोण). डिग्री
SensorEvent.values[1] पिच (X-ऐक्सिस के आस-पास का कोण).
SensorEvent.values[2] रोल (y-ऐक्सिस के आस-पास का कोण).
TYPE_PROXIMITY SensorEvent.values[0] ऑब्जेक्ट से दूरी.2 सें॰मी॰

1इस सेंसर को Android 2.2 (एपीआई लेवल 8) में बंद कर दिया गया था. साथ ही, इस तरह के सेंसर को Android 4.4W (एपीआई लेवल 20) में बंद कर दिया गया था. सेंसर फ़्रेमवर्क, डिवाइस के ओरिएंटेशन का पता लगाने के लिए अन्य तरीके उपलब्ध कराता है. इन तरीकों के बारे में डिवाइस के ओरिएंटेशन का पता लगाना में बताया गया है.

2 कुछ प्रॉक्सिमिटी सेंसर, सिर्फ़ बाइनरी वैल्यू देते हैं, जिनसे यह पता चलता है कि डिवाइस से ऑब्जेक्ट कितना दूर है.

गेम रोटेशन वेक्टर सेंसर का इस्तेमाल करना

गेम रोटेशन वेक्टर सेंसर, रोटेशन वेक्टर सेंसर जैसा ही होता है. हालांकि, यह जियोमैग्नेटिक फ़ील्ड का इस्तेमाल नहीं करता. इसलिए, Y ऐक्सिस उत्तर की ओर नहीं, बल्कि किसी दूसरे रेफ़रंस की ओर इशारा करता है. उस रेफ़रंस को उसी क्रम में बदलने की अनुमति है जिस क्रम में ज़ाइरोस्कोप, Z ऐक्सिस के आस-पास घूमता है.

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

नीचे दिए गए कोड से, डिफ़ॉल्ट गेम रोटेशन वेक्टर सेंसर का इंस्टेंस पाने का तरीका पता चलता है:

Kotlin

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR);

जियोमैग्नेटिक रोटेशन वेक्टर सेंसर का इस्तेमाल करना

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

नीचे दिए गए कोड में, डिफ़ॉल्ट जियोमैग्नेटिक रोटेशन वैक्टर सेंसर का इंस्टेंस पाने का तरीका बताया गया है:

Kotlin

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR);

डिवाइस के ओरिएंटेशन का हिसाब लगाना

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

Kotlin

private lateinit var sensorManager: SensorManager
...
// Rotation matrix based on current readings from accelerometer and magnetometer.
val rotationMatrix = FloatArray(9)
SensorManager.getRotationMatrix(rotationMatrix, null, accelerometerReading, magnetometerReading)

// Express the updated rotation matrix as three orientation angles.
val orientationAngles = FloatArray(3)
SensorManager.getOrientation(rotationMatrix, orientationAngles)

Java

private SensorManager sensorManager;
...
// Rotation matrix based on current readings from accelerometer and magnetometer.
final float[] rotationMatrix = new float[9];
SensorManager.getRotationMatrix(rotationMatrix, null,
    accelerometerReading, magnetometerReading);

// Express the updated rotation matrix as three orientation angles.
final float[] orientationAngles = new float[3];
SensorManager.getOrientation(rotationMatrix, orientationAngles);

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

  • ऐज़िमथ (-z ऐक्सिस के आस-पास रोटेशन की डिग्री). यह डिवाइस के मौजूदा कंपास दिशा और मैग्नेटिक नॉर्थ के बीच का ऐंगल होता है. अगर डिवाइस का सबसे ऊपरी हिस्सा उत्तर की ओर है, तो अज़ीमुथ 0 डिग्री होगा. अगर सबसे ऊपरी हिस्सा दक्षिण की ओर है, तो अज़ीमुथ 180 डिग्री होगा. इसी तरह, अगर सबसे ऊपरी किनारा पूर्व की ओर है, तो अज़ीमुथ 90 डिग्री होगा. अगर सबसे ऊपरी किनारा पश्चिम की ओर है, तो अज़ीमुथ 270 डिग्री होगा.
  • पिच (x ऐक्सिस के बारे में रोटेशन की डिग्री). यह डिवाइस की स्क्रीन के समानांतर प्लेन और ग्राउंड के समानांतर प्लेन के बीच का ऐंगल होता है. अगर डिवाइस को ज़मीन के समाना रखकर, सबसे नीचे वाला हिस्सा अपने पास रखें और डिवाइस के सबसे ऊपर वाले हिस्से को ज़मीन की ओर झुकाएं, तो पिच ऐंगल पॉज़िटिव हो जाता है. डिवाइस को दूसरी दिशा में झुकाने पर, डिवाइस के ऊपरी हिस्से को ज़मीन से दूर ले जाने पर, पिच ऐंगल नेगेटिव हो जाता है. वैल्यू की रेंज -90 डिग्री से लेकर 90 डिग्री तक होती है.
  • रोल (y ऐक्सिस के आस-पास घुमाव की डिग्री). यह डिवाइस की स्क्रीन के लंबवत प्लेन और ग्राउंड के लंबवत प्लेन के बीच का ऐंगल होता है. अगर डिवाइस को ज़मीन के समाना रखकर, सबसे नीचे वाला हिस्सा अपने पास रखें और डिवाइस के बाएं हिस्से को ज़मीन की ओर झुकाएं, तो रोल ऐंगल पॉज़िटिव हो जाता है. डिवाइस को उल्टी दिशा में झुकाने पर, रोल ऐंगल नेगेटिव हो जाता है. जैसे, डिवाइस के दाएं किनारे को ज़मीन की ओर ले जाने पर. वैल्यू की रेंज -180 डिग्री से लेकर 180 डिग्री तक है.

ध्यान दें:जियोसेंसर नेटवर्क में ज़्यादातर लागू किए गए तरीकों को दिखाने के लिए, सेंसर के रोल की परिभाषा बदल दी गई है.

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

ओरिएंटेशन सेंसर, ऐक्सीलेरोमीटर और जियोमैग्नेटिक फ़ील्ड सेंसर से मिले रॉ सेंसर डेटा को प्रोसेस करके अपना डेटा जनरेट करता है. इसमें बहुत ज़्यादा प्रोसेसिंग की ज़रूरत होती है. इसलिए, ऑरिएंटेशन सेंसर की सटीक जानकारी नहीं मिल पाती. खास तौर पर, यह सेंसर सिर्फ़ तब भरोसेमंद होता है, जब रोल ऐंगल 0 हो. इस वजह से, Android 2.2 (एपीआई लेवल 8) में ओरिएंटेशन सेंसर की सुविधा बंद कर दी गई थी. साथ ही, Android 4.4W (एपीआई लेवल 20) में ओरिएंटेशन सेंसर टाइप की सुविधा बंद कर दी गई थी. हमारा सुझाव है कि आप ओरिएंटेशन सेंसर के रॉ डेटा का इस्तेमाल करने के बजाय, ओरिएंटेशन वैल्यू का हिसाब लगाने के लिए, getRotationMatrix() तरीके के साथ-साथ getOrientation() तरीके का इस्तेमाल करें, जैसा कि यहां दिए गए कोड सैंपल में दिखाया गया है. इस प्रोसेस के तहत, ऑरिएंटेशन वैल्यू को अपने ऐप्लिकेशन के फ़्रेम ऑफ़ रेफ़रंस में बदलने के लिए, remapCoordinateSystem() तरीके का इस्तेमाल किया जा सकता है.

Kotlin

class SensorActivity : Activity(), SensorEventListener {

    private lateinit var sensorManager: SensorManager
    private val accelerometerReading = FloatArray(3)
    private val magnetometerReading = FloatArray(3)

    private val rotationMatrix = FloatArray(9)
    private val orientationAngles = FloatArray(3)

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)
        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
    }

    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
        // Do something here if sensor accuracy changes.
        // You must implement this callback in your code.
    }

    override fun onResume() {
        super.onResume()

        // Get updates from the accelerometer and magnetometer at a constant rate.
        // To make batch operations more efficient and reduce power consumption,
        // provide support for delaying updates to the application.
        //
        // In this example, the sensor reporting delay is small enough such that
        // the application receives an update before the system checks the sensor
        // readings again.
        sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)?.also { accelerometer ->
            sensorManager.registerListener(
                    this,
                    accelerometer,
                    SensorManager.SENSOR_DELAY_NORMAL,
                    SensorManager.SENSOR_DELAY_UI
            )
        }
        sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)?.also { magneticField ->
            sensorManager.registerListener(
                    this,
                    magneticField,
                    SensorManager.SENSOR_DELAY_NORMAL,
                    SensorManager.SENSOR_DELAY_UI
            )
        }
    }

    override fun onPause() {
        super.onPause()

        // Don't receive any more updates from either sensor.
        sensorManager.unregisterListener(this)
    }

    // Get readings from accelerometer and magnetometer. To simplify calculations,
    // consider storing these readings as unit vectors.
    override fun onSensorChanged(event: SensorEvent) {
        if (event.sensor.type == Sensor.TYPE_ACCELEROMETER) {
            System.arraycopy(event.values, 0, accelerometerReading, 0, accelerometerReading.size)
        } else if (event.sensor.type == Sensor.TYPE_MAGNETIC_FIELD) {
            System.arraycopy(event.values, 0, magnetometerReading, 0, magnetometerReading.size)
        }
    }

    // Compute the three orientation angles based on the most recent readings from
    // the device's accelerometer and magnetometer.
    fun updateOrientationAngles() {
        // Update rotation matrix, which is needed to update orientation angles.
        SensorManager.getRotationMatrix(
                rotationMatrix,
                null,
                accelerometerReading,
                magnetometerReading
        )

        // "rotationMatrix" now has up-to-date information.

        SensorManager.getOrientation(rotationMatrix, orientationAngles)

        // "orientationAngles" now has up-to-date information.
    }
}

Java

public class SensorActivity extends Activity implements SensorEventListener {

    private SensorManager sensorManager;
    private final float[] accelerometerReading = new float[3];
    private final float[] magnetometerReading = new float[3];

    private final float[] rotationMatrix = new float[9];
    private final float[] orientationAngles = new float[3];

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
        // Do something here if sensor accuracy changes.
        // You must implement this callback in your code.
    }

    @Override
    protected void onResume() {
        super.onResume();

        // Get updates from the accelerometer and magnetometer at a constant rate.
        // To make batch operations more efficient and reduce power consumption,
        // provide support for delaying updates to the application.
        //
        // In this example, the sensor reporting delay is small enough such that
        // the application receives an update before the system checks the sensor
        // readings again.
        Sensor accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        if (accelerometer != null) {
            sensorManager.registerListener(this, accelerometer,
                SensorManager.SENSOR_DELAY_NORMAL, SensorManager.SENSOR_DELAY_UI);
        }
        Sensor magneticField = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
        if (magneticField != null) {
            sensorManager.registerListener(this, magneticField,
                SensorManager.SENSOR_DELAY_NORMAL, SensorManager.SENSOR_DELAY_UI);
        }
    }

    @Override
    protected void onPause() {
        super.onPause();

        // Don't receive any more updates from either sensor.
        sensorManager.unregisterListener(this);
    }

    // Get readings from accelerometer and magnetometer. To simplify calculations,
    // consider storing these readings as unit vectors.
    @Override
    public void onSensorChanged(SensorEvent event) {
        if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
          System.arraycopy(event.values, 0, accelerometerReading,
              0, accelerometerReading.length);
        } else if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
            System.arraycopy(event.values, 0, magnetometerReading,
                0, magnetometerReading.length);
        }
    }

    // Compute the three orientation angles based on the most recent readings from
    // the device's accelerometer and magnetometer.
    public void updateOrientationAngles() {
        // Update rotation matrix, which is needed to update orientation angles.
        SensorManager.getRotationMatrix(rotationMatrix, null,
            accelerometerReading, magnetometerReading);

        // "rotationMatrix" now has up-to-date information.

        SensorManager.getOrientation(rotationMatrix, orientationAngles);

        // "orientationAngles" now has up-to-date information.
    }
}

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

जियोमैग्नेटिक फ़ील्ड सेंसर का इस्तेमाल करना

जियोमैग्नेटिक फ़ील्ड सेंसर की मदद से, धरती के चुंबकीय फ़ील्ड में होने वाले बदलावों को मॉनिटर किया जा सकता है. यहां दिए गए कोड से, डिफ़ॉल्ट जियोमैग्नेटिक फ़ील्ड सेंसर का इंस्टेंस पाने का तरीका पता चलता है:

Kotlin

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);

ध्यान दें: अगर आपका ऐप्लिकेशन Android 12 (एपीआई लेवल 31) या उससे बाद के वर्शन को टारगेट करता है, तो इस सेंसर की गति सीमित होती है.

यह सेंसर, तीनों निर्देशांक अक्षों के लिए, फ़ील्ड की तीव्रता का डेटा (μT में) देता है. आम तौर पर, आपको इस सेंसर का सीधे तौर पर इस्तेमाल करने की ज़रूरत नहीं होती. इसके बजाय, रोटेशन वेक्टर सेंसर का इस्तेमाल करके, रोटेशन की रॉ गति का पता लगाया जा सकता है. इसके अलावा, रोटेशन मैट्रिक और इनक्लाइनेशन मैट्रिक पाने के लिए, getRotationMatrix() तरीके के साथ एक्सलरोमीटर और जियोमैग्नेटिक फ़ील्ड सेंसर का इस्तेमाल किया जा सकता है. इसके बाद, अज़ीमुथ और जियोमैग्नेटिक इनक्लाइनेशन का डेटा पाने के लिए, getOrientation() और getInclination() तरीकों के साथ इन मैट्रिक का इस्तेमाल किया जा सकता है.

ध्यान दें: अपने ऐप्लिकेशन की जांच करते समय, डिवाइस को आठ के आकार में लहराकर, सेंसर की सटीक जानकारी पाने में मदद मिल सकती है.

बिना कैलिब्रेट किए गए मैग्नेटोमीटर का इस्तेमाल करना

कैलिब्रेट नहीं किया गया मैग्नेटोमीटर, जियोमैग्नेटिक फ़ील्ड सेंसर जैसा ही होता है. हालांकि, मैग्नेटिक फ़ील्ड पर कोई हार्ड आयरन कैलिब्रेशन लागू नहीं होता. फ़ैक्ट्री कैलिब्रेशन और तापमान में बदलाव की वजह से होने वाले बदलाव को मैग्नेटिक फ़ील्ड पर अब भी लागू किया जाता है. बिना कैलिब्रेट किए गए मैग्नेटोमीटर का इस्तेमाल, कठिन आयरन के अनुमान को ठीक करने के लिए किया जाता है. आम तौर पर, geomagneticsensor_event.values[0] uncalibrated_magnetometer_event.values[0] - uncalibrated_magnetometer_event.values[3] के करीब होगा. इसका मतलब है कि,

calibrated_x ~= uncalibrated_x - bias_estimate_x

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

मैग्नेटिक फ़ील्ड के अलावा, कैलिब्रेट नहीं किया गया मैग्नेटोमीटर, हर अक्ष में अनुमानित हार्ड आयरन बायस भी देता है. यहां दिए गए कोड में, डिफ़ॉल्ट तौर पर कैलिब्रेट नहीं किए गए मैग्नेटोमीटर का इंस्टेंस पाने का तरीका बताया गया है:

Kotlin

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED);

प्रॉक्सिमिटी सेंसर का इस्तेमाल करना

प्रॉक्सिमिटी सेंसर की मदद से, यह पता लगाया जा सकता है कि कोई ऑब्जेक्ट डिवाइस से कितनी दूर है. यहां दिए गए कोड से, डिफ़ॉल्ट प्रॉक्सिमिटी सेंसर का इंस्टेंस पाने का तरीका पता चलता है:

Kotlin

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);

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

ध्यान दें: कुछ डिवाइस मॉडल में, प्रॉक्सिमिटी सेंसर स्क्रीन के नीचे होता है. अगर स्क्रीन चालू होने पर प्रॉक्सिमिटी सेंसर चालू होता है, तो स्क्रीन पर एक सफ़ेद बिंदु दिख सकता है.

यहां दिए गए कोड में, आस-पास की पहचान करने वाले सेंसर का इस्तेमाल करने का तरीका बताया गया है:

Kotlin

class SensorActivity : Activity(), SensorEventListener {

    private lateinit var sensorManager: SensorManager
    private var proximity: Sensor? = null

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)

        // Get an instance of the sensor service, and use that to get an instance of
        // a particular sensor.
        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        proximity = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY)
    }

    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
        // Do something here if sensor accuracy changes.
    }

    override fun onSensorChanged(event: SensorEvent) {
        val distance = event.values[0]
        // Do something with this sensor data.
    }

    override fun onResume() {
        // Register a listener for the sensor.
        super.onResume()

        proximity?.also { proximity ->
            sensorManager.registerListener(this, proximity, SensorManager.SENSOR_DELAY_NORMAL)
        }
    }

    override fun onPause() {
        // Be sure to unregister the sensor when the activity pauses.
        super.onPause()
        sensorManager.unregisterListener(this)
    }
}

Java

public class SensorActivity extends Activity implements SensorEventListener {
    private SensorManager sensorManager;
    private Sensor proximity;

    @Override
    public final void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // Get an instance of the sensor service, and use that to get an instance of
        // a particular sensor.
        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        proximity = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
    }

    @Override
    public final void onAccuracyChanged(Sensor sensor, int accuracy) {
        // Do something here if sensor accuracy changes.
    }

    @Override
    public final void onSensorChanged(SensorEvent event) {
        float distance = event.values[0];
        // Do something with this sensor data.
    }

    @Override
    protected void onResume() {
        // Register a listener for the sensor.
        super.onResume();
        sensorManager.registerListener(this, proximity, SensorManager.SENSOR_DELAY_NORMAL);
      }

    @Override
    protected void onPause() {
        // Be sure to unregister the sensor when the activity pauses.
        super.onPause();
        sensorManager.unregisterListener(this);
    }
}

ध्यान दें: कुछ प्रॉक्सिमिटी सेंसर, "पास" या "दूर" दिखाने वाली बाइनरी वैल्यू दिखाते हैं. इस मामले में, सेंसर आम तौर पर फ़ार स्टेट में अपनी ज़्यादा से ज़्यादा रेंज की वैल्यू और नियर स्टेट में कम वैल्यू दिखाता है. आम तौर पर, दूरी की वैल्यू 5 सेंटीमीटर से ज़्यादा होती है. हालांकि, यह सेंसर के हिसाब से अलग-अलग हो सकती है. getMaximumRange() तरीके का इस्तेमाल करके, किसी सेंसर की ज़्यादा से ज़्यादा रेंज का पता लगाया जा सकता है.

आपको यह भी पढ़ना चाहिए

पीछे जाएं
मोशन सेंसर
आगे बढ़ें
वातावरण की जानकारी देने वाले सेंसर