Native App: kluczowe pojęcia, natywny rozwój iOS i Android

Co to jest Native App

Native App — to aplikacja mobilna opracowana specjalnie dla jednej platformy z użyciem jej rodzimego języka programowania i narzędzi. Dla iOS jest to Swift lub Objective-C wraz z Xcode, dla Android — Kotlin lub Java z Android Studio. Kod kompiluje się bezpośrednio do kodu maszynowego platformy (przez LLVM dla iOS, ART dla Android), co zapewnia maksymalną szybkość wykonania.

Architektura aplikacji natywnej obejmuje trzy warstwy. Presentation Layer — komponenty UI (UIKit/SwiftUI na iOS, Jetpack Compose/Android Views na Android). Domain Layer — logika biznesowa z przypadkami użycia i interfejsami repozytorium. Data Layer — źródła danych: sieć (URLSession/Alamofire na iOS, Retrofit/OkHttp na Android), baza danych (CoreData/SwiftData, Room), system plików. Każda warstwa używa natywnych SDK — na przykład aplikacja iOS może wywoływać CoreLocation dla geolokalizacji, CoreBluetooth dla BLE, AVFoundation dla kamery, Metal dla grafiki 3D. Android oferuje analogi: FusedLocationProvider dla geo, BluetoothAdapter dla BLE, CameraX dla kamery, OpenGL ES/Vulkan dla grafiki.

Cykl życia native app różni się na platformach. iOS używa ścisłego modelu z AppDelegate i SceneDelegate: aplikacja przechodzi stany notRunning → foregroundInactive → foregroundActive → background → suspended. Android używa bardziej elastycznego modelu z Activity i Fragment: onCreate → onStart → onResume → onPause → onStop → onDestroy, plus procesy mogą być zabite przez system przy braku pamięci. Deweloper musi poprawnie obsługiwać zapisywanie stanu (iOS: state restoration, Android: onSaveInstanceState) dla ciągłego doświadczenia użytkownika.

Rozwój iOS: Swift i Xcode

Rozwój iOS prowadzony jest wyłącznie na macOS w środowisku Xcode — zintegrowanym środowisku programistycznym od Apple, obejmującym edytor kodu, Interface Builder, symulator iOS i narzędzia profilowania (Instruments). Główny język — Swift, przedstawiony przez Apple w 2014 roku. Swift łączy bezpieczeństwo typów z wydajnością bliską C i wspiera paradygmaty OOP, programowania funkcyjnego i zorientowanego na protokoły.

Kluczowe frameworki iOS:

• UIKit — główny framework do budowania interfejsów z podejściem imperatywnym (UIViewController, UIView, Auto Layout)
• SwiftUI — deklaratywny framework (iOS 13+) z @State, @Binding, @ObservedObject do reaktywnego aktualizowania UI
• Combine — framework programowania reaktywnego z Publisher/Subscriber do obsługi zdarzeń asynchronicznych
• CoreData / SwiftData — frameworki do trwałego przechowywania danych z grafem obiektów i SQLite w podstawie
• URLSession — natywny klient HTTP z obsługą HTTP/2, buforowania i pobrań w tle
• ARKit, CoreML, Vision — frameworki dla AR, uczenia maszynowego i wizji komputerowej na urządzeniu

Narzędzia Xcode obejmują: Interface Builder do wizualnego projektowania UI, Asset Catalog do zarządzania zasobami, Swift Package Manager dla zależności, Test Navigator dla testów jednostkowych i UI (XCTest), Organizer do publikacji w App Store. Instruments pozwala profilować CPU, pamięć, sieć, grafikę i zużycie energii. Do CI/CD używa się Xcode Cloud lub zewnętrznych serwisów (GitHub Actions, Bitrise, Fastlane).

Rozwój Android: Kotlin i Android Studio

Rozwój Android prowadzony jest w Android Studio — IDE opartym na IntelliJ IDEA od Google. Główny język — Kotlin, który stał się preferowanym w 2017 roku. Kotlin jest w pełni kompatybilny z Java, ale oferuje bardziej zwięzłą składnię, null-safety przez operator elvisa, korutyny dla asynchroniczności i funkcje rozszerzające. Android Studio zawiera Layout Editor do wizualnego projektowania, emulator Android z Google Play Services, APK Analyzer i Profiler.

Kluczowe komponenty Android:

• Jetpack Compose — deklaratywny framework UI (Android 5+) z funkcjami @Composable i reaktywnym stanem przez mutableStateOf
• Android Views — klasyczny system imperatywny z XML-markup, Activity, Fragment, RecyclerView
• Room — biblioteka ORM dla SQLite z sprawdzaniem zapytań na etapie kompilacji i obsługą Flow
• Retrofit + OkHttp — standardowy stos do zapytań HTTP z przechwytywaczami, buforowaniem i obsługą korutyn
• Hilt / Dagger — frameworki wstrzykiwania zależności (Dependency Injection) oparte na JSR-330
• WorkManager — API dla opóźnionych i tła zadań z gwarancją wykonania nawet po restarcie

Wzorce architektoniczne Android: Google zaleca MVVM z warstwą Repository. ViewModel przechowuje stan (StateFlow), Repository abstrahuje źródła danych, Use Cases enkapsulują logikę biznesową. Navigation Component zarządza przejściami między ekranami przez graf nawigacji. Do testowania używa się JUnit, MockK, Compose UI Test i Espresso.

Przykład kodu: Swift dla iOS

Rozważmy stworzenie prostej aplikacji dla iOS na SwiftUI — listy zadań z zapisem danych przez SwiftData. Aplikacja demonstruje kluczowe wzorce natywnego rozwoju iOS: deklaratywny UI, reaktywna aktualizacja, praca z danymi.

import SwiftUI
import SwiftData

// 1. Model danych z SwiftData
@Model
final class TaskItem {
    var title: String
    var isCompleted: Bool
    var createdAt: Date

    init(title: String) {
        self.title = title
        self.isCompleted = false
        self.createdAt = Date()
    }
}

// 2. ViewModel z logiką biznesową
@Observable
final class TaskViewModel {
    var tasks: [TaskItem] = []

    func addTask(title: String, context: ModelContext) {
        let task = TaskItem(title: title)
        context.insert(task)
        tasks.append(task)
    }

    func toggleTask(task: TaskItem) {
        task.isCompleted.toggle()
    }
}

// 3. Główny ekran aplikacji
struct ContentView: View {
    @Environment(\.modelContext) private var context
    @State private var viewModel = TaskViewModel()
    @State private var newTaskTitle = ""
    @Query private var tasks: [TaskItem]

    var body: some View {
        NavigationStack {
            List {
                Section(header: Text("Nowe zadanie")) {
                    HStack {
                        TextField("Wprowadź nazwę", text: $newTaskTitle)
                        Button("Dodaj") {
                            addTask()
                        }
                        .disabled(newTaskTitle.isEmpty)
                    }
                }
                Section(header: Text("Lista zadań")) {
                    ForEach(tasks) { task in
                        HStack {
                            Image(systemName: task.isCompleted ? "checkmark.circle.fill" : "circle")
                                .onTapGesture { viewModel.toggleTask(task: task) }
                            Text(task.title)
                                .strikethrough(task.isCompleted)
                            Spacer()
                            Text(task.createdAt, style: .date)
                                .font(.caption)
                                .foregroundColor(.secondary)
                        }
                    }
                    .onDelete { indexSet in
                        for index in indexSet {
                            context.delete(tasks[index])
                        }
                    }
                }
            }
            .navigationTitle("Moje zadania")
        }
    }

    private func addTask() {
        guard !newTaskTitle.isEmpty else { return }
        viewModel.addTask(title: newTaskTitle, context: context)
        newTaskTitle = ""
    }
}

Kluczowe wzorce w kodzie: @Model — makro SwiftData do automatycznej generacji persistent storage; @Observable — makro Observable do reaktywnego aktualizowania UI; @Query — property wrapper do automatycznego ładowania danych z SwiftData. Aplikacja używa architektury MVVM z ViewModel, który zarządza logiką biznesową, i SwiftUI View do wyświetlania. SwiftData automatycznie zapisuje dane przy zmianie modelu — deweloper nie musi pisać zapytań SQL.

Przykład kodu: Kotlin dla Android

Analogiczna aplikacja dla Android na Kotlin z Jetpack Compose i Room. Pokazuje różnice w architekturze i podejściach między platformami.

// 1. Entity Room — model danych
@Entity(tableName = "tasks")
data class TaskEntity(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    val title: String,
    val isCompleted: Boolean = false,
    val createdAt: Long = System.currentTimeMillis()
)

// 2. DAO — zapytania do bazy
@Dao
interface TaskDao {
    @Query("SELECT * FROM tasks ORDER BY createdAt DESC")
    fun getAllTasks(): Flow<List<TaskEntity>>

    @Insert
    suspend fun insertTask(task: TaskEntity)

    @Delete
    suspend fun deleteTask(task: TaskEntity)
}

// 3. ViewModel z logiką biznesową
class TaskViewModel(private val dao: TaskDao) : ViewModel() {
    val tasks: StateFlow<List<TaskEntity>> = dao
        .getAllTasks()
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())

    fun addTask(title: String) {
        viewModelScope.launch {
            dao.insertTask(TaskEntity(title = title))
        }
    }

    fun toggleTask(task: TaskEntity) {
        viewModelScope.launch {
            dao.insertTask(task.copy(isCompleted = !task.isCompleted))
        }
    }
}

// 4. Compose UI
@Composable
fun TaskScreen(viewModel: TaskViewModel = viewModel()) {
    val tasks by viewModel.tasks.collectAsState()
    var newTitle by remember { mutableStateOf("") }

    Column(modifier = Modifier.padding(16.dp)) {
        Text("Moje zadania", style = MaterialTheme.typography.headlineMedium)

        Row(
            modifier = Modifier.fillMaxWidth().padding(vertical = 8.dp)
        ) {
            OutlinedTextField(
                value = newTitle,
                onValueChange = { newTitle = it },
                label = { Text("Nowe zadanie") },
                modifier = Modifier.weight(1f)
            )
            Button(
                onClick = { viewModel.addTask(newTitle); newTitle = "" },
                enabled = newTitle.isNotBlank()
            ) {
                Text("Dodaj")
            }
        }

        LazyColumn {
            items(tasks, key = { it.id }) { task ->
                Row(
                    modifier = Modifier
                        .fillMaxWidth()
                        .clickable { viewModel.toggleTask(task) }
                        .padding(vertical = 4.dp),
                    verticalAlignment = Alignment.CenterVertically
                ) {
                    Checkbox(checked = task.isCompleted, onCheckedChange = { viewModel.toggleTask(task) })
                    Text(
                        text = task.title,
                        textDecoration = if (task.isCompleted) TextDecoration.LineThrough else TextDecoration.None
                    )
                }
            }
        }
    }
}

Kluczowe różnice od iOS: Room używa adnotacji @Entity, @Dao i @Query do pracy z SQLite; ViewModel zarządza cyklem życia przez viewModelScope z korutynami; StateFlow zapewnia reaktywną aktualizację Compose UI przez collectAsState. Na Android dane są przesyłane przez Flow — analog Combine Publisher, ale z anulowaniem przy zmianie ekranu przez viewModelScope.

Zalety i wady native app

Zalety native app przed rozwiązaniami wieloplatformowymi obejmują kilka kluczowych aspektów. Wydajność: bezpośredni dostęp do GPU przez Metal (iOS) i Vulkan (Android) daje 60 fps w złożonej animacji. Dostęp do API: nowe funkcje iOS i Android są dostępne w dniu premiery, bez oczekiwania na wsparcie we frameworku. Doświadczenie użytkownika: natywne komponenty UI (NavigationStack, TabView, Sheet na iOS; Scaffold, NavigationBar, BottomSheet na Android) zapewniają znajome zachowanie. Zużycie energii: natywny kod zużywa o 15–25% mniej baterii w zadaniach tła.

Wady native app: koszt rozwoju 1.5–2 razy wyższy z powodu potrzeby dwóch oddzielnych zespołów. Czas wejścia na rynek wzrasta: dwa równoległe rozwoju wymagają koordynacji i podwajają objętość testowania. Wsparcie: aktualizacje trzeba wydawać dla dwóch platform jednocześnie, co komplikuje CI/CD. Dla prostych aplikacji (katalogi, feedy, formularze) rozwiązania wieloplatformowe mogą być bardziej ekonomiczne i szybsze.

Kiedy wybrać native app: gry i aplikacje z intensywną grafiką (Metal, Vulkan, ARKit, ARCore); aplikacje z głęboką integracją z systemem operacyjnym (Bluetooth LE, NFC, CoreBluetooth, HealthKit, Google Fit); aplikacje finansowe, medyczne i korporacyjne z wymaganiami bezpieczeństwa i certyfikacji; projekty, gdzie każda milisekunda opóźnienia jest krytyczna (handel, streaming, wideorozmowy). Dla MVP, startupów i prostych aplikacji rozwój wieloplatformowy może być bardziej racjonalnym wyborem.