Context 上下文体系

// Context 抽象类的核心方法签名（简化版）
// 这些方法定义了"上下文"的能力契约
abstract class Context {
    // ========== 资源访问 ==========
    // 获取资源管理器，用于读取 res 目录下的所有资源
    abstract fun getResources(): Resources
    // 获取资产管理器，用于读取 assets 目录下的原始文件
    abstract fun getAssets(): AssetManager
    // 获取包名，即 AndroidManifest.xml 中声明的 package 属性
    abstract fun getPackageName(): String
    // 获取应用信息，包含 versionCode、targetSdkVersion 等元数据
    abstract fun getApplicationInfo(): ApplicationInfo
    
    // ========== 组件启动 ==========
    // 启动 Activity，intent 中包含目标组件信息和传递数据
    abstract fun startActivity(intent: Intent)
    // 启动前台/后台服务
    abstract fun startService(intent: Intent): ComponentName?
    // 发送广播，可指定权限或限定接收者
    abstract fun sendBroadcast(intent: Intent)
    
    // ========== 系统服务 ==========
    // 获取系统服务的统一入口，name 参数如 Context.WINDOW_SERVICE
    abstract fun getSystemService(name: String): Any?
    
    // ========== 文件存储 ==========
    // 获取应用私有文件目录：/data/data/<pkg>/files/
    abstract fun getFilesDir(): File
    // 获取应用缓存目录：/data/data/<pkg>/cache/
    abstract fun getCacheDir(): File
    // 打开或创建 SharedPreferences 文件
    abstract fun getSharedPreferences(name: String, mode: Int): SharedPreferences
    
    // ========== 主题与样式 ==========
    // 获取当前上下文关联的主题，Activity 会返回其配置的 Theme
    abstract fun getTheme(): Resources.Theme
    // 设置主题资源 ID
    abstract fun setTheme(resId: Int)
}

// ContextWrapper 的核心实现逻辑
// 它是一个"透传层"，默认将所有调用委托给内部持有的 mBase
open class ContextWrapper(
    // mBase 是被装饰的原始 Context，通常是 ContextImpl 实例
    private var mBase: Context?
) : Context() {
    
    // 获取被装饰的基础 Context
    // 这个方法在调试和某些框架场景下很有用
    fun getBaseContext(): Context? = mBase
    
    // 关联基础 Context，通常在组件创建时由系统调用
    // 注意：attachBaseContext 只能调用一次，重复调用会抛出异常
    protected open fun attachBaseContext(base: Context) {
        if (mBase != null) {
            // 防止重复绑定，这是一个安全检查
            throw IllegalStateException("Base context already set")
        }
        mBase = base
    }
    
    // ========== 以下方法全部委托给 mBase ==========
    
    override fun getResources(): Resources {
        // 直接转发给基础 Context
        return mBase!!.getResources()
    }
    
    override fun getPackageName(): String {
        // 直接转发给基础 Context
        return mBase!!.getPackageName()
    }
    
    override fun startActivity(intent: Intent) {
        // 直接转发给基础 Context
        mBase!!.startActivity(intent)
    }
    
    override fun getSystemService(name: String): Any? {
        // 直接转发给基础 Context
        return mBase!!.getSystemService(name)
    }
    
    // ... 其他 100+ 个方法同样采用委托模式 ...
}

// 装饰器链示例：多层 ContextWrapper 嵌套
// 实际开发中可用于测试 Mock 或插件化资源替换
class LoggingContextWrapper(base: Context) : ContextWrapper(base) {
    // 重写 startActivity，添加日志记录功能
    override fun startActivity(intent: Intent) {
        // 在原有功能基础上添加日志
        Log.d("ContextWrapper", "Starting activity: ${intent.component}")
        // 调用父类方法，继续委托链
        super.startActivity(intent)
    }
}
 
class ThemeOverrideWrapper(base: Context) : ContextWrapper(base) {
    // 重写 getTheme，强制返回自定义主题
    override fun getTheme(): Resources.Theme {
        // 可以在这里实现动态主题切换逻辑
        return customTheme
    }
}
 
// 使用方式：形成装饰链
// originalContext -> ThemeOverrideWrapper -> LoggingContextWrapper
val wrappedContext = LoggingContextWrapper(ThemeOverrideWrapper(originalContext))

// ContextImpl 的核心成员变量（简化版源码分析）
// 注意：这是系统隐藏类，应用层无法直接访问
class ContextImpl private constructor() : Context() {
    
    // ========== 核心成员变量 ==========
    
    // ActivityThread 是应用进程的主线程管理者
    // 它负责调度四大组件的生命周期回调
    private lateinit var mMainThread: ActivityThread
    
    // LoadedApk 封装了 APK 的加载信息
    // 包括 ClassLoader、资源路径、so 库路径等
    private lateinit var mPackageInfo: LoadedApk
    
    // Resources 对象，用于访问 res 目录下的资源
    // 每个 ContextImpl 可能持有不同配置的 Resources 实例
    private var mResources: Resources? = null
    
    // 应用私有文件的根目录
    // 通常是 /data/data/<package_name>/
    private var mBasePackagePath: String? = null
    
    // 当前上下文关联的主题
    private var mTheme: Resources.Theme? = null
    
    // ContentResolver 用于访问 ContentProvider
    private var mContentResolver: ContentResolver? = null
    
    // ========== 方法实现示例 ==========
    
    override fun getResources(): Resources {
        // 返回当前上下文的资源管理器
        // 不同 Context 可能返回不同配置的 Resources
        return mResources!!
    }
    
    override fun getSystemService(name: String): Any? {
        // 系统服务的获取通过 SystemServiceRegistry 完成
        // 它维护了服务名称到服务获取器的映射表
        return SystemServiceRegistry.getSystemService(this, name)
    }
    
    override fun startActivity(intent: Intent) {
        // 检查是否需要添加 FLAG_ACTIVITY_NEW_TASK
        // 非 Activity 的 Context 启动 Activity 必须带此 Flag
        if (intent.flags and Intent.FLAG_ACTIVITY_NEW_TASK == 0) {
            // 如果当前不是 Activity Context，需要强制添加 NEW_TASK 标志
            // 否则系统不知道该把新 Activity 放入哪个任务栈
            throw AndroidRuntimeException(
                "Calling startActivity() from outside of an Activity context " +
                "requires the FLAG_ACTIVITY_NEW_TASK flag."
            )
        }
        // 通过 Instrumentation 转发给 AMS
        mMainThread.instrumentation.execStartActivity(
            this, null, null, null, intent, -1, null
        )
    }
    
    override fun getSharedPreferences(name: String, mode: Int): SharedPreferences {
        // SharedPreferences 文件存储在 /data/data/<pkg>/shared_prefs/ 目录
        // 系统会缓存已打开的 SP 实例，避免重复解析 XML
        val file = getSharedPreferencesPath(name)
        return SharedPreferencesImpl(file, mode)
    }
    
    // ========== 静态工厂方法 ==========
    
    companion object {
        // 创建 Application 的 Context
        // 在应用进程启动时由 ActivityThread 调用
        fun createAppContext(
            mainThread: ActivityThread,
            packageInfo: LoadedApk
        ): ContextImpl {
            return ContextImpl().apply {
                mMainThread = mainThread
                mPackageInfo = packageInfo
                mResources = packageInfo.resources
            }
        }
        
        // 创建 Activity 的 Context
        // 会额外配置主题和 Display 信息
        fun createActivityContext(
            mainThread: ActivityThread,
            packageInfo: LoadedApk,
            activityInfo: ActivityInfo,
            displayId: Int
        ): ContextImpl {
            return ContextImpl().apply {
                mMainThread = mainThread
                mPackageInfo = packageInfo
                // Activity 的 Resources 可能包含特定的配置覆盖
                mResources = createResources(displayId, packageInfo)
                // 应用 Activity 声明的主题
                setTheme(activityInfo.themeResource)
            }
        }
    }
}

// ContextThemeWrapper 的核心实现
// 它在 ContextWrapper 基础上添加了主题管理能力
open class ContextThemeWrapper : ContextWrapper {
    
    // 主题资源 ID，如 R.style.AppTheme
    private var mThemeResource: Int = 0
    
    // 已解析的 Theme 对象，懒加载创建
    private var mTheme: Resources.Theme? = null
    
    // 可能被覆盖的 Resources 对象
    // 用于支持配置变更时的资源重建
    private var mResources: Resources? = null
    
    // 无参构造器，主题稍后通过 setTheme() 设置
    constructor() : super(null)
    
    // 带主题的构造器，常用于手动创建带特定主题的 Context
    constructor(base: Context, themeResId: Int) : super(base) {
        mThemeResource = themeResId
    }
    
    // 设置主题资源 ID
    // 如果 Theme 对象已创建，会立即应用新主题
    override fun setTheme(resId: Int) {
        mThemeResource = resId
        // 如果主题对象已存在，需要重新应用
        mTheme?.let { theme ->
            // applyStyle 会将新主题的属性合并到现有 Theme 中
            theme.applyStyle(resId, true)
        }
    }
    
    // 获取主题对象，懒加载模式
    override fun getTheme(): Resources.Theme {
        // 如果尚未创建，则初始化
        if (mTheme == null) {
            // 从 Resources 创建新的 Theme 对象
            mTheme = resources.newTheme().apply {
                // 首先继承父 Context 的主题（如果有）
                val parentTheme = baseContext?.theme
                if (parentTheme != null) {
                    setTo(parentTheme)
                }
                // 然后应用当前设置的主题资源
                if (mThemeResource != 0) {
                    applyStyle(mThemeResource, true)
                }
            }
        }
        return mTheme!!
    }
    
    // 获取资源对象
    // 可能返回被覆盖的 Resources 实例
    override fun getResources(): Resources {
        return mResources ?: super.getResources()
    }
    
    // 创建配置上下文
    // 用于处理配置变更（如屏幕旋转、语言切换）
    override fun createConfigurationContext(
        overrideConfiguration: Configuration
    ): Context {
        return ContextThemeWrapper(
            baseContext!!.createConfigurationContext(overrideConfiguration),
            mThemeResource
        )
    }
}

// Activity 继承自 ContextThemeWrapper
// 因此天然具备主题管理能力
class Activity : ContextThemeWrapper(), ... {
    
    // Activity 创建时，系统会自动设置主题
    // 这发生在 onCreate() 之前
    internal fun performCreate(savedInstanceState: Bundle?) {
        // 应用 Manifest 中声明的主题
        val themeRes = activityInfo.themeResource
        if (themeRes != 0) {
            setTheme(themeRes)
        }
        // 然后才调用 onCreate()
        onCreate(savedInstanceState)
    }
    
    // 开发者也可以在 onCreate() 中手动切换主题
    // 但必须在 setContentView() 之前调用
    override fun onCreate(savedInstanceState: Bundle?) {
        // 正确：在 setContentView 之前设置主题
        setTheme(R.style.CustomTheme)
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

// Dialog 使用 ContextThemeWrapper 管理主题
class AlertDialog private constructor(
    context: Context,
    themeResId: Int
) : Dialog(
    // 创建带主题的 Context
    // resolveDialogTheme 会解析默认对话框主题
    ContextThemeWrapper(context, resolveDialogTheme(context, themeResId))
) {
    // Dialog 内部的所有 View 都会使用这个带主题的 Context
    // 确保按钮、文字、背景等样式一致
}
 
// 使用示例：创建带自定义主题的对话框
val dialog = AlertDialog.Builder(this, R.style.MyDialogTheme)
    .setTitle("提示")
    .setMessage("这是一个自定义主题的对话框")
    .create()

// attachBaseContext 的正确使用方式
class MainActivity : AppCompatActivity() {
    
    // 重写 attachBaseContext 实现多语言切换
    override fun attachBaseContext(newBase: Context) {
        // 在这里可以包装 Context 以修改配置
        val localeContext = LocaleHelper.wrap(newBase, "zh-CN")
        // 必须调用 super，否则 mBase 不会被设置
        super.attachBaseContext(localeContext)
        
        // 注意：此时 Activity 的其他成员尚未初始化
        // 不要在这里访问 View 或其他依赖 onCreate 的对象
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 此时 Context 已完全就绪，可以正常使用
        setContentView(R.layout.activity_main)
    }
}

// 不同 Context 的能力对比示例
class ContextCapabilityDemo {
    
    // Application Context：全局可用，但 UI 能力受限
    fun demonstrateApplicationContext(app: Application) {
        // ✅ 可以：获取资源
        val appName = app.getString(R.string.app_name)
        
        // ✅ 可以：获取系统服务
        val connectivityManager = app.getSystemService<ConnectivityManager>()
        
        // ✅ 可以：访问文件
        val file = app.getFilesDir()
        
        // ⚠️ 需要 FLAG：启动 Activity
        val intent = Intent(app, TargetActivity::class.java).apply {
            // 必须添加此 Flag，否则会抛出异常
            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
        }
        app.startActivity(intent)
        
        // ❌ 不推荐：填充布局（会使用系统默认主题）
        val inflater = LayoutInflater.from(app)
        // 这里填充的 View 不会应用 Activity 的主题
        val view = inflater.inflate(R.layout.some_layout, null)
        
        // ❌ 不可以：显示普通 Dialog
        // AlertDialog.Builder(app).show() // 会崩溃！
    }
    
    // Activity Context：完整 UI 能力，但有生命周期限制
    fun demonstrateActivityContext(activity: Activity) {
        // ✅ 可以：所有 Application Context 能做的事
        val appName = activity.getString(R.string.app_name)
        
        // ✅ 可以：直接启动 Activity（无需额外 Flag）
        activity.startActivity(Intent(activity, TargetActivity::class.java))
        
        // ✅ 可以：正确填充带主题的布局
        val inflater = LayoutInflater.from(activity)
        val view = inflater.inflate(R.layout.some_layout, null)
        // View 会正确应用 Activity 的主题
        
        // ✅ 可以：显示 Dialog
        AlertDialog.Builder(activity)
            .setTitle("提示")
            .setMessage("这是一个对话框")
            .show()
        
        // ⚠️ 注意：不要让长生命周期对象持有 Activity Context
        // 这会导致内存泄漏（下一节详细讨论）
    }
    
    // Service Context：后台能力完整，UI 能力受限
    fun demonstrateServiceContext(service: Service) {
        // ✅ 可以：后台操作
        val file = service.getFilesDir()
        val prefs = service.getSharedPreferences("config", Context.MODE_PRIVATE)
        
        // ⚠️ 需要 FLAG：启动 Activity
        val intent = Intent(service, TargetActivity::class.java).apply {
            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
        }
        service.startActivity(intent)
        
        // ❌ 不可以：显示普通 Dialog（Service 没有窗口令牌）
        // 但可以显示系统级悬浮窗（需要 SYSTEM_ALERT_WINDOW 权限）
    }
}

// 演示两种 Context 的获取方式与生命周期差异
class MainActivity : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 获取 Activity Context —— 生命周期与当前 Activity 绑定
        // 'this' 指向当前 Activity 实例，继承自 ContextThemeWrapper
        val activityContext: Context = this
        
        // 获取 Application Context —— 生命周期与进程绑定
        // applicationContext 返回的是 Application 实例
        val appContext: Context = applicationContext
        
        // 两者的类型实际上是不同的
        // activityContext 的实际类型是 MainActivity（继承链包含 ContextThemeWrapper）
        // appContext 的实际类型是 Application 子类（直接继承 ContextWrapper）
        Log.d("Context", "Activity Context: ${activityContext.javaClass.name}")
        Log.d("Context", "App Context: ${appContext.javaClass.name}")
    }
}

// 演示 Context 能力差异的代码示例
class ContextCapabilityDemo : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // ✅ 正确：使用 Activity Context 启动另一个 Activity
        // 新 Activity 会自动加入当前 Task 栈
        val intent1 = Intent(this, SecondActivity::class.java)
        startActivity(intent1)  // 无需额外 Flag
        
        // ⚠️ 需要注意：使用 Application Context 启动 Activity
        // 必须添加 FLAG_ACTIVITY_NEW_TASK，否则会抛出异常
        val intent2 = Intent(applicationContext, SecondActivity::class.java)
        intent2.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)  // 强制要求
        applicationContext.startActivity(intent2)
        
        // ✅ 正确：使用 Activity Context 显示 Dialog
        // Activity 拥有有效的 Window Token
        AlertDialog.Builder(this)  // 'this' 是 Activity Context
            .setTitle("提示")
            .setMessage("这是一个正常的 Dialog")
            .show()
        
        // ❌ 错误：使用 Application Context 显示 Dialog
        // 会抛出 android.view.WindowManager$BadTokenException
        // AlertDialog.Builder(applicationContext)  // 千万不要这样做！
        //     .setTitle("错误示范")
        //     .show()
        
        // ✅ 正确：使用 Activity Context 进行布局填充
        // 能够正确解析主题属性
        val correctView = LayoutInflater.from(this)
            .inflate(R.layout.item_layout, null)
        
        // ⚠️ 可能出问题：使用 Application Context 进行布局填充
        // 主题属性可能无法正确解析，导致样式异常
        val problematicView = LayoutInflater.from(applicationContext)
            .inflate(R.layout.item_layout, null)
    }
}

// 内存泄漏的引用链示意
// GC Root (静态变量) → 单例对象 → Context 字段 → Activity 实例 → View 树 → Bitmap...
//                                                    ↑
//                                            无法被回收！

// ❌ 错误示范：静态变量持有 Activity Context
object BadSingleton {
    // 静态字段，生命周期 = 进程生命周期
    // 一旦被赋值为 Activity Context，该 Activity 永远无法被回收
    private var context: Context? = null
    
    // 这个方法如果传入 Activity Context，就会造成泄漏
    fun init(ctx: Context) {
        context = ctx  // 危险！如果 ctx 是 Activity，泄漏发生
    }
    
    fun doSomething() {
        // 使用 context 进行操作
        context?.getSystemService(Context.CONNECTIVITY_SERVICE)
    }
}
 
// 在 Activity 中错误地调用
class LeakyActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // ❌ 传入 Activity Context，造成泄漏
        BadSingleton.init(this)
    }
    // 即使 Activity 被销毁，BadSingleton.context 仍然持有引用
    // Activity 及其所有 View、Drawable、Bitmap 都无法被回收
}

// ✅ 正确做法：使用 Application Context
object GoodSingleton {
    private var context: Context? = null
    
    fun init(ctx: Context) {
        // 关键修复：始终使用 Application Context
        // applicationContext 的生命周期与进程相同，不会造成泄漏
        context = ctx.applicationContext
    }
    
    fun doSomething() {
        context?.getSystemService(Context.CONNECTIVITY_SERVICE)
    }
}
 
// 或者更安全的写法：在 Application 中初始化
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        // 在 Application 中初始化，传入的就是 Application Context
        GoodSingleton.init(this)
    }
}

// ❌ 错误示范：Handler 内存泄漏（经典案例）
class HandlerLeakActivity : AppCompatActivity() {
    
    // 非静态内部类，隐式持有 HandlerLeakActivity.this 引用
    // Handler 会被 MessageQueue 持有，而 MessageQueue 生命周期很长
    private val handler = object : Handler(Looper.getMainLooper()) {
        override fun handleMessage(msg: Message) {
            // 处理消息
            // 这里可以访问外部类的成员，说明持有外部类引用
            updateUI()
        }
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 发送一个延迟消息，10 秒后执行
        handler.sendEmptyMessageDelayed(0, 10_000)
    }
    
    private fun updateUI() {
        // 更新 UI
    }
    
    // 如果用户在 10 秒内退出 Activity：
    // Message 持有 Handler → Handler 持有 Activity → 泄漏！
    // 直到消息被处理，Activity 才能被回收
}

// ✅ 正确做法：使用静态内部类 + 弱引用
class SafeHandlerActivity : AppCompatActivity() {
    
    // 静态内部类，不持有外部类引用
    // 通过 WeakReference 安全地访问 Activity
    private class SafeHandler(activity: SafeHandlerActivity) : Handler(Looper.getMainLooper()) {
        // 弱引用不会阻止 GC 回收 Activity
        private val activityRef = WeakReference(activity)
        
        override fun handleMessage(msg: Message) {
            // 通过弱引用获取 Activity，可能为 null（已被回收）
            val activity = activityRef.get()
            if (activity != null && !activity.isFinishing) {
                // Activity 仍然存活，安全地更新 UI
                activity.updateUI()
            }
            // 如果 activity 为 null，说明已被回收，直接忽略消息
        }
    }
    
    private val handler = SafeHandler(this)
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        handler.sendEmptyMessageDelayed(0, 10_000)
    }
    
    override fun onDestroy() {
        super.onDestroy()
        // 最佳实践：在 onDestroy 中移除所有待处理消息
        handler.removeCallbacksAndMessages(null)
    }
    
    private fun updateUI() {
        // 更新 UI
    }
}

// ✅ 更现代的做法：使用 Lifecycle-aware 组件
class ModernActivity : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 使用 lifecycleScope，自动在 Activity 销毁时取消协程
        lifecycleScope.launch {
            delay(10_000)  // 延迟 10 秒
            // 如果 Activity 已销毁，这里不会执行
            updateUI()
        }
    }
    
    private fun updateUI() {
        // 更新 UI
    }
}

// ❌ 错误示范：传感器监听器未注销
class SensorLeakActivity : AppCompatActivity(), SensorEventListener {
    
    private lateinit var sensorManager: SensorManager
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        val accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
        
        // 注册监听器，SensorManager 会持有 this（Activity）的引用
        sensorManager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_NORMAL)
    }
    
    override fun onSensorChanged(event: SensorEvent?) {
        // 处理传感器数据
    }
    
    override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {
        // 处理精度变化
    }
    
    // ❌ 忘记在 onDestroy 或 onPause 中注销监听器
    // SensorManager（系统服务，长生命周期）持有 Activity 引用 → 泄漏！
}

// ✅ 正确做法：配对注册与注销
class SafeSensorActivity : AppCompatActivity(), SensorEventListener {
    
    private lateinit var sensorManager: SensorManager
    private var accelerometer: Sensor? = null
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
    }
    
    override fun onResume() {
        super.onResume()
        // 在 onResume 中注册，确保 Activity 可见时才接收数据
        accelerometer?.let {
            sensorManager.registerListener(this, it, SensorManager.SENSOR_DELAY_NORMAL)
        }
    }
    
    override fun onPause() {
        super.onPause()
        // 在 onPause 中注销，Activity 不可见时停止接收数据
        // 这样即使 Activity 被销毁，也不会泄漏
        sensorManager.unregisterListener(this)
    }
    
    override fun onSensorChanged(event: SensorEvent?) {
        // 处理传感器数据
    }
    
    override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {
        // 处理精度变化
    }
}

// ❌ 错误示范：异步任务持有 Activity 引用
class AsyncLeakActivity : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 匿名内部类，隐式持有 AsyncLeakActivity.this
        Thread {
            // 模拟耗时操作，比如网络请求
            Thread.sleep(30_000)  // 30 秒
            
            // 尝试更新 UI（还可能引发崩溃，因为 Activity 可能已销毁）
            runOnUiThread {
                updateUI()
            }
        }.start()
    }
    
    private fun updateUI() {
        // 更新 UI
    }
    
    // 用户在 30 秒内退出 Activity：
    // Thread 持有 Runnable → Runnable 持有 Activity → 泄漏！
}

// ✅ 正确做法：使用协程 + lifecycleScope
class SafeAsyncActivity : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // lifecycleScope 会在 Activity 销毁时自动取消协程
        lifecycleScope.launch {
            // 切换到 IO 线程执行耗时操作
            val result = withContext(Dispatchers.IO) {
                // 模拟耗时操作
                delay(30_000)
                "操作完成"
            }
            
            // 自动切回主线程，且只有 Activity 存活时才执行
            updateUI(result)
        }
    }
    
    private fun updateUI(result: String) {
        // 安全地更新 UI
    }
}

// build.gradle.kts
dependencies {
    // 仅在 debug 构建中启用，release 构建自动禁用
    debugImplementation("com.squareup.leakcanary:leakcanary-android:2.12")
}
 
// 无需任何代码配置，LeakCanary 会自动初始化并监控泄漏
// 检测到泄漏时，会在通知栏显示提醒，点击可查看详细引用链

class NetworkManager private constructor(private val context: Context) {
    companion object {
        @Volatile
        private var instance: NetworkManager? = null
        
        fun getInstance(context: Context): NetworkManager {
            return instance ?: synchronized(this) {
                instance ?: NetworkManager(context).also { instance = it }
            }
        }
    }
    
    fun request(url: String) {
        // 使用 context 进行网络请求
    }
}
 
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        NetworkManager.getInstance(this).request("https://api.example.com")
    }
}

NetworkManager(context.applicationContext).also { instance = it }

<!-- res/values/strings.xml -->
<!-- 文件名 strings.xml 只是约定俗成，你可以叫任何名字 -->
<resources>
    <!-- 每个 <string> 标签定义一个字符串资源 -->
    <!-- name 属性才是真正的资源标识符 -->
    <string name="app_name">我的应用</string>
    
    <!-- 支持基本 HTML 格式化标签 -->
    <string name="welcome_message">欢迎使用 <b>Android</b> 开发指南</string>
    
    <!-- 使用 CDATA 或转义处理特殊字符 -->
    <string name="terms">请阅读我们的 \"服务条款\"</string>
</resources>

<!-- res/values/colors.xml -->
<resources>
    <!-- 颜色值支持多种格式 -->
    <color name="primary">#6200EE</color>           <!-- RGB -->
    <color name="primary_variant">#3700B3</color>   <!-- RGB -->
    <color name="on_primary">#FFFFFF</color>        <!-- RGB -->
    <color name="surface">#FFFFFFFF</color>         <!-- ARGB（带透明度） -->
    <color name="divider">#1F000000</color>         <!-- 12% 不透明度的黑色 -->
</resources>

<!-- res/values/dimens.xml -->
<resources>
    <!-- dp: 密度无关像素，用于布局尺寸 -->
    <dimen name="margin_standard">16dp</dimen>
    
    <!-- sp: 缩放无关像素，用于文字大小（会响应系统字体缩放设置） -->
    <dimen name="text_body">14sp</dimen>
    
    <!-- px: 实际像素，极少使用（不推荐） -->
    <dimen name="divider_height">1px</dimen>
</resources>

// 资源 ID 的位结构示意
// 0xPPTTEEEE
// PP: Package ID (8 bits) - 包标识符
// TT: Type ID (8 bits)    - 类型标识符  
// EEEE: Entry ID (16 bits) - 条目标识符
 
// 示例：R.string.app_name = 0x7F040001
// 0x7F = 127 (应用资源包，系统资源包是 0x01)
// 0x04 = 4   (string 类型在该应用中的类型 ID)
// 0x0001 = 1 (app_name 是 string 类型中的第 1 个条目)
 
object ResourceIdDecoder {
    // 解析资源 ID 的各个组成部分
    fun decode(resourceId: Int) {
        // 右移 24 位，取最高 8 位作为包 ID
        val packageId = (resourceId shr 24) and 0xFF
        // 右移 16 位，取中间 8 位作为类型 ID
        val typeId = (resourceId shr 16) and 0xFF
        // 取最低 16 位作为条目 ID
        val entryId = resourceId and 0xFFFF
        
        println("Package ID: 0x${packageId.toString(16).uppercase()}")
        println("Type ID: 0x${typeId.toString(16).uppercase()}")
        println("Entry ID: 0x${entryId.toString(16).uppercase()}")
    }
}

// 由 AAPT2 自动生成，位于 build/generated/source/r/
// 切勿手动修改此文件
public final class R {
    // 每种资源类型对应一个静态内部类
    public static final class string {
        // 每个资源对应一个静态常量
        // 值为 AAPT2 分配的资源 ID
        public static final int app_name = 0x7f040001;
        public static final int welcome_message = 0x7f040002;
        // ... 更多字符串资源
    }
    
    public static final class drawable {
        public static final int icon = 0x7f020001;
        public static final int background = 0x7f020002;
        // ... 更多图片资源
    }
    
    public static final class layout {
        public static final int activity_main = 0x7f030001;
        public static final int fragment_home = 0x7f030002;
        // ... 更多布局资源
    }
    
    public static final class id {
        // View ID 也是资源的一种
        public static final int button_submit = 0x7f050001;
        public static final int text_title = 0x7f050002;
        // ... 更多 View ID
    }
    
    public static final class styleable {
        // 自定义属性集合（用于自定义 View）
        public static final int[] CustomView = { 0x7f060001, 0x7f060002 };
        public static final int CustomView_customColor = 0;
        public static final int CustomView_customSize = 1;
    }
}

// App 模块的 R.java - 字段是 final
public static final int app_name = 0x7f040001;
 
// Library 模块的 R.java - 字段不是 final
public static int app_name = 0x7f040001;

// 在 Library 模块中，这段代码会编译失败
when (view.id) {
    R.id.button_a -> { /* ... */ }  // 错误：R.id.button_a 不是常量
    R.id.button_b -> { /* ... */ }
}
 
// 正确做法：使用 if-else 链
if (view.id == R.id.button_a) {
    // 处理 button_a
} else if (view.id == R.id.button_b) {
    // 处理 button_b
}

class ResourceLoadingExample(private val context: Context) {
    
    // 加载编译型资源 - 通过 Resources 类
    fun loadCompiledResources() {
        // Resources 是 AssetManager 的高级封装
        val resources: Resources = context.resources
        
        // 获取字符串资源
        // 内部流程：R.string.app_name -> resources.arsc 查表 -> 返回字符串值
        val appName: String = resources.getString(R.string.app_name)
        
        // 获取带格式化参数的字符串
        // strings.xml: <string name="welcome">欢迎, %1$s! 您有 %2$d 条消息</string>
        val welcome: String = resources.getString(R.string.welcome, "张三", 5)
        
        // 获取颜色值
        // 返回解析后的 ARGB 整数值
        val primaryColor: Int = resources.getColor(R.color.primary, context.theme)
        
        // 获取尺寸值
        // getDimension(): 返回精确的像素值（float）
        // getDimensionPixelSize(): 返回四舍五入的像素值（int）
        // getDimensionPixelOffset(): 返回截断的像素值（int）
        val marginPx: Float = resources.getDimension(R.dimen.margin_standard)
        
        // 获取 Drawable
        // 系统会根据当前屏幕密度自动选择合适的变体
        val icon: Drawable? = resources.getDrawable(R.drawable.icon, context.theme)
    }
    
    // 加载原始资源 - 通过 AssetManager 直接访问
    fun loadRawAssets() {
        // 获取 AssetManager 实例
        val assetManager: AssetManager = context.assets
        
        // 列出 assets 目录下的文件
        // assets/fonts/ 目录下的所有文件名
        val fontFiles: Array<String>? = assetManager.list("fonts")
        
        // 打开 assets 文件获取输入流
        // 路径相对于 assets/ 目录，不需要以 "/" 开头
        val inputStream: InputStream = assetManager.open("config/settings.json")
        
        // 读取 JSON 配置文件示例
        val jsonContent = inputStream.bufferedReader().use { reader ->
            reader.readText()  // 读取全部内容为字符串
        }
        
        // 访问模式选项
        // ACCESS_UNKNOWN: 默认模式，系统自动选择
        // ACCESS_RANDOM: 随机访问，适合需要 seek 的场景
        // ACCESS_STREAMING: 顺序流式读取
        // ACCESS_BUFFER: 尝试将整个文件加载到内存缓冲区
        val streamForRandom = assetManager.open("data/large_file.dat", AssetManager.ACCESS_RANDOM)
    }
    
    // res/raw/ 与 assets/ 的区别
    fun compareRawAndAssets() {
        // res/raw/ 目录：
        // - 文件会被分配资源 ID，可通过 R.raw.xxx 访问
        // - 文件名成为资源名（不含扩展名）
        // - 不支持子目录结构
        val rawStream: InputStream = context.resources.openRawResource(R.raw.sample_audio)
        
        // assets/ 目录：
        // - 没有资源 ID，只能通过路径字符串访问
        // - 支持任意深度的子目录结构
        // - 更灵活，适合存放大量配置文件、游戏资源等
        val assetStream: InputStream = context.assets.open("levels/level1/config.json")
    }
}

// 伪代码展示资源加载的内部流程
class ResourceLoadingInternals {
    
    /*
     * 第一步：Resources.getString() 
     * 这是应用层最常用的入口方法
     */
    fun getString(resId: Int): String {
        // Resources 将调用委托给 ResourcesImpl
        // ResourcesImpl 持有真正的 AssetManager 引用
        return resourcesImpl.getAssets().getResourceText(resId).toString()
    }
    
    /*
     * 第二步：AssetManager.getResourceText()
     * Java 层的 AssetManager 主要做参数校验和 JNI 调用
     */
    fun getResourceText(resId: Int): CharSequence {
        // 调用 native 方法进入 C++ 层
        // nativeGetResourceText() 是 JNI 桥接方法
        return nativeGetResourceText(mObject, resId)
    }
    
    /*
     * 第三步：AssetManager2::GetResource() [C++ Native]
     * 这是资源查找的核心逻辑所在
     */
    // native fun GetResource(resId: Int): ResolvedBag {
    //     1. 从 resId 解析出 package_id, type_id, entry_id
    //     2. 在已加载的 ApkAssets 列表中查找对应的包
    //     3. 从 LoadedArsc (解析后的 resources.arsc) 中定位资源条目
    //     4. 根据当前 Configuration 选择最佳匹配的配置变体
    //     5. 返回资源值或资源文件路径
    // }
    
    /*
     * 第四步：配置匹配算法
     * 当同一资源存在多个配置变体时，系统如何选择？
     */
    // 假设设备配置：zh-CN, night, xxhdpi, portrait
    // 候选资源目录：
    //   - values/strings.xml (默认)
    //   - values-zh/strings.xml (中文)
    //   - values-zh-rCN/strings.xml (简体中文)
    //   - values-night/strings.xml (深色模式)
    //   - values-zh-rCN-night/strings.xml (简体中文 + 深色模式)
    
    // 匹配算法会选择 values-zh-rCN-night/strings.xml
    // 因为它匹配了最多的限定符
}

class AssetManagerConfiguration {
    
    // AssetManager 可以加载多个资源包
    // 后加载的包可以覆盖先加载的包中的同名资源
    fun demonstrateMultipleApkAssets(context: Context) {
        // 系统资源包 (framework-res.apk)
        // 包含 android.R.* 资源，Package ID = 0x01
        
        // 应用资源包 (base.apk)  
        // 包含应用自身资源，Package ID = 0x7F
        
        // 可选：Runtime Resource Overlay (RRO)
        // 用于主题定制、厂商定制等场景
        
        // 可选：动态加载的资源包
        // 如插件化框架加载的插件 APK 资源
    }
    
    // 创建独立的 AssetManager 加载外部资源
    // 常用于插件化、换肤等场景
    @Suppress("DEPRECATION")
    fun loadExternalResources(apkPath: String): Resources? {
        return try {
            // 创建新的 AssetManager 实例
            val assetManager = AssetManager::class.java.newInstance()
            
            // 通过反射调用 addAssetPath 添加外部 APK
            // 注意：这是隐藏 API，在高版本 Android 上可能受限
            val addAssetPath = AssetManager::class.java
                .getDeclaredMethod("addAssetPath", String::class.java)
            addAssetPath.invoke(assetManager, apkPath)
            
            // 基于新的 AssetManager 创建 Resources 实例
            Resources(
                assetManager,
                context.resources.displayMetrics,
                context.resources.configuration
            )
        } catch (e: Exception) {
            e.printStackTrace()
            null
        }
    }
}

// 资源缓存的层级结构
class ResourceCachingLayers {
    
    /*
     * 第一层：ConstantState 缓存 (Drawable)
     * 
     * Drawable 使用 ConstantState 模式共享不可变状态
     * 多个 Drawable 实例可以共享同一个 ConstantState
     * 减少内存占用，加快创建速度
     */
    fun drawableConstantState(resources: Resources) {
        // 第一次加载，创建 ConstantState 并缓存
        val drawable1 = resources.getDrawable(R.drawable.icon, null)
        
        // 第二次加载，复用缓存的 ConstantState
        // 只创建新的 Drawable 壳，内部状态共享
        val drawable2 = resources.getDrawable(R.drawable.icon, null)
        
        // drawable1 和 drawable2 是不同对象
        // 但它们的 constantState 指向同一个实例
        val sameState = drawable1?.constantState === drawable2?.constantState  // true
    }
    
    /*
     * 第二层：TypedArray 缓存池
     * 
     * obtainStyledAttributes() 返回的 TypedArray 来自对象池
     * 使用完毕后必须调用 recycle() 归还到池中
     */
    fun typedArrayPooling(context: Context) {
        // 从池中获取 TypedArray
        val typedArray = context.obtainStyledAttributes(R.styleable.CustomView)
        
        try {
            // 使用 TypedArray 读取属性值
            val color = typedArray.getColor(R.styleable.CustomView_customColor, Color.BLACK)
        } finally {
            // 必须回收！否则造成对象池泄漏
            typedArray.recycle()
        }
    }
    
    /*
     * 第三层：Configuration 缓存
     * 
     * ResourcesImpl 会缓存当前 Configuration 对应的资源查找结果
     * 当 Configuration 变化时（如旋转屏幕），缓存会被清除
     */
    fun configurationCache() {
        // 配置变化时，系统会调用：
        // Resources.updateConfiguration() 
        //   -> ResourcesImpl.updateConfiguration()
        //     -> AssetManager.setConfiguration()
        //       -> 清除旧配置的缓存，建立新配置的查找上下文
    }
}

class ResourceOptimizationTips {
    
    // 1. 避免在循环中重复获取资源
    fun avoidRepeatedLoading(resources: Resources, items: List<Item>) {
        // ❌ 错误：每次迭代都查询资源
        items.forEach { item ->
            val label = resources.getString(R.string.item_label)
            // 使用 label...
        }
        
        // ✅ 正确：提前获取，循环中复用
        val label = resources.getString(R.string.item_label)
        items.forEach { item ->
            // 使用 label...
        }
    }
    
    // 2. 合理使用 Resources 缓存
    fun cacheResourcesReference(context: Context) {
        // ❌ 避免：频繁调用 context.resources
        fun processItem() {
            val res = context.resources  // 每次都获取
            val str1 = res.getString(R.string.a)
            val str2 = context.resources.getString(R.string.b)  // 又获取一次
        }
        
        // ✅ 推荐：保存 Resources 引用
        val resources = context.resources
        fun processItemOptimized() {
            val str1 = resources.getString(R.string.a)
            val str2 = resources.getString(R.string.b)
        }
    }
    
    // 3. 大型 Drawable 考虑异步加载
    suspend fun loadLargeDrawableAsync(resources: Resources): Drawable? {
        return withContext(Dispatchers.IO) {
            // 在 IO 线程解码大图
            resources.getDrawable(R.drawable.large_background, null)
        }
    }
    
    // 4. 使用 ResourcesCompat 获得向后兼容性
    fun useResourcesCompat(context: Context) {
        // ResourcesCompat 会根据 API 级别选择合适的实现
        val drawable = ResourcesCompat.getDrawable(
            context.resources,
            R.drawable.icon,
            context.theme
        )
        
        val color = ResourcesCompat.getColor(
            context.resources,
            R.color.primary,
            context.theme
        )
    }
}

// 库模块中的代码
class LibraryHelper(private val context: Context) {
    companion object {
        private const val CACHED_STRING_ID = R.string.library_name  // 编译时值：0x7f040001
    }
    
    fun getLibraryName(): String {
        return context.resources.getString(CACHED_STRING_ID)
    }
}

fun getLibraryName(): String {
    return context.resources.getString(R.string.library_name)  // 运行时解析
}

// 获取当前设备的屏幕密度信息
val displayMetrics: DisplayMetrics = resources.displayMetrics
 
// density: 密度缩放因子（相对于 mdpi 的比例，如 2.0 表示 xhdpi）
val density: Float = displayMetrics.density
 
// densityDpi: 实际的 dpi 值（如 320 表示 xhdpi）
val densityDpi: Int = displayMetrics.densityDpi
 
// scaledDensity: 文字缩放因子（受系统字体大小设置影响）
val scaledDensity: Float = displayMetrics.scaledDensity
 
// 手动进行 dp 到 px 的转换
fun Int.dp(): Int {
    return (this * density + 0.5f).toInt() // +0.5f 是为了四舍五入
}
 
// 示例：将 48dp 转换为像素值
val iconSizePx = 48.dp() // 在 xhdpi 设备上结果是 96px

<!-- res/drawable/ic_heart.xml -->
<!-- 使用 Vector Drawable 定义一个心形图标 -->
<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="24dp"
    android:height="24dp"
    android:viewportWidth="24"
    android:viewportHeight="24">
    
    <!-- 定义心形的路径数据（SVG Path 语法） -->
    <path
        android:fillColor="#FF4081"
        android:pathData="M12,21.35l-1.45,-1.32C5.4,15.36 2,12.28 2,8.5 2,5.42 4.42,3 7.5,3c1.74,0 3.41,0.81 4.5,2.09C13.09,3.81 14.76,3 16.5,3 19.58,3 22,5.42 22,8.5c0,3.78 -3.4,6.86 -8.55,11.54L12,21.35z"/>
</vector>

// build.gradle (Module)
android {
    defaultConfig {
        // 为低版本设备自动生成 PNG（已废弃，推荐使用 VectorDrawableCompat）
        vectorDrawables.useSupportLibrary = true
    }
}

<resources>
    <!-- 默认语言资源（英语），当系统语言不匹配任何限定符时使用 -->
    <string name="app_name">MyApp</string>
    <string name="greeting">Hello, welcome to our app!</string>
    <string name="item_count">You have %d items in your cart.</string>
</resources>

<resources>
    <!-- 简体中文资源 -->
    <string name="app_name">我的应用</string>
    <string name="greeting">你好，欢迎使用我们的应用！</string>
    <string name="item_count">您的购物车中有 %d 件商品。</string>
</resources>

// 获取当前语言环境下的字符串资源
val greeting = getString(R.string.greeting) 
// 如果设备语言是简体中文，greeting 的值为 "你好，欢迎使用我们的应用！"
// 如果设备语言是英语或其他未匹配的语言，使用默认的 "Hello, welcome to our app!"
 
// 带占位符的字符串格式化
val count = 5
val message = getString(R.string.item_count, count) 
// 简体中文环境下结果为 "您的购物车中有 5 件商品。"

import android.content.Context
import android.content.res.Configuration
import android.os.Build
import java.util.Locale
 
/**
 * 为应用设置自定义语言环境
 * @param context 应用上下文
 * @param language 语言代码（如 "zh", "en"）
 * @param country 区域代码（如 "CN", "US"），可选
 */
fun setAppLocale(context: Context, language: String, country: String? = null) {
    // 创建新的 Locale 对象
    val locale = if (country != null) {
        Locale(language, country) // 如 Locale("zh", "CN")
    } else {
        Locale(language) // 如 Locale("en")
    }
    
    // 设置为默认 Locale（影响格式化 API，如日期、数字格式）
    Locale.setDefault(locale)
    
    // 获取当前的 Configuration 对象
    val config = Configuration(context.resources.configuration)
    
    // 根据 API 版本选择不同的设置方法
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        // API 24+: 使用 LocaleList 支持多语言回退
        config.setLocale(locale)
    } else {
        // API 17-23: 直接设置 locale 字段
        @Suppress("DEPRECATION")
        config.locale = locale
    }
    
    // 更新 Resources 的配置（触发资源重新加载）
    @Suppress("DEPRECATION")
    context.resources.updateConfiguration(config, context.resources.displayMetrics)
}
 
// 使用示例：切换到简体中文
setAppLocale(applicationContext, "zh", "CN")
 
// 切换后需要重启 Activity 才能完全生效
recreate() // 重建当前 Activity

import androidx.appcompat.app.AppCompatDelegate
import androidx.core.os.LocaleListCompat
 
/**
 * 使用 AppCompat 库设置应用语言
 * 优势：自动处理配置变更，无需手动重启 Activity
 */
fun setAppLocaleCompat(language: String, country: String? = null) {
    val locale = if (country != null) {
        Locale(language, country)
    } else {
        Locale(language)
    }
    
    // 创建 LocaleList（支持多语言回退机制）
    val localeList = LocaleListCompat.create(locale)
    
    // 应用到整个应用（会自动触发 Activity 重建）
    AppCompatDelegate.setApplicationLocales(localeList)
}
 
// 使用示例
setAppLocaleCompat("zh", "CN") // 自动重建所有 Activity

<application
    android:supportsRtl="true"
    ...>
</application>

<resources>
    <!-- 浅色模式下的颜色定义 -->
    <color name="background">#FFFFFF</color>         <!-- 白色背景 -->
    <color name="text_primary">#000000</color>       <!-- 黑色文字 -->
    <color name="text_secondary">#757575</color>     <!-- 灰色次要文字 -->
    <color name="surface">#F5F5F5</color>            <!-- 浅灰色表面 -->
</resources>

<resources>
    <!-- 深色模式下的颜色定义 -->
    <color name="background">#121212</color>         <!-- 深灰色背景（避免纯黑） -->
    <color name="text_primary">#FFFFFF</color>       <!-- 白色文字 -->
    <color name="text_secondary">#B0B0B0</color>     <!-- 浅灰色次要文字 -->
    <color name="surface">#1E1E1E</color>            <!-- 稍浅的深灰表面 -->
</resources>

import android.content.res.Configuration
 
/**
 * 在 Activity 或 Fragment 中监听深色模式变化
 */
override fun onConfigurationChanged(newConfig: Configuration) {
    super.onConfigurationChanged(newConfig)
    
    // 判断当前是否为深色模式
    val currentNightMode = newConfig.uiMode and Configuration.UI_MODE_NIGHT_MASK
    when (currentNightMode) {
        Configuration.UI_MODE_NIGHT_NO -> {
            // 浅色模式
            Log.d("Theme", "Light mode is active")
            // 可以在这里执行特定的 UI 更新逻辑
        }
        Configuration.UI_MODE_NIGHT_YES -> {
            // 深色模式
            Log.d("Theme", "Dark mode is active")
        }
        Configuration.UI_MODE_NIGHT_UNDEFINED -> {
            // 未定义（通常不会出现）
        }
    }
}

<activity
    android:name=".MainActivity"
    android:configChanges="uiMode"
    ...>
</activity>

import androidx.appcompat.app.AppCompatDelegate
 
/**
 * 设置应用的深色模式策略
 */
fun setDarkMode(mode: Int) {
    when (mode) {
        AppCompatDelegate.MODE_NIGHT_NO -> {
            // 强制浅色模式
            AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)
        }
        AppCompatDelegate.MODE_NIGHT_YES -> {
            // 强制深色模式
            AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
        }
        AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM -> {
            // 跟随系统设置（推荐）
            AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM)
        }
        AppCompatDelegate.MODE_NIGHT_AUTO_BATTERY -> {
            // 根据电池省电模式自动切换（已废弃）
        }
    }
}
 
// 示例：强制启用深色模式
setDarkMode(AppCompatDelegate.MODE_NIGHT_YES)

import android.content.res.Configuration
import android.util.Log
 
/**
 * 输出当前设备的配置信息，用于调试资源匹配
 */
fun logDeviceConfiguration() {
    val config = resources.configuration
    
    // 语言和区域
    val locale = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        config.locales[0] // API 24+ 支持多语言
    } else {
        @Suppress("DEPRECATION")
        config.locale
    }
    Log.d("Config", "Locale: ${locale.language}-${locale.country}")
    
    // 屏幕密度
    val density = resources.displayMetrics.densityDpi
    Log.d("Config", "Screen Density: $density dpi")
    
    // 夜间模式
    val nightMode = config.uiMode and Configuration.UI_MODE_NIGHT_MASK
    val nightModeStr = when (nightMode) {
        Configuration.UI_MODE_NIGHT_YES -> "Night Mode"
        Configuration.UI_MODE_NIGHT_NO -> "Day Mode"
        else -> "Undefined"
    }
    Log.d("Config", "Night Mode: $nightModeStr")
    
    // 屏幕尺寸
    val screenLayout = config.screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK
    val screenSize = when (screenLayout) {
        Configuration.SCREENLAYOUT_SIZE_SMALL -> "Small"
        Configuration.SCREENLAYOUT_SIZE_NORMAL -> "Normal"
        Configuration.SCREENLAYOUT_SIZE_LARGE -> "Large"
        Configuration.SCREENLAYOUT_SIZE_XLARGE -> "XLarge"
        else -> "Undefined"
    }
    Log.d("Config", "Screen Size: $screenSize")
    
    // API Level
    Log.d("Config", "API Level: ${Build.VERSION.SDK_INT}")
}

android {
    lint {
        // 将资源缺失问题视为错误，构建时会失败
        error("MissingDefaultResource", "MissingTranslation")
        
        // 禁用未使用资源的警告（某些资源可能是动态引用的）
        disable("UnusedResources")
    }
}

// ❌ 不推荐：容易出错，且无法被 R8/ProGuard 优化
val resourceName = "icon_$category"
val resId = resources.getIdentifier(resourceName, "drawable", packageName)
val drawable = resources.getDrawable(resId, theme)

// ✅ 推荐：类型安全，编译时检查
val drawableRes = when (category) {
    "sports" -> R.drawable.icon_sports
    "music" -> R.drawable.icon_music
    "food" -> R.drawable.icon_food
    else -> R.drawable.icon_default
}
val drawable = resources.getDrawable(drawableRes, theme)

<!-- res/values/arrays.xml -->
<array name="category_icons">
    <item>@drawable/icon_sports</item>
    <item>@drawable/icon_music</item>
    <item>@drawable/icon_food</item>
</array>

// 通过索引访问
val iconArray = resources.obtainTypedArray(R.array.category_icons)
val drawable = iconArray.getDrawable(categoryIndex)
iconArray.recycle() // 释放资源

<!-- res/values/strings.xml -->
<resources>
    <!-- 单个占位符：%s 可简写，默认按顺序匹配 -->
    <string name="welcome">Welcome, %s!</string>
    
    <!-- 多个占位符：必须使用位置索引 -->
    <string name="order_summary">You ordered %1$d items for %2$.2f dollars.</string>
    
    <!-- 复用参数：同一参数可被多次引用 -->
    <string name="repeat_name">Hello %1$s, nice to meet you, %1$s!</string>
</resources>

// 获取 Context 引用（Activity/Fragment/Application 均可）
val context: Context = this
 
// 单参数场景
val userName = "Alice"
val welcomeMsg = context.getString(R.string.welcome, userName)
// 结果: "Welcome, Alice!"
 
// 多参数场景
val itemCount = 3
val totalPrice = 49.99
val summary = context.getString(R.string.order_summary, itemCount, totalPrice)
// 结果: "You ordered 3 items for 49.99 dollars."
 
// 参数复用场景
val greeting = context.getString(R.string.repeat_name, "Bob")
// 结果: "Hello Bob, nice to meet you, Bob!"

<!-- 英语 (en) -->
<string name="file_info">%1$s contains %2$d files</string>
 
<!-- 日语 (ja) -->
<string name="file_info">%1$s には %2$d 個のファイルがあります</string>
 
<!-- 阿拉伯语 (ar)：参数顺序可能颠倒 -->
<string name="file_info">يحتوي %1$s على %2$d ملفات</string>

<!-- 价格显示：保留 2 位小数 -->
<string name="price_tag">Price: $%1$.2f</string>
 
<!-- 百分比：整数 + 百分号转义 -->
<string name="progress">Loading... %1$d%%</string>

val price = 19.5
val priceText = getString(R.string.price_tag, price)
// 结果: "Price: $19.50"
 
val progress = 75
val progressText = getString(R.string.progress, progress)
// 结果: "Loading... 75%"

<!-- 方案 1: CDATA 块（推荐）-->
<string name="bold_text"><![CDATA[This is <b>bold</b> text]]></string>
 
<!-- 方案 2: 实体转义 -->
<string name="italic_text">This is &lt;i&gt;italic&lt;/i&gt; text</string>

import android.text.Html
import android.os.Build
 
val rawText = getString(R.string.bold_text)
 
// Android N (API 24) 及以上
val styledText = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
    Html.fromHtml(rawText, Html.FROM_HTML_MODE_LEGACY)
} else {
    @Suppress("DEPRECATION")
    Html.fromHtml(rawText)
}
 
// 将 Spanned 对象设置到 TextView
textView.text = styledText
// 显示效果: "This is bold text"（bold 为粗体）