APP 获取系统权限

permission.js

/**
 * 本模块封装了Android、iOS的应用权限判断、打开应用权限设置界面、以及位置系统服务是否开启
 */

var isIos
// #ifdef APP-PLUS
isIos = (plus.os.name == "iOS")
// #endif

// 判断推送权限是否开启
function judgeIosPermissionPush() {
	var result = false;
	var UIApplication = plus.ios.import("UIApplication");
	var app = UIApplication.sharedApplication();
	var enabledTypes = 0;
	if (app.currentUserNotificationSettings) {
		var settings = app.currentUserNotificationSettings();
		enabledTypes = settings.plusGetAttribute("types");
		console.log("enabledTypes1:" + enabledTypes);
		if (enabledTypes == 0) {
			console.log("推送权限没有开启");
		} else {
			result = true;
			console.log("已经开启推送功能!")
		}
		plus.ios.deleteObject(settings);
	} else {
		enabledTypes = app.enabledRemoteNotificationTypes();
		if (enabledTypes == 0) {
			console.log("推送权限没有开启!");
		} else {
			result = true;
			console.log("已经开启推送功能!")
		}
		console.log("enabledTypes2:" + enabledTypes);
	}
	plus.ios.deleteObject(app);
	plus.ios.deleteObject(UIApplication);
	return result;
}

// 判断定位权限是否开启
function judgeIosPermissionLocation() {
	var result = false;
	var cllocationManger = plus.ios.import("CLLocationManager");
	var status = cllocationManger.authorizationStatus();
	result = (status != 2)
	console.log("定位权限开启：" + result);
	// 以下代码判断了手机设备的定位是否关闭，推荐另行使用方法 checkSystemEnableLocation
	/* var enable = cllocationManger.locationServicesEnabled();
	var status = cllocationManger.authorizationStatus();
	console.log("enable:" + enable);
	console.log("status:" + status);
	if (enable && status != 2) {
		result = true;
		console.log("手机定位服务已开启且已授予定位权限");
	} else {
		console.log("手机系统的定位没有打开或未给予定位权限");
	} */
	plus.ios.deleteObject(cllocationManger);
	return result;
}

// 判断麦克风权限是否开启
function judgeIosPermissionRecord() {
	var result = false;
	var avaudiosession = plus.ios.import("AVAudioSession");
	var avaudio = avaudiosession.sharedInstance();
	var permissionStatus = avaudio.recordPermission();
	console.log("permissionStatus:" + permissionStatus);
	if (permissionStatus == 1684369017 || permissionStatus == 1970168948) {
		console.log("麦克风权限没有开启");
	} else {
		result = true;
		console.log("麦克风权限已经开启");
	}
	plus.ios.deleteObject(avaudiosession);
	return result;
}

// 判断相机权限是否开启
function judgeIosPermissionCamera() {
	var result = false;
	var AVCaptureDevice = plus.ios.import("AVCaptureDevice");
	var authStatus = AVCaptureDevice.authorizationStatusForMediaType('vide');
	console.log("authStatus:" + authStatus);
	if (authStatus == 3) {
		result = true;
		console.log("相机权限已经开启");
	} else {
		console.log("相机权限没有开启");
	}
	plus.ios.deleteObject(AVCaptureDevice);
	return result;
}

// 判断相册权限是否开启
function judgeIosPermissionPhotoLibrary() {
	var result = false;
	var PHPhotoLibrary = plus.ios.import("PHPhotoLibrary");
	var authStatus = PHPhotoLibrary.authorizationStatus();
	console.log("authStatus:" + authStatus);
	if (authStatus == 3) {
		result = true;
		console.log("相册权限已经开启");
	} else {
		console.log("相册权限没有开启");
	}
	plus.ios.deleteObject(PHPhotoLibrary);
	return result;
}

// 判断通讯录权限是否开启
function judgeIosPermissionContact() {
	var result = false;
	var CNContactStore = plus.ios.import("CNContactStore");
	var cnAuthStatus = CNContactStore.authorizationStatusForEntityType(0);
	if (cnAuthStatus == 3) {
		result = true;
		console.log("通讯录权限已经开启");
	} else {
		console.log("通讯录权限没有开启");
	}
	plus.ios.deleteObject(CNContactStore);
	return result;
}

// 判断日历权限是否开启
function judgeIosPermissionCalendar() {
	var result = false;
	var EKEventStore = plus.ios.import("EKEventStore");
	var ekAuthStatus = EKEventStore.authorizationStatusForEntityType(0);
	if (ekAuthStatus == 3) {
		result = true;
		console.log("日历权限已经开启");
	} else {
		console.log("日历权限没有开启");
	}
	plus.ios.deleteObject(EKEventStore);
	return result;
}

// 判断备忘录权限是否开启
function judgeIosPermissionMemo() {
	var result = false;
	var EKEventStore = plus.ios.import("EKEventStore");
	var ekAuthStatus = EKEventStore.authorizationStatusForEntityType(1);
	if (ekAuthStatus == 3) {
		result = true;
		console.log("备忘录权限已经开启");
	} else {
		console.log("备忘录权限没有开启");
	}
	plus.ios.deleteObject(EKEventStore);
	return result;
}

// Android权限查询
function requestAndroidPermission(permissionID) {
	return new Promise((resolve, reject) => {
		plus.android.requestPermissions(
			[permissionID], // 理论上支持多个权限同时查询，但实际上本函数封装只处理了一个权限的情况。有需要的可自行扩展封装
			function(resultObj) {
				var result = 0;
				for (var i = 0; i < resultObj.granted.length; i++) {
					var grantedPermission = resultObj.granted[i];
					console.log('已获取的权限：' + grantedPermission);
					result = 1
				}
				for (var i = 0; i < resultObj.deniedPresent.length; i++) {
					var deniedPresentPermission = resultObj.deniedPresent[i];
					console.log('拒绝本次申请的权限：' + deniedPresentPermission);
					result = 0
				}
				for (var i = 0; i < resultObj.deniedAlways.length; i++) {
					var deniedAlwaysPermission = resultObj.deniedAlways[i];
					console.log('永久拒绝申请的权限：' + deniedAlwaysPermission);
					result = -1
				}
				resolve(result);
				// 若所需权限被拒绝,则打开APP设置界面,可以在APP设置界面打开相应权限
				// if (result != 1) {
				// gotoAppPermissionSetting()
				// }
			},
			function(error) {
				console.log('申请权限错误：' + error.code + " = " + error.message);
				resolve({
					code: error.code,
					message: error.message
				});
			}
		);
	});
}

// 使用一个方法，根据参数判断权限
function judgeIosPermission(permissionID) {
	if (permissionID == "location") {
		return judgeIosPermissionLocation()
	} else if (permissionID == "camera") {
		return judgeIosPermissionCamera()
	} else if (permissionID == "photoLibrary") {
		return judgeIosPermissionPhotoLibrary()
	} else if (permissionID == "record") {
		return judgeIosPermissionRecord()
	} else if (permissionID == "push") {
		return judgeIosPermissionPush()
	} else if (permissionID == "contact") {
		return judgeIosPermissionContact()
	} else if (permissionID == "calendar") {
		return judgeIosPermissionCalendar()
	} else if (permissionID == "memo") {
		return judgeIosPermissionMemo()
	}
	return false;
}

// 跳转到**应用**的权限页面
function gotoAppPermissionSetting() {
	if (isIos) {
		var UIApplication = plus.ios.import("UIApplication");
		var application2 = UIApplication.sharedApplication();
		var NSURL2 = plus.ios.import("NSURL");
		// var setting2 = NSURL2.URLWithString("prefs:root=LOCATION_SERVICES");		
		var setting2 = NSURL2.URLWithString("app-settings:");
		application2.openURL(setting2);

		plus.ios.deleteObject(setting2);
		plus.ios.deleteObject(NSURL2);
		plus.ios.deleteObject(application2);
	} else {
		// console.log(plus.device.vendor);
		var Intent = plus.android.importClass("android.content.Intent");
		var Settings = plus.android.importClass("android.provider.Settings");
		var Uri = plus.android.importClass("android.net.Uri");
		var mainActivity = plus.android.runtimeMainActivity();
		var intent = new Intent();
		intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
		var uri = Uri.fromParts("package", mainActivity.getPackageName(), null);
		intent.setData(uri);
		mainActivity.startActivity(intent);
	}
}

// 检查系统的设备服务是否开启
// var checkSystemEnableLocation = async function () {
function checkSystemEnableLocation() {
	var result = false;
	if (isIos) {
		var cllocationManger = plus.ios.import("CLLocationManager");
		var result = cllocationManger.locationServicesEnabled();
		console.log("系统定位开启:" + result);
		plus.ios.deleteObject(cllocationManger);
		return result;
	} else {
		var context = plus.android.importClass("android.content.Context");
		var locationManager = plus.android.importClass("android.location.LocationManager");
		var main = plus.android.runtimeMainActivity();
		var mainSvr = main.getSystemService(context.LOCATION_SERVICE);
		result = mainSvr.isProviderEnabled(locationManager.GPS_PROVIDER);
		console.log("系统定位开启:" + result);
		return result
	}
}

module.exports = {
	judgeIosPermission: judgeIosPermission,
	requestAndroidPermission: requestAndroidPermission,
	checkSystemEnableLocation: checkSystemEnableLocation,
	gotoAppPermissionSetting: gotoAppPermissionSetting
}

tool.js

import { requestAndroidPermission ,
	gotoAppPermissionSetting,
	judgeIosPermission,

} from '@/units/permission'
let noClick = true
export const Debounce=({methods, info,wait})=>{
		      // methods是需要点击后需要执行的函数， info是点击需要传的参数
			
		       let that = this;
		       if (noClick) {
				     console.log(1);
		          // 第一次点击
		          noClick= false;
		           if(info && info !== '') {
		               // info是执行函数需要传的参数
		              methods(info);
		          } else {
		              methods();
		          }
				  let item = wait || 500
		          setTimeout(()=> {
		             noClick= true;
		         }, item)
		    } else {
				
			}
		        // 这里是重复点击的判断
	}
	
	export const navigateTo = (options) =>{
		uni.showLoading({
			title:'加载中...',
			duration:60*1000
		})
		uni.navigateTo({
			url:options.url,
			success:options.success?options.success:()=>{},
			complete:options.complete?options.complete:()=>{
				uni.hideLoading()
			},
		})
	}


	
// ... 原有代码保持不变 ...
/**
 * 查询是否受过权  获取本地储存的权限 判断是否授权成功
 */
function getRequestAndroid(androidPermission) {

	return new Promise((resolve, reject) => {
		let permission = uni.getStorageSync(androidPermission)
		if(permission){
			resolve(1)
		}else{
			resolve(0)
		}
	});
}
/**
 * 统一的权限请求方法
 * @param {Object} options
 * @param {string} options.permission - 权限标识符 (location/camera/photoLibrary/record等)
 * @param {string} options.reason - 请求权限的原因说明
 * @param {Function} options.success - 权限获取成功的回调
 * @param {Function} options.fail - 权限获取失败的回调
 */
var isIos
// #ifdef APP-PLUS
isIos = (plus.os.name == "iOS")
// #endif

function requestPermission({
    permission,
    reason = '完成功能需要获取相关权限',
    success,
    fail
}) {
    //兼容除了app平台
   if(uni.getSystemInfoSync().uniPlatform == 'web'){
       typeof success === 'function' && success();
       return
   }
    // 权限映射表
    const permissionMap = {
        location: {
            android: 'android.permission.ACCESS_FINE_LOCATION',
            title: '位置信息'
        },
        camera: {
            android: 'android.permission.CAMERA',
            title: '相机'
        },
        photoLibrary: {
            android: 'android.permission.READ_EXTERNAL_STORAGE',
            title: '相册'
        },
        record: {
            android: 'android.permission.RECORD_AUDIO',
            title: '麦克风'
        },
        phone: {
            android: 'android.permission.CALL_PHONE',
            title: '拨打电话'
        }
    };

    // 检查权限参数是否有效
    if (!permission || !permissionMap[permission]) {
        uni.showToast({
            title: '无效的权限请求',
            icon: 'none'
        });
        typeof fail === 'function' && fail({
            message: '无效的权限请求'
        });
        return;
    }

    // 获取权限显示名称
    const permissionTitle = permissionMap[permission].title;
    // 判断平台
    if (isIos) {
        // iOS 权限判断
		getRequestAndroid(permission)
		.then(result=>{
			if (result === 1) {
			    // 已有权限，直接执行成功回调
			    typeof success === 'function' && success();
			    return;
			}
			
			uni.showModal({
			    title: '权限申请',
			    content: `${reason}，请允许使用${permissionTitle}权限`,
			    success: (res) => {
			        if (res.confirm) {
			          // 已有权限，直接执行成功回调
			          typeof success === 'function' && success();
			        }
			       
			    }
			});
		})

    } else {
        // Android 权限请求
        const androidPermission = permissionMap[permission].android;
        // 先检查是否已经有权限
        getRequestAndroid(androidPermission).then(result => {
            if (result === 1) {
                // 已有权限，直接执行成功回调
                typeof success === 'function' && success();
                return;
            }
           
            // 没有权限，先显示申请原因
            uni.showModal({
                title: '权限申请',
                content: `${reason}，需要使用${permissionTitle}权限`,
                success: (res) => {
                    if (res.confirm) {
                        // 用户同意后再次请求权限
                        requestAndroidPermission(androidPermission).then(newResult => {
                            if (newResult === 1) {
								uni.setStorageSync(androidPermission,1)
                                typeof success === 'function' && success();
                            } else if (newResult === -1) {

								console.log('newResult :>> ', newResult);
                                // 永久拒绝
                              setTimeout(()=>{
								uni.showModal({
                                    title: '权限申请',
                                    content: `${reason}，请在设置中允许使用${permissionTitle}权限`,
                                    success: (modalRes) => {
                                        if (modalRes.confirm) {
                                            gotoAppPermissionSetting();
                                        }
                                        typeof fail === 'function' && fail({
                                            message: '用户永久拒绝授权'
                                        });
                                    }
                                });
							  },500)
                            } else {
                                typeof fail === 'function' && fail({
                                    message: '用户拒绝授权'
                                });
                            }
                        });
                    } else {
                        typeof fail === 'function' && fail({
                            message: '用户拒绝授权'
                        });
                    }
                }
            });
        }).catch(error => {
            typeof fail === 'function' && fail(error);
        });
    }
}

export {
	requestPermission
}

获取图片权限案例

<template>
  <view class="avatar-upload">
    <view class="avatar-wrapper" @click="chooseImage">
      <image 
        :src="avatarUrl || defaultAvatar" 
        class="avatar-image"
        mode="aspectFill"
      />
      <view class="upload-mask">
        <uni-icons type="camera-filled" size="20" color="#fff"></uni-icons>
      </view>
    </view>
  </view>
</template>

<script>
import { requestPermission } from '@/units/tool'
export default {
  name: 'AvatarUpload',
  props: {
    // 当前头像URL
    value: {
      type: String,
      default: ''
    },
    // 默认头像
    defaultAvatar: {
      type: String,
      default: '/static/0fa9cf1531d4a40acfcd220c61aa28e@2x.png'
    },
    // 上传的服务器地址
    uploadUrl: {
      type: String,
      default: ''
    }
  },
  
  data() {
    return {
      avatarUrl: ''
    }
  },
  
  watch: {
    value: {
      handler(newVal) {
        this.avatarUrl = newVal
      },
      immediate: true
    }
  },
  
  methods: {
    // 选择图片
    chooseImage() {
        requestPermission({
            permission:"camera",
            success:()=>{
                 uni.chooseImage({
        count: 1,
        sizeType: ['compressed'],
        sourceType: ['album', 'camera'],
        success: (res) => {
          // 获取图片临时路径

          const tempFilePath = res.tempFilePaths[0]
          console.log('tempFilePath :>> ', tempFilePath);
          // 裁剪图片
          this.cropImage(tempFilePath)
        },
        fail: (err) => {
        //   uni.showToast({
        //     title: '选择图片失败',
        //     icon: 'none'
        //   })
        }
      })
            }
        })
     
    },
    
    // 裁剪图片
    cropImage(tempFilePath) {
      uni.navigateTo({
        url: `/pages/common/cropper/cropper?src=${tempFilePath}`,
        events: {
          // 接收裁剪后的图片
          cropImage: (path) => {
            this.uploadAvatar(path)
          }
        }
      })
    },
    
    // 上传头像
    uploadAvatar(filePath) {
      if (!this.uploadUrl) {
        uni.showToast({
          title: '请配置上传地址',
          icon: 'none'
        })
        return
      }
      
      uni.showLoading({
        title: '上传中...'
      })
      
      uni.uploadFile({
        url: this.uploadUrl,
        filePath: filePath,
        name: 'file',
        success: (res) => {
          try {
            const data = JSON.parse(res.data)
            if (data.code === 0) {
              this.avatarUrl = data.data.url
              this.$emit('input', this.avatarUrl)
              this.$emit('success', this.avatarUrl)
              
              uni.showToast({
                title: '上传成功',
                icon: 'success'
              })
            } else {
              throw new Error(data.msg || '上传失败')
            }
          } catch (e) {
            uni.showToast({
              title: e.message,
              icon: 'none'
            })
          }
        },
        fail: () => {
          uni.showToast({
            title: '上传失败',
            icon: 'none'
          })
        },
        complete: () => {
          uni.hideLoading()
        }
      })
    }
  }
}
</script>

<style lang="scss">
.avatar-upload {
  .avatar-wrapper {
    position: relative;
    width: 100rpx;
    height: 100rpx;
    border-radius: 50%;
    overflow: hidden;
    
    .avatar-image {
      width: 100%;
      height: 100%;
    }
    
    .upload-mask {
      position: absolute;
      left: 0;
      right: 0;
      bottom: 0;
      height: 30px;
      background: rgba(0, 0, 0, 0.4);
      display: flex;
      justify-content: center;
      align-items: center;
      
      &:active {
        background: rgba(0, 0, 0, 0.6);
      }
    }
  }
}
</style>