I. Usługi. Usługa może przyjąć dwie formy:

Transkrypt

1 I. Usługi Usługa (Service) jest komponentem aplikacji, który pozwala wykonywać w tle długodziałające operacje, które nie dostarczają żadnego interfejsu użytkownika. Komponent aplikacji może uruchomić usługę, która będzie kontynuowała swoje działanie nawet gdy użytkownik przełączy się do innej aplikacji. Dodatkowo, komponent aplikacji może związać się z usługą aby komunikować się z nią oraz wymieniać z nią dane. Dla przykładu, usługa może obsługiwać transakcje w sieci, odtwarzać muzykę, wykonywać przetwarzanie plików lub komunikować się z dostawcą treści. Usługa może przyjąć dwie formy: Uruchomionej tzn. w przypadku gdy komponent aplikacji wywoła usługę metodą startservice(). Raz uruchomiona, usługa może działać w tle bez końca, nawet gdy komponent ją uruchamiający zostanie zniszczony. Zwykle usługi uruchomione w tej postaci wykonują prostą operację i nie zwracają żadnego rezultatu do komponentu wywołującego. W takiej formie usługa może służyć do pobierania lub wysyłania plików przez sieć. W przypadku gdy operacje zostaje zakończona, usługa powinna zatrzymać się samoczynnie. Związanej tzn. w przypadku gdy komponent aplikacji wywoła usługę metodą bindservice(). Usługa związana oferuje interfejs klient-serwer, który pozwala mu komunikować się z komponentami, wysyłać żądania, pobierać rezultaty. Usługa związana działa tak długo, jak długo inny komponent aplikacji jest z nią związany. Z jedną usługą mogą być związane wiele komponentów, jednak gdy wszystkie one zostaną odłączone od usługi, usługa jest niszczona. W praktyce jednak usługa może przyjąć zarówno postać uruchomionej jak i związanej. Może być zarówno uruchomiona jak i związana wszystko zależy od tego, jakie metody implementuje: onstartcommand(), który służy do uruchamiania usługi czy onbind(), która służy do jej związania z komponentem. Niezależnie do tego w jakiej formie usługa została zaimplementowana, komponent aplikacji może jej używać w takich sam sposób jak używane są aktywności poprzez uruchomienie jej z udziałem intencji. Należy zwrócić uwagę na pewne ograniczenia związane z mechanizmem usługi. Usługa funkcjonuje w głównym wątku procesu, który ją wywołał nie tworzy zatem własnego wątku ani nie funkcjonuje w osobnym procesie. Oznacza to, że jeżeli usługa będzie służyła do wykonywania pewnych czynności mocno obciążających procesor lub operacji blokujących aplikację (jak np. odtwarzanie plików MP3), powinien być dla niej utworzony osobny wątek. Poprzez wykorzystanie osobnych wątków dla usług, zmniejsza się ryzyko wystąpienia tzw. błędów ANR (Application Not Responding), polegających na nie odpowiadaniu na akcje użytkownika (potocznie zwane zawieszeniem aplikacji). W celu utworzenia usługi konieczne jest stworzenie klasy dziedziczącej po klasie Service (lub jej klasach potomnych). Implementacja powinna zawierać przesłonięte metody, które pozwolą obsłużyć cykl życia usługi oraz zapewnią, w razie konieczności, powiązanie usługi z komponentem aplikacji. Najważniejszymi metodami, które powinny zostać przesłonięte są: onstartcommand() system wywołuje tę metodę, w przypadku gdy inny komponent (np. aktywność) wywoła metodę startservice(). Gdy metoda ta zostanie wykonana, usługa zostaje uruchomiona i może działać w tle bez końca. Jeżeli metoda onstartcommand() zostanie zaimplementowana, obowiązek zatrzymania usług 1

2 spoczywa na programiście, który musi w odpowiedni sposób wywołać metodę stopself() bądź stopservice(). onbind() - system wywołuje tę metodę, w przypadku gdy inny komponent (np. aktywność) wywoła metodę bindservice(). We własnej implementacji metody, programista musi dostarczyć interfejs dla klienta, który pozwoli mu komunikować się z usługą, zwracają tzw. obiekt klasy IBinder. Ta metoda zawsze powinna być implementowana, jednak gdy usługa w zamierzeniu ma nie przyjmować formy związanej, metoda onbind() powinna zwracać wartość null. oncreate() system wywołuje tę metodę, kiedy usługa jest pierwszy raz tworzona. W tej metodzie zapewnia się procedury ustawienia funkcjonowania usługi (zanim zostaną wywołane metod onstartcommand() bądź onbind()). Jeżeli usługa jest już uruchomiona, ta metoda nie zostanie wywołana. ondestroy() system wywołuje tę metodę, kiedy usługa nie jest już wykorzystywana i należy ją zniszczyć. Własna implementacja tej metody powinna wprowadzać procedury oczyszczania zasobów wykorzystywanych przez usługę takich, jak wątki, zarejestrowani słuchacze, odbiorcy komunikatów, itd. System Android może wymusić zatrzymanie usługi tylko w przypadku niskich zasobów pamięci, które muszą zostać pozyskane dla aktywności, na której skupiony jest użytkownik. Jeżeli usługa została uruchomiona i działa już przez dłuższy czas, system obniża jej pozycję na liście zadań w tle, co powoduje zwiększenie prawdopodobieństwa jej usunięcia. Jeżeli usługa zostanie zniszczona, zostanie ponownie uruchomiona tak szybko jak to możliwe, tzn. gdy będą dostępne odpowiednie dla niej zasoby. Więcej informacji o usługach można znaleźć pod adresem: Przedstawiony tutaj przykład jest implementacją usługi pracującej w głównym procesie aplikacji oraz usługi, która obsługuje tryb wielu żądań i tworzy wiele oddzielnych wątków, które wykonują czynności i niezależnie samoczynnie się zatrzymują. Implementacja głównej klasy aplikacji została przedstawiona poniżej. public class MainActivity extends Activity implements OnClickListener{ private static final String TAG = "Aktywność"; Button buttonstart, buttonstop, buttonstart2; protected void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.activity_main); buttonstart = (Button) findviewbyid(r.id.button1); buttonstop = (Button) findviewbyid(r.id.button2); buttonstart2 = (Button) findviewbyid(r.id.button3); buttonstart.setonclicklistener(this); buttonstop.setonclicklistener(this); buttonstart2.setonclicklistener(this); 2

3 public void onclick(view v) { // TODO Auto-generated method stub switch (v.getid()) { case R.id.button1: Log.d(TAG, "onclick: uruchomienie usługi"); startservice(new Intent(this, MyService.class)); break; case R.id.button2: Log.d(TAG, "onclick: zatrzymanie usługi"); stopservice(new Intent(this, MyService.class)); break; case R.id.button3: startservice(new Intent(this, HelloService.class)); break; Główna klasa przykładowej aplikacji (aktywność MainActivity) implementuje interfejs OnClickListener, który posłuży do obsługi 3 przycisków znajdujących się w układzie aktywności. Przyciski Uruchom usługę i Zatrzymaj usługę (pola buttonstart i buttonstop ). Pole buttonstart2 związane jest z przyciskiem wywołującym usługę w nowym niezależnym wątku. W metodzie onclick dodatkowo wykorzystano klasę Log, która służy do wypisywania w zakładce LogCat (Eclipse) komunikatów pochodzących z urządzenia. Klasa posiada kilka metod, a wykorzystana tu metoda d wyświetla informacje debuggera, oznaczone poprzez wartość znajdującą się w stałej TAG, o treści przedstawionej w kodzie. Do klasy dodane zostały dwie usługi klasy MyService i HelloService, rozszerzające klasę Service. Klasa MyService implementuje usługę działającą w głównym wątku procesu aplikacji. Implementacja klasy HelloService opisuje usługę pracującą w trybie wielowątkowym, a jej struktura pochodzi ze strony: Poniżej zaprezentowana została implementacja klasy MySerivce. public class MyService extends Service { private static final String TAG = "Usługa"; private String mydate; public IBinder onbind(intent intent) { return null; public void oncreate() { mydate = java.text.dateformat.getdatetimeinstance().format(calendar.getinstance().gettime() ); Toast.makeText(this, "Usługa utworzona " + mydate, Toast.LENGTH_LONG).show(); Log.d(TAG, "oncreate"); public void ondestroy() { mydate = java.text.dateformat.getdatetimeinstance().format(calendar.getinstance().gettime() ); 3

4 Toast.makeText(this, "Usługa zniszczona " + mydate, Toast.LENGTH_LONG).show(); Log.d(TAG, "ondestroy"); public void onstart(intent intent, int startid) { Toast.makeText(this, "Usługa uruchomiona", Toast.LENGTH_LONG).show(); Log.d(TAG, "onstart"); Usługa MyService nie obsługuje trybu powiązania z komponentem, dlatego metoda onbind zwraca wartość null. W metodzie oncreate w kontrolce Toast wyświetlany jest odpowiedni komunikat o utworzeniu usługi, zawierający datę i czas tego zdarzenia (zmienna mydate ). W metodzie ondestroy i onstart również generowana jest kontrolka Toast, wyświetlająca stosowne informacje. Bardziej złożoną strukturę prezentuje klasa HelloService, reprezentująca usługę wielowątkową. W pierwszej kolejności pokazana została sekcja pól danych, w których zdefiniowano obiekty klas Looper i ServiceHandler. Klasa Looper reprezentuje pętle komunikatów związanych z danym wątkiem, w której pojawiają się różne komunikaty obsługiwane przez wątek. Klasa ServiceHandler jest w tym wypadku klasą rozszerzająca Handler, która obsługuje pętle komunikatu wątku, w którym powstał obiekt ServiceHandler. public class HelloService extends Service { private Looper mservicelooper; private ServiceHandler mservicehandler; // Handler który odbiera wiadomości z wątku private final class ServiceHandler extends Handler { public ServiceHandler(Looper looper) { super(looper); public void handlemessage(message msg) { // Uśpienie wątku na 5 sekund. long endtime = System.currentTimeMillis() + 5*1000; while (System.currentTimeMillis() < endtime) { synchronized (this) { try { wait(endtime - System.currentTimeMillis()); catch (Exception e) { // Usługa zostanie zatrzymana przy wykorystaniu startid //,aby nie zatrzymywać jej w trakcie obsługi innej czynności stopself(msg.arg1); Aby zasymulować jakąś czynność w metodzie handlemessage (która obsługuje komunikaty) zaimplementowano pętlę, w której za pomocą metody wait następuje zastopowanie wątku na czas wyrażony w postaci milisekund wprowadzonych jako argument metody. W pętli został wykorzystany tzw. blok zsynchronizowany (słówko synchronized ). Za pomocą tego wyrażenia możliwe jest blokowanie dostępu do bloku instrukcji znajdujących się dalej pomiędzy klamrami (metoda wait) przed referencją na obiekt podany jako argument metody synchronized. A więc synchronized(this) 4

5 {..blok blokuje dostęp do bloku przed obiektem klasy ServiceHandler. Po spełnieniu warunku pętli (odczekaniu 5 sekund) następuje zatrzymanie usługi o przekazanym argumencie strartid z komunikatu (klasa Message). Poniżej w metodzie oncreate tworzony jest wątek posiadający pętle komunikatów (Looper), będący obiektem klasy HandlerThread. Dla wątku ustawiany jest priorytet wykonywania w tle (THREAD_PRIORITY_BACKGROUND), a następnie za pomocą metody start, wątek jest uruchamiany. Kolejno tworzona jest pętla komunikatów (mservicelooper) oraz nowy obiekt klasy ServiceHandler, wykorzystujący wcześniej utworzoną pętlę komunikatów. Komunikat tworzony jest w metodzie onstartcommand, której implementację zaprezentowano poniżej. public int onstartcommand(intent intent, int flags, int startid) { Toast.makeText(this, "Usługa uruchomiona w oddzielnym wątku", Toast.LENGTH_SHORT).show(); // Przy każdorazowym uruchomieniu, wysyłany jest komunikat o rozpoczęciu pracy // oraz przesyłany jest identyfikator startu (startid), który jednoznacznie // pozwala stwierdzić, które usługi mają zostać zatrzymane w przypadku żądania. Message msg = mservicehandler.obtainmessage(); msg.arg1 = startid; mservicehandler.sendmessage(msg); gdy // Stała zapewniająca ponowny restart od tego miejsca, w przypadku, // usługa zostanie zniszczona. return START_STICKY; Obiekt klasy Message tworzony jest na podstawie komunikatu pozyskanego z pętli komunikatów wątku (mservicehandler). Następnie do zmiennej arg1 komunikatu, zapisywany jest identyfikator uruchomienia wątku (startid) i tak zmodyfikowana wiadomość (msg) trafia z powrotem do ServiceHandlera za pomocą metody sendmessage. Metoda onstartcomman zwraca stałą START_STICKY, która zapewnia restart usługi, w przypadku jej zniszczenia. Ostatnimi zaimplementowanymi metodami w klasie HelloService są metody onbind i ondestroy, przedstawione poniżej. public IBinder onbind(intent intent) { return null; public void ondestroy() { Toast.makeText(this, "Zakończono wykonywanie usługi", Toast.LENGTH_SHORT).show(); 5

6 Przykładowy ekran opisanej aplikacji przedstawiono na rys. 1. Uwidoczniono na nim moment generowania kontrolki Toast podczas wywołania metody oncreate dla usługi klasy MyService (uruchomionej w wątku aplikacji). Rys. 1 Przykładowy ekran aplikacji wykorzystującej usługi. Utworzenie usługi w głównym wątku aplikacji. Parokrotne kliknięcie w przycisk Uruchom usługę nic nie da, ponieważ wcześniejsza usługa musi zostać zatrzymana (należy kliknąć w przycisk Zatrzymaj usługę. Natomiast w odróżnieniu od usługi MyService, usługa wykonywana we własnym wątku, może być tworzona niezależnie. Stąd wielokrotne kliknięcie w przycisk Uruchom usługę w oddzielnym wątku powoduje utworzenie wielu wątków usług i ich systematyczne zakańczanie po 5 sekundach, w kolejności kliknięcia. II. AsyncTask Podczas uruchamiania komponentu aplikacji, w przypadku gdy aplikacja nie posiada innych działających komponentów, system Android uruchamia dla aplikacji nowy proces linuksowy, wykonywany jednowątkowo. Domyślnie, wszystkie komponenty tej samej aplikacji funkcjonują w tym samym procesie i wątku (zwanym wątkiem głównym ). W przypadku gdy uruchamiany jest komponent aplikacji i istnieje już proces przydzielony tej aplikacji, komponent uruchomiony zostaje w tym procesie i wykorzystuje ten sam wątek do wykonywania operacji. Android może zadecydować w pewnym momencie wykonywania operacji o zakończeniu procesu, w przypadku gdy ilość dostępnej pamięci jest niska a inne procesu potrzebują pamięci, aby szybciej dostarczyć odpowiedź do użytkownika. Komponenty aplikacji uruchomione w procesie, który został zniszczony zostają również unicestwione. Zabity proces uruchamiany jest ponownie, w przypadku gdy pewne komponenty zażądają jego wykonania. System Android stara się zarządzać procesem aplikacji tak długo, jak to jest możliwe. Istnieją jednak sytuacje, w których usuwane są stare procesy w celu odzyskania pamięci dla nowych lub bardziej istotnych procesów. Aby określić, które procesy powinny zostać zachowane, a które zniszczone, systemu umieszcza je wszystkie w tzw. hierarchii ważności, bazującej na komponentach działających w tym procesie oraz stanie tych komponentów. Procesy o najniższej ważności są 6

7 eliminowane jako pierwsze, następnie w razie konieczności, usuwane są procesy na kolejnym poziomie ważności, itd. Hierarchia ważności procesu podzielona została na 5 rodzajów procesów, które mogą być usunięte przez system (w kolejności od najbardziej istotnego po najmniej istotny): Proces pierwszego planu jest wymagany do operacji, wykonywanych na bieżąco przez użytkownika, Proces widoczny proces nie posiadających żadnych komponentów na pierwszym planie wykonania, jednak mający ciągły wpływ na to, co dzieje się na ekranie, Proces usługi proces, który przetwarza usługę wywołaną za pomocą metody startservice, który nie został jeszcze zdegradowany na jeden z dwóch poniższych poziomów, Proces tła proces przechowujący aktywność, która nie jest aktualnie widoczna dla użytkownika, a więc nie ma bezpośredniego wpływu na to, co wykonuje użytkownik. Pusty proces proces, który nie przechowuje żadnych aktywnych komponentów aplikacji. Jedynym powodem nie niszczenia tego procesu są mechanizmy pamięci podręcznej, które mogą być z nim związane (skracają np. czas wywołania innych komponentów). Kiedy aplikacja jest uruchomiona, system tworzy wątek wykonania dla aplikacji, którego potocznie nazywa się wątkiem głównym. Jest to bardzo ważny wątek odpowiedzialny za kontrolę zdarzeń generowanych przez odpowiednie elementy interfejsu użytkownika, włączając w to proces rysowania. Jest to również wątek, w którym aplikacja współpracuje z komponentami pochodzącymi z zestawy Android UI (User Interface). W związku z tym, główny wątek jest często nazywany wątkiem interfejsu użytkownika (UI). System nie tworzy oddzielnych wątków dla każdej instancji komponentu wszystkie komponenty uruchomione w tym samym procesie są przetwarzane w wątku UI i to właśnie w nim następuje komunikacja pomiędzy komponentami a systemem. W konsekwencji, metody, które reagują na sprzężenia zwrotne systemu (np. metody nasłuchiwaczy kliknięcia czy wciśnięcia klawisza) zawsze uruchomione są w wątku UI procesu aplikacji. Kiedy aplikacja wymaga intensywnej pracy, której wyniki są potwierdzone w postaci interakcji z użytkownikiem, model jednowątkowy może przynieść duży spadek wydajności aplikacji. Jeżeli wszystkie operacja przetwarzane są w głównym wątku UI, przetwarzanie operacji wymagających czasu (np. zapytanie do bazy danych) może powodować blokadę całego interfejsu aplikacji. Kiedy wątek UI jest blokowany, nie obsługuje żadnych żądań, włączając w to operacji rysowania. Z punktu widzenia użytkownika, aplikacja się zawiesza. W przypadku, gdy blokada głównego wątku trwa dłużej niż ok. 5 sekund, użytkownik może zobaczyć na ekranie okno dialogowe, mówiące o błędzie ANR (Application Not Responding). Dobrym rozwiązaniem w przypadku operacji dłużej przetwarzanych, jest wykorzystanie tzw. zadania asynchronicznego klasy AsyncTask. AsyncTask pozwala wykonywać operacje mogące blokować wątek główny, w tzw. wątkach roboczych, a następnie publikować wyniki w do wątku UI, bez konieczności implementacji obsługi wątków oraz ich handlerów do obsługi komunikatów. 7

8 Aby wykorzystać możliwości AsyncTask, należy stworzyć podklasę dla AsyncTaska i zaimplementować kilka metod, związanych z przetwarzaniem i wyświetlaniem wyników pracy wątku. W pierwszej kolejności należy zaimplementować metodę doinbackground, w której wykonuje się operacje w przestrzeni wątku w tle. Do aktualizacji interfejsu, powinna zostać zaimplementowana metoda onpostexecute, która dostarcza wyników z metody doinbackground i działa wątku głównym. Zadanie może zostać uruchomione poprzez wywołanie metody execute w głównym wątku aplikacji. Zasady przetwarzania AsyncTask wygląda następująco: Określa się typy parametrów, wartości postępu oraz wynikowe wartości zadania, przy wykorzystaniu typów wbudowanych, Metoda doinbackground jest automatycznie wykonywana w wątku roboczym, Metody onpreexecute, onpostexecute i onprogressupdate są wywoływane z wątku UI, Wartość zwrócona przez metodę doinbackground jest wysyłana do metody onpostexecute, Metoda publishprogress może być wywołana w metodzie doinbackground w dowolnym momencie, aby wywołać metodę onprogressupdate z głównego wątku aplikacji (wątku UI), Zadanie AsyncTask może być anulowane w dowolnym momencie przez dowolny wątek. Dla zaprezentowania mechanizmu zadania AsyncTask zaimplementowano pokazową aplikację, które symuluje wykonywanie określonej czynności w czasie podanym jako parametr przez użytkownika. Dodatkowo postęp wykonania jest ukazany z wykorzystaniem kontrolki paska postępu (ProgressBar). W opisywanej dalej aplikacji utworzona została aktywność AsyncMainActivity z wewnętrzną klasą AsyncTaskRunner. Poniżej zaprezentowano sekcję pól klasy AsyncMainActivity oraz implementację metody oncreate i onclick. W klasie zdefiniowano obiekt dla kontrolek Button, EditText, TextView oraz ProgressBar. Przycisk służy do uruchomienia zadania klasy AsyncTaskRunner. W kontrolce EditText użytkownik wprowadza liczbę milisekund, definiującą czas wykonania zadania. W kontrolce TextView oraz ProgressBar udostępniane są wyniki uzyskane z zadania AsyncTaskRunner. W metodzie oncreate tworzone są obiekty kontrolek interfejsu oraz ustawiany jest anonimowy nasłuchiwacz kliknięcia dla przycisku. Metoda onclick interfejsu OnClickListener tworzy obiekt klasy AsyncTaskRunner, pobiera wartość wpisaną przez użytkownika w polu edycyjnym, wywołuje zadanie (metoda execute) oraz zeruje pasek postępu. W metodzie execute, parametrem przekazanym do zadania jest obiekt przechowujący liczbę milisekund, podaną przez użytkownika w polu edycyjnym. public class AsyncMainActivity extends Activity { 8

9 private Button button; private EditText time; private TextView finalresult; private ProgressBar progressbar; protected void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.activity_async_main); time = (EditText) findviewbyid(r.id.et_time); button = (Button) findviewbyid(r.id.btn_do_it); finalresult = (TextView) findviewbyid(r.id.tv_result); progressbar = (ProgressBar)findViewById(R.id.progressBar1); progressbar.setprogress(0); button.setonclicklistener(new View.OnClickListener() { public void onclick(view v) { AsyncTaskRunner runner = new AsyncTaskRunner(); String sleeptime = time.gettext().tostring(); runner.execute(sleeptime); progressbar.setprogress(0); ); Poniżej zaprezentowano implementację wewnętrznej klasy zadania asynchronicznego o nazwie AsyncTaskRunner, będącej podklasą AsyncTask. Początkowo przedstawiono nagłówek tej klasy oraz implementacje metody doinbackground. W klasie zdefiniowano pole resp przechowujące wyniki przetwarzania. W metodzie doinbackground wykonywana jest pętla symulująca wykonywanie operacji, w której na krótką chwilę (time/100) usypiany jest wątek zadania oraz wywoływana jest metoda publishprogress, przekazująca parametr w postaci zmiennej iteracyjnej pętli do metody onprogressupdate. Po wykonaniu metody doinbackground zwracany jest napis zapisany w polu resp. Zmienna przekazana jako parametr do zadania asynchronicznego, jest wcześniej zamieniana do postaci liczby całkowitej (Integer.parseInt). private class AsyncTaskRunner extends AsyncTask<String, Integer, String> { private String resp; protected String doinbackground(string... params) { try { int time = Integer.parseInt(params[0]); for (int i=0; i<=100; i++) { Thread.sleep(time/100); publishprogress(i); resp = "Zadanie wykonane"; catch (InterruptedException e) { e.printstacktrace(); resp = e.getmessage(); catch (Exception e) { e.printstacktrace(); resp = e.getmessage(); return resp; 9

10 Następnie zaimplementowane zostały w klasie AsyncTaskRunner pozostałe metody zadania, przedstawione poniżej. protected void onpostexecute(string result) { finalresult.settext(result); protected void onpreexecute() { protected void onprogressupdate(integer... progress) { progressbar.setprogress(progress[0]); finalresult.settext("zadanie wykonane w " + progress[0] + " %"); Metoda onpostexecute wywołana jest po skończeniu przetwarzania metody doinbackground, zwracającej wartość pola resp. Wartość ta jest następnie użyta jako parametr wejściowy metody onpostexecute, która ustawia wynikowy napis w kontrolce TextView. Metoda onprexecute nie została zaimplementowana. W niej należy wykonać pewne operacje potrzebne przed wykonaniem metody doinbackground (np. wywołanie okna dialogowego z paskiem postępu). W metodzie onprogressupdate aktualizowany jest widok kontrolek ProgressBar oraz TextView, z wykorzystaniem parametru przekazanego z metody doinbackground przy wywołaniu metody publishprogress. Aplikacja obrazuje postęp wykonania poprzez animację paska postępu. Jego definicja została zaimplementowana w pliku activity_async_main.xml, którego fragment przedstawiono poniżej. <ProgressBar android:id="@+id/progressbar1" style="?android:attr/progressbarstylehorizontal" android:progressdrawable="@drawable/progress_bar_states" android:layout_width="400dip" android:layout_height="50dip" android:layout_alignleft="@+id/tv_time" android:layout_marginright="9dip" android:layout_margintop="15dip" android:layout_marginleft="260dip" android:minheight="60dip" android:layout_centervertical="true" /> Dla paska postępu określono wbudowany styl poziomego paska postępu (właściwość style ) oraz wskazano na zasoby drawable, związane z wyglądem graficznym paska. Elementy te zostały zdefiniowane w pliku progress_bar_states.xml, którego zawartość przedstawiono poniżej. <layer-list xmlns:android=" <item android:id="@android:id/background"> <shape android:shape="rectangle"> <corners android:radius="10px" /> <gradient android:startcolor="#000001" android:centercolor="#0b131e" android:centery="0.25" 10

11 android:endcolor="#0d1522" android:angle="90" /> </shape> </item> <item <clip> <shape android:shape="rectangle"> <corners android:radius="10px" /> <gradient android:startcolor="#000000" android:centercolor="#ff0000" android:centery="0.5" android:endcolor="#000000" android:angle="90" /> </shape> </clip> </item> </layer-list> W pliku zdefiniowano listę elementów drawable zwaną layer-list. Elementy na tej liście są rysowane zgodnie z porządkiem listy, poczynając od góry do dołu (od elementu o najniższym indeksie do elementu o najwyższym indeksie). Początkowo będzie zatem rysowany element o id background w kształcie (<shape>) prostokątnym (<rectangle>) z zaokrąglonymi rogami (android:radius) i tłem w postaci gradientu (<gradient>). Następnie narysowany na nim zostanie element o id progress, z charakterystyką podobną do poprzedniego elementu, symbolizujący czerwony prostokąt z gradientem. Dodatkowo element o id progress otoczony został znacznikiem <clip>, który determinuje zmianę kształtu prostokąta (przycięcie) zgodnie z postępem wykonywanego zadania AsyncTaskRunner. Przykładowy ekran zaimplementowanej aplikacji przedstawiono na rys. 2. Po wpisaniu przez użytkownika liczby milisekund i kliknięciu w przycisk Uruchom AsyncTask, rozpoczyna się przetwarzanie zadania. Szybkość animacji paska postępu i zmian w kontrolce TextView uwarunkowana jest wartością wpisaną w polu edycyjnym. Rys. 2 Przykładowy ekran aplikacji wykorzystującej podklasę AsyncTask. 11

12 III. Bibliografia Arsoba, R. (2011). Programowanie urządzeń mobilnych. Zagadnienia podstawowe. Pobrano Czerwiec 12, 2012 z lokalizacji Conder S., D. L. (2011). Android. Programowanie aplikacji na urządzenia przenośne. Wydanie II. Gliwice: Helion. Geetha, S. (2011, Maj 17). Sai Geetha's Blog - Android. Pobrano Czerwiec 20, 2013 z lokalizacji Sai Geetha's Blog: Komatineni S., M. D. (2012). Android 3. Tworzenie aplikacji. Gliwice: Helion. Lee, W.-M. (2011). Beginning Android Application Development. Indianapolis: Wiley Publishing Inc. 12