Android打开文件选择器的实现步骤与代码示例

Android文件选择器的核心原理与架构设计

在Android应用开发中，文件选择器是一个高频使用的功能组件。理解其核心原理对于开发高质量的文件管理功能至关重要。

系统文件选择器的工作机制

Android系统通过Intent机制提供了一套完整的文件选择解决方案。当应用需要选择文件时，系统会启动一个文件选择界面，用户选择完成后返回结果给调用应用。这个过程涉及以下几个核心组件：

Intent.ACTION_OPEN_DOCUMENT - 用于打开文档选择器
Intent.ACTION_GET_CONTENT - 用于获取内容提供者中的数据
DocumentsContract - 提供对文档提供者的访问接口
ContentResolver - 用于查询和操作内容提供者中的数据

权限模型演进

从Android 6.0（API 23）开始，Google引入了运行时权限模型。文件访问权限经历了重大变化：

Android 4.4（API 19） 之前：需要READ_EXTERNAL_STORAGE权限
Android 4.4 - Android 10（API 29）：引入存储访问框架（SAF）
Android 11（API 30）及以上：强制执行分区存储（Scoped Storage）

💡 TRAE IDE 优势：TRAE IDE 内置了权限管理助手，能够智能识别项目所需的文件访问权限，并自动生成相应的权限声明和运行时权限请求代码，大大简化了开发流程。

完整的实现步骤与代码示例

步骤1：添加必要的权限声明

在AndroidManifest.xml中添加权限：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
 
    <!-- Android 11以下版本需要的外部存储权限 -->
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
        android:maxSdkVersion="32" />
    
    <!-- Android 13及以上版本的图片和视频权限 -->
    <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
    <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
    <uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
 
    <application
        android:allowBackup="true"
        android:requestLegacyExternalStorage="true"
        ...>
        ...
    </application>
</manifest>

步骤2：创建文件选择器工具类

object FilePickerUtil {
    
    // 支持的文件类型映射
    private val MIME_TYPE_MAP = mapOf(
        "image" to arrayOf("image/jpeg", "image/png", "image/gif", "image/webp"),
        "document" to arrayOf("application/pdf", "text/plain", "application/msword"),
        "video" to arrayOf("video/mp4", "video/avi", "video/quicktime"),
        "audio" to arrayOf("audio/mpeg", "audio/wav", "audio/ogg"),
        "all" to arrayOf("*/*")
    )
    
    /**
     * 打开文件选择器
     * @param activity 当前Activity
     * @param fileType 文件类型（image, document, video, audio, all）
     * @param requestCode 请求码
     */
    fun openFilePicker(
        activity: Activity,
        fileType: String = "all",
        requestCode: Int = FILE_PICKER_REQUEST_CODE
    ) {
        val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
            // 设置选择模式为单选
            addCategory(Intent.CATEGORY_OPENABLE)
            
            // 设置文件类型过滤
            val mimeTypes = MIME_TYPE_MAP[fileType] ?: arrayOf("*/*")
            type = if (mimeTypes.size == 1) {
                mimeTypes[0]
            } else {
                "*/*"
            }
            
            // 多类型支持
            if (mimeTypes.size > 1) {
                putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes)
            }
            
            // 允许多选（可选）
            putExtra(Intent.EXTRA_ALLOW_MULTIPLE, false)
        }
        
        activity.startActivityForResult(intent, requestCode)
    }
    
    /**
     * 处理选择结果
     * @param data Intent数据
     * @return 选择的文件信息
     */
    fun handleFilePickerResult(data: Intent?): FileInfo? {
        data?.data?.let { uri ->
            return getFileInfo(uri)
        }
        return null
    }
    
    /**
     * 获取文件详细信息
     * @param uri 文件URI
     * @return 文件信息对象
     */
    private fun getFileInfo(uri: Uri): FileInfo? {
        return try {
            val cursor = TRAEApplication.context.contentResolver.query(
                uri, null, null, null, null
            )
            
            cursor?.use {
                if (it.moveToFirst()) {
                    val displayNameIndex = it.getColumnIndex(OpenableColumns.DISPLAY_NAME)
                    val sizeIndex = it.getColumnIndex(OpenableColumns.SIZE)
                    
                    val displayName = if (displayNameIndex >= 0) it.getString(displayNameIndex) else "Unknown"
                    val size = if (sizeIndex >= 0) it.getLong(sizeIndex) else 0L
                    val mimeType = TRAEApplication.context.contentResolver.getType(uri)
                    
                    FileInfo(
                        uri = uri,
                        name = displayName,
                        size = size,
                        mimeType = mimeType ?: "application/octet-stream",
                        path = uri.toString()
                    )
                } else {
                    null
                }
            }
        } catch (e: Exception) {
            e.printStackTrace()
            null
        }
    }
    
    /**
     * 读取文件内容
     * @param uri 文件URI
     * @return 文件内容的字节数组
     */
    fun readFileContent(uri: Uri): ByteArray? {
        return try {
            TRAEApplication.context.contentResolver.openInputStream(uri)?.use { inputStream ->
                inputStream.readBytes()
            }
        } catch (e: Exception) {
            e.printStackTrace()
            null
        }
    }
    
    /**
     * 复制文件到应用私有目录
     * @param uri 源文件URI
     * @param destinationDir 目标目录
     * @return 复制后的文件
     */
    fun copyFileToAppDir(uri: Uri, destinationDir: File): File? {
        return try {
            val fileInfo = getFileInfo(uri) ?: return null
            val destinationFile = File(destinationDir, fileInfo.name)
            
            TRAEApplication.context.contentResolver.openInputStream(uri)?.use { inputStream ->
                destinationFile.outputStream().use { outputStream ->
                    inputStream.copyTo(outputStream)
                }
            }
            
            destinationFile
        } catch (e: Exception) {
            e.printStackTrace()
            null
        }
    }
    
    const val FILE_PICKER_REQUEST_CODE = 1001
}
 
/**
 * 文件信息数据类
 */
data class FileInfo(
    val uri: Uri,
    val name: String,
    val size: Long,
    val mimeType: String,
    val path: String
) {
    val isImage: Boolean get() = mimeType.startsWith("image/")
    val isVideo: Boolean get() = mimeType.startsWith("video/")
    val isAudio: Boolean get() = mimeType.startsWith("audio/")
    val isDocument: Boolean get() = mimeType == "application/pdf" || mimeType == "text/plain"
    
    fun getFormattedSize(): String {
        val kb = size / 1024.0
        val mb = kb / 1024.0
        val gb = mb / 1024.0
        
        return when {
            gb >= 1 -> "%.2f GB".format(gb)
            mb >= 1 -> "%.2f MB".format(mb)
            kb >= 1 -> "%.2f KB".format(kb)
            else -> "$size B"
        }
    }
}

步骤3：在Activity中使用文件选择器

class MainActivity : AppCompatActivity() {
    
    private lateinit var binding: ActivityMainBinding
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        
        setupClickListeners()
    }
    
    private fun setupClickListeners() {
        binding.btnSelectFile.setOnClickListener {
            // 检查权限
            if (hasRequiredPermissions()) {
                openFilePicker()
            } else {
                requestPermissions()
            }
        }
        
        binding.btnSelectImage.setOnClickListener {
            FilePickerUtil.openFilePicker(this, "image", IMAGE_PICKER_REQUEST_CODE)
        }
        
        binding.btnSelectDocument.setOnClickListener {
            FilePickerUtil.openFilePicker(this, "document", DOCUMENT_PICKER_REQUEST_CODE)
        }
    }
    
    private fun hasRequiredPermissions(): Boolean {
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            // Android 13及以上版本
            ContextCompat.checkSelfPermission(this, Manifest.permission.READ_MEDIA_IMAGES) == PackageManager.PERMISSION_GRANTED
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            // Android 6.0到Android 12
            ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED
        } else {
            // Android 6.0以下版本
            true
        }
    }
    
    private fun requestPermissions() {
        val permissions = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            arrayOf(Manifest.permission.READ_MEDIA_IMAGES)
        } else {
            arrayOf(Manifest.permission.READ_EXTERNAL_STORAGE)
        }
        
        ActivityCompat.requestPermissions(this, permissions, PERMISSION_REQUEST_CODE)
    }
    
    private fun openFilePicker() {
        FilePickerUtil.openFilePicker(this)
    }
    
    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        
        when (requestCode) {
            PERMISSION_REQUEST_CODE -> {
                if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    openFilePicker()
                } else {
                    Toast.makeText(this, "需要文件访问权限才能选择文件", Toast.LENGTH_SHORT).show()
                }
            }
        }
    }
    
    @Deprecated("Deprecated in Java")
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        
        if (resultCode == Activity.RESULT_OK) {
            when (requestCode) {
                FilePickerUtil.FILE_PICKER_REQUEST_CODE,
                IMAGE_PICKER_REQUEST_CODE,
                DOCUMENT_PICKER_REQUEST_CODE -> {
                    handleFileSelection(data)
                }
            }
        }
    }
    
    private fun handleFileSelection(data: Intent?) {
        val fileInfo = FilePickerUtil.handleFilePickerResult(data)
        fileInfo?.let {
            displayFileInfo(it)
            
            // 可选：复制文件到应用目录
            val appDir = File(filesDir, "selected_files")
            if (!appDir.exists()) {
                appDir.mkdirs()
            }
            
            val copiedFile = FilePickerUtil.copyFileToAppDir(it.uri, appDir)
            copiedFile?.let { file ->
                Log.d("FilePicker", "文件已复制到: ${file.absolutePath}")
            }
        } ?: run {
            Toast.makeText(this, "未能获取文件信息", Toast.LENGTH_SHORT).show()
        }
    }
    
    private fun displayFileInfo(fileInfo: FileInfo) {
        binding.apply {
            tvFileName.text = "文件名: ${fileInfo.name}"
            tvFileSize.text = "文件大小: ${fileInfo.getFormattedSize()}"
            tvFileType.text = "文件类型: ${fileInfo.mimeType}"
            tvFilePath.text = "文件路径: ${fileInfo.path}"
            
            // 如果是图片，显示预览
            if (fileInfo.isImage) {
                ivPreview.visibility = View.VISIBLE
                Glide.with(this@MainActivity)
                    .load(fileInfo.uri)
                    .into(ivPreview)
            } else {
                ivPreview.visibility = View.GONE
            }
        }
    }
    
    companion object {
        private const val PERMISSION_REQUEST_CODE = 2001
        private const val IMAGE_PICKER_REQUEST_CODE = 2002
        private const val DOCUMENT_PICKER_REQUEST_CODE = 2003
    }
}

步骤4：布局文件示例

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp"
    tools:context=".MainActivity">
 
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Android文件选择器演示"
        android:textSize="20sp"
        android:textStyle="bold"
        android:layout_marginBottom="16dp" />
 
    <Button
        android:id="@+id/btnSelectFile"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="选择任意文件"
        android:layout_marginBottom="8dp" />
 
    <Button
        android:id="@+id/btnSelectImage"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="选择图片"
        android:layout_marginBottom="8dp" />
 
    <Button
        android:id="@+id/btnSelectDocument"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="选择文档"
        android:layout_marginBottom="16dp" />
 
    <ScrollView
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1">
 
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical">
 
            <TextView
                android:id="@+id/tvFileName"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="文件名: 未选择"
                android:layout_marginBottom="8dp" />
 
            <TextView
                android:id="@+id/tvFileSize"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="文件大小: 未知"
                android:layout_marginBottom="8dp" />
 
            <TextView
                android:id="@+id/tvFileType"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="文件类型: 未知"
                android:layout_marginBottom="8dp" />
 
            <TextView
                android:id="@+id/tvFilePath"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="文件路径: 未知"
                android:layout_marginBottom="16dp" />
 
            <ImageView
                android:id="@+id/ivPreview"
                android:layout_width="match_parent"
                android:layout_height="200dp"
                android:visibility="gone"
                android:scaleType="centerCrop"
                android:layout_marginTop="8dp" />
 
        </LinearLayout>
    </ScrollView>
 
</LinearLayout>

💡 TRAE IDE 优势：TRAE IDE 提供了智能代码补全功能，在编写文件选择器相关代码时，能够自动提示可用的 MIME 类型、Intent 参数和权限常量，减少查阅文档的时间。同时，内置的布局预览器可以实时显示界面效果，加速 UI 开发流程。

常见问题和解决方案

问题1：Android 11及以上版本无法访问外部存储

原因：Android 11引入了分区存储（Scoped Storage）机制，应用默认只能访问自己的私有目录和特定类型的媒体文件。

解决方案：

在AndroidManifest.xml中添加：

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

使用存储访问框架（SAF）：

// 使用ACTION_OPEN_DOCUMENT而不是直接访问文件路径
val intent = Intent(Intent.ACTION_OPEN_DOCUMENT)

对于Android 11及以上版本，申请MANAGE_EXTERNAL_STORAGE权限（需要特殊处理）：

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
    if (!Environment.isExternalStorageManager()) {
        val intent = Intent(Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION)
        startActivity(intent)
    }
}

问题2：文件URI无法转换为真实路径

原因：从Android 4.4开始，系统返回的URI可能是content://格式，而不是传统的file://格式。

解决方案：使用ContentResolver直接处理URI，而不是尝试转换为文件路径：

fun getFileFromUri(context: Context, uri: Uri): File? {
    return try {
        val inputStream = context.contentResolver.openInputStream(uri)
        val file = File(context.cacheDir, "temp_file")
        
        inputStream?.use { input ->
            file.outputStream().use { output ->
                input.copyTo(output)
            }
        }
        
        file
    } catch (e: Exception) {
        e.printStackTrace()
        null
    }
}

问题3：大文件处理导致内存溢出

原因：一次性读取大文件内容到内存中。

解决方案：使用流式处理，避免一次性加载整个文件：

fun processLargeFile(uri: Uri, processor: (InputStream) -> Unit) {
    try {
        TRAEApplication.context.contentResolver.openInputStream(uri)?.use { inputStream ->
            // 使用缓冲区逐块处理
            val buffer = ByteArray(8192) // 8KB缓冲区
            var bytesRead: Int
            
            while (inputStream.read(buffer).also { bytesRead = it } != -1) {
                // 处理数据块
                processDataChunk(buffer, bytesRead)
            }
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

问题4：文件选择器在某些设备上无法正常工作

原因：不同厂商的Android系统可能存在定制化差异。

解决方案：

提供多种文件选择方式作为备选方案
使用第三方文件选择库作为备选方案
添加错误处理和用户提示

fun openFilePickerWithFallback(activity: Activity) {
    try {
        // 首选方案：系统文件选择器
        FilePickerUtil.openFilePicker(activity)
    } catch (e: Exception) {
        try {
            // 备选方案：使用Intent.createChooser
            val intent = Intent.createChooser(
                Intent(Intent.ACTION_GET_CONTENT).apply {
                    type = "*/*"
                    addCategory(Intent.CATEGORY_OPENABLE)
                },
                "选择文件"
            )
            activity.startActivityForResult(intent, FALLBACK_REQUEST_CODE)
        } catch (e2: Exception) {
            // 最后方案：提示用户手动选择
            Toast.makeText(activity, "请手动选择文件", Toast.LENGTH_SHORT).show()
        }
    }
}

进阶功能实现

多文件选择支持

fun openMultiFilePicker(activity: Activity, requestCode: Int) {
    val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
        addCategory(Intent.CATEGORY_OPENABLE)
        type = "*/*"
        putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true) // 允许多选
        putExtra(Intent.EXTRA_LOCAL_ONLY, true) // 只显示本地文件
    }
    
    activity.startActivityForResult(intent, requestCode)
}
 
fun handleMultiFileSelection(data: Intent?): List<FileInfo> {
    val fileList = mutableListOf<FileInfo>()
    
    data?.let { intent ->
        // 处理单选情况
        intent.data?.let { uri ->
            FilePickerUtil.handleFilePickerResult(intent)?.let {
                fileList.add(it)
            }
        }
        
        // 处理多选情况
        intent.clipData?.let { clipData ->
            for (i in 0 until clipData.itemCount) {
                clipData.getItemAt(i).uri?.let { uri ->
                    FilePickerUtil.getFileInfo(uri)?.let { fileInfo ->
                        fileList.add(fileInfo)
                    }
                }
            }
        }
    }
    
    return fileList
}

文件类型过滤增强

fun createAdvancedFileFilter(): Intent {
    return Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
        addCategory(Intent.CATEGORY_OPENABLE)
        
        // 设置多个MIME类型
        val extraMimeTypes = arrayOf(
            "image/*",           // 所有图片
            "application/pdf",   // PDF文件
            "text/plain",        // 文本文件
            "application/msword", // Word文档
            "application/vnd.openxmlformats-officedocument.wordprocessingml.document" // DOCX
        )
        
        type = "*/*"
        putExtra(Intent.EXTRA_MIME_TYPES, extraMimeTypes)
        putExtra(Intent.EXTRA_TITLE, "选择文档或图片")
    }
}

💡 TRAE IDE 优势：TRAE IDE 的代码分析引擎能够实时检测潜在的兼容性问题，比如不同Android版本的权限差异、文件访问限制等，并提供相应的修复建议。同时，内置的性能分析工具可以帮助开发者识别大文件处理中的内存泄漏风险。

性能优化建议

1. 异步处理文件操作

// 使用协程处理文件操作
class FilePickerViewModel : ViewModel() {
    
    private val _fileSelectionResult = MutableLiveData<FileInfo?>()
    val fileSelectionResult: LiveData<FileInfo?> = _fileSelectionResult
    
    fun processSelectedFile(uri: Uri) {
        viewModelScope.launch(Dispatchers.IO) {
            try {
                val fileInfo = FilePickerUtil.getFileInfo(uri)
                withContext(Dispatchers.Main) {
                    _fileSelectionResult.value = fileInfo
                }
            } catch (e: Exception) {
                withContext(Dispatchers.Main) {
                    _fileSelectionResult.value = null
                }
            }
        }
    }
}

2. 文件缓存策略

object FileCacheManager {
    private const val MAX_CACHE_SIZE = 50 * 1024 * 1024 // 50MB
    private val cacheDir: File by lazy {
        File(TRAEApplication.context.cacheDir, "file_picker_cache").apply {
            if (!exists()) mkdirs()
        }
    }
    
    fun cacheFile(uri: Uri): File? {
        return try {
            val fileInfo = FilePickerUtil.getFileInfo(uri) ?: return null
            val cachedFile = File(cacheDir, "${fileInfo.name}_${System.currentTimeMillis()}")
            
            TRAEApplication.context.contentResolver.openInputStream(uri)?.use { input ->
                cachedFile.outputStream().use { output ->
                    input.copyTo(output)
                }
            }
            
            // 清理旧缓存
            cleanOldCache()
            
            cachedFile
        } catch (e: Exception) {
            e.printStackTrace()
            null
        }
    }
    
    private fun cleanOldCache() {
        val files = cacheDir.listFiles()?.sortedBy { it.lastModified() } ?: return
        var totalSize = files.sumOf { it.length() }
        
        while (totalSize > MAX_CACHE_SIZE && files.isNotEmpty()) {
            val oldestFile = files.first()
            totalSize -= oldestFile.length()
            oldestFile.delete()
        }
    }
}

3. 内存管理优化

class OptimizedFileProcessor {
    
    companion object {
        private const val BUFFER_SIZE = 8192
        private const val MAX_MEMORY_USAGE = 10 * 1024 * 1024 // 10MB
    }
    
    fun processFileSafely(uri: Uri, processor: (ByteArray, Int) -> Unit) {
        try {
            TRAEApplication.context.contentResolver.openInputStream(uri)?.use { inputStream ->
                val availableMemory = getAvailableMemory()
                val bufferSize = if (availableMemory > MAX_MEMORY_USAGE) {
                    BUFFER_SIZE * 4 // 较大缓冲区
                } else {
                    BUFFER_SIZE // 标准缓冲区
                }
                
                val buffer = ByteArray(bufferSize)
                var bytesRead: Int
                
                while (inputStream.read(buffer).also { bytesRead = it } != -1) {
                    processor(buffer, bytesRead)
                }
            }
        } catch (e: OutOfMemoryError) {
            // 处理内存不足情况
            System.gc() // 建议垃圾回收
            throw IOException("内存不足，无法处理文件", e)
        }
    }
    
    private fun getAvailableMemory(): Long {
        val runtime = Runtime.getRuntime()
        val maxMemory = runtime.maxMemory()
        val totalMemory = runtime.totalMemory()
        val freeMemory = runtime.freeMemory()
        
        return maxMemory - (totalMemory - freeMemory)
    }
}

测试与调试技巧

1. 单元测试

@Test
fun testFileInfoExtraction() {
    // 创建模拟URI
    val mockUri = Uri.parse("content://com.example.provider/test_file.pdf")
    
    // 模拟ContentResolver
    val mockCursor = MatrixCursor(arrayOf(OpenableColumns.DISPLAY_NAME, OpenableColumns.SIZE)).apply {
        addRow(arrayOf("test_file.pdf", 1024L))
    }
    
    val mockContentResolver = mock(ContentResolver::class.java)
    `when`(mockContentResolver.query(mockUri, null, null, null, null)).thenReturn(mockCursor)
    `when`(mockContentResolver.getType(mockUri)).thenReturn("application/pdf")
    
    // 测试文件信息提取
    val fileInfo = FilePickerUtil.getFileInfo(mockUri)
    
    assertNotNull(fileInfo)
    assertEquals("test_file.pdf", fileInfo?.name)
    assertEquals(1024L, fileInfo?.size)
    assertEquals("application/pdf", fileInfo?.mimeType)
}

2. 调试文件选择器

object FilePickerDebugger {
    
    fun logFilePickerIntent(intent: Intent) {
        Log.d("FilePickerDebug", "Intent Action: ${intent.action}")
        Log.d("FilePickerDebug", "Intent Type: ${intent.type}")
        Log.d("FilePickerDebug", "Intent Categories: ${intent.categories}")
        Log.d("FilePickerDebug", "Intent Extras: ${intent.extras?.keySet()?.joinToString()}")
        
        intent.extras?.let { extras ->
            for (key in extras.keySet()) {
                Log.d("FilePickerDebug", "Extra $key: ${extras.get(key)}")
            }
        }
    }
    
    fun logUriDetails(uri: Uri) {
        Log.d("FilePickerDebug", "URI: $uri")
        Log.d("FilePickerDebug", "URI Scheme: ${uri.scheme}")
        Log.d("FilePickerDebug", "URI Authority: ${uri.authority}")
        Log.d("FilePickerDebug", "URI Path: ${uri.path}")
        Log.d("FilePickerDebug", "URI Query: ${uri.query}")
    }
}

💡 TRAE IDE 优势：TRAE IDE 内置了强大的调试工具，支持断点调试文件选择器流程，可以实时查看Intent内容、URI详情和权限状态。同时，集成的日志分析器能够智能过滤文件选择相关的日志信息，帮助开发者快速定位问题。

总结

Android文件选择器的实现涉及多个技术层面，从基础的Intent使用到复杂的权限管理，再到性能优化和兼容性处理。通过本文的详细讲解，开发者可以构建出功能完善、性能优良的文件选择功能。

关键要点回顾：

理解不同Android版本的权限模型差异
正确使用存储访问框架（SAF）
合理处理文件URI，避免路径依赖
实施适当的性能优化和内存管理
提供完善的错误处理和备选方案

🚀 TRAE IDE 价值体现：在整个开发过程中，TRAE IDE通过智能代码提示、实时错误检测、性能分析工具和强大的调试功能，显著提升了Android文件选择器功能的开发效率。其深度集成的Android开发工具链，使得开发者能够专注于业务逻辑的实现，而不必过多关注底层细节。

通过TRAE IDE的辅助，开发者可以更快速地构建出符合现代Android开发标准的文件选择器功能，同时确保应用的稳定性、安全性和良好的用户体验。

（此内容由 AI 辅助生成，仅供参考）