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

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

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

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

जियोमैग्नेटिक फ़ील्ड सेंसर और एक्सलरोमीटर, कई डाइमेंशन वाला कलेक्शन दिखाते हैं सेंसर की हर SensorEvent के लिए सेंसर वैल्यू का इस्तेमाल करें. उदाहरण के लिए, जियोमैग्नेटिक फ़ील्ड सेंसर, किसी एक सेंसर इवेंट के दौरान, तीनों कोऑर्डिनेट ऐक्सिस के लिए, जियोमैग्नेटिक फ़ील्ड की स्ट्रेंथ की वैल्यू उपलब्ध कराता है. इसी तरह, एक्सलरोमीटर सेंसर, सेंसर इवेंट. सेंसर के इस्तेमाल किए जाने वाले कोऑर्डिनेट सिस्टम के बारे में ज़्यादा जानकारी के लिए, सेंसर कोऑर्डिनेट सिस्टम देखें. प्रॉक्सिमिटी सेंसर से एक वैल्यू मिलती है हर सेंसर इवेंट के लिए. पहले टेबल में, पोज़िशन सेंसर के बारे में खास जानकारी दी गई है 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] x ऐक्सिस पर जियोमैग्नेटिक फ़ील्ड की ताकत. μT
SensorEvent.values[1] y ऐक्सिस पर जियोमैग्नेटिक फ़ील्ड की ताकत.
SensorEvent.values[2] z-ऐक्सिस के साथ भूचुंबकीय फ़ील्ड की तीव्रता.
TYPE_MAGNETIC_FIELD_UNCALIBRATED SensorEvent.values[0] X-ऐक्सिस पर, भू-चुंबकीय क्षेत्र की तीव्रता (हार्ड आयरन कैलिब्रेशन के बिना). माइक्रोसेकंड
SensorEvent.values[1] y-ऐक्सिस पर, भू-चुंबकीय क्षेत्र की तीव्रता (हार्ड आयरन कैलिब्रेशन के बिना).
SensorEvent.values[2] z ऐक्सिस के साथ-साथ, जियोमैग्नेटिक फ़ील्ड की स्ट्रेंथ (हार्ड आयरन कैलिब्रेशन के बिना).
SensorEvent.values[3] x ऐक्सिस पर आयरन बायस का अनुमान.
SensorEvent.values[4] y ऐक्सिस पर आयरन बायस का अनुमान.
SensorEvent.values[5] z ऐक्सिस पर आयरन बायस का अनुमान.
TYPE_ORIENTATIONएक 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() तरीके का इस्तेमाल करके, किसी सेंसर की ज़्यादा से ज़्यादा रेंज का पता लगाया जा सकता है.

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

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