Kandungan

• Apakah sensor Android yang boleh saya gunakan?
• Sensor alam sekitar: Mengukur cahaya ambien
• Memaparkan data sensor anda
• Berkomunikasi dengan sensor: SensorManager, SensorEvents, dan pendengar
• 1. Dapatkan contoh SensorManager
• 2. Dapatkan rujukan kepada lightTextView
• 3. Semak sama ada sensor wujud pada peranti semasa
• 4. Mendaftarkan pendengar sensor anda
• 5. Laksanakan panggilan balik SensorEventListener
• onSensorChanged ()
• onAccuracyChanged ()
• 6. Dapatkan semula nilai sensor
• 7. Mendaftarkan pendengar anda
• Menggunakan penderia cahaya Android: Kod siap
• Uji apl sensor Android anda yang lengkap
• Mengukur jarak, dengan penderia jarak dekat Android
• Mewujudkan antara muka pengguna
• Mendapatkan data dari sensor jarak
• Ujian: Seberapa dekat pengguna ke peranti mereka?
• Sensor gerakan: Memproses tatasusunan multidimensi
• Memaparkan data masa nyata dan data roll
• Menggunakan sensor vektor putaran dalam aplikasi anda
• 1. Gunakan TYPE_ROTATION_VECTOR
• 2. Terjemah data sensor
• 3. Kemas kini tali pemegang tempat
• Memaparkan pelbagai data sensor: Kod siap
• Menguji permohonan sensor Android terakhir kami
• Mengakhiri

Hari ini, peranti Android yang paling moden dilepaskan dengan sekumpulan sensor.

Anda boleh menggunakan maklumat ini dalam banyak cara yang berbeza - sama ada ia memantau tahap cahaya supaya aplikasi anda secara automatik boleh menyesuaikan kecerahan atau skema warna; membolehkan pengguna berinteraksi dengan permainan mudah alih anda menggunakan gerak isyarat seperti menyengetkan peranti mereka; atau menggunakan sensor jarak untuk menyahaktifkan acara sentuhan secara automatik apabila pengguna memegang peranti mereka ke telinga mereka.

Dalam artikel ini, kami akan membuat tiga aplikasi yang mengambil data cahaya, kedekatan dan gerakan dari pelbagai sensor perkakasan dan perisian. Kami juga akan memantau sensor Android ini dalam masa nyata, jadi aplikasi anda sentiasa mempunyai akses kepada maklumat terkini.

Menjelang akhir artikel ini, anda akan tahu cara mengekstrak sekeping data dari sensor Android, dan bagaimana mengendalikan sensor yang menyediakan data mereka dalam bentuk pelbagai multidimensi.

Apakah sensor Android yang boleh saya gunakan?

Sensor Android boleh dibahagikan kepada kategori berikut:

• Sensor persekitaran. Ini mengukur keadaan alam sekitar, seperti suhu udara, tekanan, kelembapan dan tahap cahaya ambien.

• Sensor kedudukan. Kategori ini termasuk sensor yang mengukur kedudukan fizikal peranti, seperti sensor jarak dan sensor medan geomagnetik.
  Sensor pergerakan. Sensor ini mengukur pergerakan peranti, dan termasuk pecutan, sensor graviti, gyroscopes, dan sensor vektor putaran.

Di samping itu, penderia boleh sama ada:

• Perkakasan berasaskan. Ini adalah komponen fizikal yang dibina ke dalam peranti dan secara langsung mengukur sifat tertentu, seperti pecutan atau kekuatan medan geomagnetik di sekelilingnya.
• Perisian berasaskan, kadangkala dikenali sebagai sensor maya atau sensor komposit. Ini biasanya menyusun data dari pelbagai sensor berasaskan perkakasan. Menjelang akhir artikel ini, kami akan bekerjasama dengan sensor vektor putaran, yang merupakan sensor perisian yang menggabungkan data dari pecutan, magnetometer, dan giroskop peranti.

Sensor alam sekitar: Mengukur cahaya ambien

Pengesan cahaya Android mengukur cahaya sekeliling dalam unit "lux", yang merupakan intensiti cahaya yang dilihat oleh mata manusia. Nilai lux yang dilaporkan oleh sensor boleh berbeza mengikut peranti, jadi jika aplikasi anda memerlukan nilai-nilai yang konsisten maka anda mungkin perlu memanipulasi data mentah sebelum menggunakannya dalam aplikasi anda.

Dalam bahagian ini, kami akan membuat aplikasi yang mengambil nilai lux semasa dari sensor cahaya peranti, memaparkannya dalam TextView, dan kemudian mengemas kini TextView sebagai data baru tersedia.Anda kemudiannya boleh menggunakan maklumat ini dalam pelbagai aplikasi, misalnya anda mungkin membuat aplikasi obor yang menarik maklumat dari sensor cahaya dan kemudian secara automatik menyesuaikan kekuatan rasuknya berdasarkan tahap cahaya semasa.

Buat projek Android baharu dengan tetapan pilihan anda, dan mari bermula!

Memaparkan data sensor anda

Saya akan menambah TextView yang akhirnya akan memaparkan data yang kami telah diekstrak dari sensor cahaya. TextView ini akan dikemas kini apabila data baru tersedia, jadi pengguna sentiasa mempunyai akses kepada maklumat terkini.

Buka fail activity_main.xml anda, dan tambahkan yang berikut:

Seterusnya, kami perlu mencipta sumber rentetan "light_sensor" yang dirujuk dalam susun atur kami. Buka fail strings.xml projek anda, dan tambahkan yang berikut:

Sensor Cahaya:% 1 $ .2f

"% 1 $ .2f" adalah pemegang tempat yang menentukan maklumat yang ingin kami paparkan dan bagaimana ia harus diformat:

• %1. Anda boleh memasukkan beberapa ruang letak ke dalam sumber rentetan yang sama; "% 1" menunjukkan bahawa kami menggunakan placeholder tunggal.
• $.2. Ini menentukan bagaimana aplikasi kami perlu memformatkan setiap nilai terapung yang masuk. "$ .2" menunjukkan bahawa nilai harus dibulatkan ke dua tempat perpuluhan.
• F. Format nilai sebagai nombor terapung.

Walaupun beberapa sensor lebih biasa daripada yang lain, anda tidak boleh menganggap bahawa setiap peranti mempunyai akses kepada perkakasan dan perisian yang sama. Ketersediaan sensor mungkin juga berbeza-beza mengikut versi Android yang berbeza, kerana beberapa sensor tidak diperkenalkan hingga keluaran akhir platform Android.

Anda boleh menyemak sama ada sensor tertentu ada pada peranti, menggunakan rangka kerja sensor Android. Anda kemudian boleh menyahdayakan atau membolehkan bahagian aplikasi anda berdasarkan ketersediaan sensor, atau anda mungkin memaparkan menjelaskan bahawa beberapa ciri aplikasi anda tidak akan berfungsi seperti yang diharapkan.

Walaupun kami mempunyai fail strings.xml kami terbuka, mari kita buat rentetan "no_sensor", yang akan kami paparkan jika sensor cahaya tidak tersedia:

Tiada sensor cahaya tersedia

Jika aplikasi anda tidak dapat memberikan pengalaman pengguna yang baik tanpa akses kepada sensor tertentu, maka anda perlu menambahkan maklumat ini ke Manifes anda. Contohnya, jika aplikasi anda memerlukan akses kepada sensor kompas, maka anda boleh menggunakan yang berikut:

Sekarang, aplikasi anda hanya boleh dimuat turun ke peranti yang mempunyai sensor kompas.

Walaupun ini mungkin mengehadkan khalayak anda, ia jauh lebih merosakkan daripada membenarkan seseorang memuat turun aplikasi anda apabila mereka berada dijamin untuk mengalami pengalaman buruk, kerana konfigurasi sensor peranti mereka.

Berkomunikasi dengan sensor: SensorManager, SensorEvents, dan pendengar

Untuk berkomunikasi dengan sensor cahaya peranti, anda perlu melengkapkan langkah-langkah berikut:

1. Dapatkan contoh SensorManager

SensorManager menyediakan semua kaedah yang anda perlukan untuk mengakses pelbagai sensor peranti.

Untuk memulakan, buat pemboleh ubah yang akan memegang satu contoh SensorManager:

SensorManager swasta lightSensorManager;

Kemudian, anda perlu mendapatkan contoh SensorManager, dengan memanggil kaedah Context.getSystemService dan lulus dalam argumen Context.SENSOR_SERVICE:

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

2. Dapatkan rujukan kepada lightTextView

Seterusnya, kita perlu membuat pemboleh ubah peribadi yang akan memegang objek TextView kami, dan memberikannya kepada TextView kami:

peribadi TextView lightTextView; ... ... ... lightTextView = (TextView) findViewById (R.id.lightTextView);

3. Semak sama ada sensor wujud pada peranti semasa

Anda boleh mendapatkan akses kepada sensor tertentu dengan menghubungi kaedah getDefaultSensor (), dan kemudian lulus sensor yang dipersoalkan. Pemalar jenis untuk sensor cahaya adalah TYPE_LIGHT, jadi kita perlu menggunakan yang berikut:

lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT);

Sekiranya sensor tidak wujud pada peranti ini, maka kaedah getDefaultSensor () akan kembali null, dan kami akan memaparkan rentetan "no_sensor":

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

4. Mendaftarkan pendengar sensor anda

Setiap kali sensor mempunyai data baru, Android menghasilkan objek SensorEvent. Objek SensorEvent ini termasuk sensor yang menjana peristiwa, cap waktu, dan nilai data baru.

Pada mulanya, kami akan memberi tumpuan kepada penderia cahaya dan kedekatan, yang mengembalikan sekeping data. Walau bagaimanapun, sesetengah sensor menyediakan array multidimensi untuk setiap SensorEvent, termasuk sensor vektor giliran, yang akan kita pelajari ke arah akhir artikel ini.

Untuk memastikan permohonan kami dimaklumkan mengenai objek SensorEvent ini, kami perlu mendaftarkan pendengar untuk acara sensor tertentu, menggunakan registerListener SensorManager ().

Kaedah registerListener () mengambil argumen berikut:

• Konteks aplikasi atau Aktiviti.
• Jenis Sensor yang anda mahu memantau.
• Kadar di mana sensor perlu menghantar data baru. Kadar yang lebih tinggi akan menyediakan aplikasi anda dengan lebih banyak data, tetapi ia juga akan menggunakan lebih banyak sumber sistem, terutama bateri. Untuk membantu memelihara bateri peranti, anda harus meminta jumlah minimum data yang diperlukan oleh aplikasi anda. Saya akan menggunakan SensorManager.SENSOR_DELAY_NORMAL, yang menghantar data baru sekali setiap 200,000 mikrodetik (0.2 saat).

Oleh kerana mendengar sensor mengalirkan bateri peranti, anda tidak sepatutnya mendaftarkan pendengar dalam kaedah onCreate () aplikasi anda, kerana ini akan menyebabkan sensor untuk terus menghantar data, walaupun aplikasi anda berada di latar belakang.

Sebaliknya, anda perlu mendaftarkan sensor anda dalam kaedah hidup kitaran onStart () aplikasi:

@Override dilindungi tidak sah onStart () {super.onStart (); // Jika sensor boleh didapati pada peranti semasa ... / // if (lightSensor! = Null) {//....then start listening // lightSensorManager.registerListener (this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL); }}

5. Laksanakan panggilan balik SensorEventListener

SensorEventListener adalah antara muka yang menerima pemberitahuan dari SensorManager
setiap kali data baru tersedia, atau perubahan ketepatan sensor.

Langkah pertama, mengubah suai kelas kami untuk melaksanakan antara muka SensorEventListener:

MainActivity kelas awam memanjangkan AppCompatActivity melaksanakan SensorEventListener {

Kami kemudiannya perlu melaksanakan kaedah panggilan balik berikut:

onSensorChanged ()

Kaedah ini dipanggil sebagai respons kepada setiap SensorEvent baru.

Data sensor sering boleh berubah dengan cepat, jadi aplikasi anda mungkin memanggil kaedah onSensorChanged () secara teratur. Untuk membantu memastikan aplikasi anda berjalan dengan lancar, anda harus melakukan sedikit kerja yang mungkin di dalam kaedah onSensorChanged ().

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

onAccuracyChanged ()

Jika ketepatan sensor meningkatkan atau menurun, maka Android akan memanggil kaedah onAccuracyChanged () dan menyerahkan objek Sensor yang mengandungi nilai ketepatan baru, seperti SENSOR_STATUS_UNRELIABLE atau SENSOR_STATUS_ACCURACY_HIGH.

Sensor cahaya tidak melaporkan perubahan ketepatan, jadi saya akan meninggalkan panggilan balikAccuracyChanged () pada kosong:

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

6. Dapatkan semula nilai sensor

Setiap kali kita mempunyai nilai baru, kita perlu memanggil kaedah onSensorChanged (), dan mendapatkan rentetan "light_sensor". Kita kemudian boleh menimpa teks pemegang tempat rentetan (% 1 $ .2f) dan memaparkan rentetan yang dikemas kini sebagai sebahagian daripada TextView kami:

@Override public void onSensorChanged (SensorEvent sensorEvent) {// Nilai semasa sensor // float currentValue = sensorEvent.values; // Dapatkan rentetan "light_sensor", masukkan nilai baru dan paparkannya kepada user // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); }

7. Mendaftarkan pendengar anda

Sensor boleh menghasilkan sejumlah besar data dalam sedikit masa, jadi untuk membantu memelihara sumber daya peranti yang anda perlukan untuk mendaftarkan pendengar anda apabila mereka tidak lagi diperlukan.

Untuk berhenti mendengarkan peristiwa sensor apabila aplikasi anda berada di latar belakang, tambahkan unregisterListener () ke kaedah hidup kitaran onStop () projek anda:

@Override dilindungi tidak sah onStop () {super.onStop (); lightSensorManager.unregisterListener (ini); }

Ambil perhatian bahawa anda tidak sepatutnya tidak mendaftarkan pendengar anda pada onPause (), seperti dalam Android 7.0 dan aplikasi yang lebih tinggi boleh berjalan dalam mod split-screen dan gambar-dalam-gambar, di mana mereka berada dalam keadaan dijeda, tetapi tetap kelihatan di skrin.

Menggunakan penderia cahaya Android: Kod siap

Selepas menyelesaikan semua langkah di atas, MainActivity projek anda harus kelihatan seperti ini:

import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.content.Context; import android.hardware.Sensor; import android.hardware.SensorEvent; import android.hardware.SensorEventListener; import android.hardware.SensorManager; import android.widget.TextView; MainActivity kelas awam meluaskan AppCompatActivity // Melaksanakan antaramuka SensorEventListener // melaksanakan SensorEventListener {// Buat pemboleh ubah anda // private Sensor lightSensor; SensorManager swasta lightSensorManager; peribadi TextView lightTextView; @Override dilindungi tidak sah onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); lightTextView = (TextView) findViewById (R.id.lightTextView); // Dapatkan contoh SensorManager // lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); / / Periksa sensor cahaya // lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT); // Jika sensor cahaya tidak wujud, kemudian tunjukkan ralat // String sensor_error = getResources (). GetString (R.string.no_sensor); jika (lightSensor == null) {lightTextView.setText (sensor_error); }} @Override void protected onStart () {super.onStart (); // Jika sensor boleh didapati pada peranti semasa ... / // jika (lightSensor! = Null) {/ / selepas mendaftarkan pendengar // lightSensorManager.registerListener (ini, lightSensor, / / ​​Nyatakan seberapa sering anda ingin menerima data baru // SensorManager.SENSOR_DELAY_NORMAL); }} @Override void protected onStop () {super.onStop (); // Tidak mendaftar pendengar anda // lightSensorManager.unregisterListener (ini); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// Nilai semasa sensor // float currentValue = sensorEvent.values; // Dapatkan rentetan "light_sensor", masukkan nilai baru dan kemas kini TextView // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); } @Orrrr // Jika perubahan ketepatan sensor ... .// ketiadaan awam padaAccuracyChanged (sensor Sensor, int i) {// TO DO //}}

Uji apl sensor Android anda yang lengkap

Untuk menguji aplikasi ini pada telefon pintar Android atau tablet fizikal:

• Pasang projek pada peranti anda (dengan memilih "Run> Run" dari bar alat Android Studio).
• Walaupun ia berbeza-beza antara peranti, sensor cahaya sering terletak di sebelah kanan sebelah atas skrin. Untuk memanipulasi tahap cahaya, gerakkan peranti anda lebih dekat, dan kemudian jauh dari sumber cahaya. Sebagai alternatif, anda boleh mencuba melindungi peranti dengan tangan anda, untuk menghalang cahaya. Nilai "Sensor Cahaya" perlu meningkat dan berkurang, bergantung kepada jumlah cahaya yang ada.

Jika anda menggunakan Peranti Maya Maya (AVD), maka emulator mempunyai satu set kawalan sensor maya yang boleh anda gunakan untuk mensimulasikan pelbagai peristiwa sensor. Anda mengakses kawalan sensor maya ini, melalui tetingkap "Kawalan Lanjutan" emulator:

• Pasang aplikasi pada AVD anda.
• Di samping AVD, anda akan melihat butang jalur. Cari butang "Lagi" yang bertitik (di mana kursor berada dalam tangkapan skrin berikut) dan berikan satu klik. Ini melancarkan tetingkap "Kawalan Lanjutan".

• Dalam menu sebelah kiri, pilih "Sensor Maya."
• Pilih "Sensor tambahan" tab. Tab ini mengandungi pelbagai slider yang boleh anda gunakan untuk mensimulasikan kedudukan yang berbeza dan kejadian sensor alam sekitar.

• Cari "slider Light (lux)" dan seretnya ke kiri dan ke kanan, untuk mengubah tahap cahaya simulasi. Aplikasi anda harus memaparkan nilai-nilai yang berubah ini, dalam masa nyata.

Anda boleh memuat turun projek yang telah siap dari GitHub.

Mengukur jarak, dengan penderia jarak dekat Android

Sekarang kita telah melihat bagaimana untuk mendapatkan maklumat dari sensor alam sekitar, mari kita melihat bagaimana anda akan menggunakan pengetahuan ini kepada a kedudukan sensor.

Dalam bahagian ini, kami akan menggunakan sensor kedekatan peranti untuk memantau jarak antara telefon pintar atau tablet anda, dan objek lain. Jika aplikasi anda mempunyai apa-apa jenis fungsi suara, maka sensor kedekatan boleh membantu anda menentukan apabila telefon pintar itu diadakan ke telinga pengguna, contohnya apabila mereka mempunyai perbualan telefon. Anda kemudian boleh menggunakan maklumat ini untuk melumpuhkan acara sentuh, jadi pengguna tidak sengaja menggantung, atau memicu peristiwa lain yang tidak dikehendaki di pertengahan perbualan.

Mewujudkan antara muka pengguna

Saya akan memaparkan data kedekatan pada skrin, supaya anda boleh menontonnya dikemas dalam masa nyata. Untuk membantu memastikan perkara mudah, mari menggunakan semula susun atur daripada aplikasi terdahulu:

Seterusnya, buka fail strings.xml anda dan buat rentetan "proximity_sensor". Sekali lagi, rentetan ini perlu mengandungi placeholder, yang akhirnya akan dihuni oleh data yang diekstrak dari sensor jarak:

Sensor jarak Sensor Jarak:% 1 $ .2f Tiada sensor jarak tersedia

Mendapatkan data dari sensor jarak

Sama dengan sensor cahaya, sensor jarak Android mengembalikan nilai data tunggal, yang bermaksud kita boleh menggunakan semula banyak kod dari aplikasi terdahulu kami. Walau bagaimanapun, terdapat beberapa perbezaan utama, ditambah beberapa perubahan nama yang membuat kod ini lebih mudah untuk diikuti:

• Buat contoh SensorManager, yang kali ini saya akan namakan "proximitySensorManager."
• Dapatkan contoh "proximitySensorManager".
• Buat rujukan kepada "proximityTextView."
• Hubungi kaedah getDefaultSensor (), dan lulus sensor TYPE_PROXIMITY.
• Mendaftarkan dan menyalahi pendengar untuk penderia jarak dekat.

Setelah membuat tweak ini, anda harus mematuhi yang berikut:

import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.content.Context; import android.hardware.Sensor; import android.hardware.SensorEvent; import android.hardware.SensorManager; import android.hardware.SensorEventListener; import android.widget.TextView; MainActivity kelas awam meluaskan AppCompatActivity // Melaksanakan antaramuka SensorEventListener // melaksanakan SensorEventListener {// Buat pemboleh ubah anda // proximity Sensor privateSensor; SensorManager proximitySensorManager swasta; peribadi TextView berdekatanTextView; @Override dilindungi tidak sah onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); proximityTextView = (TextView) findViewById (R.id.proximityTextView); // Dapatkan contoh SensorManager // proximitySensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); / / Periksa sensor kedekatan // proximitySensor = proximitySensorManager.getDefaultSensor (Sensor.TYPE_PROXIMITY); // Jika sensor kedekatan tidak wujud, kemudian tunjukkan ralat // String sensor_error = getResources (). GetString (R.string.no_sensor); jika (proximitySensor == null) {proximityTextView.setText (sensor_error); }} @Override void protected onStart () {super.onStart (); // Jika sensor boleh didapati pada peranti semasa ... // if (proximitySensor! = Null) {//. Mendaftarkan pendengar // proximitySensorManager.registerListener (this, proximitySensor, // Tentukan seberapa sering anda ingin menerima data baru // SensorManager.SENSOR_DELAY_NORMAL); }} @Override void protected onStop () {super.onStop (); // Tidak mendaftar pendengar anda untuk mengekalkan sumber sistem // proximitySensorManager.unregisterListener (ini); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// Nilai semasa sensor // float currentValue = sensorEvent.values; // Mendapatkan rentetan "proximity_sensor", masukkan nilai baru dan kemas kini TextView // proximityTextView.setText (getResources (). GetString (R.string.proximity_sensor, currentValue)); } @Override // Jika ketepatan sensor berubah ... .// Ketidaksuaian awam padaAccuracyChanged (Sensor sensor, int i) {//...TO DO //}}

Ujian: Seberapa dekat pengguna ke peranti mereka?

Untuk meletakkan aplikasi ini pada ujian pada telefon pintar Android atau tablet fizikal, pasangkan aplikasi pada peranti anda dan kemudian percubaan dengan menggerakkan tangan anda ke arah skrin, dan kemudian memindahkannya lagi. Nilai "Sensor Jarak" harus mencatatkan pergerakan anda.

Hanya sedar bahawa sensor jarak boleh berbeza antara peranti. Sesetengah peranti hanya boleh memaparkan dua nilai kedekatan - satu untuk menunjukkan "Berdekatan" dan satu untuk menunjukkan "Jauh" - jadi jangan terkejut jika anda tidak melihat banyak variasi pada peranti Android fizikal anda.

Untuk menguji aplikasi ini pada emulator:

• Pasang aplikasi anda pada AVD.
• Cari butang "Lebih Lagi" tiga dan berikan satu klik, yang melancarkan tetingkap "Kawalan Extended".
• Di menu sebelah kiri tetingkap, pilih "Sensor Maya."
• Pilih "Sensor tambahan" tab.
• Cari slider "Jarak", dan seretnya ke kiri dan ke kanan untuk meniru objek yang bergerak lebih dekat ke peranti, dan kemudian jauh lagi. Nilai "Sensor Jarak" harus berubah, ketika anda memanipulasi slider.

Anda boleh memuat turun projek yang telah siap dari GitHub.

Sensor gerakan: Memproses tatasusunan multidimensi

Hingga ke tahap ini, kami telah memberi tumpuan kepada sensor yang membekalkan satu item data, tetapi terdapat beberapa sensor yang menyediakan array multidimensi untuk setiap SensorEvent. Sensor multidimensi ini termasuk sensor gerak, yang akan kita fokuskan pada bahagian akhir ini.

Sensor gerakan boleh membantu anda:

• Sediakan kaedah alternatif input pengguna. Contohnya, jika anda membangunkan permainan mudah alih maka pengguna dapat memindahkan watak mereka di sekitar skrin dengan menyengetkan peranti mereka.
• Menyimpulkan aktiviti pengguna. Sekiranya anda telah membuat aplikasi pengesanan aktiviti, maka sensor gerak boleh membantu anda mengukur sama ada pengguna sedang dalam perjalanan dalam kereta, berjoging, atau duduk di meja mereka.
• Lebih tepat menentukan orientasi.Ia mungkin untuk mengeluarkan koordinat dari sensor pergerakan peranti, dan kemudian menterjemahkannya berdasarkan sistem koordinat bumi, untuk mendapatkan wawasan yang paling tepat mengenai orientasi semasa peranti.

Dalam bahagian akhir ini, kami akan menggunakan sensor vektor putaran (TYPE_ROTATION_VECTOR). Tidak seperti penderia cahaya dan kedekatan, ini adalah sensor perisian yang menyusun data dari alat pecutan, magnetometer, dan sensor gyroscope. Walaupun bekerja dengan sensor ini sering memerlukan anda untuk melakukan penukaran matematik dan transformasi, ia juga dapat menyediakan anda dengan pelbagai maklumat yang sangat tepat mengenai peranti ini.

Kami akan mencipta aplikasi yang menggunakan sensor vektor putaran untuk mengukur:

• Pitch. Ini adalah kecondongan atas ke bawah peranti.
• Gulung. Ini adalah kecondongan kiri-ke-kanan peranti.

Memaparkan data masa nyata dan data roll

Oleh kerana kita mengukur dua metrik, kita perlu membuat dua TextViews dan dua sumber rentetan yang sepadan:

Buka fail strings.xml, dan tambahkan yang berikut:

MotionSensors Pitch Sensor:% 1 $ .2f Sensor Roll:% 1 $ .2f Tiada sensor gerakan yang tersedia

Menggunakan sensor vektor putaran dalam aplikasi anda

Kami akan menggunakan semula beberapa kod daripada aplikasi terdahulu, jadi mari fokus pada bidang yang berkomunikasi dengan sensor vektor putaran, jauh berbeza dengan apa yang telah kita lihat sebelumnya.

1. Gunakan TYPE_ROTATION_VECTOR

Oleh kerana kami bekerja dengan sensor vektor putaran, kami perlu memanggil kaedah getDefaultSensor (), dan kemudian lulusnya pemalar TYPE_ROTATION_VECTOR:

positionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR);

2. Terjemah data sensor

Berbeza dengan penderia cahaya dan kedekatan sebelumnya, sensor gerak mengembalikan array multidimensi nilai sensor untuk setiap SensorEvent. Nilai-nilai ini diformatkan menggunakan sistem koordinat piawai "X, Y, Z", yang dikira berbanding dengan peranti apabila ia dipertahankan dalam orientasi "semulajadi" asalnya.

Android tidak menukar koordinat X, Y dan Z ini untuk menyesuaikan orientasi semasa peranti, jadi paksi "X" akan kekal sama tanpa mengira sama ada peranti itu berada dalam mod potret atau landskap. Apabila menggunakan sensor vektor putaran, anda mungkin perlu menukar data masuk untuk dipadankan dengan putaran semasa peranti.

Potret adalah orientasi lalai untuk kebanyakan telefon pintar, tetapi anda tidak boleh menganggap ini akan berlaku untuknya semua Peranti Android, terutamanya tablet. Dalam artikel ini, kami akan menggunakan matriks putaran untuk menterjemahkan data sensor dari asalnya, peranti menyelaras sistem, kepada Bumi sistem koordinat, yang mewakili pergerakan dan kedudukan peranti berbanding dengan Bumi. Sekiranya diperlukan, kita kemudian boleh mengemas semula data penderia, berdasarkan orientasi semasa peranti.

Pertama, sistem koordinat peranti ialah sistem koordinat 3-paksi X, Y, Z, yang mana setiap titik pada setiap tiga paksi diwakili oleh vektor 3D. Ini bermakna kita perlu membuat pelbagai 9 nilai apungan:

putaran floatMatrix = float baru;

Kita boleh lulus array ini ke kaedah getRotationMatrix ():

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

Langkah seterusnya, menggunakan kaedah SensorManager.remapCoordinateSystem () untuk merangkum data sensor, berdasarkan orientasi semasa peranti.

Kaedah SensorManager.remapCoordinateSystem () mengambil argumen berikut:

• Matriks penggiliran asal.
• Paksi yang anda mahu remap.
• Arahan yang anda sediakan dengan data baru ini.

Berikut ialah kod yang saya akan gunakan dalam apl saya:

float adjustedRotationMatrix = float baru; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, adjustRotationMatrix);

Akhirnya, kami akan menghubungi SensorManager.getOrientation dan menceritakannya untuk menggunakanRotationMatrix yang diselaraskan:

SensorManager.getOrientation (adjustedRotationMatrix, orientasi);

3. Kemas kini tali pemegang tempat

Oleh kerana kita mempunyai dua set data (padang dan roll), kita perlu mengambil dua tali letak pemegang berasingan, mengisi mereka dengan nilai yang betul, dan kemudian mengemas kini TextView yang sepadan:

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

Memaparkan pelbagai data sensor: Kod siap

Selepas melakukan langkah-langkah di atas, MainActivity anda harus kelihatan seperti ini:

import android.app.Activity; import android.os.Bundle; import android.hardware.Sensor; import android.hardware.SensorEvent; import android.hardware.SensorEventListener; import android.hardware.SensorManager; import android.widget.TextView; MainActivity kelas awam memanjangkan Kegiatan melaksanakan SensorEventListener {sensor SensorManager swastaSensorManager; gerakan Sensor peribadiSensor; Private TextView pitchTextView; teks TextView rollTextView peribadi; int akhir akhir statik swasta SENSOR_DELAY = 500 * 1000; int akhir akhir statik FROM_RADS_TO_DEGS = -57; @Override dilindungi tidak sah onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); pitchTextView = (TextView) findViewById (R.id.pitchTextView); rollTextView = (TextView) findViewById (R.id.rollTextView); cuba {motionSensorManager = (SensorManager) getSystemService (Activity.SENSOR_SERVICE); motionSensor = motionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR); motionSensorManager.registerListener (ini, gerakanSensor, SENSOR_DELAY); } tangkapan (Pengecualian e) {pitchTextView.setText (R.string.no_sensor); rollTextView.setText (R.string.no_sensor); }} @Override public void onAccuracyChanged (Sensor sensor, int accuracy) {// To do //} @Override public void onSensorChanged (SensorEvent event) {if (event.sensor == motionSensor) {update (event.values); }} pembaruan kekosongan persendirian (vektor float) {// Menghitung matriks putaran // putaran floatMatrix = float baru; SensorManager.getRotationMatrixFromVector (rotasiMatrix, vektor); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z; // Remap matriks berdasarkan orientasi semasa Kegiatan // float adjustedRotationMatrix = float baru; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, adjustRotationMatrix); / / Hitung orientasi peranti // float orientation = float baru; // Berikan pelbagai nilai apungan kepada kaedah getOrientation () // SensorManager.getOrientation (disesuaikanRotationMatrix, orientasi); float pitch = orientasi * FROM_RADS_TO_DEGS; float roll = orientation * FROM_RADS_TO_DEGS; // Kemas kini TextViews dengan nilai pitch dan roll // pitchTextView.setText (getResources (). GetString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll)); }}

Anda boleh memuat turun projek yang telah siap dari GitHub.

Menguji permohonan sensor Android terakhir kami

Untuk menguji aplikas vektor putaran vektor ini pada telefon pintar Android atau tablet fizikal:

• Pasang aplikasi pada peranti anda.
• Letakkan telefon pintar atau tablet anda pada permukaan yang rata. Perhatikan bahawa sensor gerak sangat sensitif, jadi ia tidak biasa untuk peranti seolah-olah tidak bergerak untuk melaporkan turun naik nilai pitch dan roll.
• Untuk menguji padang, angkat bahagian bawah peranti anda supaya ia menyimpang dari anda. Nilai padang harus berubah secara dramatik.
• Untuk menguji gulung, cuba angkat sebelah kiri peranti anda, jadi ia menyengetkan ke kiri - perhatikan nilai roll itu!

Jika anda menguji projek anda pada emulator:

• Pasang aplikasi pada AVD anda.
• Pilih "Lagi," yang melancarkan tetingkap "Kawalan Extended".
• Dalam menu sebelah kiri, pilih "Sensor Maya."
• Pastikan tab "Pelancar" dipilih. Tab ini mengandungi kawalan yang boleh mensimulasikan perubahan dalam kedudukan dan orientasi peranti.
• Cuba bereksperimen dengan pelbagai slider (Putar: Z-Rot, X-Rot, Y-Rot dan Pindah: X, Y, dan Z) dan pelbagai "Putaran Peranti" butang, untuk melihat bagaimana ia mempengaruhi "Roll Sensor "Dan" Pitch Sensor "nilai.

Mengakhiri

Dalam artikel ini, kita melihat bagaimana untuk mendapatkan data dari tiga kategori utama sensor Android: persekitaran, kedudukan dan gerakan, dan cara memantau data ini dalam masa nyata.

Pernahkah anda melihat sebarang aplikasi Android yang menggunakan sensor dalam cara yang menarik atau unik? Beritahu kami dalam komen di bawah!