Zawartość

• Jakich czujników z Androidem mogę używać?
• Czujniki środowiskowe: Pomiar światła otoczenia
• Wyświetlanie danych czujnika
• Komunikacja z czujnikiem: SensorManager, SensorEvents i nasłuchiwania
• 1. Uzyskaj instancję SensorManager
• 2. Uzyskaj odniesienie do lightTextView
• 3. Sprawdź, czy czujnik istnieje w bieżącym urządzeniu
• 4. Zarejestruj swoje czujniki nasłuchujące
• 5. Zaimplementuj wywołania zwrotne SensorEventListener
• onSensorChanged ()
• onAccuracyChanged ()
• 6. Pobierz wartość czujnika
• 7. Wyrejestruj swoich słuchaczy
• Korzystanie z czujników światła Androida: Ukończony kod
• Przetestuj ukończoną aplikację czujnika na Androida
• Pomiar odległości za pomocą czujników zbliżeniowych Androida
• Tworzenie interfejsu użytkownika
• Pobieranie danych z czujnika zbliżeniowego
• Testowanie: jak blisko jest użytkownika do swojego urządzenia?
• Czujniki ruchu: Przetwarzanie tablic wielowymiarowych
• Wyświetlanie danych pitch i roll w czasie rzeczywistym
• Korzystanie z czujnika wektora obrotu w aplikacji
• 1. Użyj TYPE_ROTATION_VECTOR
• 2. Przetłumacz dane czujnika
• 3. Zaktualizuj ciągi symboli zastępczych
• Wyświetlanie danych z wielu czujników: Kod ukończony
• Testowanie naszej ostatecznej aplikacji czujnika Android
• Podsumowując

Obecnie większość nowoczesnych urządzeń z Androidem jest wyposażona w kilka czujników.

Możesz użyć tych informacji na wiele różnych sposobów - niezależnie od tego, czy monitorują one poziomy światła, aby Twoja aplikacja mogła automatycznie dostosować jasność lub kolorystykę; umożliwianie użytkownikowi interakcji z grą mobilną za pomocą gestów, takich jak przechylanie urządzenia; lub użycie czujnika zbliżeniowego do automatycznego wyłączania zdarzeń dotykowych za każdym razem, gdy użytkownik przyłoży urządzenie do ucha.

W tym artykule stworzymy trzy aplikacje, które pobierają dane dotyczące światła, odległości i ruchu z szeregu czujników sprzętowych i programowych. Będziemy również monitorować czujniki Androida w czasie rzeczywistym, aby Twoja aplikacja zawsze miała dostęp do najnowszych informacji.

Pod koniec tego artykułu dowiesz się, jak wyodrębnić pojedynczy fragment danych z czujnika Android i jak obsługiwać czujniki, które dostarczają swoje dane w postaci wielowymiarowej tablicy.

Jakich czujników z Androidem mogę używać?

Czujniki Android można podzielić na następujące kategorie:

• Czujniki środowiskowe. Mierzą one warunki otoczenia, takie jak temperatura powietrza, ciśnienie, wilgotność i poziomy oświetlenia otoczenia.

• Czujniki położenia. Ta kategoria obejmuje czujniki mierzące fizyczną pozycję urządzenia, takie jak czujniki zbliżeniowe i czujniki pola geomagnetycznego.
  Czujniki ruchu. Czujniki te mierzą ruch urządzenia i obejmują akcelerometry, czujniki grawitacyjne, żyroskopy i czujniki wektora obrotu.

Ponadto czujniki mogą być:

• Na bazie sprzętu. Są to elementy fizyczne wbudowane w urządzenie i bezpośrednio mierzą określone właściwości, takie jak przyspieszenie lub siła otaczających pól geomagnetycznych.
• Oparte na oprogramowaniu, czasami znane jako czujniki wirtualne lub czujniki kompozytowe. Zazwyczaj gromadzą one dane z wielu czujników sprzętowych. Pod koniec tego artykułu będziemy pracować z czujnikiem wektora obrotu, który jest czujnikiem programowym, który łączy dane z akcelerometru urządzenia, magnetometru i żyroskopu.

Czujniki środowiskowe: Pomiar światła otoczenia

Czujnik światła Androida mierzy światło otoczenia w jednostkach „lux”, czyli natężenie światła postrzegane przez ludzkie oko. Wartość luksów zgłaszana przez czujnik może się różnić w zależności od urządzenia, więc jeśli aplikacja wymaga spójnych wartości, może być konieczne zmodyfikowanie surowych danych przed użyciem ich w aplikacji.

W tej sekcji utworzymy aplikację, która pobierze bieżącą wartość luksów z czujnika światła urządzenia, wyświetli ją w TextView, a następnie zaktualizuje TextView, gdy pojawią się nowe dane.Następnie możesz użyć tych informacji w szeregu aplikacji, na przykład możesz utworzyć aplikację latarki, która pobiera informacje z czujnika światła, a następnie automatycznie dostosowuje siłę wiązki na podstawie aktualnych poziomów światła.

Utwórz nowy projekt na Androida z wybranymi ustawieniami i zacznijmy!

Wyświetlanie danych czujnika

Dodam TextView, który ostatecznie wyświetli dane, które wyodrębniliśmy z czujnika światła. TextView będzie aktualizowany, gdy pojawią się nowe dane, dzięki czemu użytkownik zawsze ma dostęp do najnowszych informacji.

Otwórz plik Activity_main.xml swojego projektu i dodaj następujące elementy:

Następnie musimy utworzyć zasób „light_sensor”, do którego odwołuje się nasz układ. Otwórz plik strings.xml swojego projektu i dodaj następujące elementy:

Czujnik światła:% 1 $ .2f

„% 1 $ .2f” to symbol zastępczy, który określa informacje, które chcemy wyświetlić, i sposób ich sformatowania:

• %1. Możesz wstawić wiele symboli zastępczych do tego samego zasobu ciągów; „% 1” oznacza, że ​​używamy jednego symbolu zastępczego.
• $.2. Określa, jak nasza aplikacja powinna sformatować każdą przychodzącą wartość zmiennoprzecinkową. „$ .2” oznacza, że ​​wartość należy zaokrąglić do dwóch miejsc po przecinku.
• FA. Sformatuj wartość jako liczbę zmiennoprzecinkową.

Chociaż niektóre czujniki są bardziej powszechne niż inne, nigdy nie należy zakładać, że każde urządzenie ma dostęp do dokładnie tego samego sprzętu i oprogramowania. Dostępność czujników może się nawet różnić w zależności od wersji Androida, ponieważ niektóre czujniki zostały wprowadzone dopiero w późniejszych wersjach platformy Android.

Możesz sprawdzić, czy dany czujnik jest obecny w urządzeniu, korzystając z systemu czujników Android. Następnie możesz wyłączyć lub włączyć części aplikacji w zależności od dostępności czujnika lub możesz wyświetlić wyjaśnienie, że niektóre funkcje aplikacji nie będą działać zgodnie z oczekiwaniami.

Chociaż mamy otwarty plik strings.xml, utwórzmy ciąg „no_sensor”, który wyświetlimy, jeśli czujnik światła będzie niedostępny:

Brak dostępnego czujnika światła

Jeśli aplikacja nie może zapewnić komfortu użytkowania bez dostępu do określonego czujnika, musisz dodać tę informację do manifestu. Na przykład jeśli Twoja aplikacja wymaga dostępu do czujnika kompasu, możesz użyć następujących opcji:

Teraz aplikację można pobrać tylko na urządzenia wyposażone w czujnik kompasu.

Może to ograniczać odbiorców, ale jest o wiele mniej szkodliwe niż pozwalanie komuś na pobranie Twojej aplikacji, gdy jest gwarantowane mieć złe doświadczenia ze względu na konfigurację czujników urządzenia.

Komunikacja z czujnikiem: SensorManager, SensorEvents i nasłuchiwania

Aby komunikować się z czujnikiem światła urządzenia, musisz wykonać następujące kroki:

1. Uzyskaj instancję SensorManager

SensorManager zapewnia wszystkie metody potrzebne do uzyskania dostępu do pełnego zakresu czujników urządzenia.

Aby rozpocząć, utwórz zmienną, która będzie zawierać instancję SensorManager:

prywatny SensorManager lightSensorManager;

Następnie musisz uzyskać instancję SensorManager, wywołując metodę Context.getSystemService i przekazując argument Context.SENSOR_SERVICE:

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

2. Uzyskaj odniesienie do lightTextView

Następnie musimy utworzyć prywatną zmienną członka, która będzie przechowywać nasze obiekty TextView i przypisać ją do naszego TextView:

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

3. Sprawdź, czy czujnik istnieje w bieżącym urządzeniu

Możesz uzyskać dostęp do konkretnego czujnika, wywołując metodę getDefaultSensor (), a następnie przekazując mu dany czujnik. Stała typu dla czujnika światła to TYPE_LIGHT, więc musimy użyć następujących elementów:

lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT);

Jeśli czujnik nie istnieje na tym urządzeniu, wówczas metoda getDefaultSensor () zwróci null, a my wyświetlimy ciąg „no_sensor”:

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

4. Zarejestruj swoje czujniki nasłuchujące

Za każdym razem, gdy czujnik ma nowe dane, Android generuje obiekt SensorEvent. Ten obiekt SensorEvent zawiera czujnik, który wygenerował zdarzenie, znacznik czasu i nową wartość danych.

Początkowo skupimy się na czujnikach światła i zbliżeniowych, które zwracają pojedynczy fragment danych. Jednak niektóre czujniki zapewniają tablice wielowymiarowe dla każdego SensorEvent, w tym czujnik wektora obrotu, który będziemy badać pod koniec tego artykułu.

Aby upewnić się, że nasza aplikacja jest powiadamiana o tych obiektach SensorEvent, musimy zarejestrować detektor dla tego konkretnego zdarzenia czujnika, używając metody registerListener () SensorManager.

Metoda registerListener () przyjmuje następujące argumenty:

• Aplikacja lub kontekst działania.
• Typ czujnika, który chcesz monitorować.
• Szybkość, z jaką czujnik powinien wysyłać nowe dane. Wyższa stawka zapewni Twojej aplikacji więcej danych, ale zużyje również więcej zasobów systemowych, zwłaszcza żywotność baterii. Aby pomóc w oszczędzaniu baterii urządzenia, należy poprosić o minimalną ilość danych wymaganą przez aplikację. Użyję SensorManager.SENSOR_DELAY_NORMAL, który wysyła nowe dane co 200 000 mikrosekund (0,2 sekundy).

Ponieważ słuchanie czujnika wyczerpuje baterię urządzenia, nigdy nie należy rejestrować detektorów w metodzie onCreate () aplikacji, ponieważ spowoduje to, że czujniki będą nadal wysyłać dane, nawet gdy aplikacja jest w tle.

Zamiast tego należy zarejestrować czujniki w metodzie cyklu życia aplikacji onStart ():

@Override protected void onStart () {super.onStart (); // Jeśli czujnik jest dostępny na bieżącym urządzeniu ... // if (lightSensor! = Null) {//…. Następnie zacznij nasłuchiwać // lightSensorManager.registerListener (this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL); }}

5. Zaimplementuj wywołania zwrotne SensorEventListener

SensorEventListener to interfejs, który odbiera powiadomienia z SensorManager
gdy dostępne są nowe dane lub zmienia się dokładność czujnika.

Pierwszym krokiem jest zmodyfikowanie podpisu naszej klasy w celu zaimplementowania interfejsu SensorEventListener:

klasa publiczna MainActivity rozszerza AppCompatActivity implementuje SensorEventListener {

Następnie musimy zaimplementować następujące metody wywołania zwrotnego:

onSensorChanged ()

Ta metoda jest wywoływana w odpowiedzi na każdy nowy SensorEvent.

Dane czujnika często mogą się szybko zmieniać, więc aplikacja może regularnie wywoływać metodę onSensorChanged (). Aby zapewnić płynne działanie aplikacji, należy wykonać jak najmniej pracy w metodzie onSensorChanged ().

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

onAccuracyChanged ()

Jeśli dokładność czujnika poprawi się lub spadnie, system Android wywoła metodę onAccuracyChanged () i przekaże mu obiekt Sensor zawierający nową wartość dokładności, na przykład SENSOR_STATUS_UNRELIABLE lub SENSOR_STATUS_ACCURACY_HIGH.

Czujnik światła nie zgłasza zmian dokładności, więc pozostawię puste wywołanie zwrotne onAccuracyChanged ():

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

6. Pobierz wartość czujnika

Ilekroć mamy nową wartość, musimy wywołać metodę onSensorChanged () i pobrać ciąg „light_sensor”. Następnie możemy zastąpić tekst zastępczy ciągu (% 1 $ .2f) i wyświetlić zaktualizowany ciąg jako część naszego TextView:

@Override public void onSensorChanged (SensorEvent sensorEvent) {// Aktualna wartość czujnika // float currentValue = sensorEvent.values; // Pobierz ciąg „light_sensor”, wstaw nową wartość i wyświetl ją użytkownikowi // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); }

7. Wyrejestruj swoich słuchaczy

Czujniki mogą generować duże ilości danych w krótkim czasie, więc aby zachować zasoby urządzenia, musisz wyrejestrować swoich słuchaczy, gdy nie są już potrzebne.

Aby zatrzymać nasłuchiwanie zdarzeń czujnika, gdy aplikacja znajduje się w tle, dodaj metodę unregisterListener () do metody cyklu życia onStop () projektu:

@Override protected void onStop () {super.onStop (); lightSensorManager.unregisterListener (this); }

Pamiętaj, że nie należy wyrejestrowywać swoich słuchaczy w trybie onPause (), ponieważ w Androidzie 7.0 i nowszych aplikacjach można uruchamiać w trybie podzielonego ekranu i obrazu w obrazie, w których są one wstrzymane, ale pozostają widoczne na ekranie.

Korzystanie z czujników światła Androida: Ukończony kod

Po wykonaniu wszystkich powyższych kroków MainActivity Twojego projektu powinna wyglądać mniej więcej tak:

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; klasa publiczna MainActivity rozszerza AppCompatActivity // Zaimplementuj interfejs SensorEventListener // implementuje SensorEventListener {// Utwórz zmienne // private Sensor lightSensor; prywatny SensorManager lightSensorManager; prywatny TextView lightTextView; @Override chronione void onCreate (pakiet saveInstanceState) {super.onCreate (saveInstanceState); setContentView (R.layout.activity_main); lightTextView = (TextView) findViewById (R.id.lightTextView); // Pobierz instancję SensorManager // lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Sprawdź czujnik światła // lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT); // Jeśli czujnik światła nie istnieje, wyświetl błąd // String sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_error); }} @Override protected void onStart () {super.onStart (); // Jeśli czujnik jest dostępny na bieżącym urządzeniu ... // if (lightSensor! = Null) {//…. Następnie zarejestruj słuchacza // lightSensorManager.registerListener (this, lightSensor, // Określ, jak często chcesz odbierać nowe dane // SensorManager.SENSOR_DELAY_NORMAL); }} @Override protected void onStop () {super.onStop (); // Wyrejestruj swój słuchacz // lightSensorManager.unregisterListener (this); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// Aktualna wartość czujnika // float currentValue = sensorEvent.values; // Pobierz ciąg „light_sensor”, wstaw nową wartość i zaktualizuj TextView // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); } @Override // Jeśli dokładność czujnika zmieni się… .// public void onAccuracyChanged (Sensor sensor, int i) {// TO DO //}}

Przetestuj ukończoną aplikację czujnika na Androida

Aby przetestować tę aplikację na fizycznym smartfonie lub tablecie z Androidem:

• Zainstaluj projekt na swoim urządzeniu (wybierając „Uruchom> Uruchom” z paska narzędzi Android Studio).
• Chociaż różni się w zależności od urządzenia, czujnik światła często znajduje się w prawym górnym rogu ekranu. Aby manipulować poziomem światła, przenieś urządzenie bliżej źródła światła, a następnie dalej. Alternatywnie możesz spróbować przykryć urządzenie dłonią, aby zasłonić światło. Wartość „Czujnik światła” powinna wzrastać i zmniejszać, w zależności od ilości dostępnego światła.

Jeśli używasz urządzenia wirtualnego z systemem Android (AVD), emulator ma zestaw kontrolek czujników wirtualnych, których możesz użyć do symulacji różnych zdarzeń czujnika. Dostęp do tych kontrolek czujników wirtualnych uzyskuje się za pomocą okna „Rozszerzonych kontroli” emulatora:

• Zainstaluj aplikację na AVD.
• Obok AVD zobaczysz pasek przycisków. Znajdź przycisk „Więcej” z trzema kropkami (gdzie kursor znajduje się na poniższym zrzucie ekranu) i kliknij go. Spowoduje to otwarcie okna „Rozszerzone elementy sterujące”.

• W menu po lewej stronie wybierz „Wirtualne czujniki”.
• Wybierz zakładkę „Dodatkowe czujniki”. Ta karta zawiera różne suwaki, których można użyć do symulacji różnych zdarzeń czujnika pozycji i otoczenia.

• Znajdź suwak „Światło (lux)” i przeciągnij go w lewo i prawo, aby zmienić symulowane poziomy światła. Twoja aplikacja powinna wyświetlać te zmieniające się wartości w czasie rzeczywistym.

Możesz pobrać ukończony projekt z GitHub.

Pomiar odległości za pomocą czujników zbliżeniowych Androida

Teraz widzieliśmy, jak uzyskać informacje z czujnika środowiskowego, zobaczmy, jak zastosować tę wiedzę do pozycja czujnik.

W tej sekcji wykorzystamy czujnik zbliżeniowy urządzenia do monitorowania odległości między smartfonem lub tabletem a innymi obiektami. Jeśli aplikacja ma jakąkolwiek funkcję głosową, czujnik zbliżeniowy może pomóc określić, kiedy smartfon jest trzymany przy uchu użytkownika, na przykład podczas rozmowy telefonicznej. Następnie możesz użyć tych informacji, aby wyłączyć zdarzenia dotykowe, dzięki czemu użytkownik nie rozłącza się przypadkowo lub nie wywołuje innych niepożądanych zdarzeń w trakcie rozmowy.

Tworzenie interfejsu użytkownika

Pokażę na ekranie dane zbliżeniowe, abyś mógł oglądać, jak aktualizuje się w czasie rzeczywistym. Aby uprościć sprawę, wykorzystajmy dużo układu z naszej poprzedniej aplikacji:

Następnie otwórz plik strings.xml i utwórz ciąg „czujnik_ zbliżeniowy”. Ponownie ten ciąg musi zawierać symbol zastępczy, który ostatecznie zostanie zapełniony danymi wyodrębnionymi z czujnika zbliżeniowego:

Czujnik zbliżeniowy Czujnik zbliżeniowy:% 1 $ .2f Brak czujnika zbliżeniowego

Pobieranie danych z czujnika zbliżeniowego

Podobnie jak czujnik światła, czujnik zbliżeniowy Androida zwraca pojedynczą wartość danych, co oznacza, że ​​możemy ponownie wykorzystać znaczną część kodu z naszej poprzedniej aplikacji. Istnieje jednak kilka głównych różnic oraz kilka zmian związanych z nazwami, które ułatwiają śledzenie tego kodu:

• Utwórz instancję SensorManager, która tym razem nadam nazwę „ZbliżenieSensorManager”.
• Uzyskaj instancję „ZbliżeniaSensoraManagera”.
• Utwórz odwołanie do „ZbliżeniaTekstu”.
• Wywołaj metodę getDefaultSensor () i przekaż jej czujnik TYPE_PROXIMITY.
• Zarejestruj i wyrejestruj słuchaczy z czujnika zbliżeniowego.

Po dokonaniu tych drobnych poprawek powinieneś skończyć z następującymi:

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; klasa publiczna MainActivity rozszerza AppCompatActivity // Zaimplementuj interfejs SensorEventListener // implementuje SensorEventListener {// Stwórz zmienne // private SensorimitySensor; private SensorManagerimitySensorManager; prywatny tekstViewViewTextView; @Override chronione void onCreate (pakiet saveInstanceState) {super.onCreate (saveInstanceState); setContentView (R.layout.activity_main); closeTextView = (TextView) findViewById (R.id.proximityTextView); // Uzyskaj instancję SensorManager //imitySensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Sprawdź czujnik zbliżeniowy //imitySensor =imitySensorManager.getDefaultSensor (Sensor.TYPE_PROXIMITY); // Jeśli czujnik zbliżeniowy nie istnieje, wyświetl błąd // String sensor_error = getResources (). GetString (R.string.no_sensor); if (imitySensor == null) {imityTextView.setText (sensor_error); }} @Override protected void onStart () {super.onStart (); // Jeśli czujnik jest dostępny na bieżącym urządzeniu ... // if (bliskośćSensora! = Null) {//…. Następnie zarejestruj nasłuchiwanie // bliskośćSensorManager.registerListener (to, bliskośćSensora, // Określ, jak często chcesz odbierać nowe dane // SensorManager.SENSOR_DELAY_NORMAL); }} @Override protected void onStop () {super.onStop (); // Wyrejestruj swój detektor, aby zachować zasoby systemowe //blosSensorManager.unregisterListener (this); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// Aktualna wartość czujnika // float currentValue = sensorEvent.values; // Odzyskaj ciąg „sensor_odległości”, wstaw nową wartość i zaktualizuj TextView // bliskośćTextView.setText (getResources (). GetString (R.string.proximity_sensor, currentValue)); } @Override // Jeśli dokładność czujnika ulegnie zmianie ... .// public void onAccuracyChanged (Sensor sensor, int i) {//...TO DO //}}

Testowanie: jak blisko jest użytkownika do swojego urządzenia?

Aby przetestować tę aplikację na fizycznym smartfonie lub tablecie z Androidem, zainstaluj aplikację na swoim urządzeniu, a następnie eksperymentuj, przesuwając dłoń w kierunku ekranu, a następnie ponownie ją odsuwając. Wartość „Czujnik zbliżeniowy” powinna rejestrować twoje ruchy.

Pamiętaj tylko, że czujniki zbliżeniowe mogą się różnić w zależności od urządzenia. Niektóre urządzenia mogą wyświetlać tylko dwie wartości bliskości - jedną wskazującą „Blisko”, a drugą „Daleko” - więc nie zdziw się, jeśli nie zobaczysz dużej różnorodności na fizycznym urządzeniu z Androidem.

Aby przetestować tę aplikację na emulatorze:

• Zainstaluj aplikację na AVD.
• Znajdź przycisk z trzema kropkami „Więcej” i kliknij go, co spowoduje otwarcie okna „Rozszerzone elementy sterujące”.
• W menu po lewej stronie okna wybierz „Wirtualne czujniki”.
• Wybierz zakładkę „Dodatkowe czujniki”.
• Znajdź suwak „Bliskość” i przeciągnij go w lewo i prawo, aby emulować obiekt zbliżający się do urządzenia, a następnie dalej. Wartości „Czujnik zbliżeniowy” powinny się zmieniać podczas manipulowania suwakiem.

Możesz pobrać ukończony projekt z GitHub.

Czujniki ruchu: Przetwarzanie tablic wielowymiarowych

Do tego momentu koncentrowaliśmy się na czujnikach, które dostarczają jeden element danych, ale istnieją czujniki, które zapewniają tablice wielowymiarowe dla każdego SensorEvent. Te wielowymiarowe czujniki obejmują czujniki ruchu, na których skupimy się w tym ostatnim rozdziale.

Czujniki ruchu mogą pomóc:

• Podaj alternatywną metodę wprowadzania danych przez użytkownika. Na przykład, jeśli tworzysz grę mobilną, użytkownik może przesuwać swoją postać po ekranie, przechylając urządzenie.
• Wnioskuj aktywność użytkownika. Jeśli masz aplikację do śledzenia aktywności, czujniki ruchu pomogą Ci ocenić, czy użytkownik podróżuje samochodem, jogguje lub siedzi przy biurku.
• Dokładniej określ orientację.Możliwe jest wydobycie współrzędnych z czujników ruchu urządzenia, a następnie przetłumaczenie ich w oparciu o układ współrzędnych Ziemi, aby uzyskać jak najdokładniejszy wgląd w aktualną orientację urządzenia.

W tej ostatniej sekcji będziemy używać czujnika wektora obrotu (TYPE_ROTATION_VECTOR). W odróżnieniu od czujników światła i czujników zbliżeniowych jest to czujnik programowy, który gromadzi dane z akcelerometru, magnetometru i czujników żyroskopu. Chociaż praca z tym czujnikiem często wymaga wykonywania matematycznych konwersji i przekształceń, może również zapewnić szereg bardzo dokładnych informacji o urządzeniu.

Będziemy tworzyć aplikację, która wykorzystuje czujnik wektora obrotu do pomiaru:

• Smoła. Jest to pochylenie od góry do dołu urządzenia.
• Rolka. Jest to pochylenie od lewej do prawej urządzenia.

Wyświetlanie danych pitch i roll w czasie rzeczywistym

Ponieważ mierzymy dwie metryki, musimy utworzyć dwa TextView i dwa odpowiednie ciągi znaków:

Otwórz plik strings.xml i dodaj następujące elementy:

MotionSensors Czujnik skoku:% 1 $ .2f Czujnik przechyłu:% 1 $ .2f Brak czujnika ruchu

Korzystanie z czujnika wektora obrotu w aplikacji

Ponownie wykorzystamy część kodu z naszych poprzednich aplikacji, więc skupmy się na obszarach, w których komunikacja z czujnikiem wektora obrotu różni się znacznie od tego, co widzieliśmy wcześniej.

1. Użyj TYPE_ROTATION_VECTOR

Ponieważ pracujemy z czujnikiem wektora obrotu, musimy wywołać metodę getDefaultSensor (), a następnie przekazać jej stałą TYPE_ROTATION_VECTOR:

positionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR);

2. Przetłumacz dane czujnika

W przeciwieństwie do poprzednich czujników światła i zbliżeniowych, czujniki ruchu zwracają wielowymiarowe tablice wartości czujników dla każdego SensorEvent. Wartości te są formatowane przy użyciu standardowego układu współrzędnych „X, Y, Z”, który jest obliczany względem urządzenia, gdy jest ono trzymane w domyślnej, „naturalnej” orientacji.

Android nie przełącza współrzędnych X, Y i Z, aby dopasować je do aktualnej orientacji urządzenia, więc oś „X” pozostanie taka sama, niezależnie od tego, czy urządzenie jest w trybie pionowym czy poziomym. Podczas korzystania z czujnika wektora obrotu może być konieczne przekonwertowanie przychodzących danych w celu dopasowania do bieżącego obrotu urządzenia.

Portret jest orientacją domyślną dla większości smartfonów, ale nie należy zakładać, że tak się stanie wszystko Urządzenia z Androidem, zwłaszcza tablety. W tym artykule użyjemy macierzy rotacji, aby przetłumaczyć dane czujnika z jego oryginału, urządzenie układ współrzędnych, do Ziemi układ współrzędnych, który reprezentuje ruch i położenie urządzenia względem Ziemi. W razie potrzeby możemy ponownie mapować dane czujnika, w oparciu o bieżącą orientację urządzenia.

Po pierwsze, układ współrzędnych urządzenia jest standardowym 3-osiowym układem współrzędnych X, Y, Z, w którym każdy punkt na każdej z trzech osi jest reprezentowany przez wektor 3D. Oznacza to, że musimy utworzyć tablicę 9 wartości zmiennoprzecinkowych:

float rotationMatrix = nowy float;

Następnie możemy przekazać tę tablicę do metody getRotationMatrix ():

SensorManager.getRotationMatrixFromVector (rotationMatrix, wektory); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z;

Następnym krokiem jest użycie metody SensorManager.remapCoordinateSystem () do ponownego mapowania danych czujnika, w oparciu o bieżącą orientację urządzenia.

Metoda SensorManager.remapCoordinateSystem () przyjmuje następujące argumenty:

• Oryginalna macierz obrotu.
• Osie, które chcesz mapować ponownie.
• Tablica, którą wypełniasz tymi nowymi danymi.

Oto kod, którego będę używać w mojej aplikacji:

float wyregulowanyRotationMatrix = nowy float; SensorManager.remapCoordinateSystem (rotacjaMatrix, worldAxisX, worldAxisZ, wyregulowanaRotacjaMatrix);

Na koniec wywołamy SensorManager.getOrientation i powiedzmy mu, aby używał dostosowaneRotationMatrix:

SensorManager.getOrientation (adjustRotationMatrix, orientacja);

3. Zaktualizuj ciągi symboli zastępczych

Ponieważ mamy dwa zestawy danych (pitch i roll), musimy pobrać dwa oddzielne ciągi znaków zastępczych, wypełnić je prawidłowymi wartościami, a następnie zaktualizować odpowiedni TextView:

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

Wyświetlanie danych z wielu czujników: Kod ukończony

Po wykonaniu powyższych kroków Twoja MainActivity powinna wyglądać mniej więcej tak:

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; klasa publiczna MainActivity rozszerza działanie Implementuje SensorEventListener {private SensorManager motionSensorManager; prywatny czujnik ruchu czujnik; prywatny TextView pitchTextView; prywatny TextView rollTextView; prywatny statyczny końcowy int SENSOR_DELAY = 500 * 1000; prywatny statyczny końcowy int FROM_RADS_TO_DEGS = -57; @Override chronione void onCreate (pakiet saveInstanceState) {super.onCreate (saveInstanceState); setContentView (R.layout.activity_main); pitchTextView = (TextView) findViewById (R.id.pitchTextView); rollTextView = (TextView) findViewById (R.id.rollTextView); spróbuj {motionSensorManager = (SensorManager) getSystemService (Activity.SENSOR_SERVICE); motionSensor = motionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR); motionSensorManager.registerListener (this, motionSensor, SENSOR_DELAY); } catch (Exception e) {pitchTextView.setText (R.string.no_sensor); rollTextView.setText (R.string.no_sensor); }} @Override public void onAccuracyChanged (czujnik czujnika, int dokładność) {// To zrobić //} @Override public void onSensorChanged (SensorEvent event) {if (event.sensor == motionSensor) {update (event.values); }} private void update (float vectors) {// Oblicz macierz obrotu // float rotationMatrix = new float; SensorManager.getRotationMatrixFromVector (rotationMatrix, wektory); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z; // Ponownie mapuj macierz na podstawie bieżącej orientacji działania // float wyregulowanyRotationMatrix = new float; SensorManager.remapCoordinateSystem (rotacjaMatrix, worldAxisX, worldAxisZ, wyregulowanaRotacjaMatrix); // Oblicz orientację urządzeń // floatorientation = new float; // Podaj tablicę wartości zmiennoprzecinkowych do metody getOrientation () // SensorManager.getOrientation (adjustRotationMatrix, orientacja); float pitch = orientacja * FROM_RADS_TO_DEGS; float roll = orientacja * FROM_RADS_TO_DEGS; // Zaktualizuj TextViews o wartości pitch i roll // pitchTextView.setText (getResources (). GetString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll)); }}

Możesz pobrać ukończony projekt z GitHub.

Testowanie naszej ostatecznej aplikacji czujnika Android

Aby przetestować tę aplikację czujnika wektora obrotu Android na fizycznym smartfonie lub tablecie z Androidem:

• Zainstaluj aplikację na swoim urządzeniu.
• Umieść smartfon lub tablet na płaskiej powierzchni. Pamiętaj, że czujniki ruchu są niezwykle czułe, dlatego zdaje się, że urządzenie z pozoru nieruchomym raportuje wahania wartości pochylenia i przechylenia.
• Aby przetestować wysokość dźwięku, podnieś dolną część urządzenia, aby odchylało się od Ciebie. Wartość skoku powinna się dramatycznie zmienić.
• Aby przetestować rzut, spróbuj podnieść lewą stronę urządzenia, aby przechylało się w lewo - miej oko na wartość rzutu!

Jeśli testujesz swój projekt na emulatorze:

• Zainstaluj aplikację na AVD.
• Wybierz „Więcej”, co spowoduje otwarcie okna „Rozszerzone elementy sterujące”.
• W menu po lewej stronie wybierz „Wirtualne czujniki”.
• Upewnij się, że wybrana jest karta „Akcelerometr”. Ta karta zawiera elementy sterujące, które mogą symulować zmiany położenia i orientacji urządzenia.
• Spróbuj eksperymentować z różnymi suwakami (Obróć: Z-Rot, X-Rot, Y-Rot; i Przenieś: X, Y i Z) oraz różnymi przyciskami „Obracanie urządzenia”, aby zobaczyć, jak wpływają one na „Czujnik przechyłu” w aplikacji ”I„ Pitch Sensor ”.

Podsumowując

W tym artykule widzieliśmy, jak pobierać dane z trzech głównych kategorii czujników Androida: środowisko, położenie i ruch oraz jak monitorować te dane w czasie rzeczywistym.

Czy widziałeś jakieś aplikacje na Androida wykorzystujące czujniki w interesujący lub wyjątkowy sposób? Daj nam znać w komentarzach poniżej!