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

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

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 डिग्री होता है. साथ ही, अगर सबसे ऊपर का किनारा 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() तरीके और जियोमैग्नेटिक इनक्लूनेशन डेटा के बारे में बताया गया है.

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

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

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

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

पीछे जाएं
Motion sensors
आगे बढ़ें
Environment sensors