Wprowadzenie do aplikacji mobilnych — rodzaje i cykl życia

Po co się tego uczymy?

Zanim napiszesz pierwszą linijkę kodu, musisz wiedzieć, CZYM w ogóle jest aplikacja mobilna, jakie są jej rodzaje i jak wygląda jej cykl życia — to fundament wymagany przez INF.04.6 i częsty temat pytań teoretycznych na egzaminie. Ten dział będzie oparty na .NET MAUI — technologii Microsoftu pozwalającej pisać JEDNĄ aplikację w C# działającą na Androidzie, iOS, Windows i macOS.

Teoria

Aplikacje mobilne to programy przeznaczone do uruchamiania na urządzeniach przenośnych — smartfonach i tabletach. Dzielimy je na trzy rodzaje:

Rodzaj	Charakterystyka	Języki / środowiska
Natywne	Tworzone specjalnie dla jednego systemu, pełny dostęp do sprzętu (GPS, aparat, powiadomienia push).	Android: Kotlin/Java w Android Studio. iOS: Swift/Objective-C w Xcode.
Webowe	Działają w przeglądarce, nie wymagają instalacji ze sklepu, ograniczony dostęp do sprzętu.	HTML, CSS, JavaScript (progresywne aplikacje webowe — PWA).
Hybrydowe	Łączą cechy webowych i natywnych — jeden kod na wiele platform, opakowany w natywną powłokę.	Flutter (Dart), React Native (JavaScript), Ionic, .NET MAUI (C#).

.NET MAUI (Multi-platform App UI) to framework Microsoftu należący do kategorii hybrydowej/wieloplatformowej: piszesz jedną aplikację w C# i XAML, a kompilujesz ją na Androida, iOS, Windows i macOS. To właśnie na nim skupia się ten dział — bo tak jak przy WPF, pozwala wykorzystać znajomość C#, którą masz już z wcześniejszych działów.

Cykl życia aplikacji mobilnej

Aplikacja mobilna przechodzi przez charakterystyczne stany, które pozwalają systemowi oszczędzać baterię i pamięć, gdy aplikacja nie jest aktywnie używana:

Stan	Co się dzieje
`OnCreate`	Aplikacja jest tworzona — inicjalizowany jest interfejs i dane startowe.
`OnStart`	Aplikacja staje się widoczna dla użytkownika.
`OnResume`	Aplikacja jest gotowa do interakcji — po uruchomieniu albo powrocie z pauzy.
`OnPause`	Użytkownik przechodzi do innej aplikacji — dane są zapisywane, żeby można było wrócić do tego samego stanu.
`OnStop`	Aplikacja przestaje być widoczna, ale pozostaje w pamięci dla szybkiego powrotu.
`OnDestroy`	Aplikacja jest zamykana, wszystkie zasoby zwalniane z pamięci.

Przykład: użytkownik otwiera aplikację (OnCreate → OnStart → OnResume), przełącza się na chwilę do innej aplikacji (OnPause → OnStop), po czym wraca (OnRestart → OnResume). Zamknięcie aplikacji uruchamia OnDestroy.

Aplikacje mobilne są zazwyczaj stanowe — przechowują dane użytkownika i stan działania — i mogą pracować online lub offline, synchronizując dane po odzyskaniu połączenia z internetem.

Etapy tworzenia aplikacji mobilnej (skrót cyklu produkcyjnego)

Planowanie i projektowanie (cel, grupa docelowa, platforma, UI/UX pod małe ekrany) → Tworzenie (kod + funkcje sprzętowe: GPS, aparat, powiadomienia) → Testowanie (różne urządzenia/rozdzielczości, wydajność, uprawnienia, tryb offline) → Wdrożenie (publikacja w Google Play / App Store, zatwierdzenie przez sklep) → Eksploatacja i konserwacja (analityka, aktualizacje, opinie użytkowników). Do tego procesu wrócimy szczegółowo w ostatnich lekcjach tego działu (publikacja APK/AAB).

Schemat

Cykl zycia aplikacji mobilnej (od uruchomienia do zamkniecia):

Uruchomienie -> OnCreate -> OnStart -> OnResume (aplikacja aktywna, interakcja)
                                          |
                          uzytkownik przelacza sie na inna appke
                                          v
                                     OnPause -> OnStop (w tle, w pamieci)
                                          |
                       uzytkownik wraca <-+-> system usuwa z pamieci
                          |                              |
                     OnRestart -> OnResume          OnDestroy (koniec)

Przykład z życia

Zauważ, że gdy podczas rozmowy telefonicznej wracasz na chwilę do przeglądarki albo mapy, aplikacja "pamięta", gdzie skończyłeś — nie musisz się logować ponownie ani wracać na sam początek. To właśnie zasługa cyklu życia: aplikacja zapisała swój stan w OnPause, a po powrocie odtworzyła go w OnResume, zamiast startować od zera jak przy pierwszym uruchomieniu (OnCreate).

Kod (C#)

// Przyklad (koncepcyjny) reagowania na zmiany stanu strony w .NET MAUI
// - w prawdziwym projekcie MAUI odpowiednikiem sa zdarzenia strony:
// OnAppearing (strona staje sie widoczna) i OnDisappearing (znika z ekranu)

protected override void OnAppearing()
{
    base.OnAppearing();
    // Tutaj wczytujemy dane / wznawiamy aktualizacje (np. odswiezenie listy)
}

protected override void OnDisappearing()
{
    base.OnDisappearing();
    // Tutaj zapisujemy stan / zatrzymujemy timery, zeby nie zuzywac baterii
}

Komentarz i wyjaśnienie kodu

W .NET MAUI nie programujemy bezpośrednio stanów OnCreate/OnPause systemu operacyjnego — framework daje nam własny, uproszczony odpowiednik na poziomie strony: metody OnAppearing() (strona pojawia się na ekranie — dobre miejsce na wczytanie/odświeżenie danych) i OnDisappearing() (strona znika — dobre miejsce na zapisanie stanu albo zatrzymanie kosztownych operacji, np. timera). Dzięki temu nie musimy ręcznie obsługiwać różnic między Androidem a iOS — MAUI robi to za nas w tle.

base.OnAppearing()/base.OnDisappearing() wywołuje oryginalną implementację z klasy bazowej — to standardowy nawyk przy nadpisywaniu (override) metod platformy, żeby nie zepsuć wewnętrznego działania frameworka.

Ćwiczenie samodzielne

Na kartce (lub w prostym diagramie) narysuj cykl życia aplikacji "Notatnik", która: uruchamia się, użytkownik wpisuje notatkę, wychodzi na chwilę sprawdzić SMS-a, wraca i dopisuje resztę notatki, a na końcu zamyka aplikację. Podpisz, w którym momencie występuje który stan (OnCreate, OnPause, OnResume itd.).

Zadania do pracy własnej

Wymień trzy różnice między aplikacją natywną a aplikacją webową, korzystając z tabeli z tej lekcji.
Wyjaśnij własnymi słowami, dlaczego .NET MAUI zaliczamy do aplikacji hybrydowych/wieloplatformowych, a nie natywnych — mimo że aplikacja końcowa instaluje się i działa jak natywna.
Opisz scenariusz (5-6 kroków) użycia jakiejś znanej Ci aplikacji mobilnej (np. bankowej, do nawigacji), w którym przechodzi ona przez WSZYSTKIE stany cyklu życia: OnCreate, OnStart, OnResume, OnPause, OnStop, OnDestroy. Dla każdego stanu podaj, jaka konkretna akcja użytkownika go wywołała.

Typowe błędy

Mylenie aplikacji hybrydowej z natywną — aplikacja napisana w .NET MAUI po zbudowaniu i zainstalowaniu wygląda i działa jak natywna, ale KOD źródłowy jest współdzielony między platformami — to kluczowa różnica, o którą pyta egzamin.

Zakładanie, że aplikacja zawsze ma dostęp do internetu — dobra aplikacja mobilna musi przewidzieć tryb offline i sensownie się zachować (np. pokazać komunikat, zapisać dane lokalnie do późniejszej synchronizacji), zamiast się wywalić.

Ignorowanie stanu OnPause/OnStop — jeśli aplikacja nie zapisuje stanu przy przejściu w tło, użytkownik traci wpisane dane, gdy tylko odbierze telefon albo przełączy aplikację — to jeden z najczęstszych błędów UX w aplikacjach mobilnych.

Nawiązanie do egzaminu zawodowego

To realizacja wstępu do INF.04.6 — "programuje aplikacje mobilne". Znajomość rodzajów aplikacji i cyklu życia to często pytania teoretyczne w części pisemnej egzaminu, a zrozumienie stanów aplikacji jest niezbędne przy projektowaniu aplikacji, które poprawnie zachowują dane użytkownika.