Online
PAM WIKI Programowanie aplikacji mobilnych
Baza wiedzy

Buduj nowoczesne
aplikacje mobilne

Praktyczna ścieżka: Android/iOS, web-mobile, XR, IoT i AI — od podstaw do projektu semestralnego.

Przewiń

Witam w PAM WIKI

To kompendium wiedzy z przedmiotu Programowania aplikacji mobilnych (PAM) na Katedrze Informatyki i Automatyki Politechniki Rzeszowskiej. Wybierz artykuł z menu po lewej stronie lub kliknij skrót poniżej.

  Szybki start

Android Studio Kotlin & Jetpack Compose
Xcode & iOS Swift & SwiftUI
Systemy OS Android, iOS i inne
Flutter & React Native Cross-platform i PWA
XR Mobile ARCore, ARKit, WebXR
Inf. afektywna Emocje w aplikacjach
Sprzęt mobilny Architektura urządzeń
UI/UX Metody interakcji
Sensory Obsługa sensorów
IoT Mobile Aplikacje IoT
Gry mobilne Unity i gamedev
Robotyka Autonomiczne roboty
Lokalna AI AI na urządzeniu
Zaliczenie Projekt i egzamin
Jak korzystać z WIKI? Wybierz temat z menu po lewej lub użyj wyszukiwarki. Artykuły zawierają przykłady kodu z podświetlaniem składni, tabele porównawcze i linki do oficjalnej dokumentacji.

  Roadmapa semestru

Interaktywna mapa tematów z zależnościami, widokiem tygodniowym, terminami i oznaczeniami priorytetów.

Projekt aplikacji mobilnej

Zaprojektuj i zaimplementuj aplikację mobilną w zespole jako zaliczenie laboratoriów PAM.

Harmonogram realizacji

Narzędzia do realizacji

Moja pierwsza aplikacja mobilna

Przewodnik krok po kroku przez przygotowanie środowiska, strukturę projektu i pierwsze kluczowe funkcje — od zera do działającego MVP.

Otwórz przewodnik
Kreator projektu aplikacji

Zamień pomysł w plan realizacji: zakres, zadania, roboczogodziny, wycena i baza pod dokumenty BRD/FRD/TRD.

Otwórz kreator
Obrona projektu i moduł oceniania

Wymagania końcowe projektu, role studentów, wzór oceny oraz kalkulator punktów i ocen dla zespołu i ról.

Otwórz stronę obrony

Starter Kits

Gotowe szablony repozytoriów przyspieszające start projektu. Każdy starter zawiera proponowaną architekturę, wymagania środowiskowe, kroki uruchomienia (z wyjaśnieniem celu każdego kroku) oraz sugerowaną strukturę katalogów, aby zespół od początku pracował według spójnych standardów.

Android — Kotlin + Jetpack Compose

Architektura: Clean Architecture + MVVM, podział na moduły app, core, feature, przepływ danych przez UseCase i StateFlow.

Wymagania: Android Studio Iguana+, JDK 17, Android SDK 34+, Gradle 8+.

Uruchomienie krok po kroku:

  1. Sklonuj repozytorium i przejdź do katalogu projektu, aby pracować na tym samym baseline co cały zespół.
  2. Uruchom synchronizację Gradle (./gradlew --refresh-dependencies), żeby pobrać poprawne wersje bibliotek i uniknąć konfliktów zależności.
  3. Skonfiguruj local.properties oraz plik .env z kluczami, aby oddzielić sekrety od kodu źródłowego i ułatwić zmianę środowisk.
  4. Uruchom emulator lub podłącz urządzenie fizyczne, żeby szybko zweryfikować UI i zachowanie aplikacji na docelowej platformie.
  5. Zbuduj i uruchom aplikację poleceniem ./gradlew installDebug, aby potwierdzić poprawność konfiguracji i procesu build.

Struktura katalogów:

android-starter/
├─ app/
├─ core/
│  ├─ ui/
│  ├─ network/
│  └─ database/
├─ feature/
│  ├─ auth/
│  └─ dashboard/
└─ buildSrc/
Użyj tego startera
Flutter — Dart + Riverpod

Architektura: Feature-first + Clean, warstwy Presentation / Domain / Data, zarządzanie stanem Riverpod.

Wymagania: Flutter 3.22+, Dart 3.4+, Android/iOS toolchain, CocoaPods (dla iOS).

Uruchomienie krok po kroku:

  1. Sklonuj repozytorium i wykonaj flutter pub get, aby pobrać paczki i zsynchronizować lockfile projektu.
  2. Skopiuj .env.example do .env i uzupełnij wartości, aby lokalnie podłączyć właściwe endpointy i klucze.
  3. Wygeneruj kod poleceniem dart run build_runner build, aby utworzyć klasy serializacji i adaptery wymagane przez warstwę data.
  4. Sprawdź dostępne urządzenia przez flutter devices, aby upewnić się, że toolchain poprawnie wykrywa środowisko testowe.
  5. Uruchom aplikację: flutter run, aby zweryfikować przepływy użytkownika oraz poprawność integracji bibliotek.

Struktura katalogów:

flutter-starter/
├─ lib/
│  ├─ core/
│  ├─ features/
│  │  ├─ auth/
│  │  └─ home/
│  └─ shared/
├─ test/
└─ assets/
Użyj tego startera
React Native — Expo + TypeScript

Architektura: Modular monorepo (apps/packages), feature folders, React Query + Zustand dla stanu lokalnego i serwerowego.

Wymagania: Node.js 20 LTS, pnpm 9+, Expo CLI, Android Studio/Xcode.

Uruchomienie krok po kroku:

  1. Sklonuj repo i zainstaluj zależności: pnpm install, aby odtworzyć identyczne środowisko JavaScript jak w CI.
  2. Skopiuj .env.example do .env oraz uzupełnij endpointy, żeby aplikacja łączyła się z prawidłowym backendem.
  3. Uruchom Metro bundler: pnpm expo start, aby rozpocząć hot-reload i szybkie testowanie zmian.
  4. Wybierz platformę (Android/iOS/Web) z menu Expo, by zweryfikować zachowanie UI na różnych runtime'ach.
  5. Zbuduj paczkę developerską: pnpm expo run:android lub pnpm expo run:ios, żeby przetestować natywne moduły poza Expo Go.

Struktura katalogów:

rn-starter/
├─ apps/mobile/
├─ packages/
│  ├─ ui/
│  ├─ api/
│  └─ config/
├─ scripts/
└─ docs/
Użyj tego startera
Unity — C# + URP (mobile)

Architektura: Warstwowy podział Scripts/Systems/UI, wzorzec MVC lub MVVM dla paneli UI, ScriptableObjects do konfiguracji danych i balansu.

Wymagania: Unity 2022 LTS+, Android Build Support, iOS Build Support, Visual Studio/Rider, Git LFS dla dużych assetów.

Uruchomienie krok po kroku:

  1. Sklonuj repozytorium i otwórz projekt przez Unity Hub, aby zachować zgodność wersji edytora z zespołem.
  2. Poczekaj na import assetów i kompilację skryptów, ponieważ pierwszy import buduje cache i rozwiązuje referencje pakietów.
  3. Skonfiguruj Project Settings (Package Name, Company Name, min SDK), aby przygotować projekt pod publikację mobilną.
  4. Uzupełnij pliki konfiguracyjne backendu (np. Resources/Config) i klucze API, by uruchomić integracje online.
  5. Uruchom scenę startową w Play Mode i wykonaj build testowy na urządzenie (Build And Run), aby potwierdzić płynność oraz poprawność inputu dotykowego.

Struktura katalogów:

unity-starter/
├─ Assets/
│  ├─ Art/
│  ├─ Audio/
│  ├─ Prefabs/
│  ├─ Scenes/
│  ├─ Scripts/
│  │  ├─ Core/
│  │  ├─ Gameplay/
│  │  └─ UI/
│  └─ Settings/
├─ Packages/
└─ ProjectSettings/
Użyj tego startera
Unreal Engine — C++ + Blueprints (mobile)

Architektura: Gameplay Framework (GameMode/GameState/PlayerController), logika hybrydowa C++ + Blueprints, modularne pluginy pod funkcje gameplay i usługi online.

Wymagania: Unreal Engine 5.4+, Visual Studio 2022 lub Rider, Android SDK/NDK, Xcode (dla iOS).

Uruchomienie krok po kroku:

  1. Sklonuj repo i wygeneruj pliki projektu IDE (np. przez menu kontekstowe pliku .uproject), aby przygotować środowisko do kompilacji.
  2. Zbuduj moduły C++ z IDE, żeby upewnić się, że wszystkie klasy i pluginy kompilują się poprawnie.
  3. Skonfiguruj Project Settings (platformy mobilne, input touch, rendering profile) pod docelowe urządzenia.
  4. Uzupełnij konfigurację backendu (np. REST/EOS/Firebase) w plikach Config/*.ini, by uruchomić usługi online.
  5. Wykonaj Package Project dla Android/iOS i przetestuj build na urządzeniu fizycznym, aby zweryfikować wydajność oraz sterowanie dotykowe.

Struktura katalogów:

unreal-starter/
├─ Config/
├─ Content/
│  ├─ Blueprints/
│  ├─ Maps/
│  └─ UI/
├─ Source/
│  ├─ Core/
│  ├─ Gameplay/
│  └─ MobileHub/
└─ Plugins/
Użyj tego startera
Python — Kivy + Buildozer

Architektura: Ekrany oparte o ScreenManager, separacja logiki do warstw services/repositories, konfiguracja UI w plikach .kv.

Wymagania: Python 3.11+, pip/venv, Kivy 2.3+, Buildozer (Linux) lub BeeWare briefcase jako alternatywa.

Uruchomienie krok po kroku:

  1. Sklonuj repo i utwórz środowisko wirtualne (python -m venv .venv), by odizolować zależności projektu.
  2. Zainstaluj pakiety: pip install -r requirements.txt, aby odtworzyć komplet bibliotek lokalnie.
  3. Uruchom aplikację desktopowo: python main.py, żeby szybko sprawdzić nawigację i logikę ekranów.
  4. Skonfiguruj buildozer.spec (nazwa pakietu, uprawnienia, wersja SDK), aby przygotować build mobilny.
  5. Zbuduj APK komendą buildozer android debug i przetestuj na urządzeniu, aby potwierdzić zgodność działania na Androidzie.

Struktura katalogów:

python-kivy-starter/
├─ app/
│  ├─ screens/
│  ├─ services/
│  └─ widgets/
├─ assets/
├─ tests/
├─ main.py
└─ buildozer.spec
Użyj tego startera
Ionic — Angular + Capacitor

Architektura: Modular Angular (core/shared/features), routing lazy-loaded, integracje natywne przez Capacitor Plugins.

Wymagania: Node.js 20 LTS, npm 10+, Ionic CLI, Android Studio/Xcode do buildów mobilnych.

Uruchomienie krok po kroku:

  1. Sklonuj repo i zainstaluj zależności: npm ci, aby odtworzyć dokładny zestaw paczek z lockfile.
  2. Skopiuj src/environments/environment.example.ts do plików środowiskowych i ustaw endpointy API.
  3. Uruchom aplikację webową: ionic serve, aby szybko przetestować widoki i logikę biznesową.
  4. Synchronizuj zmiany: npx cap sync, aby zaktualizować projekty natywne o najnowszą wersję kodu webowego.
  5. Synchronizuj zmiany poleceniem npx cap sync i uruchom build z Android Studio/Xcode dla testów na urządzeniu.

Struktura katalogów:

ionic-starter/
├─ src/
│  ├─ app/
│  │  ├─ core/
│  │  ├─ shared/
│  │  └─ features/
│  ├─ assets/
│  └─ environments/
├─ android/
├─ ios/
└─ capacitor.config.ts
Użyj tego startera
Kotlin Multiplatform — Compose Multiplatform

Architektura: Shared domain/data w KMP, osobne moduły UI dla Android/iOS, wspólne use-case'y i repozytoria.

Wymagania: IntelliJ IDEA/Android Studio, Kotlin 2.0+, JDK 17, Xcode 15+ (dla iOS), Gradle 8+.

Uruchomienie krok po kroku:

  1. Sklonuj repo i wykonaj ./gradlew tasks, aby pobrać wrapper i zweryfikować poprawną konfigurację pluginów.
  2. Skonfiguruj lokalne zmienne (np. local.properties) i klucze API w modułach shared/mobile.
  3. Uruchom testy logiki współdzielonej: ./gradlew :shared:test, aby potwierdzić stabilność warstwy biznesowej.
  4. Zbuduj aplikację Android: ./gradlew :androidApp:installDebug, żeby zweryfikować integrację shared + UI.
  5. Uruchom target iOS przez Xcode lub wykonaj testy: ./gradlew :shared:iosSimulatorArm64Test, aby sprawdzić zgodność na symulatorze.

Struktura katalogów:

kmp-starter/
├─ shared/
│  ├─ src/commonMain/
│  ├─ src/androidMain/
│  └─ src/iosMain/
├─ androidApp/
├─ iosApp/
└─ build-logic/
Użyj tego startera
SwiftUI — iOS Native (Apple)

Architektura: MVVM + Coordinator, warstwa networking oparta o URLSession, modele i storage w SwiftData/CoreData.

Wymagania: Xcode 16+, Swift 6+, iOS 17+ SDK, Apple Developer Account (dla testów na fizycznym urządzeniu).

Uruchomienie krok po kroku:

  1. Sklonuj repo i zainstaluj zależności (np. pod install lub SPM), a następnie otwórz projekt w Xcode.
  2. Ustaw Team i Bundle Identifier w Signing & Capabilities, żeby poprawnie podpisywać aplikację.
  3. Uzupełnij konfigurację środowisk (np. Config/Dev.xcconfig) i endpointy API, aby połączyć aplikację z backendem.
  4. Uruchom testy jednostkowe przez ⌘U, żeby zweryfikować logikę ViewModeli i warstwy danych.
  5. Odpal aplikację na symulatorze lub iPhonie, aby sprawdzić wydajność UI, nawigację i integracje natywne.

Struktura katalogów:

swiftui-starter/
├─ App/
├─ Features/
│  ├─ Auth/
│  └─ Home/
├─ Core/
│  ├─ Networking/
│  ├─ Storage/
│  └─ DesignSystem/
├─ Resources/
└─ Tests/
Użyj tego startera

Checklista po sklonowaniu startera

Co zmienić zaraz po starcie projektu
  • Package name / bundle identifier: zmień identyfikator aplikacji we wszystkich build flavorach.
  • Signing: utwórz własny keystore / certyfikaty i skonfiguruj podpisywanie buildów release.
  • Endpointy: ustaw adresy API dla środowisk dev/stage/prod i zweryfikuj CORS/polityki sieciowe.
  • Klucze API: przenieś sekrety do bezpiecznego storage (CI secrets, vault), nie trzymaj ich w repozytorium.
  • Branding: podmień nazwę aplikacji, ikonę, splash screen, kolory, fonty i podstawowe teksty.
  • Analityka i crash reporting: skonfiguruj własne projekty (np. Firebase/Sentry) i klucze środowiskowe.

Wymagania techniczne

Architektura i kod
  • Co najmniej 3 ekrany z nawigacją
  • Wzorzec MVVM, MVI lub Clean Architecture
  • Poprawne zarządzanie stanem (ViewModel / StateFlow)
  • Rozdzielenie warstwy UI od logiki
Dane i sieć
  • Lokalna baza danych (Room, CoreData, SQLite)
  • Komunikacja z zewnętrznym API (REST lub GraphQL)
  • Obsługa błędów sieciowych i stanu offline
  • Bezpieczne przechowywanie kluczy i tokenów
UI/UX
  • Spójny system kolorów i typografii
  • Responsywność na różnych rozmiarach ekranów
  • Podstawowa dostępność (content descriptions, kontrast)
  • Obsługa trybu ciemnego (opcjonalnie)
Elementy dodatkowe
  • Sensory (GPS, kamera, mikrofon, akcelerometr)
  • Powiadomienia push lub lokalne
  • Uwierzytelnianie użytkownika
  • Testy jednostkowe lub instrumentalne
  • Animacje i zaawansowane gesty

Kryteria oceniania

Kryterium Punkty Waga
Działające, stabilne funkcje podstawowe 30 pkt Kluczowe
Jakość kodu i architektura 20 pkt Ważne
Interfejs użytkownika i UX 15 pkt Średnie
Komunikacja sieciowa i dane 15 pkt Średnie
Prezentacja i dokumentacja 10 pkt Średnie
Dodatkowe funkcje i kreatywność 10 pkt Bonus
Punkty Ocena
91–100 5.0
81–90 4.5
71–80 4.0
61–70 3.5
51–60 3.0
< 50 2.0

Przykładowe tematy projektów

Aplikacje użytkowe
  • Menedżer zadań z synchronizacją w chmurze
  • Tracker budżetu domowego
  • Aplikacja do nauki słówek (fiszki + algorytm powtórzeń)
  • Dziennik treningowy z mapą i analizą danych
Aplikacje z sensorami
  • AR z ARCore/ARKit — gra edukacyjna
  • Skaner i rozpoznawanie obiektów (ML Kit)
  • Śledzenie aktywności z GPS i akcelerometrem
  • Tuner instrumentu z analizą dźwięku
Aplikacje IoT
  • Sterowanie oświetleniem przez BLE/MQTT
  • Dashboard monitoringu sensorów środowiskowych
  • Pilot do robota mobilnego przez Wi-Fi
  • Aplikacja do zarządzania smart home
Aplikacje społecznościowe
  • Lokalna tablica ogłoszeń z geolokalizacją
  • Aplikacja do wspólnego planowania wyjazdów
  • Platforma recenzji lokalnych restauracji
  • Czat w czasie rzeczywistym (Firebase)
Ważna zasada Kod projektu musi być oryginalny. Dozwolone jest korzystanie z bibliotek open-source i oficjalnej dokumentacji. Niedozwolone jest kopiowanie gotowych projektów. Plagiat skutkuje oceną niedostateczną.

Połączone kompendium — projekt zaliczeniowy

Treść z artykułu „Projekt zaliczeniowy”

Zobacz plik projekt-zaliczeniowy_z_laboratorium.md w wiki
Poniżej wczytywana jest pełna treść wiki, aby sekcja laboratoriów i projektu była spójna w jednym miejscu.

Zaliczenie teoretyczne

Egzamin sprawdzający wiedzę z wykładów i laboratoriów PAM.

Zacznij od modułu testu wiedzy ABCD, aby sprawdzić przygotowanie do egzaminu.

Przejdź do testu ABCD

Informacje o egzaminie

60 min Czas trwania
50 Pytań testowych
50 pkt Łącznie punktów
51% (26pkt) Próg zaliczenia
Zamknięty Bez notatek (chyba logiczne)

Tematy egzaminacyjne

1. Systemy operacyjne i ekosystemy mobilne
  • Architektura systemu Android (Linux kernel, HAL, ART, warstwy aplikacji)
  • Architektura iOS (XNU kernel, Core OS, Core Services, Media, Cocoa Touch)
  • Cykl życia aplikacji Android — stany Activity i Fragment
  • Cykl życia aplikacji iOS — stany UIApplicationDelegate
  • Porównanie Android vs iOS: bezpieczeństwo, fragmentacja, dystrybucja
2. Projektowanie interfejsu użytkownika
  • Zasady Material Design 3 — kolory, typografia, komponenty
  • Wytyczne Human Interface Guidelines (Apple)
  • Wzorce nawigacji — Bottom Navigation, Drawer, Tabs, Backstack
  • Dostępność (a11y) — WCAG, TalkBack, VoiceOver, contrast ratio
  • Responsive design i adaptacja do różnych rozmiarów ekranów
3. Architektura aplikacji mobilnych
  • Wzorzec MVC, MVP, MVVM — porównanie, zalety i wady
  • Clean Architecture — warstwy Presentation / Domain / Data
  • Repository Pattern — abstrakcja źródła danych
  • Dependency Injection — Hilt (Android), Swinject (iOS)
  • Wzorce reaktywne — Flow, LiveData, Combine, RxSwift
4. Programowanie Android (Kotlin / Jetpack)
  • Kotlin — klasy data, sealed, korutyny (suspend, launch, async, flow)
  • Jetpack Compose — composable, State, recomposition, side effects
  • ViewModel i StateFlow — zarządzanie stanem UI
  • Room — Entity, DAO, Database, relacje, migracje
  • Retrofit + OkHttp — REST API, interceptory, konwersja JSON
  • Navigation Component — NavGraph, NavController, deeplinki
5. Programowanie iOS (Swift / SwiftUI)
  • Swift — opcjonale, closures, protokoły, generics, async/await
  • SwiftUI — View, State, Binding, ObservableObject, EnvironmentObject
  • CoreData — NSManagedObject, NSFetchRequest, NSPersistentContainer
  • URLSession — data task, async/await, Codable, JSONDecoder
  • Combine — Publisher, Subscriber, Operator, sink, assign
6. Cross-Platform i PWA
  • Flutter — Widget tree, StatelessWidget vs StatefulWidget, BLoC, Provider
  • React Native — komponenty, hooks, Redux, Metro bundler
  • Kotlin Multiplatform — shared code, expect/actual
  • PWA — Service Worker, Cache API, Web App Manifest, offline-first
  • Porównanie: wydajność, dostęp do natywnych API, community
7. hardware i obsługa sensorów
  • Camera2 API / AVFoundation — preview, capture, analiza obrazu
  • GPS i geolokalizacja — uprawnienia, foreground vs background
  • Sensor Manager — akcelerometr, żyroskop, magnetometr
  • Biometria — BiometricPrompt (Android), LocalAuthentication (iOS)
  • Bluetooth LE — GATT, charakterystyki, skanowanie, parowanie
8. Sieć i komunikacja
  • REST API — metody HTTP, kody statusu, nagłówki, autentykacja JWT
  • WebSocket — połączenie full-duplex, zastosowania w real-time
  • MQTT — architektura broker/client, QoS levels, tematy
  • Firebase — Firestore, Realtime DB, FCM (push notifications)
  • SSL Pinning i bezpieczeństwo komunikacji sieciowej
9. Bezpieczeństwo aplikacji mobilnych
  • OWASP Mobile Top 10 — najczęstsze zagrożenia
  • Bezpieczne przechowywanie danych — Keychain (iOS), Keystore (Android)
  • Obfuskacja kodu — ProGuard/R8 (Android)
  • Certificate Pinning — zapobieganie MITM
  • Uprawnienia — runtime permissions, principle of least privilege
10. Testowanie i wydajność
  • Piramida testów — unit, integracyjne, UI (end-to-end)
  • JUnit 4/5, MockK, Espresso, XCTest — narzędzia testowania
  • Profilowanie — Android Profiler, Xcode Instruments
  • Zarządzanie pamięcią — GC (ART), ARC (iOS)
  • Renderowanie UI — 60/120 Hz, jank, overdraw, recomposition

Wskazówki do nauki

Strategia przygotowania
  • Zacznij od wykładów — przejrzyj slajdy z każdego tematu
  • Korzystaj z tej bazy wiedzy — każdy temat ma artykuł z kodem
  • Ćwicz na przykładach — wpisuj i uruchamiaj kod samodzielnie
  • Powtarzaj aktywnie — twórz własne fiszki
  • Wróć do zadań z laboratoriów
Najczęstsze błędy
  • Mylenie Room z SQLite (Room to ORM nad SQLite)
  • Nierozróżnianie LiveData od StateFlow
  • Mieszanie architektur MVVM z MVC
  • Nieznajomość QoS w MQTT
  • Pomijanie tematu OWASP Mobile Top 10
Materiały do powtórki
Pamiętaj! Egzamin sprawdza rozumienie, a nie pamięciowe odtwarzanie. Skup się na zrozumieniu dlaczego stosuje się dane wzorce, a nie tylko jak wyglądają. Powodzenia!

Kompendium - egzamin teoretyczny

Materiały do pobrania

Pliki z wykładów i laboratoriów.

Materiały live

Interaktywne wersje wykładów.

Podgląd prezentacji

Wyświetl prezentację bezpośrednio w aplikacji.

Otwórz prezentację w nowej karcie