• nazwa aplikacji – Lotto
• losowanie 6 niepowtarzalnych liczb z zakresu 1..49 po naciśnięciu przycisku „Losuj”
• aplikacja ma posiadać 3 widoki w rozkładzie RelativeLayout:
  • ImageView – zawierający logo totalizatora,
  • TextView – zawierający napis „Losowanie 6 z 49 liczb”
  • Button – posiadający napis „Losuj”
• po naciśnięciu przycisku następuje wyświetlenie wylosowanych liczb w zdefiniowanym uprzednio widoku TextView

Otwieramy Android Studio i tworzymy Nowy projekt:

Wybieramy Empty Activity

Nadajemy nazwę i klikamy Finish

Teraz do folderu res/drawable wgrywamy grafikę totalizatora (pobierz ją z internetu):

Wystarczy kliknąć na pobrany plik PPM->”copy”, następnie PPM w Android Studio na folder Drawable->”Paste”

Przechodzimy do edycji pliku activity_main.xml w widoku Code:

Przystępujemy do kodowania:

• ustawiamy biały kolor tła dla layoutu
• dodajemy id do widoków
• ustawiamy TextView na środku oraz ustawiamy mu padding górny i dolny
• dla ImageView określamy, że będzie nad TextView i wyśrodkowujemy
• przycisk wyśrodkowujemy i ustawiamy poniżej tekstu

<?xml version="1.0" encoding="utf-8"?>
<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"
    android:background="#fff"
    tools:context=".MainActivity">

    <TextView
        android:id="@+id/textview"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"
        android:paddingTop="20dp"
        android:paddingBottom="20dp"
        android:text="Losowanie 6 z 49 liczb"
        android:textSize="20sp"/>

    <ImageView
        android:id="@+id/imageView"
        android:src="@drawable/lotto"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_above="@id/textview"
        android:layout_centerInParent="true"
        />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@id/textview"
        android:layout_centerInParent="true"
        android:text="Losuj"
        android:textSize="16sp"
    />
</RelativeLayout>

Możemy podejrzeć wygląd aplikacji w zakładce split lub design.

Przechodzimy do warstwy logicznej, modyfikujemy plik MainActivity.java:

package com.example.androidlotto;

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import java.util.ArrayList;
import java.util.Collections;

public class MainActivity extends AppCompatActivity {
    //deklarujemy dwa pola, oba wykorzystują pakiet widget
    TextView textView;
    Button button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //inicjuję moje pola
        textView = (TextView) findViewById(R.id.textview); //rzutujemy na konkretny typ
        button = (Button) findViewById(R.id.button);

        //co się stanie gdy klikniemy
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //tworzymy listę liczb
                ArrayList<Integer> list = new ArrayList<>();
                for (int i=1; i<=49; i++){
                    list.add(i);
                }
                //mieszamy naszą listę
                Collections.shuffle(list);
                //wybieramy 6 pierwszych liczb i ustawiamy w kolejności rosnącej
                ArrayList<Integer> choosen = new ArrayList<>();
                for (int i=0; i<6; i++){
                    choosen.add(list.get(i));
                }
                //sortujemy rosnąco
                Collections.sort(choosen);

                //z wylosowanych liczb tworzę łańcuch liczb oddzielonych przecinkami
                StringBuilder readList = new StringBuilder();
                for (int i: choosen) {
                    readList.append(String.valueOf(i));
                    readList.append(", ");
                }
                //zamieniamy StringBuilder na łańcuch znaków i kasujemy ostatni przecinek i spację
                textView.setText(readList.toString().replaceAll(", $",""));
            }
        });
    }
}

Jeżeli podejrzymy sobie nasz widok aplikacji w Design, okaże się, że mamy 3 ostrzeżenia. Dotyczą one 2 tekstów i grafiki. Zawartość wyświetlanych stringów powinna być zdefiniowana w kodzie jako zmienna, natomiast grafika powinna posiadać tekst alternatywny dla osób niepełnosprawnych zgodnie z wytycznymi WCAG.

Po podejrzeniu błędu klikamy fix. Przeglądamy plik strings.xml w folderze res/values i widzimy, że dodały się wspomniane wcześniej stringi.

Teraz uruchomimy aplikację na emulatorze:

• otwieramy managera urządzeń wirtualnych: Tools->AVD Manager
• dodajemy urządzenie na jakim chcemy testować aplikację i startujemy
• w Android Studio wybieramy „Run app”

Zadanie:

Przetestuj aplikację na innym urządzeniu stworzonym przez siebie

Artykuł 6. Android – tworzymy pierwszą aplikację w Android Studio pochodzi z serwisu Kama Kaczmarek.

Korzystamy wtedy z rozkładów (layoutów), dzięki którym możemy odpowiednio pogrupować elementy w widoku.

ViewGroup jest klasą abstrakcyjną, a jak wiemy z programowania obiektowego, nie da się utworzyć obiektu takiej klasy. Jeżeli mamy do czynienia z klasą dziedziczącą po klasie abstrakcyjnej, to obiekt takiej klasy możemy stworzyć. Klasami dziedziczącymi po ViewGroup są m.in.: LinearLayout, RelativeLayout oraz GridLayout.

Layouty mogą być kontenerami dla innych layoutów oraz elementów widoku. W skrócie możemy je w sobie zagnieżdżać.

LinearLayout – Jeden z najpopularniejszych layoutów, który układa elementy w pionowej kolumnie lub poziomym rzędzie.

• android:orientation – określenie kieruknu: horisontal/vertical
• android:layout_weight – waga elementu, czyli wielkość obszaru jaki będzie element zajmował

Przykład użycia:

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="some content 1"
        android:textSize="30sp"
        android:background="#c0c0c0"
    />

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_weight="2"
        android:text="some content 2"
        android:textSize="30sp"
        android:background="#aaaaaa"
    />

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="some content 3"
        android:textSize="30sp"
        android:background="#aabbbc"
    />

</LinearLayout>

Linijka xmlns:android=”http://schemas.android.com/apk/res/android” wskazuje na używaną przestrzeń nazw.

Zadanie:

Wykorzystując dotychczas zdobytą wiedzę i korzystając z pomocy dokumentacji spróbuj odtworzyć widoczny poniżej layout:

RelativeLayout – układa elementy względnie, czyli względem innych elementów lub rozkładu.

• android:layout_alignParent…– Bottom/Left/Right/Top – określenie położenia względem rozkładu
• android:layout_center… -Horizontal/Vertical – gdy chcemy wyśrodkować element w rodzicu/rozkładzie
• android:layout_below – możemy użyć celem umieszczenia elementu pod innym elementem, ale ten musi mieć przypisane ID
  

Przykład użycia:

<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">


    <ImageView 
        android:src="@drawable/rocks"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:scaleType="centerCrop"
    />

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:padding="20dp"
        android:gravity="center"
        android:text="Mój relatywny layout"
        android:textSize="28sp"
        android:textColor="#000"
        android:background="#fff"
    />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:padding="10dp"
        android:text="button1"
        android:textSize="20sp" 
        android:layout_alignParentBottom="true"
        android:background="#fff"
    />
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:padding="10dp"
        android:text="button2"
        android:textSize="20sp" 
        android:layout_alignParentBottom="true"
        android:layout_alignParentRight="true"
        android:background="#fff"
    />

</RelativeLayout>

Artykuł 5. Android – ViewGroup: LinearLayout, RelativeLayout pochodzi z serwisu Kama Kaczmarek.

Jest to klasa Javy dziedzicząca po klasie View i Object.

Przejdźmy do Visualizera i rozpocznijmy tworzenie elementów. Objaśnienia poszczególnych atrybutów poniżej kodu:

<ImageView
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:src="@drawable/fall"
    android:scaleType="centerCrop"
/>

android: – oznacza użycie przestrzeni nazw języka XML dedykowanej dla platformy Android, czyli po prostu otwieramy paczkę, z której wyciągamy konkretne atrybuty (to taka jakby ścieżka dostępu).

layout_width, layout_height – szerokość i wysokość elementu, ten zapis stosujemy we wszystkich widokach na jakich pracujemy

• wrap_content – dynamiczne dostosowanie wielkości do zawartości
• match_parent – dostosowanie wielkości do elementu nadrzędnego, np. ekranu telefonu
• dp – np. 300dp, „dp” to jednostka niezależna od rozdzielczości urządzenia i nie wpływają na nią ustawienia telefonu, związana jest z gęstością ekranu (ilość pikseli w określonej przestrzeni ekranu). Zostaje automatycznie przeskalowana na urządzeniach z różną gęstością. 1dp = 1px dla gęstości 160dpi, w przypadku uruchomienia aplikacji na urządzeniu o gęstości innej niż 160, wartość zostanie przeskalowana wg wzoru: px=dp*(dpi/160).

android:src – wgrywanie obrazka, źródło obrazka

• „@drawable/fall” – podajemy ścieżkę dostępu do obrazka jaki chcemy wyświetlić. Kiedy zaczniemy korzystać z AndroidStudio, taką właśnie strukturę będziemy wykorzystywać i taką strukturę ma nasz Visualizer. Na stronie Visualizera, w prawym dolnym rogu klknij „AVAILABLE IMAGES” i zobaczysz z jakich grafik możesz skorzystać na tą chwilę. Nie musimy podawać rozszerzenia grafiki.

scaleType – skalowanie obrazka (wszystkie opcje na stronie dokumentacji)

• centerCrop – rozciąga obrazek wertykalnie i obcina krawędzie

Artykuł 4. Android – ImageView pochodzi z serwisu Kama Kaczmarek.

TextView jest klasą Javy, która dziedziczy po klasie nadrzędnej View oraz Object.

Każdy element powinien mieć zdefiniowane podstawowe atrybuty np. szerokość i wysokość.

Przejdźmy do Visualizera i rozpocznijmy tworzenie elementów. Objaśnienia poszczególnych atrybutów poniżej kodu:

<TextView
    android:text="Witaj w mojej aplikacji!"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:textSize="36sp"
    android:textStyle="bold|italic"
    android:fontFamily="sans-serif"
    android:textColor="@android:color/black"
    android:background="#c0c0c0" 
    android:gravity="center"
    android:padding="30dp"
    android:layout_marginTop="15dp"
/>

android: – oznacza użycie przestrzeni nazw języka XML dedykowanej dla platformy Android, czyli po prostu otwieramy paczkę, z której wyciągamy konkretne atrybuty (to taka jakby ścieżka dostępu).

layout_width, layout_height – szerokość i wysokość elementu, ten zapis stosujemy we wszystkich widokach na jakich pracujemy

• wrap_content – dynamiczne dostosowanie wielkości do zawartości
• match_parent – dostosowanie wielkości do elementu nadrzędnego, np. ekranu telefonu
• dp – np. 300dp, „dp” to jednostka niezależna od rozdzielczości urządzenia i nie wpływają na nią ustawienia telefonu, związana jest z gęstością ekranu (ilość pikseli w określonej przestrzeni ekranu). Zostaje automatycznie przeskalowana na urządzeniach z różną gęstością. 1dp = 1px dla gęstości 160dpi, w przypadku uruchomienia aplikacji na urządzeniu o gęstości innej niż 160, wartość zostanie przeskalowana wg wzoru: px=dp*(dpi/160).

text – treść do wyświetlenia

textSize – rozmiar tekstu, np 36sp, „sp” to jednostka niezależna od rozdzielczości urządzenia, którą można modyfikować ustawieniami urządzenia, związana jest z gęstością ekranu (ilość pikseli w określonej przestrzeni ekranu). Zostaje automatycznie przeskalowana gdy zmienimy w urządzeniu ustawienia rozmiaru czcionki. W trybie „normalny” 1sp=1 * dp, gdzie 1 to współczynnik proporcji dla urządzenia.

textStyle – styl tekstu, domyślnie: normal; za pomocą separatora | można dodawać kolejne własności elementu

textColor – kolor obiektu, podajemy w hexie lub @android:color/black

fontFamily – krój czcionki

background – kolor tła

gravity – położenie elementu, podstawowe ustawienia to:

• bottom/top
• left/right
• center – wyśrodkowanie
• więcej w dokumentacji

padding – margines wewnętrzny dla wszystkich stron lub paddingLeft, paddingRight, paddingTop, paddingBottom

layout_margin – margines zewnętrzny dla wszystkich stron lub layout_marginLeft, layout_marginRight, layout_marginTop, layout_marginBottom

Zadanie

Przeanalizuj dokumentację elementu TextView. Przypomnij sobie z języka HTML jak należy wyświetlać znaki specjalne w „bezpieczny” sposób i odtwórz w kodzie XML następujący widok:

Artykuł 3. Android – TextView pochodzi z serwisu Kama Kaczmarek.

• podstawy interfejsu użytkownika
• podstawowe elementy View, czyli widoku
• korzystamy Android Layout Visualiser
• podstawy XML

Interfejs

Interfejs(UI) to wszystko to, co użytkownik widzi i może wejść w interakcję. Niezmiernie skomplikowaną sprawą jest stworzenie uniwersalnego UI dla wszystkich istniejących urządzeń: telefony, tablety, TV, smartwatch, ekrany samochodowe, komputery i wiele innych. Poza różnorodnością rozdzielczości wielu urządzeń musimy się zmierzyć jeszcze w możliwością pracy tych urządzeń w 2 formach wyświetlania zawartości: pionowym i poziomym.

View

Widok (View), czyli podstawowy element naszej aplikacji, to nic innego jak kontener, który przechowuje widoczne dla nas elementy. Jest to podstawowa struktura, która mieści w sobie elementy potomne, jest klasą napisaną w Javie i dziedziczącą po klasie Object. Więcej na ten temat możesz przeczytać tutaj.

Musisz mieć świadomość, że to co widzisz na ekranie nie jest płaską konstrukcją jak namalowany obrazek, to są raczej budowle z klocków np. Lego. Poszczególne elementy widoku są poustawiane na sobie, obok siebie, mogą być rozdzielane określoną przestrzenią i tak z 1 widocznego elementu otrzymujemy wiele klocków, które go budują.

Elementy składające się na konkretny „kafelek” mają swoje nazwy i tak:

• tekst wyświetlany to TextView
• obrazek to ImageView
• przycisk to Button
• LinearLayout
• RelativeLayout

Wyżej wymienione elementy możemy podejrzeć na swoim telefonie używając opcji programistycznych i wybierając „Pokazywanie granic układu”. Zobaczymy wtedy granice wszystkich elementów składających się na konkretny widok.

Nazwy elementów przedstawione powyżej są tak naprawdę nazwami klas języka Java, które funkcjonują dla Androida w klasie View, dziedziczą po klasie Object. Przykładowa lista ze strony dokumentacji, która jest jedynie kroplą w morzu dostępnych klas:

Visualizer

Na początkowym etapie nauki będziemy korzystali z narzędzia Visualizer. To prosta aplikacja, która w locie pokazuje nam zmiany jakie wprowadzamy w kodzie.

Miejmy na uwadze, że nie będzie ona w stanie obsłużyć wszystkich opcji dostępnych dla języka XML, ma ona dostęp tylko do podstawowych poleceń.

Na dole ekranu są widoczne przyciski:

available images – który zawiera dostępne grafiki do testowania

cheat sheet – lista dostępnych widoków dla Android

XML

Jak wspomniałam w poprzednim wpisie, UI tworzy się przy pomocy XML, czyli rozszerzalnego języka znaczników. Jest on niezależny od platformy i służy do prostego reprezentowania danych. W języku tym dane mają format tekstowy i są możliwe do odczytu dla ludzi i maszyn. W tym języku sami definiujemy elementy, nie jesteśmy niczym ograniczeni, nie ma odgórnie określonych nazw tagów.

Na tym etapie będziesz potrzebował podstawowej wiedzy nt kodowania w XMLu (proponuję następujący kurs). Poniżej przypomnienie jedynie podstawowych zasad.

Prolog

Pierwszy wiersz naszego kodu powinien zawierać linijkę zwaną „prologiem”, która zawiera podstawowe informacje o wersji języka i kodowaniu znaków, mogą się w niej również znaleźć informacje opisujące dany dokument bardziej szczegółowo:

<?xml version="1.0" encoding="UTF-8"?>

Tagi

W języku XML kodujemy za pomocą tagów, czyli konkretnych poleceń zawartych w nawiasach ostrych <>. Każdy tag powinien mieć następującą budowę:

<to_jest_tag_otwierający>treść do wyświetlenia</to_jest_tag_zamykający>

lub jeżeli nie ma treści

<to_jest_tag_samozamykający atrybut="blablabla"/> 

Wewnątrz tagów umieszczamy również atrybuty, tak samo jak w HTMLu.

Struktura drzewiasta

Poprawnie skonstruowany dokument XML posiada jeden główny element, zwany „root”, wewnątrz którego można zagnieżdżać kolejne elementy.

Poniżej widać strukturę drzewiastą HTML, w podobny sposób można przedstawić strukturę dokumentu XML

<!– komentarz –>

nie będzie widoczny na stronie, widoczny tylko w kodzie źródłowym

<!-- Ten tekst
zostanie zignorowany
przez przeglądarkę -->

O czym należy pamiętać!

1. Zawsze zamykamy tagi.
2. Używamy wcięć.
3. Dokument powinien posiadać 1 główny root.
4. XML nie tworzy graficznego UI jedynie reprezentuje jego strukturę odwołując się do nazw klas Javy. Te klasy funkcjonują w przestrzeni nazw dedykowanej dla Androida.

Przykładowy plik XML

<?xml version="1.0" encoding="UTF-8"?>
<news>
    <article date=”2021-09-01”>
        <tytul>Rozpoczęcie roku szkolnego</tytul>
        <autor>Jan Kowalski</autor> 
    </article> 
    <article> 
        <!-- tutaj można wpisać dodatkową treść --> 
    </article>
    <opis status=”szkic”/>
</news>

Zadanie

Stwórz plik XML przechowujący katalog twoich ulubionych książek. Uzupełnij go o min. 5 pozycji. Elementy, które powinny się znaleźć to: „prolog”, tytuł, autor, ilość stron, rodzaj oprawy i krótka recenzja.

Artykuł 2. Android – podstawy pochodzi z serwisu Kama Kaczmarek.

Tylko dla doświadczonych użytkowników. Robisz to na własne ryzyko!

Oto krótki tutorial (testowane na Xiaomi Mi 10):

1. Wchodzimy w ustawienia naszego telefonu i wybieramy „O telefonie”. W innych modelach szukajcie właśnie zakładki „Informacje o telefonie”, musimy dotrzeć do ekranu, na którym będzie widoczna wersja zainstalowanego oprogramowania.

2. Kilkukrotnie dotykamy wyświetlonej wersji oprogramowania na naszym telefonie – na screenie MIUI Global 12.5.1. Po wykonaniu poprawnie operacji, wyświetlą nam się kolejno komunikaty jak na zdjęciach poniżej.

3. Wracamy do ekranu Ustawienia i wchodzimy w „Dodatkowe ustawienia” następnie „Opcje programistyczne” lub po prostu wyszukujemy „Opcje programistyczne”. I tutaj możemy je też wyłączyć.

I tyle

Miłej zabawy.

Artykuł Telefon z Androidem – opcje programistyczne pochodzi z serwisu Kama Kaczmarek.

Ale czego używać do tworzenia aplikacji na Androida?

Niekwestionowanym liderem wg mnie jest IntelliJ IDEA firmy JetBrains. To doskonałe narzędzie do pisania kodu, którego też używam m.in. w programowaniu w języku Java. Jego darmowa wersja wspiera tworzenie aplikacji na androida, jednak jeżeli będziemy chcieli napisać taką aplikację przy użyciu HTML, JS i CSS to pozostaje nam wykupienie płatnej wersji (co jest doskonałą inwestycją w przyszłość). W celu pisania aplikacji na Androida przy pomocy IntelliJ należy dodatkowo pobrać i skonfigurować Android SDK.

Jeżeli jeszcze nie stać nas na płatną licencję IntelliJ lub chcemy stworzyć aplikację tylko na Androida, możemy skorzystać z darmowego narzędzia, jakim jest AndroidStudio. Został on dostosowany przez Google tak, aby służył właśnie temu.

Będziemy korzystali właśnie z tego ostatniego rozwiązania, czyli AndroidStudio.

W jakim języku programować na platformę Android?

Do tworzenia aplikacji mobilnych na Androida zwykło się używać:

• XML do tworzenia UI – User Interface – język ten pozwala szybko i łatwo tworzyć oraz modyfikować wygląd naszej aplikacji np. w AndroidStudio. Układ kodu jest przejrzysty i pozwala od razu zobaczyć zmiany, bez konieczności kompilowania i uruchamiania kodu po każdej zmianie.
• JAVA do tworzenia warstwy logicznej
• SQLite do obsługi baz danych

Ten dobór języków jest rekomendowany przez Google.

Oczywiście można użyć innych języków i aplikacji np.

• HTML, JS i CSS tworząc aplikację w  PhoneGap
• C# tworząc aplikację w Xamarin
• za pomocą silnika Unity w JS, C#
• za pomocą silnika Unreal w C++

Warto dodatkowo skorzystać z narzędzi np. processing – do tworzenia wizualizacji graficznych i dźwiękowych oraz takich dostosowanych do VR.

Wygląd aplikacji – rekomendacje Google

Jednym z trendów projektowania aplikacji mobilnych jest Googlowski Material Design dostępny pod adresem: material.io.

Główną zasadą projektowania aplikacji jest to, że każdy element ma dokładnie przypisane miejsce w 3-warstwowej hierarchii.

Zasady te opisują jak aplikacja powinna wyglądać oraz jak powinna się zachowywać, a Material Design to coś więcej niż styl, to swoisty język w którym porozumiewają się poszczególne elementy tworzące naszą aplikację.

Na stronie Materials Design znajdziemy wiele przydatnych materiałów, zachęcam do zapoznania się z jej treścią. Znajdziecie tam podpowiedzi ad planowania UI, doboru kolorów elementów, czcionki i wiele innych.

Gdzie szukać pomocy?

Najważniejszą zdolnością jaką powinien posiadać każdy człowiek, nie tylko programista, jest umiejętność wyszukiwania informacji. Żadne źródło internetowe nie jest wyczerpującym opracowaniem danego problemu. Należy umiejętnie korzystać z wielu źródeł równolegle. Często nie wystarczy sama dokumentacja języka, dlatego też zalecam korzystanie z platformy StackOverflow, w3schools, Google i innych, na których znajdziemy rozwiązania.

Przykładem problemu na jaki możemy natrafić jest atrybut android:fontFamily, w dokumentacji nie znajdziemy informacji nt możliwych czcionek do wykorzystania, ale na stackoverflow już tak.

Środowisko pracy

Zanim przejdziemy do AndroidStudio zainstalować należy środowisko JDK, instrukcję i opis znajdziesz w tym materiale oraz edytor kodu np. SublimeText, czy inny w którym lubisz pracować.

Zainstaluj teraz kolejno JDK wg powyższej instrukcji, następnie AndroidStudio oraz preferowany edytor kodu.

Na koniec będziemy musieli zainstalować sterownik USB, by móc testować aplikacje na urządzeniu mobilnym, ale to później.

AndroidStudio

Zakładam, że znacie już podstawy Javy (jeżeli nie, niestety od tego musicie zacząć). Zakładam również, że pracowaliście w edytorze IntelliJ (darmowy kurs obsługi programu), ułatwi to bardzo pracę, ponieważ AndroidStudio to zmodyfikowany IntelliJ.

WSTAWIĆ FILMIK Z NAGRANYM OPISEM UI PROGRAMU

Opisać szczegółowo lewy panel z widokiem naszego projektu

Gradle Scripts – system budowania aplikacji. Jeżeli kończymy pracę nad projektem i chcemy przystąpić do publikacji apki w sklepie, to właśnie Gradle zbiera nasz projekt w całość, w format „apk”.

app – drzewo ze składowymi naszego projektu, a w nim:

• manifests – zawierający plik o nazwie AndroidManifest.xml – zawiera podstawowe informacje dla Androida, bez tego nie uruchomimy aplikacji. Każda aplikacja musi zawierać ten plik o niezmienionej nazwie.
• java – zawiera kody źródłowe javy, główny plik aplikacji to MainActivity. Logika aplikacji.

        Przeanalizujmy linijka po linijce zawartość tego pliku na starcie:       

package com.example.test;

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

package com.example.test; – jest to nazwa naszego pakietu

import… – importujemy klasy, których metody/funkcjonalności będziemy wykorzystywać

public class MainActivity extends AppCompatActivity { – klasa MainActivity, która dziedziczy po AppCompatActivity , klasie posiadającej więcej opcji niż Activity

@Override – to słówko oznacza, że coś nadpisujemy, a konkretnie metodę onCreate

protected void onCreate(Bundle savedInstanceState) { – metoda wywoływana podczas uruchamiania aktywności, która w argumencie posiada obiekt typu Bundle, służą one do przesyłania danych między aktywnościami. Metoda onCreate jest równoznaczna z klasą Main w Javie, a Bundle z String[] args.

super.onCreate(savedInstanceState); – wywołujemy metodę onCreate z pierwotnej deklaracji

setContentView(R.layout.activity_main); – tworzy i wyświetla na ekranie zdefiniowany przez nas rozkład (activity_main).

• res – czyli zasoby, znajdują się w nim m.in w drawable – dla grafik, mipmap – dla ikon, layout – rozkłady aplikacji, values – kolory, tablice, style

Przydatne strony:

• https://www.android.com/
• https://developer.android.com/guide
• słownik z wizualnym objaśnieniem
• https://developer.android.com/
• https://blog.google/products/android/
• https://stackoverflow.com/
• https://material.io/
• narzędzia do wyboru kolorów

Artykuł 1. Android – wstęp, historia, działanie pochodzi z serwisu Kama Kaczmarek.