Android: co to jest, architektura systemu i rozwój w Kotlin

Co to jest Android?

Android to mobilny system operacyjny oparty na jądrze Linux, opracowywany przez Google od 2007 roku. Kod źródłowy jest otwarty na licencji Apache 2.0 w ramach projektu Android Open Source Project (AOSP). Każdy producent może modyfikować system i instalować go na swoich urządzeniach.

Według StatCounter (2026), Android zajmuje około 72% światowego rynku mobilnych systemów operacyjnych. Najwięksi producenci to Samsung, Xiaomi, Oppo, Vivo, Google Pixel. Fragmentacja to kluczowy problem platformy: tysiące modeli z różnymi wersjami systemu operacyjnego są używane jednocześnie.

Architektura Android zbudowana jest na zasadzie uprawnień (permissions): każda aplikacja działa pod osobnym UID Linux i ma dostęp tylko do własnych danych. Dostęp do zasobów systemowych (kamera, mikrofon, kontakty) jest żądany przez Android Permissions w czasie wykonywania, począwszy od Android 6 (API 23).

Historia wersji Android

Android 1.0 został wydany w 2008 roku na HTC Dream. Kluczowe kamienie milowe: Android 4.0 Ice Cream Sandwich (ujednolicony interfejs dla telefonów i tabletów), Android 5.0 Lollipop (Material Design), Android 6.0 (uprawnienia runtime), Android 10 (ciemny motyw, gesty), Android 12 (Material You). Od 2023 roku Google przeszło na coroczne główne wydania bez nazw deserów.

Architektura Android: cztery kluczowe warstwy

Architektura Android składa się z czterech głównych warstw izolujących sprzęt od aplikacji użytkownika. Każda warstwa korzysta z usług warstwy poniżej poprzez ściśle określone interfejsy.

Jądro Linux i HAL

Najniższa warstwa to zmodyfikowane jądro Linux (LTS, wersja 6.x w Android 15). Zarządza pamięcią, procesami, stosem sieciowym i sterownikami. Warstwa abstrakcji sprzętowej (HAL) zapewnia ujednolicony interfejs API do interakcji ze sprzętem: aparat, Bluetooth, Wi-Fi, czujniki. Producenci implementują moduły HAL bez wpływu na wyższe warstwy.

Android Runtime (ART)

ART wykonuje kod bajtowy DEX aplikacji. Począwszy od Android 5.0, ART zastąpił Dalvik i używa kompilacji Ahead-of-Time (AOT) w celu poprawy wydajności. Każda aplikacja ma własny proces z osobną instancją ART. Garbage collection (GC) działa z minimalnymi przerwami — typowa przerwa GC wynosi 2–4 ms.

Application Framework

Framework to warstwa, z którą programista pracuje bezpośrednio. Obejmuje Activity Manager (stos ekranów), Content Providers (dostęp do danych), Resource Manager (lokalizacja, zasoby), Notification Manager, Location Manager. Wszystkie usługi systemowe są wywoływane przez Binder IPC — mechanizm komunikacji międzyprocesowej Android.

// Przykład pracy z Binder przez interfejs AIDL
interface IDataService : android.os.IInterface {
    fun getData(): List<DataItem>
    fun saveData(item: DataItem): Boolean
}

// Implementacja usługi
class DataService : Service() {
    private val binder = object : IDataService.Stub() {
        override fun getData(): List<DataItem> = repository.getAll()
        override fun saveData(item: DataItem): Boolean = repository.save(item)
    }

    override fun onBind(intent: Intent?): IBinder = binder
}

Aplikacje systemowe

Najwyższa warstwa to standardowe aplikacje systemowe: Telefon, Kontakty, Aparat, Ustawienia, Przeglądarka. Nie mają wyższych uprawnień niż aplikacje użytkownika, ale mogą być zastąpione aplikacjami innych firm. W Android 15 aplikacje systemowe są aktualizowane przez Google Play System Updates niezależnie od aktualizacji OTA producenta.

Kotlin — główny język rozwoju Android

Kotlin to statycznie typowany język programowania od JetBrains, działający na JVM. Google ogłosił Kotlin oficjalnym językiem Android w 2017 roku na Google I/O. Kotlin jest w pełni zgodny z Java, ale eliminuje jej wady: null-safety, klasy danych, funkcje rozszerzeń i korutyny.

Null Safety i typy

Główna cecha Kotlin to wbudowana ochrona przed NullPointerException. Typy są podzielone na nullable (String?) i non-null (String). Kompilator sprawdza dostęp nullable podczas kompilacji. Operator safe call (?.) i operator Elvis (?:) upraszczają pracę z wartościami opcjonalnymi bez zagnieżdżonych sprawdzeń.

// Przykład kodu Kotlin z korutynami i Flow
data class User(
    val id: Long,
    val name: String,
    val email: String
)

class UserRepository(
    private val api: UserApi,
    private val dao: UserDao
) {
    suspend fun getUser(id: Long): Result<User> {
        return try {
            val cached = dao.getUser(id)
            if (cached != null) {
                return Result.success(cached)
            }
            val remote = api.fetchUser(id)
            dao.insertUser(remote)
            Result.success(remote)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }

    fun observeUsers(): Flow<List<User>> {
        return dao.observeAll()
            .map { list -> list.sortedBy { it.name } }
            .flowOn(Dispatchers.Default)
    }
}

Przykład pokazuje korutyny (funkcja suspend) dla asynchronicznego dostępu do sieci i bazy danych, Flow dla reaktywnego obserwowania zmian danych i Result dla bezpiecznego obsługiwania błędów. Korutyny zastępują callbacki i RxJava bez narzutu na wątki.

Korutyny Kotlin i Flow

Korutyny Kotlin to lekkie wątki uruchamiane na współdzielonej puli wątków. Dispatchers.IO dla sieci i dysku, Dispatchers.Main dla UI, Dispatchers.Default dla zadań intensywnie korzystających z CPU. viewModelScope i lifecycleScope automatycznie anulują korutyny po zniszczeniu komponentu.

// ViewModel z korutynami i StateFlow
class UserViewModel(
    private val repository: UserRepository
) : ViewModel() {

    private val _users = MutableStateFlow<List<User>>(emptyList())
    val users: StateFlow<List<User>> = _users.asStateFlow()

    private val _loading = MutableStateFlow(false)
    val loading: StateFlow<Boolean> = _loading.asStateFlow()

    init {
        viewModelScope.launch {
            repository.observeUsers().collect { userList ->
                _users.value = userList
            }
        }
    }

    fun refresh() {
        viewModelScope.launch {
            _loading.value = true
            repository.getUser(42).onSuccess { user ->
                _users.value = listOf(user)
            }
            _loading.value = false
        }
    }
}

Android Studio i narzędzia programistyczne

Android Studio to oficjalne IDE oparte na IntelliJ IDEA, opracowane przez Google. Obejmuje edytor kodu, Layout Inspector, emulator urządzeń, APK Analyzer, Profiler (CPU, Pamięć, Sieć, Energia) i integrację z Firebase. Android Studio 2024 (Ladybug) obsługuje Kotlin 2.0 z trybem wieloplatformowym KMP.

Emulator Android

Emulator Android używa KVM (Linux) lub Hyper-V (Windows) do przyspieszania sprzętowego. Obsługuje symulację GPS, czujników, aparatu, połączeń i SMS. Google Pixel 9 Pro to zalecana konfiguracja do testowania z API 35 i 8 GB pamięci RAM emulatora.

Android Profiler i debugowanie

Profiler w czasie rzeczywistym wyświetla obciążenie CPU, alokację pamięci, żądania sieciowe i zużycie energii. Memory Profiler umożliwia zrzuty sterty i analizę wycieków przez drzewo referencyjne. Network Inspector rejestruje wszystkie żądania HTTP/HTTPS z ciałem i nagłówkami. Do dogłębnej analizy używany jest Android Studio Canary.

Komponenty aplikacji Android

Aplikacja Android składa się z czterech typów komponentów, każdy z własnym punktem wejścia i cyklem życia. Komponenty są rejestrowane w pliku AndroidManifest.xml.

Activity i Intent

Activity to podstawowy komponent interfejsu użytkownika. Każdy ekran to osobna Activity lub Fragment wewnątrz Activity. Nawigacja między ekranami odbywa się przez Intent — obiekt zawierający akcję (ACTION_VIEW, ACTION_SEND) i dane (URI). W Jetpack Navigation Graph nawigacja jest opisana w XML.

Service i WorkManager

Service wykonuje zadania w tle, ale od Android 8, usługi w tle są ograniczone. WorkManager to zalecana biblioteka do opóźnionych i gwarantowanych zadań w tle z obsługą łańcuchów, ograniczeń (np. tylko podczas ładowania) i restartu po awarii.

Jetpack Compose vs XML Layouts

Wybór między Jetpack Compose a tradycyjnymi układami XML to główna decyzja architektoniczna przy rozpoczynaniu projektu Android. Układy XML (RecyclerView, ConstraintLayout, FrameLayout) są standardem od 2008 roku. Jetpack Compose został wprowadzony w 2021 roku jako deklaratywna alternatywa.

Google zaleca Jetpack Compose dla wszystkich nowych projektów. Układy XML pozostają istotne dla wsparcia starszych projektów i przypadków, gdy potrzebna jest maksymalna personalizacja View (Canvas, SurfaceView). Kod Compose jest średnio o 40% krótszy niż równoważny XML + ViewBinding.

// Jetpack Compose — ekran profilu użytkownika
@Composable
fun ProfileScreen(
    user: User,
    onEditClick: () -> Unit,
    modifier: Modifier = Modifier
) {
    Column(
        modifier = modifier
            .fillMaxSize()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        AsyncImage(
            model = user.avatarUrl,
            contentDescription = "Awatar użytkownika",
            modifier = Modifier
                .size(120.dp)
                .clip(CircleShape)
        )

        Spacer(modifier = Modifier.height(16.dp))

        Text(
            text = user.name,
            style = MaterialTheme.typography.headlineMedium
        )

        Text(
            text = user.email,
            style = MaterialTheme.typography.bodyLarge,
            color = MaterialTheme.colorScheme.onSurfaceVariant
        )

        Spacer(modifier = Modifier.height(24.dp))

        Button(onClick = onEditClick) {
            Icon(Icons.Default.Edit, contentDescription = null)
            Spacer(modifier = Modifier.width(8.dp))
            Text("Edytuj profil")
        }
    }
}

@Preview(showBackground = true, showSystemUi = true)
@Composable
fun ProfileScreenPreview() {
    MaterialTheme {
        ProfileScreen(
            user = User(1, "Anna Petrova", "anna@example.com"),
            onEditClick = {}
        )
    }
}

Funkcja ProfileScreen jest zadeklarowana jako @Composable — opisuje UI deklaratywnie bez tworzenia instancji View. Compose automatycznie aktualizuje ekran po zmianie user. @Preview pokazuje wynik bezpośrednio w IDE bez budowania i uruchamiania na emulatorze.

Cykl życia Activity i Fragment

Każda Activity w Android przechodzi przez sześć stanów cyklu życia: onCreate, onStart, onResume, onPause, onStop, onDestroy. Fragment dodaje onAttach, onCreateView, onViewCreated. Zrozumienie cyklu życia jest kluczowe dla zarządzania pamięcią i zapobiegania wyciekom.

Główne stany Activity

onCreate — wywoływany raz podczas tworzenia Activity. Tutaj wykonywana jest inicjalizacja: setContentView, konfiguracja adapterów, subskrypcja LiveData. onResume — Activity jest na pierwszym planie i wchodzi w interakcję z użytkownikiem. onPause — Activity traci fokus (dialog, inna Activity). onStop — Activity nie jest widoczna. onDestroy — Activity jest niszczona.

// Activity z obsługą cyklu życia przez LifecycleScope
class MainActivity : ComponentActivity() {
    private val viewModel: UserViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContent {
            MaterialTheme {
                lifecycleScope.launch {
                    repeatOnLifecycle(Lifecycle.State.STARTED) {
                        viewModel.users.collect { users ->
                            updateUi(users)
                        }
                    }
                }
            }
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putString("last_search", searchQuery)
    }

    override fun onRestoreInstanceState(savedInstanceState: Bundle) {
        super.onRestoreInstanceState(savedInstanceState)
        searchQuery = savedInstanceState.getString("last_search", "")
    }
}

Użycie repeatOnLifecycle gwarantuje, że zbieranie danych wstrzymuje się, gdy Activity przechodzi w tło, i wznawia się po powrocie na pierwszy plan. Zapobiega to wyciekom i niepotrzebnym żądaniom sieciowym. onSaveInstanceState zapisuje stan tymczasowy podczas obrotu ekranu.

Google Play: publikacja i wymagania

Google Play to oficjalny sklep z aplikacjami Android. Rejestracja konta dewelopera kosztuje 25 USD jednorazowo. Każda aplikacja przechodzi automatyczną kontrolę Google Play Integrity pod kątem złośliwego kodu, naruszeń polityki i nieprawidłowego użycia uprawnień.

Wymagania dotyczące publikacji

Google wymaga podpisania aplikacji przez Android App Bundle (AAB) lub APK. AAB to zalecany format, umożliwiający generowanie zoptymalizowanych plików APK dla każdej konfiguracji urządzenia. Aplikacja musi być podpisana kluczem (keystore) z ważnym certyfikatem. Google Play App Signing to opcjonalne szyfrowanie klucza po stronie Google.

Polityka prywatności

Wszystkie aplikacje żądające dostępu do danych osobowych muszą zapewnić politykę prywatności. Od 2024 roku Google wymaga deklaracji Data Safety — formularza określającego rodzaje zbieranych danych i cele przetwarzania. Aplikacje kierowane na Android 14+ muszą używać Declarations API do deklarowania uprawnień.