Native App: asosiy tushunchalar, iOS va Android nativ ishlanmasi

Native App nima

Native App — bu bir platforma uchun uning ona dasturlash tili va vositalaridan foydalanib maxsus ishlab chiqilgan mobil ilova. iOS uchun bu Swift yoki Objective-C Xcode bilan, Android uchun — Kotlin yoki Java Android Studio bilan. Kod to'g'ridan-to'g'ri platformaning mashina kodiga (iOS uchun LLVM, Android uchun ART orqali) kompilyatsiya qilinadi, bu maksimal bajarish tezligini ta'minlaydi.

Nativ ilova arxitekturasi uch qatlamni o'z ichiga oladi. Presentation Layer — UI komponentlari (iOS da UIKit/SwiftUI, Android da Jetpack Compose/Android Views). Domain Layer — use cases va repository interfeyslari bilan biznes mantiq. Data Layer — ma'lumot manbalari: tarmoq (iOS da URLSession/Alamofire, Android da Retrofit/OkHttp), ma'lumotlar bazasi (CoreData/SwiftData, Room), fayl tizimi. Har bir qatlam nativ SDK-lardan foydalanadi — masalan, iOS ilovasi geolokatsiya uchun CoreLocation, BLE uchun CoreBluetooth, kamera uchun AVFoundation, 3D grafik uchun Metal ni chaqirishi mumkin. Android analoglarni taklif qiladi: geo uchun FusedLocationProvider, BLE uchun BluetoothAdapter, kamera uchun CameraX, grafik uchun OpenGL ES/Vulkan.

Native app ning hayot aylanishi platformalarda farqlanadi. iOS AppDelegate va SceneDelegate bilan qat'iy modeldan foydalanadi: ilova notRunning → foregroundInactive → foregroundActive → background → suspended holatlaridan o'tadi. Android Activity va Fragment bilan moslashuvchan modeldan foydalanadi: onCreate → onStart → onResume → onPause → onStop → onDestroy, bundan tashqari jarayonlar xotira yetishmasligida tizim tomonidan o'ldirilishi mumkin. Dasturchi uzluksiz foydalanuvchi tajribasi uchun holatni saqlashni (iOS: state restoration, Android: onSaveInstanceState) to'g'ri boshqarishi kerak.

iOS ishlanmasi: Swift va Xcode

iOS ishlanmasi faqat macOS da Xcode muhitida olib boriladi — Apple ning kod muharriri, Interface Builder, iOS simulyatori va profilash vositalari (Instruments) ni o'z ichiga olgan integratsiyalashgan ishlanma muhiti. Asosiy til — Swift, Apple tomonidan 2014 yilda taqdim etilgan. Swift tip xavfsizligini C ga yaqin ishlash bilan birlashtiradi va OOP, funksional va protokol-yo'naltirilgan dasturlash paradigmalarini qo'llab-quvvatlaydi.

Asosiy iOS freymvorklari:

• UIKit — interfeys qurish uchun asosiy freymvork imperativ yondashuv bilan (UIViewController, UIView, Auto Layout)
• SwiftUI — deklarativ freymvork (iOS 13+) @State, @Binding, @ObservedObject bilan reaktiv UI yangilanishi uchun
• Combine — Publisher/Subscriber bilan asinxron hodisalarni qayta ishlash uchun reaktiv dasturlash freymvorki
• CoreData / SwiftData — obyekt grafi va SQLite asosida ma'lumotlarni doimiy saqlash uchun freymvorklar
• URLSession — HTTP/2, keshlash va fon yuklamalari qo'llab-quvvatlovchi nativ HTTP mijoz
• ARKit, CoreML, Vision — qurilmada AR, mashina o'rganishi va kompyuter ko'rishi uchun freymvorklar

Xcode vositalari o'z ichiga oladi: UI vizual dizayni uchun Interface Builder, resurslarni boshqarish uchun Asset Catalog, bog'liqliklar uchun Swift Package Manager, birlik va UI testlari uchun Test Navigator (XCTest), App Store da nashr qilish uchun Organizer. Instruments CPU, xotira, tarmoq, grafik va energiya sarfini profillash imkonini beradi. CI/CD uchun Xcode Cloud yoki uchinchi tomon xizmatlari (GitHub Actions, Bitrise, Fastlane) ishlatiladi.

Android ishlanmasi: Kotlin va Android Studio

Android ishlanmasi Android Studio da olib boriladi — Google ning IntelliJ IDEA ga asoslangan IDE si. Asosiy til — Kotlin, 2017 yilda afzal ko'rilgan tilga aylangan. Kotlin Java bilan to'liq mos, lekin qisqaroq sintaksis, elvis-operator orqali null-xavfsizlik, asinxronlik uchun korutinlar va extension funksiyalarni taklif qiladi. Android Studio Layout Editor vizual dizayn, Google Play Services bilan Android emulyatori, APK Analyzer va Profiler ni o'z ichiga oladi.

Asosiy Android komponentlari:

• Jetpack Compose — deklarativ UI freymvorki (Android 5+) @Composable funksiyalari va mutableStateOf orqali reaktiv holat bilan
• Android Views — XML belgilash, Activity, Fragment, RecyclerView bilan klassik imperativ tizim
• Room — SQLite uchun ORM kutubxonasi, so'rovlarni kompilyatsiya bosqichida tekshirish va Flow qo'llab-quvvatlashi bilan
• Retrofit + OkHttp — interceptors, keshlash va korutin qo'llab-quvvatlovi bilan HTTP so'rovlari uchun standart stack
• Hilt / Dagger — JSR-330 asosida bog'liqlik inyeksiyasi (Dependency Injection) freymvorklari
• WorkManager — kechiktirilgan va fon vazifalari uchun API, qayta ishga tushirishdan keyin ham bajarilish kafolati bilan

Android arxitektura namunalari: Google Repository qatlami bilan MVVM ni tavsiya qiladi. ViewModel holatni saqlaydi (StateFlow), Repository ma'lumot manbalarini abstraksiyalaydi, Use Cases biznes mantiqni inkapsulatsiyalaydi. Navigation Component navigatsiya grafi orqali ekranlar o'rtasida o'tishlarni boshqaradi. Test uchun JUnit, MockK, Compose UI Test va Espresso ishlatiladi.

Kod namunasi: Swift iOS uchun

SwiftUI da iOS uchun oddiy ilova yaratishni ko'rib chiqaylik — SwiftData orqali ma'lumot saqlash bilan vazifalar ro'yxati. Ilova nativ iOS ishlanmasining asosiy namunalarini ko'rsatadi: deklarativ UI, reaktiv yangilanish, ma'lumotlar bilan ishlash.

import SwiftUI
import SwiftData

// 1. SwiftData bilan ma'lumot modeli
@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. Biznes mantiq bilan ViewModel
@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. Ilovaning asosiy ekrani
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("Yangi vazifa")) {
                    HStack {
                        TextField("Nom kiriting", text: $newTaskTitle)
                        Button("Qo'shish") {
                            addTask()
                        }
                        .disabled(newTaskTitle.isEmpty)
                    }
                }
                Section(header: Text("Vazifalar ro'yxati")) {
                    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("Mening vazifalarim")
        }
    }

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

Koddagi asosiy namunalar: @Model — doimiy xotirani avtomatik generatsiya qilish uchun SwiftData makrosi; @Observable — UI reaktiv yangilanishi uchun Observable makrosi; @Query — SwiftData dan ma'lumotlarni avtomatik yuklash uchun property wrapper. Ilova biznes mantiqni boshqaruvchi ViewModel va ko'rsatish uchun SwiftUI View bilan MVVM arxitekturasidan foydalanadi. SwiftData model o'zgarganda ma'lumotlarni avtomatik saqlaydi — dasturchi SQL so'rovlar yozishi shart emas.

Kod namunasi: Kotlin Android uchun

Jetpack Compose va Room bilan Android uchun Kotlin da o'xshash ilova. Platformalar o'rtasidagi arxitektura va yondashuvlardagi farqlarni ko'rsatadi.

// 1. Entity Room — ma'lumot modeli
@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 — bazaga so'rovlar
@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. Biznes mantiq bilan ViewModel
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("Mening vazifalarim", style = MaterialTheme.typography.headlineMedium)

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

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

iOS dan asosiy farqlar: Room SQLite bilan ishlash uchun @Entity, @Dao va @Query annotatsiyalaridan foydalanadi; ViewModel korutinlar bilan viewModelScope orqali hayot aylanishini boshqaradi; StateFlow collectAsState orqali Compose UI reaktiv yangilanishini ta'minlaydi. Android da ma'lumotlar Flow orqali uzatiladi — Combine Publisher analogi, lekin viewModelScope orqali ekran o'zgarganda bekor qilinadi.

Native app ning afzalliklari va kamchiliklari

Native app ning afzalliklari o'zaro platforma yechimlariga nisbatan bir necha asosiy jihatlarni o'z ichiga oladi. Ishlash: Metal (iOS) va Vulkan (Android) orqali GPU ga to'g'ridan-to'g'ri kirish murakkab animatsiyada 60 fps beradi. API ga kirish: iOS va Android ning yangi funksiyalari chiqish kunida, freymvorkda qo'llab-quvvatlashni kutmasdan mavjud. Foydalanuvchi tajribasi: nativ UI komponentlari (iOS da NavigationStack, TabView, Sheet; Android da Scaffold, NavigationBar, BottomSheet) tanish xatti-harakatni ta'minlaydi. Energiya sarfi: nativ kod fon vazifalarida batareyani 15–25% kam sarflaydi.

Native app ning kamchiliklari: ikkita alohida jamoa zarurati tufayli ishlanma narxi 1.5–2 baravar yuqori. Bozorga chiqish vaqti oshadi: ikkita parallel ishlanma muvofiqlashtirishni talab qiladi va test hajmini ikki baravar oshiradi. Qo'llab-quvvatlash: yangilanishlar ikkala platforma uchun bir vaqtda chiqarilishi kerak, bu CI/CD ni murakkablashtiradi. Oddiy ilovalar (kataloglar, lentalar, shakllar) uchun o'zaro platforma yechimlari iqtisodiy jihatdan tejamkor va tezroq bo'lishi mumkin.

Qachon native app ni tanlash kerak: intensiv grafikali o'yinlar va ilovalar (Metal, Vulkan, ARKit, ARCore); OT ga chuqur integratsiyalangan ilovalar (Bluetooth LE, NFC, CoreBluetooth, HealthKit, Google Fit); xavfsizlik va sertifikatlash talablari bo'lgan moliyaviy, tibbiy va korporativ ilovalar; har bir millisekund kechikish muhim bo'lgan loyihalar (savdo, striming, videoqo'ng'iroqlar). MVP, startaplar va oddiy ilovalar uchun o'zaro platforma ishlanmasi yanada oqilona tanlov bo'lishi mumkin.