เซ็นเซอร์ตำแหน่ง

แพลตฟอร์ม Android มีเซ็นเซอร์ 2 ตัวที่ช่วยให้คุณระบุตำแหน่งของอุปกรณ์ได้ ได้แก่ เซ็นเซอร์สนามแม่เหล็กโลกและตัวตรวจวัดความเร่ง แพลตฟอร์ม Android ยังมีเซ็นเซอร์ที่ช่วยให้คุณระบุได้ว่าใบหน้าของอุปกรณ์อยู่ใกล้กับวัตถุเพียงใด (เรียกว่าพร็อกซิมิตีเซ็นเซอร์) เซ็นเซอร์สนามแม่เหล็กไฟฟ้าและเซ็นเซอร์ตรวจหาบุคคลในบริเวณใกล้เคียงทำงานด้วยฮาร์ดแวร์ ผู้ผลิตโทรศัพท์มือถือและแท็บเล็ตส่วนใหญ่จะมีเซ็นเซอร์สนามแม่เหล็กโลก ในทำนองเดียวกัน ผู้ผลิตโทรศัพท์มือถือมักจะใส่พร็อกซิมิตีเซ็นเซอร์เพื่อระบุว่ามีผู้ใช้ถือโทรศัพท์มือถือไว้ใกล้กับใบหน้า (เช่น ระหว่างการโทร) หากต้องการระบุการวางแนวของอุปกรณ์ คุณสามารถใช้ค่าที่อ่านได้จากตัวตรวจวัดความเร่งและเซ็นเซอร์สนามแม่เหล็กโลกของอุปกรณ์

หมายเหตุ: ระบบเลิกใช้งานเซ็นเซอร์การวางแนวใน Android 2.2 (API ระดับ 8) และเลิกใช้งานเซ็นเซอร์การวางแนวประเภทต่างๆ ใน Android 4.4W (API ระดับ 20)

เซ็นเซอร์ตำแหน่งมีประโยชน์ในการระบุตำแหน่งทางกายภาพของอุปกรณ์ในกรอบอ้างอิงของโลก เช่น คุณสามารถใช้เซ็นเซอร์สนามแม่เหล็กโลกร่วมกับตัวตรวจวัดความเร่งเพื่อระบุตำแหน่งของอุปกรณ์เทียบกับขั้วโลกเหนือแม่เหล็ก นอกจากนี้ คุณยังใช้เซ็นเซอร์เหล่านี้เพื่อระบุการวางแนวของอุปกรณ์ในเฟรมอ้างอิงของแอปพลิเคชันได้ด้วย โดยปกติแล้ว เซ็นเซอร์ตำแหน่งไม่ได้ใช้เพื่อตรวจสอบการเคลื่อนไหวของอุปกรณ์ เช่น การเขย่า การเอียง หรือแรงผลัก (ดูข้อมูลเพิ่มเติมที่หัวข้อเซ็นเซอร์ตรวจจับการเคลื่อนไหว)

เซ็นเซอร์สนามแม่เหล็กโลกและเซ็นเซอร์วัดความเร่งจะแสดงผลอาร์เรย์หลายมิติของค่าเซ็นเซอร์สำหรับ SensorEvent แต่ละรายการ เช่น เซ็นเซอร์สนามแม่เหล็กโลกจะให้ค่าความแรงของสนามแม่เหล็กโลกสำหรับแกนพิกัดทั้ง 3 แกนในระหว่างเหตุการณ์ของเซ็นเซอร์แต่ละครั้ง ในทํานองเดียวกัน เซ็นเซอร์ตรวจวัดความเร่งจะวัดความเร่งที่กระทำกับอุปกรณ์ระหว่างเหตุการณ์เซ็นเซอร์ ดูข้อมูลเพิ่มเติมเกี่ยวกับระบบพิกัดที่เซ็นเซอร์ใช้ได้ที่ ระบบพิกัดของเซ็นเซอร์ เซ็นเซอร์ตรวจหาบุคคลในบริเวณใกล้เคียงจะให้ค่าเดียวสำหรับเหตุการณ์ของเซ็นเซอร์แต่ละรายการ ตารางที่ 1 สรุปเซ็นเซอร์ตำแหน่งที่รองรับในแพลตฟอร์ม Android

ตารางที่ 1 เซ็นเซอร์ตำแหน่งที่รองรับในแพลตฟอร์ม Android

¹ เซ็นเซอร์นี้เลิกใช้งานแล้วใน Android 2.2 (API ระดับ 8) และเลิกใช้งานเซ็นเซอร์ประเภทนี้ใน Android 4.4W (API ระดับ 20) เฟรมเวิร์กเซ็นเซอร์มีวิธีอื่นในการรับการวางแนวของอุปกรณ์ ซึ่งจะกล่าวถึงในหัวข้อคํานวณการวางแนวของอุปกรณ์

² พร็อกซิมิตีเซ็นเซอร์บางตัวให้ค่าแบบไบนารีเท่านั้น ซึ่งแสดงถึง "ใกล้" และ "ไกล"

ใช้เซ็นเซอร์เวกเตอร์การหมุนของเกม

เซ็นเซอร์เวกเตอร์การหมุนของเกมจะเหมือนกับเซ็นเซอร์เวกเตอร์การหมุน ยกเว้นจะไม่ใช้สนามแม่เหล็กโลก ดังนั้น แกน Y จึงไม่ได้ชี้ไปทางทิศเหนือ แต่ชี้ไปยังข้อมูลอ้างอิงอื่น อนุญาตให้การอ้างอิงนั้นเบี่ยงเบนตามลำดับความสำคัญเดียวกันกับที่ไจโรสโคปเบี่ยงเบนรอบแกน Z

เนื่องจากเซ็นเซอร์เวกเตอร์การหมุนของเกมไม่ได้ใช้สนามแม่เหล็ก การหมุนแบบสัมพัทธ์จึงแม่นยำกว่าและไม่ได้รับผลกระทบจากการเปลี่ยนแปลงของสนามแม่เหล็ก ใช้เซ็นเซอร์นี้ในเกมหากคุณไม่สนใจว่าทิศเหนืออยู่ตรงไหน และเวกเตอร์การหมุนปกติไม่ตรงกับความต้องการของคุณเนื่องจากอาศัยสนามแม่เหล็ก

โค้ดต่อไปนี้แสดงวิธีรับอินสแตนซ์ของเซ็นเซอร์เวกเตอร์การหมุนของเกมเริ่มต้น

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)

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

ใช้เซ็นเซอร์เวกเตอร์การหมุนของสนามแม่เหล็กโลก

เซ็นเซอร์เวกเตอร์การหมุนของสนามแม่เหล็กโลกคล้ายกับเซ็นเซอร์เวกเตอร์การหมุน แต่ไม่ได้ใช้ไจโรสโคป ความแม่นยำของเซ็นเซอร์นี้จะต่ำกว่าเซ็นเซอร์เวกเตอร์การหมุนปกติ แต่จะใช้พลังงานน้อยลง ใช้เซ็นเซอร์นี้เฉพาะในกรณีที่คุณต้องการรวบรวมข้อมูลการหมุนในเบื้องหลังโดยไม่ใช้แบตเตอรี่มากเกินไป เซ็นเซอร์นี้จะมีประโยชน์มากที่สุดเมื่อใช้ร่วมกับการแบ่งกลุ่ม

โค้ดต่อไปนี้แสดงวิธีรับอินสแตนซ์ของเซ็นเซอร์เวกเตอร์การหมุนของสนามแม่เหล็กโลกเริ่มต้น

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)

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

คํานวณการวางแนวของอุปกรณ์

การคำนวณการวางแนวของอุปกรณ์ช่วยให้คุณตรวจสอบตำแหน่งของอุปกรณ์เทียบกับกรอบอ้างอิงของโลก (โดยเฉพาะขั้วโลกเหนือแม่เหล็ก) ได้ โค้ดต่อไปนี้แสดงวิธีคํานวณการวางแนวของอุปกรณ์

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)

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);

ระบบจะคำนวณมุมการวางแนวโดยใช้เซ็นเซอร์สนามแม่เหล็กโลกของอุปกรณ์ร่วมกับเครื่องวัดความเร่งของอุปกรณ์ เมื่อใช้เซ็นเซอร์ฮาร์ดแวร์ 2 ตัวนี้ ระบบจะระบุข้อมูลสำหรับมุมการวางแนว 3 มุมต่อไปนี้

• อาซิมุท (องศาการหมุนรอบแกน -z) ค่านี้คือมุมระหว่างทิศทางของเข็มทิศปัจจุบันของอุปกรณ์กับทิศเหนือแม่เหล็ก หากขอบด้านบนของอุปกรณ์หันไปทางทิศเหนือแม่เหล็ก มุมเอียงจะเป็น 0 องศา หากขอบด้านบนหันไปทางทิศใต้ มุมเอียงจะเป็น 180 องศา ในทำนองเดียวกัน หากขอบด้านบนหันไปทางทิศตะวันออก มุมเอียงคือ 90 องศา และหากขอบด้านบนหันไปทางทิศตะวันตก มุมเอียงคือ 270 องศา
• ระดับความสูงต่ำ (องศาการหมุนรอบแกน x) ซึ่งเป็นมุมระหว่างระนาบที่ขนานกับหน้าจอของอุปกรณ์และระนาบที่ขนานกับพื้น หากคุณถืออุปกรณ์ให้ขนานกับพื้นโดยให้ขอบด้านล่างอยู่ใกล้คุณมากที่สุดและเอียงขอบด้านบนของอุปกรณ์ลงสู่พื้น มุมเอียงจะกลายเป็นบวก การเอียงไปในทิศทางตรงกันข้าม ซึ่งก็คือการเลื่อนขอบด้านบนของอุปกรณ์ให้ห่างจากพื้น จะทำให้มุมเอียงเป็นลบ ช่วงของค่าคือ -90 องศาถึง 90 องศา
• การพลิก (องศาการหมุนรอบแกน y) ซึ่งเป็นมุมระหว่างระนาบที่ตั้งฉากกับหน้าจอของอุปกรณ์และระนาบที่ตั้งฉากกับพื้น หากคุณถืออุปกรณ์ให้ขนานกับพื้นโดยให้ขอบด้านล่างอยู่ใกล้กับคุณมากที่สุดและเอียงขอบด้านซ้ายของอุปกรณ์ลงสู่พื้น มุมการกลิ้งจะเป็นค่าบวก การเอียงไปในทิศทางตรงกันข้าม ซึ่งก็คือการเลื่อนขอบด้านขวาของอุปกรณ์ลงสู่พื้น จะทำให้มุมการกลิ้งเป็นค่าลบ ช่วงของค่าคือ -180 องศาถึง 180 องศา

หมายเหตุ: คำจำกัดความของ Roll ของเซ็นเซอร์มีการเปลี่ยนแปลงเพื่อให้สอดคล้องกับการใช้งานส่วนใหญ่ในระบบนิเวศของเซ็นเซอร์ตรวจจับตำแหน่ง

โปรดทราบว่ามุมเหล่านี้ทำงานจากระบบพิกัดอื่นที่แตกต่างจากระบบพิกัดที่ใช้ในการบิน (สำหรับการหมุนตามแนวราบ การหมุนตามแนวตั้ง และการหมุนตามแนวกึ่งกลาง) ในระบบการบิน แกน X จะขนานไปกับด้านยาวของเครื่องบินจากส่วนท้ายไปจนถึงส่วนหัว

เซ็นเซอร์การวางแนวจะดึงข้อมูลโดยการประมวลผลข้อมูลเซ็นเซอร์ดิบจากเครื่องวัดความเร่งและเซ็นเซอร์สนามแม่เหล็กโลก เนื่องจากมีการดำเนินการประมวลผลจำนวนมาก ความแม่นยำของเซ็นเซอร์การวางแนวจึงลดลง กล่าวโดยละเอียดคือ เซ็นเซอร์นี้เชื่อถือได้ก็ต่อเมื่อมุมการพลิกเป็น 0 เท่านั้น ด้วยเหตุนี้ เราจึงเลิกใช้งานเซ็นเซอร์การวางแนวใน Android 2.2 (API ระดับ 8) และเลิกใช้งานประเภทเซ็นเซอร์การวางแนวใน Android 4.4W (API ระดับ 20) เราขอแนะนำให้คุณใช้เมธอด getRotationMatrix() ร่วมกับเมธอด getOrientation() เพื่อคํานวณค่าการวางแนวแทนการใช้ข้อมูลดิบจากเซ็นเซอร์การวางแนว ดังที่แสดงในตัวอย่างโค้ดต่อไปนี้ ในขั้นตอนนี้ คุณสามารถใช้วิธี remapCoordinateSystem() เพื่อแปลงค่าการวางแนวเป็นเฟรมอ้างอิงของแอปพลิเคชัน

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.
    }
}

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.
    }
}

ปกติแล้วคุณไม่จําเป็นต้องประมวลผลหรือกรองข้อมูลมุมการวางแนวดิบของอุปกรณ์ ยกเว้นการแปลระบบพิกัดของเซ็นเซอร์เป็นกรอบอ้างอิงของแอปพลิเคชัน

ใช้เซ็นเซอร์สนามแม่เหล็กไฟฟ้า

เซ็นเซอร์สนามแม่เหล็กไฟฟ้าช่วยให้คุณตรวจสอบการเปลี่ยนแปลงของสนามแม่เหล็กโลกได้ โค้ดต่อไปนี้แสดงวิธีรับอินสแตนซ์ของเซ็นเซอร์สนามแม่เหล็กไฟฟ้าเริ่มต้น

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

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

หมายเหตุ: หากแอปกำหนดเป้าหมายเป็น Android 12 (API ระดับ 31) ขึ้นไป เซ็นเซอร์นี้จะจำกัดอัตรา

เซ็นเซอร์นี้จะให้ข้อมูลความแรงของสนามแม่เหล็กดิบ (ใน μT) สำหรับแกนพิกัดทั้ง 3 แกน โดยปกติแล้ว คุณไม่จำเป็นต้องใช้เซ็นเซอร์นี้โดยตรง แต่คุณใช้เซ็นเซอร์เวกเตอร์การหมุนเพื่อระบุการเคลื่อนไหวแบบหมุนดิบ หรือใช้ตัวตรวจวัดความเร่งและเซ็นเซอร์สนามแม่เหล็กโลกร่วมกับเมธอด getRotationMatrix() เพื่อรับเมทริกซ์การหมุนและเมทริกซ์ความลาดเอียงแทนได้ จากนั้นคุณสามารถใช้เมทริกซ์เหล่านี้กับวิธีการ getOrientation() และ getInclination() เพื่อรับข้อมูลแนวราบและแนวเอียงของสนามแม่เหล็กโลก

หมายเหตุ: เมื่อทดสอบแอป คุณสามารถปรับปรุงความแม่นยำของเซ็นเซอร์ได้โดยโบกอุปกรณ์เป็นเลข 8

ใช้แม่เหล็กไฟฟ้าที่ยังไม่ได้ปรับเทียบ

เครื่องวัดค่าความเข้มข้นของสนามแม่เหล็กที่ไม่ได้ปรับเทียบจะคล้ายกับเซ็นเซอร์สนามแม่เหล็กโลก ยกเว้นว่าไม่มีการปรับเทียบสนามแม่เหล็กด้วยเหล็กแข็ง การปรับเทียบจากโรงงานและการชดเชยอุณหภูมิจะยังคงมีผลกับสนามแม่เหล็ก แมกนีตometers ที่ไม่ได้ปรับเทียบมีประโยชน์ในการจัดการการประมาณเหล็กแข็งที่ไม่ดี โดยทั่วไป geomagneticsensor_event.values[0] จะใกล้เคียงกับ uncalibrated_magnetometer_event.values[0] - uncalibrated_magnetometer_event.values[3] กล่าวคือ

calibrated_x ~= uncalibrated_x - bias_estimate_x

หมายเหตุ: เซ็นเซอร์ที่ไม่ได้ปรับเทียบจะให้ผลลัพธ์ดิบมากกว่าและอาจมีค่าเบี่ยงเบนบ้าง แต่การวัดค่าจะมีความผันผวนน้อยกว่าจากการแก้ไขที่ใช้การปรับเทียบ แอปพลิเคชันบางรายการอาจต้องการผลลัพธ์ที่ไม่ได้ปรับเทียบเหล่านี้เนื่องจากราบรื่นและเชื่อถือได้มากกว่า ตัวอย่างเช่น หากแอปพลิเคชันพยายามทำการผสานเซ็นเซอร์ของตนเอง การใส่การสอบเทียบอาจทำให้ผลลัพธ์บิดเบือนได้

นอกจากสนามแม่เหล็กแล้ว เครื่องมือวัดสนามแม่เหล็กที่ไม่ได้ปรับเทียบยังแสดงค่าความเบี่ยงเบนของเหล็กแข็งโดยประมาณในแต่ละแกนด้วย โค้ดต่อไปนี้แสดงวิธีรับอินสแตนซ์ของแม่เหล็กมาตรที่ยังไม่ได้ปรับเทียบเริ่มต้น

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)

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

ใช้พร็อกซิมิตีเซ็นเซอร์

พร็อกซิมิตีเซ็นเซอร์ช่วยให้คุณระบุระยะห่างของวัตถุจากอุปกรณ์ได้ โค้ดต่อไปนี้แสดงวิธีรับอินสแตนซ์ของเซ็นเซอร์ตรวจหาบุคคลในบริเวณใกล้เคียงเริ่มต้น

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

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

เซ็นเซอร์ตรวจหาบุคคลในบริเวณใกล้เคียงมักใช้เพื่อระบุระยะห่างระหว่างศีรษะของบุคคลกับหน้าของอุปกรณ์มือถือ (เช่น เมื่อผู้ใช้โทรออกหรือรับสาย) เซ็นเซอร์ตรวจหาบุคคลส่วนใหญ่จะแสดงผลระยะทางสัมบูรณ์เป็น cm แต่บางรุ่นจะแสดงเฉพาะค่าใกล้และไกล

หมายเหตุ: ในอุปกรณ์บางรุ่น พร็อกซิมิตีเซ็นเซอร์จะอยู่ใต้หน้าจอ ซึ่งอาจทำให้จุดกะพริบปรากฏขึ้นบนหน้าจอหากเปิดใช้ขณะที่หน้าจอเปิดอยู่

โค้ดต่อไปนี้แสดงวิธีใช้เซ็นเซอร์ตรวจหาบุคคลในบริเวณใกล้เคียง

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)
    }
}

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()

คุณควรอ่าน

• เซ็นเซอร์
• ภาพรวมเซ็นเซอร์
• เซ็นเซอร์ตรวจจับการเคลื่อนไหว
• เซ็นเซอร์ตรวจจับสภาพแวดล้อม