registerForActivityResult请求权限/拍照/选取视频图片/裁剪图片

权限相关

//近似定位（模糊定位）
Manifest.permission.ACCESS_COARSE_LOCATION
//精确定位
Manifest.permission.ACCESS_FINE_LOCATION

定位服务是否开启判断

// 判断定位服务是否开启
    private fun checkLocationServiceEnable(): Boolean {
        val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
        val gps = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)
        val network = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
        return gps || network
    }

检查是否具有某权限

//检查权限
    private fun checkPermission(): Boolean {
        return PackageManager.PERMISSION_GRANTED == if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            PermissionChecker.checkSelfPermission(App.instance, Manifest.permission.WRITE_EXTERNAL_STORAGE)
        } else {
            ContextCompat.checkSelfPermission(App.instance, Manifest.permission.WRITE_EXTERNAL_STORAGE)
        }
    }

分区存储

/**
     * 将私有目录文件拷贝到公共目录，仅针对Android10及以上版本
     * @param sourceFile 私有目录的源文件
     * */
    @RequiresApi(Build.VERSION_CODES.Q)
    private fun copyFileToPublicDir(sourceFile: File) {

        val contentValues = ContentValues().apply {
            put(MediaStore.Video.Media.DISPLAY_NAME, sourceFile.name)
            put(MediaStore.Video.Media.RELATIVE_PATH, Environment.DIRECTORY_MOVIES)
            put(MediaStore.Video.Media.IS_PENDING, true)
            put(MediaStore.Video.Media.MIME_TYPE, "video/mp4")
            put(MediaStore.Video.Media.DATE_TAKEN, System.currentTimeMillis())
        }

        contentResolver.insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, contentValues)?.apply {
            writeFile(contentValues, this, sourceFile)
        }
    }

    @RequiresApi(Build.VERSION_CODES.Q)
    private fun writeFile(contentValues: ContentValues, uri: Uri, sourceFile: File) {

        lifecycleScope.launch(Dispatchers.IO) {
            try {
                val optStream = contentResolver.openOutputStream(uri)
                val fileInputStream = sourceFile.inputStream()
                val byteArray = ByteArray(1024)
                fileInputStream.use { input ->
                    optStream?.use {
                        while (true) {
                            val readLeg = input.read(byteArray)
                            if (readLeg == -1) break
                            optStream.write(byteArray, 0, readLeg)
                        }
                    }
                }
                // 更新系统库文件
                contentValues.clear()
                contentValues.put(MediaStore.Video.Media.IS_PENDING, false)
                val num = contentResolver.update(uri, contentValues, null, null)
                if (num > 0) {
                    // 更新成功
                }
            } catch (ex: Exception) {
                Log.e(tag, ex.message ?: "copyFileToPublicDir error")
            }
        }
    }

请求单、多权限封装

import androidx.activity.result.ActivityResultCallback
import androidx.activity.result.ActivityResultCaller
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContracts

/**
 * 使用registerForActivityResult请求权限封装
 * @param caller 调用者，一般为Activity
 * */
class PermissionLauncher(caller: ActivityResultCaller) {

    // 请求权限，支持单、多权限申请
    private var launcher: ActivityResultLauncher>

    // 权限申请结果回调
    private lateinit var callback: ActivityResultCallback

    // 是否多权限
    private var multiPermission = false

    init {
        launcher = caller.registerForActivityResult(
            ActivityResultContracts.RequestMultiplePermissions()
        ) {
            // 多权限返回是否全部通过结果
            callback.onActivityResult(
                if (multiPermission) it.values.contains(false).not()
                else it.values.first()
            )
        }
    }

    /**
     * 启动请求权限
     * @param permissions 权限列表
     * @param callback 权限申请结果回调
     * */
    fun launch(
        permissions: Array,
        callback: ActivityResultCallback
    ) {
        this.callback = callback
        // 是否多权限，回调区分处理
        multiPermission = permissions.size > 1
        launcher.launch(permissions)
    }
}

使用示例：

// 权限请求，在Activity中
    private val permissionRequest = PermissionLauncher(this)
    
    private fun requestPermission() {
        permissionRequest.launch(
            arrayOf(Manifest.permission.WRITE_EXTERNAL_STORAGE
        )){ granted -> 
            if (granted) "permission ok".showToast()
            else "permission defined".showToast()
        }
    }

1.请求单权限

//注册权限请求
private final ActivityResultLauncher mActLauncherPermission = registerForActivityResult(
            new ActivityResultContracts.RequestPermission(), result -> Log.i("zhao", "权限：" + result)
    );

//在需要的时候启动权限请求
private void requestPermission() {

        mActLauncherPermission.launch(Manifest.permission.CAMERA);
    }

2.请求多权限

//多权限请求
    protected final ActivityResultLauncher mResultLauncherPermission =
            registerForActivityResult(new ActivityResultContracts.RequestMultiplePermissions(), result -> {
                boolean allOk = true;
                for (String item : result.keySet()) {
                    try {
                        boolean bOK = result.get(item);
                        if (!bOK) {
                            allOk = false;
                            break;
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                Log.i("zhao", "所有权限：" + allOk);
            });


//请求多种类权限
    private void requestMultiPermissions(String[] permissions) {
        mResultLauncherPermission.launch(permissions);
    }

3.拍照

返回图片Bitmap格式

//拍照
private final ActivityResultLauncher mLauncherCamera = registerForActivityResult(
            new ActivityResultContracts.TakePicturePreview(), result -> {
                //result为拍摄照片Bitmap格式
            });

//启动拍照（注意先检查权限）
//开启拍照,返回结果Bitmap
    private void launchCamera() {
        mLauncherCamera.launch(null);
    }

拍照返回Uri格式

（1）先自定义ActivityResultContract

import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.MediaStore;

import androidx.activity.result.contract.ActivityResultContract;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.core.content.FileProvider;

import java.io.File;

/**
 * 拍照返回存储的图片的uri
 */
public class TakeCameraUri extends ActivityResultContract {

    //拍照返回的uri
    private Uri uri;

    @NonNull
    @Override
    public Intent createIntent(@NonNull Context context, Object input) {

        String mimeType = "image/jpeg";
        String fileName = System.currentTimeMillis() + ".jpg";
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {

            ContentValues values = new ContentValues();
            values.put(MediaStore.MediaColumns.DISPLAY_NAME, fileName);
            values.put(MediaStore.MediaColumns.MIME_TYPE, mimeType);
            values.put(MediaStore.MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_DCIM);
            uri = context.getContentResolver()
                    .insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
        } else {
            //应用认证表示
            String authorities = "这里为您自己定义的fileProvider";
            uri = FileProvider.getUriForFile(context, authorities,
                    new File(context.getExternalCacheDir().getAbsolutePath(), fileName));
        }
        return new Intent(MediaStore.ACTION_IMAGE_CAPTURE).putExtra(MediaStore.EXTRA_OUTPUT, uri);
    }

    @Override
    public Uri parseResult(int resultCode, @Nullable Intent intent) {
        return uri;
    }
}

（2）注册调用

//注册调用
private final ActivityResultLauncher