305 lines
12 KiB
Plaintext
305 lines
12 KiB
Plaintext
/**
|
|
* PermissionManager.uts
|
|
*
|
|
* Utility class for managing Android permissions throughout the app
|
|
* Handles requesting permissions, checking status, and directing users to settings
|
|
*/
|
|
/**
|
|
* Common permission types that can be requested
|
|
*/
|
|
export enum PermissionType {
|
|
BLUETOOTH = 'bluetooth',
|
|
LOCATION = 'location',
|
|
STORAGE = 'storage',
|
|
CAMERA = 'camera',
|
|
MICROPHONE = 'microphone',
|
|
NOTIFICATIONS = 'notifications',
|
|
CALENDAR = 'calendar',
|
|
CONTACTS = 'contacts',
|
|
SENSORS = 'sensors'
|
|
}
|
|
/**
|
|
* Result of a permission request
|
|
*/
|
|
type PermissionResult = {
|
|
granted: boolean;
|
|
grantedPermissions: string[];
|
|
deniedPermissions: string[];
|
|
};
|
|
/**
|
|
* Manages permission requests and checks throughout the app
|
|
*/
|
|
export class PermissionManager {
|
|
/**
|
|
* Maps permission types to the actual Android permission strings
|
|
*/
|
|
private static getPermissionsForType(type: PermissionType): string[] {
|
|
switch (type) {
|
|
case PermissionType.BLUETOOTH:
|
|
return [
|
|
'android.permission.BLUETOOTH_SCAN',
|
|
'android.permission.BLUETOOTH_CONNECT',
|
|
'android.permission.BLUETOOTH_ADVERTISE'
|
|
];
|
|
case PermissionType.LOCATION:
|
|
return [
|
|
'android.permission.ACCESS_FINE_LOCATION',
|
|
'android.permission.ACCESS_COARSE_LOCATION'
|
|
];
|
|
case PermissionType.STORAGE:
|
|
return [
|
|
'android.permission.READ_EXTERNAL_STORAGE',
|
|
'android.permission.WRITE_EXTERNAL_STORAGE'
|
|
];
|
|
case PermissionType.CAMERA:
|
|
return ['android.permission.CAMERA'];
|
|
case PermissionType.MICROPHONE:
|
|
return ['android.permission.RECORD_AUDIO'];
|
|
case PermissionType.NOTIFICATIONS:
|
|
return ['android.permission.POST_NOTIFICATIONS'];
|
|
case PermissionType.CALENDAR:
|
|
return [
|
|
'android.permission.READ_CALENDAR',
|
|
'android.permission.WRITE_CALENDAR'
|
|
];
|
|
case PermissionType.CONTACTS:
|
|
return [
|
|
'android.permission.READ_CONTACTS',
|
|
'android.permission.WRITE_CONTACTS'
|
|
];
|
|
case PermissionType.SENSORS:
|
|
return ['android.permission.BODY_SENSORS'];
|
|
default:
|
|
return [];
|
|
}
|
|
}
|
|
/**
|
|
* Get appropriate display name for a permission type
|
|
*/
|
|
private static getPermissionDisplayName(type: PermissionType): string {
|
|
switch (type) {
|
|
case PermissionType.BLUETOOTH:
|
|
return '蓝牙';
|
|
case PermissionType.LOCATION:
|
|
return '位置';
|
|
case PermissionType.STORAGE:
|
|
return '存储';
|
|
case PermissionType.CAMERA:
|
|
return '相机';
|
|
case PermissionType.MICROPHONE:
|
|
return '麦克风';
|
|
case PermissionType.NOTIFICATIONS:
|
|
return '通知';
|
|
case PermissionType.CALENDAR:
|
|
return '日历';
|
|
case PermissionType.CONTACTS:
|
|
return '联系人';
|
|
case PermissionType.SENSORS:
|
|
return '身体传感器';
|
|
default:
|
|
return '未知权限';
|
|
}
|
|
}
|
|
/**
|
|
* Check if a permission is granted
|
|
* @param type The permission type to check
|
|
* @returns True if the permission is granted, false otherwise
|
|
*/
|
|
static isPermissionGranted(type: PermissionType): boolean {
|
|
try {
|
|
const permissions = this.getPermissionsForType(type);
|
|
const activity = UTSAndroid.getUniActivity();
|
|
if (activity == null || permissions.length === 0) {
|
|
return false;
|
|
}
|
|
// Check each permission in the group
|
|
for (const permission of permissions) {
|
|
if (!UTSAndroid.checkSystemPermissionGranted(activity, [permission])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
catch (e: any) {
|
|
__f__('error', 'at ak/PermissionManager.uts:132', `Error checking ${type} permission:`, e);
|
|
return false;
|
|
}
|
|
}
|
|
/**
|
|
* Request a permission from the user
|
|
* @param type The permission type to request
|
|
* @param callback Function to call with the result of the permission request
|
|
* @param showRationale Whether to show a rationale dialog if permission was previously denied
|
|
*/
|
|
static requestPermission(type: PermissionType, callback: (result: PermissionResult) => void, showRationale: boolean = true): void {
|
|
try {
|
|
const permissions = this.getPermissionsForType(type);
|
|
const activity = UTSAndroid.getUniActivity();
|
|
if (activity == null || permissions.length === 0) {
|
|
callback({
|
|
granted: false,
|
|
grantedPermissions: [],
|
|
deniedPermissions: permissions
|
|
} as PermissionResult);
|
|
return;
|
|
}
|
|
// Check if already granted
|
|
let allGranted = true;
|
|
for (const permission of permissions) {
|
|
if (!UTSAndroid.checkSystemPermissionGranted(activity, [permission])) {
|
|
allGranted = false;
|
|
break;
|
|
}
|
|
}
|
|
if (allGranted) {
|
|
callback({
|
|
granted: true,
|
|
grantedPermissions: permissions,
|
|
deniedPermissions: []
|
|
} as PermissionResult);
|
|
return;
|
|
}
|
|
// Request the permissions
|
|
UTSAndroid.requestSystemPermission(activity, permissions, (granted: boolean, grantedPermissions: string[]) => {
|
|
if (granted) {
|
|
callback({
|
|
granted: true,
|
|
grantedPermissions: grantedPermissions,
|
|
deniedPermissions: []
|
|
} as PermissionResult);
|
|
}
|
|
else if (showRationale) {
|
|
// Show rationale dialog
|
|
this.showPermissionRationale(type, callback);
|
|
}
|
|
else {
|
|
// Just report the denial
|
|
callback({
|
|
granted: false,
|
|
grantedPermissions: grantedPermissions,
|
|
deniedPermissions: this.getDeniedPermissions(permissions, grantedPermissions)
|
|
} as PermissionResult);
|
|
}
|
|
}, (denied: boolean, deniedPermissions: string[]) => {
|
|
callback({
|
|
granted: false,
|
|
grantedPermissions: this.getGrantedPermissions(permissions, deniedPermissions),
|
|
deniedPermissions: deniedPermissions
|
|
} as PermissionResult);
|
|
});
|
|
}
|
|
catch (e: any) {
|
|
__f__('error', 'at ak/PermissionManager.uts:217', `Error requesting ${type} permission:`, e);
|
|
callback({
|
|
granted: false,
|
|
grantedPermissions: [],
|
|
deniedPermissions: this.getPermissionsForType(type)
|
|
} as PermissionResult);
|
|
}
|
|
}
|
|
/**
|
|
* Show a rationale dialog explaining why the permission is needed
|
|
*/
|
|
private static showPermissionRationale(type: PermissionType, callback: (result: PermissionResult) => void): void {
|
|
const permissionName = this.getPermissionDisplayName(type);
|
|
uni.showModal({
|
|
title: '权限申请',
|
|
content: `需要${permissionName}权限才能使用相关功能`,
|
|
confirmText: '去设置',
|
|
cancelText: '取消',
|
|
success: (result) => {
|
|
if (result.confirm) {
|
|
this.openAppSettings();
|
|
callback({
|
|
granted: false,
|
|
grantedPermissions: [],
|
|
deniedPermissions: this.getPermissionsForType(type)
|
|
} as PermissionResult);
|
|
}
|
|
else {
|
|
callback({
|
|
granted: false,
|
|
grantedPermissions: [],
|
|
deniedPermissions: this.getPermissionsForType(type)
|
|
} as PermissionResult);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Open the app settings page
|
|
*/
|
|
static openAppSettings(): void {
|
|
try {
|
|
const context = UTSAndroid.getAppContext();
|
|
if (context != null) {
|
|
const intent = new android.content.Intent();
|
|
intent.setAction("android.settings.APPLICATION_DETAILS_SETTINGS");
|
|
const uri = android.net.Uri.fromParts("package", context.getPackageName(), null);
|
|
intent.setData(uri);
|
|
intent.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK);
|
|
context.startActivity(intent);
|
|
}
|
|
}
|
|
catch (e: any) {
|
|
__f__('error', 'at ak/PermissionManager.uts:285', 'Failed to open app settings', e);
|
|
uni.showToast({
|
|
title: '请手动前往系统设置修改应用权限',
|
|
icon: 'none',
|
|
duration: 3000
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
* Helper to get the list of granted permissions
|
|
*/
|
|
private static getGrantedPermissions(allPermissions: string[], deniedPermissions: string[]): string[] {
|
|
return allPermissions.filter((p): boolean => !deniedPermissions.includes(p));
|
|
}
|
|
/**
|
|
* Helper to get the list of denied permissions
|
|
*/
|
|
private static getDeniedPermissions(allPermissions: string[], grantedPermissions: string[]): string[] {
|
|
return allPermissions.filter((p): boolean => !grantedPermissions.includes(p));
|
|
}
|
|
/**
|
|
* Request multiple permission types at once
|
|
* @param types Array of permission types to request
|
|
* @param callback Function to call when all permissions have been processed
|
|
*/
|
|
static requestMultiplePermissions(types: PermissionType[], callback: (results: Map<PermissionType, PermissionResult>) => void): void {
|
|
if (types.length === 0) {
|
|
callback(new Map());
|
|
return;
|
|
}
|
|
const results = new Map<PermissionType, PermissionResult>();
|
|
let remaining = types.length;
|
|
for (const type of types) {
|
|
this.requestPermission(type, (result) => {
|
|
results.set(type, result);
|
|
remaining--;
|
|
if (remaining === 0) {
|
|
callback(results);
|
|
}
|
|
}, true);
|
|
}
|
|
}
|
|
/**
|
|
* Convenience method to request Bluetooth permissions
|
|
* @param callback Function to call after the permission request
|
|
*/
|
|
static requestBluetoothPermissions(callback: (granted: boolean) => void): void {
|
|
this.requestPermission(PermissionType.BLUETOOTH, (result) => {
|
|
// For Bluetooth, we also need location permissions on Android
|
|
if (result.granted) {
|
|
this.requestPermission(PermissionType.LOCATION, (locationResult) => {
|
|
callback(locationResult.granted);
|
|
});
|
|
}
|
|
else {
|
|
callback(false);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
//# sourceMappingURL=PermissionManager.uts.map |