Isi

• Sensor Android apa yang dapat saya gunakan?
• Sensor lingkungan: Mengukur cahaya sekitar
• Menampilkan data sensor Anda
• Berkomunikasi dengan sensor: SensorManager, SensorEvents, dan pendengar
• 1. Dapatkan instance dari SensorManager
• 2. Dapatkan referensi ke lightTextView
• 3. Periksa apakah sensor ada pada perangkat saat ini
• 4. Daftarkan pendengar sensor Anda
• 5. Terapkan panggilan balik SensorEventListener
• onSensorChanged ()
• padaAccuracyChanged ()
• 6. Ambil nilai sensor
• 7. Batalkan registrasi pendengar Anda
• Menggunakan sensor cahaya Android: Kode lengkap
• Uji aplikasi sensor Android Anda yang lengkap
• Mengukur jarak, dengan sensor jarak Android
• Membuat antarmuka pengguna
• Mendapatkan data dari sensor jarak
• Pengujian: Seberapa dekat pengguna dengan perangkat mereka?
• Sensor gerak: Memproses array multidimensi
• Menampilkan data pitch and roll waktu nyata
• Menggunakan sensor vektor rotasi di aplikasi Anda
• 1. Gunakan TYPE_ROTATION_VECTOR
• 2. Terjemahkan data sensor
• 3. Perbarui string placeholder
• Menampilkan beberapa data sensor: Kode lengkap
• Menguji aplikasi sensor Android terakhir kami
• Membungkus

Saat ini, sebagian besar perangkat Android modern dilengkapi dengan sejumlah sensor.

Anda dapat menggunakan informasi ini dalam banyak cara yang berbeda - apakah itu memantau level cahaya sehingga aplikasi Anda dapat secara otomatis menyesuaikan kecerahan atau skema warnanya; memungkinkan pengguna untuk berinteraksi dengan game seluler Anda menggunakan gerakan seperti memiringkan perangkat mereka; atau menggunakan sensor proximity untuk secara otomatis menonaktifkan acara sentuh setiap kali pengguna memegang perangkat mereka di telinga mereka.

Dalam artikel ini, kami akan membuat tiga aplikasi yang mengambil data cahaya, kedekatan, dan gerak dari berbagai perangkat keras dan sensor perangkat lunak. Kami juga akan memonitor sensor Android ini secara real time, sehingga aplikasi Anda selalu memiliki akses ke informasi terbaru.

Pada akhir artikel ini, Anda akan tahu cara mengekstrak satu bagian data dari sensor Android, dan bagaimana menangani sensor yang menyediakan data mereka dalam bentuk array multidimensi.

Sensor Android apa yang dapat saya gunakan?

Sensor Android dapat dibagi ke dalam kategori berikut:

• Sensor lingkungan. Ini mengukur kondisi lingkungan, seperti suhu udara, tekanan, kelembaban dan tingkat cahaya sekitar.

• Sensor posisi. Kategori ini mencakup sensor yang mengukur posisi fisik perangkat, seperti sensor jarak dan sensor medan geomagnetik.
  Sensor gerak. Sensor ini mengukur gerakan perangkat, dan termasuk akselerometer, sensor gravitasi, giroskop, dan sensor vektor rotasi.

Selain itu, sensor dapat berupa:

• Berbasis perangkat keras. Ini adalah komponen fisik yang dibangun ke dalam perangkat dan secara langsung mengukur properti tertentu, seperti akselerasi atau kekuatan medan geomagnetik di sekitarnya.
• Berbasis perangkat lunak, kadang-kadang dikenal sebagai sensor virtual atau sensor komposit. Ini biasanya mengumpulkan data dari beberapa sensor berbasis perangkat keras. Menjelang akhir artikel ini, kami akan bekerja dengan sensor vektor rotasi, yang merupakan sensor perangkat lunak yang menggabungkan data dari accelerometer, magnetometer, dan giroskop perangkat.

Sensor lingkungan: Mengukur cahaya sekitar

Sensor cahaya Android mengukur cahaya sekitar dalam unit "lux", yang merupakan intensitas cahaya seperti yang dirasakan oleh mata manusia. Nilai lux yang dilaporkan oleh sensor dapat bervariasi antar perangkat, jadi jika aplikasi Anda membutuhkan nilai yang konsisten maka Anda mungkin perlu memanipulasi data mentah sebelum menggunakannya dalam aplikasi Anda.

Di bagian ini, kami akan membuat aplikasi yang mengambil nilai lux saat ini dari sensor cahaya perangkat, menampilkannya di TextView, dan kemudian memperbarui TextView saat data baru tersedia.Anda kemudian dapat menggunakan informasi ini dalam berbagai aplikasi, misalnya Anda dapat membuat aplikasi obor yang menarik informasi dari sensor cahaya dan kemudian secara otomatis menyesuaikan kekuatan pancarannya berdasarkan tingkat cahaya saat ini.

Buat proyek Android baru dengan pengaturan pilihan Anda, dan mari kita mulai!

Menampilkan data sensor Anda

Saya akan menambahkan TextView yang pada akhirnya akan menampilkan data yang telah kami ekstrak dari sensor cahaya. TextView ini akan memperbarui setiap kali data baru tersedia, sehingga pengguna selalu memiliki akses ke informasi terbaru.

Buka file activity_main.xml proyek Anda, dan tambahkan yang berikut:

Selanjutnya, kita perlu membuat sumber string “light_sensor” yang dirujuk dalam tata letak kita. Buka file strings.xml proyek Anda, dan tambahkan berikut ini:

Sensor Cahaya:% 1 $ .2f

"% 1 $ .2f" adalah placeholder yang menentukan informasi yang ingin kami tampilkan, dan bagaimana itu harus diformat:

• %1. Anda bisa memasukkan beberapa placeholder ke sumber daya string yang sama; "% 1" menunjukkan bahwa kami menggunakan satu placeholder.
• $.2. Ini menentukan bagaimana aplikasi kita harus memformat setiap nilai floating-point yang masuk. "$ .2" menunjukkan bahwa nilai harus dibulatkan ke dua tempat desimal.
• F. Memformat nilai sebagai angka floating-point.

Meskipun beberapa sensor lebih umum daripada yang lain, Anda tidak boleh berasumsi bahwa setiap perangkat memiliki akses ke perangkat keras dan perangkat lunak yang sama persis. Ketersediaan sensor bahkan dapat bervariasi di berbagai versi Android, karena beberapa sensor tidak diperkenalkan hingga rilis berikutnya dari platform Android.

Anda dapat memeriksa apakah ada sensor tertentu pada perangkat, menggunakan kerangka sensor Android. Anda kemudian dapat menonaktifkan atau mengaktifkan bagian-bagian aplikasi Anda berdasarkan ketersediaan sensor, atau Anda mungkin menampilkan penjelasan bahwa beberapa fitur aplikasi Anda tidak akan berfungsi seperti yang diharapkan.

Sementara file strings.xml dibuka, mari buat string "no_sensor", yang akan kami tampilkan jika sensor cahaya tidak tersedia:

Tidak ada sensor cahaya yang tersedia

Jika aplikasi Anda tidak dapat memberikan pengalaman pengguna yang baik tanpa memiliki akses ke sensor tertentu, maka Anda perlu menambahkan informasi ini ke Manifest Anda. Misalnya, jika aplikasi Anda memerlukan akses ke sensor kompas, maka Anda dapat menggunakan yang berikut ini:

Sekarang, aplikasi Anda hanya dapat diunduh ke perangkat yang memiliki sensor kompas.

Meskipun ini mungkin membatasi audiens Anda, itu jauh lebih merusak daripada membiarkan seseorang mengunduh aplikasi Anda ketika mereka terjamin memiliki pengalaman buruk, karena konfigurasi sensor perangkat mereka.

Berkomunikasi dengan sensor: SensorManager, SensorEvents, dan pendengar

Untuk berkomunikasi dengan sensor cahaya perangkat, Anda harus menyelesaikan langkah-langkah berikut:

1. Dapatkan instance dari SensorManager

SensorManager menyediakan semua metode yang Anda butuhkan untuk mengakses berbagai sensor perangkat.

Untuk memulai, buat variabel yang akan menyimpan instance dari SensorManager:

SensorManager pribadi lightSensorManager;

Kemudian, Anda perlu mendapatkan instance dari SensorManager, dengan memanggil metode Context.getSystemService dan meneruskan argumen Context.SENSOR_SERVICE:

lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE);

2. Dapatkan referensi ke lightTextView

Selanjutnya, kita perlu membuat variabel anggota pribadi yang akan menahan objek TextView kita, dan menetapkannya ke TextView kita:

textTextView lightTextView pribadi; ... ... ... lightTextView = (TextView) findViewById (R.id.lightTextView);

3. Periksa apakah sensor ada pada perangkat saat ini

Anda bisa mendapatkan akses ke sensor tertentu dengan memanggil metode getDefaultSensor (), dan kemudian meneruskannya sensor tersebut. Konstanta tipe untuk sensor cahaya adalah TYPE_LIGHT, jadi kita perlu menggunakan yang berikut:

lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT);

Jika sensor tidak ada pada perangkat ini, maka metode getDefaultSensor () akan mengembalikan nol, dan kami akan menampilkan string "no_sensor":

String sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_error); }}

4. Daftarkan pendengar sensor Anda

Setiap kali sensor memiliki data baru, Android menghasilkan objek SensorEvent. Objek SensorEvent ini mencakup sensor yang menghasilkan acara, stempel waktu, dan nilai data baru.

Awalnya, kami akan fokus pada sensor cahaya dan kedekatan, yang mengembalikan sepotong data. Namun, beberapa sensor menyediakan array multidimensi untuk setiap SensorEvent, termasuk sensor vektor rotasi, yang akan kami jelajahi menjelang akhir artikel ini.

Untuk memastikan aplikasi kami diberi tahu tentang objek SensorEvent ini, kami perlu mendaftarkan pendengar untuk acara sensor tertentu, menggunakan registerListener SensorManager ().

Metode registerListener () mengambil argumen berikut:

• Aplikasi atau Konteks Aktivitas.
• Jenis Sensor yang ingin Anda pantau.
• Tingkat di mana sensor harus mengirim data baru. Tingkat yang lebih tinggi akan memberikan aplikasi Anda lebih banyak data, tetapi itu juga akan menggunakan lebih banyak sumber daya sistem, terutama usia baterai. Untuk membantu menghemat baterai perangkat, Anda harus meminta jumlah data minimum yang diperlukan aplikasi Anda. Saya akan menggunakan SensorManager.SENSOR_DELAY_NORMAL, yang mengirimkan data baru setiap 200.000 mikrodetik (0,2 detik).

Karena mendengarkan sensor menguras baterai perangkat, Anda tidak boleh mendaftarkan pendengar dalam metode onCreate () aplikasi Anda, karena ini akan menyebabkan sensor untuk terus mengirim data, bahkan ketika aplikasi Anda berada di latar belakang.

Sebagai gantinya, Anda harus mendaftarkan sensor Anda di metode siklus hidup OnStart () aplikasi:

@Override void yang dilindungi onStart () {super.onStart (); // Jika sensor tersedia pada perangkat saat ini ... // jika (lightSensor! = Null) {//....kemudian mulai mendengarkan // lightSensorManager.registerListener (ini, lightSensor, SensorManager.SENSOR_DELAY_NORMAL); }}

5. Terapkan panggilan balik SensorEventListener

SensorEventListener adalah antarmuka yang menerima pemberitahuan dari SensorManager
kapan pun data baru tersedia, atau akurasi sensor berubah.

Langkah pertama, adalah memodifikasi tanda tangan kelas kami untuk mengimplementasikan antarmuka SensorEventListener:

MainActivity kelas publik memperluas AppCompatActivity mengimplementasikan SensorEventListener {

Kami kemudian perlu menerapkan metode panggilan balik berikut:

onSensorChanged ()

Metode ini disebut sebagai respons terhadap setiap SensorEvent baru.

Data sensor sering dapat berubah dengan cepat, sehingga aplikasi Anda mungkin memanggil metode onSensorChanged () secara teratur. Untuk membantu menjaga aplikasi Anda berjalan lancar, Anda harus melakukan pekerjaan sesedikit mungkin di dalam metode onSensorChanged ().

@Override public void onSensorChanged (SensorEvent sensorEvent) {// Aktivitas //}

padaAccuracyChanged ()

Jika keakuratan sensor meningkat atau menurun, maka Android akan memanggil metode onAccuracyChanged () dan memberikannya objek Sensor yang berisi nilai akurasi baru, seperti SENSOR_STATUS_UNRELIABLE atau SENSOR_STATUS_ACCURACY_HIGH.

Sensor cahaya tidak melaporkan keakuratan yang berubah, jadi saya akan membiarkan callback onAccuracyChanged () kosong:

@Override public void onAccuracyChanged (Sensor sensor, int i) {// To do //}}

6. Ambil nilai sensor

Setiap kali kita memiliki nilai baru, kita perlu memanggil metode onSensorChanged (), dan mengambil string "light_sensor". Kami kemudian dapat mengganti teks placeholder string (% 1 $ .2f) dan menampilkan string yang diperbarui sebagai bagian dari TextView kami:

@Override public void onSensorChanged (SensorEvent sensorEvent) {// Nilai terkini sensor // float currentValue = sensorEvent.values; // Ambil string "light_sensor", masukkan nilai baru dan tampilkan ke pengguna // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); }

7. Batalkan registrasi pendengar Anda

Sensor dapat menghasilkan data dalam jumlah besar dalam waktu yang sedikit, jadi untuk membantu melestarikan sumber daya perangkat Anda harus membatalkan registrasi pendengar Anda ketika mereka tidak lagi diperlukan.

Untuk berhenti mendengarkan acara sensor saat aplikasi Anda di latar belakang, tambahkan unregisterListener () ke metode siklus hidup onStop () proyek Anda:

@Override void yang dilindungi onStop () {super.onStop (); lightSensorManager.unregisterListener (ini); }

Perhatikan bahwa Anda tidak harus membatalkan registrasi pendengar Anda di onPause (), seperti pada Android 7.0 dan aplikasi yang lebih tinggi dapat berjalan dalam mode layar terbagi dan gambar-dalam-gambar, di mana mereka dalam keadaan jeda, tetapi tetap terlihat di layar.

Menggunakan sensor cahaya Android: Kode lengkap

Setelah menyelesaikan semua langkah di atas, MainActivity proyek Anda akan terlihat seperti ini:

impor android.support.v7.app.AppCompatActivity; impor android.os.Bundle; impor android.content.Context; impor android.hardware.Sensor; impor android.hardware.SensorEvent; impor android.hardware.SensorEventListener; impor android.hardware.SensorManager; impor android.widget.TextView; kelas publik MainActivity memperluas AppCompatActivity // Terapkan antarmuka SensorEventListener // mengimplementasikan SensorEventListener {// Buat variabel Anda // private Sensor lightSensor; SensorManager pribadi lightSensorManager; textTextView lightTextView pribadi; @Override void onCreate yang dilindungi (Bundle saverInstanceState) {super.onCreate (saverInstanceState); setContentView (R.layout.activity_main); lightTextView = (TextView) findViewById (R.id.lightTextView); // Dapatkan instance dari SensorManager // lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Periksa sensor cahaya // lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT); // Jika sensor cahaya tidak ada, maka tampilkan kesalahan // String sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_error); }} @Override void onStart () {super.onStart (); // Jika sensor tersedia pada perangkat saat ini ... // jika (lightSensor! = Null) {//....kemudian daftarkan pendengar // lightSensorManager.registerListener (ini, lightSensor, // Tentukan seberapa sering Anda ingin menerima data baru // SensorManager.SENSOR_DELAY_NORMAL); }} @Override void terlindungi onStop () {super.onStop (); // Batalkan registrasi pendengar Anda // lightSensorManager.unregisterListener (ini); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// Nilai saat ini dari sensor // float currentValue = sensorEvent.values; // Ambil string "light_sensor", masukkan nilai baru dan perbarui TextView // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); } @Override // Jika akurasi sensor berubah .... .// public void onAccuracyChanged (Sensor sensor, int i) {// TO DO //}}

Uji aplikasi sensor Android Anda yang lengkap

Untuk menguji aplikasi ini di smartphone atau tablet Android fisik:

• Instal proyek di perangkat Anda (dengan memilih "Run> Run" dari bilah alat Android Studio).
• Meskipun bervariasi antar perangkat, sensor cahaya sering terletak di kanan atas layar. Untuk memanipulasi tingkat cahaya, gerakkan perangkat Anda lebih dekat, dan kemudian menjauh dari sumber cahaya. Atau, Anda bisa mencoba menutupi perangkat dengan tangan Anda, untuk menghalangi cahaya. Nilai "Sensor Cahaya" harus naik dan turun, tergantung pada jumlah cahaya yang tersedia.

Jika Anda menggunakan Perangkat Virtual Android (AVD), maka emulator memiliki serangkaian kontrol sensor virtual yang dapat Anda gunakan untuk mensimulasikan berbagai peristiwa sensor. Anda mengakses kontrol sensor virtual ini, melalui jendela "Extended Controls" emulator:

• Instal aplikasi pada AVD Anda.
• Di samping AVD, Anda akan melihat potongan tombol. Temukan tombol “More” bertitik tiga (tempat kursor diposisikan pada tangkapan layar berikut) dan beri klik. Ini meluncurkan jendela "Kontrol Diperpanjang".

• Di menu sebelah kiri, pilih "Sensor virtual."
• Pilih tab "Sensor tambahan". Tab ini berisi berbagai bilah geser yang dapat Anda gunakan untuk mensimulasikan berbagai posisi dan peristiwa sensor lingkungan.

• Temukan slider "Light (lux)" dan seret ke kiri dan kanan, untuk mengubah level cahaya yang disimulasikan. Aplikasi Anda harus menampilkan nilai-nilai yang berubah ini, secara real time.

Anda dapat mengunduh proyek yang sudah selesai dari GitHub.

Mengukur jarak, dengan sensor jarak Android

Sekarang kita telah melihat cara mengambil informasi dari sensor lingkungan, mari kita lihat bagaimana Anda menerapkan pengetahuan ini ke posisi sensor.

Di bagian ini, kami akan menggunakan sensor kedekatan perangkat untuk memantau jarak antara ponsel cerdas atau tablet Anda, dan objek lainnya. Jika aplikasi Anda memiliki fungsionalitas suara apa pun, maka sensor proximity dapat membantu Anda menentukan kapan smartphone dipegang di telinga pengguna, misalnya saat mereka melakukan percakapan telepon. Anda kemudian dapat menggunakan informasi ini untuk menonaktifkan acara sentuh, sehingga pengguna tidak menutup telepon secara tidak sengaja, atau memicu acara lain yang tidak diinginkan di tengah percakapan.

Membuat antarmuka pengguna

Saya akan menampilkan data kedekatan di layar, sehingga Anda dapat menontonnya diperbarui secara waktu nyata. Untuk membantu menjaga hal-hal sederhana, mari gunakan kembali banyak tata letak dari aplikasi kami sebelumnya:

Selanjutnya, buka file strings.xml Anda dan buat string “proximity_sensor”. Sekali lagi, string ini harus berisi placeholder, yang pada akhirnya akan diisi oleh data yang diambil dari sensor proximity:

Sensor jarak Sensor Jarak:% 1 $ .2f Tidak ada sensor proximity yang tersedia

Mendapatkan data dari sensor jarak

Mirip dengan sensor cahaya, sensor jarak Android mengembalikan nilai data tunggal, yang berarti kita dapat menggunakan kembali banyak kode dari aplikasi kita sebelumnya. Namun, ada beberapa perbedaan besar, ditambah beberapa perubahan terkait nama yang membuat kode ini lebih mudah diikuti:

• Buat instance dari SensorManager, yang kali ini akan saya beri nama "proximitySensorManager."
• Dapatkan contoh "proximitySensorManager."
• Buat referensi ke "proximityTextView."
• Panggil metode getDefaultSensor (), dan berikan sensor TYPE_PROXIMITY.
• Daftarkan dan batalkan pendengar untuk sensor jarak.

Setelah melakukan tweak ini, Anda harus berakhir dengan yang berikut:

impor android.support.v7.app.AppCompatActivity; impor android.os.Bundle; impor android.content.Context; impor android.hardware.Sensor; impor android.hardware.SensorEvent; impor android.hardware.SensorManager; impor android.hardware.SensorEventListener; impor android.widget.TextView; kelas publik MainActivity memperluas AppCompatActivity // Terapkan antarmuka SensorEventListener // mengimplementasikan SensorEventListener {// Buat variabel Anda // Sensor pribadi proximitySensor; SensorManager proximitySensorManager pribadi; pribadi TextView proximityTextView; @Override void onCreate yang dilindungi (Bundle saverInstanceState) {super.onCreate (saverInstanceState); setContentView (R.layout.activity_main); proximityTextView = (TextView) findViewById (R.id.proximityTextView); // Dapatkan instance dari SensorManager // proximitySensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Periksa sensor proximity // proximitySensor = proximitySensorManager.getDefaultSensor (Sensor.TYPE_PROXIMITY); // Jika sensor proximity tidak ada, maka tampilkan kesalahan // String sensor_error = getResources (). GetString (R.string.no_sensor); if (proximitySensor == null) {proximityTextView.setText (sensor_error); }} @Override void onStart () {super.onStart (); // Jika sensor tersedia pada perangkat saat ini ... // jika (proximitySensor! = Null) {//....kemudian daftarkan pendengar // proximitySensorManager.registerListener (ini, proximitySensor, // Tentukan seberapa sering Anda ingin menerima data baru // SensorManager.SENSOR_DELAY_NORMAL); }} @Override void terlindungi onStop () {super.onStop (); // Batalkan registrasi pendengar Anda untuk melestarikan sumber daya sistem // proximitySensorManager.unregisterListener (ini); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// Nilai saat ini dari sensor // float currentValue = sensorEvent.values; // Ambil string "proximity_sensor", masukkan nilai baru dan perbarui TextView // proximityTextView.setText (getResources (). GetString (R.string.proximity_sensor, currentValue)); } @Override // Jika akurasi sensor berubah .... .// public void onAccuracyChanged (Sensor sensor, int i) {//...TO DO //}}

Pengujian: Seberapa dekat pengguna dengan perangkat mereka?

Untuk menguji aplikasi ini pada smartphone atau tablet Android fisik, instal aplikasi pada perangkat Anda dan kemudian bereksperimen dengan menggerakkan tangan Anda ke layar, lalu memindahkannya lagi. Nilai "Proximity Sensor" harus merekam gerakan Anda.

Perlu diketahui bahwa sensor jarak dapat bervariasi antar perangkat. Beberapa perangkat hanya dapat menampilkan dua nilai kedekatan - satu untuk menunjukkan "Dekat" dan satu untuk menunjukkan "Jauh" - jadi jangan heran jika Anda tidak melihat banyak variasi di perangkat Android fisik Anda.

Untuk menguji aplikasi ini pada emulator:

• Instal aplikasi Anda pada AVD.
• Temukan tombol "Lainnya" tiga titik dan beri klik, yang meluncurkan jendela "Kontrol Diperpanjang".
• Di menu sebelah kiri jendela, pilih "Sensor virtual."
• Pilih tab "Sensor tambahan".
• Temukan slider “Proximity”, dan seret ke kiri dan kanan untuk meniru objek yang bergerak lebih dekat ke perangkat, dan kemudian semakin jauh. Nilai "Proximity Sensor" harus berubah, saat Anda memanipulasi slider.

Anda dapat mengunduh proyek yang sudah selesai dari GitHub.

Sensor gerak: Memproses array multidimensi

Hingga saat ini, kami fokus pada sensor yang memasok satu item data, tetapi ada beberapa sensor yang menyediakan array multidimensi untuk setiap SensorEvent. Sensor multidimensi ini mencakup sensor gerak, yang akan kami fokuskan pada bagian akhir ini.

Sensor gerak dapat membantu Anda:

• Berikan metode alternatif input pengguna. Misalnya, jika Anda mengembangkan game seluler maka pengguna dapat memindahkan karakter mereka di layar dengan memiringkan perangkat mereka.
• Libatkan aktivitas pengguna. Jika Anda membuat aplikasi pelacakan aktivitas, maka sensor gerak dapat membantu Anda mengukur apakah pengguna bepergian dengan mobil, jogging, atau duduk di meja mereka.
• Lebih akurat menentukan orientasi.Dimungkinkan untuk mengekstrak koordinat dari sensor gerak perangkat, dan kemudian menerjemahkannya berdasarkan sistem koordinat Bumi, untuk mendapatkan wawasan paling akurat tentang orientasi perangkat saat ini.

Di bagian akhir ini, kita akan menggunakan sensor vektor rotasi (TYPE_ROTATION_VECTOR). Berbeda dengan sensor cahaya dan jarak, ini adalah sensor perangkat lunak yang mengumpulkan data dari sensor accelerometer, magnetometer, dan giroskop perangkat. Meskipun bekerja dengan sensor ini sering mengharuskan Anda untuk melakukan konversi dan transformasi matematis, itu juga dapat memberi Anda serangkaian informasi yang sangat akurat tentang perangkat.

Kami akan membuat aplikasi yang menggunakan sensor vektor rotasi untuk mengukur:

• Nada. Ini adalah kemiringan perangkat dari atas ke bawah.
• Gulungan. Ini adalah kemiringan kiri ke kanan perangkat.

Menampilkan data pitch and roll waktu nyata

Karena kami mengukur dua metrik, kami perlu membuat dua TextViews dan dua sumber string yang sesuai:

Buka file strings.xml, dan tambahkan berikut ini:

Sensor gerak Sensor Pitch:% 1 $ .2f Sensor Roll:% 1 $ .2f Tidak ada sensor gerak yang tersedia

Menggunakan sensor vektor rotasi di aplikasi Anda

Kami akan menggunakan kembali beberapa kode dari aplikasi kami sebelumnya, jadi mari kita fokus pada area di mana berkomunikasi dengan sensor vektor rotasi, sangat berbeda dengan apa yang telah kita lihat sebelumnya.

1. Gunakan TYPE_ROTATION_VECTOR

Karena kami bekerja dengan sensor vektor rotasi, kami perlu memanggil metode getDefaultSensor (), dan meneruskannya konstanta TYPE_ROTATION_VECTOR:

positionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR);

2. Terjemahkan data sensor

Berbeda dengan sensor kedekatan dan cahaya sebelumnya, sensor gerak mengembalikan susunan nilai sensor multidimensi untuk setiap SensorEvent. Nilai-nilai ini diformat menggunakan sistem koordinat "X, Y, Z" standar, yang dihitung relatif terhadap perangkat ketika dipegang dalam orientasi default, "alami".

Android tidak mengubah koordinat X, Y, dan Z ini untuk menyesuaikan dengan orientasi perangkat saat ini, sehingga sumbu "X" akan tetap sama terlepas dari apakah perangkat berada dalam mode potret atau lanskap. Saat menggunakan sensor vektor rotasi, Anda mungkin perlu mengonversi data yang masuk agar cocok dengan rotasi perangkat saat ini.

Potret adalah orientasi default untuk sebagian besar ponsel cerdas, tetapi Anda tidak boleh menganggap ini akan menjadi kasus untuk semua Perangkat Android, khususnya tablet. Dalam artikel ini, kami akan menggunakan matriks rotasi untuk menerjemahkan data sensor dari aslinya, alat sistem koordinat, ke Bumi sistem koordinat, yang mewakili gerakan dan posisi perangkat relatif terhadap Bumi. Jika diperlukan, kami dapat memetakan kembali data sensor, berdasarkan orientasi perangkat saat ini.

Pertama, sistem koordinat perangkat adalah sistem koordinat 3-sumbu X, Y, Z standar, di mana setiap titik pada masing-masing dari ketiga sumbu diwakili oleh vektor 3D. Ini berarti kita perlu membuat array 9 nilai float:

float rotatingmatrix = float baru;

Kami kemudian dapat meneruskan array ini ke metode getRotationMatrix ():

SensorManager.getRotationMatrixFromVector (rotasiMatrix, vektor); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z;

Langkah selanjutnya, menggunakan metode SensorManager.remapCoordinateSystem () untuk memetakan ulang data sensor, berdasarkan pada orientasi perangkat saat ini.

Metode SensorManager.remapCoordinateSystem () mengambil argumen berikut:

• Matriks rotasi asli.
• Sumbu yang ingin Anda remap.
• Array yang Anda isi dengan data baru ini.

Inilah kode yang akan saya gunakan di aplikasi saya:

float customizedRotationMatrix = float baru; SensorManager.remapCoordinateSystem (rotasiMatrix, worldAxisX, worldAxisZ, customizedRotationMatrix);

Akhirnya, kami akan memanggil SensorManager.getOrientation dan memberitahunya untuk menggunakan customizedRotationMatrix:

SensorManager.getOrientation (customizedRotationMatrix, orientasi);

3. Perbarui string placeholder

Karena kami memiliki dua set data (pitch and roll), kami perlu mengambil dua string placeholder yang terpisah, mengisinya dengan nilai yang benar, dan kemudian memperbarui TextView yang sesuai:

pitchTextView.setText (getResources (). getString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll));

Menampilkan beberapa data sensor: Kode lengkap

Setelah melakukan langkah-langkah di atas, MainActivity Anda akan terlihat seperti ini:

impor android.app.Aktivitas; impor android.os.Bundle; impor android.hardware.Sensor; impor android.hardware.SensorEvent; impor android.hardware.SensorEventListener; impor android.hardware.SensorManager; impor android.widget.TextView; MainActivity kelas publik memperluas Activity mengimplementasikan SensorEventListener {private SensorManager motionSensorManager; Sensor Sensor gerak pribadi; pitchTextView TextView pribadi; rollTextView TextView pribadi; SENSOR_DELAY int akhir statis pribadi = 500 * 1000; FROM_RADS_TO_DEGS int akhir statis pribadi = -57; @Override void onCreate yang dilindungi (Bundle saverInstanceState) {super.onCreate (saverInstanceState); setContentView (R.layout.activity_main); pitchTextView = (TextView) findViewById (R.id.pitchTextView); rollTextView = (TextView) findViewById (R.id.rollTextView); coba {motionSensorManager = (SensorManager) getSystemService (Activity.SENSOR_SERVICE); motionSensor = motionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR); motionSensorManager.registerListener (ini, motionSensor, SENSOR_DELAY); } catch (Exception e) {pitchTextView.setText (R.string.no_sensor); rollTextView.setText (R.string.no_sensor); }} @Override public void onAccuracyChanged (Sensor sensor, akurasi int) {// Untuk melakukan //} @Override public void onSensorChanged (event SensorEvent) {if (event.sensor == motionSensor) {update (event.values); }} pembaruan void pribadi (vektor float) {// Hitung matriks rotasi // float rotatingmatrix = float baru; SensorManager.getRotationMatrixFromVector (rotasiMatrix, vektor); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z; // Remap matriks berdasarkan orientasi Aktivitas saat ini // float customizedRotationMatrix = float baru; SensorManager.remapCoordinateSystem (rotasiMatrix, worldAxisX, worldAxisZ, customizedRotationMatrix); // Hitung orientasi perangkat // orientasi float = float baru; // Sediakan larik nilai float ke metode getOrientation () // SensorManager.getOrientation (customizedRotationMatrix, orientasi); pitch float = orientasi * FROM_RADS_TO_DEGS; float roll = orientasi * FROM_RADS_TO_DEGS; // Perbarui TextViews dengan nilai pitch and roll // pitchTextView.setText (getResources (). GetString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll)); }}

Anda dapat mengunduh proyek yang sudah selesai dari GitHub.

Menguji aplikasi sensor Android terakhir kami

Untuk menguji aplikasi sensor vektor Android rotasi ini pada smartphone atau tablet Android fisik:

• Instal aplikasi di perangkat Anda.
• Tempatkan ponsel cerdas atau tablet Anda di permukaan yang rata. Perhatikan bahwa sensor gerak sangat peka, sehingga tidak aneh jika perangkat yang tampaknya tidak bergerak melaporkan fluktuasi nilai pitch and roll.
• Untuk menguji nada, angkat bagian bawah perangkat Anda sehingga miring menjauh dari Anda. Nilai nada harus berubah secara dramatis.
• Untuk menguji gulungan, coba angkat sisi kiri perangkat Anda, sehingga miring ke kiri - perhatikan nilai gulungan itu!

Jika Anda menguji proyek Anda pada emulator:

• Instal aplikasi pada AVD Anda.
• Pilih "Lainnya," yang meluncurkan jendela "Kontrol Diperpanjang".
• Di menu sebelah kiri, pilih "Sensor virtual."
• Pastikan tab "Accelerometer" dipilih. Tab ini berisi kontrol yang dapat mensimulasikan perubahan posisi dan orientasi perangkat.
• Coba bereksperimen dengan berbagai bilah geser (Putar: Z-Rot, X-Rot, Y-Rot; dan Pindahkan: X, Y, dan Z) dan berbagai tombol "Rotasi Perangkat", untuk melihat bagaimana pengaruhnya terhadap "Roll Sensor" aplikasi Anda. "Dan" Sensor Pitch "nilai.

Membungkus

Pada artikel ini, kami melihat cara mengambil data dari tiga kategori utama sensor Android: lingkungan, posisi dan gerakan, dan cara memantau data ini secara real time.

Pernahkah Anda melihat aplikasi Android yang menggunakan sensor dengan cara yang menarik atau unik? Beri tahu kami di komentar di bawah!