Native App: แนวคิดหลัก, การพัฒนาเนทีฟ iOS และ Android

Native App คืออะไร

Native App — แอปพลิเคชันมือถือที่พัฒนาเฉพาะสำหรับแพลตฟอร์มเดียวโดยใช้ภาษาโปรแกรมและเครื่องมือดั้งเดิมของแพลตฟอร์มนั้น สำหรับ iOS คือ Swift หรือ Objective-C กับ Xcode สำหรับ Android คือ Kotlin หรือ Java กับ Android Studio โค้ดจะถูกคอมไพล์โดยตรงเป็นโค้ดเครื่องของแพลตฟอร์ม (ผ่าน LLVM สำหรับ iOS, ART สำหรับ Android) ซึ่งรับประกันความเร็วในการทำงานสูงสุด

สถาปัตยกรรมของแอปเนทีฟ ประกอบด้วยสามชั้น ชั้นการนำเสนอ — ส่วนประกอบ UI (UIKit/SwiftUI บน iOS, Jetpack Compose/Android Views บน Android) ชั้นโดเมน — ตรรกะทางธุรกิจพร้อม use case และอินเทอร์เฟซพื้นที่เก็บข้อมูล ชั้นข้อมูล — แหล่งข้อมูล: เครือข่าย (URLSession/Alamofire บน iOS, Retrofit/OkHttp บน Android), ฐานข้อมูล (CoreData/SwiftData, Room), ระบบไฟล์ แต่ละชั้นใช้ SDK ดั้งเดิม — ตัวอย่างเช่น แอป iOS สามารถเรียก CoreLocation สำหรับตำแหน่งทางภูมิศาสตร์, CoreBluetooth สำหรับ BLE, AVFoundation สำหรับกล้อง, Metal สำหรับกราฟิก 3D Android มีตัวเลือกที่คล้ายกัน: FusedLocationProvider สำหรับตำแหน่ง, BluetoothAdapter สำหรับ BLE, CameraX สำหรับกล้อง, OpenGL ES/Vulkan สำหรับกราฟิก

วงจรชีวิตของ native app แตกต่างกันตามแพลตฟอร์ม iOS ใช้โมเดลที่เข้มงวดกับ AppDelegate และ SceneDelegate: แอปผ่านสถานะ notRunning → foregroundInactive → foregroundActive → background → suspended Android ใช้โมเดลที่ยืดหยุ่นกว่ากับ Activity และ Fragment: onCreate → onStart → onResume → onPause → onStop → onDestroy และกระบวนการสามารถถูกฆ่าโดยระบบเมื่อหน่วยความจำไม่เพียงพอ นักพัฒนาต้องจัดการการบันทึกสถานะอย่างถูกต้อง (iOS: การคืนค่าสถานะ, Android: onSaveInstanceState) เพื่อประสบการณ์ผู้ใช้ที่ต่อเนื่อง

การพัฒนา iOS: Swift และ Xcode

การพัฒนา iOS ทำบน macOS ในสภาพแวดล้อม Xcode เท่านั้น — สภาพแวดล้อมการพัฒนาแบบบูรณาการของ Apple ที่ประกอบด้วยตัวแก้ไขโค้ด, Interface Builder, จำลอง iOS และเครื่องมือวิเคราะห์ประสิทธิภาพ (Instruments) ภาษาหลักคือ Swift ซึ่ง Apple เปิดตัวในปี 2014 Swift ผสานความปลอดภัยของประเภทกับประสิทธิภาพที่ใกล้เคียงกับ C และรองรับกระบวนทัศน์การเขียนโปรแกรมเชิงวัตถุ เชิงฟังก์ชัน และเชิงโปรโตคอล

เฟรมเวิร์กหลักของ iOS:

• UIKit — เฟรมเวิร์กหลักสำหรับสร้างอินเทอร์เฟสด้วยแนวทางเชิงคำสั่ง (UIViewController, UIView, Auto Layout)
• SwiftUI — เฟรมเวิร์กเชิงประกาศ (iOS 13+) ที่มี @State, @Binding, @ObservedObject สำหรับการอัปเดต UI แบบรีแอกทีฟ
• Combine — เฟรมเวิร์กการเขียนโปรแกรมแบบรีแอกทีฟที่มี Publisher/Subscriber สำหรับจัดการเหตุการณ์แบบอะซิงโครนัส
• CoreData / SwiftData — เฟรมเวิร์กสำหรับจัดเก็บข้อมูลถาวรด้วยกราฟวัตถุและ SQLite เป็นพื้นฐาน
• URLSession — ไคลเอนต์ HTTP ดั้งเดิมที่รองรับ HTTP/2, แคชชิง และดาวน์โหลดพื้นหลัง
• ARKit, CoreML, Vision — เฟรมเวิร์กสำหรับ AR, การเรียนรู้ของเครื่อง และคอมพิวเตอร์วิทัศน์บนอุปกรณ์

เครื่องมือ Xcode ประกอบด้วย: Interface Builder สำหรับออกแบบ UI ด้วยภาพ, Asset Catalog สำหรับจัดการทรัพยากร, Swift Package Manager สำหรับการพึ่งพา, Test Navigator สำหรับการทดสอบหน่วยและการทดสอบ UI (XCTest), Organizer สำหรับเผยแพร่บน App Store Instruments ช่วยให้วิเคราะห์ CPU, หน่วยความจำ, เครือข่าย, กราฟิก และการใช้พลังงาน สำหรับ CI/CD ใช้ Xcode Cloud หรือบริการของบุคคลที่สาม (GitHub Actions, Bitrise, Fastlane)

การพัฒนา Android: Kotlin และ Android Studio

การพัฒนา Android ทำใน Android Studio — IDE ที่ใช้ IntelliJ IDEA ของ Google ภาษาหลักคือ Kotlin ซึ่งกลายเป็นตัวเลือกที่ต้องการในปี 2017 Kotlin เข้ากันได้กับ Java อย่างสมบูรณ์ แต่มีไวยากรณ์ที่กระชับกว่า, null-safety ผ่าน Elvis โอเปอเรเตอร์, coroutine สำหรับอะซิงโครนัส และฟังก์ชันส่วนขยาย Android Studio ประกอบด้วย Layout Editor สำหรับออกแบบด้วยภาพ, จำลอง Android ที่มี Google Play Services, APK Analyzer และ Profiler

ส่วนประกอบหลักของ Android:

• Jetpack Compose — เฟรมเวิร์ก UI เชิงประกาศ (Android 5+) ที่มีฟังก์ชัน @Composable และสถานะรีแอกทีฟผ่าน mutableStateOf
• Android Views — ระบบเชิงคำสั่งแบบคลาสสิกที่มีเค้าโครง XML, Activity, Fragment, RecyclerView
• Room — ไลบรารี ORM สำหรับ SQLite ที่มีการตรวจสอบคิวรีในเวลาคอมไพล์และรองรับ Flow
• Retrofit + OkHttp — สแต็กมาตรฐานสำหรับคำขอ HTTP ที่มีตัวสกัดกั้น, แคชชิง และรองรับ coroutine
• Hilt / Dagger — เฟรมเวิร์กการฉีดการพึ่งพาที่ใช้ JSR-330
• WorkManager — API สำหรับงานที่เลื่อนออกไปและงานพื้นหลังที่รับประกันการทำงานแม้หลังจากรีบูต

รูปแบบสถาปัตยกรรม Android: Google แนะนำ MVVM กับชั้น Repository ViewModel เก็บสถานะ (StateFlow), Repository ทำให้แหล่งข้อมูลเป็นนามธรรม, Use Cases ห่อหุ้มตรรกะทางธุรกิจ Navigation Component จัดการการเปลี่ยนระหว่างหน้าจอผ่านกราฟนำทาง สำหรับการทดสอบใช้ JUnit, MockK, Compose UI Test และ Espresso

ตัวอย่างโค้ด: Swift สำหรับ iOS

มาดูการสร้างแอป iOS ง่าย ๆ ใน SwiftUI — รายการงานที่จัดเก็บข้อมูลผ่าน SwiftData แอปแสดงรูปแบบการพัฒนาเนทีฟ iOS ที่สำคัญ: UI เชิงประกาศ, การอัปเดตแบบรีแอกทีฟ, การจัดการข้อมูล

import SwiftUI
import SwiftData

// 1. โมเดลข้อมูลด้วย 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 พร้อมตรรกะทางธุรกิจ
@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. หน้าจอหลักของแอป
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("งานใหม่")) {
                    HStack {
                        TextField("ป้อนชื่อ", text: $newTaskTitle)
                        Button("เพิ่ม") {
                            addTask()
                        }
                        .disabled(newTaskTitle.isEmpty)
                    }
                }
                Section(header: Text("รายการงาน")) {
                    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("งานของฉัน")
        }
    }

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

รูปแบบสำคัญในโค้ด: @Model — มาโคร SwiftData สำหรับสร้างพื้นที่จัดเก็บถาวรโดยอัตโนมัติ; @Observable — มาโคร Observable สำหรับการอัปเดต UI แบบรีแอกทีฟ; @Query — ตัวห่อคุณสมบัติสำหรับโหลดข้อมูลจาก SwiftData โดยอัตโนมัติ แอปใช้สถาปัตยกรรม MVVM โดยมี ViewModel จัดการตรรกะทางธุรกิจ และ SwiftUI View สำหรับการแสดงผล SwiftData บันทึกข้อมูลโดยอัตโนมัติเมื่อโมเดลเปลี่ยนแปลง — นักพัฒนาไม่จำเป็นต้องเขียนคิวรี SQL

ตัวอย่างโค้ด: Kotlin สำหรับ Android

แอป Android ที่คล้ายกันใน Kotlin กับ Jetpack Compose และ Room แสดงความแตกต่างในสถาปัตยกรรมและแนวทางระหว่างแพลตฟอร์ม

// 1. Entity Room — โมเดลข้อมูล
@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 — คิวรีฐานข้อมูล
@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 พร้อมตรรกะทางธุรกิจ
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("งานของฉัน", style = MaterialTheme.typography.headlineMedium)

        Row(
            modifier = Modifier.fillMaxWidth().padding(vertical = 8.dp)
        ) {
            OutlinedTextField(
                value = newTitle,
                onValueChange = { newTitle = it },
                label = { Text("งานใหม่") },
                modifier = Modifier.weight(1f)
            )
            Button(
                onClick = { viewModel.addTask(newTitle); newTitle = "" },
                enabled = newTitle.isNotBlank()
            ) {
                Text("เพิ่ม")
            }
        }

        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: Room ใช้คำอธิบายประกอบ @Entity, @Dao และ @Query สำหรับทำงานกับ SQLite; ViewModel จัดการวงจรชีวิตผ่าน viewModelScope กับ coroutine; StateFlow ให้การอัปเดต Compose UI แบบรีแอกทีฟผ่าน collectAsState บน Android ข้อมูลถูกส่งผ่าน Flow — คล้ายกับ Combine Publisher แต่มีการยกเลิกเมื่อเปลี่ยนหน้าจอผ่าน viewModelScope

ข้อดีและข้อเสียของ Native App

ข้อดีของ native app เมื่อเทียบกับโซลูชันข้ามแพลตฟอร์มรวมถึงหลายประเด็นสำคัญ ประสิทธิภาพ: การเข้าถึง GPU โดยตรงผ่าน Metal (iOS) และ Vulkan (Android) ให้ 60 fps ในแอนิเมชันที่ซับซ้อน การเข้าถึง API: คุณสมบัติใหม่ของ iOS และ Android พร้อมใช้งานในวันที่วางจำหน่าย โดยไม่ต้องรอการสนับสนุนในเฟรมเวิร์ก ประสบการณ์ผู้ใช้: ส่วนประกอบ UI ดั้งเดิม (NavigationStack, TabView, Sheet บน iOS; Scaffold, NavigationBar, BottomSheet บน Android) ให้พฤติกรรมที่คุ้นเคย ประสิทธิภาพพลังงาน: โค้ดเนทีฟใช้แบตเตอรี่น้อยกว่า 15–25% ในงานพื้นหลัง

ข้อเสียของ native app: ต้นทุนการพัฒนาสูงกว่า 1.5–2 เท่าเนื่องจากต้องมีทีมแยกกันสองทีม เวลาออกสู่ตลาดเพิ่มขึ้น: การพัฒนาแบบขนานสองชุดต้องการการประสานงานและเพิ่มปริมาณการทดสอบเป็นสองเท่า การบำรุงรักษา: การอัปเดตต้องเผยแพร่สำหรับทั้งสองแพลตฟอร์มพร้อมกัน ทำให้ CI/CD ซับซ้อน สำหรับแอปง่าย ๆ (แคตตาล็อก, ฟีด, ฟอร์ม) โซลูชันข้ามแพลตฟอร์มอาจประหยัดและเร็วกว่า

เมื่อใดควรเลือก native app: เกมและแอปที่มีกราฟิกเข้มข้น (Metal, Vulkan, ARKit, ARCore); แอปที่มีการรวมเข้ากับระบบปฏิบัติการอย่างลึกซึ้ง (Bluetooth LE, NFC, CoreBluetooth, HealthKit, Google Fit); แอปทางการเงิน การแพทย์ และองค์กรที่มีข้อกำหนดด้านความปลอดภัยและการรับรอง; โปรเจกต์ที่ทุกมิลลิวินาทีของความหน่วงมีความสำคัญ (การซื้อขาย, การสตรีม, การสนทนาทางวิดีโอ) สำหรับ MVP, สตาร์ทอัพ และแอปง่าย ๆ การพัฒนาแบบข้ามแพลตฟอร์มอาจเป็นทางเลือกที่สมเหตุสมผลกว่า