Native App: concepte cheie, dezvoltare nativă iOS și Android

Ce este Native App

Native App — este o aplicație mobilă dezvoltată special pentru o singură platformă folosind limbajul său nativ de programare și instrumentele sale. Pentru iOS este Swift sau Objective-C împreună cu Xcode, pentru Android — Kotlin sau Java cu Android Studio. Codul se compilează direct în cod mașină al platformei (prin LLVM pentru iOS, ART pentru Android), ceea ce asigură viteză maximă de execuție.

Arhitectura aplicației native include trei straturi. Presentation Layer — componente UI (UIKit/SwiftUI pe iOS, Jetpack Compose/Android Views pe Android). Domain Layer — logică de business cu use cases și repository interfaces. Data Layer — surse de date: rețea (URLSession/Alamofire pe iOS, Retrofit/OkHttp pe Android), bază de date (CoreData/SwiftData, Room), sistem de fișiere. Fiecare strat folosește SDK-uri native — de exemplu, aplicația iOS poate apela CoreLocation pentru geopoziționare, CoreBluetooth pentru BLE, AVFoundation pentru cameră, Metal pentru grafică 3D. Android oferă analogi: FusedLocationProvider pentru geo, BluetoothAdapter pentru BLE, CameraX pentru cameră, OpenGL ES/Vulkan pentru grafică.

Ciclul de viață al native app diferă pe platforme. iOS folosește un model strict cu AppDelegate și SceneDelegate: aplicația trece prin stările notRunning → foregroundInactive → foregroundActive → background → suspended. Android folosește un model mai flexibil cu Activity și Fragment: onCreate → onStart → onResume → onPause → onStop → onDestroy, plus procesele pot fi ucise de sistem la lipsă de memorie. Dezvoltatorul trebuie să gestioneze corect salvarea stării (iOS: state restoration, Android: onSaveInstanceState) pentru o experiență continuă a utilizatorului.

Dezvoltarea iOS: Swift și Xcode

Dezvoltarea iOS se face exclusiv pe macOS în mediul Xcode — mediu integrat de dezvoltare de la Apple, incluzând editor de cod, Interface Builder, simulator iOS și instrumente de profilare (Instruments). Limbajul principal — Swift, prezentat de Apple în 2014. Swift combină siguranța tipurilor cu performanța apropiată de C și suportă paradigmele OOP, programării funcționale și orientate pe protocoale.

Framework-uri cheie iOS:

• UIKit — framework principal pentru construirea interfețelor cu abordare imperativă (UIViewController, UIView, Auto Layout)
• SwiftUI — framework declarativ (iOS 13+) cu @State, @Binding, @ObservedObject pentru actualizare reactivă a UI
• Combine — framework de programare reactivă cu Publisher/Subscriber pentru procesarea evenimentelor asincrone
• CoreData / SwiftData — framework-uri pentru stocarea persistentă a datelor cu graf de obiecte și SQLite la bază
• URLSession — client HTTP nativ cu suport pentru HTTP/2, cache și descărcări în fundal
• ARKit, CoreML, Vision — framework-uri pentru AR, învățare automată și viziune computerizată pe dispozitiv

Instrumente Xcode includ: Interface Builder pentru proiectarea vizuală a UI, Asset Catalog pentru gestionarea resurselor, Swift Package Manager pentru dependențe, Test Navigator pentru teste unitare și UI (XCTest), Organizer pentru publicare în App Store. Instruments permite profilarea CPU, memoriei, rețelei, graficii și consumului de energie. Pentru CI/CD se folosesc Xcode Cloud sau servicii terțe (GitHub Actions, Bitrise, Fastlane).

Dezvoltarea Android: Kotlin și Android Studio

Dezvoltarea Android se face în Android Studio — IDE bazat pe IntelliJ IDEA de la Google. Limbajul principal — Kotlin, devenit preferat în 2017. Kotlin este complet compatibil cu Java, dar oferă sintaxă mai concisă, null-safety prin operatorul elvis, corutine pentru asincronism și funcții de extensie. Android Studio include Layout Editor pentru proiectare vizuală, emulator Android cu Google Play Services, APK Analyzer și Profiler.

Componente cheie Android:

• Jetpack Compose — framework UI declarativ (Android 5+) cu funcții @Composable și stare reactivă prin mutableStateOf
• Android Views — sistem imperativ clasic cu marcare XML, Activity, Fragment, RecyclerView
• Room — bibliotecă ORM pentru SQLite cu verificarea interogărilor la compilare și suport Flow
• Retrofit + OkHttp — stivă standard pentru cereri HTTP cu interceptoare, cache și suport pentru corutine
• Hilt / Dagger — framework-uri de injectare a dependențelor (Dependency Injection) bazate pe JSR-330
• WorkManager — API pentru sarcini amânate și de fundal cu garanție de execuție chiar și după repornire

Pattern-uri arhitecturale Android: Google recomandă MVVM cu strat Repository. ViewModel stochează starea (StateFlow), Repository abstractizează sursele de date, Use Cases încapsulează logica de business. Navigation Component gestionează tranzițiile între ecrane printr-un graf de navigare. Pentru testare se folosesc JUnit, MockK, Compose UI Test și Espresso.

Exemplu de cod: Swift pentru iOS

Să examinăm crearea unei aplicații simple pentru iOS cu SwiftUI — o listă de sarcini cu salvare a datelor prin SwiftData. Aplicația demonstrează pattern-urile cheie ale dezvoltării native iOS: UI declarativ, actualizare reactivă, lucrul cu date.

import SwiftUI
import SwiftData

// 1. Model de date cu 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 cu logică de business
@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. Ecranul principal al aplicației
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("Sarcină nouă")) {
                    HStack {
                        TextField("Introduceți numele", text: $newTaskTitle)
                        Button("Adaugă") {
                            addTask()
                        }
                        .disabled(newTaskTitle.isEmpty)
                    }
                }
                Section(header: Text("Lista de sarcini")) {
                    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("Sarcinile mele")
        }
    }

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

Pattern-uri cheie în cod: @Model — macro SwiftData pentru generarea automată a stocării persistente; @Observable — macro Observable pentru actualizare reactivă a UI; @Query — property wrapper pentru încărcarea automată a datelor din SwiftData. Aplicația folosește arhitectura MVVM cu ViewModel care gestionează logica de business și SwiftUI View pentru afișare. SwiftData salvează automat datele la modificarea modelului — dezvoltatorul nu trebuie să scrie interogări SQL.

Exemplu de cod: Kotlin pentru Android

Aplicație similară pentru Android în Kotlin cu Jetpack Compose și Room. Arată diferențele de arhitectură și abordări între platforme.

// 1. Entity Room — model de date
@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 — interogări la bază
@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 cu logică de business
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("Sarcinile mele", style = MaterialTheme.typography.headlineMedium)

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

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

Diferențe cheie față de iOS: Room folosește adnotări @Entity, @Dao și @Query pentru lucrul cu SQLite; ViewModel gestionează ciclul de viață prin viewModelScope cu corutine; StateFlow asigură actualizarea reactivă a Compose UI prin collectAsState. Pe Android datele sunt transmise prin Flow — analog Combine Publisher, dar cu anulare la schimbarea ecranului prin viewModelScope.

Avantaje și dezavantaje ale native app

Avantajele native app față de soluțiile cross-platform includ câteva aspecte cheie. Performanță: acces direct la GPU prin Metal (iOS) și Vulkan (Android) oferă 60 fps în animații complexe. Acces la API: funcții noi iOS și Android sunt disponibile în ziua lansării, fără a aștepta suport în framework. Experiența utilizatorului: componente UI native (NavigationStack, TabView, Sheet pe iOS; Scaffold, NavigationBar, BottomSheet pe Android) asigură un comportament familiar. Consum energetic: codul nativ consumă cu 15–25% mai puțină baterie în sarcinile de fundal.

Dezavantaje ale native app: costul de dezvoltare de 1.5–2 ori mai mare din cauza necesității a două echipe separate. Timpul de lansare pe piață crește: două dezvoltări paralele necesită coordonare și dublează volumul de testare. Suport: actualizările trebuie lansate pentru ambele platforme simultan, ceea ce complică CI/CD. Pentru aplicații simple (cataloage, fluxuri, formulare) soluțiile cross-platform pot fi mai economice și mai rapide.

Când să alegem native app: jocuri și aplicații cu grafică intensivă (Metal, Vulkan, ARKit, ARCore); aplicații cu integrare profundă în sistemul de operare (Bluetooth LE, NFC, CoreBluetooth, HealthKit, Google Fit); aplicații financiare, medicale și corporative cu cerințe de securitate și certificare; proiecte unde fiecare milisecundă de întârziere este critică (trading, streaming, apeluri video). Pentru MVP, startup-uri și aplicații simple, dezvoltarea cross-platform poate fi o alegere mai rațională.