|
|
Kierunek
Informatyka
|
|||
|
|
||||
Instrukcja
do ćwiczeń laboratoryjnych nr:
|
1
|
Nazwa przedmiotu:
|
||
Temat: Wprowadzenie do programowania aplikacji
mobilnych
|
Tryb
studiów: stacjonarne |
|||
|
Czas trwanie ćw. 2x45
min |
||||
|
Autor materiałów:
dr Marcin Skuba |
||||
1. Treści programowe:
Środowisko programistyczne
AndroidStudio, tworzenie nowego projektu, struktura projektu, uruchamiania
aplikacji na urządzeniach mobilnych oraz na emulatorze, pliki Java oraz XML,
2. Cel zajęć:
Celem zajęć jest wprowadzenie studentów
do tematu programowania aplikacji mobilnych w systemie operacyjnym Android.
Poznanie środowiska programistycznego AndroidStudio, struktury projektu oraz
podstawowych narzędzi.
3. Materiały dydaktyczne
· Aplikacje
natywne
Aplikacje natywne pisane są specjalnie
pod konkretny system operacyjny (Android albo iOS), dzięki czemu mają najlepszą
wydajność i pełny dostęp do funkcji urządzenia.
Android
- Języki:
- Kotlin (obecnie
preferowany przez Google)
- Java (starsze
projekty nadal często w nim istnieją)
- Narzędzia:
- Android Studio (oficjalne
IDE z emulatorami, debuggerem, design toolami)
- Biblioteki:
- Jetpack (komponenty
UI, architektura, nawigacja)
- Retrofit
(komunikacja z API)
iOS
- Języki:
- Swift (główny
język Apple)
- Objective-C (starsze
projekty)
- Narzędzia:
- Xcode (IDE
od Apple, emulator iPhone/iPad, Interface Builder)
- Frameworki:
- SwiftUI (deklaratywne
UI, nowoczesne podejście)
- UIKit
(starsze, ale wciąż używane podejście)
· Aplikacje
cross-platformowe (wieloplatformowe)
Jedna baza kodu działa na Androidzie i
iOS (czasem też na Web i Desktop). Oszczędza czas i pieniądze, choć czasami
kosztem wydajności lub pełnego dostępu do specyficznych funkcji urządzenia.
Popularne rozwiązania
- Flutter (Google)
- Język: Dart
- Narzędzie: Android Studio, Visual Studio
Code
- Zalety: szybkie UI, „hot reload”, działa
na Android, iOS, Web, Desktop
- React Native (Meta/Facebook)
- Język: JavaScript /
TypeScript
- Narzędzia: Visual Studio Code, Expo (do
szybkiego startu), Metro bundler
- Zalety: duża społeczność, łatwa
integracja z kodem natywnym
- Xamarin / .NET MAUI (Microsoft)
- Język: C#
- Narzędzie: Visual Studio
- Zalety: integracja z .NET,
multiplatforma (Android, iOS, Windows, macOS)
- Ionic
+ Capacitor
- Język: JavaScript /
TypeScript (Angular, React, Vue)
- Narzędzie: Visual Studio Code
- Zalety: aplikacje wyglądają jak mobilne,
a pod spodem to aplikacje webowe w wrapperze
- Jeśli chcesz najlepszej wydajności i
pełnego dostępu do sprzętu – wybierasz natywne podejście.
- Jeśli zależy Ci na szybszym czasie
developmentu i jednym kodzie na wiele platform – lepiej crossowe.
·
Programowanie
dla systemu operacyjnego Android w środowisku Android Studio
Krótka historia Androida
·
2003 –
w kalifornijskim Palo Alto powstała firma Android Inc., założona przez Andy’ego
Rubina i Richarda Minera. Początkowo system miał być wykorzystywany w aparatach
cyfrowych, później zmieniono koncepcję na telefony.
·
2005 –
Google kupuje Android Inc. i zaczyna rozwijać system jako otwartą platformę dla
smartfonów.
·
2007 –
powstaje Open Handset Alliance – konsorcjum firm wspierających rozwój Androida
(Google, HTC, Motorola, Samsung i inni).
Android 0.5 Milestone 3 to pierwsza wersja android uruchamiana na
emulatorze. W tym roku pojawił się pierwszy iPhone.
·
2008 –
na rynek trafia pierwszy telefon z Androidem: HTC Dream (T-Mobile G1). W
Polsce - ERA G1 2009
·
2010–2012 –
Android staje się najpopularniejszym systemem mobilnym na świecie, wyprzedzając
Symbiana i iOS.
·
2014
– pojawia się Material Design, nowy język projektowania interfejsów od Google.
·
2019 –
Google odchodzi od nazw „cukierkowych” i przechodzi na numerację – np. Android
10 zamiast „Q”.
·
Dziś (2025) – Android to
najpopularniejszy system mobilny na świecie, używany przez miliardy urządzeń:
smartfony, tablety, zegarki, telewizory, a nawet samochody.
Kluczowe
cechy Androida
o Otwartość i darmowa licencja
o
Android jest oparty na
jądrze Linuxa i rozwijany jako projekt open source (AOSP – Android Open Source
Project).
o
Dzięki temu producenci
urządzeń mogli łatwo adoptować system bez opłat licencyjnych (w przeciwieństwie
do np. Windows Phone).
o Ogromna elastyczność i możliwość personalizacji
o
Użytkownik może zmieniać launcher (aplikacja odpowiedzialna za ekran główny i
menu aplikacji), widżety, motywy, a nawet całe ROM-y (ROM w
świecie Androida oznacza system operacyjny Android - jego wersję
instalowaną na urządzeniu).
o
Producenci mogą
dostosowywać interfejs (Samsung One UI, Xiaomi MIUI, Huawei EMUI).
o Szeroka dostępność urządzeń
o
Android działa na
telefonach od tanich modeli po flagowe smartfony.
o
Dzięki temu stał się
systemem „dla każdego”, w przeciwieństwie do iOS, który jest tylko na iPhone.
o Ogromny ekosystem aplikacji (Google Play)
o
Miliony aplikacji i gier,
łatwy dostęp do narzędzi dla deweloperów.
o
Google Play Store umożliwia
szybkie publikowanie i aktualizowanie aplikacji.
o Integracja z usługami Google
o
Gmail, Google Maps,
YouTube, Google Drive czy Asystent Google to aplikacje, które zwiększyły
atrakcyjność systemu.
o Wsparcie dla wielu producentów i urządzeń
o
Android jest stosowany nie
tylko w smartfonach, ale też w tabletach, telewizorach (Android TV), smartwatch
o
System bazujący na jądrze SO Linux
o
Duży udział w rynku (około 73%)
Środowisko programistyczne
Android Studio
- Android
Studio
to oficjalne środowisko programistyczne (IDE) do tworzenia aplikacji na
system Android.
- Oparte
jest na popularnym IntelliJ IDEA od firmy JetBrains.
- Zostało
ogłoszone przez Google w 2013 roku, a od 2014 jest oficjalnym
narzędziem dla deweloperów Androida (wcześniej Eclipse) .
🔹
Główne funkcje Android Studio
- Edytor
kodu
z podpowiadaniem składni, refaktoryzacją i analizą błędów.
- Projektant
interfejsu (Layout Editor) – graficzne tworzenie widoków w XML.
- Emulator
Androida – uruchamianie i testowanie aplikacji na
wirtualnych urządzeniach.
- Debuggowanie
i profilowanie – narzędzia do śledzenia błędów i
optymalizacji wydajności.
- Gradle –
system automatyzacji budowania aplikacji i zarządzania zależnościami.
- Integracja
z Git
– kontrola wersji kodu bezpośrednio w IDE.
🔹
Obsługiwane języki programowania
- Kotlin –
obecnie preferowany język przez Google.
- Java – nadal
szeroko używana, szczególnie w starszych projektach.
- C++ – w
przypadku aplikacji wymagających kodu natywnego (NDK).
🔹
Struktura projektu w Android Studio
- app/java – kod
źródłowy aplikacji.
- app/res –
zasoby: layouty (XML), obrazy, style, napisy.
- AndroidManifest.xml – opis aplikacji
(uprawnienia, aktywności, ikona).
- Gradle
Scripts – konfiguracja projektu, zależności,
kompilacja.
---------------------------------------------------------------------------------------------------------------------------------------------------------
Pliki konfiguracyjne –
skrypt modułowy build.gradle.kts (kotlin) zamiast build.gradel
To jest konfiguracja projektu Android w
Android Studio w nowym stylu Kotlin DSL (czyli build.gradle.kts
zamiast build.gradle).
1. Sekcja plugins
·
Określa wtyczki Gradle używane w projekcie.
·
android.application oznacza, że jest to aplikacja Android (a nie
biblioteka).
·
Alias (libs.plugins...)
pochodzi z pliku libs.versions.toml, który
centralizuje zarządzanie wersjami.
alias(libs.plugins.android.application) odnosi się do pliku libs.versions.toml, w którym istniej zapisana wtyczka com.android.application:
To główna wtyczka Androida, która
umożliwia:
- kompilowanie aplikacji mobilnych,
- zarządzanie manifestem,
- ustawianie SDK, buildTypes,
flavorów, itp.
Bez niej nie da się zbudować aplikacji
Androida.
2. Sekcja android
·
namespace – przestrzeń nazw aplikacji (odpowiednik package).
· compileSdk – numer wersji Android SDK,
na której kompilowana jest aplikacja (API 36 = Android 14). Określa, jakie API możesz używać w kodzie.
Jeśli dasz compileSdk = 36, możesz pisać kod
używający funkcji i klas z Androida 14 (API 36). Nie wpływa bezpośrednio na to,
na jakich urządzeniach aplikacja będzie działać.
·
· applicationId – unikalny identyfikator aplikacji (ważny m.in. w
Google Play).
· minSdk – minimalna wersja Androida (API 24 = Android
7.0).
· targetSdk – docelowa wersja Androida (API 36). To docelowa
wersja Androida, na której aplikacja została przetestowana i jest
zoptymalizowana. Informuje system Android, jak powinien traktować aplikację:
jeśli aplikacja ma niższy targetSdk niż aktualny
system → Android włącza tryb
kompatybilności, żeby aplikacja działała,
ale może np. ograniczyć dostęp do nowszych funkcji. Jeśli targetSdk
= wersja systemu → aplikacja działa „natywnie” bez trybu kompatybilności.
Google Play wymaga, aby aplikacje miały aktualny targetSdk,
bo inaczej mogą być odrzucane przy publikacji.
· versionCode – techniczny numer wersji (inkrementowany przy
aktualizacjach).
· versionName – wersja aplikacji widoczna dla użytkownika.
· testInstrumentationRunner – runner testów dla
Androida (JUnit + Espresso).
· Definiuje różne tryby budowania aplikacji.
· release – konfiguracja dla wersji produkcyjnej.
- isMinifyEnabled = false → wyłączona minifikacja
(można włączyć dla mniejszych APK).
- proguardFiles(...) →
pliki konfiguracyjne do optymalizacji i zaciemniania kodu.
· sourceCompatibility - określa wersję języka Java, w której tworzony
jest projekt.
Kompilator zaakceptuje
składnię i funkcje dostępne w Javie 11 (np. var w
zmiennych lokalnych). Jeśli spróbujesz użyć nowszych konstrukcji (np. z Javy
17), kompilator zgłosi błąd.
· targetCompatibility - Określa dla jakiej wersji JVM ma zostać
wygenerowany kod bajtowy (class files).
Możesz pisać w Javie 11, ale wygenerować kod działający np. na JVM z Javy 8
(jeśli ustawisz targetCompatibility =
JavaVersion.VERSION_1_8). W praktyce mówi: „ta aplikacja ma działać na maszynie
wirtualnej Javy w wersji X”.
· Włącza dodatkowe funkcje.
· viewBinding = true – aktywuje View Binding, czyli nowoczesny sposób dostępu do widoków zamiast
findViewById.
· Definiuje biblioteki potrzebne w projekcie.
·
implementation – zależności aplikacji, dodaje bibliotekę tylko do
kodu aplikacji.:
- libs.appcompat –
kompatybilność wsteczna (AndroidX) (wsparcie dla
starszych wersji Androida)..
- libs.material –
komponenty Material Design.
- libs.activity –
obsługa cyklu życia Activity AndroidX.
- libs.constraintlayout –
elastyczny układ ConstraintLayout.
· testImplementation – biblioteki do testów jednostkowych (JUnit).
· androidTestImplementation – biblioteki do testów instrumentalnych (JUnit + Espresso).
---------------------------------------------------------------------------------------------------------------------------------------------------------
Pliki konfiguracyjne –
skrypt dla całego projektu build.gradle.kts
Sekcja plugins
· plugins { ... } – deklarujesz wtyczki Gradle.
· alias(libs.plugins.android.application) – odwołanie do aliasu z pliku libs.versions.toml.
- Ten alias odpowiada wtyczce com.android.application, czyli pluginowi dla modułów aplikacji Android.
·
apply false – oznacza, że plugin
jest dostępny dla projektu, ale nie jest stosowany na poziomie root.
---------------------------------------------------------------------------------------------------------------------------------------------------------
Plik konfiguracyjny –
AndroidManifest.xml
1. Nagłówek pliku
· Deklaruje plik XML i kodowanie (utf-8).
· xmlns:android → przestrzeń nazw dla atrybutów Androida
(np. android:label).
· xmlns:tools → przestrzeń nazw używana w Android Studio
(np. do adnotacji developerskich, ostrzeżeń itp.).
2. Sekcja <application>
Atrybuty:
·
android:allowBackup="true"
o Pozwala systemowi tworzyć kopię zapasową danych
aplikacji (np. w chmurze Google).
·
android:dataExtractionRules
o Wskazuje zasady eksportu/eksportu danych w pliku
XML (res/xml/data_extraction_rules.xml).
·
android:fullBackupContent
o Określa, które dane aplikacji są dołączone do
pełnej kopii zapasowej (res/xml/backup_rules.xml).
·
android:icon="@mipmap/ic_launcher"
o Ikona aplikacji (widoczna w systemie i launcherze).
·
android:label="@string/app_name"
o Nazwa aplikacji (pokazywana pod ikoną). Pobierana z
pliku res/values/strings.xml.
·
android:roundIcon="@mipmap/ic_launcher_round"
o Okrągła wersja ikony (dla systemów, które jej
wymagają).
·
android:supportsRtl="true"
o Włącza obsługę układów od prawej do lewej (RTL, np.
arabski, hebrajski).
·
android:theme="@style/Theme.JavaProjectExample"
o Domyślny motyw aplikacji (styl w res/values/styles.xml).
3. Sekcja <activity>
· android:name=".MainActivity"
- Określa klasę Activity, która będzie
uruchamiana.
- . oznacza, że jest w głównym pakiecie
aplikacji.
·
android:exported="true"
- Wymóg od Androida 12 (API 31).
- true →
oznacza, że aktywność może być uruchamiana przez inne aplikacje (np. launcher systemu).
4. Sekcja <intent-filter>
· Definiuje, w jaki sposób aktywność może być
uruchamiana.
· <action android:name="android.intent.action.MAIN" />
·
Oznacza, że to jest główna
aktywność aplikacji (punkt wejścia).
·
<category android:name="android.intent.category.LAUNCHER" />
·
Powoduje, że aktywność
pojawia się w launcherze (lista aplikacji w
telefonie).
- Oficjalna strona –
Android dla programistów https://developer.android.com/
- Pobierz Android Studio: https://developer.android.com/studio/
- Informacje o wersjach
Android SDK: https://developer.android.com/studio/releases/platforms
|
Nazwa kodowa |
Numery wersji |
Data pierwszego wydania |
API |
|
Apple Pie |
1.0 |
23 września 2008 |
1 |
|
Banana Bread |
1.1 |
9 lutego 2009 |
2 |
|
Cupcake |
1.5 |
27 kwietnia 2009 |
3 |
|
Donut |
1.6 |
15 września 2009 |
4 |
|
Eclair |
2.0-2.1 |
26 października 2009 |
5-7 |
|
Froyo |
2.2-2.2.3 |
20 maja 2010 |
8 |
|
Gingerbread |
2.3-2.3.7 |
6 grudnia 2010 |
9-10 |
|
Honeycomb |
3.0-3.2.6 |
22 lutego 2011 |
11-13 |
|
4.0-4.0.4 |
18 października 2011 |
14-15 |
|
|
4.1-4.3.1 |
9 lutego 2012 |
16-18 |
|
|
4.4-4.4.4 |
31 października 2013 |
19-20 |
|
|
5.0-5.1.1 |
12 listopada 2014 |
21-22 |
|
|
6.0-6.0.1 |
5 października 2015 |
23 |
|
|
7.0-7.1.2 |
22 sierpnia 2016 |
24-25 |
|
|
8.0-8.1 |
21 sierpnia 2017 |
26-27 |
|
|
Pie |
9 |
6 sierpnia 2018 |
28 |
|
Android 10 (wewnętrznie
Quince Tart) |
10 |
3 września 2019 |
29 |
|
Android 11 (wewnętrznie
Red Velvet Cake) |
11 |
8 września 2020 |
30 |
|
Android 12 (wewnętrznie
Snow Cone') |
12-12L |
4 października 2021 |
31-32 |
|
Android 13 (wewnętrznie
Tiramisu') |
13 |
15 sierpnia 2022 |
33 |
|
Android
14 (wewnętrznie: Upside Down Cake) |
14 |
4 października 2023 |
34 |
|
Android 15 (wewnętrznie: Vanilla Ice
Cream) |
15 |
15 października 2024 |
35 |
|
Android 16 wewnętrznie: Baklava |
16 |
3 czerwca 2025 |
36 |
Dla prawidłowego działania emulatora systemu android
wymagane jest włączenie virtualizacji: Virtualization: Enabled
