Android: nó là gì, kiến trúc hệ thống và phát triển bằng Kotlin

Android là gì?

Android là hệ điều hành di động dựa trên nhân Linux, được Google phát triển từ năm 2007. Mã nguồn được mở theo giấy phép Apache 2.0 trong khuôn khổ dự án Android Open Source Project (AOSP). Mỗi nhà sản xuất có thể sửa đổi hệ thống và cài đặt trên thiết bị của mình.

Theo StatCounter (2026), Android chiếm khoảng 72% thị trường hệ điều hành di động toàn cầu. Các nhà sản xuất lớn nhất là Samsung, Xiaomi, Oppo, Vivo, Google Pixel. Phân mảnh là vấn đề chính của nền tảng: hàng nghìn mẫu máy với các phiên bản hệ điều hành khác nhau được sử dụng đồng thời.

Kiến trúc Android được xây dựng trên nguyên tắc quyền (permissions): mỗi ứng dụng chạy dưới một UID Linux riêng biệt và chỉ có quyền truy cập vào dữ liệu của chính nó. Quyền truy cập vào tài nguyên hệ thống (camera, micrô, danh bạ) được yêu cầu thông qua Android Permissions trong thời gian chạy, bắt đầu từ Android 6 (API 23).

Lịch sử phiên bản Android

Android 1.0 được phát hành vào năm 2008 trên HTC Dream. Các cột mốc quan trọng: Android 4.0 Ice Cream Sandwich (giao diện thống nhất cho điện thoại và máy tính bảng), Android 5.0 Lollipop (Material Design), Android 6.0 (quyền runtime), Android 10 (chủ đề tối, cử chỉ), Android 12 (Material You). Từ năm 2023, Google đã chuyển sang phát hành chính hàng năm không có tên món tráng miệng.

Kiến trúc Android: bốn lớp chính

Kiến trúc Android bao gồm bốn lớp chính cách ly phần cứng khỏi các ứng dụng người dùng. Mỗi lớp sử dụng dịch vụ của lớp bên dưới thông qua các giao diện được xác định chặt chẽ.

Nhân Linux và HAL

Lớp dưới cùng là nhân Linux đã được sửa đổi (LTS, phiên bản 6.x trong Android 15). Nó quản lý bộ nhớ, tiến trình, ngăn xếp mạng và trình điều khiển. Lớp trừu tượng hóa phần cứng (HAL) cung cấp API thống nhất để tương tác với phần cứng: camera, Bluetooth, Wi-Fi, cảm biến. Các nhà sản xuất triển khai mô-đun HAL mà không ảnh hưởng đến các lớp trên.

Android Runtime (ART)

ART thực thi mã bytecode DEX của ứng dụng. Bắt đầu từ Android 5.0, ART đã thay thế Dalvik và sử dụng biên dịch Ahead-of-Time (AOT) để cải thiện hiệu suất. Mỗi ứng dụng có tiến trình riêng với một phiên bản ART riêng biệt. Bộ thu gom rác (GC) hoạt động với thời gian tạm dừng tối thiểu — thời gian tạm dừng GC điển hình là 2–4 ms.

Application Framework

Framework là lớp mà nhà phát triển làm việc trực tiếp. Nó bao gồm Activity Manager (ngăn xếp màn hình), Content Providers (truy cập dữ liệu), Resource Manager (bản địa hóa, tài nguyên), Notification Manager, Location Manager. Tất cả các dịch vụ hệ thống được gọi thông qua Binder IPC — cơ chế giao tiếp liên tiến trình của Android.

// Ví dụ làm việc với Binder qua giao diện AIDL
interface IDataService : android.os.IInterface {
    fun getData(): List<DataItem>
    fun saveData(item: DataItem): Boolean
}

// Triển khai dịch vụ
class DataService : Service() {
    private val binder = object : IDataService.Stub() {
        override fun getData(): List<DataItem> = repository.getAll()
        override fun saveData(item: DataItem): Boolean = repository.save(item)
    }

    override fun onBind(intent: Intent?): IBinder = binder
}

Ứng dụng hệ thống

Lớp trên cùng bao gồm các ứng dụng hệ thống tiêu chuẩn: Điện thoại, Danh bạ, Camera, Cài đặt, Trình duyệt. Chúng không có đặc quyền cao hơn ứng dụng người dùng, nhưng có thể được thay thế bằng ứng dụng của bên thứ ba. Trong Android 15, các ứng dụng hệ thống được cập nhật thông qua Google Play System Updates độc lập với các bản cập nhật OTA của nhà sản xuất.

Kotlin — ngôn ngữ phát triển Android chính

Kotlin là ngôn ngữ lập trình tĩnh của JetBrains chạy trên JVM. Google đã công bố Kotlin là ngôn ngữ chính thức của Android vào năm 2017 tại Google I/O. Kotlin hoàn toàn tương thích với Java nhưng loại bỏ các nhược điểm của nó: an toàn null, lớp dữ liệu, hàm mở rộng và coroutine.

An toàn Null và kiểu dữ liệu

Tính năng chính của Kotlin là bảo vệ tích hợp chống NullPointerException. Các kiểu được chia thành nullable (String?) và non-null (String). Trình biên dịch kiểm tra quyền truy cập nullable tại thời điểm biên dịch. Toán tử safe call (?.) và toán tử Elvis (?:) đơn giản hóa việc làm việc với các giá trị tùy chọn mà không cần kiểm tra lồng nhau.

// Ví dụ mã Kotlin với coroutine và Flow
data class User(
    val id: Long,
    val name: String,
    val email: String
)

class UserRepository(
    private val api: UserApi,
    private val dao: UserDao
) {
    suspend fun getUser(id: Long): Result<User> {
        return try {
            val cached = dao.getUser(id)
            if (cached != null) {
                return Result.success(cached)
            }
            val remote = api.fetchUser(id)
            dao.insertUser(remote)
            Result.success(remote)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }

    fun observeUsers(): Flow<List<User>> {
        return dao.observeAll()
            .map { list -> list.sortedBy { it.name } }
            .flowOn(Dispatchers.Default)
    }
}

Ví dụ minh họa coroutine (hàm suspend) để truy cập mạng và cơ sở dữ liệu bất đồng bộ, Flow để quan sát phản ứng các thay đổi dữ liệu và Result để xử lý lỗi an toàn. Coroutine thay thế callback và RxJava mà không có chi phí luồng.

Coroutine Kotlin và Flow

Coroutine Kotlin là các luồng nhẹ chạy trên một nhóm luồng dùng chung. Dispatchers.IO cho mạng và đĩa, Dispatchers.Main cho UI, Dispatchers.Default cho các tác vụ tốn CPU. viewModelScope và lifecycleScope tự động hủy coroutine khi thành phần bị hủy.

// ViewModel với coroutine và StateFlow
class UserViewModel(
    private val repository: UserRepository
) : ViewModel() {

    private val _users = MutableStateFlow<List<User>>(emptyList())
    val users: StateFlow<List<User>> = _users.asStateFlow()

    private val _loading = MutableStateFlow(false)
    val loading: StateFlow<Boolean> = _loading.asStateFlow()

    init {
        viewModelScope.launch {
            repository.observeUsers().collect { userList ->
                _users.value = userList
            }
        }
    }

    fun refresh() {
        viewModelScope.launch {
            _loading.value = true
            repository.getUser(42).onSuccess { user ->
                _users.value = listOf(user)
            }
            _loading.value = false
        }
    }
}

Android Studio và công cụ phát triển

Android Studio là IDE chính thức dựa trên IntelliJ IDEA, do Google phát triển. Nó bao gồm trình soạn thảo mã, Layout Inspector, trình giả lập thiết bị, APK Analyzer, Profiler (CPU, Bộ nhớ, Mạng, Năng lượng) và tích hợp Firebase. Android Studio 2024 (Ladybug) hỗ trợ Kotlin 2.0 với chế độ đa nền tảng KMP.

Trình giả lập Android

Trình giả lập Android sử dụng KVM (Linux) hoặc Hyper-V (Windows) để tăng tốc phần cứng. Nó hỗ trợ mô phỏng GPS, cảm biến, camera, cuộc gọi và SMS. Google Pixel 9 Pro là cấu hình được khuyến nghị để kiểm thử với API 35 và 8 GB RAM giả lập.

Android Profiler và gỡ lỗi

Profiler hiển thị thời gian thực tải CPU, cấp phát bộ nhớ, yêu cầu mạng và mức tiêu thụ năng lượng. Memory Profiler cho phép kết xuất heap và phân tích rò rỉ thông qua cây tham chiếu. Network Inspector ghi lại tất cả các yêu cầu HTTP/HTTPS với nội dung và tiêu đề. Để phân tích chuyên sâu, Android Studio Canary được sử dụng.

Thành phần của ứng dụng Android

Ứng dụng Android bao gồm bốn loại thành phần, mỗi loại có điểm vào và vòng đời riêng. Các thành phần được đăng ký trong tệp AndroidManifest.xml.

Activity và Intent

Activity là thành phần cơ bản của giao diện người dùng. Mỗi màn hình là một Activity riêng biệt hoặc một Fragment trong Activity. Điều hướng giữa các màn hình được thực hiện thông qua Intent — một đối tượng chứa hành động (ACTION_VIEW, ACTION_SEND) và dữ liệu (URI). Trong Jetpack Navigation Graph, điều hướng được mô tả bằng XML.

Service và WorkManager

Service thực thi các tác vụ nền, nhưng từ Android 8, các dịch vụ nền bị hạn chế. WorkManager là thư viện được khuyến nghị cho các tác vụ nền bị trì hoãn và được đảm bảo với hỗ trợ chuỗi, ràng buộc (ví dụ: chỉ khi sạc) và khởi động lại sau sự cố.

Jetpack Compose so với XML Layouts

Lựa chọn giữa Jetpack Compose và bố cục XML truyền thống là quyết định kiến trúc chính khi bắt đầu dự án Android. XML Layouts (RecyclerView, ConstraintLayout, FrameLayout) là tiêu chuẩn từ năm 2008. Jetpack Compose được giới thiệu vào năm 2021 như một giải pháp thay thế khai báo.

Google khuyến nghị Jetpack Compose cho tất cả các dự án mới. XML Layouts vẫn phù hợp để hỗ trợ các dự án kế thừa và cho các trường hợp cần tùy chỉnh View tối đa (Canvas, SurfaceView). Mã Compose trung bình ngắn hơn 40% so với XML + ViewBinding tương đương.

// Jetpack Compose — màn hình hồ sơ người dùng
@Composable
fun ProfileScreen(
    user: User,
    onEditClick: () -> Unit,
    modifier: Modifier = Modifier
) {
    Column(
        modifier = modifier
            .fillMaxSize()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        AsyncImage(
            model = user.avatarUrl,
            contentDescription = "Ảnh đại diện người dùng",
            modifier = Modifier
                .size(120.dp)
                .clip(CircleShape)
        )

        Spacer(modifier = Modifier.height(16.dp))

        Text(
            text = user.name,
            style = MaterialTheme.typography.headlineMedium
        )

        Text(
            text = user.email,
            style = MaterialTheme.typography.bodyLarge,
            color = MaterialTheme.colorScheme.onSurfaceVariant
        )

        Spacer(modifier = Modifier.height(24.dp))

        Button(onClick = onEditClick) {
            Icon(Icons.Default.Edit, contentDescription = null)
            Spacer(modifier = Modifier.width(8.dp))
            Text("Chỉnh sửa hồ sơ")
        }
    }
}

@Preview(showBackground = true, showSystemUi = true)
@Composable
fun ProfileScreenPreview() {
    MaterialTheme {
        ProfileScreen(
            user = User(1, "Anna Petrova", "anna@example.com"),
            onEditClick = {}
        )
    }
}

Hàm ProfileScreen được khai báo là @Composable — nó mô tả UI một cách khai báo mà không tạo phiên bản View. Compose tự động cập nhật màn hình khi user thay đổi. @Preview hiển thị kết quả trực tiếp trong IDE mà không cần xây dựng và chạy trên trình giả lập.

Vòng đời của Activity và Fragment

Mỗi Activity trong Android trải qua sáu trạng thái vòng đời: onCreate, onStart, onResume, onPause, onStop, onDestroy. Fragment thêm onAttach, onCreateView, onViewCreated. Hiểu vòng đời rất quan trọng để quản lý bộ nhớ và ngăn ngừa rò rỉ.

Các trạng thái chính của Activity

onCreate — được gọi một lần khi Activity được tạo. Quá trình khởi tạo được thực hiện ở đây: setContentView, thiết lập bộ điều hợp, đăng ký LiveData. onResume — Activity ở nền trước và tương tác với người dùng. onPause — Activity mất tiêu điểm (hộp thoại, Activity khác). onStop — Activity không hiển thị. onDestroy — Activity bị hủy.

// Activity với xử lý vòng đời qua LifecycleScope
class MainActivity : ComponentActivity() {
    private val viewModel: UserViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContent {
            MaterialTheme {
                lifecycleScope.launch {
                    repeatOnLifecycle(Lifecycle.State.STARTED) {
                        viewModel.users.collect { users ->
                            updateUi(users)
                        }
                    }
                }
            }
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putString("last_search", searchQuery)
    }

    override fun onRestoreInstanceState(savedInstanceState: Bundle) {
        super.onRestoreInstanceState(savedInstanceState)
        searchQuery = savedInstanceState.getString("last_search", "")
    }
}

Sử dụng repeatOnLifecycle đảm bảo rằng việc thu thập dữ liệu tạm dừng khi Activity vào nền và tiếp tục khi quay lại nền trước. Điều này ngăn ngừa rò rỉ và các yêu cầu mạng không cần thiết. onSaveInstanceState lưu trạng thái tạm thời khi xoay màn hình.

Google Play: xuất bản và yêu cầu

Google Play là cửa hàng ứng dụng Android chính thức. Đăng ký tài khoản nhà phát triển có phí $25 một lần. Mỗi ứng dụng trải qua quá trình kiểm tra tự động Google Play Integrity để phát hiện mã độc, vi phạm chính sách và sử dụng quyền không đúng.

Yêu cầu xuất bản

Google yêu cầu ký ứng dụng thông qua Android App Bundle (AAB) hoặc APK. AAB là định dạng được khuyến nghị, cho phép tạo APK được tối ưu hóa cho từng cấu hình thiết bị. Ứng dụng phải được ký bằng khóa (keystore) với chứng chỉ hợp lệ. Google Play App Signing là mã hóa khóa tùy chọn phía Google.

Chính sách bảo mật

Tất cả các ứng dụng yêu cầu quyền truy cập dữ liệu cá nhân phải cung cấp Chính sách bảo mật. Từ năm 2024, Google yêu cầu khai báo Data Safety — một biểu mẫu chỉ định loại dữ liệu được thu thập và mục đích xử lý. Các ứng dụng nhắm mục tiêu Android 14+ phải sử dụng API Declarations để khai báo quyền.