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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SensorManager

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

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() เพื่อลงทะเบียนและยกเลิกการลงทะเบียนโปรแกรมฟังเหตุการณ์เซ็นเซอร์ แนวทางปฏิบัติแนะนำคือคุณควรปิดใช้เซ็นเซอร์ที่ไม่จำเป็นเสมอ โดยเฉพาะเมื่อกิจกรรมหยุดชั่วคราว หากไม่ดำเนินการอาจทำให้แบตเตอรี่หมดภายใน 2-3 ชั่วโมงเนื่องจากเซ็นเซอร์บางตัวต้องใช้พลังงานมากและใช้พลังงานแบตเตอรี่อย่างรวดเร็ว ระบบจะไม่ปิดใช้เซ็นเซอร์โดยอัตโนมัติเมื่อหน้าจอปิดอยู่

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

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 ของเซ็นเซอร์เมื่อคุณใช้เซ็นเซอร์เสร็จแล้วหรือเมื่อเซ็นเซอร์หยุดทำงานชั่วคราว หากบันทึก 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 Emulator

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