在如今这个数字化飞速发展的时代，应用安全已经成为用户选择和使用应用的关键考量因素。鸿蒙操作系统深刻洞察到这一需求，为开发者精心打造了一套全面且精细的权限管理体系和强大的安全架构，助力开发者构建既安全又可靠的高质量应用。
一、鸿蒙权限模型精讲
（一）权限分类与分级
鸿蒙操作系统的权限模型基于“最小权限原则”构建，将权限精细划分为多个类别和级别，以满足不同场景下的安全需求。
系统权限 ：这类权限是系统的 “特权通行证”，仅授予系统应用和关键系统服务使用。它们掌控着系统的核心资源和关键功能，如系统设置的深度调整、核心硬件的直接操控等。系统权限在授权时会经过极为严格的审查和管控，第三方普通应用在常规情况下无法触及这类权限，从而确保系统的稳定性和安全性。
普通权限 ：相较于系统权限，普通权限的影响范围较小，主要涉及一些对用户隐私和系统安全影响有限的操作。例如，读取设备上的公开文档、使用设备的蓝牙功能等。对于这类权限，用户在安装应用时，系统会根据应用的声明自动进行授权，无需用户额外干预，简化了用户的操作流程。
用户授权权限 ：这类权限涉及到用户的敏感信息，如位置信息、通讯录、麦克风录音等。由于这些权限的敏感性和对用户隐私的潜在影响，应用必须在运行时明确告知用户使用这些权限的目的，并获得用户的明确授权后才能使用。
（二）运行时权限管控与透明化
运行时权限动态申请 ：敏感权限的申请不再是安装时的一次性行为，而是被巧妙地安排在应用运行时，与功能的使用紧密相连。这样的设计不仅提升了用户对权限使用的感知度，还赋予了用户更大的控制权。例如，当用户在使用一款社交应用时，只有在用户准备发送语音消息，点击录音按钮的那一刻，应用才会弹出请求麦克风权限的对话框。用户能够清晰地理解申请权限的背景和目的，从而做出更为明智的决策。
权限使用透明化机制 ：鸿蒙系统为用户提供了详尽的权限使用记录，构建了一个透明的权限使用环境。系统会自动记录应用获取和使用权限的时间、场景等详细信息，并向用户展示。用户可以随时在系统设置中查看这些记录，对应用的权限使用情况了如指掌。这不仅增强了用户对应用的信任，还促使开发者更加谨慎地对待权限的申请和使用，毕竟，任何不当的行为都可能被用户察觉。
（三）细粒度权限控制
鸿蒙系统支持精确到特定场景的权限管理，这种细粒度的控制赋予了用户和开发者更大的灵活性，使权限的授予更加精准地匹配实际需求。
例如，对于相机权限，用户可以选择仅在应用前台运行时授权使用。当应用退居后台时，系统会自动收回该权限，防止应用在未经用户允许的情况下进行后台拍照等可能侵犯隐私的操作。这种场景化的权限管理方式，让用户能够在享受应用功能的同时，最大程度地保护自己的隐私。
二、应用权限声明与配置要点
（一）精准声明权限：模块化配置文件
在开发鸿蒙应用时，module.json 文件是应用配置的核心，其中的权限声明部分尤为关键。开发者需要根据应用的实际功能需求，在 module.json 文件中清晰、准确地列出所需权限。
{
"module": {
"requestPermissions": [
{
"name": "ohos.permission.READ_CONTACTS",
"reason": "需要读取联系人信息以提供社交功能",
"usedScene": {
"ability": [
"MainAbility"
],
"when": "always"
}
},
{
"name": "ohos.permission.CAMERA",
"reason": "需要使用相机拍摄照片",
"usedScene": {
"ability": [
"MainAbility"
],
"when": "inuse"
}
}
]
}
}
name 字段 ：明确标识所需权限的名称，这是系统识别权限的关键。
reason 字段 ：这是与用户沟通的重要桥梁。用简洁明了的语言阐述申请权限的原因，能够帮助用户理解权限使用的必要性，降低用户因困惑而拒绝授权的可能性。
usedScene 字段 ：它定义了权限的使用场景，包括使用该权限的具体 Ability 组件以及权限使用时机（always 表示权限始终可用，inuse 表示权限仅在应用前台运行时可用）。通过合理设置 usedScene，开发者可以确保权限的使用范围符合实际需求，进一步遵循最小权限原则。
（二）常用权限列表：开发必备参考
以下是鸿蒙系统中一些常用权限及其说明，供开发者在开发过程中参考：
| 权限名称 | 说明 | 权限类型 |
|---|---|---|
| ohos.permission.READ_CONTACTS | 读取联系人 | 用户授权 |
| ohos.permission.WRITE_CONTACTS | 写入联系人 | 用户授权 |
| ohos.permission.READ_CALENDAR | 读取日历 | 用户授权 |
| ohos.permission.CAMERA | 使用相机 | 用户授权 |
| ohos.permission.READ_MEDIA | 读取媒体文件 | 用户授权 |
| ohos.permission.WRITE_MEDIA | 写入媒体文件 | 用户授权 |
| ohos.permission.LOCATION | 获取位置信息 | 用户授权 |
| ohos.permission.MICROPHONE | 使用麦克风 | 用户授权 |
| ohos.permission.INTERNET | 网络访问 | 普通权限 |
| ohos.permission.BLUETOOTH | 蓝牙通信 | 普通权限 |
三、运行时权限申请实战
对于用户授权权限，应用需要在运行时动态申请。鸿蒙系统提供了 abilityAccessCtrl 模块，帮助开发者高效地管理权限申请流程。
（一）权限申请流程：步骤清晰明确
权限申请流程一般包括以下几个关键步骤：
检查权限状态 ：在申请权限之前，先检查应用是否已经获得了相应权限。这一步骤可以避免不必要的权限申请对话框弹出，提升用户体验。如果应用已经获得了权限，就可以直接执行相关功能，无需进行后续的申请流程。
申请权限 ：如果应用尚未获得权限，就需要向用户申请。在申请权限时，要确保向用户清晰地传达使用该权限的目的和价值，使用户能够理解并信任应用对权限的需求。
处理授权结果 ：根据用户的决策（授权或拒绝），应用需要做出相应的响应。如果用户授予了权限，应用就可以顺利地开启相关功能；如果用户拒绝了权限申请，应用需要优雅地处理这一情况，例如提供功能降级选项或引导用户至系统设置手动授权。
（二）代码示例：权限申请的实用指南
1. 引入权限管理模块
import abilityAccessCtrl from '@ohos.abilityAccessCtrl';
import {
BusinessError } from '@ohos.base';
2. 检查权限状态
async checkPermission(permission: string): Promise<boolean> {
let atManager = abilityAccessCtrl.createAtManager();
try {
// 获取应用程序的 accessTokenID
let tokenId = this.getContext().getApplicationInfo().accessTokenId;
// 检查应用是否已被授予权限
let result = await atManager.checkAccessToken(tokenId, permission);
console.info(`Permission ${
permission} granted: ${
result}`);
return result === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED;
} catch (err) {
let error = err as BusinessError;
console.error(`Failed to check permission ${
permission}, error: ${
error.code}, ${
error.message}`);
return false;
}
}
3. 申请单个权限
async requestPermission(permission: string): Promise<boolean> {
// 先检查权限是否已授予
let hasPermission = await this.checkPermission(permission);
if (hasPermission) {
return true;
}
// 如未授予，向用户申请权限
let atManager = abilityAccessCtrl.createAtManager();
try {
let result = await atManager.requestPermissionsFromUser(this.getContext(), [permission]);
// 处理授权结果
if (result.authResults[0] === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
console.info(`Permission ${
permission} granted by user`);
return true;
} else {
console.info(`Permission ${
permission} denied by user`);
return false;
}
} catch (err) {
let error = err as BusinessError;
console.error(`Failed to request permission ${
permission}, error: ${
error.code}, ${
error.message}`);
return false;
}
}
4. 批量申请权限
async requestMultiplePermissions(permissions: string[]): Promise<Map<string, boolean>> {
let grantResults = new Map<string, boolean>();
// 检查每个权限的授权状态
for (let permission of permissions) {
let granted = await this.checkPermission(permission);
grantResults.set(permission, granted);
}
// 筛选出未授权的权限
let permissionsToRequest = Array.from(grantResults.entries())
.filter(([_, granted]) => !granted)
.map(([permission, _]) => permission);
if (permissionsToRequest.length === 0) {
// 所有权限已授予
return grantResults;
}
// 向用户申请未授权的权限
let atManager = abilityAccessCtrl.createAtManager();
try {
let result = await atManager.requestPermissionsFromUser(this.getContext(), permissionsToRequest);
// 更新授权结果
for (let i = 0; i < permissionsToRequest.length; i++) {
let permission = permissionsToRequest[i];
let granted = result.authResults[i] === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED;
grantResults.set(permission, granted);
}
return grantResults;
} catch (err) {
let error = err as BusinessError;
console.error(`Failed to request permissions, error: ${
error.code}, ${
error.message}`);
return grantResults;
}
}
5. 在 Ability 中使用
以相机权限为例，展示如何在实际开发中运用上述代码：
import abilityAccessCtrl from '@ohos.abilityAccessCtrl';
import {
BusinessError } from '@ohos.base';
import camera from '@ohos.multimedia.camera';
@Entry
@Component
struct CameraPage {
@State hasPermission: boolean = false;
aboutToAppear() {
this.requestCameraPermission();
}
async requestCameraPermission() {
// 创建权限管理对象
let atManager = abilityAccessCtrl.createAtManager();
let tokenId = this.getContext().getApplicationInfo().accessTokenId;
try {
// 检查相机权限
let result = await atManager.checkAccessToken(tokenId, 'ohos.permission.CAMERA');
if (result === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
this.hasPermission = true;
this.initCamera();
return;
}
// 申请相机权限
let requestResult = await atManager.requestPermissionsFromUser(
this.getContext(),
['ohos.permission.CAMERA']
);
if (requestResult.authResults[0] === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
this.hasPermission = true;
this.initCamera();
} else {
promptAction.showToast({
message: '没有相机权限，无法使用相机功能',
duration: 2000
});
}
} catch (err) {
let error = err as BusinessError;
console.error(`相机权限请求失败: ${
error.code}, ${
error.message}`);
}
}
initCamera() {
// 初始化相机逻辑
console.info('相机初始化');
// ...相机初始化代码...
}
build() {
Column() {
if (this.hasPermission) {
// 显示相机预览
Text('相机预览')
.fontSize(20)
} else {
// 显示权限提示
Text('需要相机权限才能使用此功能')
.fontSize(16)
Button('授权相机权限')
.onClick(() => this.requestCameraPermission())
}
}
.width('100%')
.height('100%')
}
}
四、权限最佳实践：开发者的行动指南
（一）权限使用原则：遵循最小权限原则
最小权限原则 ：这是权限管理的基石。开发者在开发过程中，要时刻秉持仅申请应用功能所必需的权限的理念。这样可以最大程度地减少权限滥用的风险，降低对用户隐私的潜在影响。例如，一个简单的文本编辑应用，通常只需要文件读写权限，而无需申请访问用户通讯录或位置信息等不相关权限。
及时申请权限 ：权限申请的时机至关重要。开发者应确保在应用需要使用某项功能时才申请对应权限，而不是在应用安装时就一次性申请所有权限。这种策略可以避免用户被大量的权限申请请求淹没，使用户能够更专注于当前的功能需求，从而提高用户对权限申请的接受度。
明确说明权限用途 ：清晰、简洁地向用户解释申请权限的目的和用途，是获得用户信任的关键。当用户清楚地了解权限将如何被使用，并且明白这对应用功能的实现至关重要时，他们更有可能授予权限。例如，在申请位置权限时，可以向用户说明 “我们需要您的位置信息，以便为您提供附近兴趣点的推荐服务”。
优雅降级策略 ：当用户拒绝授予权限时，应用不应简单地停止工作或报错，而是要提供合理的降级方案。这意味着应用在部分权限受限的情况下，仍能提供有限但有价值的功能。例如，若用户拒绝了相机权限，应用可以提供从相册选择照片的功能作为替代方案。
（二）权限拒绝处理：优化用户体验
当用户拒绝授予权限时，应用应采取以下措施来妥善处理这一情况：
友好解释 ：以礼貌、友好的方式向用户解释该功能需要相应权限才能正常运行，并且提供简明的指导，告知用户如何在系统设置中手动授予权限。例如，弹出一个对话框，内容为 “该功能需要相机权限才能正常使用。您可以在设备的设置 – 应用管理 – 本应用 – 权限中开启相机权限。”
引导至设置 ：为用户提供更便捷的操作方式，开发者可以在应用内提供直接跳转至系统权限设置页面的功能。这样，用户无需手动返回桌面查找设置入口，简化了操作流程，提高了用户体验。
（三）避免频繁申请被拒绝的权限：尊重用户选择
为了避免因多次申请同一被拒权限而导致的用户体验不佳，开发者可以采用以下策略：
记录拒绝次数 ：应用可以通过本地存储（如 SharedPreferences）记录用户拒绝权限的次数。当用户拒绝权限时，将相应的计数器加 1 并保存。
设置申请阈值 ：定义一个合理的申请阈值，例如 2 次。当用户拒绝权限的次数达到这个阈值时，应用将不再主动弹出权限申请对话框，转而引导用户前往系统设置页面进行手动授权。
// 存储用户拒绝权限的记录
class PermissionDenialTracker {
private static DENIAL_THRESHOLD = 2; // 最多申请次数
private static denialCounts = new Map<string, number>();
// 记录权限拒绝
static recordDenial(permission: string): void {
let count = this.denialCounts.get(permission) || 0;
this.denialCounts.set(permission, count + 1);
}
// 检查是否应该再次申请权限
static shouldRequestAgain(permission: string): boolean {
let count = this.denialCounts.get(permission) || 0;
return count < this.DENIAL_THRESHOLD;
}
// 重置拒绝计数
static resetDenialCount(permission: string): void {
this.denialCounts.set(permission, 0);
}
}
使用示例：
async smartRequestPermission(permission: string): Promise<boolean> {
// 检查是否已获得权限
let hasPermission = await this.checkPermission(permission);
if (hasPermission) {
return true;
}
// 检查是否超过拒绝阈值
if (!PermissionDenialTracker.shouldRequestAgain(permission)) {
// 已多次拒绝，直接引导用户前往设置
this.showPermissionSettingsGuide(permission);
return false;
}
// 申请权限
let granted = await this.requestPermission(permission);
if (!granted) {
// 记录拒绝
PermissionDenialTracker.recordDenial(permission);
} else {
// 权限获取成功，重置拒绝计数
PermissionDenialTracker.resetDenialCount(permission);
}
return granted;
}
// 显示权限设置引导
showPermissionSettingsGuide(permission: string): void {
promptAction.showDialog({
title: '需要权限',
message: `此功能需要${
this.getPermissionDescription(permission)}权限。
请在设置中手动授予权限。`,
buttons: [
{
text: '取消',
color: '#888888'
},
{
text: '前往设置',
color: '#0000ff'
}
],
success: (result) => {
if (result.index === 1) {
this.openPermissionSettings();
}
}
});
}
五、鸿蒙系统安全架构全解析
（一）多层次安全防护体系：全方位守护应用安全
鸿蒙系统的安全架构采用了多层次的设计，从系统底层到应用层，构建了全方位的安全防护体系。这一体系包括：
系统层安全 ：基于微内核架构，将核心系统服务和关键资源管理与外围功能相隔离。这种分离方式有效缩小了系统的攻击面，降低了系统受到恶意攻击的风险。同时，通过特权分离机制，确保不同组件和服务只能访问其合法权限范围内的资源，防止权限越界操作。
框架层安全 ：在框架层面，应用沙箱机制为每个应用提供了独立的运行环境，防止应用之间相互干扰或恶意访问。进程间通信（IPC）控制机制对应用之间的通信进行严格的安全检查，包括验证通信双方的身份、检查通信数据的完整性和保密性等，确保数据在不同进程之间的传输安全可靠。
应用层安全 ：应用层的权限管理机制通过精细的权限划分和严格的授权流程，确保应用只能执行其被授权的操作。应用签名验证机制则确保了应用的来源可信，防止未授权的应用在系统上运行，同时在应用升级过程中，签名验证也能确保应用未被篡改，保障了应用的完整性和安全性。
数据层安全 ：数据层的安全措施主要包括加密存储和安全传输。加密存储确保了即使设备丢失或被盗，存储在设备上的敏感数据也不会轻易被非法获取。安全传输机制（如强制使用 HTTPS）则保护了数据在网络传输过程中的保密性和完整性，防止数据被窃听或篡改。
（二）应用签名与验证：守护应用安全的基石
应用签名是鸿蒙系统保障应用安全的重要环节。开发者在发布应用时，需要使用自己的私钥对应用进行签名。系统在安装应用时，会通过公钥对签名进行验证，确保应用的完整性和来源可信。
签名与权限关联 ：应用签名与权限紧密相关。系统权限通常只授予具有特定签名的应用，确保只有可信的应用能够访问敏感的系统资源和功能。例如，系统级的权限可能只允许由系统签名的应用使用，而第三方应用则只能申请普通权限或用户授权权限。
签名一致性的升级保护 ：在应用升级过程中，系统会验证新版本的应用签名是否与已安装的旧版本应用签名一致。如果签名不一致，系统将阻止升级，防止恶意应用通过伪装成合法应用的更新来入侵用户设备。
（三）数据安全保护：加密与安全存储
鸿蒙系统为开发者提供了完善的数据安全保护机制，确保应用数据的安全性。
1. 加密存储：守护敏感数据的防线
开发者可以利用鸿蒙的加密库，采用标准加密算法（如 AES – GCM）对敏感数据进行加密存储。以下是一个简单的数据加密示例：
import cryptoFramework from '@ohos.security.cryptoFramework';
// 数据加密示例
async encryptSensitiveData(plaintext: string, key: Uint8Array): Promise<string> {
try {
// 创建AES算法参数
let spec = {
algName: 'AES',
mode: 'GCM',
paddingName: 'PKCS7',
ivSize: 16,
engineMode: 'ANY'
};
// 生成初始化向量
let iv = cryptoFramework.generateRandom(16);
// 创建密码实例
let cipher = cryptoFramework.createCipher(spec);
// 初始化加密器
cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, key, iv);
// 执行加密
let plaintextBuffer = new Uint8Array(Buffer.from(plaintext, 'utf-8'));
let ciphertextBuffer = cipher.doFinal(plaintextBuffer);
// 组合IV和密文
let result = new Uint8Array(iv.length + ciphertextBuffer.length);
result.set(iv);
result.set(ciphertextBuffer, iv.length);
// 转为Base64字符串
return Buffer.from(result).toString('base64');
} catch (error) {
console.error(`加密失败: ${
error}`);
throw error;
}
}
// 数据解密示例
async decryptSensitiveData(encryptedBase64: string, key: Uint8Array): Promise<string> {
try {
// 解析Base64数据
let encryptedData = new Uint8Array(Buffer.from(encryptedBase64, 'base64'));
// 提取IV (前16字节)
let iv = encryptedData.slice(0, 16);
// 提取密文
let ciphertext = encryptedData.slice(16);
// 创建AES算法参数
let spec = {
algName: 'AES',
mode: 'GCM',
paddingName: 'PKCS7',
ivSize: 16,
engineMode: 'ANY'
};
// 创建密码实例
let cipher = cryptoFramework.createCipher(spec);
// 初始化解密器
cipher.init(cryptoFramework.CryptoMode.DECRYPT_MODE, key, iv);
// 执行解密
let plaintextBuffer = cipher.doFinal(ciphertext);
// 转为字符串
return Buffer.from(plaintextBuffer).toString('utf-8');
} catch (error) {
console.error(`解密失败: ${
error}`);
throw error;
}
}
2. 安全偏好存储：安全存储小型数据的选择
对于需要安全存储的小型数据（如用户设置、令牌等），鸿蒙系统的安全偏好存储提供了一个简单易用的解决方案。
import data_preferences from '@ohos.data.preferences';
import {
BusinessError } from '@ohos.base';
class SecurePreferences {
private static instance: SecurePreferences;
private preferences: data_preferences.Preferences | null = null;
private securityKey: Uint8Array | null = null;
private constructor() {
}
static getInstance(): SecurePreferences {
if (!this.instance) {
this.instance = new SecurePreferences();
}
return this.instance;
}
async init(context: Context): Promise<void> {
try {
// 获取或生成加密密钥
this.securityKey = await this.getOrCreateSecurityKey();
// 初始化首选项
this.preferences = await data_preferences.getPreferences(context, 'secureStorage');
} catch (err) {
let error = err as BusinessError;
console.error(`初始化安全存储失败: ${
error.code}, ${
error.message}`);
throw err;
}
}
// 安全存储字符串
async putString(key: string, value: string): Promise<void> {
if (!this.preferences || !this.securityKey) {
throw new Error('安全存储未初始化');
}
try {
// 加密数据
let encryptedValue = await this.encryptSensitiveData(value, this.securityKey);
// 存储加密后的数据
await this.preferences.put(key, encryptedValue);
await this.preferences.flush();
} catch (err) {
let error = err as BusinessError;
console.error(`安全存储失败: ${
error.code}, ${
error.message}`);
throw err;
}
}
// 从安全存储获取字符串
async getString(key: string, defaultValue: string = ''): Promise<string> {
if (!this.preferences || !this.securityKey) {
throw new Error('安全存储未初始化');
}
try {
// 获取加密数据
let encryptedValue = await this.preferences.get(key, '');
if (encryptedValue === '') {
return defaultValue;
}
// 解密数据
return await this.decryptSensitiveData(encryptedValue, this.securityKey);
} catch (err) {
let error = err as BusinessError;
console.error(`安全读取失败: ${
error.code}, ${
error.message}`);
return defaultValue;
}
}
// 获取或创建安全密钥
private async getOrCreateSecurityKey(): Promise<Uint8Array> {
// 实际应用中应使用系统密钥库存储密钥
// 此处仅为示例，使用固定密钥（实际应用不应这样做）
return new Uint8Array([
0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
]);
}
// 加密和解密方法（与上面实现相同）
private async encryptSensitiveData(plaintext: string, key: Uint8Array): Promise<string> {
// 同上方实现
}
private async decryptSensitiveData(encryptedBase64: string, key: Uint8Array): Promise<string> {
// 同上方实现
}
}
六、实战案例：打造安全健康追踪应用
通过一个实际的健康追踪应用案例，我们将深入探讨如何在鸿蒙应用中正确实现权限管理和安全措施，使理论与实践紧密结合。
（一）场景描述：健康追踪应用的需求与挑战
该健康追踪应用旨在帮助用户记录和分析运动数据，其核心功能包括：
运动轨迹记录 ：通过获取用户的位置信息，绘制运动轨迹地图，让用户直观了解自己的运动路线和距离。
运动类型识别 ：利用设备的传感器，自动识别用户的运动类型，如步行、跑步、骑行等，为用户提供良好的运动分析基础。
运动数据存储 ：将用户的运动数据（如时间、距离、消耗的卡路里等）安全地存储在设备上，以便用户随时查看历史记录和分析报告。
运动照片记录 ：支持用户在运动过程中使用相机拍摄照片，记录运动瞬间，丰富运动记录的内容。
为了实现上述功能，应用需要申请以下权限：
位置信息权限：用于获取用户的运动轨迹数据。
活动识别权限：用于识别用户的运动类型。
存储权限：用于保存运动数据和照片。
相机权限：用于记录运动照片。
（二）应用权限声明：清晰明确的权限清单
在 module.json 文件中，我们按照应用的功能需求，精确声明所需权限：
{
"module": {
"package": "com.example.healthtracker",
"name": "HealthTrackerModule",
"requestPermissions": [
{
"name": "ohos.permission.LOCATION",
"reason": "需要获取位置信息以跟踪您的运动轨迹",
"usedScene": {
"ability": ["MainAbility"],
"when": "inuse"
}
},
{
"name": "ohos.permission.ACTIVITY_MOTION",
"reason": "需要识别您的运动类型",
"usedScene": {
"ability": ["MainAbility"],
"when": "inuse"
}
},
{
"name": "ohos.permission.READ_MEDIA",
"reason": "需要读取媒体文件以展示运动照片",
"usedScene": {
"ability": ["MainAbility"],
"when": "always"
}
},
{
"name": "ohos.permission.WRITE_MEDIA",
"reason": "需要保存您的运动照片和视频",
"usedScene": {
"ability": ["MainAbility"],
"when": "always"
}
},
{
"name": "ohos.permission.CAMERA",
"reason": "需要使用相机记录您的运动照片",
"usedScene": {
"ability": ["MainAbility"],
"when": "inuse"
}
}
]
}
}
（三）权限管理类：统一管理权限申请
创建一个专门的权限管理类，能够统一处理应用的权限申请和检查，使权限管理逻辑集中化，便于维护和管理。
// PermissionManager.ets
import abilityAccessCtrl from '@ohos.abilityAccessCtrl';
import {
BusinessError } from '@ohos.base';
import common from '@ohos.app.ability.common';
export class PermissionManager {
private context: common.UIAbilityContext;
private denialCounts: Map<string, number> = new Map();
private static readonly DENIAL_THRESHOLD = 2;
constructor(context: common.UIAbilityContext) {
this.context = context;
}
// 检查单个权限
async checkPermission(permission: string): Promise<boolean> {
const atManager = abilityAccessCtrl.createAtManager();
try {
const tokenId = this.context.getApplicationInfo().accessTokenId;
const result = await atManager.checkAccessToken(tokenId, permission);
return result === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED;
} catch (err) {
const error = err as BusinessError;
console.error(`权限检查失败 ${
permission}: ${
error.code}, ${
error.message}`);
return false;
}
}
// 申请单个权限
async requestPermission(permission: string): Promise<boolean> {
// 先检查是否已有权限
const hasPermission = await this.checkPermission(permission);
if (hasPermission) {
return true;
}
// 检查是否超过拒绝阈值
const denialCount = this.denialCounts.get(permission) || 0;
if (denialCount >= PermissionManager.DENIAL_THRESHOLD) {
this.showPermissionSettingsGuide(permission);
return false;
}
// 申请权限
const atManager = abilityAccessCtrl.createAtManager();
try {
const result = await atManager.requestPermissionsFromUser(this.context, [permission]);
const granted = result.authResults[0] === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED;
if (!granted) {
// 记录拒绝次数
this.denialCounts.set(permission, denialCount + 1);
}
return granted;
} catch (err) {
const error = err as BusinessError;
console.error(`权限申请失败 ${
permission}: ${
error.code}, ${
error.message}`);
return false;
}
}
// 批量申请权限
async requestPermissions(permissions: string[]): Promise<Map<string, boolean>> {
const results = new Map<string, boolean>();
// 先检查所有权限状态
for (const permission of permissions) {
const granted = await this.checkPermission(permission);
results.set(permission, granted);
}
// 筛选未授权的权限
const permissionsToRequest = Array.from(results.entries())
.filter(([_, granted]) => !granted)
.map(([permission, _]) => permission);
if (permissionsToRequest.length === 0) {
return results;
}
// 逐个申请权限（为了更好的用户体验，避免一次性弹出多个权限申请框）
for (const permission of permissionsToRequest) {
const granted = await this.requestPermission(permission);
results.set(permission, granted);
}
return results;
}
// 显示权限设置引导
private showPermissionSettingsGuide(permission: string): void {
// 获取权限的用户友好名称
const permissionName = this.getPermissionFriendlyName(permission);
// 显示对话框引导用户前往设置
import promptAction from '@ohos.promptAction';
promptAction.showDialog({
title: '需要权限',
message: `此功能需要${
permissionName}权限才能正常工作。
请前往设置手动授予此权限。`,
buttons: [
{
text: '取消',
color: '#888888'
},
{
text: '前往设置',
color: '#0000ff'
}
],
success: (result) => {
if (result.index === 1) {
// 跳转到应用权限设置页面
this.openPermissionSettings();
}
}
});
}
// 获取权限的用户友好名称
private getPermissionFriendlyName(permission: string): string {
const permissionMap: Record<string, string> = {
'ohos.permission.LOCATION': '位置',
'ohos.permission.ACTIVITY_MOTION': '活动识别',
'ohos.permission.READ_MEDIA': '媒体访问',
'ohos.permission.WRITE_MEDIA': '媒体存储',
'ohos.permission.CAMERA': '相机'
};
return permissionMap[permission] || permission;
}
// 跳转到应用权限设置页面
private openPermissionSettings(): void {
// 使用bundle管理跳转到应用的权限设置页面
import bundleManager from '@ohos.bundle.bundleManager';
import common from '@ohos.app.ability.common';
import wantConstant from '@ohos.app.ability.wantConstant';
try {
const bundleName = this.context.getApplicationInfo().name;
const want = {
action: wantConstant.Action.ACTION_APPLICATION_DETAILS_SETTINGS,
entities: [wantConstant.Entity.ENTITY_HOME_SCREEN],
parameters: {
'bundle.name': bundleName
}
};
this.context.startAbility(want);
} catch (err) {
const error = err as BusinessError;
console.error(`跳转到权限设置失败: ${
error.code}, ${
error.message}`);
}
}
}
（四）在页面中使用权限管理：功能与权限紧密结合
在运动追踪页面中，通过权限管理类，我们可以实现对位置权限、活动识别权限、存储权限以及相机权限的精确管理和申请，确保用户能够流畅地使用应用的各项功能。
// TrackingPage.ets
import {
PermissionManager } from '../common/PermissionManager';
@Entry
@Component
struct TrackingPage {
private permissionManager: PermissionManager = new PermissionManager(getContext(this) as common.UIAbilityContext);
@State hasLocationPermission: boolean = false;
@State hasActivityPermission: boolean = false;
@State hasCameraPermission: boolean = false;
aboutToAppear() {
this.checkAndRequestPermissions();
}
async checkAndRequestPermissions() {
// 检查并申请所需权限
const permissions = [
'ohos.permission.LOCATION',
'ohos.permission.ACTIVITY_MOTION',
'ohos.permission.READ_MEDIA',
'ohos.permission.WRITE_MEDIA'
];
const results = await this.permissionManager.requestPermissions(permissions);
// 更新权限状态
this.hasLocationPermission = results.get('ohos.permission.LOCATION') || false;
this.hasActivityPermission = results.get('ohos.permission.ACTIVITY_MOTION') || false;
// 根据权限状态启用相应功能
if (this.hasLocationPermission) {
this.startLocationTracking();
}
if (this.hasActivityPermission) {
this.startActivityRecognition();
}
}
// 打开相机前检查相机权限
async openCamera() {
const granted = await this.permissionManager.requestPermission('ohos.permission.CAMERA');
this.hasCameraPermission = granted;
if (granted) {
// 打开相机逻辑
this.startCamera();
} else {
// 提示用户权限被拒绝
promptAction.showToast({
message: '无法使用相机功能，请授予相机权限',
duration: 2000
});
}
}
// 启动位置追踪
startLocationTracking() {
// 位置追踪实现...
}
// 启动活动识别
startActivityRecognition() {
// 活动识别实现...
}
// 启动相机
startCamera() {
// 相机功能实现...
}
build() {
Column() {
// 应用UI实现
Text('健康追踪')
.fontSize(24)
.fontWeight(FontWeight.Bold)
.margin({
bottom: 20 })
if (this.hasLocationPermission && this.hasActivityPermission) {
// 显示完整功能
Text('正在追踪您的活动...')
.fontSize(16)
.margin({
bottom: 10 })
Button('拍摄照片')
.onClick(() => this.openCamera())
.margin({
top: 20 })
} else {
// 显示有限功能和权限提示
Text('需要位置和活动识别权限才能使用完整功能')
.fontSize(16)
.margin({
bottom: 20 })
Button('授予必要权限')
.onClick(() => this.checkAndRequestPermissions())
}
}
.width('100%')
.height('100%')
.padding(20)
}
}
（五）安全存储用户数据：确保数据安全
创建一个安全的数据管理器，用于处理用户的健康数据的加密存储和检索，保障用户数据的安全性。
// HealthDataManager.ets
import {
SecurePreferences } from '../common/SecurePreferences';
import data_rdb from '@ohos.data.relationalStore';
import {
BusinessError } from '@ohos.base';
import cryptoFramework from '@ohos.security.cryptoFramework';
export class HealthDataManager {
private context: common.Context;
private securePrefs: SecurePreferences;
private database: data_rdb.RdbStore | null = null;
private encryptionKey: Uint8Array | null = null;
constructor(context: common.Context) {
this.context = context;
this.securePrefs = SecurePreferences.getInstance();
}
// 初始化数据管理器
async init(): Promise<boolean> {
try {
// 初始化安全偏好存储
await this.securePrefs.init(this.context);
// 获取或生成加密密钥
this.encryptionKey = await this.getOrCreateEncryptionKey();
// 初始化数据库
await this.initDatabase();
return true;
} catch (err) {
const error = err as BusinessError;
console.error(`数据管理器初始化失败: ${
error.code}, ${
error.message}`);
return false;
}
}
// 获取或创建加密密钥
private async getOrCreateEncryptionKey(): Promise<Uint8Array> {
try {
// 从安全存储中获取密钥
const storedKey = await this.securePrefs.getString('encryption_key', '');
if (storedKey !== '') {
// 解码已存储的密钥
return new Uint8Array(Buffer.from(storedKey, 'base64'));
}
// 生成新密钥
const newKey = cryptoFramework.generateRandom(32); // 256位密钥
// 存储密钥
await this.securePrefs.putString('encryption_key', Buffer.from(newKey).toString('base64'));
return newKey;
} catch (err) {
const error = err as BusinessError;
console.error(`加密密钥生成失败: ${
error.code}, ${
error.message}`);
throw err;
}
}
// 初始化数据库
private async initDatabase(): Promise<void> {
try {
const STORE_CONFIG = {
name: 'HealthData.db',
securityLevel: data_rdb.SecurityLevel.S1
};
// 创建数据库
this.database = await data_rdb.getRdbStore(this.context, STORE_CONFIG);
// 创建表
await this.database.executeSql(
'CREATE TABLE IF NOT EXISTS activities (' +
'id INTEGER PRIMARY KEY AUTOINCREMENT, ' +
'type TEXT NOT NULL, ' +
'start_time INTEGER NOT NULL, ' +
'duration INTEGER NOT NULL, ' +
'encrypted_data TEXT NOT NULL, ' +
'created_at INTEGER NOT NULL)'
);
} catch (err) {
const error = err as BusinessError;
console.error(`数据库初始化失败: ${
error.code}, ${
error.message}`);
throw err;
}
}
// 保存活动数据
async saveActivity(activityType: string, startTime: number, duration: number, activityData: Object): Promise<boolean> {
if (!this.database || !this.encryptionKey) {
throw new Error('数据管理器未初始化');
}
try {
// 加密活动数据
const dataJson = JSON.stringify(activityData);
const encryptedData = await this.encryptData(dataJson, this.encryptionKey);
// 准备值对象
const valueObject = {
type: activityType,
start_time: startTime,
duration: duration,
encrypted_data: encryptedData,
created_at: Date.now()
};
// 插入数据
await this.database.insert('activities', valueObject);
return true;
} catch (err) {
const error = err as BusinessError;
console.error(`保存活动数据失败: ${
error.code}, ${
error.message}`);
return false;
}
}
// 获取活动数据
async getActivities(limit: number = 20, offset: number = 0): Promise<Array<any>> {
if (!this.database || !this.encryptionKey) {
throw new Error('数据管理器未初始化');
}
try {
// 查询数据
const resultSet = await this.database.querySql(
'SELECT * FROM activities ORDER BY start_time DESC LIMIT ? OFFSET ?',
[limit, offset]
);
const activities = [];
while (resultSet.goToNextRow()) {
const id = resultSet.getLong(resultSet.getColumnIndex('id'));
const type = resultSet.getString(resultSet.getColumnIndex('type'));
const startTime = resultSet.getLong(resultSet.getColumnIndex('start_time'));
const duration = resultSet.getLong(resultSet.getColumnIndex('duration'));
const encryptedData = resultSet.getString(resultSet.getColumnIndex('encrypted_data'));
// 解密数据
const decryptedData = await this.decryptData(encryptedData, this.encryptionKey);
const activityData = JSON.parse(decryptedData);
activities.push({
id,
type,
startTime,
duration,
data: activityData
});
}
resultSet.close();
return activities;
} catch (err) {
const error = err as BusinessError;
console.error(`获取活动数据失败: ${
error.code}, ${
error.message}`);
return [];
}
}
// 加密数据
private async encryptData(data: string, key: Uint8Array): Promise<string> {
// 使用前面实现的加密方法
// ...
}
// 解密数据
private async decryptData(encryptedData: string, key: Uint8Array): Promise<string> {
// 使用前面实现的解密方法
// ...
}
}
七、总结与最佳实践：构建安全应用的不二法则
鸿蒙系统的权限管理和安全机制为开发者提供了坚实的保障，助力开发者打造出既安全又可靠的应用。在开发过程中，开发者应当严格遵循以下最佳实践：
坚守最小权限原则 ：精准评估应用功能需求，仅申请必不可少的权限，避免权限冗余带来的安全风险。
精细化运行时权限管理 ：巧妙把握权限申请时机，紧密关联功能使用场景进行动态权限申请。同时，妥善应对权限拒绝情况，通过友好提示和引导，提升用户体验。
完善权限降级策略 ：在面对用户拒绝关键权限时，巧妙设计应用的功能降级方案。确保应用在权限受限情况下，仍能提供基础且实用的功能，维持应用的可用性和用户满意度。
加密存储常态化 ：养成对敏感数据加密存储的良好习惯，充分利用鸿蒙系统提供的加密库和安全存储组件，确保用户数据在设备上的安全性。
透明化数据使用 ：秉持开放、坦诚的态度向用户展示数据使用情况，通过清晰易懂的方式告知用户数据收集、使用和存储的全过程，增强用户对应用的信任感。
持续安全监控与更新 ：密切已关注应用的安全状况，定期进行安全评估和漏洞扫描。及时跟进鸿蒙系统的安全更新和最佳实践，不断强化应用的安全防护能力。
通过深入理解并践行上述最佳实践，开发者能够熟练运用鸿蒙系统的权限管理和安全机制，打造出既符合安全标准又具备卓越用户体验的应用。这不仅有助于保护用户的隐私和数据安全，还能提升应用在市场上的竞争力，赢得用户的信赖和青睐。在鸿蒙生态的蓬勃发展之下，安全可靠的应用将更具优势，能够更好地满足用户对高品质应用的需求，共同推动鸿蒙应用市场的繁荣与进步。
暂无评论内容