MyApp/
├── app/
│   ├── src/
│   │   ├── main/
│   │   │   ├── java/com/example/myapp/   # Java 源码目录
│   │   │   │   ├── MainActivity.java
│   │   │   │   ├── model/               # 数据模型
│   │   │   │   ├── adapter/             # RecyclerView 适配器
│   │   │   │   ├── service/             # Service 类
│   │   │   │   └── util/                # 工具类
│   │   │   ├── res/
│   │   │   │   ├── layout/              # XML 布局文件
│   │   │   │   ├── drawable/            # 图片/矢量图
│   │   │   │   ├── values/              # strings.xml, colors.xml, styles.xml
│   │   │   │   ├── menu/                # 菜单资源
│   │   │   │   └── anim/                # 动画资源
│   │   │   └── AndroidManifest.xml      # 应用清单（核心配置文件）
│   │   ├── test/                        # 单元测试
│   │   └── androidTest/                 # 集成测试
│   └── build.gradle                     # 模块级构建脚本
├── build.gradle                         # 项目级构建脚本
├── gradle.properties
└── settings.gradle

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.myapp">

    <!-- 权限声明 -->
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.READ_CONTACTS" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme">

        <!-- Activity 注册 -->
        <activity
            android:name=".MainActivity"
            android:launchMode="singleTop"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <!-- Service 注册 -->
        <service android:name=".MusicService"
            android:exported="false" />

        <!-- BroadcastReceiver 静态注册 -->
        <receiver android:name=".BootReceiver"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.BOOT_COMPLETED" />
            </intent-filter>
        </receiver>

        <!-- ContentProvider 注册 -->
        <provider
            android:name=".MyContentProvider"
            android:authorities="com.example.myapp.provider"
            android:exported="false" />
    </application>
</manifest>

package com.example.myapp;

import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";
    private static final String KEY_COUNT = "key_count";
    private int clickCount = 0;

    /**
     * onCreate: Activity 首次创建时调用
     * - 初始化 UI 组件
     * - 恢复保存的状态
     * - 绑定 ViewModel
     * savedInstanceState 非空时说明是从销毁状态恢复
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);  // 设置布局
        Log.d(TAG, "onCreate");

        // 恢复状态
        if (savedInstanceState != null) {
            clickCount = savedInstanceState.getInt(KEY_COUNT, 0);
        }

        // 初始化视图
        initViews();
    }

    /**
     * onStart: Activity 变为可见时调用（用户可以看到但不能交互）
     * - 开始监听广播（如网络变化）
     * - 刷新 UI 数据
     */
    @Override
    protected void onStart() {
        super.onStart();
        Log.d(TAG, "onStart");
    }

    /**
     * onResume: Activity 进入前台，用户可以交互
     * - 开始动画
     * - 打开相机/传感器
     * - 恢复视频播放
     */
    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "onResume");
        // 开始传感器监听、恢复播放等
    }

    /**
     * onPause: Activity 失去焦点（另一个 Activity 覆盖在上面）
     * 重要: 此方法必须快速执行，不能做耗时操作
     * - 暂停动画
     * - 释放相机
     * - 保存未提交的数据
     */
    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "onPause");
        // 暂停传感器、相机等资源密集型操作
    }

    /**
     * onStop: Activity 完全不可见
     * - 停止位置更新
     * - 保存数据到数据库
     * - 注销不必要的广播接收器
     */
    @Override
    protected void onStop() {
        super.onStop();
        Log.d(TAG, "onStop");
        // 保存数据，释放资源
    }

    /**
     * onRestart: 从停止状态重新变为可见（onStop -> onRestart -> onStart）
     */
    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d(TAG, "onRestart");
    }

    /**
     * onDestroy: Activity 即将销毁
     * - 释放所有资源
     * - 取消异步任务
     * - isFinishing() 判断是主动销毁还是系统回收
     */
    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy, isFinishing=" + isFinishing());
        // 释放所有资源，避免内存泄漏
    }

    /**
     * onSaveInstanceState: 系统即将销毁 Activity 前调用（旋转、内存不足）
     * 注意: 用户主动按返回键不会触发此方法
     */
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putInt(KEY_COUNT, clickCount);  // 保存计数
        outState.putString("user_input", "some text");
    }

    /**
     * onRestoreInstanceState: 从已保存状态恢复时调用
     * 也可以在 onCreate 的 savedInstanceState 中恢复
     */
    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        clickCount = savedInstanceState.getInt(KEY_COUNT, 0);
    }

    private void initViews() {
        // 初始化视图绑定
    }
}

<!-- singleTask: 主页 Activity，确保全局唯一 -->
<activity
    android:name=".HomeActivity"
    android:launchMode="singleTask"
    android:taskAffinity="com.example.myapp" />

<!-- singleTop: 推送通知目标 Activity -->
<activity
    android:name=".NotificationActivity"
    android:launchMode="singleTop" />

// singleTop/singleTask/singleInstance 模式下，已存在实例时调用 onNewIntent
@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    // 更新当前 Activity 的 Intent
    setIntent(intent);
    // 处理新的 Intent 数据
    String action = intent.getStringExtra("action");
    if ("refresh".equals(action)) {
        refreshData();
    }
}

private void refreshData() { /* 刷新数据 */ }

package com.example.myapp;

import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import androidx.activity.result.ActivityResult;
import androidx.activity.result.ActivityResultLauncher;
import androidx.activity.result.contract.ActivityResultContracts;
import androidx.appcompat.app.AppCompatActivity;

public class IntentDemoActivity extends AppCompatActivity {

    // ========== 新 API: ActivityResultLauncher (推荐) ==========
    // 替代已废弃的 startActivityForResult()
    private ActivityResultLauncher resultLauncher;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_intent_demo);

        // 注册 ActivityResultLauncher（必须在 onCreate 中注册）
        resultLauncher = registerForActivityResult(
            new ActivityResultContracts.StartActivityForResult(),
            (ActivityResult result) -> {
                // 处理返回结果
                if (result.getResultCode() == RESULT_OK && result.getData() != null) {
                    String returnedData = result.getData().getStringExtra("result_key");
                    // 使用返回数据
                }
            }
        );
    }

    // --------- 显式 Intent：明确指定目标 Activity ---------
    private void startExplicitActivity() {
        Intent intent = new Intent(this, DetailActivity.class);

        // 传递基本数据
        intent.putExtra("user_id", 123);
        intent.putExtra("user_name", "张三");

        // 传递 Bundle
        Bundle bundle = new Bundle();
        bundle.putString("token", "abc123");
        intent.putExtras(bundle);

        startActivity(intent);
    }

    // --------- 带返回结果的启动 ---------
    private void startForResult() {
        Intent intent = new Intent(this, EditActivity.class);
        intent.putExtra("edit_mode", true);
        resultLauncher.launch(intent);
    }

    // --------- 隐式 Intent：通过 Action 匹配 ---------
    private void startImplicitActivities() {
        // 打开网页
        Intent webIntent = new Intent(Intent.ACTION_VIEW,
            Uri.parse("https://www.google.com"));
        startActivity(webIntent);

        // 拨打电话（需要 CALL_PHONE 权限）
        Intent callIntent = new Intent(Intent.ACTION_DIAL,
            Uri.parse("tel:+86138xxxxxx"));
        startActivity(callIntent);

        // 发送邮件
        Intent emailIntent = new Intent(Intent.ACTION_SENDTO);
        emailIntent.setData(Uri.parse("mailto:"));
        emailIntent.putExtra(Intent.EXTRA_EMAIL, new String[]{"test@example.com"});
        emailIntent.putExtra(Intent.EXTRA_SUBJECT, "主题");
        emailIntent.putExtra(Intent.EXTRA_TEXT, "邮件内容");
        startActivity(Intent.createChooser(emailIntent, "选择邮件应用"));

        // 分享文本
        Intent shareIntent = new Intent(Intent.ACTION_SEND);
        shareIntent.setType("text/plain");
        shareIntent.putExtra(Intent.EXTRA_TEXT, "分享内容");
        startActivity(Intent.createChooser(shareIntent, "分享到"));
    }

    // --------- Intent Flags ---------
    private void startWithFlags() {
        Intent intent = new Intent(this, HomeActivity.class);

        // FLAG_ACTIVITY_CLEAR_TOP: 清除 HomeActivity 之上的所有 Activity
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

        // FLAG_ACTIVITY_SINGLE_TOP: 若已在栈顶则不创建新实例
        intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);

        // FLAG_ACTIVITY_NEW_TASK: 在新 Task 中启动（从非 Activity 上下文启动时必须加）
        // intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

        // FLAG_ACTIVITY_NO_HISTORY: 不保留历史记录（Activity 离开后立即从栈中移除）
        // intent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);

        startActivity(intent);
    }
}

// 方案一: 在 AndroidManifest 中声明自己处理配置变更
// android:configChanges="orientation|screenSize|keyboardHidden"

// 方案二（推荐）: 使用 ViewModel 保留数据
import androidx.lifecycle.ViewModel;
import androidx.lifecycle.ViewModelProvider;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;

// ViewModel: 在配置变更时自动保留
public class MainViewModel extends ViewModel {
    private MutableLiveData userData = new MutableLiveData<>();
    private List itemList = new ArrayList<>();

    public LiveData getUserData() { return userData; }

    public void loadData() {
        // 异步加载数据
        userData.setValue("loaded data");
    }

    @Override
    protected void onCleared() {
        super.onCleared();
        // 清理资源（如取消网络请求）
    }
}

// 在 Activity 中使用 ViewModel
public class ConfigChangeActivity extends AppCompatActivity {
    private MainViewModel viewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // ViewModelProvider 确保旋转后返回同一 ViewModel 实例
        viewModel = new ViewModelProvider(this).get(MainViewModel.class);

        // 观察数据变化
        viewModel.getUserData().observe(this, data -> {
            // 更新 UI
        });

        viewModel.loadData();
    }
}

package com.example.myapp.service;

import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.media.MediaPlayer;
import android.os.Binder;
import android.os.Build;
import android.os.IBinder;
import android.util.Log;
import androidx.core.app.NotificationCompat;

public class MusicService extends Service {

    private static final String TAG = "MusicService";
    private static final String CHANNEL_ID = "music_channel";
    private static final int NOTIFICATION_ID = 1;

    // Binder 对象，供客户端调用本地方法
    private final IBinder musicBinder = new MusicBinder();
    private MediaPlayer mediaPlayer;
    private String currentSong = "";

    /**
     * MusicBinder: 返回给客户端，用于直接调用 Service 方法
     * 适用于同进程通信
     */
    public class MusicBinder extends Binder {
        public MusicService getService() {
            return MusicService.this;  // 返回 Service 实例
        }
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate");
        mediaPlayer = new MediaPlayer();
        // 创建通知渠道（Android 8.0+）
        createNotificationChannel();
    }

    /**
     * onStartCommand: 每次 startService() 都会调用
     * 返回值决定系统杀死后的重启行为：
     * START_STICKY: 重启，Intent 为 null
     * START_NOT_STICKY: 不重启
     * START_REDELIVER_INTENT: 重启，重新传递最后一个 Intent
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand, startId=" + startId);

        if (intent != null) {
            String action = intent.getAction();
            if ("PLAY".equals(action)) {
                String songPath = intent.getStringExtra("song_path");
                playSong(songPath);
            } else if ("PAUSE".equals(action)) {
                pauseSong();
            } else if ("STOP".equals(action)) {
                stopSong();
                stopSelf();  // 停止服务
            }
        }

        return START_STICKY;  // 被杀死后系统会重启 Service
    }

    @Override
    public IBinder onBind(Intent intent) {
        Log.d(TAG, "onBind");
        return musicBinder;  // 返回 Binder 给客户端
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.d(TAG, "onUnbind");
        return super.onUnbind(intent);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy");
        if (mediaPlayer != null) {
            mediaPlayer.stop();
            mediaPlayer.release();
            mediaPlayer = null;
        }
    }

    // ---- 公开给 Bound 客户端调用的方法 ----
    public void playSong(String path) {
        try {
            currentSong = path;
            mediaPlayer.reset();
            mediaPlayer.setDataSource(path);
            mediaPlayer.prepareAsync();
            mediaPlayer.setOnPreparedListener(mp -> {
                mp.start();
                // 启动前台服务，显示通知栏
                startForeground(NOTIFICATION_ID, buildNotification());
            });
        } catch (Exception e) {
            Log.e(TAG, "playSong error", e);
        }
    }

    public void pauseSong() {
        if (mediaPlayer != null && mediaPlayer.isPlaying()) {
            mediaPlayer.pause();
        }
    }

    public void stopSong() {
        if (mediaPlayer != null) {
            mediaPlayer.stop();
            stopForeground(true);  // 移除通知
        }
    }

    public boolean isPlaying() {
        return mediaPlayer != null && mediaPlayer.isPlaying();
    }

    public int getCurrentPosition() {
        return mediaPlayer != null ? mediaPlayer.getCurrentPosition() : 0;
    }

    // ---- 前台服务通知 ----
    private Notification buildNotification() {
        Intent stopIntent = new Intent(this, MusicService.class);
        stopIntent.setAction("STOP");
        PendingIntent stopPendingIntent = PendingIntent.getService(
            this, 0, stopIntent,
            PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
        );

        return new NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle("正在播放")
            .setContentText(currentSong)
            .setSmallIcon(android.R.drawable.ic_media_play)
            .addAction(android.R.drawable.ic_media_pause, "停止", stopPendingIntent)
            .setPriority(NotificationCompat.PRIORITY_LOW)
            .setOngoing(true)  // 不可滑动消除
            .build();
    }

    private void createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel(
                CHANNEL_ID, "音乐播放",
                NotificationManager.IMPORTANCE_LOW
            );
            channel.setDescription("音乐播放控制");
            NotificationManager manager = getSystemService(NotificationManager.class);
            manager.createNotificationChannel(channel);
        }
    }
}

public class PlayerActivity extends AppCompatActivity {

    private MusicService musicService;
    private boolean isBound = false;

    // ServiceConnection: 监听 Service 连接状态
    private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // 获取 Binder，进而获取 Service 实例
            MusicService.MusicBinder binder = (MusicService.MusicBinder) service;
            musicService = binder.getService();
            isBound = true;
            // 此时可以调用 musicService 的方法
            updateUI();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            isBound = false;
            musicService = null;
        }
    };

    @Override
    protected void onStart() {
        super.onStart();
        // 绑定 Service
        Intent intent = new Intent(this, MusicService.class);
        bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // 解绑 Service（避免内存泄漏）
        if (isBound) {
            unbindService(serviceConnection);
            isBound = false;
        }
    }

    private void onPlayButtonClick() {
        if (isBound) {
            musicService.playSong("/sdcard/music/song.mp3");
        }
    }

    private void updateUI() {
        if (isBound && musicService.isPlaying()) {
            // 更新播放按钮状态
        }
    }
}

import androidx.work.*;
import java.util.concurrent.TimeUnit;

// 定义 Worker
public class SyncWorker extends Worker {
    public SyncWorker(Context context, WorkerParameters params) {
        super(context, params);
    }

    @Override
    public Result doWork() {
        // 在后台线程执行同步任务
        String userId = getInputData().getString("user_id");
        try {
            syncDataToServer(userId);
            return Result.success();
        } catch (Exception e) {
            // 失败重试（最多 3 次）
            if (getRunAttemptCount() < 3) {
                return Result.retry();
            }
            return Result.failure();
        }
    }

    private void syncDataToServer(String userId) { /* 网络请求 */ }
}

// 在 Activity/Fragment 中调度任务
public void scheduleSync() {
    // 定义约束条件
    Constraints constraints = new Constraints.Builder()
        .setRequiredNetworkType(NetworkType.CONNECTED)  // 需要网络
        .setRequiresBatteryNotLow(true)                 // 电量不低
        .build();

    // 创建工作请求
    Data inputData = new Data.Builder()
        .putString("user_id", "user_123")
        .build();

    OneTimeWorkRequest syncRequest = new OneTimeWorkRequest.Builder(SyncWorker.class)
        .setConstraints(constraints)
        .setInputData(inputData)
        .setInitialDelay(10, TimeUnit.MINUTES)  // 延迟 10 分钟
        .addTag("sync_task")
        .build();

    // 加入队列
    WorkManager.getInstance(this)
        .enqueueUniqueWork(
            "sync_work",
            ExistingWorkPolicy.REPLACE,  // 已有相同任务则替换
            syncRequest
        );

    // 观察状态
    WorkManager.getInstance(this)
        .getWorkInfoByIdLiveData(syncRequest.getId())
        .observe(this, info -> {
            if (info != null && info.getState().isFinished()) {
                // 任务完成
            }
        });
}

package com.example.myapp;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.util.Log;

// ===== 定义 BroadcastReceiver =====
public class NetworkChangeReceiver extends BroadcastReceiver {

    private static final String TAG = "NetworkReceiver";

    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        Log.d(TAG, "接收到广播: " + action);

        if (ConnectivityManager.CONNECTIVITY_ACTION.equals(action)) {
            // 检查网络状态
            ConnectivityManager cm = (ConnectivityManager)
                context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo info = cm.getActiveNetworkInfo();
            boolean isConnected = info != null && info.isConnected();
            Log.d(TAG, "网络状态: " + (isConnected ? "已连接" : "断开"));
        }
    }
}

// ===== 在 Activity 中动态注册/注销 =====
public class MainActivity extends AppCompatActivity {

    private NetworkChangeReceiver networkReceiver;

    @Override
    protected void onStart() {
        super.onStart();
        // 动态注册广播接收器
        networkReceiver = new NetworkChangeReceiver();
        IntentFilter filter = new IntentFilter();
        filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
        // 可以添加多个 Action
        filter.addAction(Intent.ACTION_AIRPLANE_MODE_CHANGED);
        registerReceiver(networkReceiver, filter);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // 必须注销，否则内存泄漏
        if (networkReceiver != null) {
            unregisterReceiver(networkReceiver);
            networkReceiver = null;
        }
    }

    // 发送自定义广播
    private void sendCustomBroadcast() {
        String action = "com.example.myapp.MY_ACTION";

        // 普通广播（异步，无序）
        Intent intent = new Intent(action);
        intent.putExtra("data", "some data");
        sendBroadcast(intent);

        // 有序广播（同步，可被拦截，有优先级）
        sendOrderedBroadcast(intent, null,
            new BroadcastReceiver() {
                @Override
                public void onReceive(Context context, Intent intent) {
                    // 最终结果接收者（无论中间是否被拦截都会收到）
                    String result = getResultData();
                    Log.d("Final", "最终广播结果: " + result);
                }
            },
            null, Activity.RESULT_OK, null, null
        );
    }
}

<!-- AndroidManifest.xml 静态注册（Android 8.0+ 仅支持特定系统广播）-->
<receiver
    android:name=".BootReceiver"
    android:exported="true"
    android:permission="android.permission.RECEIVE_BOOT_COMPLETED">
    <intent-filter android:priority="100">
        <!-- 开机广播，仍然支持静态注册 -->
        <action android:name="android.intent.action.BOOT_COMPLETED" />
    </intent-filter>
</receiver>

<!-- 自定义广播静态注册，设置权限保护 -->
<receiver
    android:name=".SecureReceiver"
    android:exported="true"
    android:permission="com.example.myapp.SEND_BROADCAST">
    <intent-filter>
        <action android:name="com.example.myapp.SECURE_ACTION" />
    </intent-filter>
</receiver>

// 推荐方案: 使用 ViewModel + LiveData 替代本地广播
// 在 ViewModel 中定义可观察的事件
public class SharedViewModel extends ViewModel {
    private MutableLiveData eventLiveData = new MutableLiveData<>();

    public void postEvent(String event) {
        eventLiveData.setValue(event);
    }

    public LiveData getEvent() {
        return eventLiveData;
    }
}

// Fragment A 发送事件
SharedViewModel vm = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);
vm.postEvent("data_updated");

// Fragment B 接收事件
vm.getEvent().observe(getViewLifecycleOwner(), event -> {
    if ("data_updated".equals(event)) {
        refreshList();
    }
});

package com.example.myapp;

import android.content.ContentProvider;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.net.Uri;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

public class UserContentProvider extends ContentProvider {

    private static final String TAG = "UserProvider";

    // Authority 必须与 Manifest 中声明的一致
    public static final String AUTHORITY = "com.example.myapp.provider";
    public static final Uri CONTENT_URI =
        Uri.parse("content://" + AUTHORITY + "/users");

    // URI 匹配码
    private static final int USERS = 100;       // content://authority/users
    private static final int USER_ID = 101;     // content://authority/users/42

    private static final UriMatcher uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);

    static {
        uriMatcher.addURI(AUTHORITY, "users", USERS);
        uriMatcher.addURI(AUTHORITY, "users/#", USER_ID);  // # 匹配数字
    }

    private SQLiteOpenHelper dbHelper;

    @Override
    public boolean onCreate() {
        // 初始化数据库（不要做耗时操作）
        dbHelper = new UserDatabaseHelper(getContext());
        Log.d(TAG, "ContentProvider onCreate");
        return true;
    }

    @Nullable
    @Override
    public Cursor query(@NonNull Uri uri, @Nullable String[] projection,
                        @Nullable String selection, @Nullable String[] selectionArgs,
                        @Nullable String sortOrder) {
        SQLiteDatabase db = dbHelper.getReadableDatabase();
        Cursor cursor;

        switch (uriMatcher.match(uri)) {
            case USERS:
                // 查询所有用户
                cursor = db.query("users", projection, selection,
                    selectionArgs, null, null, sortOrder);
                break;
            case USER_ID:
                // 查询指定 ID 用户
                long id = ContentUris.parseId(uri);
                cursor = db.query("users", projection,
                    "_id = ?", new String[]{String.valueOf(id)},
                    null, null, sortOrder);
                break;
            default:
                throw new IllegalArgumentException("Unknown URI: " + uri);
        }

        // 注册内容观察者，数据变化时通知
        cursor.setNotificationUri(getContext().getContentResolver(), uri);
        return cursor;
    }

    @Nullable
    @Override
    public Uri insert(@NonNull Uri uri, @Nullable ContentValues values) {
        if (uriMatcher.match(uri) != USERS) {
            throw new IllegalArgumentException("Invalid URI for insert: " + uri);
        }

        SQLiteDatabase db = dbHelper.getWritableDatabase();
        long rowId = db.insert("users", null, values);

        if (rowId > 0) {
            Uri newUri = ContentUris.withAppendedId(CONTENT_URI, rowId);
            // 通知所有观察者数据已变化
            getContext().getContentResolver().notifyChange(newUri, null);
            return newUri;
        }
        return null;
    }

    @Override
    public int update(@NonNull Uri uri, @Nullable ContentValues values,
                      @Nullable String selection, @Nullable String[] selectionArgs) {
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        int count;

        switch (uriMatcher.match(uri)) {
            case USERS:
                count = db.update("users", values, selection, selectionArgs);
                break;
            case USER_ID:
                long id = ContentUris.parseId(uri);
                count = db.update("users", values,
                    "_id = ?", new String[]{String.valueOf(id)});
                break;
            default:
                throw new IllegalArgumentException("Unknown URI: " + uri);
        }

        if (count > 0) {
            getContext().getContentResolver().notifyChange(uri, null);
        }
        return count;
    }

    @Override
    public int delete(@NonNull Uri uri, @Nullable String selection,
                      @Nullable String[] selectionArgs) {
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        int count;

        switch (uriMatcher.match(uri)) {
            case USERS:
                count = db.delete("users", selection, selectionArgs);
                break;
            case USER_ID:
                long id = ContentUris.parseId(uri);
                count = db.delete("users",
                    "_id = ?", new String[]{String.valueOf(id)});
                break;
            default:
                throw new IllegalArgumentException("Unknown URI: " + uri);
        }

        if (count > 0) {
            getContext().getContentResolver().notifyChange(uri, null);
        }
        return count;
    }

    @Nullable
    @Override
    public String getType(@NonNull Uri uri) {
        // 返回 MIME 类型
        switch (uriMatcher.match(uri)) {
            case USERS:
                return "vnd.android.cursor.dir/vnd.com.example.users";
            case USER_ID:
                return "vnd.android.cursor.item/vnd.com.example.users";
            default:
                return null;
        }
    }

    // ===== 内部 SQLite 帮助类 =====
    private static class UserDatabaseHelper extends SQLiteOpenHelper {
        UserDatabaseHelper(android.content.Context context) {
            super(context, "users.db", null, 1);
        }

        @Override
        public void onCreate(SQLiteDatabase db) {
            db.execSQL("CREATE TABLE users (" +
                "_id INTEGER PRIMARY KEY AUTOINCREMENT," +
                "name TEXT NOT NULL," +
                "email TEXT," +
                "age INTEGER)");
        }

        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
            db.execSQL("DROP TABLE IF EXISTS users");
            onCreate(db);
        }
    }
}

// ===== 客户端访问 ContentProvider =====
public class ContentProviderClient extends AppCompatActivity {

    private ContentObserver userObserver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // 注册内容观察者：数据变化时自动回调
        userObserver = new ContentObserver(new Handler(Looper.getMainLooper())) {
            @Override
            public void onChange(boolean selfChange, Uri uri) {
                super.onChange(selfChange, uri);
                // 数据已变化，刷新列表
                loadUsers();
            }
        };
        getContentResolver().registerContentObserver(
            UserContentProvider.CONTENT_URI, true, userObserver);

        loadUsers();
    }

    // 查询所有用户
    private void loadUsers() {
        Cursor cursor = getContentResolver().query(
            UserContentProvider.CONTENT_URI,
            new String[]{"_id", "name", "email", "age"},  // projection
            null, null,  // selection / selectionArgs
            "name ASC"  // sortOrder
        );

        if (cursor != null) {
            while (cursor.moveToNext()) {
                long id = cursor.getLong(cursor.getColumnIndexOrThrow("_id"));
                String name = cursor.getString(cursor.getColumnIndexOrThrow("name"));
                String email = cursor.getString(cursor.getColumnIndexOrThrow("email"));
                Log.d("User", id + ": " + name + " (" + email + ")");
            }
            cursor.close();
        }
    }

    // 插入用户
    private void insertUser() {
        ContentValues values = new ContentValues();
        values.put("name", "李四");
        values.put("email", "lisi@example.com");
        values.put("age", 28);

        Uri newUri = getContentResolver().insert(
            UserContentProvider.CONTENT_URI, values);
        Log.d("Insert", "新记录 URI: " + newUri);
    }

    // 更新用户
    private void updateUser(long userId) {
        Uri uri = ContentUris.withAppendedId(UserContentProvider.CONTENT_URI, userId);
        ContentValues values = new ContentValues();
        values.put("email", "newemail@example.com");

        int rows = getContentResolver().update(uri, values, null, null);
        Log.d("Update", "更新了 " + rows + " 行");
    }

    // 删除用户
    private void deleteUser(long userId) {
        Uri uri = ContentUris.withAppendedId(UserContentProvider.CONTENT_URI, userId);
        int rows = getContentResolver().delete(uri, null, null);
        Log.d("Delete", "删除了 " + rows + " 行");
    }

    // 访问系统联系人（需要 READ_CONTACTS 权限）
    private void readContacts() {
        Cursor cursor = getContentResolver().query(
            android.provider.ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
            null, null, null, null);

        if (cursor != null) {
            while (cursor.moveToNext()) {
                String name = cursor.getString(cursor.getColumnIndexOrThrow(
                    android.provider.ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME));
                String phone = cursor.getString(cursor.getColumnIndexOrThrow(
                    android.provider.ContactsContract.CommonDataKinds.Phone.NUMBER));
                Log.d("Contact", name + ": " + phone);
            }
            cursor.close();
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 注销内容观察者
        getContentResolver().unregisterContentObserver(userObserver);
    }
}

<?xml version="1.0" encoding="utf-8"?>
<paths xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- 内部存储的 files 目录 -->
    <files-path name="my_files" path="." />
    <!-- 外部存储的 files 目录 -->
    <external-files-path name="external_files" path="." />
    <!-- 缓存目录 -->
    <cache-path name="my_cache" path="." />
</paths>

import androidx.core.content.FileProvider;

// 获取可以安全共享的 Uri（Android 7.0+ 必须用 FileProvider）
File imageFile = new File(getFilesDir(), "photo.jpg");
Uri photoUri = FileProvider.getUriForFile(
    this,
    getPackageName() + ".fileprovider",  // 与 Manifest 中 authorities 一致
    imageFile
);

// 拍照并保存到 FileProvider Uri
Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, photoUri);
// 授予临时读取权限
cameraIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
startActivityForResult(cameraIntent, REQUEST_CAMERA);

<!-- 默认 affinity = 包名 com.example.myapp -->
<activity android:name=".MainActivity" />

<!-- 独立 Task 的 Activity -->
<activity
    android:name=".SubActivity"
    android:taskAffinity="com.example.myapp.sub"
    android:launchMode="singleTask" />

<!-- 无 affinity（永远不会被移入其他 Task）-->
<activity
    android:name=".IsolatedActivity"
    android:taskAffinity=""
    android:launchMode="singleTask" />

// 场景1: 登录成功后跳转主页，清空登录流程的所有 Activity
public void onLoginSuccess() {
    Intent intent = new Intent(this, MainActivity.class);
    // FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK
    // 清空当前 Task 并以 MainActivity 为根重新开始
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
    startActivity(intent);
    finish();  // 不需要，因为 CLEAR_TASK 会清掉当前 Activity
}

// 场景2: 通知跳转 — 已有 DetailActivity 则复用，否则新建
public static void startFromNotification(Context context, int itemId) {
    Intent intent = new Intent(context, DetailActivity.class);
    intent.putExtra("item_id", itemId);
    // CLEAR_TOP: 清除 DetailActivity 之上的所有 Activity
    // SINGLE_TOP: 若 DetailActivity 恰好在栈顶，触发 onNewIntent
    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
    // 从非 Activity Context 启动必须加 NEW_TASK
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    context.startActivity(intent);
}

// 场景3: 从 Service 启动 Activity（非 Activity Context）
public class MyService extends Service {
    private void launchActivity() {
        Intent intent = new Intent(this, MainActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  // 必须！
        startActivity(intent);
    }
}

// 场景4: 避免引导页被回退访问
public void startHomeFromSplash() {
    Intent intent = new Intent(this, HomeActivity.class);
    // 不保留引导页在返回栈中
    startActivity(intent);
    // 直接 finish() 自己即可
    finish();
    // 或者用 FLAG_ACTIVITY_NO_HISTORY 在 Manifest 中配置
}

public class MainActivity extends AppCompatActivity {

    // 在主线程创建 Handler，自动绑定主线程的 Looper
    private final Handler mainHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what) {
                case MSG_UPDATE_PROGRESS:
                    progressBar.setProgress(msg.arg1);
                    break;
                case MSG_UPDATE_TEXT:
                    textView.setText((String) msg.obj);
                    break;
                case MSG_HIDE_LOADING:
                    loadingView.setVisibility(View.GONE);
                    break;
            }
        }
    };

    private static final int MSG_UPDATE_PROGRESS = 1;
    private static final int MSG_UPDATE_TEXT     = 2;
    private static final int MSG_HIDE_LOADING    = 3;

    private void startDownload() {
        new Thread(() -> {
            for (int i = 0; i <= 100; i += 10) {
                // 模拟下载耗时
                try { Thread.sleep(200); } catch (InterruptedException e) { break; }

                // 方式1: 发送带数据的 Message
                Message msg = mainHandler.obtainMessage(MSG_UPDATE_PROGRESS);
                msg.arg1 = i;
                mainHandler.sendMessage(msg);
            }
            // 方式2: post Runnable（更简洁）
            mainHandler.post(() -> {
                textView.setText("下载完成");
                loadingView.setVisibility(View.GONE);
            });
        }).start();
    }

    // 延迟执行
    private void showToastLater() {
        mainHandler.postDelayed(() -> {
            Toast.makeText(this, "3秒后显示", Toast.LENGTH_SHORT).show();
        }, 3000);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 清理未执行的消息，防止内存泄漏
        mainHandler.removeCallbacksAndMessages(null);
    }
}

public class MainActivity extends AppCompatActivity {

    private HandlerThread handlerThread;
    private Handler backgroundHandler;
    private Handler mainHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mainHandler = new Handler(Looper.getMainLooper());

        // 创建后台 HandlerThread（内部自带 Looper）
        handlerThread = new HandlerThread("BackgroundWorker");
        handlerThread.start();

        // 绑定到后台线程的 Looper
        backgroundHandler = new Handler(handlerThread.getLooper()) {
            @Override
            public void handleMessage(@NonNull Message msg) {
                // 这里在后台线程执行
                String result = doHeavyWork(msg.arg1);
                // 结果回调到主线程
                mainHandler.post(() -> updateUI(result));
            }
        };
    }

    private void doWork(int param) {
        // 将任务派发给后台线程串行执行
        Message msg = backgroundHandler.obtainMessage();
        msg.arg1 = param;
        backgroundHandler.sendMessage(msg);
    }

    private String doHeavyWork(int param) {
        // 耗时操作...
        return "result_" + param;
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 安全退出 HandlerThread 的 Looper
        handlerThread.quitSafely();
    }
}

// Message 主要字段
// msg.what   — 消息标识符 (int)
// msg.arg1   — 轻量整数参数1 (int)
// msg.arg2   — 轻量整数参数2 (int)
// msg.obj    — 任意对象参数 (Object)
// msg.data   — Bundle 数据 (用于多参数)
// msg.target — 处理该消息的 Handler

// ✅ 推荐: 从消息池获取（复用）
Message msg = handler.obtainMessage(WHAT, arg1, arg2, obj);

// 或者链式写法
handler.obtainMessage(MSG_LOAD_IMAGE)
       .sendToTarget();

// ❌ 避免直接 new
// Message msg = new Message();

// 携带 Bundle 数据（多个参数）
Message msg2 = handler.obtainMessage(MSG_BATCH_DATA);
Bundle data = msg2.getData();
data.putString("key", "value");
data.putInt("count", 42);
handler.sendMessage(msg2);

public class SafeActivity extends AppCompatActivity {

    // ✅ 静态内部类 + 弱引用，不持有 Activity 强引用
    private static class SafeHandler extends Handler {
        private final WeakReference<SafeActivity> activityRef;

        SafeHandler(SafeActivity activity) {
            super(Looper.getMainLooper());
            this.activityRef = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(@NonNull Message msg) {
            SafeActivity activity = activityRef.get();
            if (activity == null || activity.isFinishing()) return;

            switch (msg.what) {
                case 1:
                    activity.textView.setText((String) msg.obj);
                    break;
            }
        }
    }

    private SafeHandler handler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        handler = new SafeHandler(this);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        handler.removeCallbacksAndMessages(null);
    }
}

// 方式1: 继承 Thread
class DownloadThread extends Thread {
    private final String url;
    DownloadThread(String url) { this.url = url; }

    @Override
    public void run() {
        // 下载逻辑
        Log.d("Thread", "当前线程: " + Thread.currentThread().getName());
    }
}
new DownloadThread("https://example.com/file").start();

// 方式2: 实现 Runnable（推荐，避免单继承限制）
Runnable task = () -> {
    // 任务逻辑
};
new Thread(task, "worker-1").start();

// 方式3: 实现 Callable（可获得返回值）
Callable<String> callable = () -> {
    Thread.sleep(1000);
    return "result";
};
FutureTask<String> futureTask = new FutureTask<>(callable);
new Thread(futureTask).start();
try {
    String result = futureTask.get(); // 阻塞等待结果
} catch (ExecutionException | InterruptedException e) {
    e.printStackTrace();
}

// ThreadPoolExecutor 构造参数说明
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    2,                          // corePoolSize: 核心线程数（常驻）
    4,                          // maximumPoolSize: 最大线程数
    60L,                        // keepAliveTime: 空闲线程存活时间
    TimeUnit.SECONDS,           // 时间单位
    new LinkedBlockingQueue<>(100), // 任务队列（容量100）
    new ThreadFactory() {       // 自定义线程工厂（可命名线程）
        private final AtomicInteger count = new AtomicInteger(1);
        @Override
        public Thread newThread(@NonNull Runnable r) {
            return new Thread(r, "pool-worker-" + count.getAndIncrement());
        }
    },
    new ThreadPoolExecutor.CallerRunsPolicy()  // 拒绝策略：调用者线程执行
    // 其他拒绝策略:
    // AbortPolicy（默认）: 抛出 RejectedExecutionException
    // DiscardPolicy: 静默丢弃新任务
    // DiscardOldestPolicy: 丢弃最老的任务，重试提交
);

// 提交任务
executor.execute(() -> doWork());      // 无返回值
Future<String> future = executor.submit(() -> fetchData());  // 有返回值

// 获取线程池状态
Log.d("Pool", "活跃线程: " + executor.getActiveCount());
Log.d("Pool", "已完成任务: " + executor.getCompletedTaskCount());

// 有序关闭（等待已提交任务完成）
executor.shutdown();
// 立即关闭（尝试中断正在执行的任务）
executor.shutdownNow();

// ===== CountDownLatch: 等待多个线程完成 =====
CountDownLatch latch = new CountDownLatch(3); // 等待3个任务

for (int i = 0; i < 3; i++) {
    final int taskId = i;
    executor.execute(() -> {
        try {
            doTask(taskId);
        } finally {
            latch.countDown(); // 任务完成，计数-1
        }
    });
}
latch.await(); // 阻塞直到计数为0
Log.d("TAG", "所有任务完成");

// ===== CyclicBarrier: 多线程相互等待，到达屏障后同时继续 =====
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    Log.d("TAG", "所有线程到达屏障，开始下一阶段");
});

for (int i = 0; i < 3; i++) {
    executor.execute(() -> {
        prepareData();
        try {
            barrier.await(); // 等待其他线程
        } catch (Exception e) { e.printStackTrace(); }
        processData(); // 所有线程同时开始
    });
}

// ===== Semaphore: 控制并发访问数量（限流）=====
Semaphore semaphore = new Semaphore(5); // 最多5个线程同时访问

executor.execute(() -> {
    try {
        semaphore.acquire(); // 获取许可
        accessResource();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        semaphore.release(); // 释放许可
    }
});

public class Counter {

    // volatile: 保证可见性（所有线程读到最新值），但不保证原子性
    private volatile boolean running = true;

    // AtomicInteger: 保证原子性操作（底层 CAS）
    private final AtomicInteger count = new AtomicInteger(0);

    // synchronized: 保证可见性 + 原子性（同一时刻只有一个线程执行）
    private int syncCount = 0;

    public synchronized void increment() {
        syncCount++;
    }

    public synchronized int getCount() {
        return syncCount;
    }

    // 单例模式中的双重检查锁（正确写法）
    private static volatile Counter instance;

    public static Counter getInstance() {
        if (instance == null) {              // 第一次检查（无锁，提升性能）
            synchronized (Counter.class) {
                if (instance == null) {      // 第二次检查（防止重复创建）
                    instance = new Counter();
                }
            }
        }
        return instance;
    }

    public void stopLoop() {
        running = false; // volatile 写，立刻对所有线程可见
    }

    public void runLoop() {
        while (running) { // volatile 读
            doWork();
        }
    }
}

// ===== 无参数 =====
// 旧写法
new Thread(new Runnable() {
    @Override
    public void run() { doWork(); }
}).start();
// Lambda
new Thread(() -> doWork()).start();
// 方法引用
new Thread(this::doWork).start();

// ===== 单参数 =====
// 旧写法
button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) { v.setAlpha(0.5f); }
});
// Lambda（单参数可省略括号）
button.setOnClickListener(v -> v.setAlpha(0.5f));

// ===== 多参数 =====
Comparator<String> comp = (a, b) -> a.length() - b.length();
List<String> list = Arrays.asList("banana", "apple", "kiwi");
list.sort(comp);

// ===== 多行语句 =====
executor.execute(() -> {
    String data = fetchFromNetwork();
    saveToDatabase(data);
    mainHandler.post(() -> updateUI(data));
});

// 1. 静态方法引用: ClassName::staticMethod
List<String> list = Arrays.asList("1", "2", "3");
list.stream().map(Integer::parseInt).collect(Collectors.toList());

// 2. 实例方法引用（特定对象）: instance::method
String prefix = "Hello ";
list.stream().map(prefix::concat).forEach(System.out::println);

// 3. 实例方法引用（任意对象）: ClassName::instanceMethod
list.stream().map(String::toUpperCase).forEach(System.out::println);
list.sort(String::compareTo);

// 4. 构造方法引用: ClassName::new
List<User> users = nameList.stream()
    .map(User::new)          // 调用 User(String name) 构造器
    .collect(Collectors.toList());

// Android 中常见方法引用
button.setOnClickListener(this::onButtonClicked); // 实例方法引用
Log.d("TAG", list.stream().collect(Collectors.joining(", ")));

List<User> users = getUsers();

// 过滤 + 映射 + 收集
List<String> activeNames = users.stream()
    .filter(u -> u.isActive())           // 中间操作: 过滤
    .filter(u -> u.getAge() >= 18)       // 中间操作: 再次过滤
    .map(User::getName)                  // 中间操作: 提取姓名
    .sorted()                            // 中间操作: 排序
    .distinct()                          // 中间操作: 去重
    .collect(Collectors.toList());       // 终止操作: 收集为 List

// 统计
long count = users.stream().filter(User::isActive).count();
OptionalDouble avgAge = users.stream()
    .mapToInt(User::getAge)
    .average();

// 分组
Map<String, List<User>> groupByCityMap = users.stream()
    .collect(Collectors.groupingBy(User::getCity));

// anyMatch / allMatch / noneMatch
boolean hasAdmin = users.stream().anyMatch(u -> "admin".equals(u.getRole()));

// findFirst
Optional<User> firstAdmin = users.stream()
    .filter(u -> "admin".equals(u.getRole()))
    .findFirst();
firstAdmin.ifPresent(u -> Log.d("TAG", "找到管理员: " + u.getName()));

// reduce 归约
int totalAge = users.stream()
    .mapToInt(User::getAge)
    .reduce(0, Integer::sum);

// 创建
Optional<String> opt1 = Optional.of("value");       // 非空值
Optional<String> opt2 = Optional.empty();            // 空值
Optional<String> opt3 = Optional.ofNullable(maybeNull); // 可能为 null

// 使用
String value = opt3.orElse("默认值");
String value2 = opt3.orElseGet(() -> computeDefault());
opt3.ifPresent(v -> Log.d("TAG", v));
String upper = opt3.map(String::toUpperCase).orElse("");

// 链式防 NPE（替代多层 if null 判断）
String city = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getCity)
    .orElse("未知城市");

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    // MeasureSpec 由 mode + size 打包成一个 int
    int widthMode = MeasureSpec.getMode(widthMeasureSpec);
    int widthSize = MeasureSpec.getSize(widthMeasureSpec);

    int measuredWidth;
    switch (widthMode) {
        case MeasureSpec.EXACTLY:   // match_parent 或具体 dp 值
            measuredWidth = widthSize;
            break;
        case MeasureSpec.AT_MOST:   // wrap_content
            measuredWidth = Math.min(getDesiredWidth(), widthSize);
            break;
        default:                    // UNSPECIFIED（ScrollView 中）
            measuredWidth = getDesiredWidth();
            break;
    }
    setMeasuredDimension(measuredWidth, getDesiredHeight());
}

public class UserAdapter extends RecyclerView.Adapter<UserAdapter.ViewHolder> {

    public interface OnItemClickListener {
        void onItemClick(User user, int position);
        void onItemLongClick(User user, int position);
    }

    private final List<User> items;
    private OnItemClickListener listener;

    public UserAdapter(List<User> items) {
        this.items = new ArrayList<>(items);
    }

    public void setOnItemClickListener(OnItemClickListener l) {
        this.listener = l;
    }

    // ① 创建 ViewHolder（inflate 布局）
    @NonNull
    @Override
    public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(parent.getContext())
            .inflate(R.layout.item_user, parent, false);
        return new ViewHolder(view);
    }

    // ② 绑定数据到 ViewHolder
    @Override
    public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
        User user = items.get(position);
        holder.nameText.setText(user.getName());
        holder.emailText.setText(user.getEmail());
        // 使用 Glide 加载头像
        Glide.with(holder.itemView)
            .load(user.getAvatarUrl())
            .circleCrop()
            .placeholder(R.drawable.ic_avatar_default)
            .into(holder.avatarImage);

        holder.itemView.setOnClickListener(v -> {
            if (listener != null) listener.onItemClick(user, holder.getAdapterPosition());
        });
        holder.itemView.setOnLongClickListener(v -> {
            if (listener != null) listener.onItemLongClick(user, holder.getAdapterPosition());
            return true;
        });
    }

    @Override
    public int getItemCount() { return items.size(); }

    // DiffUtil 局部刷新（性能优化）
    public void updateData(List<User> newData) {
        DiffUtil.DiffResult result = DiffUtil.calculateDiff(new DiffUtil.Callback() {
            @Override public int getOldListSize() { return items.size(); }
            @Override public int getNewListSize() { return newData.size(); }
            @Override public boolean areItemsTheSame(int o, int n) {
                return items.get(o).getId() == newData.get(n).getId();
            }
            @Override public boolean areContentsTheSame(int o, int n) {
                return items.get(o).equals(newData.get(n));
            }
        });
        items.clear();
        items.addAll(newData);
        result.dispatchUpdatesTo(this); // 自动计算最小更新操作
    }

    static class ViewHolder extends RecyclerView.ViewHolder {
        ImageView avatarImage;
        TextView nameText;
        TextView emailText;

        ViewHolder(View v) {
            super(v);
            avatarImage = v.findViewById(R.id.iv_avatar);
            nameText    = v.findViewById(R.id.tv_name);
            emailText   = v.findViewById(R.id.tv_email);
        }
    }
}

RecyclerView recyclerView = findViewById(R.id.recycler_view);

// 布局管理器
recyclerView.setLayoutManager(new LinearLayoutManager(this));
// recyclerView.setLayoutManager(new GridLayoutManager(this, 2));
// recyclerView.setLayoutManager(new StaggeredGridLayoutManager(2, VERTICAL));

// 固定大小优化（每个 item 尺寸相同时开启）
recyclerView.setHasFixedSize(true);

UserAdapter adapter = new UserAdapter(userList);
recyclerView.setAdapter(adapter);

// 分割线
recyclerView.addItemDecoration(
    new DividerItemDecoration(this, DividerItemDecoration.VERTICAL)
);

// Item 动画（默认已有，可自定义）
recyclerView.setItemAnimator(new DefaultItemAnimator());

// 监听
adapter.setOnItemClickListener((user, pos) -> {
    Intent intent = new Intent(this, DetailActivity.class);
    intent.putExtra("user_id", user.getId());
    startActivity(intent);
});

public class CircleProgressView extends View {

    private Paint bgPaint;
    private Paint progressPaint;
    private Paint textPaint;
    private RectF ovalRect;

    private int progress = 0;    // 0~100
    private int maxProgress = 100;

    // 自定义属性（在 res/values/attrs.xml 中定义后这里读取）
    private int progressColor = Color.parseColor("#58a6ff");
    private int bgColor       = Color.parseColor("#30363d");
    private float strokeWidth = 12f;

    public CircleProgressView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        if (attrs != null) {
            TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.CircleProgressView);
            progressColor = a.getColor(R.styleable.CircleProgressView_progressColor, progressColor);
            strokeWidth   = a.getDimension(R.styleable.CircleProgressView_strokeWidth, strokeWidth);
            a.recycle();
        }
        initPaints();
    }

    private void initPaints() {
        bgPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        bgPaint.setStyle(Paint.Style.STROKE);
        bgPaint.setColor(bgColor);
        bgPaint.setStrokeWidth(strokeWidth);

        progressPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        progressPaint.setStyle(Paint.Style.STROKE);
        progressPaint.setColor(progressColor);
        progressPaint.setStrokeWidth(strokeWidth);
        progressPaint.setStrokeCap(Paint.Cap.ROUND);

        textPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        textPaint.setColor(Color.WHITE);
        textPaint.setTextSize(sp2px(18));
        textPaint.setTextAlign(Paint.Align.CENTER);
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldW, int oldH) {
        super.onSizeChanged(w, h, oldW, oldH);
        float padding = strokeWidth / 2f + getPaddingLeft();
        ovalRect = new RectF(padding, padding, w - padding, h - padding);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 绘制背景圆弧
        canvas.drawArc(ovalRect, -90, 360, false, bgPaint);
        // 绘制进度圆弧（从 -90° 开始，顺时针扫过）
        float sweepAngle = 360f * progress / maxProgress;
        canvas.drawArc(ovalRect, -90, sweepAngle, false, progressPaint);
        // 绘制中心文字
        String text = progress + "%";
        float textY = getHeight() / 2f - (textPaint.descent() + textPaint.ascent()) / 2f;
        canvas.drawText(text, getWidth() / 2f, textY, textPaint);
    }

    public void setProgress(int progress) {
        this.progress = Math.min(Math.max(progress, 0), maxProgress);
        invalidate(); // 触发重绘
    }

    // 属性动画驱动进度（需要 getter 配合）
    public int getProgress() { return progress; }

    private float sp2px(float sp) {
        return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, sp,
            getResources().getDisplayMetrics());
    }
}

// ===== ObjectAnimator: 动画单个属性 =====
ObjectAnimator fadeOut = ObjectAnimator.ofFloat(view, "alpha", 1f, 0f);
fadeOut.setDuration(400);
fadeOut.setInterpolator(new AccelerateDecelerateInterpolator());
fadeOut.start();

// 平移
ObjectAnimator slideIn = ObjectAnimator.ofFloat(view, "translationX", -500f, 0f);
slideIn.setDuration(300);

// 自定义 View 的属性（需要 getter+setter）
ObjectAnimator progressAnim = ObjectAnimator.ofInt(circleView, "progress", 0, 80);
progressAnim.setDuration(1200);
progressAnim.setInterpolator(new DecelerateInterpolator());
progressAnim.start();

// ===== AnimatorSet: 组合多个动画 =====
AnimatorSet set = new AnimatorSet();
set.playTogether(                       // 同时播放
    ObjectAnimator.ofFloat(view, "scaleX", 0f, 1f),
    ObjectAnimator.ofFloat(view, "scaleY", 0f, 1f),
    ObjectAnimator.ofFloat(view, "alpha", 0f, 1f)
);
set.setDuration(500);
set.setInterpolator(new OvershootInterpolator());
set.start();

// 顺序播放
AnimatorSet seq = new AnimatorSet();
seq.playSequentially(fadeOut, slideIn);
seq.start();

// ===== ValueAnimator: 纯数值动画（配合自定义绘制）=====
ValueAnimator colorAnim = ValueAnimator.ofArgb(
    Color.parseColor("#58a6ff"),
    Color.parseColor("#bc8cff")
);
colorAnim.setDuration(1000);
colorAnim.setRepeatMode(ValueAnimator.REVERSE);
colorAnim.setRepeatCount(ValueAnimator.INFINITE);
colorAnim.addUpdateListener(animator -> {
    int color = (int) animator.getAnimatedValue();
    view.setBackgroundColor(color);
});
colorAnim.start();

// ===== 监听动画状态 =====
fadeOut.addListener(new AnimatorListenerAdapter() {
    @Override
    public void onAnimationEnd(Animator animation) {
        view.setVisibility(View.GONE);
    }
    @Override
    public void onAnimationCancel(Animator animation) {
        view.setAlpha(1f); // 取消时恢复
    }
});

// 链式调用，自动批量优化，推荐用于简单动画
view.animate()
    .alpha(0f)
    .translationY(-200f)
    .scaleX(0.8f)
    .setDuration(400)
    .setInterpolator(new AccelerateInterpolator())
    .withEndAction(() -> view.setVisibility(View.GONE))
    .start();

// 出现动画
view.setVisibility(View.VISIBLE);
view.setAlpha(0f);
view.animate().alpha(1f).translationY(0f).setDuration(300).start();

// src/main/aidl/com/example/IRemoteService.aidl
package com.example;

// 自定义 Parcelable 需要声明
import com.example.UserInfo;

interface IRemoteService {
    // 基本类型直接使用
    int getPid();
    String getVersion();

    // 复杂对象需实现 Parcelable
    // in: 输入（Client→Server），out: 输出（Server→Client），inout: 双向
    void registerCallback(in UserInfo user);
    List<UserInfo> getActiveUsers();

    // 单向（oneway）调用：不阻塞客户端，不等服务端返回
    oneway void notifyEvent(int eventType, String data);
}

public class RemoteService extends Service {

    // Stub 是 AIDL 编译器生成的抽象类，继承 Binder
    private final IRemoteService.Stub binder = new IRemoteService.Stub() {

        @Override
        public int getPid() throws RemoteException {
            return android.os.Process.myPid();
        }

        @Override
        public String getVersion() throws RemoteException {
            return BuildConfig.VERSION_NAME;
        }

        @Override
        public void registerCallback(UserInfo user) throws RemoteException {
            Log.d("RemoteService", "注册用户: " + user.getName());
        }

        @Override
        public List<UserInfo> getActiveUsers() throws RemoteException {
            return userRepository.getActiveUsers();
        }

        @Override
        public void notifyEvent(int eventType, String data) throws RemoteException {
            // oneway 调用，不需要返回值
            eventBus.post(new RemoteEvent(eventType, data));
        }
    };

    @Override
    public IBinder onBind(Intent intent) {
        return binder; // 返回 Stub 实例
    }
}

public class ClientActivity extends AppCompatActivity {

    private IRemoteService remoteService;
    private boolean isBound = false;

    private final ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // 将 IBinder 转为 AIDL 接口
            // 同进程: asInterface 返回原 Stub 对象
            // 跨进程: asInterface 返回 Proxy 代理对象
            remoteService = IRemoteService.Stub.asInterface(service);
            isBound = true;

            try {
                int pid = remoteService.getPid();
                Log.d("Client", "远程服务 PID: " + pid);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            remoteService = null;
            isBound = false;
        }
    };

    @Override
    protected void onStart() {
        super.onStart();
        Intent intent = new Intent(this, RemoteService.class);
        bindService(intent, connection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        if (isBound) {
            unbindService(connection);
            isBound = false;
        }
    }

    private void callRemote() {
        if (!isBound || remoteService == null) return;
        try {
            // 注意：跨进程调用在调用线程阻塞，避免在主线程调用耗时接口
            String version = remoteService.getVersion();
            Log.d("Client", "版本: " + version);
        } catch (RemoteException e) {
            // 服务端崩溃或被杀死时抛出
            Log.e("Client", "远程调用失败", e);
        }
    }
}

// IMyCustomService.aidl
package android.os;

interface IMyCustomService {
    // 获取自定义系统属性
    String getCustomProperty(String key);
    void setCustomProperty(String key, String value);
    // 权限保护方法
    boolean isFeatureEnabled(String featureName);
}

// MyCustomService.java
public class MyCustomService extends IMyCustomService.Stub {

    private static final String TAG = "MyCustomService";
    private static final String PERMISSION = "android.permission.MY_CUSTOM_PERMISSION";

    private final Context mContext;
    private final Map<String, String> mProperties = new HashMap<>();

    public MyCustomService(Context context) {
        mContext = context;
        // 在系统启动时初始化
        Slog.i(TAG, "MyCustomService 初始化完成");
    }

    @Override
    public String getCustomProperty(String key) throws RemoteException {
        // 检查调用者权限
        mContext.enforceCallingOrSelfPermission(PERMISSION, TAG);
        synchronized (mProperties) {
            return mProperties.get(key);
        }
    }

    @Override
    public void setCustomProperty(String key, String value) throws RemoteException {
        // 只允许系统进程调用
        if (Binder.getCallingUid() != Process.SYSTEM_UID) {
            throw new SecurityException("只有系统进程可以调用 setCustomProperty");
        }
        synchronized (mProperties) {
            mProperties.put(key, value);
        }
        Slog.d(TAG, "设置属性: " + key + " = " + value);
    }

    @Override
    public boolean isFeatureEnabled(String featureName) throws RemoteException {
        return SystemProperties.getBoolean("persist.sys.feature." + featureName, false);
    }
}

// frameworks/base/services/java/com/android/server/SystemServer.java
// 在 startOtherServices() 方法中添加：

private void startOtherServices() {
    // ... 现有代码 ...

    // 注册自定义服务到 ServiceManager
    try {
        Slog.i(TAG, "启动 MyCustomService");
        ServiceManager.addService(
            "my_custom_service",              // 服务名称（Context.MY_CUSTOM_SERVICE）
            new MyCustomService(mSystemContext)
        );
    } catch (Throwable e) {
        reportWtf("启动 MyCustomService 失败", e);
    }
}

// MyCustomManager.java（frameworks/base/core/java/android/app/）
public class MyCustomManager {

    public static final String SERVICE_NAME = "my_custom_service";

    private final IMyCustomService mService;

    /** @hide */
    public MyCustomManager(IMyCustomService service) {
        mService = service;
    }

    public String getCustomProperty(String key) {
        try {
            return mService.getCustomProperty(key);
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    }

    public boolean isFeatureEnabled(String featureName) {
        try {
            return mService.isFeatureEnabled(featureName);
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    }
}

// 在 ContextImpl 中注册（frameworks/base/core/java/android/app/ContextImpl.java）
// registerService(Context.MY_CUSTOM_SERVICE, MyCustomManager.class,
//     new CachedServiceFetcher<MyCustomManager>() {
//         @Override
//         public MyCustomManager createService(ContextImpl ctx) {
//             IBinder b = ServiceManager.getService(MyCustomManager.SERVICE_NAME);
//             return new MyCustomManager(IMyCustomService.Stub.asInterface(b));
//         }
//     });