Android Wear Programowanie urządzeń ubieralnych

Autorzy: Dawid Borycki

03.11.2014
WPROWADZENIE

Android Wear to interfejs programistyczny stworzony przez firmę Google dedykowany urządzeniom ubieralnym, a w szczególności inteligentnym zegarkom (smartwatch). Oprócz podstawowej funkcjonalności, polegającej na prezentacji czasu, umożliwiają one wykonywanie zadań charakterystycznych dla smartfonów. Inteligentne zegarki mogą posiadać wbudowane czujniki lokalizacji oraz biometryczne, analizujące chociażby puls serca ich użytkownika. Ponadto, urządzenia ubieralne typu smartwatch mogą być zsynchronizowane ze smartfonem lub tabletem z wykorzystaniem protokołu Bluetooth. Dzięki temu notyfikacje odbierane przez urządzenie główne mogą być wyświetlane na urządzeniu ubieralnym. Taka konfiguracja umożliwia inteligentnemu zegarkowi na wykorzystanie połączenia internetowego urządzenia nadrzędnego. W związku z tym programowanie aplikacji dla urządzeń ubieralnych polega na uzupełnianiu istniejących aplikacji dla systemu Android o dodatkowe aktywności (moduły), dedykowane urządzeniom ubieralnym. Pozwala to na wykonanie większości operacji, zwłaszcza tych długotrwałych, po stronie głównego urządzenia. Natomiast prezentacja wyników odbywa się na obydwu urządzeniach. Dodatkowo, technologia Android Wear umożliwia tworzenie niezależnych aplikacji dla urządzeń ubieralnych. W tym artykule skoncentruję się na drugiej z tych możliwości. W tym celu najpierw omówię proces instalacji oraz konfiguracji narzędzi programistycznych. W kolejnym kroku utworzę projekt typu „Witaj, Świecie!”, którego zadaniem będzie wyświetlenie statycznego komunikatu. Następnie rozszerzę funkcjonalność tego projektu o prezentację aktualnej godziny i rozpoznawanie mowy.


Rysunek 1. Właściwości systemu Windows 8.1 Pro

INSTALACJA I KONFIGURACJA NARZĘDZI PROGRAMISTYCZNYCH

Programowanie aplikacji dla systemu Android Wear wspierają dwa zintegrowane środowiska programistyczne (IDE): Eclipse z dodatkiem ADT (Android Developer Tools) oraz Android Studio. Chociaż drugie z wymienionych narzędzi dostępne jest w wersji beta, to jest ono zalecanym środowiskiem do tworzenia nowych projektów. Z tego powodu wykorzystam je w tym artykule. Podczas pisania tego artykułu Android Studio było dostępne w wersji 0.8.14, którą można pobrać spod adresu: https://developer.android.com/sdk/installing/ studio.html#download. Android Studio nie posiada tradycyjnego instalatora. W związku z tym dodatkowe narzędzia należy zainstalować i skonfigurować samodzielnie. Android Studio wymaga między innymi wcześniejszego zainstalowania narzędzi programistycznych Java Development Kit (JDK) oraz Android SDK Tools. Aktualne wersje JDK są dostępne pod adresem: http://www.oracle.com/ technetwork/java/javase/downloads/jdk8-downloads-2133151.html. Po pobraniu i zainstalowaniu JDK odpowiedniego dla posiadanego systemu operacyjnego należy skonfigurować zmienną środowiskową JAVA_HOME, aby wskazywała na folder JDK. W tym celu:

» Uruchamiamy przystawkę System, co można wykonać na co najmniej dwa sposoby :
  •  Klikamy prawym przyciskiem myszy ikonę Komputer i z menu kontekstowego wybieramy opcję Właściwości.
  •  W Panelu sterowania klikamy hiperłącze z etykietą System. W przypadku, gdy elementy Panelu sterowania są sortowane według kategorii, odnośnik System znajduje się w kategorii System i zabezpieczenia.
» W przystawce System (Rysunek 1) klikamy odnośnik Zaawansowane ustawienia systemu, co spowoduje uruchomienie okna Właściwości systemu (Rysunek 2), w którym klikamy przycisk z etykietą Zmienne środowiskowe.

» W kreatorze Zmienne środowiskowe (Rysunek 3) klikamy przycisk z etykietą Nowa…, a następnie w polu Nazwa zmiennej wpisujemy JAVA_HOME, a w polu wartość zmiennej umieszczamy ścieżkę folderu JDK (Rysunek 4).

» W celu aktywacji zmiennej środowiskowej należy wylogować i zalogować się ponownie do systemu operacyjnego.


Rysunek 2. Zaawansowane właściwości systemu


ANDROID WEAR. PROGRAMOWANIE URZĄDZEŃ UBIERALNYCH
 


Rysynek 3. Kreator zmienne środowiskowe


Rysunek 4. Tworzenie zmiennej środowiskowej



Rysunek 5. Android SDK Manager

Alternatywnym sposobem konfiguracji zmiennej środowiskowej jest wykorzystanie wiersza poleceń Windows, w którym wystarczy wydać następujące polecenie:


set JAVA_HOME=%ProgramFiles%\Java\jdk1.8.0_25\

w przypadku wersji x64 lub:

set JAVA_HOME=%ProgramFiles(x86)%\Java\jdk1.8.0_11\

w przypadku wersji x86 JDK. Poprawność konfiguracji zmiennej JAVA_HOME można wówczas sprawdzić, wydając polecenie:

echo %JAVA_HOME%

W efekcie polecenie to powinno wyświetlić ścieżkę określoną powyżej. W kolejnym kroku pobieramy narzędzia Android SDK tools. Odpowiedni instalator jest dostępny pod adresem: http://dl.google.com/android/installer_r23.0.2-windows.exe. Sam proces instalacyjny Android SDK wymaga jedynie wcześniejszego zainstalowania JDK i przebiega automatycznie. W związku z tym opis instalacji nie wymaga dłuższego komentarza. Po zainstalowaniu narzędzi Android SDK należy je skonfigurować za pomocą aplikacji SDK Manager. Po uruchomieniu tej aplikacji, na liście pakietów (Rysunek 5) zaznaczamy, a następnie instalujemy następujące elementy:
» Grupa Tools: Android SDK Tools, Android SDK Platform-tools Rev. 21 oraz Android SDK Build-tools 21.1.1.
» Android 4.4W.2 (API 20).
» Grupa Extras: Android Support Repository, Android Support Library, Google Play services Google Repository oraz Intel x86 Emulator Accelerator (HAXM installer).

Po zainstalowaniu pakietów przygotujmy wirtualne urządzenie Android Wear. W tym celu w aplikacji SDK Manager klikamy opcję Manage AVDs… z menu Tools, co spowoduje uaktywnienie kreatora Android Virtual Device (AVD) Manager, w którym klikamy przycisk z etykietą Create… Następnie, w kreatorze tworzenia nowego wirtualnego urządzenia konfigurujemy je według wzoru z rysunku 6.


Rysunek 6. Definicja nowego wirtualnego urządzenia ubieralnego

Po zainstalowaniu i skonfigurowaniu JDK oraz Android SDK można przystąpić do instalacji Android Studio, co polega na rozpakowaniu pobranego wcześniej archiwum. W kolejnym kroku wystarczy uruchomić plik studio.exe lub studio64.exe, w zależności od posiadanego systemu operacyjnego. Oba pliki znajdują się w folderze bin rozpakowanego archiwum.
Uruchomienie Android Studio może opcjonalnie wymagać wcześniejszego zainstalowania środowiska uruchomieniowego Visual C++ Redistributable Package for Visual Studio 2010, które jest dostępne pod adresem: http://www. microsoft.com/en-us/download/details.aspx?id=5555. O konieczności ich instalacji świadczy komunikat o braku pliku MSVCRT10.dll, który może pojawić się podczas próby uruchomienia Android Studio.
Po poprawnym uruchomieniu Android Studio, jego ekran startowy powinien być analogiczny do przedstawionego na Rysunku 7. Ekran ten pozwala między innymi na utworzenie nowego projektu, jednak zanim do tego przejdziemy, konieczne jest wskazanie ścieżki do Android SDK w Android Studio.

PROGRAMOWANIE URZĄDZEŃ MOBILNYCH

W tym celu klikamy opcję Configure, a następnie Project Defaults i Project Structure. Spowoduje to uruchomienie kreatora, w którym w polu Android SDK location wskazujemy ścieżkę do folderu, w którym zainstalowaliśmy te narzędzia (Rysunek 8). Po skonfigurowaniu ścieżki do Android SDK możliwe będzie uruchamianie aplikacji Android SDK Manager z poziomu Android Studio.
 
Rysunek 7.Ekran powitalny Android Studio IDE


Rysunek 8. Kreator Project Structure w Android Studio

TWORZENIE PROJEKTU


Po przygotowaniu środowiska programistycznego można przystąpić do utworzenia pierwszej aplikacji dla systemu Android Wear. W tym celu w ekranie powitalnym Android Studio (Rysunek 5) klikamy odnośnik New Project… Spowoduje to uruchomienie kreatora nowego projektu, w którym (Rysunek 9):
» Zmieniamy nazwę aplikacji na HelloWorldWear
» W polu Company name wpisujemy programistamag.pl, a następnie definiujemy lokalizację plików projektu
» Po kliknięciu przycisku z etykietą Next zostanie wyświetlona lista urządzeń wspieranych przez aplikację HelloWorldWear. Zaznaczamy w niej tylko pozycję Wear
» W kolejnym kroku kreatora zaznaczamy opcję Blank Wear Activity i klikamy przycisk z etykietą Next
» W ostatnim kroku kreatora konfigurujemy nazwę aktywności aplikacji. W tym celu w polu ActivityName wpisujemy HelloWorldActivity. Nazwy pozostałych pól zostaną skonfigurowane automatycznie. Klikamy przycisk z etykietą Finis


Rysunek 9. Kreator tworzenia nowego projektu w Android Studio


Po utworzeniu projektu nastąpi uruchomienie Android Studio. Za jego pomocą możliwe staje się projektowanie oraz edycja kodu źródłowego aplikacji. Jednak zanim do tego przejdziemy, uruchomimy domyślną wersję projektu HelloWorldWear. Projekt ten można uruchomić w utworzonym wcześniej wirtualnym urządzeniu ubieralnym. W tym celu wystarczy za pomocą edytora konfiguracji (Rysunek 10) wskazać odpowiednie urządzenie. Edytor konfiguracji uruchamia się za pomocą przycisku opcji Edit Configurations w menu Run. Po skompilowaniu i uruchomieniu projektu (opcja Run 'app' z menu Run) uzyskamy efekt analogiczny do przedstawionego na Rysunku 11.


Rysunek 10. Wybór docelowego urządzenia


Rysunek 11. Aplikacja HelloWordWear w trakcie działania na emulatorze urządzenia AndroidWear z prostokątnym wyświetlaczem

Na strukturę projektu aplikacji HelloWorldWear składają się trzy foldery: manifests, java oraz res (Rysunek 12). Pierwszy z nich zawiera plik manifestu aplikacji, AndroidManifest.xml, i pozwala zdefiniować podstawowe parametry aplikacji, takie jak jej nazwa, ikona itp. Folder java zawiera pliki z kodem źródłowym implementujące logikę aplikacji. Z kolei widoki oraz zasoby aplikacji zawarte są w folderze res. Domyślnie w podfolderze drawable znajdują się ikony aplikacji dla różnych rozdzielczości wyświetlacza. Z kolei folder layout przechowuje widoki aplikacji.

Zegarki z zainstalowanym systemem Android Wear mogą mieć kształt zaokrąglony lub prostokątny. Z tego powodu podczas tworzenia aplikacji należy przewidzieć obie te możliwości i dostosować widoki aplikacji do kształtu urządzenia ubieralnego. Google udostępnia specjalny mechanizm, który rozpoznaje kształt urządzenia i na tej podstawie ładuje odpowiedni widok. Programista jest odpowiedzialny za przygotowanie dedykowanych widoków dostosowanych do kształtu urządzenia ubieralnego. Z tego powodu folder layout zawiera specyficzne pliki w formacie XML dla zaokrąglonego (round_activity_hello_world.xml) oraz prostokątnego (rect_activity_hello_world. xml) ekranu urządzenia mobilnego. Ładowanie wybranego widoku odbywa się z wykorzystaniem klasy WatchViewStub w momencie uruchamiania aktywności w ramach metody onCreate klasy HelloWorldActivity (Listing 1). Z kolei informacja o tym, że aktywność posiada różne widoki odpowiadające różnym ekranom urządzenia ubieralnego, zawarta jest w pliku activity_hello_world.xml (Listing 2)

       

ANDROID WEAR. PROGRAMOWANIE URZĄDZEŃ UBIERALNYCH



Listing 1. Definicja klasy HelloWorldActivity

 
public class HelloWorldActivity extends Activity {


   private TextView mTextView;

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_hello_world);
       final WatchViewStub stub = (WatchViewStub)
         findViewById(R.id.watch_view_stub);
       stub.setOnLayoutInflatedListener(
            new WatchViewStub.OnLayoutInflatedListener() {
         @Override
         public void onLayoutInflated(WatchViewStub stub) {
           mTextView = (TextView) stub.findViewById(R.id.text);
         }
      });
    } 
  }

Listing 2. Zawartość pliku activity_hello_world.xaml

<?xml version="1.0" encoding="utf-8"?>
<android.support.wearable.view.WatchViewStub        
xmlns:android=
"http://schemas.android.com/apk/res/android"    
xmlns:app=
"http://schemas.android.com/apk/res-auto"  
xmlns:tools=
"http://schemas.android.com/tools"  
android:id=
"@+id/watch_view_stub"  
android:layout_width="match_parent"  
android:layout_height
="match_parent"  
app:rectLayout="@layout/rect_activity_hello_world"  
app:roundLayout=
"@layout/round_activity_hello_world"  
tools:context=
".HelloWorldActivity" tools:deviceIds="wear">
</android.support.wearable.view.WatchViewStub>



Rysunek 12. Główny widok aplikacji Android Studio

ZEGAR CYFROWY I ANALOGOWY

Przejdźmy teraz do zmodyfikowania domyślnej zawartości projektu HelloWorldWear. Widok domyślnej aktywności urządzenia ubieralnego z prostokątnym wyświetlaczem uzupełnimy o zegar cyfrowy i analogowy. W tym celu w pliku rect_activity_hello_world.xml wstawmy polecenia z Listingu 3. W efekcie, po ponownym uruchomieniu aplikacji HelloWorldWear w emulatorze urządzenia ubieralnego, uzyskamy efekt widoczny na Rysunku 13.


Listing 3. Definicja widoku rect_activity_hello_world

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".HelloWorldActivity"







tools:deviceIds="wear_square">

<Text View

android:id="@+id/text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hello_square"
android:layout_gravity="center"/>

<AnalogClock


android:layout_width="wrap_content"
android:layout_height="130dp"
android:id="@+id/analogClock"
android:layout_gravity="center_horizontal"
android:layout_margin="5dp"/>

<textClock

android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/textClock"
android:layout_gravity="center_horizontal"
android:textSize="20sp"/>

</LinearLayout


Rysunek 13. Widok zmodyfikowanej wersji aplikacji HelloWorldWear

Android Studio pozwala edytować interfejs użytkownika (UI) na dwa sposoby. Pierwszy, który wykorzystaliśmy powyżej, polega na edycji odpowiedniego pliku XML. Natomiast drugi sposób projektowania UI opiera się na wizualnym projektowaniu widoku. Wybór danego mechanizmu projektowania interfejsu użytkownika realizuje się poprzez kliknięcie odpowiedniej zakładki Design lub Text widocznej w dolnej części okna Android Studio. Widok Design umożliwia wizualną inspekcję UI danego modułu (Rysunek 14). Ponadto, w tym trybie widoczna jest lista wszystkich dostępnych kontrolek (widok Palette), z których można korzystać podczas projektowania aktywności dla aplikacji systemu Android Wear. Analogicznie jak w innych zintegrowanych środowiskach programistycznych umieszczenie danej kontrolki w widoku sprowadza się do przeniesienia jej za pomocą techniki drag&drop w odpowiednie miejsce. Po umieszczeniu danej kontrolki w widoku możliwe jest również edytowanie jej własności. Służy do tego okno Properties.


Rysunek 14. Widok projektowania interfejsu użytkownika w AndroidWear



PROGRAMOWANIE URZĄDZEŃ MOBILNYCH

KOMENDY GŁOSOWE
Urządzenia ubieralne Android Wear, po
dobnie jak Google Glass, mogą być sterowane głosowo. Android Wear obsługuje kilka intencji głosowych, które pozwalają na uruchomienie wbudowanych funkcji systemowych, takich jak chociażby ustawienie alarmu, uaktywnienie modułu prezentującego zarejestrowany puls serca użytkownika czy też utworzenie notatki. Powyższe aktywności uruchamia się poprzez wypowiedzenie odpowiedniej sentencji: „OK Google, set an alarm for 8 AM”, „OK Google, what’s my bpm” lub „OK Google, take a note”.
W celu obsłużenia wbudowanych intencji głosowych w pliku manifestu aplikacji należy wskazać nazwę aktywności, która ma zostać uruchomiona po rozpoznaniu danej sentencji, oraz filtr intencji, na przykład:

<activity android:name="MyBpmActivity"
   <intent-filter
      <action android:name="vnd.google.fitness.VIEW" /> 
      <data android:mimeType=      
           "vnd.google.fitness.data_type/com.google.heart_rate.bpm" /> 
   </intent-filter
</activity>

Powyższa definicja spowoduje uruchomienie aktywności MyBpmActivity w reakcji na sentencje „OK Google, what’s my bpm”. Możliwość ta pozwala na uruchamianie aktywności na urządzeniu ubieralnym za pomocą komend głosowych.
W Android Wear istnieje również możliwość samodzielnego obsługiwania komend głosowych w oparciu o wbudowany moduł rozpoznawania mowy, Speech Recognizer. Zilustruję tę możliwość kolejnym przykładem, w ramach którego Speech Recognizer zostanie uruchomiony po kliknięciu analogowego zegara. Wypowiedziane polecenia zostaną następnie wyświetlone w polu tekstowym TextView. W celu zaimplementowania tej funkcjonalności należy zmodyfikować zawartość pliku HelloWorldActivity.java według wzoru z Listingu 4.
Po uruchomieniu aplikacji i kliknięciu zegara analogowego nastąpi aktywacja wbudowanego modułu rozpoznawania mowy, co realizuje metoda displaySpeechRecognizer. Polega ona na wywołaniu funkcji startActivityForResult z argumentem typu Intent określającym odpowiednią intencję. Treść rozpoznanego polecenia głosowego można odczytać z poziomu metody onActivitySearchResult, która stanowi funkcję zwrotną wywoływaną po zakończeniu działania aktywności rozpoznawania mowy.
Emulator urządzenia Android Wear nie obsługuje mikrofonu komputera, na którym jest uruchomiony. Jednakże polecenia głosowe można symulować, wpisując je z klawiatury. Po rozpoznaniu komendy następuje wyświetlenie jej treści w polu tekstowym. Cały ten proces ilustruje Rysunek 15.
Listing 4. Zawartość pliku HelloWorldActivity.java

package pl.programistamag.helloworldwear; 

import android.app.Activity; 
import android.content.Intent; 
import android.os.Bundle; 
import android.speech.RecognizerIntent; 
import android.support.wearable.view.WatchViewStub; 
import android.view.View; 
import android.widget.AnalogClock; 
import android.widget.TextView;
import java.util.List; 

public class HelloWorldActivity extends Activity { 
   private TextView mTextView
   private AnalogClock mAnalogClock; 

   private static final int SPEECH_REQUEST_CODE = 0; 

  @Override 
protected void onCreate(Bundle savedInstanceState) {    
  super.onCreate(savedInstanceState);   
  setContentView(R.layout.activity_hello_world); 
  final WatchViewStub stub = (WatchViewStub)    
    findViewById(R.id.watch_view_stub);
configureLayout(stub);
@Override
 protected void onActivityResult(int requestCode,
   int resultCode, Intent data) { 
 if (requestCode == SPEECH_REQUEST_CODE
     && resultCode == RESULT_OK) { 
   List<String> results = data.getStringArrayListExtra(    
     RecognizerIntent.EXTRA_RESULTS); 

   String spokenText = results.get(0); 
   mTextView.setText(spokenText); 
 } 
 super.onActivityResult(requestCode, resultCode, data); 
private void configureLayout(WatchViewStub stub) {    
  stub.setOnLayoutInflatedListener( 
     new WatchViewStub.OnLayoutInflatedListener() { 
        @Override 
        public void onLayoutInflated(WatchViewStub stub) { 
          mTextView = (TextView) stub.findViewById(R.id.text);

          configureClock(stub); 
       } 
   });
 } 
private void configureClock(WatchViewStub stub){ 
  mAnalogClock = (AnalogClock) stub.findViewById(R.id.analogClock);

  mAnalogClock.setOnClickListener(new View.OnClickListener() { 
     @Override 
      public void onClick(View v) {
         displaySpeechRecognizer();
       }
    }); 
private void displaySpeechRecognizer() { 
   Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);    intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,    
      RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);    
   startActivityForResult(intent, SPEECH_REQUEST_CODE); 
  }
}

  
  
Rysunek 15. Detekcja komend głosowych w aplikacji HelloWorldWear


ANDROID WEAR. PROGRAMOWANIE URZĄDZEŃ UBIERALNYCH 

PAROWANIE TELEFONU Z EMULATOREM URZĄDZENIA ANDROID WEAR

Testowanie niektórych funkcjonalności aplikacji dla Android Wear wymaga aktywnego połączenia pomiędzy urządzeniem głównym a ubieralnym. W tej części artykułu zaprezentuję procedurę synchronizacji telefonu Samsung Galaxy S3 z emulatorem urządzenia Android Wear. Synchronizacja telefonu z emulatorem składa się z następujących etapów:
» Na urządzeniu głównym pobieramy ze sklepu Google Play, a następnie instalujemy aplikację Android Wear.
» Na telefonie włączamy tryb debugowania USB. W przypadku telefonu Samsung Galaxy S3 opcja ta staje się dostępna po kilkukrotnym dotknięciu pozycji Numer wersji w menu Ustawienia/Więcej…/Informacje o urządzeniu.
» W kolejnym kroku wystarczy uruchomić Opcje programisty (Ustawienia/ Więcej…) i zaznaczyć pole wyboru Debugowanie USB (Rysunek 16), a następnie podłączyć telefon do komputera za pomocą kabla USB.
» W celu potwierdzenia poprawnego połączenia w wierszu poleceń należy wydać komendę:

adb devices

a następnie otworzyć port komunikacyjny 5601 poleceniem (Rysunek 17):

adb –d forward tcp:5601 tcp:5601
» Po uruchomieniu aplikacji Android Wear, w urządzeniu głównym wystarczy kliknąć ikonę ustawień, a następnie wybrać Pair with emulator. Spowoduje to nawiązanie połączenia z emulatorem. Od tej pory oba urządzenia są zsynchronizowane i mogą wymieniać informacje pomiędzy sobą.
» W celu przetestowania poprawności konfiguracji wystarczy z ustawień aplikacji Android Wear wybrać opcję Demo cards i wysłać do urządzenia ubieralnego dowolną kartę. W efekcie odpowiednie informacje będą prezentowane na ekranie urządzenia ubieralnego (Rysunek 18).


  
Rysunek 16. Aktywacja opcji programisty(lewy panel) i włączanie debugowania USB(prawy panel) na telefonie Samsung Galaxy S3


Rysunek 17. Konfiguracja portu komunikacyjnego z wykorzystaniem narzędzia adb


Rysunek 18. widok ekranu urządzenia ubieralnego po wysłaniu karty Package tracking

DETEKCJA LOKALIZACJI

Niektóre z urządzeń ubieralnych posiadają wbudowane czujniki GPS, które umożliwiają odczytywanie lokalizacji geograficznej bez użycia powiązanego urządzenia. W przypadku, gdy urządzenie ubieralne jest połączone z innym urządzeniem, to system Android automatycznie wybiera najbardziej optymalny sposób odczytania danych o aktualnej pozycji. Funkcjonalność ta jest zaimplementowana w ramach dostawcy Fusion location provider. Jednak zanim do tego przejdziemy, spróbujmy sprawdzić, czy emulator urządzenia posiada wirtualny odbiornik GPS. W tym celu nagłówek pliku HelloWorldActivity. java uzupełnijmy o deklarację:

import android.content.pm.PackageManager;


Natomiast w definicji klasy HelloWorldActivity wstawmy polecenia z Listingu 5:


Listing 5. Sprawdzenie, czy urządzenie ubieralne jest wyposażone we wbudowany odbiornik GPS


private void checkGps(){ 
   if(wearableHasGps()){ 
     mTextView.setText("Wearable equipped with built-in GPS");
   } 
   else
      mTextView.setText("No built-in GPS"); 
   } 

private boolean wearableHasGps() { 
  return getPackageManager().    
    hasSystemFeature(PackageManager.FEATURE_LOCATION_GPS); 
}



PROGRAMOWANIE URZĄDZEŃ MOBILNYCH

W ostatnim kroku przejdźmy do edycji funkcji configureLayout (Listing 4) i zastąpmy w niej wywołanie procedury configureClock metodą checkGps. Po uruchomieniu tak zmodyfikowanej aplikacji wynik jej działania powinien być analogiczny do przedstawionego na Rysunku 19, co pokazuje, że, jak można było się spodziewać, emulator urządzenia ubieralnego nie posiada odbiornika GPS.

Rysunek 19. Emulator urządzenia ubieralnego nie posiada czujnika GPS

W przypadku, gdy urządzenie ubieralne nie posiada wbudowanego czujnika GPS, może ono odczytać pozycję na podstawie danych z urządzenia głównego w oparciu o klasę FusedLocationApi. Aby móc z niej korzystać, w pliku manifestu należy:

» Umieścić następujące dwie deklaracje:

<uses-permission android:name="android.permission. ACCESS_COARSE_LOCATION"/> 
<uses-permission android:name="android.permission.
ACCESS_FINE_LOCATION"/>

» Natomiast sekcję application należy uzupełnić o deklaracje:

<meta-data android:name="com.google.android.gms.version"  android:value="@integer/google_play_services_version" /> 

Przykładową definicję procedur pobierających ostatnią znaną lokalizację przedstawia Listing 6. Użyte tam polecenia wymagają importu przestrzeni nazw, których listę zawiera Listing 7. Pobranie ostatniej znanej lokalizacji rozpoczynamy od sprawdzenia, czy usługi GooglePlay są dostępne. W przypadku, gdy warunek ten jest spełniony, można odczytać ostatnią znaną pozycję za pomocą metody getLastLocation klasy FusedLocationApi. Metoda ta przyjmuje jeden argument, typu GoogleApiClient, implementujący klienta serwisu interfejsów Google API typu REST. W tym konkretnym przykładzie ograniczyłem się do odczytywania ostatniej znanej lokalizacji. Aczkolwiek w praktycznym zastosowaniu aplikacja może wymagać ciągłego odczytywania lokalizacji lub jej zmiany. W takiej sytuacji można skorzystać z metody FusedLocationApi. requestLocationUpdates. Umożliwia ona automatyczne odczytywanie zmian położenia geograficznego w określonych interwałach czasowych. Informacje te są wówczas przekazywane w ramach funkcji zwrotnej onLocationChanged klasy implementującej interfejs LocationListener.

Listing 6. Pobranie informacji o położeniu geograficznym

private void getLocationFromGooglePlay() {   
  if(GooglePlayServicesUtil.isGooglePlayServicesAvailable(this
      == ConnectionResult.SUCCESS) { 
    getAndDisplayLocation(); 
   } 
  else
     mTextView.setText("Google services are not available");
  } 
private void getAndDisplayLocation() { 
   GoogleApiClient googleApiClient; 

   googleApiClient = new GoogleApiClient.Builder(this)    
      .addApi(LocationServices.API
      .build(); 

   googleApiClient.connect(); 

   Location location = LocationServices.FusedLocationApi.    
     getLastLocation(googleApiClient); 

   if(location != null) { 
     mTextView.setText(location.toString()); 
    } 
    else
       mTextView.setText("Can not determine location"); 
    } 

   googleApiClient.disconnect(); 
}

Listing 7. Lista przestrzeni nazw wymaganych przez polecenia z Listingu 6

import android.location.Location; 
import android.os.Bundle; 
import com.google.android.gms.common.ConnectionResult; 
import com.google.android.gms.common.GooglePlayServicesUtil; 
import com.google.android.gms.common.api.GoogleApiClient; 
import com.google.android.gms.location.LocationServices; 
import com.google.android.gms.wearable.Wearable;

PODSUMOWANIE

W tym artykule zaprezentowałem opis instalacji oraz konfiguracji środowiska programistycznego Android Studio na potrzeby projektowania oraz programowania aplikacji dla systemu Android Wear. W ramach przykładowych projektów utworzyłem zegar cyfrowy oraz analogowy, uzupełniłem projekt aktywności o rozpoznawanie poleceń głosowych. Dodatkowo pokazałem, w jaki sposób uzyskać informacje o położeniu geograficznym na podstawie klasy FusedLocationApi.
   Konfiguracja środowiska programistycznego wymagała sporo pracy, aczkolwiek powyższy opis stanowi kompletny przewodnik umożliwiający rozpoczęcie tworzenia bardziej zaawansowanych aplikacji na platformę Android Wear, co może okazać się szczególnie przydatne dla początkujących programistów aplikacji dla platformy Android.