Czas na napisanie swojej pierwszej aplikacji, tak zwanego "Hello World" . W tym poradniku dowiecie się jak to zrobić z pomocą Eclipse, jakie są typy edytorów w naszym IDE, do czego służy AndroidManifest w programach, gdzie co tworzyć i dodawać oraz wiele więcej... Bez zbędnego gadania, zaczynamy, bo podpunktów jest sporo!

1. Tworzymy projekt

Uruchamiamy Eclipse, po czym w naszym doku Package Explorer lub menu narzędziowym File wybieramy pozycję New i Android Application Project. Jeżeli wszystko dobrze zrobiliście, zobaczycie mniej więcej takie okienko: Jest to standardowy kreator projektu aplikacji dla Androida. Niestety, zmienia się on bardzo często i możliwe, że wkrótce będzie on kompletnie inaczej wyglądał. No ale na to nic nie poradzę, tutaj tworzę na aktualnie dostępnym. Po co nam ten cały kreator? Jak każdy inny element tego typu, tak i ten służy on nam do łatwego wprowadzania podstawowych danych, tutaj wymaganych przez system Android. Jak pewnie już zauważyliście, jest to nazwa aplikacji, projektu (to dla Eclipse), paczki (dla pliku apk i unikalnego identyfikatora w markecie), wersja systemu, pod którą SDK ma kompilować program, oraz minimalna wymagana wersja systemu przez program. Poniższe checkboxy natomiast służą do tworzenia ikony w kolejnych krokach (odznaczcie to najlepiej), oznaczenia projektu jako biblioteka (odznaczcie) oraz do wskazania niestandardowej lokalizacji projektu na dysku (zostawcie zaznaczone). Pola wypełniamy jak chcemy, wpisując nazwę aplikacji w "Application Name" (np Moja pierwsza aplikacja), nazwę projektu w "Project Name" oraz nazwę paczki w "Package Name". Ta ostatnia powinna stosować się do ogólnej konwencji nazywania paczek w języku Java, to znaczy tworzyć hierarchię, gdzie każdy poziom jest oddzielony kropką. Ważne jest również to, aby ta nazwa była unikalna - jeżeli użyjemy zajętej już nazwy, market nam aplikacji nie przyjmie. Nazwa paczki rozpoczyna się od głównej domeny, zazwyczaj nazwy organizacji czy autora i zapisuje w odwrotnej kolejności (np eclipse.org nazywa swoje paczki org.eclipse). Kolejne miejsca oznaczają subdomeny. Wersję systemu powinniśmy wybrać starannie, ale w razie pomyłki później możemy to zmienić. Pierwsze pole to wersja Androida, pod którą chcemy kierować aplikację. Polecam wybranie czegoś aktualnego, jak na przykład 4.1 lub 4.0.  Większe znaczenie ma niższe pole, czyli minimalna wymagana wersja oprogramowania. Jest to informacja dla marketu oraz Androida, od której wersji program ma działać. Powinniśmy wybrać coś pomiędzy 2.0 a 2.3, aby program był obecny na większości smartfonów. Klikamy dalej. Pojawi się okienko o tworzenie pierwszego Activity. Jest to opcjonalna funkcja i nic nie musimy tworzyć, ale dla łatwiejszej pracy zaznaczmy jednak pierwszą opcję - "BlankActivity" - i przejdźmy dalej. Kolejny krok to konfigurowanie swojego pierwszego Activity, jeżeli zaznaczyliśmy wcześniej tworzenie go na starcie. Wpisujemy tutaj co chcemy, ja polecam jednak zachowanie jakiejkolwiek konwencji (nawet własniej) w nazwach, co by to później się nie pogubić. Przykładowo, główne Activity niech nazywa się View_Main lub ViewMain (View - bo będzie mieć layout i inne widoki), a layout dla niego view_main (pisane z małych literek). Dzięki temu chcąc wprowadzić zmiany nie będziemy musieli przeklikywać się przez tuzin plików, aby dotrzeć do tego jednego. "Navigation Type" i "Hierarchical Parent" pozostawiamy puste, "Title"  powinno nazywać się tak samo jak "Activity Name". Klikamy finish, projekt się tworzy i bam - widzimy swój layout dla programu.

2. Edytory w Eclipse IDE i Android SDK

Jak pewnie zauważyliście, Eclipse posiada graficzny edytor layoutów XML (w takim są formacie). Jest on całkiem przydatny, bo większości elementów Views nie musimy tworzyć ręcznie wpisując w edytorze tekstowym. Wystarczy jedynie z lewego panelu przeciągnąć coś do layoutu i element zostaje stworzony na wybranym miejscu. Proste i przyjemne. Ale uwaga! Nie wierzcie mu do końca, jest masa przypadków, gdzie on po prostu jest bezużyteczny. Traktujcie ten edytor jako pomocniczy, a nie podstawowy. Naszą podstawą oczywiście będzie wersja tekstowa. Dostaniecie się do niej klikając ten przycisk w rogu: Wtedy widzimy czysty kod, w którym możemy ręcznie i dowolnie ustalać atrybuty. Podobnie będzie z innymi plikami, używamy edytora tekstowego zamiast graficznego.

3. Co, gdzie i jak - architektura aplikacji

Android, jak sami wiecie, działa na wielu urządzeniach - od smartfonów, przez tablety, a na całych komputerach kończąc. Oznacza to, że struktura programu będzie bardzo podzielona na części, by zapewnić wsparcie niezależnie od zaplecza sprzętowego. I nie jest to wcale wada, bo dzięki przemyślanej konstrukcji za bardzo nie musimy martwić się o to, jak program będzie się zachowywał się (i wyglądał) na różnym sprzęcie. Główny rywal Androida - iOS - takiego dodatku nie miał, co w końcu doprowadziło do tragedii na iPhone 5, gdzie na dole i górze ekranu widzimy czarne pasy, a w pierwszej fazie wprowadzania iPada widzieliśmy małe, rozciągnięte okienko na cały obszar. My z góry ustalony mamy inny porządek. Struktura aplikacji na Androida prezentuje się następująco: Idąc po kolei po folderach i plikach:

• src - pliki .java programu, gdzie znajduje się cała logika aplikacji. To tutaj dodajemy klasy, definiujemy poszczególne Activity, Adaptery i tak dalej. Całość jest gromadzona w paczkach, które są oczywiście jednocześnie nazwą .apk w katalogu /data/app w Androidzie (jednak to nie jest przymus, czasem system dopisuje sam coś do nazwy a i tak program działa). Jak widzicie, posiadamy jedną klasę o nazwie View_Main, która została stworzona automatycznie w kreatorze.
• gen - pliki generowane przez kompilator (i pre-kompilator) do poprawnego działania aplikacji. Nic ciekawego dla nas tam nie znajdziemy, lepiej nie ruszajcie tego folderu.
• assets - jeden z folderów z zasobami dla naszego programu. Tutaj dodajemy pliki dowolnego formatu, które później chcemy użyć w aplikacji. Uwaga! Android nie generuje tutaj id dla każdego elementu, chcąc użyć jakiegoś pliku z tego folderu musimy podać jego ścieżkę!
• bin - pliki binarne, nic wartego uwagi - podobnie jak gen
• libs - tutaj wklejamy ewentualne zewnętrzne biblioteki do programów. We wcześniejszych wersjach SDK/ADP ten folder nazywał się lib, co obecnie może powodować błędy i zakłopotanie, jeżeli stosujemy się do jakiegoś starszego poradnika. Jak widzicie, mamy tam android-support-v4.jar, czyli bibliotekę znaną szerzej jako compability library. Po co nam ona? W skrócie umożliwia korzystanie z nowych API z Androida 4.0 na starszych urządzeniach. Dzięki temu możemy pisać jeden kod (mniej więcej), a i tak będzie on działał na starszych wersjach systemu. Uwaga! Niektóre  biblioteki należy dodawać do projektu przez Properties->Android->Add lub Properties->Java Build Path->Libraries->Add JARs, klikając najpierw prawym przyciskiem myszy na projekt! Próbujcie obu sposobów, jeżeli któryś nie działa.
• res - główny folder z zasobami dla programu. Działa podobnie do assets, z tą różnicą, że generowane są identyfikatory do pliku R.java, przez co w programie nie musimy znać jego lokalizacji a jedynie nazwę. To tutaj dbamy również o wygląd aplikacji na różnych urządzeniach - wystarczy dodać odpowiednie foldery, skopiować layout który chcemy nieco zmienić, wkleić do wybranego przedziału i gotowe. Wszystko samo zadziała. Tłumacząc kolejne podfoldery: - w drawable-xxxx dodajemy pliki graficzne w różnych rozdzielczościach (xhdpi - bardzo wysoka, hdpi - wysoka, mdpi - średnia , ldpi - niska rozdzielczość) - w drawable pliki xml z generowanymi kształtami (np tła z ramką) - w layout-xxxx szablony wyglądu w różnych wielkościach (np dla tabletów i telefonów) - w menu ustawienia przycisku menu (lub actionbara) - w values różne ciągi znaków i ustawienia.Uwaga! Android musi rozpoznawać formaty tych plików, aby mogły one się w tym miejscu znaleźć! 
• AndroidManifest.xml - konfiguracja aplikacji, o tym za chwilę.
• Oraz różne ustawienia dla Eclipse

Tych folderów jest nieco więcej dostępnych, więcej w dokumentacji Androida. Podstawowe póki co nam wystarczą. Jest tego sporo i trzeba to wykuć na pamięć, ale pisząc aplikacje sami zobaczycie, że ma to sens i jest bardzo proste. Przejdźmy jednak dalej, do AndroidManifestu.

4. AndroidManifest.xml 

Uruchomcie plik AndroidManifest. Przy pierwszym razie zauważycie znowu graficzny edytor pliku, wyłączcie go i przejdźcie do tekstowego. W nim znowu zobaczycie coś podobnego do tego kodu:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.moja.pierwsza.aplikacja"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="5"
        android:targetSdkVersion="15" />

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".View_Main"
            android:label="@string/title_activity_view__main" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Jest to nic innego jak konfiguracja aplikacji. Co w niej powinno być? Deklaracja każdego Activity, używane uprawnienia, wersje SDK, wersja aplikacji, intent-filtery, nazwa programu i takie tam. Zacznijmy od deklaracji głównego Activity, w tym wypadku nazwanego "View_Main". Jak widzicie dodany jest do niego intent-filter, który posiada wartości z kategorii LAUNCHER i akcji MAIN. Po poprzednich poradnikach już wiecie, że intent-filter reaguje na niektóre zdarzenia w systemie, tutaj akurat pokazuje nam nasze Actvity na liście dostępnych programów w Launcherze. Tak więc, gdy wybrana zostanie nasza aplikacja, to od razu uruchomi się Activity kryjące się pod klasą ".View_Main". Proste. Jeżeli chcemy dodać więcej ikonek do listy aplikacji (jak np. Facebook), powinniśmy ten kawałek skopiować (od <activity) i użyć innych wartości. Deklarując inne Activity (bez ikony) nie musimy używać dokładnie tego kodu, wystarczy wkleić coś takiego:

<activity android:name=".View_Welcome" />

I normalnie używać dodanej klasy w programie. Jeżeli coś takie pominiemy, Android wyrzuci błąd o niezarejestrowanym Activity. Może się zdarzyć, że w programie będziemy potrzebować uprawnień np. do dostępu do internetu. Wtedy gdzieś na początku pliku, najlepiej po <uses-sdk>, dodajemy linię podobną do tej:

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

Pozwala ona oczywiście korzystać z wybranych zasobów, informując jednocześnie usera o takich funkcjach przy instalacji. Lista dostępnych praw oraz więcej informacji znajdziecie tutaj oraz tutaj. PS. Zauważyliście linię @string/app_name albo @drawable/ic_launcher? To przykład wykorzystania zasobów z folderu res w plikach XML :)

5. Klasy do pracy!

Na (prawie) sam koniec przejdźmy do folderu src, gdzie jak wiecie jest logika naszej aplikacji, i wybierzcie swoje domyślne Activity. W tym pliku javazobaczycie mniej więcej taki kod:

package com.example.moja.pierwsza.aplikacja;

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

public class View_Main extends Activity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_view__main);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_view__main, menu);
        return true;
    }
}

Są to działania, jakie aplikacja wykonuje. Nie są one zbyt rozbudowane, ale w końcu nie takie mają być przy samym tworzeniu projektu. Z poprzednich wpisów wiecie już czym jest funkcja OnCreate, a jeżeli nie kojarzycie za bardzo, to przypomnę wam, że kod w niej wykonuje się od razu przy uruchomieniu Activity, czy jeszcze dokładniej dokładniej - obiektu klasy (bo onCreate możemy używać również w innych elementach systemu, nie tylko w Activity).  W tym wypadku ustawiany jest jedynie layout z folderu res/layout/ (R. to wszystkie wygenerowane ID, layout zasób w res, a ostatnia część to nazwa pliku). onCreateOptionsMenu natomiast służy do generowania menu z zasobu res/menu. Zostawmy na chwilę to wszytko tak jak jest i uruchommy aplikację.

5a. Uruchamianie aplikacji na urządzeniu

Jak uruchomić aplikację? Najprościej jest wybrać odpowiedni przycisk z Eclipse IDE. Jest to to zielone koło ze znaczkiem play: Po kliknięciu zobaczymy kilka okienek, gdzie klikamy odpowiednio "Android Application" i tym podobne. Przechodząc dalej IDE może nas pytać o zapis plików, co potwierdzamy, oraz o sprzęt. Tutaj dobrze jest podłączyć własnego smartfona z włączonym Debugowaniem USB (Ustawienia->Aplikacje->Debuguj), a jeżeli takiego nie posiadamy, to wymagane będzie stworzenie wirtualnej maszyny AVD. To z kolei ten przycisk: Klikamy New i postępujemy wg wskazówek, bardzo prostych zresztą. Po wszystkim na urządzeniu zobaczymy ruch, a w ostatecznym efekcie nasz program :)

5b. Co by tu zmienić...

Zróbmy coś prostego i zobaczmy efekty - na przykład zmieńmy napis Hello world na inny, dowolny. Najpierw musimy przejść do naszego layoutu z tekstem. Otwórzcie edytor tekstowy, znajdźcie element TextView w ViewGroup RelativeLayout i dodajcie do atrybutów pole id z dowolną nazwą, tak aby wyglądało to jak poniżej:

    <TextView
        android:id="@+id/tvTest"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true"
        android:text="@string/hello_world"
        tools:context=".View_Main" />

Pamiętajcie o dobrych praktykach, skoro jest to TextView to nazwę elementu stwórzcie tak, abyście wiedzieli, że to on. U mnie jest to tvTest (tv od TextView). Zapisz XML i przejdź do klasy z Activity (folder src) - w pliku View_Main funkcję OnCreatezmień tak:

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_view__main);

        TextView tvTest1 = (TextView) findViewById(R.id.tvTest);
        tvTest1.setText("Jakiś tekst");
    }

Co zrobiliśmy? Jeżeli wcześniej programowałeś, to doskonale wiesz co - z definiowaliśmy zmienną typu TextView o nazwie tvTest1, przypisaliśmy do niej View (rzutując na typ TextView) o id tvTest (to z pliku XML), po czym ustawiliśmy na niej swój tekst. Po wszystkim uruchamiamy i boom, jest efekt :) Prosty, ale zawsze coś. Na dziś to tyle. Sporo się nauczyliśmy, czas więc odpocząć i przygotować się na więcej - jutro będziemy już reagować na kliknięcia! Uff...