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

อุปกรณ์ที่ทำงานด้วยระบบ 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

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

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

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

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

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

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

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

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

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

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

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