ภาพรวมเซ็นเซอร์

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

แพลตฟอร์ม Android รองรับเซ็นเซอร์ 3 หมวดหมู่หลักๆ ดังนี้

• เซ็นเซอร์ตรวจจับความเคลื่อนไหว

  เซ็นเซอร์เหล่านี้จะวัดแรงเร่งและแรงหมุนตาม 3 แกน หมวดหมู่นี้ประกอบด้วยตัวตรวจวัดความเร่ง เซ็นเซอร์แรงโน้มถ่วง เครื่องวัดการหมุน และเซ็นเซอร์เวกเตอร์การหมุน

• เซ็นเซอร์ตรวจจับสภาพแวดล้อม

  เซ็นเซอร์เหล่านี้จะวัดพารามิเตอร์ด้านสิ่งแวดล้อมต่างๆ เช่น อุณหภูมิและความดันของอากาศรอบตัว การส่องสว่าง และความชื้น หมวดหมู่นี้รวมถึงบารอมิเตอร์ โฟโตมิเตอร์ และเทอร์โมมิเตอร์

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

  เซ็นเซอร์เหล่านี้จะวัดตำแหน่งทางกายภาพของอุปกรณ์ หมวดหมู่นี้ประกอบด้วยเซ็นเซอร์การวางแนวและมาตรแม่เหล็ก

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

• ตรวจสอบว่าเซ็นเซอร์ใดบ้างที่พร้อมใช้งานในอุปกรณ์
• ระบุความสามารถของเซ็นเซอร์แต่ละตัว เช่น ระยะสัญญาณสูงสุด ผู้ผลิต ข้อกำหนดด้านพลังงาน และความละเอียด
• รับข้อมูลเซ็นเซอร์ดิบและกําหนดอัตราการรับข้อมูลเซ็นเซอร์ขั้นต่ำ
• ลงทะเบียนและยกเลิกการลงทะเบียน Listener เหตุการณ์เซ็นเซอร์ที่ตรวจสอบการเปลี่ยนแปลงของเซ็นเซอร์

หัวข้อนี้จะแสดงภาพรวมของเซ็นเซอร์ที่มีอยู่ในแพลตฟอร์ม Android รวมถึงมีข้อมูลเบื้องต้นเกี่ยวกับเฟรมเวิร์กเซ็นเซอร์ด้วย

ข้อมูลเบื้องต้นเกี่ยวกับเซ็นเซอร์

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

อุปกรณ์ Android บางรุ่นมีเซ็นเซอร์ทุกประเภท ตัวอย่างเช่น อุปกรณ์มือถือและแท็บเล็ตส่วนใหญ่มีเครื่องตรวจวัดความเร่งและแม่เหล็ก แต่อุปกรณ์ที่มีบารอมิเตอร์หรือเครื่องวัดอุณหภูมิมีจำนวนน้อยกว่า นอกจากนี้ อุปกรณ์หนึ่งอาจมีเซ็นเซอร์ประเภทหนึ่งๆ ได้มากกว่า 1 ตัว เช่น อุปกรณ์อาจมีเซ็นเซอร์แรงโน้มถ่วง 2 ตัว โดยแต่ละตัวมีระยะสัญญาณต่างกัน

ตารางที่ 1 ประเภทเซ็นเซอร์ที่แพลตฟอร์ม Android รองรับ

เฟรมเวิร์กเซ็นเซอร์

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

SensorManager

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

Sensor

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

SensorEvent

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

SensorEventListener

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

ในแอปพลิเคชันทั่วไป คุณจะใช้ API ที่เกี่ยวข้องกับเซ็นเซอร์เหล่านี้เพื่อทํางานพื้นฐาน 2 อย่างต่อไปนี้

• การระบุเซ็นเซอร์และความสามารถของเซ็นเซอร์

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

• ตรวจสอบเหตุการณ์ของเซ็นเซอร์

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

ความพร้อมใช้งานของเซ็นเซอร์

แม้ว่าความพร้อมใช้งานของเซ็นเซอร์จะแตกต่างกันไปในแต่ละอุปกรณ์ แต่อาจแตกต่างกันไปตามเวอร์ชัน Android ด้วย เนื่องจากเซ็นเซอร์ Android ได้รับการเปิดตัวในช่วงที่มีการเผยแพร่แพลตฟอร์มหลายรุ่น ตัวอย่างเช่น เซ็นเซอร์จำนวนมากเปิดตัวใน Android 1.5 (API ระดับ 3) แต่เซ็นเซอร์บางตัวไม่ได้นำมาใช้งานและยังไม่พร้อมใช้งานจนกว่า Android 2.3 (API ระดับ 9) ในทํานองเดียวกัน ระบบได้เปิดตัวเซ็นเซอร์หลายรายการใน Android 2.3 (API ระดับ 9) และ Android 4.0 (API ระดับ 14) เราได้เลิกใช้งานเซ็นเซอร์ 2 ตัวและแทนที่ด้วยเซ็นเซอร์ที่ใหม่กว่าและมีประสิทธิภาพดีกว่า

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

ตารางที่ 2 ความพร้อมใช้งานของเซ็นเซอร์ตามแพลตฟอร์ม

¹ เซ็นเซอร์ประเภทนี้เพิ่มเข้ามาใน Android 1.5 (API ระดับ 3) แต่ยังไม่พร้อมใช้งานจนกว่าจะใช้ใน Android 2.3 (API ระดับ 9)

² เซ็นเซอร์นี้พร้อมใช้งาน แต่เลิกใช้งานแล้ว

การระบุเซ็นเซอร์และความสามารถของเซ็นเซอร์

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

หากต้องการระบุเซ็นเซอร์ที่อยู่ในอุปกรณ์ ก่อนอื่นคุณต้องขอข้อมูลอ้างอิงสำหรับบริการเซ็นเซอร์ โดยสร้างอินสแตนซ์ของคลาส SensorManager ด้วยการเรียกใช้เมธอด getSystemService() และส่งอาร์กิวเมนต์ SENSOR_SERVICE เช่น

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

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

จากนั้น คุณจะเห็นรายการเซ็นเซอร์ทั้งหมดในอุปกรณ์โดยการเรียกใช้เมธอด getSensorList() และใช้ค่าคงที่ TYPE_ALL เช่น

val deviceSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_ALL)

List<Sensor> deviceSensors = sensorManager.getSensorList(Sensor.TYPE_ALL);

หากต้องการแสดงรายการเซ็นเซอร์ทั้งหมดของประเภทหนึ่งๆ ให้ใช้ค่าคงที่อื่นแทน TYPE_ALL เช่น TYPE_GYROSCOPE, TYPE_LINEAR_ACCELERATION หรือ TYPE_GRAVITY

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

private lateinit var sensorManager: SensorManager
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
if (sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null) {
    // Success! There's a magnetometer.
} else {
    // Failure! No magnetometer.
}

private SensorManager sensorManager;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
if (sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null){
    // Success! There's a magnetometer.
} else {
    // Failure! No magnetometer.
}

หมายเหตุ: Android ไม่ได้กำหนดให้ผู้ผลิตอุปกรณ์ต้องใส่เซ็นเซอร์ประเภทใดประเภทหนึ่งลงในอุปกรณ์ที่ทำงานด้วยระบบ Android ดังนั้นอุปกรณ์จึงมีการกำหนดค่าเซ็นเซอร์ได้หลากหลาย

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

2 วิธีแบบสาธารณะจะมีประโยชน์อย่างยิ่งหากคุณต้องการเพิ่มประสิทธิภาพแอปพลิเคชันสำหรับเซ็นเซอร์ของผู้ผลิตรายอื่นหรือเซ็นเซอร์เวอร์ชันต่างๆ เช่น หากแอปพลิเคชันต้องตรวจสอบท่าทางของผู้ใช้ เช่น การเอียงและการเขย่า คุณอาจสร้างกฎและการเพิ่มประสิทธิภาพการกรองข้อมูลชุดหนึ่งสำหรับอุปกรณ์รุ่นใหม่ที่มีเซ็นเซอร์แรงโน้มถ่วงของผู้ให้บริการรายใดรายหนึ่ง และสร้างกฎและการเพิ่มประสิทธิภาพการกรองข้อมูลอีกชุดหนึ่งสำหรับอุปกรณ์ที่ไม่มีเซ็นเซอร์แรงโน้มถ่วงและมีเพียงเซ็นเซอร์ความเร่งเท่านั้น ตัวอย่างโค้ดต่อไปนี้แสดงวิธีใช้เมธอด getVendor() และ getVersion() ในตัวอย่างนี้ เรากําลังมองหาเซ็นเซอร์แรงโน้มถ่วงที่ระบุ Google LLC เป็นผู้ให้บริการและมีหมายเลขเวอร์ชัน 3 หากอุปกรณ์ไม่มีเซ็นเซอร์ดังกล่าว เราจะพยายามใช้เครื่องวัดความเร่ง

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

...

sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager

if (sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY) != null) {
    val gravSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_GRAVITY)
    // Use the version 3 gravity sensor.
    mSensor = gravSensors.firstOrNull { it.vendor.contains("Google LLC") && it.version == 3 }
}
if (mSensor == null) {
    // Use the accelerometer.
    mSensor = if (sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null) {
        sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
    } else {
        // Sorry, there are no accelerometers on your device.
        // You can't play this game.
        null
    }
}

private SensorManager sensorManager;
private Sensor mSensor;

...

sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
mSensor = null;

if (sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY) != null){
    List<Sensor> gravSensors = sensorManager.getSensorList(Sensor.TYPE_GRAVITY);
    for(int i=0; i<gravSensors.size(); i++) {
        if ((gravSensors.get(i).getVendor().contains("Google LLC")) &&
           (gravSensors.get(i).getVersion() == 3)){
            // Use the version 3 gravity sensor.
            mSensor = gravSensors.get(i);
        }
    }
}
if (mSensor == null){
    // Use the accelerometer.
    if (sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null){
        mSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
    } else{
        // Sorry, there are no accelerometers on your device.
        // You can't play this game.
    }
}

อีกวิธีที่มีประโยชน์คือเมธอด getMinDelay() ซึ่งจะแสดงผลช่วงเวลาขั้นต่ำ (เป็นไมโครวินาที) ที่เซ็นเซอร์สามารถใช้เพื่อตรวจจับข้อมูล เซ็นเซอร์ที่แสดงผลค่าที่ไม่ใช่ศูนย์สำหรับเมธอด getMinDelay() เป็นเซ็นเซอร์สตรีมมิง เซ็นเซอร์สตรีมมิงจะตรวจจับข้อมูลเป็นระยะๆ และเปิดตัวใน Android 2.3 (API ระดับ 9) หากเซ็นเซอร์แสดงผลเป็น 0 เมื่อคุณเรียกใช้เมธอด getMinDelay() แสดงว่าเซ็นเซอร์ไม่ใช่เซ็นเซอร์สตรีมมิง เนื่องจากจะรายงานข้อมูลเฉพาะเมื่อมีการเปลี่ยนแปลงในพารามิเตอร์ที่ตรวจจับเท่านั้น

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

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

การตรวจสอบเหตุการณ์เซ็นเซอร์

หากต้องการตรวจสอบข้อมูลเซ็นเซอร์ดิบ คุณต้องใช้เมธอดการเรียกกลับ 2 รายการที่แสดงผ่านอินเทอร์เฟซ SensorEventListener ได้แก่ onAccuracyChanged() และ onSensorChanged() ระบบ Android จะเรียกใช้เมธอดเหล่านี้ทุกครั้งที่เหตุการณ์ต่อไปนี้เกิดขึ้น

• ความแม่นยำของเซ็นเซอร์เปลี่ยนแปลง

  ในกรณีนี้ ระบบจะเรียกใช้เมธอด onAccuracyChanged() ซึ่งจะแสดงการอ้างอิงถึงออบเจ็กต์ Sensor ที่เปลี่ยนแปลงไปและความแม่นยำใหม่ของเซ็นเซอร์ ความแม่นยำแสดงด้วยค่าคงที่สถานะอย่างใดอย่างหนึ่งต่อไปนี้ SENSOR_STATUS_ACCURACY_LOW, SENSOR_STATUS_ACCURACY_MEDIUM, SENSOR_STATUS_ACCURACY_HIGH หรือ SENSOR_STATUS_UNRELIABLE

• เซ็นเซอร์รายงานค่าใหม่

  ในกรณีนี้ ระบบจะเรียกใช้เมธอด onSensorChanged() ซึ่งจะให้ออบเจ็กต์ SensorEvent ออบเจ็กต์ SensorEvent ประกอบด้วยข้อมูลเกี่ยวกับข้อมูลเซ็นเซอร์ใหม่ ซึ่งรวมถึงความแม่นยำของข้อมูล เซ็นเซอร์ที่สร้างข้อมูล การประทับเวลาที่สร้างข้อมูล และข้อมูลใหม่ที่เซ็นเซอร์บันทึกไว้

โค้ดต่อไปนี้แสดงวิธีใช้เมธอด onSensorChanged() เพื่อตรวจสอบข้อมูลจากเซ็นเซอร์แสง ตัวอย่างนี้แสดงข้อมูลเซ็นเซอร์ดิบใน TextView ที่ระบุไว้ในไฟล์ main.xml เป็น sensor_data

class SensorActivity : Activity(), SensorEventListener {
    private lateinit var sensorManager: SensorManager
    private var mLight: Sensor? = null

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

        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        mLight = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)
    }

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

    override fun onSensorChanged(event: SensorEvent) {
        // The light sensor returns a single value.
        // Many sensors return 3 values, one for each axis.
        val lux = event.values[0]
        // Do something with this sensor value.
    }

    override fun onResume() {
        super.onResume()
        mLight?.also { light ->
            sensorManager.registerListener(this, light, SensorManager.SENSOR_DELAY_NORMAL)
        }
    }

    override fun onPause() {
        super.onPause()
        sensorManager.unregisterListener(this)
    }
}

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

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

        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        mLight = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
    }

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

    @Override
    public final void onSensorChanged(SensorEvent event) {
        // The light sensor returns a single value.
        // Many sensors return 3 values, one for each axis.
        float lux = event.values[0];
        // Do something with this sensor value.
    }

    @Override
    protected void onResume() {
        super.onResume();
        sensorManager.registerListener(this, mLight, SensorManager.SENSOR_DELAY_NORMAL);
    }

    @Override
    protected void onPause() {
        super.onPause();
        sensorManager.unregisterListener(this);
    }
}

ในตัวอย่างนี้ ระบบจะระบุการหน่วงเวลาข้อมูลเริ่มต้น (SENSOR_DELAY_NORMAL) เมื่อเรียกใช้เมธอด registerListener() การหน่วงเวลาข้อมูล (หรืออัตราการสุ่มตัวอย่าง) จะควบคุมช่วงเวลาที่ส่งเหตุการณ์เซ็นเซอร์ไปยังแอปพลิเคชันผ่านเมธอด onSensorChanged() Callback การหน่วงเวลาข้อมูลเริ่มต้นเหมาะสำหรับการตรวจสอบการเปลี่ยนแปลงการวางแนวหน้าจอทั่วไป และใช้การหน่วงเวลา 200,000 ไมโครวินาที คุณสามารถระบุการหน่วงเวลาข้อมูลอื่นๆ เช่น SENSOR_DELAY_GAME (การหน่วงเวลา 20,000 ไมโครวินาที) SENSOR_DELAY_UI (การหน่วงเวลา 60,000 ไมโครวินาที) หรือ SENSOR_DELAY_FASTEST (การหน่วงเวลา 0 ไมโครวินาที) ตั้งแต่ Android 3.0 (API ระดับ 11) เป็นต้นไป คุณจะระบุเวลาหน่วงเป็นค่าสัมบูรณ์ (เป็นไมโครวินาที) ได้ด้วย

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

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

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

การจัดการการกำหนดค่าเซ็นเซอร์แบบต่างๆ

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

คุณมี 2 ตัวเลือกในการตรวจสอบว่ามีเซ็นเซอร์หนึ่งๆ ในอุปกรณ์หรือไม่

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

แต่ละตัวเลือกจะอธิบายไว้ในส่วนต่อไปนี้

การตรวจหาเซ็นเซอร์ขณะรันไทม์

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

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

if (sensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE) != null) {
    // Success! There's a pressure sensor.
} else {
    // Failure! No pressure sensor.
}

private SensorManager sensorManager;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
if (sensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE) != null){
    // Success! There's a pressure sensor.
} else {
    // Failure! No pressure sensor.
}

การใช้ตัวกรอง Google Play เพื่อกําหนดเป้าหมายการกำหนดค่าเซ็นเซอร์ที่เฉพาะเจาะจง

หากเผยแพร่แอปพลิเคชันใน Google Play คุณสามารถใช้องค์ประกอบ <uses-feature> ในไฟล์ Manifest เพื่อกรองแอปพลิเคชันจากอุปกรณ์ที่ไม่มีการกำหนดค่าเซ็นเซอร์ที่เหมาะสมสำหรับแอปพลิเคชัน องค์ประกอบ <uses-feature> มีส่วนอธิบายฮาร์ดแวร์หลายรายการที่ช่วยให้คุณกรองแอปพลิเคชันตามที่มีเซ็นเซอร์ที่เฉพาะเจาะจง เซ็นเซอร์ที่คุณระบุได้ ได้แก่ ตัวตรวจวัดความเร่ง บารอมิเตอร์ เข็มทิศ (สนามแม่เหล็กโลก) เครื่องวัดการหมุน แสง และพร็อกซิมิตี ต่อไปนี้คือตัวอย่างรายการไฟล์ Manifest ที่กรองแอปที่ไม่มีเครื่องวัดความเร่ง

<uses-feature android:name="android.hardware.sensor.accelerometer"
              android:required="true" />

หากคุณเพิ่มองค์ประกอบและตัวระบุนี้ลงในไฟล์ Manifest ของแอปพลิเคชัน ผู้ใช้จะเห็นแอปพลิเคชันของคุณใน Google Play ก็ต่อเมื่ออุปกรณ์มีเครื่องวัดความเร่งเท่านั้น

คุณควรตั้งค่าตัวบ่งชี้เป็น android:required="true" เฉพาะในกรณีที่แอปพลิเคชันของคุณใช้เซ็นเซอร์ที่เฉพาะเจาะจงทั้งหมด หากแอปพลิเคชันใช้เซ็นเซอร์สำหรับฟังก์ชันบางอย่าง แต่ยังคงทำงานได้โดยไม่ต้องใช้เซ็นเซอร์ คุณควรระบุเซ็นเซอร์ในองค์ประกอบ <uses-feature> แต่ตั้งค่าตัวบ่งชี้เป็น android:required="false" วิธีนี้ช่วยให้มั่นใจได้ว่าอุปกรณ์จะติดตั้งแอปของคุณได้แม้ว่าจะไม่มีเซ็นเซอร์ดังกล่าวก็ตาม นอกจากนี้ ยังถือเป็นแนวทางปฏิบัติแนะนำในการจัดการโปรเจ็กต์ที่ช่วยให้คุณติดตามฟีเจอร์ที่แอปพลิเคชันใช้อยู่ได้ โปรดทราบว่าหากแอปพลิเคชันใช้เซ็นเซอร์หนึ่งๆ แต่ยังคงทำงานได้โดยไม่ต้องใช้เซ็นเซอร์ คุณควรตรวจหาเซ็นเซอร์ดังกล่าวที่รันไทม์ และปิดหรือเปิดใช้ฟีเจอร์แอปพลิเคชันตามความเหมาะสม

ระบบพิกัดของเซ็นเซอร์

โดยทั่วไปแล้ว เฟรมเวิร์กเซ็นเซอร์จะใช้ระบบพิกัด 3 แกนมาตรฐานเพื่อแสดงค่าข้อมูล สําหรับเซ็นเซอร์ส่วนใหญ่ ระบบพิกัดจะกําหนดตามหน้าจอของอุปกรณ์เมื่อถืออุปกรณ์ในแนวการวางเริ่มต้น (ดูรูปที่ 1) เมื่อถืออุปกรณ์ในแนวการวางเริ่มต้น แกน X จะวางแนวนอนและชี้ไปทางขวา แกน Y จะวางแนวตั้งและชี้ขึ้น และแกน Z จะชี้ออกไปด้านนอกของหน้าจอ ในระบบนี้ พิกัดที่อยู่หลังหน้าจอจะมีค่า Z เป็นลบ เซ็นเซอร์ต่อไปนี้ใช้ระบบพิกัดนี้

รูปที่ 1 ระบบพิกัด (สัมพันธ์กับอุปกรณ์) ที่ Sensor API ใช้

• เซ็นเซอร์การเร่ง
• เซ็นเซอร์แรงโน้มถ่วง
• ไจโรสโคป
• เซ็นเซอร์การเร่งความเร็วเชิงเส้น
• เซ็นเซอร์สนามแม่เหล็กไฟฟ้า

สิ่งที่สำคัญที่สุดที่ควรทราบเกี่ยวกับระบบพิกัดนี้คือ ระบบจะไม่สลับแกนเมื่อการวางแนวหน้าจอของอุปกรณ์เปลี่ยนไป กล่าวคือ ระบบพิกัดของเซ็นเซอร์จะไม่เปลี่ยนแปลงเมื่ออุปกรณ์เคลื่อนไหว ลักษณะการทำงานนี้เหมือนกับลักษณะการทํางานของระบบพิกัดของ OpenGL

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

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

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

การจำกัดอัตราการส่งข้อมูลของเซ็นเซอร์

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

ขีดจำกัดอัตราการรีเฟรชจะขึ้นอยู่กับวิธีที่คุณเข้าถึงข้อมูลเซ็นเซอร์ ดังนี้

• หากคุณเรียกใช้เมธอด registerListener() เพื่อตรวจสอบเหตุการณ์เซ็นเซอร์ อัตราการสุ่มตัวอย่างเซ็นเซอร์จะจำกัดอยู่ที่ 200 Hz ซึ่งใช้ได้กับตัวแปรทั้งหมดที่โอเวอร์โหลดของเมธอด registerListener()
• หากคุณใช้คลาส SensorDirectChannel ระบบจะจำกัดอัตราการสุ่มตัวอย่างของเซ็นเซอร์ไว้ที่ RATE_NORMAL ซึ่งโดยปกติแล้วจะอยู่ที่ประมาณ 50 Hz

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

AndroidManifest.xml

<manifest ...>
    <uses-permission android:name="android.permission.HIGH_SAMPLING_RATE_SENSORS"/>
    <application ...>
        ...
    </application>
</manifest>

แนวทางปฏิบัติแนะนำในการเข้าถึงและใช้เซ็นเซอร์

เมื่อออกแบบการติดตั้งเซ็นเซอร์ โปรดปฏิบัติตามหลักเกณฑ์ที่กล่าวถึงในส่วนนี้ หลักเกณฑ์เหล่านี้เป็นแนวทางปฏิบัติแนะนำสำหรับผู้ที่ใช้เฟรมเวิร์กเซ็นเซอร์เพื่อเข้าถึงเซ็นเซอร์และรับข้อมูลเซ็นเซอร์

รวบรวมเฉพาะข้อมูลเซ็นเซอร์ในเบื้องหน้า

ในอุปกรณ์ที่ใช้ Android 9 (API ระดับ 28) ขึ้นไป แอปที่ทำงานอยู่เบื้องหลังจะมีข้อจำกัดต่อไปนี้

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

ด้วยเหตุนี้ คุณจึงควรตรวจหาเหตุการณ์ของเซ็นเซอร์เมื่อแอปอยู่เบื้องหน้าหรือเป็นส่วนหนึ่งของบริการที่ทำงานอยู่เบื้องหน้า

ยกเลิกการลงทะเบียน Listener ของเซ็นเซอร์

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

private lateinit var sensorManager: SensorManager
...
override fun onPause() {
    super.onPause()
    sensorManager.unregisterListener(this)
}

private SensorManager sensorManager;
...
@Override
protected void onPause() {
    super.onPause();
    sensorManager.unregisterListener(this);
}

ดูข้อมูลเพิ่มเติมได้ที่ unregisterListener(SensorEventListener)

ทดสอบด้วยโปรแกรมจำลอง Android

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

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

คุณดูซอร์สโค้ดสําหรับแอป SdkControllerSensor ได้ที่ตำแหน่งต่อไปนี้

$ your-android-sdk-directory/tools/apps/SdkController

หากต้องการโอนข้อมูลระหว่างอุปกรณ์กับโปรแกรมจำลอง ให้ทำตามขั้นตอนต่อไปนี้

1. ตรวจสอบว่าเปิดใช้การแก้ไขข้อบกพร่องผ่าน USB บนอุปกรณ์แล้ว
2. เชื่อมต่ออุปกรณ์กับเครื่องสำหรับพัฒนาโดยใช้สาย USB
3. เริ่มแอป SdkControllerSensor ในอุปกรณ์
4. เลือกเซ็นเซอร์ที่ต้องการจําลองในแอป

5. เรียกใช้คำสั่ง adb ต่อไปนี้

$ adb forward tcp:1968 tcp:1968

6. เริ่มโปรแกรมจำลอง ตอนนี้คุณควรใช้การเปลี่ยนรูปแบบกับโปรแกรมจำลองได้โดยย้ายอุปกรณ์

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

ดูข้อมูลเพิ่มเติมได้ที่คู่มือโปรแกรมจำลอง Android

อย่าบล็อกเมธอด onSensorChanged()

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

หลีกเลี่ยงการใช้วิธีการหรือเซ็นเซอร์ประเภทที่เลิกใช้งานแล้ว

เลิกใช้งานเมธอดและค่าคงที่หลายรายการแล้ว โดยเฉพาะอย่างยิ่ง เราเลิกใช้งานประเภทเซ็นเซอร์ TYPE_ORIENTATION แล้ว หากต้องการรับข้อมูลการวางแนว คุณควรใช้เมธอด getOrientation() แทน ในทํานองเดียวกัน เราเลิกใช้งานเซ็นเซอร์ประเภท TYPE_TEMPERATURE แล้ว คุณควรใช้TYPE_AMBIENT_TEMPERATUREเซ็นเซอร์ประเภทอื่นแทนในอุปกรณ์ที่ใช้ Android 4.0

ยืนยันเซ็นเซอร์ก่อนใช้งาน

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

เลือกเวลาหน่วงของเซ็นเซอร์อย่างรอบคอบ

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