Wstęp do Androida

post_img

Android jest obecnie najpopularniejszym systemem operacyjnym przeznaczonym dla urządzeń mobilnych. Według danych firmy Canalys w ostatnim kwartale 2010 roku Android osiągnął wynik 32,9 miliona sprzedanych telefonów, wyprzedzając Symbiana (31 mln) oraz pozostawiając w tyle iOS (16,2 mln). Od przejęcia w roku 2005 roku firmy Android Inc. rozwijany jest przez Google. Opiera się na jądrze Linuxa. Działa na zasadach wolnego oprogramowania (Apache License 2.0) – nie licząc linii 3.x przeznaczonej wyłącznie na tablety. Android udostępnia bardzo rozbudowane możliwości deweloperskie: bazę danych SQLite, WebKit, GPS, sensory, bibliotekę graficzną OpenGL ES, TTS i wiele innych. W tym artykule przedstawię podstawowe informacje dotyczące Androida oraz pokażę, jak zacząć swoją przygodę z programowaniem w ramach tej platformy.

Ważniejsze pojęcia

  • Activity – klasa, która odpowiada za stworzenie okna aplikacji. Zawiera takie metody jak onCreate (wywoływana w momencie inicjalizacji klasy) oraz inne metody reagujące na przejście klasy w inne stany cyklu życia, np. onPause, onStop, onResume i inne.
  • Layout – schemat określający rozmieszczenie elementów na ekranie.
  • Intent – klasa opisująca operację, którą mamy zamiar wykonać.
  • SDK (Software Development Kit) – zbiór narzędzi umożliwiający pisanie, uruchamianie oraz testowanie aplikacji w danej technologii – w naszym przypadku dla platformy Android.
  • NDK (Native Development Kit) – zbiór narzędzi umożliwiający pisanie aplikacji w języku C/C++ dla platformy Android.
  • ADT (Android Development Tools) – plugin umożliwiający pisanie aplikacji na Androida przy wykorzystaniu środowiska Eclipse.
  • AVD (Android Virtual Device) – emulator systemu Android umożliwiający uruchomienie plików .apk na komputerze.

Jak zacząć

Język programowania

Podstawowym językiem programowania dla tej platformy jest Java z ograniczonym API, dostosowana do potrzeb smartfonów i tabletów (Android SDK). Przy pomocy NDK (Native Development Kit) można również korzystać z języka C/C++, co może spowodować znaczne zwiększenie szybkości pracy aplikacji, np. w wypadku zaawansowanych operacji graficznych. NDK umożliwia pisanie mieszanych aplikacji Java/C/C++ jak również (od wersji r5) samodzielnych aplikacji C/C++.

Środowisko programistyczne

Do pisania aplikacji na urządzenia z systemem Android można wykorzystać takie IDE, jak Eclipse, NetBeans czy IntelliJ IDEA. W tym przykładzie skorzystamy z pierwszego z nich. Instalacja środowiska (oryginalna instrukcja pod adresem http://developer.android.com/sdk/installing.html):

1. Ściągamy i instalujemy JDK5 lub JDK6. Samo JRE jest niewystarczające.

2. Ściągamy i instalujemy Eclipse (for Java Developers, for Java EE Developers lub Classic w wersji 3.5.1 lub wyższej).

3. Ściągamy i instalujemy Android SDK.

4. Dodajemy komponent do SDK.

  • Włączamy „SDK Manager”.
  • Automatycznie zostaną wyszukane wszystkie aktualizacje.
  • Akceptujemy licencje paczek, które nas interesują i klikamy Install.


Wskazówka: Gdy łączymy się przez serwer Proxy, należy włączyć SDK Manager, wejść w Tools > Options… (w starszych wersjach SDK wchodzimy w Settings) i tam skonfigurować swoje połączenie.

5. Dodajemy AVD (Android Virtual Device).

  • Włączamy „SDK Manager”.
  • Wchodzimy w Tools > Manage AVDs…
  • Klikamy New.
  • W nowym oknie nadajemy nazwę nowemu AVD.
  • W polu Target wybieramy interesującą nas wersję API. Numer API określa minimalną wersję Androida, dla której aplikacja będzie działać poprawnie, np. API 7 określa wersję Androida 2.1. Kolejne platformy wersji 1.x i 2.x są kompatybilne wstecz.
  • Wybieramy rodzaj wyświetlacza w polu Skin oraz inne parametry sprzętowe w polu Hardware.
  • Możemy również zaznaczyć opcję Snapshot, która umożliwi szybsze włączanie się emulatora.
  • Klikamy Create AVD.


Wskazówka: Przy większych projektach lub wymagających dostępu do niektórych elementów sprzętowych korzystanie z emulatora może okazać się bardzo uciążliwe lub w ogóle niemożliwe. W takich przypadkach warto skorzystać z możliwości bezpośredniego instalowania/debugowania aplikacji w telefonie. Aby to zrobić, należy w ustawieniach telefonu wybrać opcję Aplikacje, zaznaczyć pole Nieznane źródła oraz w zakładce Dla programistów zaznaczyć Debugowanie USB. Następnie podłączamy telefon do komputera przy pomocy kabla USB. Aby sprawdzić, czy nasze urządzenie jest widziane przez Android Debug Bridge (ADB), należy w konsoli wywołać komendę adb devices. Powinna pojawić się lista podłączonych urządzeń z systemem Android oraz włączonych emulatorów. Jeżeli na tej liście znajduje się nasz telefon, możemy z poziomu Eclipse instalować, uruchamiać oraz debugować (przy pomocy DDMS) w nim nasze aplikacje.

6. Instalujemy ADT(Android Development Tools).

  • Włączamy Eclipse.
  • Wchodzimy w Help > Install New Software.
  • Klikamy Add.
  • Location: https://dl-ssl.google.com/android/eclipse/.
  • Klikamy Ok.
  • Zaznaczamy Developer Tools i klikamy Next.
  • Kolejny raz klikamy Next, następnie pojawią się warunki licencji, akceptujemy i klikamy Finish
  • Restartujemy Eclipsa.

Wskazówka: Gdy łączymy się przez serwer Proxy, należy włączyć Eclipse i wejść w Window > Preferences > General > Network Connections i tam skonfigurować swoje połączenie.

7. Konfiguracja ADT

  • Włączamy Eclipse.
  • Wchodzimy w Window > Preferences.
  • Wybieramy zakładkę Android.
  • Klikamy Browse i wybieramy miejsce, w którym zainstalowaliśmy Android SDK.
  • Klikamy Apply a następnie Ok.

konfiguracja AVD

Przykładowa aplikacja

Pierwszą aplikacją na telefony z systemem Android będzie prosty notatnik umożliwiający dodawanie, usuwanie oraz edytowanie notatek. Nasza aplikacja będzie składała się z dwóch layout’ów: jednego zawierającego listę naszych notatek i drugiego umożliwiającego dodawanie i edycję notatek. Nasze informacje będziemy przechowywać z bazie SQLite. Dodawanie notatek będzie wywoływane poprzez przycisk w wysuwanym menu, a edycja i usuwanie poprzez przyciski w menu kontekstowym wywoływanym przy naciśnięciu danej notatki.

Tworzenie nowego projektu

1. Włączamy Eclipse.

2. Wchodzimy w File > New > Android Project.

3. Nadajemy nazwę projektowi i klikamy Next.

4. Wybieramy interesującą nas wersję API i klikamy Next.


5. Podajemy nazwę naszej paczki i klikamy Finish.

6. Eclipse wygenerował nam nasz projekt, w którym znajdują się między innymi:

  • Folder src zawierający naszą paczkę oraz pierwszą klasę, do której powrócimy podczas pisania naszej pierwszej aplikacji.
  • Folder gen zawierający automatycznie wygenerowany plik R.java, którego nie należy modyfikować ręcznie. Klasa ta łączy zasoby graficzne z kodem Javy.
  • Folder bin, w którym będą się znajdować stworzone przez nas aplikacje oraz klasy po skompilowaniu.
  • Folder res zawierający nasze zasoby m. in. podfolder layout, w którym możemy w postaci plików xml zdefiniować wygląd interfejsów naszej aplikacji. Oczywiście można dodawać elementy w kodzie aplikacji analogicznie jak przy użyciu biblioteki Swing, jednak skorzystanie z plików xml jest o wiele wygodniejszą metodą. Dodatkowo Eclipse pozwala na automatyczne budowanie layoutów w postaci plików xml dzięki prostemu edytorowi graficznemu.
  • Plik AndroidManifest.xml jest to główny plik konfiguracyjny Androida zawierający m. in. nazwę paczki, minimalną wersję API, zezwolenia na dostęp do zasobów sprzętowych, zdefiniowane klasy Activity, Serwisy

Elementy aplikacji

1. Konfiguracja wyglądu

1.1. Konfiguracja poprzez xml

W Eclipsie w panelu Package Explorer klikamy prawym przyciskiem myszy na folder res/layout. Z menu wybieramy New -> Android XML File. Wprowadzamy nazwę nowego pliku – w naszym przypadku będzie to addnote. W tym miejscu możemy dodać elementy widoku, ale zrobimy to później, a więc klikamy Finish. Klikamy dwa razy na nowo powstały plik, przez co otwieramy graficzny interfejs pozwalający na dodawanie elementów do widoku.


Z panelu Form Widgets wybieramy Medium text i przeciągamy go na nasz ekran. Jego zawartość oraz id możemy ustalić, przechodząc do widoku xml (zakładka u dołu panelu). Analogicznie postępujemy z kolejnymi elementami. W edytorze graficznym możemy w zależności od wybranego layout’u (standardowo jest to LinearLayout) pozycjonować oraz zmieniać wielkość dodanych przez nas elementów. Po dodaniu wszystkich elementów wygenerowany plik xml powinien wyglądać tak:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent"
   android:orientation="vertical" >

    <TextView
       android:id="@+id/textView1"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Title: "
       android:textAppearance="?android:attr/textAppearanceMedium" />

    <EditText
       android:id="@+id/editText1"
       android:layout_width="fill_parent"
       android:layout_height="wrap_content" >

        <requestFocus />
    </EditText>

    <TextView
       android:id="@+id/textView2"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Text: "
       android:textAppearance="?android:attr/textAppearanceMedium" />


    <EditText
       android:id="@+id/editText2"
       android:layout_width="fill_parent"
       android:layout_height="wrap_content"
       android:layout_weight="0.88"
       android:inputType="textMultiLine" />

</LinearLayout>

Warto w tym miejscu podejrzeć plik R.java. W tym pliku wygenerował nam się fragment kodu przypisujący id naszych elementów pewne stałe.

1
2
3
4
        public static final int editText1=0x7f050001;
        public static final int editText2=0x7f050003;
        public static final int textView1=0x7f050000;
        public static final int textView2=0x7f050002;

Jak już wspomniałem wcześniej, nie należy samodzielnie modyfikować tego pliku. Wartości tych stałych nie mają dla nas większego znaczenia. Te wpisy demonstrują, w jaki sposób android łączy zasoby graficzne z kodem Javy.

1.2. Konfiguracja z poziomu javy

W przypadku widoku listy najprostszym sposobem jest zrobienie tego z poziomu javy. Zmieniamy klasę, z której dziedziczy klasa AtenaNotepadActivity z

1
public class AtenaNotepadActivity extends Activity

na

1
public class AtenaNotepadActivity extends ListActivity

Teraz wystarczy ustawić adapter wskazujący, co ma wyświetlać nasza lista. Robimy to poprzez:

1
2
this.setListAdapter(new ArrayAdapter<String>(this,
                    android.R.layout.simple_list_item_1,results));

gdzie results jest to ArrayList danych, które chcemy wyświetlić, a android.R.layout.simple_list_item_1 jest to stała określająca wygląd naszej listy.

2. Definiowanie napisów

Aby zdefiniować napisy, które wykorzystamy później w celu wyświetlenia ich na przyciskach naszych menu, wchodzimy w folder res naszego projektu. Następnie wybieramy katalog values i klikamy dwukrotnie na plik strings.xml. Klikamy Add, w kolejnym okienku wybieramy opcje String i klikamy OK. Następnie możemy nadać nazwę oraz wartość naszego stringa. Aby odwołać się do utworzonego napisu w kodzie wystarczy R.string.nazwa.

3. Stworzenie bazy danych oraz tablicy składającej się z 2 kolumn „Title” i „Text” .

  • Definiujemy nazwę bazy danych.
1
2
private final String DB_NAME = "AtenaNotepad";
private SQLiteDatabase baza = null;
  • Otwieramy (jeżeli istnieje) lub tworzymy bazę danych oraz tablicę Notepad poprzez metodę execSQL. Poniższy fragment kodu wstawiamy do metody onCreate, która zostaje wywołana w momencie startu naszej aplikacji.
1
2
3
4
5
6
7
try {
baza = this.openOrCreateDatabase(DB_NAME, MODE_PRIVATE, null);
baza.execSQL("CREATE TABLE IF NOT EXISTS Notepad (Title VARCHAR UNIQUE, Text VARCHAR)");
           
} catch (SQLException e) {
    e.printStackTrace();
}
  • Przykładowe zapytanie do bazy danych.
1
Cursor cursor = baza.rawQuery("SELECT Title FROM Notepad", null);

4. Wywołanie okna wprowadzania i edycji notatki.

1
2
Intent intent = new Intent(getApplicationContext(), AddNote.class);
startActivityForResult(intent, REQUEST_CODE);

5. Przekazywanie parametrów pomiędzy widokami.

1
2
3
4
5
6
7
intent = new Intent();
               
        intent.putExtra("Title", title.getText().toString());
        intent.putExtra("Text", text.getText().toString());
                 
        AddNote.this.setResult(RESULT_CODE, intent);                    
AddNote.this.finish();

6. Tworzenie oraz obsługa wysuwanego menu.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Override
    public boolean onCreateOptionsMenu(Menu menu) {
        super.onCreateOptionsMenu(menu);
        menu.add(0, ADD_ID, 0, R.string.menu_add);
        return true;
}

@Override
    public boolean onMenuItemSelected(int featureId, MenuItem item) {
        switch(item.getItemId()) {
            case ADD_ID:
                addNote();
                return true;
        }

        return super.onMenuItemSelected(featureId, item);
    }

7. Naciskając Run, tworzymy plik apk jednocześnie odpalając go na emulatorze (jeżeli stworzyliśmy AVD) lub na urządzeniu.

Cały projekt można pobrać z: AtenaNotepad

Podsumowanie

Programowanie na platformę Android jest bardzo szerokim tematem m.in. ze względu na ilość dostępnych peryferii oraz bibliotek. Ten artykuł jest jedynie wstępem, w którym skupiłem się na przygotowaniu środowiska oraz stworzeniem pierwszego projektu. Przedstawiona aplikacja pokazuje wykorzystanie takich elementów, jak menu kontekstowe, widok listy, komunikacja pomiędzy widokami, wysuwane menu, obsługa bazy danych oraz tworzenie widoków poprzez pliki xml. Jeżeli ktoś chciałby zapoznać się z innymi możliwościami, zachęcam do przeanalizowania przykładów zawartych w folderze samples z katalogu, w którym zainstalowaliśmy SDK. Można je zaimportować do Eclipse poprzez wybranie opcji File->Import->Existing Project into Workspace. Działanie aplikacji demonstrujących możliwości poszczególnych API można również zaobserwować w emulatorze w folderze API Demos.

Materiały


Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *

12 komentarzy do “Wstęp do Androida

  • kamil

    Wszystko fajnie, tylko jaki sens ma taki wpis? to jak odgrzewanie kotleta, wszystko już było opisane w 100 miejscach i to o wiele lepiej.
    Blog ma wnosić coś nowego, świeże spojrzenie, nowe pomysły, opinie – a tu nic, wszystko to co można znaleźć w oficjalnej dokumentacji.

  • Piotr Łabuński

    Artykuł ma na celu zebranie wszystkich informacji potrzebnych do startu z Androidem w jednym miejscu. Nie dla wszystkich te informacje są oczywiste. Jest to wstęp umożliwiający czytelnikowi swobodną lekturę oraz przetestowanie treści kolejnych wpisów, które mam nadzieję będą wnosić coś nowego, świeże spojrzenie i nowe pomysły. 🙂

  • aio

    Kolejny przykład niedziałającego przykładu, a szkoda bo byłby świetny gdyby nie takie fragmenty w nim:
    ..W przypadku widoku listy najprostszym sposobem jest zrobienie tego z poziomu javy. Zmieniamy klasę, … lub ..Teraz wystarczy ustawić adapter wskazujący, co ma wyświetlać nasza lista. Robimy to poprzez:…
    Tego się nie da zrobić bo początkujący nie potrafią odgadnąć w którym pliku i miejscu trzeba to zrobić a ci którzy to wiedzą nie będą tego czytać. Mogliby zaimportować źródła ale trzeba to opisać, w przeciwnym wypadku kończy się to np dla ver. 3.7.1 co najmniej 8 błedami (krzyżykami) i życzę powodzenia początkującym w poprawianiu tych błędów.

    • Piotr Łabuński Autor wpisu

      Aplikacja została przetestowana na telefonach ZTE Blade, Samsungu Galxy S2 oraz na emulatorze i w każdym przypadku działała poprawnie.
      Poproszę o informację na temat tego na jakim sprzęcie i wersji Androida wystąpiły problemy na adres Piotr.Labunski@atena.pl – chętnie się temu przyjrzę.
      Ze względu na przyjętą długość artykułu nie opisywałem każdego fragmentu aplikacji a skupiłem się tylko na kluczowych częściach.

  • Nic

    Kod ma się nijak do zrzutów ekranów, taki przykład skutecznie wprowadza w błąd każdego początkującego. Paczka źródłowa też nie działa.

  • Lukasz

    Dzięki wielkie 🙂

    Bardzo dobry post, pozwolił mi rozpocząć naukę 🙂

    Oby tak dalej, zmieńcie tylko ten DELETE i INSERT na UPDATE, jak ktoś nie miał styczności z DB to będzie miał kolejny kroczek nauki 🙂

    • Piotr Łabuński Autor wpisu

      Dziękuję, słuszna uwaga. Oczywiście w pliku AtenaNotepadActivity INSERT i DELETE z linii 137 i 138 można zastąpić poprzez UPDATE znajdujący rekord ze starym tytułem i zapisujący do niego nowe wartości.

  • ktoś

    Witam,

    Czy ktoś mógłby mi pomóc i powiedzieć czy jest możliwe dodanie do tej bazy kolejnych pól, np Text2 itd, jeśli tak to w jaki sposób można to zrobić? Dziekuję za odpowiedz

    • Piotr Łabuński Autor wpisu

      Witam, oczywiście jest to możliwe, można dodać pole w momencie tworzenia bazy:
      baza.execSQL(„CREATE TABLE IF NOT EXISTS Notepad (Title VARCHAR UNIQUE, Text VARCHAR, Text2 VARCHAR)”);
      plik AtenaNotepadActivity.java linia 59
      lub w innym miejscu programu poprzez:
      baza.execSQL(„ALTER TABLE Notepad ADD COLUMN Text2 VARCHAR”);