Android 应用模型与环境

// 从应用层视角理解内核的作用
// 当我们调用以下代码时，背后涉及多个内核子系统的协作
 
class KernelInteractionExample {
    
    fun demonstrateKernelInteraction(context: Context) {
        // 1. 文件操作 - 触发内核的 VFS（虚拟文件系统）和具体文件系统驱动
        val file = File(context.filesDir, "data.txt")  // 内核分配 inode
        file.writeText("Hello")                         // 内核处理写缓冲、磁盘调度
        
        // 2. 网络请求 - 触发内核的网络协议栈
        // TCP/IP 协议处理、Socket 缓冲区管理都在内核完成
        val url = URL("https://api.example.com")
        val connection = url.openConnection()           // 内核创建 Socket
        
        // 3. 获取系统服务 - 触发 Binder 驱动进行跨进程通信
        // 应用进程 -> Binder 驱动 -> system_server 进程
        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE)
        
        // 4. 申请 WakeLock - 触发内核电源管理子系统
        val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
        val wakeLock = powerManager.newWakeLock(
            PowerManager.PARTIAL_WAKE_LOCK,             // 内核记录 wakelock 引用计数
            "MyApp::MyWakeLockTag"
        )
    }
}

// 应用与 Framework 系统服务的交互示例
class FrameworkInteractionDemo(private val context: Context) {
    
    // 获取系统服务的标准方式
    // 底层通过 ServiceManager 查找服务，再通过 Binder 获取代理对象
    private val activityManager: ActivityManager = 
        context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
    
    private val packageManager: PackageManager = 
        context.packageManager  // 等价于 getSystemService + 类型转换
    
    private val windowManager: WindowManager = 
        context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
    
    fun demonstrateAMSInteraction() {
        // 查询正在运行的应用进程 - 与 AMS 通信
        val runningProcesses = activityManager.runningAppProcesses
        runningProcesses?.forEach { processInfo ->
            // processInfo.importance 反映了进程的优先级
            // 这个值由 AMS 根据进程状态动态计算
            Log.d("AMS", "Process: ${processInfo.processName}, " +
                        "Importance: ${processInfo.importance}")
        }
        
        // 获取内存信息 - AMS 汇总各进程的内存使用情况
        val memoryInfo = ActivityManager.MemoryInfo()
        activityManager.getMemoryInfo(memoryInfo)
        Log.d("AMS", "Available memory: ${memoryInfo.availMem / 1024 / 1024} MB")
    }
    
    fun demonstratePMSInteraction() {
        // 查询已安装的应用 - 与 PMS 通信
        val installedApps = packageManager.getInstalledApplications(0)
        Log.d("PMS", "Installed apps count: ${installedApps.size}")
        
        // 查询特定包的信息
        try {
            val packageInfo = packageManager.getPackageInfo(
                context.packageName,
                PackageManager.GET_PERMISSIONS  // 同时获取权限信息
            )
            Log.d("PMS", "Version: ${packageInfo.versionName}")
            packageInfo.requestedPermissions?.forEach { permission ->
                Log.d("PMS", "Requested permission: $permission")
            }
        } catch (e: PackageManager.NameNotFoundException) {
            // 包不存在
        }
    }
    
    fun demonstrateWMSInteraction() {
        // 获取屏幕信息 - 与 WMS 通信
        val displayMetrics = DisplayMetrics()
        windowManager.defaultDisplay.getMetrics(displayMetrics)
        Log.d("WMS", "Screen: ${displayMetrics.widthPixels} x ${displayMetrics.heightPixels}")
        Log.d("WMS", "Density: ${displayMetrics.density}")
    }
}

// ActivityThread.java - 简化版 main 函数
public static void main(String[] args) {
    // 1. 初始化当前进程的 Trace 标签，用于 Systrace 性能分析
    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
    
    // 2. 安装选择性的系统调用拦截器（用于严格模式等）
    AndroidOs.install();
    
    // 3. 初始化当前进程的运行环境
    Environment.initForCurrentUser();
    
    // 4. 确保 TrustedCertificateStore 能找到正确的证书目录
    final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
    TrustedCertificateStore.setDefaultUserDirectory(configDir);
    
    // 5. 设置进程名称为 "<pre-initialized>"，后续会被真正的进程名替换
    Process.setArgV0("<pre-initialized>");
    
    // 6. 【关键】准备主线程的 Looper
    // 这一步创建了主线程的消息队列，是整个消息驱动机制的基础
    Looper.prepareMainLooper();
    
    // 7. 获取启动时传入的序列号，用于后续与 AMS 通信
    long startSeq = 0;
    if (args != null) {
        for (int i = args.length - 1; i >= 0; --i) {
            if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {
                startSeq = Long.parseLong(
                    args[i].substring(PROC_START_SEQ_IDENT.length()));
            }
        }
    }
    
    // 8. 【关键】创建 ActivityThread 实例
    // ActivityThread 是应用进程的核心管理者
    ActivityThread thread = new ActivityThread();
    
    // 9. 【关键】将当前进程附加到 AMS
    // 这一步建立了应用进程与系统服务的连接
    thread.attach(false, startSeq);
    
    // 10. 获取主线程的 Handler，用于处理来自 AMS 的消息
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }
    
    // 11. 结束 Trace 标记
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    
    // 12. 【关键】启动消息循环，开始处理消息
    // 这是一个无限循环，应用的所有事件都通过这个循环处理
    // 一旦 loop() 返回，意味着应用即将退出
    Looper.loop();
    
    // 13. 如果执行到这里，说明消息循环异常退出
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

// Looper 核心机制示意（简化版）
class LooperMechanism {
    
    // 演示 Looper 的基本工作流程
    fun demonstrateLooperFlow() {
        // 1. prepareMainLooper 的核心逻辑
        // 创建 Looper 实例并存储在 ThreadLocal 中
        // ThreadLocal 保证每个线程只有一个 Looper
        
        // 2. Looper 内部持有一个 MessageQueue
        // MessageQueue 是一个按时间排序的消息优先队列
        
        // 3. loop() 方法的核心是一个无限循环
        // 伪代码如下：
        
        fun loop() {
            val looper = myLooper()           // 获取当前线程的 Looper
            val queue = looper.messageQueue   // 获取消息队列
            
            while (true) {
                // 从队列中取出下一条消息
                // 如果队列为空，会阻塞等待
                val msg = queue.next()        // 可能阻塞
                
                if (msg == null) {
                    // 消息为 null 表示队列已退出
                    return
                }
                
                // 将消息分发给对应的 Handler 处理
                msg.target.dispatchMessage(msg)
                
                // 回收消息对象，放入对象池复用
                msg.recycleUnchecked()
            }
        }
        
    }
}

// 主线程 Handler 的典型使用场景
class MainThreadHandlerDemo : Activity() {
    
    // 主线程 Handler，用于在主线程执行代码
    private val mainHandler = Handler(Looper.getMainLooper())
    
    fun performBackgroundTask() {
        // 在后台线程执行耗时操作
        Thread {
            // 模拟耗时操作（网络请求、数据库查询等）
            val result = doHeavyWork()
            
            // 切换回主线程更新 UI
            // 这里发送的消息会进入主线程的 MessageQueue
            // 然后由主线程的 Looper 取出并处理
            mainHandler.post {
                // 这段代码在主线程执行
                updateUI(result)
            }
        }.start()
    }
    
    // 延迟执行任务
    fun scheduleDelayedTask() {
        // 消息会被放入队列，并标记执行时间为 "当前时间 + 1000ms"
        // Looper 会在适当的时机取出并执行
        mainHandler.postDelayed({
            showToast("1秒后执行")
        }, 1000L)
    }
    
    private fun doHeavyWork(): String = "Result"
    private fun updateUI(result: String) { /* 更新界面 */ }
    private fun showToast(message: String) { /* 显示 Toast */ }
}

// ActivityThread.attach() 简化版
private void attach(boolean system, long startSeq) {
    // 保存当前 ActivityThread 实例到静态变量
    // 这使得其他地方可以通过 ActivityThread.currentActivityThread() 获取
    sCurrentActivityThread = this;
    mSystemThread = system;
    
    if (!system) {
        // 非系统进程（普通应用）的处理流程
        
        // 1. 设置应用的 DDMS 名称（用于调试工具显示）
        android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
                                                UserHandle.myUserId());
        
        // 2. 设置运行时的 TargetSdkVersion 回调
        RuntimeInit.setApplicationObject(mAppThread.asBinder());
        
        // 3. 【关键】获取 AMS 的 Binder 代理
        final IActivityManager mgr = ActivityManager.getService();
        
        try {
            // 4. 【关键】调用 AMS 的 attachApplication 方法
            // 将当前进程的 ApplicationThread 传递给 AMS
            // ApplicationThread 是一个 Binder 对象，AMS 通过它回调应用
            mgr.attachApplication(mAppThread, startSeq);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
        
        // 5. 注册 GC 监听器，当内存紧张时会收到通知
        BinderInternal.addGcWatcher(new Runnable() {
            @Override
            public void run() {
                if (!mSomeActivitiesChanged) {
                    return;
                }
                Runtime runtime = Runtime.getRuntime();
                long dalvikMax = runtime.maxMemory();
                long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();
                if (dalvikUsed > ((3 * dalvikMax) / 4)) {
                    // 内存使用超过 75%，尝试释放一些 Activity
                    mSomeActivitiesChanged = false;
                    try {
                        ActivityTaskManager.getService().releaseSomeActivities(mAppThread);
                    } catch (RemoteException e) {
                        throw e.rethrowFromSystemServer();
                    }
                }
            }
        });
    } else {
        // 系统进程的处理流程（system_server）
        // 这里的逻辑与普通应用不同，不在本章讨论范围
    }
    
    // 6. 注册 Configuration 变化的回调
    ViewRootImpl.ConfigChangedCallback configChangedCallback = ...;
    ViewRootImpl.addConfigCallback(configChangedCallback);
}

// ApplicationThread 的工作机制示意
class ApplicationThreadMechanism {
    
    // ApplicationThread 接收 AMS 的调用（运行在 Binder 线程）
    // 然后通过 Handler 转发到主线程处理
    
    
    // 简化的 ApplicationThread 实现
    private inner class ApplicationThread : IApplicationThread.Stub() {
        
        // AMS 调用此方法启动 Activity
        override fun scheduleLaunchActivity(intent: Intent, ...) {
            // 创建 ActivityClientRecord 保存 Activity 信息
            val r = ActivityClientRecord()
            r.intent = intent
            // ...
            
            // 发送消息到主线程的 Handler
            // LAUNCH_ACTIVITY 是消息类型常量
            sendMessage(H.LAUNCH_ACTIVITY, r)
        }
        
        // AMS 调用此方法暂停 Activity
        override fun schedulePauseActivity(token: IBinder, ...) {
            sendMessage(H.PAUSE_ACTIVITY, token)
        }
        
        // 其他生命周期方法类似...
    }
    
    
    // H 类是 ActivityThread 的内部 Handler
    // 负责在主线程处理各种消息
    
    private inner class H : Handler() {
        override fun handleMessage(msg: Message) {
            when (msg.what) {
                LAUNCH_ACTIVITY -> {
                    // 在主线程执行 Activity 启动逻辑
                    val r = msg.obj as ActivityClientRecord
                    handleLaunchActivity(r)
                }
                PAUSE_ACTIVITY -> {
                    // 在主线程执行 Activity 暂停逻辑
                    handlePauseActivity(msg.obj as IBinder)
                }
                // 其他消息类型...
            }
        }
    }
    
}

// Instrumentation 在 Activity 启动过程中的作用
class InstrumentationRole {
    
    // 演示 Instrumentation 如何参与 Activity 的创建和启动
    fun demonstrateActivityCreation() {
        
        // ActivityThread.performLaunchActivity() 简化版
        
        private fun performLaunchActivity(r: ActivityClientRecord): Activity? {
            // 1. 获取 Activity 的类信息
            val component = r.intent.component
            val activityClass = component.className
            
            // 2. 【关键】通过 Instrumentation 创建 Activity 实例
            // 这里使用反射机制实例化 Activity
            val activity = mInstrumentation.newActivity(
                classLoader,      // 类加载器
                activityClass,    // Activity 类名
                r.intent          // 启动 Intent
            )
            
            // 3. 创建 Activity 的 Context
            val appContext = createBaseContextForActivity(r)
            
            // 4. 调用 Activity.attach() 初始化 Activity
            activity.attach(
                appContext,       // Context
                this,             // ActivityThread
                mInstrumentation, // Instrumentation
                r.token,          // Activity 的 Binder 令牌
                application,      // Application 实例
                r.intent,         // Intent
                // ... 其他参数
            )
            
            // 5. 【关键】通过 Instrumentation 调用 onCreate
            mInstrumentation.callActivityOnCreate(activity, r.state)
            
            return activity
        }
        
    }
}

// 自定义 Instrumentation 用于测试
class TestInstrumentation : Instrumentation() {
    
    // 记录所有创建的 Activity
    private val createdActivities = mutableListOf<Activity>()
    
    // 重写 newActivity 方法，可以拦截 Activity 的创建
    override fun newActivity(
        cl: ClassLoader,
        className: String,
        intent: Intent
    ): Activity {
        // 调用父类方法创建 Activity
        val activity = super.newActivity(cl, className, intent)
        
        // 记录创建的 Activity（用于测试验证）
        createdActivities.add(activity)
        
        // 可以在这里进行额外的初始化或监控
        logActivityCreation(className)
        
        return activity
    }
    
    // 重写 callActivityOnCreate，可以监控 onCreate 的调用
    override fun callActivityOnCreate(
        activity: Activity,
        icicle: Bundle?
    ) {
        // 记录 onCreate 开始时间
        val startTime = System.currentTimeMillis()
        
        // 调用真正的 onCreate
        super.callActivityOnCreate(activity, icicle)
        
        // 计算 onCreate 耗时
        val duration = System.currentTimeMillis() - startTime
        logOnCreateDuration(activity.javaClass.simpleName, duration)
    }
    
    private fun logActivityCreation(className: String) {
        // 记录日志
    }
    
    private fun logOnCreateDuration(name: String, duration: Long) {
        // 记录 onCreate 耗时
    }
}

// 启动优化示例
class OptimizedApplication : Application() {
    
    override fun onCreate() {
        super.onCreate()
        
        // 1. 必要的同步初始化（尽量精简）
        initCrashReporter()  // 崩溃上报必须最先初始化
        
        // 2. 非必要初始化延迟到后台线程
        Thread {
            initAnalytics()      // 数据统计
            initImageLoader()    // 图片加载库
            initNetworkClient()  // 网络库
        }.start()
        
        // 3. 某些初始化可以延迟到首屏显示后
        // 使用 IdleHandler 在主线程空闲时执行
        Looper.myQueue().addIdleHandler {
            initNonCriticalSDKs()
            false  // 返回 false 表示只执行一次
        }
    }
    
    private fun initCrashReporter() { /* 崩溃上报初始化 */ }
    private fun initAnalytics() { /* 数据统计初始化 */ }
    private fun initImageLoader() { /* 图片库初始化 */ }
    private fun initNetworkClient() { /* 网络库初始化 */ }
    private fun initNonCriticalSDKs() { /* 非关键 SDK 初始化 */ }
}

<?xml version="1.0" encoding="utf-8"?>
<!-- 
    AndroidManifest.xml 根元素
    xmlns:android 声明 Android 命名空间，用于访问 Android 特有的属性
-->
<manifest 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.example.myapp">
    
    <!-- 权限声明区域 -->
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.CAMERA" />
    
    <!-- 硬件特性声明 -->
    <uses-feature 
        android:name="android.hardware.camera"
        android:required="false" />
    
    <!-- 应用配置区域 -->
    <application
        android:name=".MyApplication"
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme">
        
        <!-- 组件注册区域 -->
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        
        <service android:name=".MyService" />
        
        <receiver android:name=".MyReceiver" />
        
        <provider
            android:name=".MyContentProvider"
            android:authorities="com.example.myapp.provider" />
            
        <!-- 元数据配置 -->
        <meta-data
            android:name="com.example.API_KEY"
            android:value="your-api-key-here" />
            
    </application>
    
</manifest>

// 包名的使用场景示例
class PackageNameUsage(private val context: Context) {
    
    // 1. 获取当前应用的包名
    fun getCurrentPackageName(): String {
        // context.packageName 返回清单文件中声明的包名
        return context.packageName  // 例如: "com.example.myapp"
    }
    
    // 2. 通过包名启动其他应用
    fun launchOtherApp(packageName: String) {
        // 获取该包名应用的启动 Intent
        val intent = context.packageManager
            .getLaunchIntentForPackage(packageName)
        
        intent?.let {
            context.startActivity(it)
        }
    }
    
    // 3. 检查某个应用是否已安装
    fun isAppInstalled(packageName: String): Boolean {
        return try {
            // 尝试获取包信息，如果抛出异常说明未安装
            context.packageManager.getPackageInfo(packageName, 0)
            true
        } catch (e: PackageManager.NameNotFoundException) {
            false
        }
    }
    
    // 4. 包名用于构建 ContentProvider 的 URI
    fun buildContentUri(): Uri {
        // authority 通常基于包名，确保唯一性
        return Uri.parse("content://com.example.myapp.provider/users")
    }
    
    // 5. 包名用于文件存储路径
    fun getAppSpecificDirectory(): File {
        // 返回 /data/data/com.example.myapp/files
        // 系统根据包名为每个应用分配独立的存储目录
        return context.filesDir
    }
}

// build.gradle.kts (Module level)
android {
    namespace = "com.example.myapp"  // 替代清单文件中的 package
    
    defaultConfig {
        // 这是应用的真正唯一标识
        applicationId = "com.example.myapp"
        // ...
    }
    
    buildTypes {
        debug {
            // Debug 版本使用不同的 applicationId
            // 这样可以同时安装 debug 和 release 版本
            applicationIdSuffix = ".debug"
            // 最终 applicationId: com.example.myapp.debug
        }
    }
    
    flavorDimensions += "version"
    productFlavors {
        create("free") {
            applicationIdSuffix = ".free"
            // 最终 applicationId: com.example.myapp.free
        }
        create("paid") {
            applicationIdSuffix = ".paid"
            // 最终 applicationId: com.example.myapp.paid
        }
    }
}

<!-- Activity 完整注册示例 -->
<activity
    android:name=".ui.MainActivity"
    
    android:label="@string/main_activity_title"
    
    android:icon="@mipmap/ic_main"
    
    android:theme="@style/Theme.MyApp.Main"
    
    android:screenOrientation="portrait"
    
    android:launchMode="singleTop"
    
    android:taskAffinity="com.example.myapp.main"
    
    android:windowSoftInputMode="adjustResize"
    
    android:configChanges="orientation|screenSize|keyboardHidden"
    
    android:exported="true">
    
    <!-- Intent Filter 定义该 Activity 可以响应的 Intent -->
    <intent-filter>
        <!-- MAIN action 表示这是应用的入口点 -->
        <action android:name="android.intent.action.MAIN" />
        <!-- LAUNCHER category 表示在桌面显示图标 -->
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
    
    <!-- 可以有多个 intent-filter，响应不同类型的 Intent -->
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <!-- 处理特定 scheme 的 URL -->
        <data
            android:scheme="myapp"
            android:host="open" />
    </intent-filter>
    
</activity>

<!-- Service 注册示例 -->
 
<!-- 普通后台服务 -->
<service
    android:name=".service.DownloadService"
    android:enabled="true"
    android:exported="false"
    android:description="@string/download_service_desc">
</service>
 
<!-- 前台服务（Android 9+ 需要声明前台服务类型） -->
<service
    android:name=".service.MusicPlayerService"
    android:enabled="true"
    android:exported="false"
    android:foregroundServiceType="mediaPlayback">
</service>
 
<!-- 可被其他应用绑定的服务 -->
<service
    android:name=".service.RemoteService"
    android:enabled="true"
    android:exported="true"
    android:permission="com.example.myapp.permission.BIND_REMOTE_SERVICE">
    <intent-filter>
        <action android:name="com.example.myapp.action.REMOTE_SERVICE" />
    </intent-filter>
</service>
 
<!-- 运行在独立进程的服务 -->
<service
    android:name=".service.IsolatedService"
    android:process=":isolated"
    android:isolatedProcess="true">
</service>

<!-- BroadcastReceiver 静态注册示例 -->
 
<!-- 接收开机完成广播（少数仍支持静态注册的系统广播） -->
<receiver
    android:name=".receiver.BootCompletedReceiver"
    android:enabled="true"
    android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.BOOT_COMPLETED" />
    </intent-filter>
</receiver>
 
<!-- 接收应用自定义广播 -->
<receiver
    android:name=".receiver.CustomActionReceiver"
    android:enabled="true"
    android:exported="false">
    <intent-filter>
        <action android:name="com.example.myapp.action.CUSTOM_EVENT" />
    </intent-filter>
</receiver>
 
<!-- 带权限保护的广播接收器 -->
<receiver
    android:name=".receiver.SecureReceiver"
    android:permission="com.example.myapp.permission.SEND_SECURE_BROADCAST"
    android:exported="true">
    <intent-filter>
        <action android:name="com.example.myapp.action.SECURE_EVENT" />
    </intent-filter>
</receiver>

// 动态注册广播接收器（推荐方式）
class DynamicReceiverExample : Activity() {
    
    // 定义广播接收器
    private val networkReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context, intent: Intent) {
            // 处理网络状态变化
            val isConnected = checkNetworkConnectivity(context)
            updateUI(isConnected)
        }
    }
    
    override fun onStart() {
        super.onStart()
        // 在 Activity 可见时注册接收器
        val filter = IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)
        registerReceiver(networkReceiver, filter)
    }
    
    override fun onStop() {
        super.onStop()
        // 在 Activity 不可见时注销接收器，避免内存泄漏
        unregisterReceiver(networkReceiver)
    }
    
    private fun checkNetworkConnectivity(context: Context): Boolean = true
    private fun updateUI(isConnected: Boolean) { /* 更新界面 */ }
}

<!-- ContentProvider 注册示例 -->
<provider
    android:name=".provider.UserDataProvider"
    
    android:authorities="com.example.myapp.provider.userdata"
    
    android:exported="true"
    
    android:readPermission="com.example.myapp.permission.READ_USER_DATA"
    android:writePermission="com.example.myapp.permission.WRITE_USER_DATA"
    
    android:grantUriPermissions="true">
    
    <!-- 细粒度的 URI 权限控制 -->
    <path-permission
        android:pathPrefix="/public"
        android:readPermission="android.permission.INTERNET" />
        
    <grant-uri-permission android:pathPattern="/shared/.*" />
    
</provider>
 
<!-- FileProvider 用于安全地共享文件（Android 7.0+ 必需） -->
<provider
    android:name="androidx.core.content.FileProvider"
    android:authorities="${applicationId}.fileprovider"
    android:exported="false"
    android:grantUriPermissions="true">
    <meta-data
        android:name="android.support.FILE_PROVIDER_PATHS"
        android:resource="@xml/file_paths" />
</provider>

<!-- 权限声明示例 -->
<manifest ...>
    
    <!-- Normal 权限：安装时自动授予 -->
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.VIBRATE" />
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    
    <!-- Dangerous 权限：需要运行时请求 -->
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
    <uses-permission android:name="android.permission.READ_CONTACTS" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    
    <!-- 后台位置权限（Android 10+ 需要单独声明） -->
    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
    
    <!-- 存储权限（Android 版本差异较大） -->
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" 
        android:maxSdkVersion="32" />
    <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
    <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
    
    <!-- 特殊权限：需要引导用户到设置页面手动开启 -->
    <!-- SYSTEM_ALERT_WINDOW: 悬浮窗权限 -->
    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
    <!-- WRITE_SETTINGS: 修改系统设置 -->
    <uses-permission android:name="android.permission.WRITE_SETTINGS" />
    
</manifest>

<manifest ...>
    
    <!-- 定义自定义权限 -->
    <permission
        android:name="com.example.myapp.permission.ACCESS_PREMIUM_FEATURES"
        android:label="@string/permission_premium_label"
        android:description="@string/permission_premium_description"
        android:protectionLevel="signature" />
    
    <permission
        android:name="com.example.myapp.permission.RECEIVE_PUSH"
        android:label="@string/permission_push_label"
        android:description="@string/permission_push_description"
        android:protectionLevel="normal" />
    
    <application ...>
        
        <!-- 使用自定义权限保护组件 -->
        <activity
            android:name=".PremiumActivity"
            android:permission="com.example.myapp.permission.ACCESS_PREMIUM_FEATURES"
            android:exported="true" />
            
        <receiver
            android:name=".PushReceiver"
            android:permission="com.example.myapp.permission.RECEIVE_PUSH"
            android:exported="true">
            <intent-filter>
                <action android:name="com.example.myapp.action.PUSH_MESSAGE" />
            </intent-filter>
        </receiver>
        
    </application>
    
</manifest>

<application ...>
    
    <!-- 场景1：第三方 SDK 配置 -->
    <!-- Google Maps API Key -->
    <meta-data
        android:name="com.google.android.geo.API_KEY"
        android:value="AIzaSyXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" />
    
    <!-- Firebase 配置 -->
    <meta-data
        android:name="com.google.firebase.messaging.default_notification_icon"
        android:resource="@drawable/ic_notification" />
    
    <meta-data
        android:name="com.google.firebase.messaging.default_notification_channel_id"
        android:value="@string/default_notification_channel_id" />
    
    <!-- 场景2：应用全局配置 -->
    <meta-data
        android:name="com.example.myapp.CONFIG_ENV"
        android:value="production" />
    
    <meta-data
        android:name="com.example.myapp.FEATURE_FLAGS"
        android:resource="@xml/feature_flags" />
    
    <!-- 场景3：组件级别的元数据 -->
    <activity android:name=".MainActivity">
        <meta-data
            android:name="android.app.shortcuts"
            android:resource="@xml/shortcuts" />
    </activity>
    
    <service android:name=".MyJobService"
        android:permission="android.permission.BIND_JOB_SERVICE">
        <meta-data
            android:name="com.example.myapp.JOB_PRIORITY"
            android:value="high" />
    </service>
    
    <!-- 场景4：FileProvider 路径配置 -->
    <provider
        android:name="androidx.core.content.FileProvider"
        android:authorities="${applicationId}.fileprovider"
        android:exported="false"
        android:grantUriPermissions="true">
        <meta-data
            android:name="android.support.FILE_PROVIDER_PATHS"
            android:resource="@xml/file_paths" />
    </provider>
    
</application>

// 读取 Meta-Data 的各种方式
class MetaDataReader(private val context: Context) {
    
    // 读取 Application 级别的元数据
    fun readApplicationMetaData() {
        try {
            // 获取 ApplicationInfo，包含 meta-data 信息
            val appInfo = context.packageManager.getApplicationInfo(
                context.packageName,
                PackageManager.GET_META_DATA  // 必须指定这个 flag
            )
            
            // 从 Bundle 中读取不同类型的值
            val metaData: Bundle = appInfo.metaData ?: return
            
            // 读取字符串值
            val apiKey = metaData.getString("com.google.android.geo.API_KEY")
            
            // 读取整数值
            val configValue = metaData.getInt("com.example.myapp.CONFIG_INT", -1)
            
            // 读取布尔值
            val featureEnabled = metaData.getBoolean("com.example.myapp.FEATURE_ENABLED", false)
            
            // 读取资源引用（返回资源 ID）
            val resourceId = metaData.getInt("com.example.myapp.FEATURE_FLAGS")
            
            Log.d("MetaData", "API Key: $apiKey")
            Log.d("MetaData", "Config: $configValue")
            Log.d("MetaData", "Feature: $featureEnabled")
            
        } catch (e: PackageManager.NameNotFoundException) {
            Log.e("MetaData", "Package not found", e)
        }
    }
    
    // 读取 Activity 级别的元数据
    fun readActivityMetaData(activityClass: Class<*>) {
        try {
            val activityInfo = context.packageManager.getActivityInfo(
                ComponentName(context, activityClass),
                PackageManager.GET_META_DATA
            )
            
            val metaData = activityInfo.metaData ?: return
            val shortcutsRes = metaData.getInt("android.app.shortcuts")
            
            Log.d("MetaData", "Shortcuts resource: $shortcutsRes")
            
        } catch (e: PackageManager.NameNotFoundException) {
            Log.e("MetaData", "Activity not found", e)
        }
    }
    
    // 读取 Service 级别的元数据
    fun readServiceMetaData(serviceClass: Class<*>) {
        try {
            val serviceInfo = context.packageManager.getServiceInfo(
                ComponentName(context, serviceClass),
                PackageManager.GET_META_DATA
            )
            
            val metaData = serviceInfo.metaData ?: return
            val priority = metaData.getString("com.example.myapp.JOB_PRIORITY")
            
            Log.d("MetaData", "Job priority: $priority")
            
        } catch (e: PackageManager.NameNotFoundException) {
            Log.e("MetaData", "Service not found", e)
        }
    }
    
    // 读取 Receiver 级别的元数据
    fun readReceiverMetaData(receiverClass: Class<*>) {
        try {
            val receiverInfo = context.packageManager.getReceiverInfo(
                ComponentName(context, receiverClass),
                PackageManager.GET_META_DATA
            )
            
            val metaData = receiverInfo.metaData
            // 处理元数据...
            
        } catch (e: PackageManager.NameNotFoundException) {
            Log.e("MetaData", "Receiver not found", e)
        }
    }
}

<manifest ...>
    
    <!-- 硬件特性声明 -->
    
    <!-- 相机特性 -->
    <uses-feature 
        android:name="android.hardware.camera"
        android:required="true" />
    <!-- 自动对焦（可选） -->
    <uses-feature 
        android:name="android.hardware.camera.autofocus"
        android:required="false" />
    
    <!-- 位置特性 -->
    <uses-feature 
        android:name="android.hardware.location.gps"
        android:required="false" />
    
    <!-- 传感器特性 -->
    <uses-feature 
        android:name="android.hardware.sensor.accelerometer"
        android:required="false" />
    <uses-feature 
        android:name="android.hardware.sensor.gyroscope"
        android:required="false" />
    
    <!-- 蓝牙特性 -->
    <uses-feature 
        android:name="android.hardware.bluetooth"
        android:required="false" />
    <uses-feature 
        android:name="android.hardware.bluetooth_le"
        android:required="false" />
    
    <!-- NFC 特性 -->
    <uses-feature 
        android:name="android.hardware.nfc"
        android:required="false" />
    
    <!-- 触摸屏特性（大多数应用隐式需要） -->
    <uses-feature 
        android:name="android.hardware.touchscreen"
        android:required="false" />
    
    <!-- 软件特性声明 -->
    
    <!-- OpenGL ES 版本要求 -->
    <uses-feature 
        android:glEsVersion="0x00030000"
        android:required="true" />
    
</manifest>

// 运行时检查硬件特性
class FeatureChecker(private val context: Context) {
    
    private val packageManager = context.packageManager
    
    // 检查相机是否可用
    fun hasCameraFeature(): Boolean {
        return packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA_ANY)
    }
    
    // 检查 GPS 是否可用
    fun hasGpsFeature(): Boolean {
        return packageManager.hasSystemFeature(PackageManager.FEATURE_LOCATION_GPS)
    }
    
    // 检查蓝牙 LE 是否可用
    fun hasBluetoothLeFeature(): Boolean {
        return packageManager.hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)
    }
    
    // 检查 NFC 是否可用
    fun hasNfcFeature(): Boolean {
        return packageManager.hasSystemFeature(PackageManager.FEATURE_NFC)
    }
    
    // 根据特性可用性调整 UI
    fun setupCameraButton(button: Button) {
        if (hasCameraFeature()) {
            button.isEnabled = true
            button.setOnClickListener { openCamera() }
        } else {
            button.isEnabled = false
            button.text = "相机不可用"
        }
    }
    
    private fun openCamera() { /* 打开相机 */ }
}

// build.gradle.kts
android {
    compileSdk = 34  // 编译时使用的 SDK 版本
    
    defaultConfig {
        minSdk = 21      // 最低支持的 Android 版本（Android 5.0）
        targetSdk = 34   // 目标 SDK 版本（Android 14）
    }
}

// targetSdk 影响示例
class TargetSdkBehavior(private val context: Context) {
    
    // 示例：运行时权限
    // targetSdk < 23: 权限在安装时自动授予
    // targetSdk >= 23: 危险权限需要运行时请求
    
    // 示例：后台限制
    // targetSdk < 26: 可以自由启动后台服务
    // targetSdk >= 26: 后台启动服务受限，需要使用 startForegroundService
    
    // 示例：存储访问
    // targetSdk < 29: 可以自由访问外部存储
    // targetSdk >= 29: 启用分区存储（Scoped Storage）
    // targetSdk >= 30: 强制分区存储，无法通过 requestLegacyExternalStorage 绕过
    
    fun startBackgroundWork() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            // Android 8.0+ 需要使用前台服务
            val intent = Intent(context, MyForegroundService::class.java)
            context.startForegroundService(intent)
        } else {
            // 旧版本可以直接启动后台服务
            val intent = Intent(context, MyBackgroundService::class.java)
            context.startService(intent)
        }
    }
}

<manifest 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.example.myapp">
    
    <!-- 替换库中声明的属性值 -->
    <application
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        tools:replace="android:icon,android:label">
        
        <!-- 移除库中声明的某个组件 -->
        <activity
            android:name="com.thirdparty.UnwantedActivity"
            tools:node="remove" />
        
        <!-- 覆盖库中组件的某些属性 -->
        <service
            android:name="com.thirdparty.SomeService"
            android:exported="false"
            tools:replace="android:exported" />
        
        <!-- 强制保留某个属性，即使库中没有声明 -->
        <receiver
            android:name=".MyReceiver"
            android:enabled="true"
            tools:node="merge"
            tools:strict="android:enabled" />
            
    </application>
    
    <!-- 移除库中声明的权限 -->
    <uses-permission 
        android:name="android.permission.WRITE_EXTERNAL_STORAGE"
        tools:node="remove" />
    
</manifest>

// Application 单例的获取方式对比
class MyApplication : Application() {
    
    companion object {
        // 方式一：静态变量持有（常见但需注意初始化时机）
        // lateinit 表示延迟初始化，在 onCreate 中赋值
        lateinit var instance: MyApplication
            private set  // 外部只读，内部可写
    }
    
    override fun onCreate() {
        super.onCreate()
        // 在 onCreate 中初始化静态引用
        // 此时 Application 已完全构造完成，可以安全使用
        instance = this
    }
}
 
// 方式二：通过 Context 获取（推荐，更安全）
class SomeClass(private val context: Context) {
    
    fun doSomething() {
        // applicationContext 返回的就是 Application 实例
        // 这是 Android 官方推荐的获取方式
        val app = context.applicationContext as MyApplication
        
        // 或者直接使用 applicationContext，无需强转
        // 适用于只需要 Context 功能而不需要自定义方法的场景
        val appContext: Context = context.applicationContext
    }
}

// 正确示例：Application 作为依赖注入的根容器
class MyApplication : Application() {
    
    // 懒加载的全局服务实例
    // by lazy 保证线程安全且只初始化一次
    val networkModule: NetworkModule by lazy {
        // 创建网络模块，传入 Application Context
        // 使用 applicationContext 而非 this 是一种防御性编程
        NetworkModule(applicationContext)
    }
    
    // 数据库实例，整个应用共享
    val database: AppDatabase by lazy {
        // Room 数据库构建，需要 Context 参数
        Room.databaseBuilder(
            applicationContext,           // 使用 Application Context
            AppDatabase::class.java,      // 数据库类
            "app_database"                // 数据库文件名
        ).build()
    }
    
    override fun onCreate() {
        super.onCreate()
        // 初始化必须在应用启动时完成的组件
        initializeLogging()      // 日志系统
        initializeCrashReporting() // 崩溃上报
    }
    
    private fun initializeLogging() {
        // 仅在 Debug 构建时启用详细日志
        if (BuildConfig.DEBUG) {
            // Timber 是一个流行的日志库
            // DebugTree 会自动添加类名和行号
            Timber.plant(Timber.DebugTree())
        }
    }
    
    private fun initializeCrashReporting() {
        // 生产环境启用崩溃收集
        if (!BuildConfig.DEBUG) {
            // 初始化 Firebase Crashlytics
            FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(true)
        }
    }
}

class MyApplication : Application() {
    
    // attachBaseContext 是最早的初始化时机
    // 此时 Application 的 Context 刚刚被绑定
    override fun attachBaseContext(base: Context) {
        // 必须首先调用 super，否则后续代码无法使用 Context
        super.attachBaseContext(base)
        
        // 适合在这里做的事情：
        // 1. MultiDex 安装（Android 5.0 以下需要）
        //    MultiDex.install(this)
        
        // 2. 热修复框架的早期初始化
        //    因为热修复需要在类加载之前介入
        //    Tinker.install(this)
        
        // 3. 某些需要极早初始化的安全检测
        //    SecurityChecker.init(this)
        
        // 注意：此时 ContentProvider 尚未初始化
        // 不要在这里访问 ContentProvider
    }
    
    override fun onCreate() {
        super.onCreate()
        
        // onCreate 是常规初始化时机
        // 此时 ContentProvider 已经初始化完成
        // 可以安全地进行各种初始化操作
        
        // 适合在这里做的事情：
        // 1. 第三方 SDK 初始化
        initializeThirdPartySDKs()
        
        // 2. 全局异常处理器
        setupGlobalExceptionHandler()
        
        // 3. 应用配置加载
        loadAppConfiguration()
    }
    
    private fun initializeThirdPartySDKs() {
        // 按照依赖顺序初始化各个 SDK
        // 网络库通常最先初始化，因为其他 SDK 可能依赖它
        initializeNetworking()
        
        // 然后是分析和监控类 SDK
        initializeAnalytics()
        
        // 最后是业务相关的 SDK
        initializeBusinessSDKs()
    }
    
    private fun setupGlobalExceptionHandler() {
        // 获取默认的异常处理器
        val defaultHandler = Thread.getDefaultUncaughtExceptionHandler()
        
        // 设置自定义的全局异常处理器
        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
            // 记录崩溃日志
            logCrash(thread, throwable)
            
            // 调用默认处理器（通常会终止应用）
            defaultHandler?.uncaughtException(thread, throwable)
        }
    }
    
    private fun logCrash(thread: Thread, throwable: Throwable) {
        // 将崩溃信息写入本地文件
        // 下次启动时上传到服务器
        Timber.e(throwable, "Crash on thread: ${thread.name}")
    }
    
    private fun loadAppConfiguration() {
        // 从 SharedPreferences 或远程配置加载应用设置
        // 这些配置会影响后续的应用行为
    }
    
    private fun initializeNetworking() { /* ... */ }
    private fun initializeAnalytics() { /* ... */ }
    private fun initializeBusinessSDKs() { /* ... */ }
}

class MyApplication : Application() {
    
    override fun onCreate() {
        super.onCreate()
        
        // 策略一：只初始化启动必需的组件
        // 这些组件如果不初始化，应用无法正常显示第一个界面
        initializeCriticalComponents()
        
        // 策略二：使用 IdleHandler 在主线程空闲时初始化
        // 这样不会阻塞界面渲染
        scheduleIdleInitialization()
        
        // 策略三：使用后台线程初始化非 UI 相关组件
        // 注意：某些 SDK 要求在主线程初始化，需要查阅文档
        scheduleBackgroundInitialization()
    }
    
    private fun initializeCriticalComponents() {
        // 只放启动必需的初始化
        // 例如：崩溃收集（需要尽早启动以捕获启动阶段的崩溃）
        // 例如：路由框架（否则无法跳转到正确的 Activity）
    }
    
    private fun scheduleIdleInitialization() {
        // 获取主线程的消息队列
        Looper.myQueue().addIdleHandler {
            // 当主线程空闲时（没有待处理的消息），这个回调会被执行
            // 适合初始化那些"不急但最好早点有"的组件
            
            initializeAnalyticsSDK()  // 数据分析 SDK
            initializePushSDK()       // 推送 SDK
            
            // 返回 false 表示这个 IdleHandler 只执行一次
            // 返回 true 则每次空闲都会执行
            false
        }
    }
    
    private fun scheduleBackgroundInitialization() {
        // 使用协程在后台线程执行初始化
        // GlobalScope 在 Application 中使用是安全的
        // 因为 Application 的生命周期等于进程生命周期
        GlobalScope.launch(Dispatchers.IO) {
            // 这些初始化不需要在主线程执行
            // 也不需要在应用启动时立即完成
            
            initializeImageLoader()   // 图片加载库
            initializeDatabase()      // 数据库预热
            preloadCommonData()       // 预加载常用数据
        }
    }
    
    private fun initializeAnalyticsSDK() { /* ... */ }
    private fun initializePushSDK() { /* ... */ }
    private fun initializeImageLoader() { /* ... */ }
    private fun initializeDatabase() { /* ... */ }
    private fun preloadCommonData() { /* ... */ }
}

class MyApplication : Application() {
    
    // ==================== 核心生命周期 ====================
    
    override fun attachBaseContext(base: Context) {
        super.attachBaseContext(base)
        // 最早的初始化时机
        // Context 刚刚绑定，ContentProvider 尚未创建
    }
    
    override fun onCreate() {
        super.onCreate()
        // 标准初始化时机
        // ContentProvider 已创建，可以安全使用各种 Context 功能
    }
    
    override fun onTerminate() {
        super.onTerminate()
        // 应用进程终止时调用
        // 重要：这个方法只在模拟器中被调用！
        // 在真实设备上，进程被杀死时不会调用此方法
        // 因此不要依赖它来做清理工作
    }
    
    // ==================== 配置变更回调 ====================
    
    override fun onConfigurationChanged(newConfig: Configuration) {
        super.onConfigurationChanged(newConfig)
        // 设备配置发生变化时调用
        // 例如：屏幕旋转、语言切换、字体大小变化、深色模式切换
        
        // 检查具体是什么配置发生了变化
        when {
            // 检查是否是深色模式变化
            newConfig.uiMode and Configuration.UI_MODE_NIGHT_MASK == 
                Configuration.UI_MODE_NIGHT_YES -> {
                // 切换到深色模式
                onDarkModeEnabled()
            }
            newConfig.uiMode and Configuration.UI_MODE_NIGHT_MASK == 
                Configuration.UI_MODE_NIGHT_NO -> {
                // 切换到浅色模式
                onDarkModeDisabled()
            }
        }
        
        // 检查语言变化
        val currentLocale = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            newConfig.locales[0]
        } else {
            @Suppress("DEPRECATION")
            newConfig.locale
        }
        onLocaleChanged(currentLocale)
    }
    
    private fun onDarkModeEnabled() {
        // 通知各个模块切换到深色主题资源
        Timber.d("Dark mode enabled")
    }
    
    private fun onDarkModeDisabled() {
        // 通知各个模块切换到浅色主题资源
        Timber.d("Dark mode disabled")
    }
    
    private fun onLocaleChanged(locale: Locale) {
        // 语言变化时可能需要重新加载某些资源
        Timber.d("Locale changed to: ${locale.language}")
    }
    
    // ==================== 内存管理回调 ====================
    
    override fun onLowMemory() {
        super.onLowMemory()
        // 系统内存严重不足时调用
        // 这是一个强烈的信号：必须立即释放内存，否则进程可能被杀死
        // 详见下一节的深入讲解
    }
    
    override fun onTrimMemory(level: Int) {
        super.onTrimMemory(level)
        // 系统请求应用释放内存
        // level 参数表示内存压力的程度
        // 详见下一节的深入讲解
    }
}

class MyApplication : Application() {
    
    override fun onTrimMemory(level: Int) {
        super.onTrimMemory(level)
        
        when (level) {
            // ========== 应用在前台运行时的级别 ==========
            
            TRIM_MEMORY_RUNNING_MODERATE -> {
                // 级别 5：系统内存开始紧张，但应用仍在前台
                // 建议：释放不必要的缓存
                Timber.d("Memory: Running Moderate - 释放部分缓存")
                releaseNonCriticalCaches()
            }
            
            TRIM_MEMORY_RUNNING_LOW -> {
                // 级别 10：系统内存较低，应用仍在前台
                // 建议：释放更多缓存，减少内存占用
                Timber.d("Memory: Running Low - 释放更多缓存")
                releaseMoreCaches()
            }
            
            TRIM_MEMORY_RUNNING_CRITICAL -> {
                // 级别 15：系统内存严重不足，应用仍在前台
                // 建议：释放所有可释放的内存
                // 如果不释放，后台应用会被杀死
                Timber.d("Memory: Running Critical - 释放所有非必要内存")
                releaseAllNonEssentialMemory()
            }
            
            // ========== 应用 UI 不可见时的级别 ==========
            
            TRIM_MEMORY_UI_HIDDEN -> {
                // 级别 20：应用的 UI 已经不可见（用户按了 Home 键）
                // 这是释放 UI 相关资源的好时机
                // 例如：释放大图片、清除 View 缓存
                Timber.d("Memory: UI Hidden - 释放 UI 资源")
                releaseUIResources()
            }
            
            // ========== 应用在后台时的级别 ==========
            
            TRIM_MEMORY_BACKGROUND -> {
                //级别 40：应用进程在 LRU 列表的开头（最近使用）
                // 系统内存紧张，但应用暂时安全
                // 建议：释放容易恢复的资源
                Timber.d("Memory: Background - 释放可恢复资源")
                releaseRecoverableResources()
            }
            
            TRIM_MEMORY_MODERATE -> {
                // 级别 60：应用进程在 LRU 列表的中间位置
                // 如果内存继续紧张，进程可能被杀死
                // 建议：释放更多资源
                Timber.d("Memory: Moderate - 进程可能被杀死，释放更多资源")
                releaseMoreResources()
            }
            
            TRIM_MEMORY_COMPLETE -> {
                // 级别 80：应用进程在 LRU 列表的末尾（最久未使用）
                // 进程随时可能被杀死
                // 建议：释放所有可释放的资源
                Timber.d("Memory: Complete - 进程即将被杀死，释放一切")
                releaseEverythingPossible()
            }
        }
    }
    
    // 分级释放策略的具体实现
    private fun releaseNonCriticalCaches() {
        // 释放非关键缓存，如预加载的数据
        imageLoader?.clearMemoryCache(percentage = 25)
    }
    
    private fun releaseMoreCaches() {
        // 释放更多缓存
        imageLoader?.clearMemoryCache(percentage = 50)
        dataCache?.trimToSize(dataCache.maxSize() / 2)
    }
    
    private fun releaseAllNonEssentialMemory() {
        // 释放所有非必要内存
        imageLoader?.clearMemoryCache(percentage = 100)
        dataCache?.evictAll()
    }
    
    private fun releaseUIResources() {
        // 释放 UI 相关资源
        // 例如：通知图片加载库清除内存缓存
        Glide.get(this).clearMemory()
    }
    
    private fun releaseRecoverableResources() {
        // 释放可以从磁盘或网络恢复的资源
        releaseUIResources()
        clearInMemoryDatabaseCache()
    }
    
    private fun releaseMoreResources() {
        releaseRecoverableResources()
        // 释放更多资源，如预编译的正则表达式、缓存的计算结果等
    }
    
    private fun releaseEverythingPossible() {
        releaseMoreResources()
        // 最后的努力：释放一切可以释放的
        System.gc()  // 建议 GC（不保证立即执行）
    }
    
    // 占位符变量，实际项目中应该是真实的实例
    private var imageLoader: ImageLoader? = null
    private var dataCache: LruCache<String, Any>? = null
    
    private fun clearInMemoryDatabaseCache() { /* ... */ }
}
 
// 辅助接口定义
interface ImageLoader {
    fun clearMemoryCache(percentage: Int)
}

class MyApplication : Application() {
    
    override fun onLowMemory() {
        super.onLowMemory()
        
        // onLowMemory 被调用意味着系统内存已经非常紧张
        // 必须立即释放所有可释放的内存
        
        Timber.w("onLowMemory called - 系统内存严重不足！")
        
        // 1. 清除所有内存缓存
        clearAllMemoryCaches()
        
        // 2. 释放所有可释放的资源
        releaseAllResources()
        
        // 3. 通知所有注册的监听器
        notifyLowMemoryListeners()
        
        // 4. 建议进行垃圾回收
        // 注意：System.gc() 只是建议，不保证立即执行
        System.gc()
    }
    
    // 内存监听器列表
    private val lowMemoryListeners = mutableListOf<LowMemoryListener>()
    
    fun registerLowMemoryListener(listener: LowMemoryListener) {
        lowMemoryListeners.add(listener)
    }
    
    fun unregisterLowMemoryListener(listener: LowMemoryListener) {
        lowMemoryListeners.remove(listener)
    }
    
    private fun notifyLowMemoryListeners() {
        // 通知所有监听器释放内存
        lowMemoryListeners.forEach { listener ->
            try {
                listener.onLowMemory()
            } catch (e: Exception) {
                // 捕获异常，确保一个监听器的错误不会影响其他监听器
                Timber.e(e, "Error notifying low memory listener")
            }
        }
    }
    
    private fun clearAllMemoryCaches() {
        // 清除图片缓存
        Glide.get(this).clearMemory()
        
        // 清除自定义缓存
        // ...
    }
    
    private fun releaseAllResources() {
        // 释放所有可释放的资源
        // ...
    }
}
 
// 低内存监听器接口
interface LowMemoryListener {
    fun onLowMemory()
}

class MyApplication : Application() {
    
    override fun onCreate() {
        super.onCreate()
        // Glide 会自动注册为 ComponentCallbacks2 的监听器
        // 但我们也可以手动控制其行为
    }
    
    override fun onTrimMemory(level: Int) {
        super.onTrimMemory(level)
        // Glide 提供了便捷的内存管理方法
        Glide.get(this).trimMemory(level)
    }
    
    override fun onLowMemory() {
        super.onLowMemory()
        // 清除 Glide 的所有内存缓存
        Glide.get(this).clearMemory()
    }
}
 
// 自定义 Glide 模块，配置内存缓存策略
@GlideModule
class CustomGlideModule : AppGlideModule() {
    
    override fun applyOptions(context: Context, builder: GlideBuilder) {
        // 配置内存缓存大小
        val memoryCacheSizeBytes = 1024 * 1024 * 20  // 20 MB
        builder.setMemoryCache(LruResourceCache(memoryCacheSizeBytes.toLong()))
        
        // 配置 Bitmap 池大小
        val bitmapPoolSizeBytes = 1024 * 1024 * 30  // 30 MB
        builder.setBitmapPool(LruBitmapPool(bitmapPoolSizeBytes.toLong()))
    }
    
    override fun isManifestParsingEnabled(): Boolean {
        // 禁用清单解析以提高启动速度
        return false
    }
}

<!-- AndroidManifest.xml 中的多进程配置 -->
<application android:name=".MyApplication">
    
    <!-- 主进程中的 Activity -->
    <activity android:name=".MainActivity" />
    
    <!-- 独立进程中的 Service -->
    <!-- :remote 表示私有进程，完整名称是 包名:remote -->
    <service 
        android:name=".RemoteService"
        android:process=":remote" />
    
    <!-- 另一个独立进程中的 ContentProvider -->
    <provider
        android:name=".DataProvider"
        android:authorities="${applicationId}.provider"
        android:process=":provider"
        android:exported="false" />
        
</application>

class MyApplication : Application() {
    
    override fun onCreate() {
        super.onCreate()
        
        // 获取当前进程名称
        val processName = getProcessName()
        
        // 根据进程名称决定初始化策略
        when {
            processName == packageName -> {
                // 主进程：执行完整初始化
                initializeMainProcess()
            }
            processName?.endsWith(":remote") == true -> {
                // remote 进程：只初始化该进程需要的组件
                initializeRemoteProcess()
            }
            processName?.endsWith(":provider") == true -> {
                // provider 进程：最小化初始化
                initializeProviderProcess()
            }
            else -> {
                // 未知进程：基础初始化
                initializeBaseComponents()
            }
        }
    }
    
    private fun getProcessName(): String? {
        // 方法一：通过 ActivityManager 获取（兼容性好）
        val pid = android.os.Process.myPid()
        val activityManager = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
        
        return activityManager.runningAppProcesses?.find { 
            it.pid == pid 
        }?.processName
        
        // 方法二：Android 9+ 可以直接获取
        // return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
        //     Application.getProcessName()
        // } else {
        //     // 使用方法一的逻辑
        // }
    }
    
    private fun initializeMainProcess() {
        Timber.d("Initializing main process")
        
        // 主进程需要完整的初始化
        initializeUI()           // UI 相关
        initializeNetworking()   // 网络
        initializeDatabase()     // 数据库
        initializeAnalytics()    // 数据分析
        initializePush()         // 推送
    }
    
    private fun initializeRemoteProcess() {
        Timber.d("Initializing remote process")
        
        // Remote 进程可能只需要网络和特定的业务逻辑
        initializeNetworking()
        initializeRemoteServiceComponents()
    }
    
    private fun initializeProviderProcess() {
        Timber.d("Initializing provider process")
        
        // Provider 进程只需要数据库
        initializeDatabase()
    }
    
    private fun initializeBaseComponents() {
        Timber.d("Initializing base components")
        
        // 所有进程都需要的基础组件
        initializeLogging()
        initializeCrashReporting()
    }
    
    // 各个初始化方法的占位实现
    private fun initializeUI() { /* ... */ }
    private fun initializeNetworking() { /* ... */ }
    private fun initializeDatabase() { /* ... */ }
    private fun initializeAnalytics() { /* ... */ }
    private fun initializePush() { /* ... */ }
    private fun initializeRemoteServiceComponents() { /* ... */ }
    private fun initializeLogging() { /* ... */ }
    private fun initializeCrashReporting() { /* ... */ }
}

class MyApplication : Application() {
    
    companion object {
        // 这个变量在每个进程中都有独立的副本
        // 在主进程中修改它，不会影响 :remote 进程中的值
        var sharedData: String = "initial"
    }
    
    override fun onCreate() {
        super.onCreate()
        
        // 演示进程隔离
        val processName = getProcessName()
        Timber.d("Process: $processName, sharedData before: $sharedData")
        
        sharedData = "modified in $processName"
        Timber.d("Process: $processName, sharedData after: $sharedData")
        
        // 输出结果（假设主进程先启动，然后 :remote 进程启动）：
        // 主进程：sharedData before: initial, after: modified in com.example.app
        // :remote 进程：sharedData before: initial, after: modified in com.example.app:remote
        // 注意：:remote 进程看到的 before 值仍然是 "initial"，而不是主进程修改后的值
    }
    
    private fun getProcessName(): String? {
        // 实现同上
        return null
    }
}

// ZygoteConnection.java 中的核心逻辑（简化版）
// 这段代码展示了 Zygote 如何处理来自 AMS 的进程创建请求
public Runnable processCommand(ZygoteServer zygoteServer, boolean multipleOK) {
    // 解析来自 AMS 的参数，包括 uid、gid、目标类名等
    ZygoteArguments parsedArgs = ZygoteArguments.getInstance(args);
    
    // 执行 fork 系统调用，这是进程诞生的关键时刻
    // fork 返回两次：在父进程中返回子进程 PID，在子进程中返回 0
    int pid = Zygote.forkAndSpecialize(
        parsedArgs.mUid,           // 新进程的用户 ID
        parsedArgs.mGid,           // 新进程的组 ID
        parsedArgs.mGids,          // 补充组 ID 数组
        parsedArgs.mRuntimeFlags,  // 运行时标志，如是否开启调试
        rlimits,                   // 资源限制配置
        parsedArgs.mMountExternal, // 外部存储挂载模式
        parsedArgs.mSeInfo,        // SELinux 安全信息
        parsedArgs.mNiceName,      // 进程的友好名称
        fdsToClose,                // 需要关闭的文件描述符
        fdsToIgnore,               // 需要忽略的文件描述符
        parsedArgs.mStartChildZygote,  // 是否启动子 Zygote
        parsedArgs.mInstructionSet,    // CPU 指令集
        parsedArgs.mAppDataDir,        // 应用数据目录
        parsedArgs.mIsTopApp           // 是否为前台应用
    );
    
    if (pid == 0) {
        // 子进程分支：这里是新应用进程的起点
        // 关闭从父进程继承的 Zygote Socket，子进程不需要它
        zygoteServer.closeServerSocket();
        
        // 返回一个 Runnable，稍后会执行 ActivityThread.main()
        return handleChildProc(parsedArgs, childPipeFd, parsedArgs.mStartChildZygote);
    } else {
        // 父进程分支：Zygote 继续等待下一个请求
        // 向 AMS 返回新进程的 PID
        handleParentProc(pid, serverPipeFd);
        return null;
    }
}