动态权限

// 方式1：通过 Context 获取（推荐，适配所有版本）
// 私有文件目录（/Android/data/包名/files/）
val privateFilesDir = context.getExternalFilesDir(null) 
// 私有图片目录（/Android/data/包名/files/Pictures/）
val privatePicDir = context.getExternalFilesDir(Environment.DIRECTORY_PICTURES)
// 私有缓存目录（/Android/data/包名/cache/）
val privateCacheDir = context.externalCacheDir

// 方式2：通过 MediaStore 访问媒体专属目录（/Android/media/包名/）
// Android 10+ 新增，用于存储应用对外共享的媒体文件
val mediaDir = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
    context.getExternalMediaDirs().firstOrNull()
} else {
    privatePicDir // 低版本降级到 files 目录
}

// 写入文件到专属目录
fun writeToPrivateDir(context: Context, fileName: String, content: String) {
    val file = File(context.getExternalFilesDir(null), fileName)
    file.writeText(content, Charsets.UTF_8)
}

// 读取专属目录文件
fun readFromPrivateDir(context: Context, fileName: String): String? {
    val file = File(context.getExternalFilesDir(null), fileName)
    return if (file.exists()) file.readText(Charsets.UTF_8) else null
}

// 查询所有图片文件（适配 Android 10+）
fun queryImages(context: Context): List<Uri> {
    val imageUris = mutableListOf<Uri>()
    // 定义要查询的列
    val projection = arrayOf(
        MediaStore.Images.Media._ID,
        MediaStore.Images.Media.DISPLAY_NAME,
        MediaStore.Images.Media.DATE_ADDED
    )
    // 排序：按添加时间降序
    val sortOrder = "${MediaStore.Images.Media.DATE_ADDED} DESC"

    // 执行查询
    context.contentResolver.query(
        MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
        projection,
        null,
        null,
        sortOrder
    )?.use { cursor ->
        val idColumn = cursor.getColumnIndexOrThrow(MediaStore.Images.Media._ID)
        while (cursor.moveToNext()) {
            // 构建图片 Uri（content:// 格式，而非文件路径）
            val id = cursor.getLong(idColumn)
            val uri = ContentUris.withAppendedId(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, id)
            imageUris.add(uri)
        }
    }
    return imageUris
}

// 通过 Uri 读取图片内容
fun loadImageFromUri(context: Context, uri: Uri): Bitmap? {
    return try {
        val inputStream = context.contentResolver.openInputStream(uri)
        BitmapFactory.decodeStream(inputStream)
    } catch (e: Exception) {
        null
    }
}

// 保存图片到 DCIM 目录（Android 10+）
fun saveImageToDCIM(context: Context, bitmap: Bitmap, fileName: String): Uri? {
    val contentValues = ContentValues().apply {
        // 文件名称
        put(MediaStore.Images.Media.DISPLAY_NAME, fileName)
        // 文件类型
        put(MediaStore.Images.Media.MIME_TYPE, "image/jpeg")
        // Android 10+ 必须设置相对路径
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            put(MediaStore.Images.Media.RELATIVE_PATH, "DCIM/MyApp/")
        }
        // 文件修改时间
        put(MediaStore.Images.Media.DATE_MODIFIED, System.currentTimeMillis() / 1000)
    }

    // 插入到 MediaStore 并获取 Uri
    return context.contentResolver.insert(
        MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
        contentValues
    )?.also { uri ->
        // 通过 Uri 写入图片数据
        context.contentResolver.openOutputStream(uri)?.use { outputStream ->
            bitmap.compress(Bitmap.CompressFormat.JPEG, 90, outputStream)
        }
    }
}

// 删除共享媒体文件（需用户确认，Android 10+）
fun deleteMediaFile(context: Context, uri: Uri): Boolean {
    return try {
        // Android 11+ 需申请 DELETE_PHOTO_PERMISSION 或用户手动确认
        val rowsDeleted = context.contentResolver.delete(uri, null, null)
        rowsDeleted > 0
    } catch (e: Exception) {
        false
    }
}

// 打开文件选择器，选择 Download 目录的文件
fun openFilePicker(activity: Activity) {
    val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
        addCategory(Intent.CATEGORY_OPENABLE)
        // 指定文件类型（*/* 表示所有类型）
        type = "*/*"
        // 限定在 Download 目录（可选）
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            putExtra(DocumentsContract.EXTRA_INITIAL_URI, MediaStore.Downloads.EXTERNAL_CONTENT_URI)
        }
    }
    // 注册 ActivityResultLauncher 接收结果
    filePickerLauncher.launch(intent)
}

// 处理文件选择结果
private val filePickerLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
    if (result.resultCode == Activity.RESULT_OK) {
        val uri = result.data?.data
        uri?.let {
            // 读取文件内容（需申请 READ_EXTERNAL_STORAGE/READ_MEDIA_* 权限）
            val inputStream = contentResolver.openInputStream(it)
            // 处理文件...
        }
    }
}

fun requestManageStoragePermission(context: Context) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && !Environment.isExternalStorageManager()) {
        val intent = Intent(Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION)
        intent.data = Uri.parse("package:${context.packageName}")
        context.startActivity(intent)
    }
}

// 通用文件写入工具（适配 Android 6-16）
fun saveFileCompat(context: Context, content: String, isPublic: Boolean, fileName: String) {
    if (isPublic) {
        // 写入共享目录（媒体/Download）
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            // Android 10+：使用 MediaStore
            saveToMediaStore(context, content, fileName)
        } else {
            // Android 6-9：使用 File 类 + WRITE_EXTERNAL_STORAGE 权限
            val file = File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM), fileName)
            file.writeText(content)
        }
    } else {
        // 写入专属目录（全版本兼容）
        writeToPrivateDir(context, fileName, content)
    }
}

import android.Manifest
import android.app.AlertDialog
import android.content.Context
import android.content.Intent
import android.net.Uri
import android.os.Build
import android.provider.Settings
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContracts
import androidx.core.content.ContextCompat

/**
 * Android 10+ 共享媒体权限申请工具类
 */
class MediaPermissionHelper(private val context: Context) {
    // 1. 定义不同版本的媒体权限数组
    private fun getMediaPermissions(): Array<String> {
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) { // Android 13+
            // 按需选择（示例：仅申请图片+视频权限）
            arrayOf(
                Manifest.permission.READ_MEDIA_IMAGES,
                Manifest.permission.READ_MEDIA_VIDEO
            )
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { // Android 10-12
            arrayOf(Manifest.permission.READ_EXTERNAL_STORAGE)
        } else { // 低版本（Android 6-9，兼容用）
            arrayOf(Manifest.permission.READ_EXTERNAL_STORAGE)
        }
    }

    // 2. 检查权限是否已授予
    fun hasMediaPermission(): Boolean {
        val permissions = getMediaPermissions()
        return permissions.all {
            ContextCompat.checkSelfPermission(context, it) == android.content.pm.PackageManager.PERMISSION_GRANTED
        }
    }

    // 3. 动态申请权限（需传入 Activity 的权限启动器）
    fun requestMediaPermission(
        launcher: ActivityResultLauncher<Array<String>>,
        onGranted: () -> Unit, // 权限授予回调
        onDenied: () -> Unit   // 权限拒绝回调
    ) {
        val permissions = getMediaPermissions()
        if (hasMediaPermission()) {
            onGranted()
            return
        }

        // 申请权限（Android 13+ 会按细分权限弹窗，用户可选择仅授予部分）
        launcher.launch(permissions) { result ->
            val allGranted = result.all { it.value }
            if (allGranted) {
                onGranted()
            } else {
                onDenied()
                // 引导用户到设置页开启（Android 13+ 首次拒绝后二次申请直接跳设置）
                showPermissionDeniedGuide()
            }
        }
    }

    // 4. 权限拒绝后引导用户到设置页
    private fun showPermissionDeniedGuide() {
        AlertDialog.Builder(context)
            .setTitle("需要媒体权限")
            .setMessage(
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                    "需开启图片/视频访问权限以加载本地媒体文件（Android 13+ 可仅授予部分权限）"
                } else {
                    "需开启存储权限以访问本地图片/视频文件"
                }
            )
            .setPositiveButton("去设置") { _, _ ->
                // 跳转到应用权限设置页（适配国内 ROM）
                val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
                intent.data = Uri.fromParts("package", context.packageName, null)
                intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
                context.startActivity(intent)
            }
            .setNegativeButton("取消", null)
            .show()
    }
}

class MediaPermissionActivity : AppCompatActivity() {
    private lateinit var mediaPermissionHelper: MediaPermissionHelper
    // 注册权限启动器（AndroidX 推荐，替代旧版 onRequestPermissionsResult）
    private val mediaPermissionLauncher = registerForActivityResult(
        ActivityResultContracts.RequestMultiplePermissions()
    ) { result ->
        // 该回调会在工具类中处理，此处无需重复逻辑
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_media_permission)
        mediaPermissionHelper = MediaPermissionHelper(this)

        // 点击按钮申请权限
        findViewById<android.widget.Button>(R.id.btn_request_media).setOnClickListener {
            mediaPermissionHelper.requestMediaPermission(
                launcher = mediaPermissionLauncher,
                onGranted = {
                    // 权限授予成功：读取媒体文件
                    loadMediaFiles()
                },
                onDenied = {
                    // 权限拒绝：提示用户
                    android.widget.Toast.makeText(this, "权限拒绝，无法访问媒体文件", android.widget.Toast.LENGTH_SHORT).show()
                }
            )
        }
    }

    // 读取共享媒体文件（权限授予后执行）
    private fun loadMediaFiles() {
        // 此处调用 MediaStore 查询图片/视频（参考前文分区存储的 MediaStore 示例）
        val images = queryImages(this) // 该方法见前文分区存储的 MediaStore 查询示例
        android.widget.Toast.makeText(this, "读取到 ${images.size} 张图片", android.widget.Toast.LENGTH_SHORT).show()
    }
}

@Composable
fun MediaPermissionCompose() {
    val context = LocalContext.current
    val mediaPermissionHelper = remember { MediaPermissionHelper(context) }

    // 注册 Compose 权限启动器
    val mediaPermissionLauncher = rememberLauncherForActivityResult(
        ActivityResultContracts.RequestMultiplePermissions()
    ) { result ->
        val allGranted = result.all { it.value }
        if (allGranted) {
            // 权限授予：加载媒体文件
            loadMediaFiles(context)
        } else {
            // 权限拒绝：显示引导弹窗
            AlertDialog(
                onDismissRequest = {},
                title = { Text("权限申请失败") },
                text = { Text("需开启媒体权限以访问本地图片/视频") },
                confirmButton = {
                    TextButton(onClick = {
                        // 跳转到设置页
                        val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
                        intent.data = Uri.fromParts("package", context.packageName, null)
                        context.startActivity(intent)
                    }) {
                        Text("去设置")
                    }
                },
                dismissButton = {
                    TextButton(onClick = {}) { Text("取消") }
                }
            )
        }
    }

    // UI 按钮
    Column(modifier = Modifier.padding(16.dp)) {
        Button(
            onClick = {
                mediaPermissionHelper.requestMediaPermission(
                    launcher = mediaPermissionLauncher,
                    onGranted = { loadMediaFiles(context) },
                    onDenied = {}
                )
            }
        ) {
            Text(
                if (mediaPermissionHelper.hasMediaPermission()) "已授予媒体权限" 
                else "申请媒体权限（Android 10-16）"
            )
        }
    }
}

// Compose 中读取媒体文件
private fun loadMediaFiles(context: Context) {
    val images = queryImages(context) // 复用前文 MediaStore 查询图片的方法
    android.widget.Toast.makeText(context, "读取到 ${images.size} 张图片", android.widget.Toast.LENGTH_SHORT).show()
}

// 检查是否仅授予图片权限
fun hasOnlyImagePermission(context: Context): Boolean {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return false
    val hasImage = ContextCompat.checkSelfPermission(context, Manifest.permission.READ_MEDIA_IMAGES) == android.content.pm.PackageManager.PERMISSION_GRANTED
    val hasVideo = ContextCompat.checkSelfPermission(context, Manifest.permission.READ_MEDIA_VIDEO) == android.content.pm.PackageManager.PERMISSION_GRANTED
    return hasImage && !hasVideo
}

// 打开文件选择器选择图片（无需权限）
fun openImagePicker(activity: Activity, launcher: ActivityResultLauncher<Intent>) {
    val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
        addCategory(Intent.CATEGORY_OPENABLE)
        type = "image/*" // 限定图片类型
    }
    launcher.launch(intent)
}

// 处理选择结果
private val imagePickerLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
    if (result.resultCode == RESULT_OK) {
        val uri = result.data?.data // 获取选中图片的 Uri
        uri?.let { loadImageFromUri(context, it) } // 读取图片
    }
}