Native App: khái niệm chính, phát triển native iOS và Android

Native App là gì

Native App — ứng dụng di động được phát triển riêng cho một nền tảng bằng ngôn ngữ lập trình và công cụ native của nó. Đối với iOS là Swift hoặc Objective-C với Xcode, đối với Android là Kotlin hoặc Java với Android Studio. Mã nguồn được biên dịch trực tiếp thành mã máy của nền tảng (qua LLVM cho iOS, ART cho Android), đảm bảo tốc độ thực thi tối đa.

Kiến trúc ứng dụng native bao gồm ba lớp. Lớp trình bày — thành phần UI (UIKit/SwiftUI trên iOS, Jetpack Compose/Android Views trên Android). Lớp miền — logic nghiệp vụ với các use case và giao diện kho lưu trữ. Lớp dữ liệu — nguồn dữ liệu: mạng (URLSession/Alamofire trên iOS, Retrofit/OkHttp trên Android), cơ sở dữ liệu (CoreData/SwiftData, Room), hệ thống tệp. Mỗi lớp sử dụng SDK native — ví dụ, ứng dụng iOS có thể gọi CoreLocation cho định vị, CoreBluetooth cho BLE, AVFoundation cho camera, Metal cho đồ họa 3D. Android cung cấp các giải pháp thay thế tương tự: FusedLocationProvider cho định vị, BluetoothAdapter cho BLE, CameraX cho camera, OpenGL ES/Vulkan cho đồ họa.

Vòng đời của native app khác nhau giữa các nền tảng. iOS sử dụng mô hình nghiêm ngặt với AppDelegate và SceneDelegate: ứng dụng trải qua các trạng thái notRunning → foregroundInactive → foregroundActive → background → suspended. Android sử dụng mô hình linh hoạt hơn với Activity và Fragment: onCreate → onStart → onResume → onPause → onStop → onDestroy, và các tiến trình có thể bị hệ thống kết thúc khi thiếu bộ nhớ. Nhà phát triển phải xử lý lưu trạng thái đúng cách (iOS: khôi phục trạng thái, Android: onSaveInstanceState) để có trải nghiệm người dùng liền mạch.

Phát triển iOS: Swift và Xcode

Phát triển iOS được thực hiện độc quyền trên macOS trong môi trường Xcode — môi trường phát triển tích hợp của Apple bao gồm trình soạn thảo mã, Interface Builder, trình giả lập iOS và các công cụ phân tích (Instruments). Ngôn ngữ chính là Swift, được Apple giới thiệu vào năm 2014. Swift kết hợp an toàn kiểu dữ liệu với hiệu suất gần bằng C và hỗ trợ các mô hình lập trình hướng đối tượng, chức năng và hướng giao thức.

Các framework chính của iOS:

• UIKit — framework chính để xây dựng giao diện với cách tiếp cận mệnh lệnh (UIViewController, UIView, Auto Layout)
• SwiftUI — framework khai báo (iOS 13+) với @State, @Binding, @ObservedObject để cập nhật UI phản ứng
• Combine — framework lập trình phản ứng với Publisher/Subscriber để xử lý sự kiện bất đồng bộ
• CoreData / SwiftData — framework lưu trữ dữ liệu bền vững với đồ thị đối tượng và SQLite nền
• URLSession — trình khách HTTP native với hỗ trợ HTTP/2, bộ nhớ đệm và tải xuống nền
• ARKit, CoreML, Vision — framework cho AR, học máy và thị giác máy tính trên thiết bị

Công cụ Xcode bao gồm: Interface Builder để thiết kế UI trực quan, Asset Catalog để quản lý tài nguyên, Swift Package Manager cho phụ thuộc, Test Navigator cho kiểm thử đơn vị và UI (XCTest), Organizer để xuất bản lên App Store. Instruments cho phép phân tích CPU, bộ nhớ, mạng, đồ họa và mức tiêu thụ năng lượng. Cho CI/CD, sử dụng Xcode Cloud hoặc dịch vụ bên thứ ba (GitHub Actions, Bitrise, Fastlane).

Phát triển Android: Kotlin và Android Studio

Phát triển Android được thực hiện trong Android Studio — IDE dựa trên IntelliJ IDEA của Google. Ngôn ngữ chính là Kotlin, trở thành lựa chọn ưu tiên vào năm 2017. Kotlin tương thích hoàn toàn với Java nhưng cung cấp cú pháp ngắn gọn hơn, an toàn null qua toán tử Elvis, coroutine cho bất đồng bộ và hàm mở rộng. Android Studio bao gồm Trình chỉnh sửa bố cục cho thiết kế trực quan, trình giả lập Android với Google Play Services, APK Analyzer và Profiler.

Các thành phần chính của Android:

• Jetpack Compose — framework UI khai báo (Android 5+) với hàm @Composable và trạng thái phản ứng qua mutableStateOf
• Android Views — hệ thống mệnh lệnh cổ điển với bố cục XML, Activity, Fragment, RecyclerView
• Room — thư viện ORM cho SQLite với xác minh truy vấn tại thời điểm biên dịch và hỗ trợ Flow
• Retrofit + OkHttp — ngăn xếp tiêu chuẩn cho yêu cầu HTTP với bộ chặn, bộ nhớ đệm và hỗ trợ coroutine
• Hilt / Dagger — framework tiêm phụ thuộc dựa trên JSR-330
• WorkManager — API cho tác vụ trì hoãn và nền với đảm bảo thực thi ngay cả sau khi khởi động lại

Mẫu kiến trúc Android: Google khuyến nghị MVVM với lớp Kho lưu trữ. ViewModel lưu trữ trạng thái (StateFlow), Repository trừu tượng hóa nguồn dữ liệu, Use Cases đóng gói logic nghiệp vụ. Navigation Component quản lý chuyển đổi giữa các màn hình qua đồ thị điều hướng. Để kiểm thử, sử dụng JUnit, MockK, Compose UI Test và Espresso.

Ví dụ mã: Swift cho iOS

Hãy xem xét việc tạo một ứng dụng iOS đơn giản trong SwiftUI — danh sách tác vụ với lưu trữ dữ liệu qua SwiftData. Ứng dụng minh họa các mẫu phát triển native iOS chính: UI khai báo, cập nhật phản ứng, quản lý dữ liệu.

import SwiftUI
import SwiftData

// 1. Mô hình dữ liệu với 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 với logic nghiệp vụ
@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. Màn hình chính của ứng dụng
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("Nhiệm vụ mới")) {
                    HStack {
                        TextField("Nhập tên", text: $newTaskTitle)
                        Button("Thêm") {
                            addTask()
                        }
                        .disabled(newTaskTitle.isEmpty)
                    }
                }
                Section(header: Text("Danh sách nhiệm vụ")) {
                    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("Nhiệm vụ của tôi")
        }
    }

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

Các mẫu chính trong mã: @Model — macro SwiftData để tự động tạo bộ lưu trữ bền vững; @Observable — macro Observable để cập nhật UI phản ứng; @Query — trình bao bọc thuộc tính để tự động tải dữ liệu từ SwiftData. Ứng dụng sử dụng kiến trúc MVVM với ViewModel quản lý logic nghiệp vụ và View SwiftUI để hiển thị. SwiftData tự động lưu dữ liệu khi mô hình thay đổi — nhà phát triển không cần viết truy vấn SQL.

Ví dụ mã: Kotlin cho Android

Ứng dụng Android tương tự trong Kotlin với Jetpack Compose và Room. Cho thấy sự khác biệt về kiến trúc và cách tiếp cận giữa các nền tảng.

// 1. Entity Room — mô hình dữ liệu
@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 — truy vấn cơ sở dữ liệu
@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 với logic nghiệp vụ
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("Nhiệm vụ của tôi", style = MaterialTheme.typography.headlineMedium)

        Row(
            modifier = Modifier.fillMaxWidth().padding(vertical = 8.dp)
        ) {
            OutlinedTextField(
                value = newTitle,
                onValueChange = { newTitle = it },
                label = { Text("Nhiệm vụ mới") },
                modifier = Modifier.weight(1f)
            )
            Button(
                onClick = { viewModel.addTask(newTitle); newTitle = "" },
                enabled = newTitle.isNotBlank()
            ) {
                Text("Thêm")
            }
        }

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

Sự khác biệt chính so với iOS: Room sử dụng chú thích @Entity, @Dao và @Query để làm việc với SQLite; ViewModel quản lý vòng đời qua viewModelScope với coroutine; StateFlow cung cấp cập nhật Compose UI phản ứng qua collectAsState. Trên Android, dữ liệu được truyền qua Flow — tương tự Combine Publisher, nhưng có hủy bỏ khi chuyển màn hình qua viewModelScope.

Ưu điểm và nhược điểm của Native App

Ưu điểm của native app so với giải pháp đa nền tảng bao gồm một số khía cạnh chính. Hiệu suất: truy cập GPU trực tiếp qua Metal (iOS) và Vulkan (Android) mang lại 60 fps trong hoạt ảnh phức tạp. Truy cập API: tính năng mới của iOS và Android có sẵn ngày phát hành, không cần chờ hỗ trợ framework. Trải nghiệm người dùng: thành phần UI native (NavigationStack, TabView, Sheet trên iOS; Scaffold, NavigationBar, BottomSheet trên Android) mang lại hành vi quen thuộc. Hiệu quả năng lượng: mã native tiêu thụ ít hơn 15–25% pin trong tác vụ nền.

Nhược điểm của native app: chi phí phát triển cao gấp 1,5–2 lần do cần hai nhóm riêng biệt. Thời gian tiếp cận thị trường tăng lên: hai quá trình phát triển song song đòi hỏi sự phối hợp và nhân đôi khối lượng kiểm thử. Bảo trì: bản cập nhật phải được phát hành đồng thời cho cả hai nền tảng, làm phức tạp CI/CD. Đối với ứng dụng đơn giản (danh mục, nguồn cấp dữ liệu, biểu mẫu), giải pháp đa nền tảng có thể kinh tế và nhanh hơn.

Khi nào chọn native app: trò chơi và ứng dụng đồ họa nặng (Metal, Vulkan, ARKit, ARCore); ứng dụng tích hợp sâu với hệ điều hành (Bluetooth LE, NFC, CoreBluetooth, HealthKit, Google Fit); ứng dụng tài chính, y tế và doanh nghiệp có yêu cầu bảo mật và chứng nhận; dự án mà mỗi mili giây độ trễ đều quan trọng (giao dịch, phát trực tuyến, gọi video). Đối với MVP, startup và ứng dụng đơn giản, phát triển đa nền tảng có thể là lựa chọn hợp lý hơn.