Android 的修炼之道

┌──────────────────────────────────┐
│ 应用层：你的 App（四大组件）        │ ← 开发者在这里
│ Jetpack 库（ViewModel/Compose…）  │
├──────────────────────────────────┤
│ 应用框架层：AMS/WMS/ContentProvider│ ← 系统服务
├──────────────────────────────────┤
│ 系统运行库：ART（执行引擎）        │ ← Kotlin/Java 字节码在这跑
│        + 原生库（C/C++）          │
├──────────────────────────────────┤
│ Linux 内核：进程/内存/驱动         │ ← 地基
└──────────────────────────────────┘

【进程与沙箱（移动端和桌面最大的不同）】
  每个 App 一个进程 + 独立沙箱（互相隔离）
  系统内存不足 → 杀后台进程（按优先级：前台>可见>服务>后台）
  → 所以 App 要「保存状态」：进程可能随时被回收！

【Android 版本碎片化（永恒的痛）】
  系统版本多（Android 8~15+）、厂商定制多（MIUI/ColorOS…）
  → 适配是 Android 开发日常（第10站）

【ART vs JVM（第十四本对比）】
  桌面 Java：JVM 跑，一次编译到处运行
  Android：ART 跑，AOT 预编译到设备指令（更快启动）

【构建产物】
  .apk（安装包）/ .aab（上架用，Google Play 分包）

// Java: 一个简单的类要写一大坨
// public class User { private String name; ... getter/setter ... }

// Kotlin: data class 一行搞定
data class User(
    val id: Long,
    val name: String,
    val phone: String?          // 可空类型：可能为 null
)

// 空安全：编译器强制处理 null
fun greet(user: User?) {
    println(user?.name ?: "匿名用户")    // 空安全调用 + 兜底
    // user!!.name  // 强制非空（危险，少用）
}

// 扩展函数：给 String 加方法
fun String.isValidPhone(): Boolean =
    length == 11 && startsWith("1")

// 作用域函数
val name = user?.let { it.name } ?: "unknown"   // let：非空才执行
user?.apply { /* 在对象上下文里操作 */ }

// lambda：函数式（第一本老朋友）
val adults = users.filter { it.age >= 18 }
                 .map { it.name }

【Kotlin 与 Java 关系】
  互操作：Kotlin 能调 Java 库，Java 也能调 Kotlin
  编译：都编译成 JVM 字节码（Android 上由 ART 执行）
  趋势：新项目 Kotlin 是默认，Java 老项目继续维护

【协程预告（第7站）】
  suspend fun fetchData() = withContext(Dispatchers.IO) { ... }
  → 挂起不阻塞，比线程轻 1000 倍

用户打开 App
   ↓
onCreate（创建：初始化 UI/数据）——只调一次
   ↓
onStart（可见：还没可交互）
   ↓
onResume（可交互：前台焦点）── 返回 ──┐
   ↓                                   │
onPause（失去焦点：弹窗/来电话）        │
   ↓                                   │
onStop（不可见：切后台）──────────────┤
   ↓                                   │
onDestroy（销毁：进程被回收/用户关闭）   │
   → 系统可能随时回收后台进程（第1站）────┘

【为什么生命周期重要】
  旋转屏幕 → Activity 销毁重建 → 数据要保存（onSaveInstanceState）
  切后台 → 音乐 Service 继续播（Service 的用武之地）
  内存不足 → 系统杀后台 → 回来要恢复状态

【Kotlin 实现（简化）】
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent { ... }        // Compose UI（第4站）
    }
    override fun onSaveInstanceState(outState: Bundle) {
        outState.putString("note", currentNote)   // 保存状态
        super.onSaveInstanceState(outState)
    }
}

【Service 类型】
  前台服务（有通知，用户看得见——播放器）
  后台服务（WorkManager 管理——约束触发，现代推荐）

【Intent 三兄弟】
  显式 Intent：指定目标组件（App 内跳转）
  隐式 Intent：描述动作，系统匹配（打开网页/分享）
  PendingIntent：留待将来执行的 Intent（通知点击）

@Composable
fun OrderListScreen(viewModel: OrderViewModel) {
    val orders by viewModel.orders.collectAsState()   // 状态订阅

    LazyColumn {                                      // 虚拟化列表
        items(orders) { order ->
            OrderCard(order)                          // 每行一个卡片
        }
    }
}

@Composable
fun OrderCard(order: Order) {
    Card(elevation = 4.dp, modifier = Modifier.padding(8.dp)) {
        Row(Modifier.padding(16.dp)) {
            Column(Modifier.weight(1f)) {
                Text(order.title, style = MaterialTheme.typography.titleMedium)
                Text("¥${order.amount}", color = MaterialTheme.colorScheme.primary)
            }
            Icon(Icons.Default.Add, contentDescription = null)
        }
    }
}

// 状态驱动：点一下按钮，界面自动更新
@Composable
fun Counter() {
    var count by remember { mutableStateOf(0) }      // 状态
    Button(onClick = { count++ }) {
        Text("点击了 $count 次")                       // 状态变 → 自动重组
    }
}

【Compose vs 老 View 体系】
  老（XML + findViewById）：手动找控件、手动更新——代码多
  Compose：声明式函数 + 状态自动驱动——代码少、好维护
  → 新项目 Compose 是默认，老项目 View 继续维护

【UI 组件速查】
  布局：Column / Row / Box（线性/横向/层叠）
  常用：Text / Button / Card / Icon / Image
  列表：LazyColumn / LazyRow（虚拟化）
  主题：MaterialTheme（颜色/字体/形状统一）

// ① Retrofit：接口声明（自动发请求 + 解析 JSON）
interface LedgerApi {
    @GET("api/orders")
    suspend fun getOrders(): List<Order>      // 协程挂起函数

    @POST("api/orders")
    suspend fun createOrder(@Body order: Order): Order
}

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.ledger.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build()

// ② Room：本地数据库
@Entity
data class OrderEntity(
    @PrimaryKey val id: Long,
    val title: String,
    val amount: Double,
)

@Dao
interface OrderDao {
    @Query("SELECT * FROM orders")
    fun observeAll(): Flow<List<OrderEntity>>    // Flow 观察变化

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun upsert(orders: List<OrderEntity>)
}

// ③ Repository：统一数据入口（缓存优先）
class OrderRepository(
    private val api: LedgerApi,
    private val dao: OrderDao,
) {
    val orders: Flow<List<OrderEntity>> = dao.observeAll()

    suspend fun refresh() {
        val remote = api.getOrders()              // 拉网络
        dao.upsert(remote.map { it.toEntity() })  // 存本地
        // 界面观察 dao → 自动更新（缓存优先架构）
    }
}

【数据流设计】
  界面 → ViewModel → Repository → (网络/数据库)
  离线可用：先读 Room 缓存 → 后台刷新 → 界面自动更新
  → 和第十六本 Repository 模式一模一样！

// ① UI 层：Compose 只做展示和转发
@Composable
fun OrderScreen(viewModel: OrderViewModel) {
    val uiState by viewModel.uiState.collectAsState()
    when (val s = uiState) {
        is Loading -> CircularProgressIndicator()
        is Success -> OrderList(s.orders, onRefresh = viewModel::refresh)
        is Error   -> Text("出错了：${s.message}")
    }
}

// ② ViewModel：状态 + 业务逻辑（旋转不销毁！）
class OrderViewModel(
    private val repo: OrderRepository,
) : ViewModel() {
    val uiState: StateFlow<UiState> = repo.orders
        .map { UiState.Success(it) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(), Loading)

    fun refresh() = viewModelScope.launch { repo.refresh() }
}

// ③ Hilt：依赖注入（不用手动 new！）
@HiltViewModel
class OrderViewModel @Inject constructor(
    private val repo: OrderRepository,
) : ViewModel()

【MVVM 数据流（单向）】
  用户操作 → ViewModel（改状态）→ UI 自动更新
  → 逻辑不写 UI 里、状态不散落在界面——好测、好维护

【为什么 ViewModel 重要】
  旋转屏幕 Activity 重建——ViewModel 存活，数据不丢
  进程被系统杀了（第1站）——ViewModel 也能配合 SavedState 恢复

【WorkManager 场景】
  上传日志（延迟+联网才跑）、每日提醒、数据库清理
  → 系统调度，省电，App 被杀也会补跑

// 错误示范：主线程发网络请求 → 卡死 + ANR！
// 正确姿势：挂起函数 + 切换调度器

class OrderRepository(private val api: LedgerApi) {

    // suspend：可挂起的网络请求（Retrofit 原生支持）
    suspend fun fetchOrders(): List<Order> =
        withContext(Dispatchers.IO) {        // IO 线程跑网络
            api.getOrders()
        }
}

// ViewModel 里调用（自动在主线程安全更新 UI）
class OrderViewModel(private val repo: OrderRepository) : ViewModel() {
    fun load() = viewModelScope.launch {    // 主线程作用域
        val orders = repo.fetchOrders()      // 自动切 IO，回来切 Main
        uiState.value = UiState.Success(orders)   // UI 更新安全
    }
}

// Flow：响应式数据流
val latestOrders: Flow<List<Order>> = flow {
    while (true) {
        emit(repo.fetchOrders())             // 每 30 秒发一次
        delay(30_000)
    }
}.flowOn(Dispatchers.IO)                     // 上游在 IO 跑

【协程 vs 线程（第十六本老朋友）】
  线程：重量级（1 个线程 ≈ 1MB 栈）——几万个就爆
  协程：轻量级（挂起不占线程）——几十万个都行
  → Android 默认用协程（asyncio 的 Kotlin 版）

【结构化并发】
  viewModelScope：界面销毁 → 协程自动取消 → 不泄漏
  SupervisorJob：子协程失败不影响兄弟

【ANR 预防】
  主线程只做 UI——超过 5 秒不响应 = ANR（第9站）

【Gradle 配置（build.gradle.kts）】
plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
}

android {
    namespace = "com.ledger.app"
    compileSdk = 35                 // 编译版本（对应 Android 15）
    defaultConfig {
        applicationId = "com.ledger.app"
        minSdk = 24                 // 最低支持 Android 7.0
        targetSdk = 35              // 目标版本（上架要求新）
        versionCode = 12            // 版本号（更新递增）
        versionName = "2.1.0"       // 版本名（给用户看）
    }
    buildTypes {
        release {
            isMinifyEnabled = true  // R8 混淆压缩
        }
    }
}

【构建命令】
  ./gradlew assembleDebug     # 调试包（可直接安装）
  ./gradlew assembleRelease   # 发布包（签名+混淆）
  ./gradlew bundleRelease     # aab（Google Play 上架用）

【签名（保命）】
  生成：keytool / Android Studio 生成 keystore
  保管：丢了 = 以后无法更新同一个 App！
  国内商店要签名 + 部分要软著证书

【国内上架流程（简化）】
  准备：隐私政策 + 软著 + 应用截图 + 签名包
  提交各商店（华为/小米/OPPO/vivo/腾讯应用宝…）
  审核（隐私合规是重灾区，第10站）
  发布后：版本更新、崩溃监控（第9站）

【版本适配提示】
  targetSdk 必须跟随最新（商店强制要求）
  minSdk 决定覆盖多少设备（24 = 覆盖 95%+）

// ① 单元测试：ViewModel 业务逻辑
@Test
fun `订单金额格式化正确`() {
    val vm = OrderViewModel(mockRepo)
    assertEquals("¥1,299.00", vm.formatAmount(1299.00))
}

// ② UI 测试（Compose Test）
@get:Rule
val composeRule = createComposeRule()

@Test
fun `点击按钮列表更新`() {
    composeRule.setContent { Counter() }
    composeRule.onNodeWithText("点击了 0 次").assertExists()
    composeRule.onNodeWithText("点击了 0 次").performClick()
    composeRule.onNodeWithText("点击了 1 次").assertExists()
}

【性能三巨头（移动端特有）】
  ANR：主线程 5 秒无响应 → 系统弹「应用无响应」
    预防：主线程只做 UI；重活走协程 IO（第7站）
  冷启动：点击图标到首帧——目标 < 2 秒
    优化：启动任务异步化、延迟初始化、启动页
  内存泄漏：Activity 被持有不释放 → OOM
    检测：LeakCanary 自动定位泄漏点

【崩溃监控（Crashlytics）】
  集成 SDK → 用户崩溃自动上报
  → 崩溃率看板 + 堆栈定位 + 版本对比
  → 发布后盯三天：崩溃率 > 0.5% 要紧急修复

【发布质量门槛】
  单元测试覆盖率 > 60%（核心逻辑 100%）
  无内存泄漏告警（LeakCanary 全绿）
  崩溃率 < 0.5%（新版本观察期）
  启动 < 2 秒 / 掉帧率 < 5%

【运行时权限（Kotlin 简版）】
if (ContextCompat.checkSelfPermission(this, CAMERA) != GRANTED) {
    requestPermissions(arrayOf(CAMERA), 100)   // 弹窗申请
} else {
    openCamera()
}
// 用户拒绝 → 引导去设置页 / 功能降级（别硬来）

【版本适配策略】
  用 AndroidX/Jetpack 兼容库（自动处理 90% 差异）
  targetSdk 跟上最新（商店强制 + 新行为适配）
  老版本降级：功能检测（Build.VERSION.SDK_INT）按需分支

【屏幕适配】
  单位用 dp（密度无关）/ sp（文字）——别用 px！
  Compose 自适应布局（BoxWithConstraints / 窗口尺寸）
  多资源：values-sw600dp（平板）/ values-night（深色模式）

【隐私合规清单（上架生死线）】
  □ 隐私政策在应用内可查 + 首次弹窗告知
  □ 权限最小化（不申请用不到的权限！）
  □ 收集数据要「告知-同意」+ 提供删除渠道（第八本）
  □ 敏感权限（通讯录/位置）用途说明
  □ SDK 合规（第三方 SDK 也要审——不合规被通报）

【数据安全（第7本老朋友）】
  HTTPS 全链路（明文流量默认禁止）
  敏感数据加密存储（EncryptedSharedPreferences）
  WebView 安全（禁用 file 访问、白名单域名）