Native App: klíčové pojmy, nativní vývoj iOS a Android

Co je Native App

Native App — je mobilní aplikace vyvinutá speciálně pro jednu platformu s použitím jejího nativního programovacího jazyka a nástrojů. Pro iOS je to Swift nebo Objective-C spolu s Xcode, pro Android — Kotlin nebo Java s Android Studio. Kód je kompilován přímo do strojového kódu platformy (přes LLVM pro iOS, ART pro Android), což zajišťuje maximální rychlost provádění.

Architektura nativní aplikace zahrnuje tři vrstvy. Presentation Layer — UI komponenty (UIKit/SwiftUI na iOS, Jetpack Compose/Android Views na Android). Domain Layer — obchodní logika s use cases a repository interfaces. Data Layer — zdroje dat: síť (URLSession/Alamofire na iOS, Retrofit/OkHttp na Android), databáze (CoreData/SwiftData, Room), souborový systém. Každá vrstva používá nativní SDK — například iOS aplikace může volat CoreLocation pro geolokaci, CoreBluetooth pro BLE, AVFoundation pro kameru, Metal pro 3D grafiku. Android nabízí analogy: FusedLocationProvider pro geo, BluetoothAdapter pro BLE, CameraX pro kameru, OpenGL ES/Vulkan pro grafiku.

Životní cyklus native app se na platformách liší. iOS používá striktní model s AppDelegate a SceneDelegate: aplikace prochází stavy notRunning → foregroundInactive → foregroundActive → background → suspended. Android používá flexibilnější model s Activity a Fragment: onCreate → onStart → onResume → onPause → onStop → onDestroy, plus procesy mohou být ukončeny systémem při nedostatku paměti. Vývojář musí správně zpracovávat ukládání stavu (iOS: state restoration, Android: onSaveInstanceState) pro nepřetržitý uživatelský zážitek.

Vývoj pro iOS: Swift a Xcode

Vývoj pro iOS probíhá výhradně na macOS v prostředí Xcode — integrovaném vývojovém prostředí od Apple, zahrnujícím editor kódu, Interface Builder, iOS simulátor a nástroje pro profilování (Instruments). Hlavní jazyk — Swift, představený Apple v roce 2014. Swift kombinuje typovou bezpečnost s výkonem blízkým C a podporuje paradigmata OOP, funkcionálního a protokolově orientovaného programování.

Klíčové frameworky iOS:

• UIKit — hlavní framework pro budování rozhraní s imperativním přístupem (UIViewController, UIView, Auto Layout)
• SwiftUI — deklarativní framework (iOS 13+) s @State, @Binding, @ObservedObject pro reaktivní aktualizaci UI
• Combine — framework reaktivního programování s Publisher/Subscriber pro zpracování asynchronních událostí
• CoreData / SwiftData — frameworky pro trvalé ukládání dat s grafem objektů a SQLite v základu
• URLSession — nativní HTTP klient s podporou HTTP/2, cachování a stahování na pozadí
• ARKit, CoreML, Vision — frameworky pro AR, strojové učení a počítačové vidění na zařízení

Nástroje Xcode zahrnují: Interface Builder pro vizuální návrh UI, Asset Catalog pro správu zdrojů, Swift Package Manager pro závislosti, Test Navigator pro jednotkové a UI testy (XCTest), Organizer pro publikaci v App Store. Instruments umožňuje profilovat CPU, paměť, síť, grafiku a spotřebu energie. Pro CI/CD se používají Xcode Cloud nebo služby třetích stran (GitHub Actions, Bitrise, Fastlane).

Vývoj pro Android: Kotlin a Android Studio

Vývoj pro Android probíhá v Android Studio — IDE založeném na IntelliJ IDEA od Google. Hlavní jazyk — Kotlin, který se stal preferovaným v roce 2017. Kotlin je plně kompatibilní s Javou, ale nabízí stručnější syntaxi, null-bezpečnost přes elvis operátor, korutiny pro asynchronnost a extension funkce. Android Studio obsahuje Layout Editor pro vizuální návrh, Android emulátor s Google Play Services, APK Analyzer a Profiler.

Klíčové komponenty Android:

• Jetpack Compose — deklarativní UI framework (Android 5+) s @Composable funkcemi a reaktivním stavem přes mutableStateOf
• Android Views — klasický imperativní systém s XML značením, Activity, Fragment, RecyclerView
• Room — ORM knihovna pro SQLite s kontrolou dotazů v době kompilace a podporou Flow
• Retrofit + OkHttp — standardní stack pro HTTP požadavky s interceptory, cachováním a podporou korutin
• Hilt / Dagger — frameworky pro vkládání závislostí (Dependency Injection) založené na JSR-330
• WorkManager — API pro odložené úlohy a úlohy na pozadí se zárukou provedení i po restartu

Architektonické vzory Android: Google doporučuje MVVM s Repository vrstvou. ViewModel ukládá stav (StateFlow), Repository abstrahuje zdroje dat, Use Cases zapouzdřují obchodní logiku. Navigation Component spravuje přechody mezi obrazovkami pomocí navigačního grafu. Pro testování se používají JUnit, MockK, Compose UI Test a Espresso.

Ukázka kódu: Swift pro iOS

Podívejme se na vytvoření jednoduché aplikace pro iOS ve SwiftUI — seznam úkolů s ukládáním dat přes SwiftData. Aplikace demonstruje klíčové vzory nativního vývoje iOS: deklarativní UI, reaktivní aktualizace, práce s daty.

import SwiftUI
import SwiftData

// 1. Datový model se 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 s obchodní logikou
@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. Hlavní obrazovka aplikace
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("Nový úkol")) {
                    HStack {
                        TextField("Zadejte název", text: $newTaskTitle)
                        Button("Přidat") {
                            addTask()
                        }
                        .disabled(newTaskTitle.isEmpty)
                    }
                }
                Section(header: Text("Seznam úkolů")) {
                    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 úkoly")
        }
    }

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

Klíčové vzory v kódu: @Model — makro SwiftData pro automatické generování trvalého úložiště; @Observable — makro Observable pro reaktivní aktualizaci UI; @Query — property wrapper pro automatické načítání dat z SwiftData. Aplikace používá architekturu MVVM s ViewModel, který spravuje obchodní logiku, a SwiftUI View pro zobrazení. SwiftData automaticky ukládá data při změně modelu — vývojář nemusí psát SQL dotazy.

Ukázka kódu: Kotlin pro Android

Podobná aplikace pro Android v Kotlin s Jetpack Compose a Room. Ukazuje rozdíly v architektuře a přístupech mezi platformami.

// 1. Entity Room — datový model
@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 — dotazy do databáze
@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 s obchodní logikou
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 úkoly", style = MaterialTheme.typography.headlineMedium)

        Row(
            modifier = Modifier.fillMaxWidth().padding(vertical = 8.dp)
        ) {
            OutlinedTextField(
                value = newTitle,
                onValueChange = { newTitle = it },
                label = { Text("Nový úkol") },
                modifier = Modifier.weight(1f)
            )
            Button(
                onClick = { viewModel.addTask(newTitle); newTitle = "" },
                enabled = newTitle.isNotBlank()
            ) {
                Text("Přidat")
            }
        }

        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
                    )
                }
            }
        }
    }
}

Klíčové rozdíly od iOS: Room používá anotace @Entity, @Dao a @Query pro práci s SQLite; ViewModel spravuje životní cyklus přes viewModelScope s korutinami; StateFlow zajišťuje reaktivní aktualizaci Compose UI přes collectAsState. Na Androidu jsou data přenášena přes Flow — obdoba Combine Publisher, ale se zrušením při změně obrazovky přes viewModelScope.

Výhody a nevýhody native app

Výhody native app oproti multiplatformním řešením zahrnují několik klíčových aspektů. Výkon: přímý přístup k GPU přes Metal (iOS) a Vulkan (Android) poskytuje 60 fps ve složitých animacích. Přístup k API: nové funkce iOS a Android jsou dostupné v den vydání, bez čekání na podporu v frameworku. Uživatelský zážitek: nativní UI komponenty (NavigationStack, TabView, Sheet na iOS; Scaffold, NavigationBar, BottomSheet na Android) zajišťují známé chování. Spotřeba energie: nativní kód spotřebovává o 15–25% méně baterie u úloh na pozadí.

Nevýhody native app: náklady na vývoj 1.5–2krát vyšší kvůli potřebě dvou samostatných týmů. Doba uvedení na trh se prodlužuje: dva paralelní vývoje vyžadují koordinaci a zdvojnásobují objem testování. Podpora: aktualizace musí být vydávány pro obě platformy současně, což komplikuje CI/CD. Pro jednoduché aplikace (katalogy, feedy, formuláře) mohou být multiplatformní řešení ekonomičtější a rychlejší.

Kdy zvolit native app: hry a aplikace s intenzivní grafikou (Metal, Vulkan, ARKit, ARCore); aplikace s hlubokou integrací do OS (Bluetooth LE, NFC, CoreBluetooth, HealthKit, Google Fit); finanční, lékařské a podnikové aplikace s požadavky na bezpečnost a certifikaci; projekty, kde je každá milisekunda zpoždění kritická (obchodování, streamování, videohovory). Pro MVP, startupy a jednoduché aplikace může být multiplatformní vývoj racionálnější volbou.