หน้านี้ได้รับการแปลโดย Cloud Translation API

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

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

โปรดดูแหล่งข้อมูลที่เกี่ยวข้องต่อไปนี้

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

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

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

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

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

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

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

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

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

เซ็นเซอร์	ประเภท	คำอธิบาย	การใช้งานทั่วไป
`TYPE_ACCELEROMETER`	ฮาร์ดแวร์	วัดแรงเร่งเป็น m/s² ที่กระทำกับอุปกรณ์ในทั้ง 3 แกน (x, y และ z) รวมถึงแรงโน้มถ่วง	การตรวจจับการเคลื่อนไหว (การสั่น การส่าย เป็นต้น)
`TYPE_AMBIENT_TEMPERATURE`	ฮาร์ดแวร์	วัดอุณหภูมิแวดล้อมในห้องเป็นองศาเซลเซียส (°C) โปรดดูหมายเหตุด้านล่าง	การตรวจสอบอุณหภูมิอากาศ
`TYPE_GRAVITY`	ซอฟต์แวร์หรือฮาร์ดแวร์	วัดแรงโน้มถ่วงในหน่วยเมตร/วินาที² ที่กระทำต่ออุปกรณ์ 3 แกน (x, y, z)	การตรวจจับการเคลื่อนไหว (เขย่า เอียง ฯลฯ)
`TYPE_GYROSCOPE`	ฮาร์ดแวร์	วัดอัตราการหมุนของอุปกรณ์เป็นหน่วย rad/s รอบๆ อุปกรณ์ทั้ง 3 แกนทางกายภาพ (x, y และ z)	การตรวจจับการหมุน (การหมุน การเลี้ยว ฯลฯ)
`TYPE_LIGHT`	ฮาร์ดแวร์	วัดระดับแสงแวดล้อม (การส่องสว่าง) ในหน่วย lx	การควบคุมความสว่างของหน้าจอ
`TYPE_LINEAR_ACCELERATION`	ซอฟต์แวร์หรือฮาร์ดแวร์	วัดแรงเร่งในหน่วยเมตร/วินาที² ที่ ใช้กับอุปกรณ์ใน แกนทั้ง 3 แกน (x, y และ z) ไม่รวมแรงโน้มถ่วง	การตรวจสอบการเร่งตามแกนเดียว
`TYPE_MAGNETIC_FIELD`	ฮาร์ดแวร์	วัดสนามแม่เหล็กไฟฟ้าโดยรอบสำหรับแกนกายภาพทั้ง 3 แกน (x, y, z) นิ้ว ไมโครT	กำลังสร้างเข็มทิศ
`TYPE_ORIENTATION`	ซอฟต์แวร์	วัดองศาการหมุนที่อุปกรณ์ทำรอบแกนทั้ง 3 แกน (x, y, z) ตั้งแต่ API ระดับ 3 เป็นต้นไป คุณสามารถรับเมทริกซ์ความลาดเอียงและเมทริกซ์การหมุนของอุปกรณ์ได้โดยใช้เซ็นเซอร์ความโน้มถ่วงและเซ็นเซอร์สนามแม่เหล็กโลกร่วมกับ`getRotationMatrix()`วิธีนี้	กำลังระบุตำแหน่งของอุปกรณ์
`TYPE_PRESSURE`	ฮาร์ดแวร์	วัดความดันบรรยากาศโดยรอบเป็น hPa หรือ mbar	เฝ้าดูการเปลี่ยนแปลงของความกดอากาศ
`TYPE_PROXIMITY`	ฮาร์ดแวร์	วัดระยะใกล้/ไกลของวัตถุในหน่วย CM ซึ่งสัมพันธ์กับหน้าจอมุมมองของ อุปกรณ์ โดยปกติแล้วเซ็นเซอร์นี้จะใช้เพื่อพิจารณาว่าการถือโทรศัพท์อยู่นิ่งๆ หรือไม่ เข้าหูคนๆ นั้น	ตำแหน่งของโทรศัพท์ระหว่างการโทร
`TYPE_RELATIVE_HUMIDITY`	ฮาร์ดแวร์	วัดความชื้นสัมพัทธ์โดยรอบเป็นเปอร์เซ็นต์ (%)	ตรวจสอบจุดน้ำค้าง ความชื้นสัมบูรณ์ และความชื้นสัมพัทธ์
`TYPE_ROTATION_VECTOR`	ซอฟต์แวร์หรือฮาร์ดแวร์	วัดการวางแนวของอุปกรณ์โดยการระบุองค์ประกอบ 3 อย่างของอุปกรณ์ เวกเตอร์การหมุน	การตรวจจับการเคลื่อนไหวและการตรวจจับการหมุน
`TYPE_TEMPERATURE`	ฮาร์ดแวร์	วัดอุณหภูมิของอุปกรณ์เป็นองศาเซลเซียส (°C) เซ็นเซอร์นี้ การติดตั้งใช้งานจะแตกต่างกันไปตามอุปกรณ์และ เซ็นเซอร์นี้ถูกแทนที่ด้วยเซ็นเซอร์ `TYPE_AMBIENT_TEMPERATURE` ใน API ระดับ 14	การตรวจสอบอุณหภูมิ

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

คุณสามารถเข้าถึงเซ็นเซอร์เหล่านี้และรับข้อมูลเซ็นเซอร์ดิบได้โดยใช้เฟรมเวิร์กเซ็นเซอร์ 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 4.0 (API ระดับ 14)	Android 2.3 (API ระดับ 9)	Android 2.2 (API ระดับ 8)	Android 1.5 (API ระดับ 3)
`TYPE_ACCELEROMETER`	ทราบ	ทราบ	ทราบ	ทราบ
`TYPE_AMBIENT_TEMPERATURE`	ทราบ	ไม่มี	ไม่มี	ไม่มี
`TYPE_GRAVITY`	ทราบ	ทราบ	ไม่มี	ไม่มี
`TYPE_GYROSCOPE`	ทราบ	ทราบ	ไม่มี¹	ไม่มี¹
`TYPE_LIGHT`	ทราบ	ทราบ	ทราบ	ทราบ
`TYPE_LINEAR_ACCELERATION`	ทราบ	ทราบ	ไม่มี	ไม่มี
`TYPE_MAGNETIC_FIELD`	ทราบ	ทราบ	ทราบ	ทราบ
`TYPE_ORIENTATION`	ใช่²	ใช่²	ใช่²	ทราบ
`TYPE_PRESSURE`	ทราบ	ทราบ	ไม่มี¹	ไม่มี¹
`TYPE_PROXIMITY`	ทราบ	ทราบ	ทราบ	ทราบ
`TYPE_RELATIVE_HUMIDITY`	ทราบ	ไม่มี	ไม่มี	ไม่มี
`TYPE_ROTATION_VECTOR`	ทราบ	ทราบ	ไม่มี	ไม่มี
`TYPE_TEMPERATURE`	ใช่²	ทราบ	ทราบ	ทราบ

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

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

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

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

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

KotlinJava

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

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

ถัดไป คุณสามารถดูรายชื่อเซ็นเซอร์ทุกตัวบนอุปกรณ์โดยเรียกใช้ getSensorList() และใช้ค่าคงที่ TYPE_ALL เช่น

KotlinJava

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

KotlinJava

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

KotlinJava

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

KotlinJava

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

KotlinJava

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

AndroidManifest.xml

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

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

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

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

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

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

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

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

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

KotlinJava

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

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

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

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

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

$ adb forward tcp:1968 tcp:1968

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

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

สำหรับข้อมูลเพิ่มเติม โปรดดูแท็บ Android คู่มือโปรแกรมจำลอง

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

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

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

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

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

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

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

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

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