1 komentarz

Hello World, Android

Lipiec 8, 2011 Pierwsze kroki Tutoriale

Jeżeli już udało nam się przebrnąć przez konfigurację naszego środowiska pracy, przyszedł czas by stworzyć pierwszą aplikację. W niniejszym artykule zmierzymy się zatem ze stworzeniem i uruchomieniem naszego pierwszego programu napisanego dla systemu Android – Hello World.

Stworzenie nowego projektu w Eclipse

  1. Nowy projektPo uruchomieniu Eclipse wybieramy File -> New -> Project…, po czym w kreatorze projektu wskazujemy Android -> Android Project.
  2. W tym momencie powinno nam się ukazać okno konfiguracji nowego projektu, w którym dostępne będą następujące pola:
    • Project name – nazwa naszego projektu,
    • Contents  - informacja o tym czy tworzymy nowy projekt czy korzystamy z istniejącego,
    • Build Target – wersja systemu /API, do którego będziemy docelowo pisać naszą aplikację,
    • Application Name – nazwa aplikacji,
    • Package Name – nazwa pakietu w którym będzie przechowywana nasz aplikacja,
    • Create Activity – Nazwa klasy głównego Activity (okna) naszej aplikacji.
    • Min SDK Version – minimalna sugerowana wersja systemu, pod którą ma działać nasza aplikacja (najlepiej gdy będzie ona taka sama jak Build Target)
  3. Po kliknięciu przycisku Finish Eclipse automatycznie utworzy nam nowy projekt aplikacji.

Na obrazku obok można podejrzeć przykładową konfigurację aplikacji.

Struktura katalogowa projektu

Jak widać, Eclipse wygenerowało nam gotową strukturę katalogów, która narzuca wstępny porządek przechowywania danych naszej aplikacji. Package explorer

  • src/ – zawiera pakiety oraz kod źródłowy naszej aplikacji. Jak widać, na razie znajduje się tam jedynie głównej Activity naszej aplikacji – HelloWorldActivity.java.
  • gen/ – zawiera pliki generowane przez wtyczkę AVD. Znajduje się tam przede wszystkim plik R.java, opisujący klasę R, która zawiera w sobie definicje elementów z jakich składa się nasza aplikacja. Dzięki temu np. do elementów layoutu, opisanego w plikach xml mamy dostęp taki, jakby znajdowały się one bezpośrednio w kodzie (są to po prostu publiczne pola statyczne, przechowujące „adresy” elementów layoutu itp.).
  • assets/ – służy do przechowywania plików z których korzysta nasza aplikacja (aczkolwiek folder ten jest używany zdecydowanie rzadziej niż res/)
  • res/ – j.w., w tym katalogu również przechowywane są pliki wykorzystywane w naszej aplikacji. W przeciwieństwie do katalogu assets/, elementy z res/ mają automatycznie wygenerowane ID (w pliku R.java, o którym pisałem powyżej). W związku z tym, to właśnie katalog res/ powinien służyć do przechowywania plików naszej aplikacji.
  • res/drawable-…/ - przechwuje elementy graficzne aplikacji (podzielony na na 3 foldery, w których umieszczamy obrazki przystosowane do różnych rozdzielczości ekranu). W tym momencie możemy tam znaleźć pliki icon.png, będące ikoną naszej aplikacji.
  • res/layout/ – przechowuje pliki .xml opisujące wygląd naszej aplikacji.
  • res/values/ – przechowuje niezmienne wartości, m.in. ciągi znaków
  • AndroidManifest.xml – plik opisujący naszą aplikację. Zawiera wszelkie informacje o jej działaniu, wymaganiach sprzętowych/software’owych (pozwolenia wykorzystania różnych zasobów) i wiele innych. Jest on też swego rodzaju publicznym API naszej aplikacji (plik ten można oglądać nawet po stworzeniu ostatecznej paczki z naszą aplikacją, gdzie większość kodu jest nieczytelna).
  • default.properties – automatycznie generowany plik z ustawieniami naszej aplikacji, którego nie powinniśmy ręcznie edytować (ustawienia zmieniamy klikając prawym przyciskiem na nasz projekt, wybierając properties).
  • proguard.cfg – ProGuard jest narzędziem, które optymalizuje naszą aplikację poprzez usuwanie zbędnego kodu, zmianę nazw klas/pól/metod itp. (oczywiście w momencie pakowania wszystkiego do pliku .apk). W związku z czym plik proguard.cfg jest zbiorem zasad, według których powinno działać narzędzie ProGuard.

Zapoznanie z wygenerowanym kodem źródłowym

Jak widać, oprócz struktury katalogowej, Eclipse wygenerował nam również kilka plików z kodem źródłowym, na które teraz rzucimy okiem.

Activity

Activity (Aktywność) jest czymś w rodzaju okienka naszej aplikacji. Nie jest to może do końca poprawne i wyczerpujące temat stwierdzenie. Ale jest chyba najbardziej trafne w tym momencie. Aktywności od bardziej teoretycznej strony zostaną przedstawione w osobnym artykule. Tutaj natomiast skupimy się tylko nad tym, co wygenerowało nam nasze IDE.

HelloWorldActivity.java

package pl.froger.helloworld;

import android.app.Activity;
import android.os.Bundle;

public class HelloWorldActivity extends Activity {
	/** Called when the activity is first created. */
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
	}
}

Nasza klasa Aktywności dziedziczy po klasie Activity i posiada jedną przeciążoną metodę – onCreate() . To właśnie ona wywoływana jest po stworzeniu (uruchomieniu) Aktywności. Wewnątrz tej metody powinny zachodzić wszelkie operacje inicjalizujące aplikację/Aktywność. W tym wypadku jest to tylko jedna czynność – wywołanie metody setContentView(int).
Powoduje ona załadowanie layoutu z pliku main.xml, zawartego w folderze /res/layout/. Jak nietrudno zauważyć, layout przekazywany jest za pomocą automatycznie generowanej klasy R.java, której pola statyczne są odwzorowaniem ścieżki w folderze res/.

UI

Interfejs w Androidzie opisywany jest najczęściej za pomocą plików .xml. Istnieje również możliwość definiowania wyglądu wewnątrz kodu źródłowego aplikacji, aczkolwiek powinniśmy z tego korzystać jedynie w wyjątkowych sytuacjach.
Przykładem takiego pliku niech będzie wygenerowany automatycznie main.xml zawarty w katalogu /res/layout/ naszego projektu.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
	xmlns:android="http://schemas.android.com/apk/res/android"
	android:orientation="vertical"
	android:layout_width="fill_parent"
	android:layout_height="fill_parent">
	<TextView
		android:layout_width="fill_parent"
		android:layout_height="wrap_content"
		android:text="@string/hello" />
</LinearLayout>

Jak widać, opis wyglądu jest dość intuicyjny, w związku z czym na razie nie będziemy się w niego zbytnio zagłębiać. Jedyną wartą uwagi linijką kodu jest zaznaczone powyżej przypisanie tekstu. Nie jest on bowiem ustawiany bezpośrednio, a pobierany za pliku strings.xml zawartego w /res/values/strings.xml. @string/hello wskazuje właśnie na ten plik, dokładnie na zmienną hello.

strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello World, HelloWorldActivity!</string>
    <string name="app_name">HelloWorld</string>
</resources>

AndroidManifest

Ostatnim, wartym uwagi plikiem jest AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="pl.froger.helloworld" android:versionCode="1"
      android:versionName="1.0">
    <uses-sdk android:minSdkVersion="8" />
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".HelloWorldActivity" android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Idąc od góry (i pomijając bardziej intuicyjne linijki kodu):

  • linijka 3 – atrybut android:versionCode odpowiedzialny jest za wersję aplikacji. Służy ona jednak tylko do porównania czy nasza aplikacja jest nowsza czy starsza (na tej podstawie system stwierdza czy należy ją aktualizować). Wartość ta nie jest wyświetlana użytkownikowi. Ten bowiem „widzi” atrybut android:versionName z linijki 4.
  • linijka 6 – <application> jest elementem w których przechowywane są wszystkie komponenty naszej aplikacji. Atrybuty android:icon wskazuje plik z ikoną naszej aplikacji (która wybierana jest z jednego z folderów /res/drawable-…/, zgodnie z rozdzielczością naszego urządzenia). Atrybut android:label to nazwa naszej aplikacji.
  • linijka 7 – deklaracja naszej Aktywności. Atrybut android:name to nazwa klasy naszego Activity. Kropka przed nazwą oznacza, że klasa znajduje się w domyślnej paczce naszej aplikacji. W innym wypadku należy podać pełną nazwę klasy aktywności (wraz z pakietem). Atrybut android:label jest nazwą naszej Aktywności, wyświetlaną na pasku w momencie gdy jest ona aktywna. Jeżeli atrybut ten nie jest ustawiony, nazwa będzie dziedziczona z tego samego atrybutu elementu <application>
  • linijki 8-11 – jest to filtr intencji, którego opis na razie pominiemy. W tym momencie ważne jest jedynie to, że filtr o takiej zawartości jak w naszym pliku sprawia, że właśnie ta Aktywność (HelloWorldActivity) jest główną Aktywnością naszej aplikacji i jest uruchamiana jako pierwsza.

Po więcej szczegółów dotyczących pliku AndroidManifest.xml odsyłam do oficjalnej dokumentacji (link).

Uruchamianie projektu

Kiedy już posiadamy ogólną wiedzę na temat naszego kodu źródłowego, pozostał nam tylko jego uruchomienie.

Konfiguracja uruchomieniowa

  1. Run configurationW Eclipse konfigurator uruchamiamy za pomocą Run -> Run Configurations… (lub rozwijając menu obok przycisku Run).
  2. W dziale Android Application dodajemy, za pomocą przycisku New nową konfigurację.
  3. W polu Name: wpisujemy nazwę naszej konfiguracji (obojętnie jaką). Następnie w zakładce Android wybieramy projekt, do którego będzie odnosić się ta konfiguracja. Launch Action pozostawiamy bez zmian na Launch Default Activity.
  4. W zakładce Target w Deployment Target Selection Mode mamy dwa tryby do wyboru:
    • Manual – podczas każdorazowego uruchomienia naszej aplikacji będziemy wybierać urządzenie, na którym ma się to odbyć,
    • Automatic – wybieramy urządzenie do uruchamiania na stałe.
  5. Klikamy Apply i w tym momencie nasza konfiguracja została dodana do listy.

Uruchamianie aplikacji

W tym momencie nie pozostało nam już nic innego jak uruchomić aplikację na naszym smartfonie/AVD.

Uwaga – czasem może zdarzyć się, że aplikacja zawiera jakieś błędy i ostrzeżenia, co uniemożliwia nam jej zbudowanie i uruchomienie. Zwykle pomaga na to jedna z dwóch czynności:

  1. Wyczyszczenie projektu za pomocą Project -> Clean (po czym wybieramy który ma być wyczyszczony).
  2. Usunięcie pliku R.java z katalogu gen/<namespace>/ . Zostanie on i tak wygenerowany przez IDE.

Aby uruchomić projekt należy:

  1. Kliknąć Run -> Run (lub przycisk Run, albo skrót Ctrl + F11).
  2. Jeżeli w konfiguracji ustawiliśmy Manual, powinno ukazać się okno podobne do poniższego:
    Android Device ChooserW tym momencie możemy wybrać pomiędzy urządzeniem podłączonym do komputera, a Android Virtual Device.
  3. Niezależnie od wyboru naszym oczom powinien ukazać się widok podobny do poniższego:

    Hello world

Tym też sposobem, bez napisania linijki kodu udalo nam się stworzyć aplikację Hello World, i uruchomić ją na urządzeniu z system Android.

Komentarze (1) Subskrybuj

 

  1. [...] Hello World, Android | android4devs Tu jest fajny tutorial ( po polsku) opisujący m.in. strukturę katalogów projektu. Polecam! Odpowiedz z cytatem + Odpowiedz w tym wątku « Poprzedni wątek | Następny wątek » [...]

Prześlij komentarz

Zaloguj się lub skorzystaj z profilu:

[rpxlogin redirect="http://www.android4devs.pl" prompt="" style="large"]

Możesz również zostawić komentarz bez rejestracji, korzystając z poniższego formularza:

Musisz być zalogowany aby móc pisać komentarze.