Android 代碼架構通常包括四個主要層次：應用層、框架層、原生層和 Linux 內核層。下面我們用 mermaid 圖來表示：

結合這個圖示來詳細闡述 Android 代碼架構：

1. 應用層（Application Layer）：

   • 這是用戶直接接觸的層面，包括系統自帶的應用程序（如聯絡人、簡訊、相機等）和第三方應用程序（如微信、淘寶等）。
   • 應用層使用 Java 或 Kotlin 語言編寫，運行在 Android 運行時（ART）上。

2. 框架層（Framework Layer）：

   • 框架層為應用層提供了大量的 API，使開發者能夠快速開發應用程序。框架層包含了各種管理器和服務，例如：
     • Activity Manager：管理應用程序的生命週期和活動棧。
     • Window Manager：管理窗口程序。
     • Content Providers：管理應用程序間數據共享。
     • View System：構建用戶界面的基本元件。
     • Notification Manager：管理通知。
     • Package Manager：管理應用程序包。
     • Telephony Manager：管理移動設備功能。
     • Resource Manager：管理非代碼資源（如圖片、字串等）。
     • Location Manager：管理位置服務。
     • XMPP Service：管理即時通訊服務。
   • 框架層主要使用 Java 語言編寫。

3. 原生層（Native Layer）：

   • 原生層包括原生 C/C++ 庫和 Android 運行時。
   • 原生 C/C++ 庫：包括一系列 C/C++ 庫，如 OpenGL ES、Webkit、SQLite 等，這些庫為 Android 系統提供了底層的功能支持。
   • Android 運行時：包括 Dalvik 虛擬機和 ART。從 Android 5.0 開始，ART 取代了 Dalvik 虛擬機。ART 在應用安裝時將字節碼轉換為機器碼，提高了應用的運行效率。
   • 原生層還包含了硬體抽象層（HAL），它提供了標準介面，使得框架層能夠與硬體設備進行通信，而無需關心底層驅動實現。

4. Linux 內核層（Linux Kernel Layer）：

   • Android 基於 Linux 內核，但增加了一些特定的驅動和功能，如電源管理、進程管理等。
   • 該層包含了各種硬體驅動，如顯示驅動、攝影機驅動、藍牙驅動、USB 驅動、按鍵區驅動、WiFi 驅動、音頻驅動等。
   • Linux 內核層還負責系統安全、記憶體管理、進程管理、網路協議棧等。

除了上述層次，Android 架構中還包含了一些重要的元件和概念，如：

• 四大元件：Activity、Service、BroadcastReceiver、ContentProvider。
• Intent：用於在元件之間傳遞訊息。
• Binder：Android 中的一種跨進程通訊（IPC）機制。
• Handler：用於線程間通訊，特別是在主線程（UI 線程）和子線程之間。
• View 和 ViewGroup：構建用戶界面的基礎。
• 資源管理：如何管理圖片、字串、佈局等資源。
• 清單文件（AndroidManifest.xml） ：聲明元件、權限等。

一、Android 代碼架構演進與核心思想

Android 應用架構的核心思想是分離關注點 和 數據驅動 UI。架構的演進是為了讓代碼更易於測試、維護和團隊協作。

1. MVC：早期模式，但在 Android 中，Activity/Fragment 經常承擔了 Controller 和 View 的雙重角色，導致它們過於臃腫。
2. MVP：引入了 Presenter 層，將 UI 邏輯從 Activity/Fragment 中抽離出來，大大改善了可測試性。
3. MVVM：當前主流和官方推薦的架構。它利用數據綁定和生命週期感知元件，實現了數據與 UI 的自動同步，進一步減少了模板代碼。

二、現代 Android 應用架構詳解

下面我們以 MVVM 為核心，結合 Jetpack 元件，來剖析一個完整的、現代的 Android 應用架構。

三個核心層以及它們之間的依賴關係：UI 層 -> 領域層 -> 數據層。數據流是單向的。

三、各層核心技術詳解與代碼示例

1. UI 層

職責：在螢幕上顯示應用數據，並處理用戶互動。

核心技術：

• Activity / Fragment：UI 的容器，負責處理系統互動和生命週期。
• Jetpack Compose：現代首選的聲明式 UI 工具包，用 Kotlin 代碼構建介面。
• View System：傳統的基於 XML 的 UI 系統。
• ViewModel：架構核心，為 UI 準備和管理數據。它能在配置變更（如螢幕旋轉）後存活。
• LiveData / StateFlow：可觀察的數據持有者。StateFlow 是 Kotlin 協程中的現代選擇，與 Compose 配合極佳。
• DataBinding / ViewBinding：用於將 UI 元件與數據源綁定。

代碼示例 (Compose + ViewModel + StateFlow)：

// 1. ViewModel
class MainViewModel(
    private val getPostsUseCase: GetPostsUseCase // 使用用例
) : ViewModel() {

    // UI 狀態使用 StateFlow 暴露
    private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()

    init {
        loadPosts()
    }

    private fun loadPosts() {
        viewModelScope.launch {
            _uiState.value = UiState.Loading
            try {
                val posts = getPostsUseCase()
                _uiState.value = UiState.Success(posts)
            } catch (e: Exception) {
                _uiState.value = UiState.Error(e.message ?: "未知錯誤")
            }
        }
    }
}

// 密封類（Sealed Class）用來表示所有可能的 UI 狀態
sealed class UiState {
    object Loading : UiState()
    data class Success(val posts: List<Post>) : UiState()
    data class Error(val message: String) : UiState()
}

// 2. Composable UI
@Composable
fun MainScreen(
    viewModel: MainViewModel = hiltViewModel() // 使用 Hilt 依賴注入獲取 ViewModel
) {
    val uiState by viewModel.uiState.collectAsState()

    when (val state = uiState) {
        is UiState.Loading -> {
            CircularProgressIndicator()
        }
        is UiState.Success -> {
            LazyColumn {
                items(state.posts) { post ->
                    PostItem(post = post)
                }
            }
        }
        is UiState.Error -> {
            Text(text = "錯誤: ${state.message}", color = Color.Red)
        }
    }
}

@Composable
fun PostItem(post: Post) {
    Card(
        modifier = Modifier
            .fillMaxWidth()
            .padding(8.dp)
    ) {
        Column(modifier = Modifier.padding(16.dp)) {
            Text(text = post.title, fontWeight = FontWeight.Bold)
            Spacer(modifier = Modifier.height(4.dp))
            Text(text = post.body)
        }
    }
}

2. 領域層

職責：封裝複雜的商業邏輯，或組合多個 Repository 的調用。它是一個可選層，但對於複雜商業邏輯非常有用，可以使代碼更清晰、可重用。

核心技術：

• Use Cases / Interactors：每個 UseCase 應該只負責一個單一的商業功能。

代碼示例：

// 獲取帖子列表的用例
class GetPostsUseCase(
    private val postsRepository: PostsRepository
) {
    // 使用‘operator invoke’可以讓調用像函數一樣簡單：useCase()
    suspend operator fun invoke(): List<Post> {
        // 在這裡可以添加商業邏輯，比如過濾、排序等
        return postsRepository.getPosts()
    }
}

// 另一個例子：刷新帖子數據的用例
class RefreshPostsUseCase(
    private val postsRepository: PostsRepository
) {
    suspend operator fun invoke() {
        postsRepository.refreshPosts()
    }
}

3. 數據層

職責：管理應用的數據，包括來自網路、本地數據庫等多種數據源。它提供單一的數據入口給上層。

核心技術：

• Repository：架構核心，是資料的唯一來源。它決定從網路還是本地數據庫獲取數據，並處理快取策略。
• Room：SQLite 的物件映射庫，用於本地數據持久化。
• Retrofit：類型安全的 HTTP 客戶端，用於訪問網路 API。
• WorkManager：管理後台任務。
• Paging Library：分頁加載數據。

代碼示例：

// 1. Data Class (Entity)
@Entity(tableName = "posts")
data class Post(
    @PrimaryKey val id: Int,
    val title: String,
    val body: String
)

// 2. Retrofit API Interface
interface PostsApiService {
    @GET("posts")
    suspend fun getPosts(): List<Post>
}

// 3. Room Dao (Data Access Object)
@Dao
interface PostDao {
    @Query("SELECT * FROM posts")
    fun getPosts(): Flow<List<Post>>

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertAll(posts: List<Post>)
}

// 4. Repository 實現
class DefaultPostsRepository(
    private val apiService: PostsApiService,
    private val postDao: PostDao,
    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO
) : PostsRepository {

    // 對外暴露一個 Flow，這樣 UI 可以持續觀察數據庫的變化
    override fun getPosts(): Flow<List<Post>> {
        return postDao.getPosts()
    }

    // 刷新策略：網路優先，失敗則使用快取
    override suspend fun refreshPosts() {
        withContext(ioDispatcher) {
            try {
                val posts = apiService.getPosts()
                postDao.insertAll(posts)
            } catch (e: Exception) {
                // 處理網路錯誤，例如拋出錯誤狀態或使用快取
                throw e
            }
        }
    }
}

四、依賴注入 - 架構的黏合劑

為什麼重要：它管理著類之間的依賴關係，使得代碼更鬆散耦合、更易測試。

核心技術：

• Hilt：官方推薦的基於 Dagger 的 DI 庫，極大簡化了 Android 上的 DI 配置。

代碼示例：

// 1. 使用 Hilt 定義依賴
@Module
@InstallIn(SingletonComponent::class)
object AppModule {

    @Provides
    @Singleton
    fun providePostsApiService(): PostsApiService {
        return Retrofit.Builder()
            .baseUrl("https://jsonplaceholder.typicode.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(PostsApiService::class.java)
    }

    @Provides
    @Singleton
    fun providePostDatabase(@ApplicationContext context: Context): PostDatabase {
        return Room.databaseBuilder(
            context,
            PostDatabase::class.java,
            "posts.db"
        ).build()
    }
}

@Module
@InstallIn(ViewModelComponent::class)
object UseCaseModule {
    @Provides
    fun provideGetPostsUseCase(repository: PostsRepository): GetPostsUseCase {
        return GetPostsUseCase(repository)
    }
}

// 2. 在 ViewModel 中使用 Hilt 注入
@HiltViewModel
class MainViewModel @Inject constructor(
    private val getPostsUseCase: GetPostsUseCase // Hilt 自動注入
) : ViewModel() { ... }

五、如何掌握

遵循一個由淺入深、理論與實踐結合的路徑：

第一階段：基礎入門

1. Kotlin 語言：掌握基礎語法、數據類、密封類、擴展函數、Lambda 表達式。
2. Android 基礎：Activity/Fragment 生命週期、常用佈局和控件。
3. 構建第一個 App：一個簡單的靜態介面 App。

第二階段：核心架構與非同步編程

1. ViewModel & LiveData/StateFlow：理解為何要使用它們，並在專案中實踐。
2. Coroutines：重中之重！理解協程的作用，掌握 launch、async、flow 等基本概念。
3. Room：學習本地數據庫操作。
4. Retrofit：學習網路請求。
5. 專案實踐：構建一個簡單的“待辦事項”或“新聞閱讀” App，使用以上所有技術，實現數據的增刪改查。

第三階段：進階與現代化工具

1. Jetpack Compose：開始學習聲明式 UI。從基礎元件和狀態管理入手。
2. Hilt：在之前的專案中引入 Hilt，管理所有依賴。
3. Repository 模式：重構你的“新聞閱讀” App，明確分離數據層和 UI 層。

第四階段：精通與最佳實踐

1. Use Cases：在更複雜的專案中引入領域層。
2. Paging 3.0：學習列表分頁。
3. Navigation：學習應用內頁面導航。
4. Testing：為 ViewModel、Repository、UseCase 編寫單元測試，為 UI 編寫儀器測試。
5. 關注官方資源：
   • Android Developers 官網：有最權威的指南和文檔。
   • Now in Android：Google 官方示例專案，展示了所有最新最佳實踐。
   • Google Codelabs：提供手把手的免費教程。

總結

現代 Android 架構是一個圍繞 MVVM、分層設計、單向數據流 和 響應式編程 構建的生態系統。核心技術棧是 Kotlin + Jetpack (ViewModel, Room, Compose) + Coroutines/Flow + Hilt。

從簡單開始，然後逐步將學到的每一項新技術應用到專案中，不斷重構和優化你的代碼結構。通過實踐，才能真正理解和掌握這套強大的架構。

原文出處：https://juejin.cn/post/7555780704271319059