Sebagian besar perangkat Android memiliki sensor bawaan yang mengukur gerakan, orientasi, dan berbagai kondisi lingkungan. Sensor ini mampu menyediakan data mentah dengan presisi dan akurasi, serta berguna jika Anda ingin memantau pergerakan perangkat tiga dimensi atau pemosisian, atau ingin memantau perubahan di lingkungan sekitar di dekat perangkat. Sebagai contoh, game ini mungkin melacak pembacaan dari sensor gravitasi perangkat untuk menyimpulkan gestur pengguna yang kompleks dan gerakan, seperti kemiringan, goyangan, rotasi, atau ayunan. Demikian juga, aplikasi cuaca mungkin menggunakan sensor suhu dan sensor kelembapan perangkat untuk menghitung dan melaporkan titik embun, atau perjalanan mungkin menggunakan sensor medan geomagnetik dan akselerometer untuk melaporkan kompas bearing.
Lihat referensi terkait berikut ini:
Platform Android mendukung tiga kategori sensor yang luas:
- Sensor gerakan
Sensor ini mengukur gaya akselerasi dan gaya rotasi pada tiga sumbu. Ini termasuk akselerometer, sensor gravitasi, giroskop, dan vektor rotasi sensor.
- Sensor lingkungan
Sensor ini mengukur berbagai parameter lingkungan, seperti suhu udara sekitar dan tekanan, pencahayaan, dan kelembapan. Kategori ini mencakup barometer, fotometer, dan termometer.
- Sensor posisi
Sensor ini mengukur posisi fisik perangkat. Kategori ini mencakup sensor orientasi, dan magnetometer.
Anda bisa mengakses sensor yang tersedia di perangkat dan memperoleh data sensor mentah menggunakan Android framework sensor. Framework sensor menyediakan beberapa class dan antarmuka yang membantu Anda melakukan berbagai tugas terkait sensor. Contohnya, Anda dapat menggunakan framework sensor untuk melakukan hal berikut:
- Menentukan sensor yang tersedia di perangkat.
- Menentukan kemampuan sensor individu, seperti rentang maksimumnya, produsen, daya persyaratan, dan resolusi.
- Mendapatkan data sensor mentah dan menentukan kecepatan minimum saat Anda mendapatkan data sensor.
- Mendaftarkan dan membatalkan pendaftaran pemroses peristiwa sensor yang memantau perubahan sensor.
Topik ini memberikan ringkasan sensor yang tersedia di platform Android. Topik ini juga memberikan pengantar tentang framework sensor.
Pengantar Sensor
Framework sensor Android memungkinkan Anda mengakses berbagai jenis sensor. Beberapa sensor ini adalah berbasis perangkat keras dan beberapa berbasis perangkat lunak. Sensor berbasis hardware adalah komponen fisik yang dibuat ke perangkat handset atau tablet. Mereka memperoleh data mereka dengan langsung mengukur kondisi lingkungan properti, seperti akselerasi, kekuatan medan geomagnetik, atau perubahan sudut. Berbasis software sensor bukan perangkat fisik, meskipun mereka meniru sensor berbasis perangkat keras. Sensor berbasis software mengambil data dari satu atau beberapa sensor berbasis perangkat keras dan terkadang disebut virtual sensor atau sensor sintetis. Sensor akselerasi linear dan sensor gravitasi adalah contoh sensor berbasis software. Tabel 1 merangkum sensor yang didukung oleh Android terkelola sepenuhnya.
Hanya sedikit perangkat Android yang memiliki semua jenis sensor. Misalnya, sebagian besar perangkat handset dan tablet memiliki akselerometer dan magnetometer, tetapi lebih sedikit perangkat yang barometer atau termometer. Selain itu, perangkat dapat memiliki lebih dari satu sensor dari jenis tertentu. Sebagai misalnya, perangkat dapat memiliki dua sensor gravitasi, masing-masing memiliki rentang yang berbeda.
Tabel 1. Jenis sensor yang didukung oleh platform Android.
Sensor | Jenis | Deskripsi | Penggunaan Umum |
---|---|---|---|
TYPE_ACCELEROMETER |
Hardware | Mengukur gaya akselerasi dalam m/s2 yang diterapkan pada perangkat di ketiga sumbu fisik (x, y, dan z), termasuk gaya gravitasi. | Deteksi gerakan (goyangan, kemiringan, dll.). |
TYPE_AMBIENT_TEMPERATURE |
Hardware | Mengukur suhu ruangan sekitar dalam derajat Celcius (°C). Lihat catatan di bawah. | Memantau suhu udara. |
TYPE_GRAVITY |
Software atau Hardware | Mengukur gaya gravitasi dalam m/s2 yang diterapkan pada perangkat pada semua tiga sumbu fisik (x, y, z). | Deteksi gerakan (goyangan, kemiringan, dll.). |
TYPE_GYROSCOPE |
Hardware | Mengukur tingkat rotasi perangkat dalam rad/s di sekitar ketiganya sumbu fisik (x, y, dan z). | Deteksi rotasi (berputar, berbalik, dll.). |
TYPE_LIGHT |
Hardware | Mengukur level cahaya sekitar (pencahayaan) dalam lx. | Mengontrol kecerahan layar. |
TYPE_LINEAR_ACCELERATION |
Software atau Hardware | Mengukur gaya percepatan dalam m/s2 yang diterapkan ke perangkat pada ketiga sumbu fisik (x, y, dan z), tidak termasuk gaya gravitasi. | Memantau akselerasi sepanjang sumbu tunggal. |
TYPE_MAGNETIC_FIELD |
Hardware | Mengukur medan geomagnetik sekitar untuk ketiga sumbu fisik (x, y, z) dalam μT. | Membuat kompas. |
TYPE_ORIENTATION |
Software | Mengukur derajat rotasi yang dibuat perangkat di sekitar ketiga sumbu fisik (x, y, z).
Mulai level API 3, Anda bisa mendapatkan matriks kemiringan dan matriks rotasi untuk
perangkat dengan menggunakan sensor gravitasi dan
sensor medan geomagnetik bersama dengan
getRotationMatrix()
. |
Menentukan posisi perangkat. |
TYPE_PRESSURE |
Hardware | Mengukur tekanan udara sekitar dalam hPa atau mbar. | Memantau perubahan tekanan udara. |
TYPE_PROXIMITY |
Hardware | Mengukur kedekatan objek dalam cm relatif terhadap layar tampilan perangkat seluler. Sensor ini biasanya digunakan untuk menentukan apakah handset ditahan untuk telinga seseorang. | Posisi telepon selama panggilan. |
TYPE_RELATIVE_HUMIDITY |
Hardware | Mengukur kelembapan udara relatif dalam persen (%). | Memantau kelembapan relatif, mutlak dan titik embun. |
TYPE_ROTATION_VECTOR |
Software atau Hardware | Mengukur orientasi perangkat dengan menyediakan tiga elemen vektor rotasi. | Deteksi gerakan dan deteksi rotasi. |
TYPE_TEMPERATURE |
Hardware | Mengukur suhu perangkat dalam derajat Celcius (°C). Sensor ini
implementasinya bervariasi
di berbagai perangkat dan
sensor ini diganti dengan sensor TYPE_AMBIENT_TEMPERATURE di
Level API 14 |
Memantau suhu. |
Framework Sensor
Anda dapat mengakses sensor ini dan mendapatkan data mentah sensor dengan framework sensor Android.
Framework sensor adalah bagian dari paket android.hardware
dan mencakup hal berikut
class dan antarmuka:
SensorManager
- Anda dapat menggunakan class ini untuk membuat instance layanan sensor. Class ini menyediakan berbagai metode untuk mengakses dan membuat daftar sensor, mendaftarkan dan membatalkan pendaftaran peristiwa sensor pemroses, dan memperoleh informasi orientasi. Class ini juga menyediakan beberapa konstanta sensor yang digunakan untuk melaporkan akurasi sensor, menetapkan kecepatan akuisisi data, dan melakukan kalibrasi sensor.
Sensor
- Anda dapat menggunakan class ini untuk membuat instance sensor spesifik. Class ini menyediakan berbagai metode yang memungkinkan Anda menentukan kemampuan sensor.
SensorEvent
- Sistem menggunakan class ini untuk membuat objek peristiwa sensor, yang memberikan informasi tentang peristiwa sensor. Objek peristiwa sensor menyertakan informasi berikut: data sensor mentah, jenis sensor yang menghasilkan peristiwa, akurasi data, dan stempel waktu untuk acara.
SensorEventListener
- Anda dapat menggunakan antarmuka ini untuk membuat dua metode callback yang menerima notifikasi (sensor saat nilai sensor berubah atau saat akurasi sensor berubah.
Di aplikasi biasa, Anda menggunakan API terkait sensor ini untuk melakukan dua tugas dasar:
- Mengidentifikasi sensor dan kemampuan sensor
Mengidentifikasi sensor dan kemampuan sensor saat runtime berguna jika aplikasi Anda memiliki fitur yang mengandalkan jenis atau kemampuan sensor tertentu. Misalnya, Anda mungkin ingin mengidentifikasi semua sensor yang ada di perangkat dan menonaktifkan fitur aplikasi apa pun yang mengandalkan sensor yang tidak ada. Demikian juga, sebaiknya identifikasi semua sensor dari jenis tertentu sehingga Anda dapat memilih implementasi sensor yang memiliki performa optimal untuk aplikasi Anda.
- Memantau peristiwa sensor
Memantau aktivitas sensor adalah cara mendapatkan data sensor mentah. Peristiwa sensor terjadi setiap kali sensor mendeteksi perubahan parameter yang diukur. Peristiwa sensor memberi Anda dengan empat informasi: nama sensor yang memicu peristiwa, stempel waktu untuk peristiwa, akurasi peristiwa, dan data sensor mentah yang dipicu acara tersebut.
Ketersediaan Sensor
Meskipun ketersediaan sensor berbeda-beda di setiap perangkat, ketersediaannya juga dapat bervariasi antarperangkat Android. versi. Hal ini karena sensor Android telah diperkenalkan selama beberapa rilis platform. Misalnya, banyak sensor diperkenalkan di Android 1.5 (API Level 3), tetapi beberapa tidak diimplementasikan dan tidak tersedia untuk digunakan hingga Android 2.3 (API Level 9). Demikian juga, beberapa sensor diperkenalkan di Android 2.3 (API Level 9) dan Android 4.0 (API Level 14). Dua sensor tidak digunakan lagi dan diganti dengan sensor yang lebih baru dan lebih baik.
Tabel 2 merangkum ketersediaan setiap sensor berdasarkan platform per platform. Hanya empat platform terdaftar karena mereka adalah platform yang melibatkan perubahan sensor. Sensor yang yang tercantum sebagai tidak digunakan lagi masih tersedia di platform berikutnya (asalkan sensor ada di perangkat), yang sesuai dengan kebijakan kompatibilitas maju Android.
Tabel 2. Ketersediaan sensor menurut platform.
Sensor | Android 4.0 (API Level 14) |
Android 2.3 (API Level 9) |
Android 2.2 (API Level 8) |
Android 1.5 (API Level 3) |
---|---|---|---|---|
TYPE_ACCELEROMETER |
Ya | Ya | Ya | Ya |
TYPE_AMBIENT_TEMPERATURE |
Ya | t/a | t/a | t/a |
TYPE_GRAVITY |
Ya | Ya | t/a | t/a |
TYPE_GYROSCOPE |
Ya | Ya | t/a1 | t/a1 |
TYPE_LIGHT |
Ya | Ya | Ya | Ya |
TYPE_LINEAR_ACCELERATION |
Ya | Ya | t/a | t/a |
TYPE_MAGNETIC_FIELD |
Ya | Ya | Ya | Ya |
TYPE_ORIENTATION |
Ya2 | Ya2 | Ya2 | Ya |
TYPE_PRESSURE |
Ya | Ya | t/a1 | t/a1 |
TYPE_PROXIMITY |
Ya | Ya | Ya | Ya |
TYPE_RELATIVE_HUMIDITY |
Ya | t/a | t/a | t/a |
TYPE_ROTATION_VECTOR |
Ya | Ya | t/a | t/a |
TYPE_TEMPERATURE |
Ya2 | Ya | Ya | Ya |
1 Jenis sensor ini ditambahkan di Android 1.5 (API Level 3), tetapi fitur ini tidak tersedia untuk digunakan hingga Android 2.3 (API Level 9).
2 Sensor ini tersedia, tetapi telah digunakan tidak digunakan lagi.
Mengidentifikasi Sensor dan Kemampuan Sensor
Kerangka kerja sensor Android menyediakan beberapa metode yang memudahkan Anda untuk menentukan runtime sensor yang ada di perangkat. API ini juga menyediakan metode yang memungkinkan Anda menentukan kemampuan setiap sensor, seperti jangkauan maksimumnya, resolusinya, dan dayanya lainnya.
Untuk mengidentifikasi sensor yang ada di perangkat, Anda harus terlebih dahulu mendapatkan referensi ke sensor
layanan. Untuk melakukannya, buat instance class SensorManager
dengan
memanggil metode getSystemService()
dan meneruskan
dalam argumen SENSOR_SERVICE
. Contoh:
Kotlin
private lateinit var sensorManager: SensorManager ... sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
Java
private SensorManager sensorManager; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
Selanjutnya, Anda bisa mendapatkan daftar setiap sensor pada perangkat dengan memanggil
Metode getSensorList()
dan menggunakan konstanta TYPE_ALL
. Contoh:
Kotlin
val deviceSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_ALL)
Java
List<Sensor> deviceSensors = sensorManager.getSensorList(Sensor.TYPE_ALL);
Jika ingin membuat daftar semua sensor dari jenis tertentu, Anda dapat menggunakan konstanta lain, bukan
TYPE_ALL
seperti TYPE_GYROSCOPE
,
TYPE_LINEAR_ACCELERATION
, atau
TYPE_GRAVITY
.
Anda juga dapat menentukan apakah ada jenis sensor tertentu pada perangkat dengan menggunakan metode getDefaultSensor()
dan meneruskan jenis tersebut
untuk sensor tertentu. Jika perangkat memiliki lebih dari satu sensor dari jenis tertentu, salah satu sensor
sensor harus ditetapkan
sebagai sensor default. Jika sensor default tidak ada untuk
jenis sensor, panggilan metode mengembalikan nol, yang berarti perangkat tidak memiliki jenis
sensor. Misalnya, kode berikut memeriksa apakah terdapat magnetometer pada perangkat:
Kotlin
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. }
Java
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. }
Catatan: Android tidak mewajibkan produsen perangkat untuk membuat jenis sensor tertentu ke perangkat berbasis Android, jadi perangkat dapat memiliki berbagai konfigurasi sensor tertentu.
Selain mencantumkan sensor yang ada di perangkat, Anda dapat menggunakan metode publik
Sensor
class untuk menentukan kemampuan dan atribut individu
sensor. Ini berguna jika Anda ingin aplikasi berperilaku berbeda berdasarkan sensor atau
kemampuan sensor yang tersedia
di suatu perangkat. Misalnya, Anda dapat menggunakan getResolution()
dan getMaximumRange()
metode untuk memperoleh resolusi sensor dan rentang pengukuran maksimum. Anda juga dapat menggunakan
Metode getPower()
untuk mendapatkan persyaratan daya sensor.
Dua metode publik tersebut sangat berguna jika Anda ingin mengoptimalkan aplikasi untuk
sensor dari produsen yang berbeda atau
versi sensor yang berbeda. Misalnya, jika aplikasi Anda
perlu memantau {i>gesture <i}pengguna seperti kemiringan dan {i>shake<i}, Anda bisa membuat satu set
dan pengoptimalan untuk perangkat baru yang memiliki sensor gravitasi vendor tertentu, dan
serangkaian aturan pemfilteran data dan pengoptimalan untuk perangkat yang tidak memiliki sensor gravitasi dan
hanya akselerometer. Contoh kode berikut menunjukkan cara menggunakan metode getVendor()
dan getVersion()
untuk melakukannya
ini. Dalam contoh ini, kami mencari sensor gravitasi yang mencantumkan Google LLC sebagai vendor dan
memiliki nomor versi 3. Jika sensor tertentu tidak ada pada perangkat, kami akan mencoba menggunakan
akselerometer.
Kotlin
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 } }
Java
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. } }
Metode lain yang berguna adalah metode getMinDelay()
,
yang menampilkan interval waktu minimum (dalam mikrodetik) yang dapat digunakan sensor untuk mendeteksi data. Sensor apa pun
yang menampilkan nilai bukan nol untuk getMinDelay()
metode ini adalah streaming
sensor. Sensor streaming mendeteksi data secara berkala dan diperkenalkan di Android 2.3 (API
Tingkat 9). Jika sensor menampilkan nol saat Anda memanggil metode getMinDelay()
, ini berarti
sensor bukan sensor streaming karena sensor ini hanya melaporkan data ketika ada perubahan
parameter yang dideteksinya.
Metode getMinDelay()
berguna karena memungkinkan
Anda menentukan tingkat maksimum
di mana sensor dapat
memperoleh data. Jika fitur tertentu dalam aplikasi memerlukan data yang tinggi
tingkat akuisisi atau sensor streaming, Anda dapat
menggunakan metode ini untuk menentukan apakah suatu sensor
memenuhi persyaratan tersebut, kemudian mengaktifkan atau menonaktifkan fitur yang relevan dalam aplikasi
sebagaimana mestinya.
Perhatian: Kecepatan akuisisi data maksimum sensor tidak adalah kecepatan di mana framework sensor mengirimkan data sensor ke aplikasi Anda. Tujuan kerangka kerja sensor melaporkan data melalui kejadian sensor, dan beberapa faktor mempengaruhi laju aplikasi Anda menerima kejadian sensor. Untuk informasi selengkapnya, lihat Memantau Peristiwa Sensor.
Memantau Peristiwa Sensor
Untuk memantau data sensor mentah, Anda perlu menerapkan dua metode callback yang diekspos melalui
antarmuka SensorEventListener
: onAccuracyChanged()
dan onSensorChanged()
. Sistem Android memanggil
metode ini setiap kali hal berikut terjadi:
- Akurasi sensor berubah.
Dalam hal ini, sistem akan memanggil metode
onAccuracyChanged()
, yang memberikan Anda dengan referensi ke objekSensor
yang berubah dan akurasi sensor yang baru. Akurasi diwakili oleh salah satu dari empat konstanta status:SENSOR_STATUS_ACCURACY_LOW
,SENSOR_STATUS_ACCURACY_MEDIUM
,SENSOR_STATUS_ACCURACY_HIGH
, atauSENSOR_STATUS_UNRELIABLE
. - Sensor melaporkan nilai baru.
Dalam hal ini, sistem akan memanggil metode
onSensorChanged()
, yang memberi Anda objekSensorEvent
. ObjekSensorEvent
berisi informasi tentang data sensor baru, termasuk: akurasi data, sensor yang menghasilkan data, stempel waktu di mana data dihasilkan, dan data yang direkam sensor.
Kode berikut menunjukkan cara menggunakan metode onSensorChanged()
untuk memantau data dari
sensor cahaya. Contoh ini menampilkan data sensor mentah dalam TextView
yang
ditentukan dalam file main.xml sebagai sensor_data
.
Kotlin
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) } }
Java
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); } }
Dalam contoh ini, penundaan data default (SENSOR_DELAY_NORMAL
) ditetapkan saat metode registerListener()
dipanggil. Data
penundaan (atau frekuensi pengambilan sampel) mengontrol interval pengiriman peristiwa sensor ke aplikasi Anda
melalui metode callback onSensorChanged()
. Default
penundaan data cocok untuk pemantauan
orientasi layar biasa berubah dan menggunakan penundaan 200.000 mikrodetik. Anda dapat menentukan
penundaan data, seperti SENSOR_DELAY_GAME
(20.000 mikrodetik
penundaan), SENSOR_DELAY_UI
(penundaan 60.000 mikrodetik), atau SENSOR_DELAY_FASTEST
(penundaan 0 mikrodetik). Mulai dari Android 3.0 (API
Level 11) Anda juga dapat menentukan penundaan sebagai nilai absolut (dalam mikrodetik).
Penundaan yang Anda tentukan hanya penundaan yang disarankan. Sistem Android dan aplikasi lainnya dapat mengubah penundaan ini. Sebagai praktik terbaik, Anda harus menentukan penundaan terbesar yang dapat Anda lakukan karena sistem biasanya menggunakan penundaan yang lebih kecil dari yang Anda tetapkan (yaitu, Anda harus frekuensi sampling paling lambat yang masih memenuhi kebutuhan aplikasi Anda). Menerapkan penundaan yang lebih besar beban yang lebih rendah pada prosesor dan oleh karena itu menggunakan lebih sedikit daya.
Tidak ada metode publik untuk menentukan kecepatan pengiriman framework sensor kejadian sensor ke aplikasi Anda; Namun, Anda dapat menggunakan stempel waktu yang terkait dengan peristiwa sensor untuk menghitung frekuensi sampling selama beberapa peristiwa. Anda tidak perlu mengubah frekuensi sampling (penundaan) setelah Anda menetapkannya. Jika karena alasan tertentu Anda perlu mengubah penundaan, Anda akan harus membatalkan pendaftaran dan mendaftarkan kembali pemroses sensor.
Penting juga untuk diperhatikan bahwa contoh ini menggunakan onResume()
dan
Metode callback onPause()
untuk mendaftarkan dan membatalkan pendaftaran peristiwa sensor
pemroses. Sebagai praktik terbaik, Anda harus selalu menonaktifkan sensor yang tidak diperlukan, terutama saat
aktivitas dijeda. Jika tidak dilakukan, baterai akan cepat habis hanya dalam beberapa jam karena beberapa sensor
memiliki kebutuhan daya yang besar dan
dapat menghabiskan daya baterai dengan cepat. Sistem
tidak akan menonaktifkan sensor secara otomatis saat layar mati.
Menangani Konfigurasi Sensor yang Berbeda
Android tidak menentukan konfigurasi sensor standar untuk perangkat, yang berarti produsen perangkat dapat memasukkan konfigurasi sensor apa pun yang mereka inginkan ke dalam Perangkat yang didukung Android. Akibatnya, perangkat dapat mencakup berbagai sensor dalam berbagai konfigurasi. Jika aplikasi Anda bergantung pada jenis sensor tertentu, Anda harus memastikan bahwa sensor ada di perangkat sehingga aplikasi Anda dapat berjalan dengan sukses.
Anda memiliki dua opsi untuk memastikan bahwa sensor tertentu ada di perangkat:
- Mendeteksi sensor saat waktu proses serta mengaktifkan atau menonaktifkan fitur aplikasi sebagaimana mestinya.
- Menggunakan filter Google Play untuk menargetkan perangkat dengan konfigurasi sensor spesifik.
Setiap opsi dibahas di bagian berikut.
Mendeteksi sensor pada waktu proses
Jika aplikasi Anda menggunakan jenis sensor tertentu, namun tidak bergantung padanya, Anda bisa menggunakan framework sensor untuk mendeteksi sensor pada saat runtime, lalu menonaktifkan atau mengaktifkan fitur aplikasi sebagaimana mestinya. Misalnya, aplikasi navigasi mungkin menggunakan sensor suhu, sensor tekanan, sensor GPS, dan sensor medan geomagnetik untuk menampilkan suhu, barometrik tekanan, lokasi, dan penjuru kompas. Jika perangkat tidak memiliki sensor tekanan, Anda dapat menggunakan framework sensor untuk mendeteksi tidak adanya sensor tekanan saat runtime, lalu menonaktifkan bagian dari UI aplikasi Anda yang menampilkan tekanan. Misalnya, pemeriksaan kode berikut apakah terdapat sensor tekanan pada perangkat:
Kotlin
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. }
Java
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. }
Menggunakan filter Google Play untuk menargetkan konfigurasi sensor spesifik
Jika Anda memublikasikan aplikasi di Google Play, Anda dapat menggunakan
Elemen <uses-feature>
dalam file manifes untuk memfilter aplikasi dari perangkat yang tidak
memiliki konfigurasi sensor yang sesuai untuk aplikasi Anda. Tujuan
Elemen <uses-feature>
memiliki beberapa deskripsi hardware yang memungkinkan Anda memfilter
aplikasi berdasarkan keberadaan sensor tertentu. Sensor yang dapat Anda cantumkan meliputi:
akselerometer, barometer, kompas (medan geomagnetik), giroskop, cahaya, dan kedekatan. Tujuan
berikut adalah contoh entri manifes yang memfilter aplikasi yang tidak memiliki akselerometer:
<uses-feature android:name="android.hardware.sensor.accelerometer" android:required="true" />
Jika Anda menambahkan elemen dan deskriptor ini ke manifes aplikasi, pengguna akan melihat aplikasi di Google Play hanya jika perangkatnya memiliki akselerometer.
Anda harus menetapkan deskriptor ke android:required="true"
hanya jika aplikasi Anda
bergantung sepenuhnya pada sensor tertentu. Jika aplikasi Anda menggunakan sensor
untuk beberapa fungsi, namun
masih berjalan tanpa sensor, Anda harus mencantumkan sensor di <uses-feature>
, tetapi tetapkan deskriptor ke android:required="false"
. Hal ini membantu memastikan bahwa
dapat menginstal aplikasi Anda meskipun perangkat tersebut tidak memiliki sensor khusus. Ini juga merupakan
praktik terbaik dalam manajemen proyek yang membantu Anda melacak fitur yang digunakan aplikasi Anda.
Perlu diingat, jika aplikasi Anda menggunakan sensor tertentu, tetapi masih berjalan tanpa sensor,
maka Anda harus mendeteksi sensor saat
runtime dan menonaktifkan atau mengaktifkan fitur aplikasi
yang sesuai.
Sistem Koordinat Sensor
Secara umum, framework sensor menggunakan sistem koordinat 3 sumbu standar untuk menyatakan nilai data. Untuk sebagian besar sensor, sistem koordinat ditentukan relatif terhadap layar perangkat saat perangkat ditahan dalam orientasi defaultnya (lihat gambar 1). Ketika perangkat dipegang dalam orientasi {i>default-<i}nya, sumbu X horizontal dan mengarah ke kanan, sumbu Y vertikal dan mengarah ke atas, dan Z menunjuk ke arah luar tampilan layar. Dalam sistem ini, koordinat di belakang layar memiliki nilai Z negatif. Sistem koordinat ini digunakan oleh sensor berikut:
![](https://developer.android.com/static/images/axis_device.png?authuser=0000&hl=id)
Gambar 1. Sistem koordinat (relatif terhadap perangkat) yang digunakan oleh Sensor Compute Engine API.
Hal terpenting yang perlu dipahami tentang sistem koordinat ini adalah sumbu tidak ditukar saat orientasi layar perangkat berubah—yaitu, sistem koordinat sensor tidak pernah berubah ketika perangkat bergerak. Perilaku ini sama dengan perilaku OpenGL sistem koordinat ini.
Hal lain yang perlu dipahami adalah bahwa aplikasi Anda tidak boleh berasumsi bahwa perangkat (default) orientasi adalah potret. Orientasi alami untuk banyak perangkat tablet adalah lanskap. Dan sistem koordinat sensor selalu didasarkan pada orientasi alami perangkat.
Terakhir, jika aplikasi Anda mencocokkan data sensor dengan tampilan di layar, Anda harus menggunakan
Metode getRotation()
untuk menentukan rotasi layar, lalu gunakan metode
Metode remapCoordinateSystem()
untuk memetakan
koordinat sensor ke koordinat layar. Anda perlu melakukannya bahkan jika manifes Anda menentukan
tampilan khusus potret.
Catatan: Beberapa sensor dan metode menggunakan sistem koordinat yang
relatif terhadap bingkai referensi dunia (berlawanan dengan bingkai referensi perangkat). Ini
sensor dan metode mengembalikan data yang mewakili gerakan perangkat atau posisi perangkat relatif terhadap
bumi. Untuk informasi selengkapnya, lihat metode getOrientation()
, metode getRotationMatrix()
, Orientasi
Sensor, dan Rotation Vector
Sensor.
Pembatasan Kapasitas Sensor
Untuk melindungi informasi yang berpotensi sensitif tentang pengguna, jika aplikasi Anda menargetkan Android 12 (API level 31) atau yang lebih baru, sistem akan menempatkan batas pemuatan ulang kecepatan data dari sensor gerakan dan sensor posisi tertentu. Data ini berisi nilai yang dicatat oleh atribut akselerometer, giroskop, dan medan geomagnetik sensor.
Batas kecepatan refresh bergantung pada cara Anda mengakses data sensor:
- Jika Anda memanggil
registerListener()
untuk memantau peristiwa sensor, frekuensi sampling sensor adalah dibatasi hingga 200 Hz. Hal ini berlaku untuk semua varian kelebihan beban MetoderegisterListener()
. - Jika Anda menggunakan
class
SensorDirectChannel
, frekuensi sampel sensor dibatasi hinggaRATE_NORMAL
, yang biasanya sekitar 50 Hz.
Jika aplikasi perlu mengumpulkan data sensor gerakan pada kecepatan yang lebih tinggi, Anda harus
mendeklarasikan
HIGH_SAMPLING_RATE_SENSORS
seperti yang ditunjukkan dalam cuplikan kode berikut. Atau, jika aplikasi Anda mencoba
untuk mengumpulkan data sensor gerakan pada
kecepatan yang lebih tinggi tanpa menyatakan izin ini,
SecurityException
terjadi.
AndroidManifest.xml
<manifest ...> <uses-permission android:name="android.permission.HIGH_SAMPLING_RATE_SENSORS"/> <application ...> ... </application> </manifest>
Praktik Terbaik untuk Mengakses dan Menggunakan Sensor
Saat mendesain implementasi sensor, pastikan untuk mengikuti panduan yang dibahas dalam bagian ini. Pedoman ini adalah praktik terbaik yang direkomendasikan bagi siapa saja yang menggunakan sensor framework untuk mengakses sensor dan memperoleh data sensor.
Hanya kumpulkan data sensor di latar depan
Pada perangkat yang menjalankan Android 9 (API level 28) atau yang lebih baru, aplikasi yang berjalan di memiliki batasan berikut:
- Sensor yang menggunakan berkelanjutan mode pelaporan, seperti akselerometer dan giroskop, tidak menerima peristiwa.
- Sensor yang menggunakan saat berubah atau one-shot mode pelaporan tidak menerima peristiwa.
Dengan batasan ini, sebaiknya Anda mendeteksi kejadian sensor saat berada di latar depan atau sebagai bagian dari layanan latar depan.
Membatalkan pendaftaran pemroses sensor
Pastikan untuk membatalkan pendaftaran pemroses sensor setelah selesai menggunakan sensor atau ketika sensor
aktivitas akan dijeda. Jika pemroses sensor terdaftar dan aktivitasnya dijeda, sensor akan
terus memperoleh data dan menggunakan sumber daya baterai kecuali Anda membatalkan pendaftaran sensor. Hal berikut
kode menunjukkan cara menggunakan metode onPause()
untuk membatalkan pendaftaran pemroses:
Kotlin
private lateinit var sensorManager: SensorManager ... override fun onPause() { super.onPause() sensorManager.unregisterListener(this) }
Java
private SensorManager sensorManager; ... @Override protected void onPause() { super.onPause(); sensorManager.unregisterListener(this); }
Untuk informasi selengkapnya, lihat unregisterListener(SensorEventListener)
.
Menguji dengan Android Emulator
Android Emulator menyertakan seperangkat kontrol sensor virtual yang memungkinkan Anda untuk menguji sensor seperti akselerometer, suhu sekitar, magnetometer, kedekatan, cahaya, dan lainnya.
Emulator menggunakan koneksi dengan perangkat Android yang menjalankan SdkControllerSensor . Perhatikan bahwa aplikasi ini hanya tersedia di perangkat yang menjalankan Android 4.0 (API level 14) atau lebih tinggi. (Jika perangkat menjalankan Android 4.0, perangkat harus memiliki Revisi 2 diinstal.) Aplikasi SdkControllerSensor memantau perubahan pada sensor pada perangkat dan mengirimkannya ke emulator. Emulatornya adalah kemudian diubah berdasarkan nilai baru yang diterimanya dari sensor pada perangkat Anda.
Anda dapat melihat kode sumber untuk aplikasi SdkControllerSensor di lokasi berikut:
$ your-android-sdk-directory/tools/apps/SdkController
Untuk mentransfer data antara perangkat Anda dan emulator, ikuti langkah-langkah berikut langkah:
- Periksa apakah USB proses debug diaktifkan di perangkat.
- Sambungkan perangkat ke mesin pengembangan menggunakan kabel USB.
- Mulai aplikasi SdkControllerSensor di perangkat Anda.
- Dalam aplikasi tersebut, pilih sensor yang ingin Anda emulasi.
Jalankan perintah
adb
berikut:- Mulai emulator. Sekarang Anda dapat menerapkan transformasi ke emulator dengan menggerakkan perangkat Anda.
$ adb forward tcp:1968 tcp:1968
Catatan: Jika gerakan yang Anda lakukan pada
perangkat fisik tidak mengubah emulator, coba jalankan
adb
dari langkah 5 lagi.
Untuk informasi selengkapnya, lihat dokumen Panduan emulator.
Jangan blokir metode onSensorChanged()
Data sensor dapat berubah dengan kecepatan tinggi, artinya sistem mungkin sering memanggil metode onSensorChanged(SensorEvent)
. Sebagai praktik terbaik, Anda
harus melakukan sesedikit mungkin dalam metode onSensorChanged(SensorEvent)
sehingga Anda tidak memblokirnya. Jika
mengharuskan Anda melakukan penyaringan atau pengurangan data sensor, Anda harus
yang berfungsi di luar metode onSensorChanged(SensorEvent)
.
Hindari penggunaan metode atau jenis sensor yang tidak digunakan lagi
Beberapa metode dan konstanta sudah tidak digunakan lagi.
Secara khusus, TYPE_ORIENTATION
jenis sensor tidak digunakan lagi. Untuk mendapatkan data orientasi, sebaiknya gunakan getOrientation()
. Demikian juga,
Jenis sensor TYPE_TEMPERATURE
tidak digunakan lagi. Sebaiknya Anda menggunakan
jenis sensor TYPE_AMBIENT_TEMPERATURE
di perangkat
yang menjalankan Android 4.0.
Verifikasi sensor sebelum menggunakannya
Selalu pastikan bahwa sensor ada di perangkat sebelum mencoba mendapatkan data darinya. Larangan mengasumsikan bahwa sensor ada hanya karena sensor tersebut sering digunakan. Produsen perangkat tidak diharuskan menyediakan sensor tertentu di perangkatnya.
Pilih penundaan sensor dengan cermat
Saat mendaftarkan sensor dengan metode registerListener()
, pastikan Anda memilih kecepatan pengiriman yang sesuai untuk
aplikasi atau kasus penggunaan. Sensor dapat memberikan data dengan kecepatan yang sangat tinggi. Mengizinkan sistem
untuk mengirim
data tambahan yang tidak diperlukan, menyia-nyiakan
sumber daya sistem dan menghabiskan daya baterai.