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

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

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

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

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

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

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

โปรแกรมจำลองจะใช้การเชื่อมต่อกับอุปกรณ์ 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 Emulator

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

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

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

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

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

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

เลือกการหน่วงเวลาของเซ็นเซอร์อย่างระมัดระวัง

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