Darmowy fragment publikacji:
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
Spis treści (skrócony)
Cykl życia aktywności. Była sobie aktywność
Interfejs użytkownika. Podziwiaj widoki
Wprowadzenie
Zaczynamy. Skok na głęboką wodę
Tworzenie interaktywnych aplikacji. Aplikacje, które coś robią
1
2
3 Wiele aktywności i intencji. Jakie są Twoje intencje?
4
5
6 Widoki list i adaptery. Zorganizuj się
Fragmenty. Zadbaj o modularyzację
7
Fragmenty zagnieżdżone. Zadbaj o potomstwo
8
9
Paski akcji. Na skróty
10
Szuflady nawigacyjne. Z miejsca na miejsce
11 Bazy danych SQLite. Odpal bazę danych
12 Kursory i zadania asynchroniczne. Nawiązywanie połączenia z bazą danych
13 Usługi. Do usług
14 Material Design. W materialistycznym świecie
A ART. Środowisko uruchomieniowe Androida
B
C
D Pozostałości. Dziesięć najważniejszych zagadnień (których nie opisaliśmy)
Spis treści
xxiii
1
39
73
115
163
227
269
325
365
397
437
471
541
597
649
653
659
663
ADB. Android Debug Bridge
Emulator. Emulator Androida
Spis treści (z prawdziwego zdarzenia)
W
Wprowadzenie
Twój mózg jest nastawiony na Androida. Jesteś tu po to, by się czegoś nauczyć, natomiast
Twój mózg robi Ci przysługę, upewniając się, że to, czego się nauczyłeś, szybko wyleci
z pamięci. Twój mózg myśli sobie: „Lepiej zostawić miejsce na coś ważnego, na przykład: których
dzikich zwierząt lepiej unikać albo czy jeżdżenie nago na snowboardzie to dobry pomysł”.
A zatem, w jaki sposób możesz skłonić swój mózg, by myślał, że Twoje życie zależy
od umiejętności pisania aplikacji na Androida?
Dla kogo jest przeznaczona ta książka?
Wiemy, co sobie myślisz
Wiemy, co sobie myśli Twój mózg
Metapoznanie — myślenie o myśleniu
Oto co MY zrobiliśmy
Przeczytaj to
Zespół recenzentów technicznych
Podziękowania
xxiv
xxv
xxv
xxvii
xxviii
xxx
xxxii
xxxiii
v
Poleć książkęKup książkęSpis treści
1
Android SDK
Zaczynamy
Skok na głęboką wodę
Android błyskawicznie podbił świat.
Każdy chce mieć smartfon lub tablet, a urządzenia z Androidem są niezwykle popularne.
W tej książce nauczymy Cię, jak pisać własne aplikacje, a zaczniemy od pokazania procesu
przygotowania bardzo prostej aplikacji i uruchomienia jej na wirtualnym urządzeniu z Androidem.
W trakcie tych prac poznasz także kilka podstawowych komponentów wszystkich aplikacji
na Androida, takich jak aktywności i układy. Jedyną rzeczą, której będziesz do tego
potrzebować, jest znajomość Javy, choć wcale nie musisz być w niej mistrzem…
Witamy w Androidowie
Platforma Android w szczegółach
Środowisko programistyczne
Zainstaluj Javę
Stwórzmy prostą aplikację
Aktywności z wysokości 15 tysięcy metrów
Tworzenie aplikacji (ciąg dalszy)
Tworzenie aplikacji (ciąg dalszy)
Właśnie utworzyłeś swoją pierwszą aplikację na Androida
Android Studio utworzy pełną strukturę katalogów aplikacji
Przydatne pliki projektu
Edycja kodu z użyciem edytorów Android Studio
Uruchamianie aplikacji w emulatorze Androida
Tworzenie wirtualnego urządzenia z Androidem
Uruchomienie aplikacji w emulatorze
Postępy możesz obserwować w konsoli
Jazda próbna
Ale co się właściwie stało?
Usprawnianie aplikacji
Czym jest układ?
Plik activity_main.xml zawiera dwa elementy
Plik układu zawiera odwołanie do łańcucha, a nie sam łańcuch znaków
Zajrzyjmy do pliku strings.xml
Weź swoją aplikację na jazdę próbną
Twój przybornik do Androida
2
3
5
6
8
12
13
14
15
16
17
18
23
24
27
28
29
30
31
32
33
34
35
37
38
vi
Urządzenie
Układ
/Układ
Aktywność
Layout
/Layout
Układ
Poleć książkęKup książkęSpis treści
2
Tworzenie interaktywnych aplikacji
Aplikacje, które coś robią
Większość aplikacji musi w jakiś sposób reagować na poczynania
użytkowników.
Z tego rozdziału dowiesz się, co zrobić, aby Twoje aplikacje były nieco bardziej interaktywne.
Przekonasz się, jak zmusić aplikację, by coś zrobiła w odpowiedzi na działania użytkownika,
oraz jak sprawić, by aktywności i układy porozumiewały się ze sobą jak starzy kumple.
Przy okazji pokażemy Ci nieco dokładniej, jak naprawdę działa Android — poznasz plik R,
czyli ukryty klejnot, który spaja pozostałe elementy aplikacji.
resources
/resources
strings.xml
Layout
/Layout
Układ
Aktywność
BeerExpert
W tym rozdziale napiszemy aplikację Doradca piwny
Utworzenie projektu
Utworzyliśmy domyślną aktywność i układ
Dodawanie komponentów w edytorze projektu
Plik activity_find_beer.xml zawiera nowy przycisk
Zmiany w kodzie XML układu…
…są uwzględniane w edytorze projektu
Stosuj zasoby łańcuchowe, a nie łańcuchy podawane w kodzie
Zmiana układu i zastosowanie w nim zasobów łańcuchowych
Weź swoją aplikację na jazdę próbną
Dodanie wartości do komponentu Spinner
Dodanie do komponentu Spinner odwołania do string-array
Jazda próbna komponentu Spinner
Musimy zadbać o to, by przycisk coś robił
Niech przycisk wywołuje metodę
Jak wygląda kod aktywności?
Dodaj do aktywności metodę onClickFindBeer()
Metoda onClickFindBeer() musi coś robić
Dysponując obiektem View, można odwoływać się do jego metod
Aktualizacja kodu aktywności
Pierwsza wersja aktywności
Jazda próbna — test modyfikacji
Tworzenie własnej klasy Javy
Dodaj do aktywności wywołanie metody naszej klasy,
aby była wyświetlana FAKTYCZNA porada
Kod aktywności, wersja 2
Co się dzieje podczas wykonywania tego kodu?
Jazda próbna — test aplikacji
Twój przybornik do Androida
40
42
43
44
45
48
49
50
51
52
53
54
54
55
56
57
58
59
60
61
63
65
66
67
69
70
71
72
vii
Poleć książkęKup książkęWiele aktywności i intencji
Jakie są Twoje intencje?
Większość aplikacji potrzebuje więcej niż jednej aktywności.
Dotychczas mieliśmy do czynienia z aplikacjami składającymi się tylko z jednej aktywności. Kiedy
jednak sprawy się komplikują, jedna aktywność zwyczajnie nie wystarczy. Dlatego w tym rozdziale
pokażemy Ci, jak tworzyć aplikacje składające się z wielu aktywności i jak nasze aplikacje
mogą porozumiewać się z innymi, wykorzystując w tym celu intencje. Pokażemy także, jak można
używać intencji, by wykraczać poza granice naszych aplikacji, i jak wykorzystywać aktywności
należące do innych aplikacji dostępnych w urządzeniu do wykonywania akcji. To wszystko
zapewni nam znacznie większe możliwości.
Aplikacja może zawierać więcej niż jedną aktywność
Oto struktura naszej aplikacji
Utworzenie projektu
Utworzenie drugiej aktywności i układu
Przedstawiamy plik manifestu aplikacji na Androida
Użycie intencji do uruchomienia drugiej aktywności
Co się dzieje po uruchomieniu aplikacji?
Jazda próbna aplikacji
Przekazanie tekstu do drugiej aktywności
Aktualizacja właściwości widoku tekstowego
Metoda putExtra() zapisuje w intencji dodatkowe informacje
Aktualizacja kodu aktywności CreateMessageActivity
Zastosowanie informacji przekazanych w intencji w klasie
ReceiveMessageActivity
Co się dzieje, gdy użytkownik kliknie przycisk Wyślij wiadomość?
Jazda próbna aplikacji
Jak działają aplikacje na Androida?
Co się dzieje podczas działania kodu?
Jak Android korzysta z filtrów intencji?
Musisz uruchomić aplikację na PRAWDZIWYM urządzeniu
Jazda próbna aplikacji
Zmień kod, aby wyświetlać okno dialogowe
Jazda próbna aplikacji
Twój przybornik do Androida
74
75
75
78
80
83
84
85
86
87
88
91
92
93
94
95
99
102
105
107
111
112
114
Spis treści
3
Intencja
Do: InnaAktywnosc
Hej,
użytkowniku! Każda
z tych aktywności może
wysyłać wiadomości. Której
z nich chcesz użyć?
CreateMessageActivity
viii
Android
Użytkownik
Poleć książkęKup książkę4
Aktywność
uruchomiona
onCreate()
onStart()
onResume()
Aktywność
działająca
onRestart()
onPause()
onStop()
onDestroy()
Aktywność
usunięta
Cykl życia aktywności
Była sobie aktywność
Aktywności stanowią podstawę wszystkich aplikacji na Androida.
Wiesz już, jak tworzyć aktywności i jak sprawić, by jedna aktywność uruchomiła drugą, używając
do tego celu intencji. Ale co tak naprawdę dzieje się za kulisami? W tym rozdziale nieco
dokładniej poznamy cykl życia aktywności. Co się dzieje, kiedy aktywność jest tworzona
i usuwana? Jakie metody są wywoływane, gdy aktywność jest wyświetlana i pojawia się na
ekranie, a jakie gdy aktywność traci miejsce wprowadzania i jest ukrywana? W jaki sposób
można zapisywać i odtwarzać stan aktywności?
Jak właściwie działają aktywności?
Aplikacja stopera
Kod układu aplikacji stopera
Dodanie kodu obsługującego przyciski
Metoda runTimer()
Obiekty Handler umożliwiają planowanie wykonania kodu
Pełny kod metody runTimer()
Kompletny kod aktywności StopwatchActivity
Obrót ekranu zmienia konfigurację urządzenia
Od narodzin do śmierci: stany aktywności
Cykl życia aktywności: od utworzenia do usunięcia
W jaki sposób radzić sobie ze zmianami konfiguracji?
Co się stanie po uruchomieniu aplikacji?
Tworzenie i usuwanie to nie cały cykl życia aktywności
Cykl życia aktywności: widzialny czas życia
Zaktualizowany kod aktywności StopwatchActivity
Co się dzieje podczas działania aplikacji?
Jazda próbna aplikacji
A co się dzieje, jeśli aplikacja jest tylko częściowo widoczna?
Cykl życia aktywności: życie na pierwszym planie
Zatrzymanie stopera w razie wstrzymania aktywności
Kompletny kod aktywności
Wygodny przewodnik po metodach cyklu życia aktywności
Twój przybornik do Androida
116
118
119
122
123
124
125
126
132
133
134
136
139
142
143
147
148
149
150
151
154
157
161
162
ix
Spis treściPoleć książkęKup książkę5
Interfejs użytkownika
Podziwiaj widoki
Nie masz innego wyjścia, musisz tworzyć szałowe układy.
Jeśli chcesz pisać aplikacje, których inni będą używać, musisz zadbać o to, by wyglądały one
dokładnie tak, jak sobie tego życzysz. Zagadnienie tworzenia układów potraktowaliśmy
dotychczas bardzo powierzchownie, najwyższy zatem czas, by przyjrzeć mu się dokładniej.
W tym rozdziale pokażemy Ci różne typy układów, które można tworzyć, i zabierzemy Cię na
wycieczkę po najważniejszych komponentach GUI i sposobach ich stosowania. Pod koniec tego
rozdziału przekonasz się, że choć wszystkie te układy i komponenty wyglądają nieco inaczej,
to jednak mają ze sobą więcej wspólnego, niż można by przypuszczać.
Widoki mogą być
rozmieszczane
względem układu
nadrzędnego…
…bądź względem
innych widoków.
Układ względny
ViewGroup
Layout
/Layout
layout.xml
Przycisk
Trzy kluczowe układy: względny, liniowy i siatki
Rozmieszczanie widoków względem układu nadrzędnego
Rozmieszczanie widoków względem innych widoków
Atrybuty do rozmieszczania widoków względem innych widoków
RelativeLayout — podsumowanie
Układ LinearLayout wyświetla widoki w jednym wierszu lub kolumnie
Zmieńmy nieco prosty układ liniowy
Dodawanie wagi do widoków
Dodawanie wagi do większej liczby widoków
Stosowanie atrybutu android:gravity — lista wartości
Inne wartości, których można używać w atrybucie
android:layout_gravity
Kompletny układ liniowy
LinearLayout — podsumowanie
Układ GridLayout wyświetla widoki w siatce
Dodawanie widoków do układu siatki
Utwórzmy nowy układ siatki
Wiersz 0: dodajemy widoki do określonych wierszy i kolumn
Wiersz 1: tworzymy widok zajmujący komórki kilku kolumn
Wiersz 2: tworzymy widok zajmujący komórki kilku kolumn
Pełny kod układu siatki
GridLayout — podsumowanie
Układy i komponenty GUI mają wiele wspólnego
Zabawy z widokami
Twój przybornik do Androida
165
168
170
171
173
174
176
179
180
182
184
185
186
189
190
191
193
194
195
196
197
201
205
225
Pole
tekstowe
x
View
View
Spis treściPoleć książkęKup książkęSpis treści
6
Widoki list i adaptery
Zorganizuj się
Chcesz wiedzieć, jaki jest najlepszy sposób na określenie struktury aplikacji?
Znasz już podstawowe elementy konstrukcyjne używane do tworzenia aplikacji, więc teraz nadszedł
czas, żebyś się lepiej zorganizował. W tym rozdziale pokażemy Ci, jak możesz przekształcić
zbiór pomysłów w niesamowitą aplikację. Zobaczysz, że listy danych mogą stać się kluczowym
elementem projektu aplikacji i że łączenie ich może prowadzić do powstania aplikacji łatwej
w użyciu i zapewniającej ogromne możliwości. Przy okazji zapoznasz się z obiektami
nasłuchującymi i adapterami, dzięki którym Twoja aplikacja stanie się bardziej dynamiczna.
Ekran
pocz¹tkowy
z list¹ opcji
Menu zawieraj¹ce
wszystko, co
mo¿na u nas
zjeśæ
Szczegó³owe
informacje
o ka¿dym
napoju
Każda aplikacja zaczyna się od pomysłu
Skategoryzuj swoje pomysły — aktywności: poziom główny,
kategoria i szczegóły/edycja
Nawigowanie po aktywnościach
Użyj ListViews do nawigowania po danych
Napiszemy aplikację kafeterii Coffeina
Aktywność szczegółów napoju
Struktura aplikacji dla kafeterii Coffeina
Układ aktywności głównego poziomu składa się z obrazka i listy
Kompletny kod układu aktywności głównego poziomu
Zapewnianie reakcji ListView na kliknięcia za pomocą
obiektu nasłuchującego
Kompletny kod aktywności TopLevelActivity
Jak utworzyć aktywność listy?
Łączenie widoków list z tablicami za pomocą adaptera ArrayAdapter
Dodanie adaptera ArrayAdapter do aktywności DrinkCategoryActivity
Co się stanie po wykonaniu kodu?
Jak obsługiwaliśmy kliknięcia w aktywności TopLevelActivity?
Kompletny kod aktywności DrinkCategoryActivity
Aktywność szczegółów wyświetla informacje o jednym rekordzie
Wypełnienie widoków danymi
Kod aktywności DrinkActivity
Jazda próbna aplikacji
Twój przybornik do Androida
228
229
230
231
232
233
234
238
240
241
243
249
251
252
253
256
258
259
261
263
266
268
To jest nasz widok listy. Utworzymy adapter ArrayAdapter,
aby powiązać widok listy z naszą tablicą.
To jest
nasza tablica.
ListView
Array
Adapter
Drink.
drinks
xi
Poleć książkęKup książkęSpis treści
7
Fragmenty
Zadbaj o modularyzację
Wiesz już, jak tworzyć aplikacje, które działają tak samo niezależnie od tego,
na jakim urządzeniu zostały uruchomione…
…ale co zrobić w przypadku, kiedy akurat chcesz, by aplikacja wyglądała i działała inaczej
w zależności od tego, czy zostanie uruchomiona na telefonie, czy na tablecie? W tym rozdziale
pokażemy Ci, co zrobić, aby aplikacja wybierała układ, który najlepiej pasuje do wielkości
ekranu urządzenia. Oprócz tego przedstawimy fragmenty, czyli modularne komponenty
kodu, które mogą być wielokrotnie używane przez różne aktywności.
Struktura aplikacji Trenażer
Klasa Workout
Jak dodać fragment do projektu?
Jak wygląda kod fragmentu?
Przypomnienie stanów aktywności
Cykl życia fragmentów
Nasze fragmenty dziedziczą metody cyklu życia
Jazda próbna aplikacji
Jak utworzyć fragment typu ListFragment?
Zaktualizowany kod klasy WorkoutListFragment
Jazda próbna aplikacji
Powiązanie listy z widokiem szczegółów
Stosowanie transakcji fragmentu
Zaktualizowany kod aktywności MainActivity
Jazda próbna aplikacji
Kod fragmentu WorkoutDetailFragment
Struktury aplikacji na tablety i telefony
Różne opcje katalogów
Układ MainActivity dla telefonów
Kompletny kod aktywności DetailActivity
Zmodyfikowany kod aktywności MainActivity
Jazda próbna aplikacji
273
275
276
278
282
283
284
286
290
292
294
295
301
302
303
305
307
309
315
319
321
322
A zatem fragment
będzie zawierał jedną listę.
Kiedy chcieliśmy użyć aktywności
zawierającej pojedynczą listę,
zastosowaliśmy aktywność typu
ListActivity. Zastanawiam się, czy
przypadkiem nie istnieje jakiś typ
fragmentu stanowiący odpowiednik
tej klasy.
xii
Poleć książkęKup książkęSpis treści
8
Fragmenty zagnieżdżone
Zadbaj o potomstwo
Wiesz już, że stosowanie fragmentów w aktywnościach pozwala na
wielokrotne wykorzystywanie kodu i zwiększa elastyczność aplikacji.
W tym rozdziale mamy zamiar pokazać Ci, jak zagnieżdżać fragmenty w innych
fragmentach. Dowiesz się, jak używać menedżera fragmentów podrzędnych,
by poskromić niesforne transakcje. Ponadto dowiesz się, dlaczego tak ważna jest
znajomość różnic między aktywnościami i fragmentami.
Tworzenie zagnieżdżonych fragmentów
Kod fragmentu StopwatchFragment
Układ fragmentu StopwatchFragment
Metoda getFragmentManager() tworzy transakcje
na poziomie aktywności
Zagnieżdżone fragmenty wymagają zagnieżdżonych transakcji
Kompletny kod fragmentu WorkoutDetailFragment
Jazda próbna aplikacji
Dlaczego kliknięcie przycisku powoduje awarię aplikacji?
Przyjrzyjmy się kodowi układu StopwatchFragment
Zaimplementuj we fragmencie interfejs OnClickListener
Powiązanie obiektu nasłuchującego OnClickListener z przyciskami
Kod fragmentu StopwatchFragment
Jazda próbna aplikacji
Kod fragmentu WorkoutDetailFragment
Jazda próbna aplikacji
Twój przybornik do Androida
326
332
335
340
341
343
344
345
346
349
351
352
354
358
359
364
Jak widzę, pojawiły się
jakieś transakcje fragmentu.
Muszę je natychmiast
zastosować.
Transakcje
fragmentu
Aktywność
Fragment
xiii
Poleć książkęKup książkęSpis treści
9
Paski akcji
Na skróty
Każdy lubi chodzić na skróty.
Z tego rozdziału dowiesz się, jak korzystając z pasków akcji, wzbogacić aplikację o możliwość chodzenia
na skróty. Pokażemy Ci, jak uruchamiać inne aplikacje za pomocą elementów akcji dodawanych do
pasków akcji, jak udostępniać treści innym aplikacjom, używając dostawcy akcji współdzielenia, oraz
jak poruszać się w górę hierarchii aplikacji za pomocą przycisku W górę umieszczonego na pasku
akcji. Dowiesz się też, jak można nadawać tworzonym aplikacjom spójny wygląd i sposób działania,
korzystając z motywów, i poznasz pakiet biblioteki wsparcia systemu Android.
Właśnie tak wygląda akcja udostępniania
wyświetlona na pasku akcji. Po jej
kliknięciu wyświetlana jest lista aplikacji,
którym możemy udostępnić treści.
Świetne aplikacje mają przejrzystą strukturę
Różne typy nawigacji
Zacznijmy od paska akcji
Pakiet bibliotek Support Libraries
Twój projekt może już używać bibliotek wsparcia
Zadbamy, by aplikacja używała aktualnych motywów
Zastosowanie motywu w pliku AndroidManifest.xml
Definiowanie stylów w pliku zasobów stylów
Określenie domyślnego motywu w pliku styles.xml
Co się dzieje podczas działania aplikacji?
Dodawanie elementów do paska akcji
Plik zasobów menu
Atrybut showAsAction menu
Dodawanie nowego elementu akcji
Utworzenie aktywności OrderActivity
Uruchomienie aktywności OrderActivity
po kliknięciu przycisku Złóż zamówienie
Kompletny kod aktywności MainActivity
Dzielenie się treściami z poziomu paska akcji
Określanie treści za pomocą intencji
Kompletny kod aktywności MainActivity
Włączanie nawigacji w górę
Określanie aktywności nadrzędnej
Dodawanie przycisku W górę
Jazda próbna aplikacji
Twój przybornik do Androida
366
367
368
369
370
371
372
373
374
375
376
377
378
379
382
383
384
386
388
389
391
392
393
394
395
API 21?
Idealnie pasuje.
xiv
Android
values-v21
xml
/xml
styles.xml
Name: AppTheme
Parent: Theme.Material.Light
Poleć książkęKup książkęSpis treści
10
Szuflady nawigacyjne
Z miejsca na miejsce
Aplikacje są nieporównanie lepsze, gdy można się po nich łatwo poruszać.
W tym rozdziale przedstawimy Ci szufladę nawigacyjną — wysuwany panel, który jest
wyświetlany na ekranie po przesunięciu palcem lub kliknięciu ikony umieszczonej na pasku akcji.
Pokażemy Ci, jak można wyświetlać w niej listę odnośników umożliwiających przechodzenie
do kluczowych węzłów aplikacji. Oprócz tego przekonasz się, że przełączanie fragmentów
pozwala łatwo docierać do tych węzłów i je szybko wyświetlać.
Zmiany w aplikacji dla restauracji Włoskie Co Nieco
Szuflady nawigacyjne bez tajemnic
Struktura aplikacji dla restauracji Włoskie Co Nieco
Utworzenie fragmentu TopFragment
Utworzenie fragmentu PizzaFragment
Utworzenie fragmentu PastaFragment
Utworzenie fragmentu StoresFragment
Dodanie układu DrawerLayout
Kompletna zawartość pliku activity_main.xml
Inicjalizacja listy szuflady nawigacyjnej
Zmiana tytułu paska akcji
Zamykanie szuflady nawigacyjnej
Zaktualizowany kod pliku MainActivity.java
Stosowanie ActionBarDrawerToggle
Modyfikowanie elementów paska akcji w trakcie działania aplikacji
Zaktualizowany kod aktywności MainActivity
Włączenie możliwości otwierania i zamykania szuflady nawigacyjnej
Synchronizacja stanu przycisku ActionBarDrawerToggle
Zaktualizowany kod aktywności MainActivity
Obsługa zmian konfiguracji
Reagowanie na zmiany stosu cofnięć
Dodawanie znaczników do fragmentów
Kompletny kod aktywności MainActivity
Jazda testowa aplikacji
Twój przybornik do Androida
398
399
400
401
402
403
404
405
406
407
412
413
414
417
418
419
420
421
422
425
426
427
429
435
436
xv
Zawartość ekranu jest
wyświetlana w układzie
FrameLayout. Chcemy, by
wypełniała ona cały dostępny
obszar ekranu. W tym przykładzie
jest ona częściowo przesłonięta
przez szufladę nawigacyjną.
Poleć książkęKup książkęSpis treści
11
Jaśnie panie,
oto pańska baza
danych. Czy mogę
jeszcze czymś służyć?
onCreate()
Pomocnik SQLite
DRINK
Nazwa: Coffeina
Wersja: 1
Baza danych SQLite
xvi
Bazy danych SQLite
Odpal bazę danych
Jeśli rejestrujesz najlepsze wyniki lub przesyłane komunikaty,
to Twoja aplikacja będzie musiała przechowywać dane.
A w Androidzie dane są zazwyczaj bezpiecznie i trwale przechowywane w bazach danych
SQLite. W tym rozdziale pokażemy Ci, jak utworzyć bazę danych, dodawać do niej tabele,
wypełnić ją wstępnie danymi, a wszystko to za pomocą pomocnika SQLite. Dowiesz się też,
w jaki sposób można bezproblemowo przeprowadzać aktualizacje struktury bazy danych
i jak w razie konieczności wycofania zmian wrócić do jej wcześniejszych wersji.
Znowu w kafeterii Coffeina
Android trwale przechowuje dane, używając baz danych SQLite
Android udostępnia kilka klas związanych z SQLite
Obecna struktura aplikacji kafeterii Coffeina
Pomocnik SQLite zarządza Twoją bazą danych
Pomocnik SQLite
Tworzenie pomocnika SQLite
Wnętrze bazy danych SQLite
Tabele tworzymy w języku SQL
Wstawianie danych za pomocą metody insert()
Aktualizacja rekordów za pomocą metody update()
Określanie wielu warunków
Kod klasy CoffeinaDatabaseHelper
Co robi kod pomocnika SQLite?
Co zrobić, gdy trzeba będzie zmienić bazę?
Bazy danych SQLite mają numer wersji
Aktualizacja bazy danych — omówienie
Jak pomocnik SQLite podejmuje decyzje?
Aktualizacja bazy w metodzie onUpgrade()
Przywracanie starszej wersji bazy za pomocą metody onDowngrade()
Zaktualizujmy bazę danych
Aktualizacja istniejącej bazy danych
Zmiana nazwy tabeli
Pełny kod pomocnika SQLite
Kod pomocnika SQLite (ciąg dalszy)
Co się dzieje podczas działania kodu?
Twój przybornik do Androida
438
439
440
441
443
443
444
446
447
448
449
450
451
452
455
456
457
459
460
461
462
465
466
467
468
469
470
Poleć książkęKup książkę12
onPreExecute
doInBackground
onProgressUpdate
onPostExecute
Spis treści
Kursory i zadania asynchroniczne
Nawiązywanie połączenia z bazą danych
Jak łączysz swoje aplikacje z bazami danych SQLite?
Dotychczas dowiedziałeś się, jak tworzyć bazy danych, używając pomocnika SQLite. Kolejnym
krokiem będzie uzyskanie dostępu do tych baz danych w aktywnościach. Z tego rozdziału dowiesz
się, jak tworzyć kursory, by pobierać dane z bazy danych, jak poruszać się po kursorach oraz
jak pobierać z nich dane. Oprócz tego dowiesz się, jak używać adapterów kursorów, by łączyć
kursory z widokami list. A na koniec przekonasz się, że pisanie wydajnego kodu wielowątkowego
korzystającego z klasy AsyncTask może zagwarantować wysoką wydajność działania aplikacji.
Aktualny kod aktywności DrinkActivity
Określanie tabeli i kolumn
Zapytania z wieloma warunkami
Stosowanie funkcji SQL w zapytaniach
Poruszanie się po kursorze
Pobieranie wartości z kursora
Kod aktywności DrinkActivity
Dodanie ulubionych napojów do aktywności DrinkActivity
Kod aktywności DrinkActivity
Nowy kod aktywności głównego poziomu
Zmodyfikowany kod aktywności TopLevelActivity
Metoda onPreExecute()
Metoda doInBackground()
Metoda onProgressUpdate()
Metoda onPostExecute()
Klasa AsyncTask
Kod aktywności DrinkActivity
Twój przybornik do Androida
474
478
479
481
488
489
490
508
513
518
524
531
532
533
534
535
537
540
Hej, adapterze,
potrzebuję więcej
danych.
Hej, kursorze, potrzebuję
więcej… Kursorze? Stary,
jesteś tam?
Widok ListView
Adapter CursorAdapter
Kursor
xvii
Poleć książkęKup książkęSpis treści
13
Usługi
Do usług
Są operacje, które będziemy chcieli realizować niezależnie od tego,
która aplikacja jest widoczna na ekranie.
Na przykład kiedy rozpoczniesz odtwarzanie pliku w aplikacji muzycznej, to najprawdopodobniej
będziesz oczekiwać, że będzie ona kontynuowała odtwarzanie nawet wówczas, gdy przejdziesz
do innej aplikacji. Z tego rozdziału dowiesz się, jak używać usług, by radzić sobie w sytuacjach
takich jak ta. Przy okazji nauczysz się korzystać z kilku wbudowanych usług systemu Android.
Dowiesz się, jak za pomocą usługi powiadomień sprawić, by użytkownik zawsze był dobrze
poinformowany, i jak poznać aktualne położenie geograficzne, korzystając z usługi lokalizacji.
543
Aplikacja z usługą uruchomioną
545
Usługa IntentService z wysokości 15 tysięcy metrów
546
Jak rejestrować komunikaty?
547
Kompletny kod usługi DelayedMessageService
554
Kompletny kod usługi DelayedMessageService
557
Jak używać usługi powiadomień?
559
Uruchamianie intencji przez powiadomienie
561
Wysyłanie powiadomień za pomocą usługi systemowej
562
Kompletny kod usługi DelayedMessageService
570
Etapy tworzenia usługi Odometer
573
Zdefiniowanie obiektu Binder
575
Klasa Service ma cztery kluczowe metody
577
Dodanie obiektu LocationListener do usługi
578
Rejestracja obiektu LocationListener
580
Kompletny kod usługi OdometerService
582
Aktualizacja pliku AndroidManifest.xml
586
Aktualizacja układu aktywności MainActivity
587
Tworzenie obiektu ServiceConnection
Powiązanie z usługą należy utworzyć podczas uruchamiania aktywności 588
589
Wyświetlanie przebytego dystansu
590
Kompletny kod aktywności MainActivity
Twój przybornik do Androida
595
getDistance()
Systemowa
usługa
lokalizacyjna
Layout
/Layout
activity_main.xml
xviii
MainActivity.java
1.11
OdometerService.java
Liczba przebytych kilometrów.
Poleć książkęKup książkęSpis treści
14
Material Design
W materialistycznym świecie
W API poziomu 21 Google wprowadził Material Design.
Z tego rozdziału dowiesz się, czym jest Material Design i jak sprawić, by nasze aplikacje do
niego pasowały. Zaczniemy od przedstawienia widoków kart (ang. card views), których możemy
wielokrotnie używać w całej aplikacji, zapewniając jej spójny wygląd i sposób obsługi. Następnie
przedstawimy widok RecyclerView — elastycznego przyjaciela widoków list. Przy okazji dowiesz
się także, jak tworzyć własne adaptery i jak całkowicie zmienić wygląd widoku RecyclerView,
używając zaledwie dwóch wierszy kodu.
Przedstawiamy Material Design
Struktura aplikacji dla restauracji Włoskie Co Nieco
Utworzenie widoku CardView
Kompletny kod pliku card_captioned_image.xml
Utworzenie prostego adaptera
Zdefiniowanie obiektu ViewHolder na potrzeby adaptera
Utworzenie obiektów ViewHolder
Każdy widok CardView wyświetla zdjęcie i podpis
Dodanie danych do widoków CardView
Kompletny kod pliku CaptionedImagesAdapter.java
Utworzenie widoku RecyclerView
Dodanie widoku RecyclerView do układu
Kod klasy PizzaMaterialFragment
Do rozmieszczania zawartości RecyclerView używa menedżera układu
Określanie menedżera układu
Kompletny kod klasy PizzaMaterialFragment
Zastosowanie fragmentu PizzaMaterialFragment
w aktywności MainActivity
Co się stanie po uruchomieniu kodu?
Utworzenie aktywności PizzaDetailActivity
Co musi robić aktywność PizzaDetailActivity?
Aktualizacja pliku AndroidManifest.xml
Kod pliku PizzaDetailActivity.java
Obsługa kliknięć w widoku RecyclerView
Dodanie interfejsu do adaptera
Implementacja interfejsu Listener
we fragmencie PizzaMaterialFragment
Umieszczenie treści na samym początku
Kompletny kod pliku układu fragment_top.xml
Kompletny kod klasy TopFragment
Twój przybornik do Androida
598
600
603
604
606
607
608
609
610
611
612
613
614
615
616
617
618
619
627
628
628
629
631
634
636
639
644
645
647
xix
Poleć książkęKup książkęA
ART
Środowisko uruchomieniowe Androida
Aplikacje na Androida muszą działać na urządzeniach wyposażonych
w słabe procesory i bardzo małą pamięć.
Aplikacje pisane w Javie mogą potrzebować sporo pamięci, a ponieważ działają wewnątrz własnej
wirtualnej maszyny Javy (JVM), ich uruchomienie na komputerze o niewielkiej mocy obliczeniowej
może trwać dosyć długo. Android rozwiązuje ten problem, nie używając JVM do uruchamiania
aplikacji. Zamiast JVM używa całkowicie odmiennej wirtualnej maszyny, nazywanej środowiskiem
uruchomieniowym Androida (ang. Android Runtime, w skrócie ART). W tym dodatku zobaczysz,
jak to się dzieje, że ART umożliwia dobre działanie aplikacji napisanych w Javie nawet na małych
komputerach o niewielkiej mocy obliczeniowej.
.java
.class
classes.dex
.apk
B
ADB
Android Debug Bridge
W tej książce skoncentrowaliśmy się na zaspokajaniu wszystkich potrzeb
związanych z pisaniem aplikacji na Androida z wykorzystaniem IDE.
Zdarzają się jednak sytuacje, w których zastosowanie narzędzi obsługiwanych z poziomu wiersza
poleceń jest po prostu przydatne. Mamy tu na myśli na przykład przypadki, gdy Android Studio nie
jest w stanie zauważyć urządzenia z Androidem, choć my wiemy, że ono istnieje. W tym rozdziale
przedstawimy Android Debug Bridge (w skrócie ADB) — obsługiwany z poziomu wiersza
poleceń program narzędziowy, którego można używać do komunikacji z emulatorem
lub z rzeczywistymi urządzeniami zaopatrzonymi w Androida.
adb
polecenie adb
adbd
proces
demona adb
Urządzenie
Urządzenie
xx
Spis treściPoleć książkęKup książkęSpis treści
C
Emulator
Emulator Androida
Czy miałeś kiedyś wrażenie, że cały swój czas spędzasz, czekając na emulator?
Nie ma najmniejszych wątpliwości co do tego, że emulator Androida jest bardzo przydatny. Dzięki
niemu możemy się przekonać, jak nasza aplikacja będzie działała na urządzeniach innych niż te,
do których mamy fizyczny dostęp. Niekiedy jednak można odnieść wrażenie, że emulator działa…
wolno. W tym dodatku wyjaśnimy, dlaczego tak się dzieje. Ale to nie wszystko, damy Ci bowiem
także kilka wskazówek, jak przyspieszyć jego działanie.
AVD
AVD AVD AVD AVD
Wszystkie wirtualne urządzenia
z Androidem (AVD) są wykonywane
przez emulator QEMU.
Emulator QEMU
D
Pozostałości
Dziesięć najważniejszych zagadnień (których nie opisaliśmy)
Nawet po tym wszystkim, co opisaliśmy w tej książce, wciąż pozostaje
wiele innych interesujących zagadnień.
Jest jeszcze kilka dodatkowych spraw, o których musisz się dowiedzieć. Czulibyśmy się nie
w porządku, gdybyśmy je pominęli, a jednocześnie chcieliśmy oddać w Twoje ręce książkę,
którą dasz radę podnieść bez intensywnego treningu na siłowni. Dlatego zanim odłożysz
tę książkę, przeczytaj kilka dodatkowych zagadnień opisanych w tym dodatku.
1. Rozpowszechnianie aplikacji
2. Dostawcy treści
3. Klasa WebView
4. Animacje
5. Mapy
5. Mapy (ciąg dalszy)
6. Klasa CursorLoader
7. Odbiorcy komunikatów
8. Widżety aplikacji
9. Grafika 9-patch
10. Testowanie
Bateria już
jest prawie
rozładowana… jeśli
to kogoś interesuje.
Android
Skorowidz
S
664
665
666
667
668
669
669
670
671
672
673
674
xxi
Poleć książkęKup książkęPoleć książkęKup książkę10. Szuflady nawigacyjne
Z miejsca na miejsce
Wiem, że ze swoją
cudowną szufladą
nawigacyjną nigdy się
nie zgubię!
Aplikacje są nieporównanie lepsze, gdy można się po nich łatwo poruszać.
W tym rozdziale przedstawimy Ci szufladę nawigacyjną — wysuwany panel, który jest
wyświetlany na ekranie po przesunięciu palcem lub kliknięciu ikony umieszczonej na pasku akcji.
Pokażemy Ci, jak można wyświetlać w niej listę odnośników umożliwiających przechodzenie
do kluczowych węzłów aplikacji. Oprócz tego przekonasz się, że przełączanie fragmentów
pozwala łatwo docierać do tych węzłów i je szybko wyświetlać.
to jest nowy rozdział
397
Poleć książkęKup książkęWięcej pizzy
Zmiany w aplikacji dla restauracji Włoskie Co Nieco
W rozdziale 9. przedstawiliśmy szkic głównego ekranu najwyższego poziomu aplikacji dla
Włoskiego Co Nieco. Zawierał on listę opcji umożliwiających użytkownikom przechodzenie
w różne miejsca aplikacji. Pierwsze trzy opcje prowadziły do ekranów kategorii prezentujących
odpowiednio pizze, dania z makaronów i restauracje, natomiast ostatnia opcja pozwalała
przechodzić do ekranu szczegółów/edycji, na którym użytkownik mógł złożyć zamówienie.
Włoskie Co Nieco
To jest aktywność głównego poziomu
aplikacji.
Pizze
Makarony
Restauracje
Złóż zamówienie
To są odnośniki do ekranów kategorii.
Ten odnośnik pozwala wyświetlić ekran
szczegółów/edycji, na którym można
złożyć zamówienie. W rozdziale 9.
przenieśliśmy go na pasek aktywności.
Wiesz już, jak dodawać nowe elementy do paska akcji. To rozwiązanie najlepiej się
nadaje do umieszczania opcji aktywnych, takich jak tworzenie zamówień. Co jednak
można zrobić w przypadku odnośników do ekranów kategorii? Ponieważ są to opcje
pasywne, służące za elementy nawigacyjne w obrębie całej aplikacji, musimy je
potraktować nieco inaczej.
Pozostałe trzy opcje — Pizze, Makarony oraz Restauracje — umieścimy w szufladzie
nawigacyjnej (ang. navigation drawer). Szuflada nawigacyjna to wysuwany panel
zawierający odnośniki do głównych części aplikacji. Te główne części aplikacji są
określane jako jej kluczowe węzły i zazwyczaj odgrywają najważniejszą rolę
w poruszaniu się po niej; przeważnie są nimi ekrany głównego poziomu i ekrany
kategorii.
.
.
.
Włoskie Co Nieco
Ekran główny
Pizze
Makarony
Restauracje
Po kliknięciu elementu szuflady
nawigacyjnej odpowiadająca mu
zawartość jest wyświetlana
w tym miejscu ekranu.
To jest szuflada
nawigacyjna. Zawiera
ona listę kluczowych
węzłów aplikacji.
398 Rozdział 10.
Poleć książkęKup książkęSzuflady nawigacyjne
Szuflady nawigacyjne bez tajemnic
Do implementacji szuflad nawigacyjnych używany jest specjalny typ układów
— DrawerLayout. Układ typu DrawerLayout zarządza dwoma widokami:
Widok zawartości głównej, którym zazwyczaj jest układ FrameLayout, dzięki
czemu w prosty sposób można wyświetlać i zmieniać prezentowane fragmenty.
Widok szuflady nawigacyjnej, którym zazwyczaj jest ListView.
Domyślnie układ DrawerLayout wyświetla widok prezentujący główną
zawartość aplikacji. Wygląda on bardzo podobnie do normalnej aktywności:
To jest ikona szuflady
nawigacyjnej. Wystarczy
ją kliknąć lub przeciągnąć
palcem, by wyświetlić
zawartość szuflady.
To właśnie tu jest
umieszczona główna
zawartość aplikacji.
Kiedy klikniemy ikonę szuflady nawigacyjnej lub przeciągniemy palcem od
krawędzi ekranu do jego środka, widok zwierający szufladę nawigacyjną
zostanie wysunięty na ekran i częściowo przesłoni prezentowane na nim treści.
To jest szuflada nawigacyjna.
Jak widać, zawiera ona listę
opcji.
Szuflada jest
nasuwana na
prezentowaną
zawartość
główną.
To właśnie zawartość szuflady umożliwia nam poruszanie się po aplikacji.
A jaki to ma wpływ na strukturę naszej aplikacji dla Włoskiego Co Nieco?
jesteś tutaj
399
Poleć książkęKup książkęStruktura aplikacji
Struktura aplikacji dla restauracji Włoskie Co Nieco
Planujemy zmienić aktywność MainActivity w taki sposób, by korzystała z szuflady
nawigacyjnej. Będzie ona zawierała układ FrameLayout do wyświetlania fragmentów
i widok listy do prezentowania listy opcji.
Widok listy będzie zawierał opcje Ekran główny, Pizze, Makarony oraz Restauracje, dzięki
którym użytkownik będzie mógł w prosty sposób poruszać się pomiędzy głównymi węzłami
aplikacji. Dla każdej z tych opcji utworzymy następnie odrębny fragment. Oznacza to,
że będziemy mogli podmieniać fragmenty w trakcie działania aplikacji, a użytkownik będzie
w stanie uzyskać dostęp do szuflady nawigacyjnej z każdego ekranu aplikacji.
Włoskie
Co Nieco
Top Fragment
Głównymi węzłami aplikacji są fragmenty, więc
możemy wyświetlać jeden z nich, w zależności
od opcji klikniętej przez użytkownika.
Pizze
Diavolo
Funghi
.
.
.
Włoskie Co Nieco
Ekran główny
Pizze
Makarony
Restauracje
PizzasFragment
Restauracje
Wrocław
Kraków
TopFragment
Makarony
Spaghetti
bolognese
Lasagne
PastaFragment
StoresFragment
MainActivity
Oto czynności, które wykonamy w ramach wprowadzania tych modyfikacji:
1
2
Utworzymy fragmenty dla poszczególnych głównych węzłów aplikacji.
Utworzymy i zainicjujemy szufladę nawigacyjną.
Szuflada ta będzie zawierała widok ListView prezentujący listę opcji.
3
4
Zapewnimy, by widok ListView reagował na kliknięcia elementów.
Dzięki temu użytkownik będzie mógł przechodzić do głównych węzłów aplikacji.
Dodamy ActionBarDrawerToggle.
Dzięki temu elementowi użytkownik będzie mógł kontrolować szufladę
przy użyciu paska akcji, a aktywność będzie mogła reagować na zdarzenia
otwierania i zamykania szuflady.
Zaczniemy od utworzenia fragmentów.
400
S p o ko j n i e
Dodanie szuflady
nawigacyjnej
wymaga napisania
sporej ilości kodu.
Na omówienie sposobu dodawania
szuflady nawigacyjnej poświęcimy cały
ten rozdział, a na samym jego końcu
pokażemy kompletny kod aktywności
MainActivity.
Rozdział 10. Poleć książkęKup książkęUtworzenie fragmentu TopFragment
Fragmentu TopFragment użyjemy do prezentowania zawartości najwyższego
poziomu. Na razie ograniczmy się jednak do wyświetlenia tekstu „Fragment
TopFragment”, dzięki czemu będziemy wiedzieli, który fragment jest aktualnie
widoczny. A zatem utwórz pusty fragment, nadaj mu nazwę TopFragment,
a używany przez niego plik układu nazwij fragment_top.
Oto zawartość pliku TopFragment.java:
package com.hfad.wloskieconieco;
import android.os.Bundle;
import android.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
Nasz TopFragment jest
zwyczajnym fragmentem.
public class TopFragment extends Fragment {
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
return inflater.inflate(R.layout.fragment_top, container, false);
}
}
Szuflady nawigacyjne
Dodanie fragmentów
Utworzenie szuflady
Obsługa kliknięcia ListView
Dodanie ActionBarDrawerToggle
Wszystkie nasze fragmenty utworzymy
na bazie pustych fragmentów, gdyż
i tak w całości będziemy zastępować kod
wygenerowany przez Android Studio.
WloskieCoNieco
app/src/main
app/src/main
java
com.hfad.wloskieconieco
TopFragment.java
Oprócz tego dodaj do pliku strings.xml następujący zasób łańcuchowy
(użyjemy go w układzie fragmentu):
string name=”title_top” Fragment TopFragment /string
Dodaj ten łańcuch do pliku strings.xml.
Dodamy go do układu, aby wiedzieć,
kiedy będzie wyświetlany fragment
TopFragment.
Oto kod pliku fragment_top.xml:
RelativeLayout 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”
tools:context=”.MainActivity”
TextView
android:text=”@string/title_top”
android:layout_width=”wrap_content”
android:layout_height=”wrap_content” /
/RelativeLayout
WloskieCoNieco
app/src/main
app/src/main
res
layout
xml
/xml
fragment_top.xml
jesteś tutaj
401
Poleć książkęKup książkę Dodanie fragmentów
Utworzenie szuflady
Obsługa kliknięcia ListView
Dodanie ActionBarDrawerToggle
Utworzenie fragmentu PizzaFragment
Utworzenie fragmentu PizzaFragment
Do wyświetlania listy pizz użyjemy fragmentu PizzaFragment typu ListFragment.
A zatem utwórz pusty fragment o nazwie PizzaFragment, jednocześnie usuń
zaznaczenie pola wyboru pozwalającego na utworzenie pliku układu. Rezygnujemy
z tworzenia układu dlatego, że fragmenty typu ListFragment używają swoich
własnych układów.
Następnie dodaj do pliku strings.xml nową tablicę łańcuchów o nazwie pizzas
(zapiszemy w niej nazwy dostępnych pizz):
string-array name=”pizzas”
item Diavolo /item
item Funghi /item
/string-array
Dodajemy tablicę z nazwami pizz
do pliku strings.xml.
Następnie zmodyfikuj kod w pliku PizzaFragment.java w taki sposób,
by tworzony fragment dziedziczył po klasie ListFragment. Lista
wyświetlana w tym fragmencie powinna zostać wypełniona nazwami pizz.
Oto kod tego pliku:
package com.hfad.wloskieconieco;
WloskieCoNieco
import android.app.ListFragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
app/src/main
app/src/main
java
Do wyświetlenia listy pizz
użyjemy fragmentu typu
ListFragment.
com.hfad.wloskieconieco
PizzaFragment.java
public class PizzaFragment extends ListFragment {
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
ArrayAdapter String adapter = new ArrayAdapter String (
inflater.getContext(),
android.R.layout.simple_list_item_1,
getResources().getStringArray(R.array.pizzas));
setListAdapter(adapter);
return super.onCreateView(inflater, container, savedInstanceState);
}
}
402 Rozdział 10.
Poleć książkęKup książkęSzuflady nawigacyjne
Utworzenie fragmentu PastaFragment
Fragmentu PastaFragment typu ListFragment użyjemy do wyświetlania listy
dań z makronu. Aby przygotować ten fragment, utwórz pusty fragment i nadaj mu
nazwę PastaFragment. Nie zapomnij także o usunięciu znaczników z pola wyboru
pozwalającego na utworzenie pliku układu, gdyż fragmenty typu ListFragment
dysponują własnym układem.
Następnie do pliku strings.xml dodaj tablicę łańcuchów o nazwie pasta
(będzie ona zawierała nazwy dań z makaronu):
string-array name=”pasta”
item Spaghetti bolognese /item
item Lasagne /item
/string-array
Dodajemy do pliku strings.xml tablicę
z nazwami dań z makaronu.
Następnie zmień kod w pliku PastaFragment.java w taki sposób, by klasa
PastaFragment dziedziczyła po ListFragment. Widok ListView tego fragmentu
powinien zostać wypełniony nazwami dań z makaronu. Oto kod tej klasy:
package com.hfad.wloskieconieco;
import android.app.ListFragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
WloskieCoNieco
Fragmentu typu ListFragment
użyjemy do wyświetlenia listy
dań z makaronu.
app/src/main
app/src/main
java
com.hfad.wloskieconieco
public class PastaFragment extends ListFragment {
PastaFragment.java
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
ArrayAdapter String adapter = new ArrayAdapter String (
inflater.getContext(),
android.R.layout.simple_list_item_1,
getResources().getStringArray(R.array.pasta));
setListAdapter(adapter);
return super.onCreateView(inflater, container, savedInstanceState);
}
}
jesteś tutaj
403
Poleć książkęKup książkęUtworzenie fragmentu StoresFragment
Utworzenie fragmentu StoresFragment
Fragmentu StoresFragment typu ListFragment użyjemy do wyświetlania
listy restauracji. Aby przygotować ten fragment, utwórz pusty fragment i nadaj
mu nazwę StoresFragment. Nie zapomnij także o usunięciu znaczników
z pola wyboru pozwalającego na utworzenie pliku układu, gdyż fragmenty typu
ListFragment dysponują własnym układem.
Następnie do pliku strings.xml dodaj tablicę łańcuchów o nazwie stores
(będzie ona zawierała nazwy miast, w których są restauracje Włoskie Co Nieco):
Dodanie fragmentów
Utworzenie szuflady
Obsługa kliknięcia ListView
Dodanie ActionBarDrawerToggle
string-array name=”stores”
item Wrocław /item
item Kraków /item
/string-array
Dodajemy do pliku strings.xml tablicę
z nazwami miast, w których są restauracje.
Następnie zmień kod w pliku StoresFragment.java w taki sposób, by klasa
StoresFragment dziedziczyła po ListFragment. Widok ListView tego
fragmentu powinien zostać wypełniony nazwami miast. Oto kod tej klasy:
Fragmentu typu ListFragment
użyjemy do wyświetlenia
listy miast, w których są
restauracje.
WloskieCoNieco
app/src/main
app/src/main
java
com.hfad.wloskieconieco
StoresFragment.java
package com.hfad.wloskieconieco;
import android.app.ListFragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
public class StoresFragment extends ListFragment {
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
ArrayAdapter String adapter = new ArrayAdapter String (
inflater.getContext(),
android.R.layout.simple_list_item_1,
getResources().getStringArray(R.array.stores));
setListAdapter(adapter);
return super.onCreateView(inflater, container, savedInstanceState);
}
}
404 Rozdział 10.
Poleć książkęKup książkęSzuflady nawigacyjne
Dodanie układu DrawerLayout
Teraz zajmiemy się zmianą układu używanego przez aktywność główną, MainActivity,
tak by używała ona układu typu DrawerLayout. Zgodnie z tym, o czym wspominaliśmy
już wcześniej, będzie on zawierał układ FrameLayout, którego użyjemy do wyświetlania
fragmentów, i widok ListView prezentujący zawartość szuflady nawigacyjnej.
Układ DrawerLayout można utworzyć, używając następującego kodu:
Nasz układ korzysta z układu DrawerLayout
pochodzącego z biblioteki wsparcia v4. Biblioteka
appcompat v7 zawiera bibliotekę wsparcia v4.
Układu FrameLayout będziemy używać
do wyświetlania fragmentów.
android.support.v4.widget.DrawerLayout
xmlns:android=”http://schemas.android.com/apk/res/android”
android:id=”@+id/drawer_layout”
android:layout_width=”match_parent”
android:layout_height=”match_parent”
FrameLayout
android:layout_width=”match_parent”
android:layout_height=”match_parent”
... /
ListView
android:layout_width=”240dp”
android:layout_height=”match_parent”
... /
/android.support.v4.widget.DrawerLayout
Element ListView opisuje szufladę
nawigacyjną.
Elementem głównym naszego nowego układu jest DrawerLayout. To zrozumiałe,
gdyż musi on kontrolować wszystko, co dzieje się na ekranie. Klasa DrawerLayout
pochodzi z biblioteki Support Library v4, dlatego zastosujemy jej pełną nazwę:
android.support.v4.widget.DrawerLayout.
Pierwszy element umieszczony w układzie DrawerLayout będzie służył do
wyświetlania zawartości. W naszym przypadku będzie to układ FrameLayout,
w którym będziemy wyświetlali poszczególne fragmenty. Chcemy, aby był
on możliwie jak największy, dlatego obu jego atrybutom — layout_width
i layout_height — przypisaliśmy wartość ”match_parent”.
Drugim elementem układu DrawerLayout jest sama szuflada nawigacyjna.
Jeśli utworzymy ją za pomocą widoku ListView, to będzie ona zawierała listę
opcji. Zazwyczaj będziemy chcieli, aby ta szuflada wysuwała się w poziomie
i częściowo przykrywała dotychczasową zawartość ekranu. Dlatego atrybutowi
layout_height tego widoku przypisaliśmy wartość ”match_parent”, natomiast
w atrybucie layout_width podaliśmy stałą szerokość.
Kompletny kod pliku activity_main.xml przedstawiamy na następnej stronie.
Szufladę
nawigacyjną
zdefiniowaliśmy
za pomocą
widoku ListView.
Po wysunięciu
powinna ona
częściowo
przesłonić
pozostałą
zawartość ekranu.
Zawartość ekranu jest
wyświetlana w układzie
FrameLayout. Chcemy, by
wypełniała ona cały dostępny
obszar ekranu. W tym przykładzie
jest ona częściowo przesłonięta
przez szufladę nawigacyjną.
jesteś tutaj
405
Poleć książkęKup książkęKod układu
Kompletna zawartość pliku activity_main.xml
Oto kompletna zawartość pliku układu activity_main.xml:
Dodanie fragmentów
Utworzenie szuflady
Obsługa kliknięcia ListView
Dodanie ActionBarDrawerToggle
Fragmenty będą
wyświetlane
w układzie
FrameLayout.
android.support.v4.widget.DrawerLayout
xmlns:android=”http://schemas.android.com/apk/res/android”
android:id=”@+id/drawer_layout”
android:layout_width=”match_parent”
android:layout_height=”match_parent”
FrameLayout
android:id=”@+id/content_frame”
android:layout_width=”match_parent”
android:layout_height=”match_parent” /
ListView android:id=”@+id/drawer”
android:layout_width=”240dp”
android:layout_height=”match_parent”
android:layout_gravity=”start”
android:choiceMode=”singleChoice”
android:divider=”@android:color/transparent”
android:dividerHeight=”0dp”
android:background=”#ffffff”/
/android.support.v4.widget.DrawerLayout
To jest szerokość szuflady.
Szufladę
nawigacyjną
opisuje
widok
ListView.
WloskieCoNieco
app/src/main
app/src/main
res
layout
xml
/xml
activity_main.xml
Ten atrybut określa, gdzie należy umieścić szufladę.
Ten atrybut określa, że w danej chwili
można wybrać tylko jeden element listy.
W tych wierszach wyłączamy linie oddzielające
poszczególne elementy listy i określamy kolor
tła szuflady.
Zwróć baczną uwagę na ustawienia podane w elemencie ListView , gdyż
najprawdopodobniej wszystkie szuflady nawigacyjne będą wyglądały podobnie.
Do określenia wymiarów szuflady używamy atrybutów layout_width
i layout_height. Pierwszemu z nich przypisaliśmy szerokość ”240dp”,
dzięki czemu po otworzeniu szuflada będzie miała szerokość 240 dp.
Przypisanie atrybutowi layout_gravity wartości ”start” sprawi, że w razie
wyboru języka, w którym znaki są zapisywane od lewej do prawej, szuflada zostanie
umieszczona po lewej stronie ekranu, a w przypadku języków, w których znaki są
zapisywane od prawej do lewej, zostanie ona umieszczona po prawej stronie.
Atrybuty divider, dividerHeight oraz backgroud zastosowaliśmy, aby ukryć
linie oddzielające poszczególne elementy listy i określić kolor jej tła.
I wreszcie przypisanie atrybutowi choiceMode wartości ”singleChoice” sprawi,
że w danym momencie użytkownik będzie mógł wybrać tylko jeden element listy.
406 Rozdział 10.
Jeśli Twój projekt
Obejr zyj to!
nie zawiera
zależności
od biblioteki wsparcia
appcompat v7, to
przedstawiony w tym
rozdziale kod szuflady
nawigacyjnej nie będzie
działał.
W Android Studio zależnościami
możesz zarządzać, wybierając
z menu opcje File/Project
Structure/App/Dependencies.
Poleć książkęKup książkęInicjalizacja listy szuflady nawigacyjnej
Skoro już dodaliśmy do pliku activity_main.xml układ DrawerLayout, musimy
teraz określić jego zachowanie w pliku MainActivity.java. Pierwszą rzeczą,
którą należy zrobić, jest dodanie opcji do widoku listy. W tym celu dodamy
do pliku strings.xml kolejną tablicę łańcuchów. Następnie użyjemy adaptera
tablicowego do określenia opcji listy.
Poniżej przedstawiliśmy tablicę łańcuchów znaków, którą musimy dodać do
pliku zasobów strings.xml (każdy element tej tablicy określa fragment,
który zostanie wyświetlony po kliknięciu danego elementu listy):
Szuflady nawigacyjne
WloskieCoNieco
string-array name=”titles”
item Ekran główny /item
item Pizze /item
item Makarony /item
item Resatuaracje /item
/string-array
To są opcje, które zostaną
wyświetlone w szufladzie
nawigacyjnej. Dodaj tę tablicę
do pliku strings.xml.
app/src/main
app/src/main
res
Zawartość listy określimy w kodzie pliku MainActivity.java, a konkretnie
w metodzie onCreate(). Tablicę łańcuchów znaków i widok listy zapiszemy
w zmiennych prywatnych, gdyż będą nam one jeszcze potrzebne w innych
miejscach kodu. Oto kod odpowiedzialny za wypełnienie listy:
...
import android.widget.ArrayAdapter;
import android.widget.ListView;
Używamy tych klas,
więc musimy je
zaimportować.
values
xml
/xml
strings.xml
WloskieCoNieco
app/src/main
app/src/main
java
com.hfad.wloskieconieco
MainActivity.java
Do określenia zawartości
widoku listy użyjemy
adaptera ArrayAdapter.
Tych danych będziemy także
potrzebowali w innych metodach,
więc zapiszemy je w prywatnych
zmiennych klasowych.
public class MainActivity extends Activity {
...
private String[] titles;
private ListView drawerList;
@Override
protected void onCreate(Bundle savedInstanceState) {
...
titles = getResources().getStringArray(R.array.titles);
drawerList = (ListView)findViewById(R.id.drawer);
drawerList.setAdapter(new ArrayAdapter String (this,
android.R.layout.simple_list_item_activated_1, titles));
}
...
}
Zastosowanie simple_list_item_activated_1
oznacza, że element kliknięty przez użytkownika
ma być wyróżniony.
Skoro już określiliśmy opcje wyświetlane na liście szuflady nawigacyjnej,
zadbajmy o to, by lista ta reagowała na kliknięcia.
jesteś tutaj
407
Poleć książkęKup książkęReagowanie na kliknięcia
Zastosowanie OnItemClickListener, aby zapewnić
reagowanie na kliknięcia elementów listy
Aby lista reagowała na kliknięcia, zastosujemy to samo rozwiązanie, którego
użyliśmy już w rozdziale 6. — zaimplementujemy interfejs OnItemClickListener.
Innymi słowy: utworzymy obiekt nasłuchujący, zaimplementujemy jego metodę
onItemClick(), a następnie przypiszemy ten obiekt nasłuchujący do widoku listy.
Oto kod, który realizuje te operacje:
...
import android.view.View;
import android.widget.AdapterView;
Używamy tych klas,
więc musimy je
zaimportować.
Dodanie fragmentów
Utworzenie szuflady
Obsługa kliknięcia ListView
Dodanie ActionBarDrawerToggle
WloskieCoNieco
app/src/main
app/src/main
java
Ta klasa opisuje nasz obiekt
nasłuchujący typu OnItemClickListener.
public class MainActivity extends Activity {
...
private class DrawerItemClickListener implements ListView.OnItemClickListener {
@Override
public void onItemClick(AdapterView ? parent, View view, int position, long id){
// Kod, który należy wykonać po kliknięciu elementu listy
}
};
Kiedy użytkownik kliknie któryś z elementów w szufladzie
nawigacyjnej, zostanie wywołana metoda onItemClick().
com.hfad.wloskieconieco
MainActivity.java
@Override
protected void onCreate(Bundle savedInstanceState) {
...
drawerList.setOnItemClickListener(new DrawerItemClickListener());
}
};
Do widoku ListView w szufladzie nawigacyjnej dodajemy
nową instancję obiektu OnItemClickListener.
Metoda onItemClick() musi zawierać kod, który ma zostać wykonany, kiedy użytkownik kliknie
któryś z elementów widoku listy. W naszym przypadku w odpowiedzi na kliknięcie wywołamy
metodę selectItem(), przekazując do niej pozycję klikniętego elementu na liście. Już zaraz
zajmiemy się zaimplementowaniem tej metody.
Metoda selectItem() będzie musiała wykonywać trzy operacje:
Podmienić fragment wyświetlany w układzie FrameLayout.
Zmienić tytuł wyświetlany na pasku akcji tak, by odpowiadał nowemu fragmentowi.
Zamknąć szufladę nawigacyjną.
Obecnie wiesz już wszystko, co jest niezbędne do zaimplementowania pierwszej z tych operacji,
dlatego zajmiesz się tym samodzielnie w ramach ćwiczenia przedstawionego na następnej stronie.
408 Rozdział 10.
Poleć książkęKup książkęMagnesiki z kodem
Kiedy użytkownik kliknie element wyświetlony na liście w szufladzie
nawigacyjnej, wówczas w układzie FrameLayout o identyfikatorze
content_frame musi zostać wyświetlony odpowiedni fragment.
Przekonajmy się, czy potrafisz uzupełnić poniższy kod.
To jest widok ListView
prezentujący listę
elementów.
Szuflady nawigacyjne
Ekran główny
Pizze
Makarony
Restauracje
beginTransaction()
new
position
PizzaFragment()
TopFragment()
new
fragment
StoresFragment()
PastaFragment()
new
commit()
new
jesteś tutaj
409
private void selectItem(int position) {
Fragment fragment;
switch(..................) {
case 1:
fragment = ............................;
break;
case 2:
fragment = ............................;
break;
case 3:
fragment = ............................;
break;
default:
fragment = ............................;
}
FragmentTransaction ft = getFragmentManager(). ......................;
ft.replace(R.id.content_frame, .................);
ft.addToBackStack(null);
ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
ft. .................;
}
Poleć książkęKup książkęRozwiązanie magnesików
Magnesiki z kodem. Rozwiązanie
Kiedy użytkownik kliknie element wyświetlony na liście w szufladzie
nawigacyjnej, wówczas w układzie FrameLayout o identyfikatorze
content_frame musi zostać wyświetlony odpowiedni fragment.
Przekonajmy się, czy potrafisz uzupełnić poniższy kod.
To jest widok ListView
prezentujący listę
elementów.
Ekran główny
Pizze
Makarony
Restauracje
private void selectItem(int position) {
Fragment fragment;
switch(..................) {
switch(..................) {
case 1:
case 1:
position
Sprawdzamy pozycję klikniętego elementu
na liście ListView szuflady nawigacyjnej.
fragment = .................................;
fragment = .................................;
fragment = .................................;
fragment = .................................;
fragment = .................................;
fragment = .................................;
break;
case 2:
new
PizzaFragment()
fragment = ...............................;
fragment = ...............................;
fragment = ...............................;
fragment = ...............................;
fragment = ...............................;
fragment = ...............................;
break;
case 3:
new
PastaFragment()
fragment = ..............................;
fragment = ..............................;
fragment = ..............................;
fragment = ..............................;
fragment = ..............................;
fragment = ..............................;
break;
default:
StoresFragment()
StoresFragment()
new
fragment = ............................;
fragment = ............................;
fragment = ............................;
fragment = ............................;
fragment = ............................;
fragment = ............................;
}
new
TopFragment()
Tworzymy fragment, którego
typ jest zależny od pozycji
klikniętego elementu. Na
przykład jeśli użytkownik
kliknął element Pizze, to
tworzymy fragment klasy
PizzaFragment.
Domyślnie tworzymy fragment
klasy TopFragment.
FragmentTransaction ft = getFragmentManager(). ...........................;
FragmentTransaction ft = getFragmentManager(). ...........................;
beginTransaction()
fragment
ft.replace(R.id.content_frame, .................);
ft.replace(R.id.content_frame, .................);
ft.addToBackStack(null);
ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
ft. .................;
ft. .................;
}
Zatwierdzamy transakcję.
commit()
Rozpoczynamy transakcję
fragmentu, która podmieni
aktualnie prezentowany fragment.
410 Rozdział 10.
Poleć książkęKup książkęMetoda selectItem() w obecnej postaci
Poniżej przedstawiliśmy zmodyfikowany kod pliku MainActivity.java
(kiedy zostanie kliknięty jeden z elementów prezentowanych w szufladzie
nawigacyjnej, wywoływana jest metoda selectItem(), która wyświetla
odpowiedni fragment):
...
import android.app.Fragment;
import android.app.FragmentTransaction;
Szuflady nawigacyjne
WloskieCoNieco
app/src/main
app/src/main
java
com.hfad.wloskieconieco
MainActivity.java
public class MainActivity extends Activity {
...
private class DrawerItemClickListener implements ListView.OnItemClickListener {
@Override
public void onItemClick(AdapterView ? parent, View view, int position,long id){
selectItem(position);
}
};
Po kliknięciu elementu wywołujemy
metodę selectItem().
Sprawdzamy pozycję klikniętego elementu na liście.
private void selectItem(int position) {
Fragment fragment;
switch(position) {
case 1:
fragment = new PizzaFragment();
break;
case 2:
fragment = new PastaFragment();
break;
case 3:
fragment = new StoresFragment();
break;
default:
fragment = new TopFragment();
}
FragmentTransaction ft = getFragmentManager().beginTransaction();
ft.replace(R.id.content_frame, fragment);
ft.addToBackStack(null);
ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
ft.commit();
}
}
Używamy transakcji, by podmienić
aktualnie wyświetlany fragment.
Na podstawie pozycji klikniętego elementu
na liście określamy typ tworzonego
fragmentu. Na przykład opcja „Pizze”
znajduje się na pozycji 1, więc
w przypadku jej kliknięcia utworzymy
fragment PizzaFragment.
Domyślnie tworzymy fragment TopFragment.
Skoro metoda selectItem() wyświetla już odpowiedni fragment,
zajmiemy się zmianą tytułu paska akcji.
jesteś tutaj
411
Poleć książkęKup książkęZmiana tytułu
Zmiana tytułu paska akcji
Oprócz podmieniania wyświetlanego fragmentu musimy także zmieniać tytuł
wyświetlany na pasku akcji, tak by odpowiadał on aktualnie prezentowanemu
fragmentowi. Chcemy, by na pasku akcji domyślnie była wyświetlana nazwa aplikacji,
jeśli jednak użytkownik kliknie na przykład opcję Pizze, to będziemy chcieli zmienić
tytuł paska akcji na „Pizze”. Dzięki temu użytkownik będzie wiedział, w którym
miejscu aplikacji aktualnie się znajduje.
Implementując to rozwiązanie, wykorzystamy pozycję klikniętego elementu listy
i na jej podstawie określimy tekst, który zostanie wyświetlony na pasku akcji.
Następnie zmienim
Pobierz darmowy fragment (pdf)