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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SensorManager

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

Sensor

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

SensorEvent

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

SensorEventListener

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

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

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

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

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

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

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

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

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

• การเร่งความเร็ว เซ็นเซอร์
• แรงโน้มถ่วง เซ็นเซอร์
• เครื่องวัดการหมุน
• การเร่งความเร็วเชิงเส้น เซ็นเซอร์
• สนามแม่เหล็กโลก เซ็นเซอร์

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

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

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

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

การจำกัดอัตราเซ็นเซอร์

เพื่อปกป้องข้อมูลที่อาจมีความละเอียดอ่อนเกี่ยวกับผู้ใช้ หากแอปกำหนดเป้าหมาย 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) ขึ้นไป แอปที่ทำงานใน จะมีข้อจำกัดต่อไปนี้

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

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