Native App: mga pangunahing konsepto, native na pag-develop ng iOS at Android

Ano ang Native App

Native App — ay isang mobile na aplikasyon na binuo partikular para sa isang platform gamit ang katutubong programming language at mga tool nito. Para sa iOS ito ay Swift o Objective-C kasama ang Xcode, para sa Android — Kotlin o Java kasama ang Android Studio. Ang code ay direktang nagko-compile sa machine code ng platform (sa pamamagitan ng LLVM para sa iOS, ART para sa Android), na tinitiyak ang maximum na bilis ng pag-execute.

Arkitektura ng native na aplikasyon ay may tatlong layer. Presentation Layer — mga UI component (UIKit/SwiftUI sa iOS, Jetpack Compose/Android Views sa Android). Domain Layer — lohika ng negosyo na may use cases at repository interfaces. Data Layer — mga pinagmumulan ng data: network (URLSession/Alamofire sa iOS, Retrofit/OkHttp sa Android), database (CoreData/SwiftData, Room), file system. Bawat layer ay gumagamit ng native na SDK — halimbawa, ang iOS aplikasyon ay maaaring tumawag sa CoreLocation para sa geolokasyon, CoreBluetooth para sa BLE, AVFoundation para sa camera, Metal para sa 3D graphics. Ang Android ay nag-aalok ng mga katumbas: FusedLocationProvider para sa geo, BluetoothAdapter para sa BLE, CameraX para sa camera, OpenGL ES/Vulkan para sa graphics.

Life cycle ng native app ay nag-iiba sa mga platform. Ang iOS ay gumagamit ng mahigpit na modelo na may AppDelegate at SceneDelegate: ang aplikasyon ay dumadaan sa mga estado notRunning → foregroundInactive → foregroundActive → background → suspended. Ang Android ay gumagamit ng mas flexible na modelo na may Activity at Fragment: onCreate → onStart → onResume → onPause → onStop → onDestroy, at ang mga proseso ay maaaring patayin ng system kapag kulang ang memorya. Dapat na tamang hawakan ng developer ang pag-save ng estado (iOS: state restoration, Android: onSaveInstanceState) para sa tuloy-tuloy na karanasan ng user.

Pag-develop ng iOS: Swift at Xcode

Pag-develop ng iOS ay eksklusibong ginagawa sa macOS sa Xcode environment — isang integrated development environment mula sa Apple, kasama ang code editor, Interface Builder, iOS simulator at mga profiling tool (Instruments). Ang pangunahing wika — Swift, ipinakilala ng Apple noong 2014. Ang Swift ay pinagsasama ang kaligtasan ng uri na may performance na malapit sa C at sumusuporta sa mga paradigma ng OOP, functional at protocol-oriented programming.

Mga pangunahing framework ng iOS:

• UIKit — pangunahing framework para sa pagbuo ng mga interface na may imperative approach (UIViewController, UIView, Auto Layout)
• SwiftUI — declarative framework (iOS 13+) na may @State, @Binding, @ObservedObject para sa reactive na pag-update ng UI
• Combine — reactive programming framework na may Publisher/Subscriber para sa pagproseso ng mga asynchronous na kaganapan
• CoreData / SwiftData — mga framework para sa persistent na pag-imbak ng data na may object graph at SQLite bilang base
• URLSession — native na HTTP client na may suporta para sa HTTP/2, caching at background downloads
• ARKit, CoreML, Vision — mga framework para sa AR, machine learning at computer vision sa device

Mga tool ng Xcode ay kinabibilangan ng: Interface Builder para sa visual na disenyo ng UI, Asset Catalog para sa pamamahala ng resources, Swift Package Manager para sa dependencies, Test Navigator para sa unit at UI tests (XCTest), Organizer para sa pag-publish sa App Store. Ang Instruments ay nagbibigay-daan sa profiling ng CPU, memorya, network, graphics at konsumo ng kuryente. Para sa CI/CD ay ginagamit ang Xcode Cloud o mga third-party na serbisyo (GitHub Actions, Bitrise, Fastlane).

Pag-develop ng Android: Kotlin at Android Studio

Pag-develop ng Android ay ginagawa sa Android Studio — IDE na batay sa IntelliJ IDEA mula sa Google. Ang pangunahing wika — Kotlin, na naging preperensya noong 2017. Ang Kotlin ay ganap na compatible sa Java, ngunit nag-aalok ng mas maikling syntax, null-safety sa pamamagitan ng elvis operator, coroutines para sa asynchrony at extension functions. Ang Android Studio ay may kasamang Layout Editor para sa visual na disenyo, Android emulator na may Google Play Services, APK Analyzer at Profiler.

Mga pangunahing component ng Android:

• Jetpack Compose — declarative UI framework (Android 5+) na may @Composable functions at reactive na estado sa pamamagitan ng mutableStateOf
• Android Views — klasikong imperative system na may XML markup, Activity, Fragment, RecyclerView
• Room — ORM library para sa SQLite na may compile-time na pagsusuri ng query at suporta sa Flow
• Retrofit + OkHttp — standard stack para sa HTTP requests na may interceptors, caching at suporta sa coroutine
• Hilt / Dagger — dependency injection frameworks (Dependency Injection) batay sa JSR-330
• WorkManager — API para sa mga delayed at background task na may garantiya ng execution kahit pagkatapos ng restart

Mga pattern ng arkitektura ng Android: Inirerekumenda ng Google ang MVVM na may Repository layer. Ang ViewModel ay nag-iimbak ng estado (StateFlow), ang Repository ay nag-aabstrak ng mga pinagmumulan ng data, ang Use Cases ay nag-e-encapsulate ng lohika ng negosyo. Ang Navigation Component ay namamahala ng mga transisyon sa pagitan ng mga screen sa pamamagitan ng navigation graph. Para sa pag-test ay ginagamit ang JUnit, MockK, Compose UI Test at Espresso.

Halimbawa ng code: Swift para sa iOS

Tingnan natin ang paggawa ng simpleng aplikasyon para sa iOS sa SwiftUI — isang listahan ng mga gawain na may pag-save ng data sa pamamagitan ng SwiftData. Ang aplikasyon ay nagpapakita ng mga pangunahing pattern ng native na iOS development: declarative UI, reactive na pag-update, pagtatrabaho sa data.

import SwiftUI
import SwiftData

// 1. Modelo ng data gamit ang 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 na may lohika ng negosyo
@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. Pangunahing screen ng aplikasyon
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("Bagong gawain")) {
                    HStack {
                        TextField("Ilagay ang pangalan", text: $newTaskTitle)
                        Button("Idagdag") {
                            addTask()
                        }
                        .disabled(newTaskTitle.isEmpty)
                    }
                }
                Section(header: Text("Listahan ng mga gawain")) {
                    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("Aking mga gawain")
        }
    }

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

Mga pangunahing pattern sa code: @Model — SwiftData macro para sa awtomatikong pagbuo ng persistent storage; @Observable — Observable macro para sa reactive na pag-update ng UI; @Query — property wrapper para sa awtomatikong pag-load ng data mula sa SwiftData. Ang aplikasyon ay gumagamit ng MVVM architecture na may ViewModel na namamahala ng lohika ng negosyo at SwiftUI View para sa pagpapakita. Awtomatikong nagse-save ang SwiftData ng data kapag nagbago ang model — hindi kailangang magsulat ng SQL queries ang developer.

Halimbawa ng code: Kotlin para sa Android

Katulad na aplikasyon para sa Android sa Kotlin na may Jetpack Compose at Room. Ipinapakita ang mga pagkakaiba sa arkitektura at approach sa pagitan ng mga platform.

// 1. Entity Room — modelo ng data
@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 — mga query sa database
@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 na may lohika ng negosyo
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("Aking mga gawain", style = MaterialTheme.typography.headlineMedium)

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

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

Mga pangunahing pagkakaiba mula sa iOS: Room ay gumagamit ng mga anotasyon na @Entity, @Dao at @Query para sa pagtatrabaho sa SQLite; ViewModel ay namamahala ng life cycle sa pamamagitan ng viewModelScope na may coroutines; StateFlow ay tinitiyak ang reactive na pag-update ng Compose UI sa pamamagitan ng collectAsState. Sa Android ang data ay ipinapadala sa pamamagitan ng Flow — katumbas ng Combine Publisher, ngunit may pagkansela sa pagpapalit ng screen sa pamamagitan ng viewModelScope.

Mga kalamangan at kahinaan ng native app

Mga kalamangan ng native app kumpara sa cross-platform na solusyon ay may ilang pangunahing aspeto. Performance: direktang access sa GPU sa pamamagitan ng Metal (iOS) at Vulkan (Android) ay nagbibigay ng 60 fps sa kumplikadong animation. Access sa API: mga bagong feature ng iOS at Android ay available sa araw ng paglabas, nang hindi naghihintay ng suporta sa framework. Karanasan ng user: ang mga native na UI component (NavigationStack, TabView, Sheet sa iOS; Scaffold, NavigationBar, BottomSheet sa Android) ay tinitiyak ang pamilyar na behavior. Konsumo ng kuryente: ang native na code ay kumokonsumo ng 15–25% mas kaunting baterya sa mga background task.

Mga kahinaan ng native app: gastos ng pag-develop 1.5–2 beses na mas mataas dahil sa pangangailangan ng dalawang hiwalay na koponan. Ang oras ng paglabas sa merkado ay tumataas: dalawang parallel na pag-develop ay nangangailangan ng koordinasyon at nagdodoble ng dami ng pag-test. Suporta: ang mga update ay kailangang ilabas para sa parehong platform nang sabay-sabay, na nagpapakomplikado ng CI/CD. Para sa mga simpleng aplikasyon (catalog, feeds, forms) ang cross-platform na solusyon ay maaaring mas matipid at mas mabilis.

Kailan pumili ng native app: mga laro at aplikasyon na may masinsinang graphics (Metal, Vulkan, ARKit, ARCore); mga aplikasyon na may malalim na integrasyon sa OS (Bluetooth LE, NFC, CoreBluetooth, HealthKit, Google Fit); mga pinansyal, medikal at korporatibong aplikasyon na may mga kinakailangan sa seguridad at sertipikasyon; mga proyekto kung saan ang bawat millisecond ng pagkaantala ay kritikal (trading, streaming, video calls). Para sa MVP, startup at simpleng aplikasyon, ang cross-platform na pag-develop ay maaaring mas makatwirang pagpili.