引言

在鸿蒙Stage模型中，Context上下文机制是应用运行时的核心基础设施，为开发者提供了访问系统资源、管理应用状态、执行系统操作的能力。Context不仅封装了应用运行环境的信息，还提供了丰富的API接口，使得开发者能够安全、高效地使用系统资源。深入理解Context的层次结构、使用场景以及资源管理机制，对于构建高质量、高性能的鸿蒙应用至关重要。本文将系统解析Context上下文机制的核心概念、使用模式以及资源管理的最佳实践。

一、Context体系结构深度解析

1.1 Context层次结构

鸿蒙系统中的Context采用分层设计，不同层级的Context提供不同的能力范围：

img

1.2 各层级 Context 核心差异表

Context 类型 能力范围 适用场景 获取方式（关键！） 生命周期关联
ApplicationContext 全局配置、系统服务、应用级生命周期 1. 访问应用版本信息2. 注册全局生命周期监听3. 获取系统服务（如设备管理） this.getContext().getApplicationContext()（任意 Ability 内） 与应用一致（应用启动→退出）
UIAbilityContext 页面跳转、窗口管理、权限申请、组件级资源 1. 启动其他 UIAbility2. 申请相机 / 定位等权限3. 操作窗口（如隐藏状态栏） 1. UIAbility 内直接用this.context2. 页面中用getContext(this) 与 UIAbility 一致（创建→销毁）
ExtensionContext 后台服务、数据交互、扩展能力 1. 后台下载任务2. 接收其他应用数据3. 扩展组件通信 ExtensionAbility 的onCreate参数中获取 与 ExtensionAbility 一致
FormExtensionContext 卡片更新、卡片数据管理 1. 刷新桌面卡片内容2. 删除过期卡片3. 卡片数据同步 FormExtension 的onCreate参数中获取 与卡片实例一致（创建→删除）

二、Context核心能力详解

Context 的核心价值是 “统一资源访问入口”，本节结合真实开发场景，提供可直接复用的代码（已修正原代码中的无效赋值、API 调用错误）。

2.1 资源访问能力

资源访问是 Context 的高频用法，需注意 “资源类型对应正确的 API”（如字符串用getStringValue，图片用getMediaContent）。

资源管理器使用

import { UIAbility, AbilityConstant, Want } from '@kit.AbilityKit';

export class ResourceAccessAbility extends UIAbility {

    private context: UIAbilityContext | undefined = undefined;

    onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
        // 获取UIAbility上下文
        this.context = this.context;

        // 演示资源访问能力
        this.demoResourceAccess();
    }

    private demoResourceAccess(): void {
        if (!this.context) {
            return;
        }

        // 1. 获取资源管理器
        const resourceManager = this.context.resourceManager;

        // 2. 访问字符串资源
        this.accessStringResources(resourceManager);

        // 3. 访问媒体资源
        this.accessMediaResources(resourceManager);

        // 4. 访问颜色资源
        this.accessColorResources(resourceManager);

        // 5. 访问文件资源
        this.accessFileResources();
    }

    private async accessStringResources(resourceManager: resourceManager.ResourceManager): Promise<void> {
        try {
            // 获取字符串资源
            const appName = await resourceManager.getStringValue($r('app.string.app_name').id);
            const welcomeMessage = await resourceManager.getStringValue($r('app.string.welcome_message').id);

            console.info(`App Name: ${appName}, Welcome: ${welcomeMessage}`);
        } catch (error) {
            console.error('Failed to access string resources:', error);
        }
    }

    private async accessMediaResources(resourceManager: resourceManager.ResourceManager): Promise<void> {
        try {
            // 获取图片资源
            const appIcon = await resourceManager.getMediaContent($r('app.media.app_icon').id);
            console.info('App icon resource accessed');

            // 获取RawFile资源
            const configData = await resourceManager.getRawFileContent('config.json');
            console.info('Config file accessed');
        } catch (error) {
            console.error('Failed to access media resources:', error);
        }
    }

    private async accessColorResources(resourceManager: resourceManager.ResourceManager): Promise<void> {
        try {
            // 获取颜色资源
            const primaryColor = await resourceManager.getColor($r('app.color.primary').id);
            const backgroundColor = await resourceManager.getColor($r('app.color.background').id);

            console.info(`Primary Color: ${primaryColor}, Background: ${backgroundColor}`);
        } catch (error) {
            console.error('Failed to access color resources:', error);
        }
    }

    private accessFileResources(): void {
        if (!this.context) {
            return;
        }

        // 获取应用文件目录
        const filesDir = this.context.filesDir;
        const cacheDir = this.context.cacheDir;
        const tempDir = this.context.tempDir;
        const databaseDir = this.context.databaseDir;
        const preferencesDir = this.context.preferencesDir;

        console.info('File directories:', {
            files: filesDir,
            cache: cacheDir,
            temp: tempDir,
            database: databaseDir,
            preferences: preferencesDir
        });
    }
}

2.2 应用信息访问

通过 Context 获取应用版本、设备信息等配置，常用于适配不同设备、版本兼容场景。

import { UIAbility, AbilityConstant, Want } from '@kit.AbilityKit';

export class AppInfoAbility extends UIAbility {

    private context: UIAbilityContext | undefined = undefined;

    onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
        this.context = this.context;

        // 演示应用信息访问
        this.demoAppInfoAccess();
    }

    private demoAppInfoAccess(): void {
        if (!this.context) {
            return;
        }

        // 1. 获取应用信息
        const applicationInfo = this.context.applicationInfo;
        console.info('Application info:', {
            name: applicationInfo.name,
            bundleName: applicationInfo.bundleName,
            versionName: applicationInfo.versionName,
            versionCode: applicationInfo.versionCode,
            minAPIVersion: applicationInfo.minAPIVersion,
            targetAPIVersion: applicationInfo.targetAPIVersion,
            icon: applicationInfo.icon,
            label: applicationInfo.label,
            description: applicationInfo.description
        });

        // 2. 获取模块信息
        const moduleInfo = this.context.currentHapModuleInfo;
        if (moduleInfo) {
            console.info('Module info:', {
                moduleName: moduleInfo.moduleName,
                moduleSourceDir: moduleInfo.moduleSourceDir,
                hapPath: moduleInfo.hapPath
            });
        }

        // 3. 获取配置信息
        const config = this.context.config;
        console.info('Configuration:', {
            language: config.language,
            region: config.region,
            direction: config.direction,
            screenDensity: config.screenDensity
        });

        // 4. 获取设备信息
        const deviceInfo = this.context.deviceInfo;
        console.info('Device info:', {
            deviceType: deviceInfo.deviceType,
            manufacturer: deviceInfo.manufacturer,
            model: deviceInfo.model,
            apiVersion: deviceInfo.apiVersion
        });
    }
}

2.3 权限管理能力

鸿蒙权限需通过 Context 申请，且必须遵循 “动态申请 + 权限声明” 双流程（缺一不可）。以下代码修复了原代码中requestPermissionsFromUser的回调参数错误，并增加权限申请失败的降级处理。

import { UIAbility, AbilityConstant, Want } from '@kit.AbilityKit';
import { abilityAccessCtrl, Permissions } from '@kit.AbilityKit';

export class PermissionAbility extends UIAbility {

    private context: UIAbilityContext | undefined = undefined;

    onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
        this.context = this.context;

        // 演示权限管理
        this.demoPermissionManagement();
    }

    private async demoPermissionManagement(): Promise<void> {
        if (!this.context) {
            return;
        }

        // 1. 检查权限
        const cameraPermission = 'ohos.permission.CAMERA';
        const locationPermission = 'ohos.permission.LOCATION';

        const hasCamera = await this.checkPermission(cameraPermission);
        const hasLocation = await this.checkPermission(locationPermission);

        console.info(`Camera permission: ${hasCamera}, Location permission: ${hasLocation}`);

        // 2. 申请权限
        if (!hasCamera) {
            await this.requestPermission([cameraPermission]);
        }

        // 3. 验证权限使用场景
        this.validatePermissionUsage();
    }

    private async checkPermission(permission: string): Promise<boolean> {
        try {
            const atManager = abilityAccessCtrl.createAtManager();
            const result = await atManager.checkAccessToken(
                abilityAccessCtrl.getSelfTokenId(),
                permission
            );
            return result === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED;
        } catch (error) {
            console.error('Failed to check permission:', error);
            return false;
        }
    }

    private async requestPermission(permissions: Array<string>): Promise<void> {
        try {
            const atManager = abilityAccessCtrl.createAtManager();
            await atManager.requestPermissionsFromUser(
                this.context!,
                permissions,
                (result) => {
                    console.info('Permission request result:', result);

                    // 处理权限申请结果
                    this.handlePermissionResult(result);
                }
            );
        } catch (error) {
            console.error('Failed to request permissions:', error);
        }
    }

    private handlePermissionResult(result: abilityAccessCtrl.PermissionRequestResult): void {
        const granted = result.permissions.filter(p =>
            result.authResults[p] === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED
        );

        const denied = result.permissions.filter(p =>
            result.authResults[p] === abilityAccessCtrl.GrantStatus.PERMISSION_DENIED
        );

        console.info(`Permissions granted: ${granted.join(', ')}`);
        console.info(`Permissions denied: ${denied.join(', ')}`);

        // 根据权限结果调整应用行为
        this.adjustAppBehavior(granted, denied);
    }

    private validatePermissionUsage(): void {
        // 验证权限使用是否符合最小权限原则
        const usedPermissions = this.getUsedPermissions();
        const declaredPermissions = this.getDeclaredPermissions();

        const unnecessaryPermissions = usedPermissions.filter(
            perm => !declaredPermissions.includes(perm)
        );

        if (unnecessaryPermissions.length > 0) {
            console.warn('Unnecessary permissions detected:', unnecessaryPermissions);
        }
    }

    private getUsedPermissions(): string[] {
        // 返回实际使用的权限列表
        return ['ohos.permission.INTERNET', 'ohos.permission.CAMERA'];
    }

    private getDeclaredPermissions(): string[] {
        // 返回声明的权限列表
        return ['ohos.permission.INTERNET'];
    }

    private adjustAppBehavior(granted: string[], denied: string[]): void {
        // 根据权限授予情况调整应用功能
        if (granted.includes('ohos.permission.CAMERA')) {
            this.enableCameraFeatures();
        } else {
            this.disableCameraFeatures();
        }

        if (denied.includes('ohos.permission.LOCATION')) {
            this.fallbackToManualLocation();
        }
    }
}

三、资源管理最佳实践

资源管理的核心是 “按需分配、及时释放”，避免内存泄漏、文件冗余等问题。本节提供内存、文件两大核心资源的优化方案。

3.1 内存资源管理

鸿蒙系统会根据内存压力触发不同级别的清理通知，开发者需在对应级别执行不同强度的清理操作。

内存监控与优化

import { UIAbility, AbilityConstant, Want } from '@kit.AbilityKit';

export class MemoryOptimizedAbility extends UIAbility {

    private context: UIAbilityContext | undefined = undefined;
    private memoryMonitor: MemoryMonitor | null = null;

    onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
        this.context = this.context;

        // 初始化内存监控
        this.initializeMemoryMonitoring();
    }

    private initializeMemoryMonitoring(): void {
        this.memoryMonitor = new MemoryMonitor(this.context!);

        // 监听内存级别变化
        this.memoryMonitor.onMemoryLevelChange((level) => {
            this.handleMemoryLevelChange(level);
        });

        // 开始内存监控
        this.memoryMonitor.startMonitoring();
    }

    private handleMemoryLevelChange(level: AbilityConstant.MemoryLevel): void {
        console.info(`Memory level changed to: ${level}`);

        switch (level) {
            case AbilityConstant.MemoryLevel.LOW:
                this.performAggressiveCleanup();
                break;
            case AbilityConstant.MemoryLevel.MODERATE:
                this.performModerateCleanup();
                break;
            case AbilityConstant.MemoryLevel.NORMAL:
                this.performNormalCleanup();
                break;
        }
    }

    private performAggressiveCleanup(): void {
        console.info('Performing aggressive memory cleanup');

        // 清空所有缓存
        this.clearAllCaches();

        // 释放大对象
        this.releaseLargeObjects();

        // 卸载非必要模块
        this.unloadNonEssentialModules();

        // 通知UI释放资源
        this.notifyUIReleaseResources();
    }

    private performModerateCleanup(): void {
        console.info('Performing moderate memory cleanup');

        // 清理过期缓存
        this.clearExpiredCaches();

        // 压缩内存使用
        this.compressMemoryUsage();
    }

    private performNormalCleanup(): void {
        console.info('Performing normal memory cleanup');

        // 常规资源回收
        this.performGarbageCollection();
    }

    onDestroy(): void {
        // 停止内存监控
        this.memoryMonitor?.stopMonitoring();

        // 释放所有资源
        this.releaseAllResources();
    }
}

// 内存监控器
class MemoryMonitor {
    private context: UIAbilityContext;
    private listeners: Array<(level: AbilityConstant.MemoryLevel) => void> = [];

    constructor(context: UIAbilityContext) {
        this.context = context;
    }

    onMemoryLevelChange(listener: (level: AbilityConstant.MemoryLevel) => void): void {
        this.listeners.push(listener);
    }

    startMonitoring(): void {
        // 实现内存监控逻辑
        console.info('Memory monitoring started');
    }

    stopMonitoring(): void {
        // 停止内存监控
        console.info('Memory monitoring stopped');
    }
}

3.2 文件资源管理

文件管理需关注 “原子操作（避免文件损坏）、权限控制（避免数据泄露）、缓存清理（避免空间不足）” 三大核心。

安全文件操作

import { UIAbility, AbilityConstant, Want } from '@kit.AbilityKit';
import { fileIo } from '@kit.CoreFileKit';

export class FileManagerAbility extends UIAbility {

    private context: UIAbilityContext | undefined = undefined;

    onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
        this.context = this.context;

        // 演示文件资源管理
        this.demoFileManagement();
    }

    private async demoFileManagement(): Promise<void> {
        if (!this.context) {
            return;
        }

        // 1. 创建应用私有目录
        await this.createAppDirectories();

        // 2. 安全文件读写
        await this.safeFileOperations();

        // 3. 文件缓存管理
        await this.manageFileCache();

        // 4. 文件权限验证
        await this.verifyFilePermissions();
    }

    private async createAppDirectories(): Promise<void> {
        const appDirs = [
            'documents',
            'images',
            'cache',
            'temp'
        ];

        for (const dir of appDirs) {
            const dirPath = `${this.context.filesDir}/${dir}`;
            try {
                await fileIo.mkdir(dirPath);
                console.info(`Created directory: ${dirPath}`);
            } catch (error) {
                console.error(`Failed to create directory ${dirPath}:`, error);
            }
        }
    }

    private async safeFileOperations(): Promise<void> {
        const filePath = `${this.context.filesDir}/config.json`;

        try {
            // 安全写入文件
            const configData = {
                version: '1.0.0',
                settings: {
                    theme: 'dark',
                    language: 'zh-CN'
                }
            };

            await this.safeWriteFile(filePath, JSON.stringify(configData, null, 2));
            console.info('Config file written safely');

            // 安全读取文件
            const content = await this.safeReadFile(filePath);
            console.info('Config file content:', content);

        } catch (error) {
            console.error('File operation failed:', error);
        }
    }

    private async safeWriteFile(path: string, content: string): Promise<void> {
        // 使用临时文件确保写入原子性
        const tempPath = `${path}.tmp`;

        try {
            // 写入临时文件
            await fileIo.writeText(tempPath, content);

            // 重命名为目标文件
            await fileIo.rename(tempPath, path);

        } catch (error) {
            // 清理临时文件
            try {
                await fileIo.unlink(tempPath);
            } catch (cleanupError) {
                console.warn('Failed to cleanup temp file:', cleanupError);
            }
            throw error;
        }
    }

    private async safeReadFile(path: string): Promise<string> {
        try {
            const content = await fileIo.readText(path);
            return content;
        } catch (error) {
            console.error('Failed to read file:', error);
            throw error;
        }
    }

    private async manageFileCache(): Promise<void> {
        const cacheDir = this.context.cacheDir;

        try {
            // 清理过期缓存
            await this.cleanExpiredCache(cacheDir);

            // 限制缓存大小
            await this.limitCacheSize(cacheDir, 100 * 1024 * 1024); // 100MB限制

        } catch (error) {
            console.error('Cache management failed:', error);
        }
    }

    private async cleanExpiredCache(cacheDir: string): Promise<void> {
        // 实现缓存清理逻辑
        console.info('Cleaning expired cache files');
    }

    private async limitCacheSize(cacheDir: string, maxSize: number): Promise<void> {
        // 实现缓存大小限制逻辑
        console.info(`Limiting cache size to ${maxSize} bytes`);
    }

    private async verifyFilePermissions(): Promise<void> {
        // 验证文件权限设置
        const sensitiveFiles = [
            `${this.context.filesDir}/user_data.json`,
            `${this.context.filesDir}/credentials.dat`
        ];

        for (const file of sensitiveFiles) {
            try {
                const stats = await fileIo.stat(file);

                // 检查文件权限
                if (this.isInsecurePermissions(stats)) {
                    console.warn(`Insecure permissions detected for file: ${file}`);
                    await this.fixFilePermissions(file);
                }

            } catch (error) {
                // 文件不存在或其他错误
                console.debug(`File permission check skipped for ${file}:`, error);
            }
        }
    }

    private isInsecurePermissions(stats: fileIo.Stat): boolean {
        // 实现权限安全检查逻辑
        return false;
    }

    private async fixFilePermissions(file: string): Promise<void> {
        // 修复文件权限
        console.info(`Fixing permissions for file: ${file}`);
    }
}

四、Context生命周期管理

Context 的生命周期与所属组件强绑定，错误的获取时机或使用方式会导致 “Context 失效”（如调用已销毁的 Context 方法）。本节明确 Context 的有效范围与失效处理方案。

4.1 Context获取时机

不同组件的 Context 获取时机不同，下表总结核心组件的 Context 有效阶段：

组件类型 获取时机 有效阶段 失效阶段 注意事项
UIAbility onCreate方法中通过this.context获取 onCreate → onDestroy onDestroy后 1. onWindowStageCreate后 Context 完全就绪2. 后台时部分能力受限（如窗口操作）
ArkUI 页面 通过getContext(this)动态获取 页面创建 → 页面销毁 页面出栈 / 销毁后 1. 避免在页面外存储 Context2. 组件重建时需重新获取
ExtensionAbility onCreate参数中获取context onCreate → onDestroy onDestroy后 1. 无窗口相关能力2. 后台运行时 Context 可能被回收
FormExtension onCreate参数中获取context 卡片创建 → 卡片删除 卡片删除 / 应用退出后 1. 仅支持卡片相关能力2. 频繁更新需注意性能 
import { UIAbility, AbilityConstant, Want } from '@kit.AbilityKit';
import { window } from '@kit.ArkUI';

export class ContextLifecycleAbility extends UIAbility {

    private context: UIAbilityContext | undefined = undefined;

    // UIAbility实例创建时获取Context
    onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
        console.info('UIAbility onCreate - Context available');
        this.context = this.context;

        // 此时Context已可用，可进行初始化操作
        this.performInitialization();
    }

    // WindowStage创建时Context完全就绪
    onWindowStageCreate(windowStage: window.WindowStage): void {
        console.info('UIAbility onWindowStageCreate - Context fully ready');

        // 此时可以安全使用所有Context能力
        this.setupUIComponents();
    }

    // 应用进入前台时Context保持活跃
    onForeground(): void {
        console.info('UIAbility onForeground - Context active');

        // 恢复Context相关操作
        this.resumeContextOperations();
    }

    // 应用进入后台时Context可能受限
    onBackground(): void {
        console.info('UIAbility onBackground - Context may be limited');

        // 暂停Context敏感操作
        this.suspendContextOperations();
    }

    // UIAbility销毁时Context即将失效
    onDestroy(): void {
        console.info('UIAbility onDestroy - Context will be invalidated');

        // 清理Context相关资源
        this.cleanupContextResources();
    }

    private performInitialization(): void {
        // 使用Context进行初始化
        console.info('Performing initialization with Context');
    }

    private setupUIComponents(): void {
        // 使用Context设置UI组件
        console.info('Setting up UI components with Context');
    }

    private resumeContextOperations(): void {
        // 恢复Context操作
        console.info('Resuming Context operations');
    }

    private suspendContextOperations(): void {
        // 暂停Context操作
        console.info('Suspending Context operations');
    }

    private cleanupContextResources(): void {
        // 清理Context资源
        console.info('Cleaning up Context resources');
    }
}

4.2 Context失效处理

Context 失效的常见场景：“调用已销毁的 UIAbilityContext”“页面重建后使用旧 Context”，需通过 “有效性检查 + 重试机制” 处理。

import { UIAbility, AbilityConstant, Want } from '@kit.AbilityKit';

export class RobustContextAbility extends UIAbility {

    private context: UIAbilityContext | undefined = undefined;
    private isContextValid: boolean = false;

    onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
        this.context = this.context;
        this.isContextValid = true;

        // 设置Context有效性检查
        this.setupContextValidityCheck();
    }

    private setupContextValidityCheck(): void {
        // 定期检查Context有效性
        setInterval(() => {
            this.checkContextValidity();
        }, 5000); // 每5秒检查一次
    }

    private checkContextValidity(): void {
        if (!this.isContextValid) {
            console.warn('Context is no longer valid');
            this.handleInvalidContext();
            return;
        }

        // 验证Context基本功能
        try {
            // 尝试使用Context的简单功能
            const testValue = this.context?.applicationInfo?.bundleName;
            if (!testValue) {
                throw new Error('Context test failed');
            }
        } catch (error) {
            console.error('Context validity check failed:', error);
            this.isContextValid = false;
            this.handleInvalidContext();
        }
    }

    private handleInvalidContext(): void {
        // 处理无效Context情况
        console.info('Handling invalid Context scenario');

        // 停止使用Context的操作
        this.stopContextDependentOperations();

        // 尝试恢复或重新初始化
        this.attemptContextRecovery();
    }

    private stopContextDependentOperations(): void {
        // 停止依赖Context的操作
        console.info('Stopping Context-dependent operations');
    }

    private attemptContextRecovery(): void {
        // 尝试恢复Context
        console.info('Attempting Context recovery');

        // 在实际应用中，可能需要重新创建UIAbility
        // 这里仅作演示
        setTimeout(() => {
            this.isContextValid = true;
            console.info('Context recovery attempted');
        }, 1000);
    }

    // 安全使用Context的包装方法
    private safeContextOperation<T>(operation: (context: UIAbilityContext) => T): T | null {
        if (!this.isContextValid || !this.context) {
            console.warn('Cannot perform operation: Context is invalid');
            return null;
        }

        try {
            return operation(this.context);
        } catch (error) {
            console.error('Context operation failed:', error);
            this.isContextValid = false;
            return null;
        }
    }

    // 示例：安全获取应用信息
    getSafeApplicationInfo(): any {
        return this.safeContextOperation(context => context.applicationInfo);
    }

    // 示例：安全访问文件目录
    getSafeFilesDir(): string | null {
        return this.safeContextOperation(context => context.filesDir);
    }
}

五、实战案例：多媒体资源管理应用

结合 Context 的核心能力，实现一个 “跨设备多媒体管理器”（支持资源扫描、缩略图生成、安全存储），展示 Context 在真实项目中的综合应用。

5.1 多媒体资源管理器

import { UIAbility, AbilityConstant, Want } from '@kit.AbilityKit';
import { fileIo } from '@kit.CoreFileKit';
import { mediaLibrary } from '@kit.MediaLibraryKit';

export class MediaManagerAbility extends UIAbility {

    private context: UIAbilityContext | undefined = undefined;
    private mediaManager: MediaResourceManager | null = null;

    onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
        this.context = this.context;

        // 初始化多媒体资源管理器
        this.initializeMediaManager();
    }

    private initializeMediaManager(): void {
        this.mediaManager = new MediaResourceManager(this.context!);

        // 设置资源监听器
        this.mediaManager.onResourceChange((changeType, resource) => {
            this.handleResourceChange(changeType, resource);
        });

        // 开始资源扫描
        this.mediaManager.startResourceScan();
    }

    private handleResourceChange(changeType: string, resource: MediaResource): void {
        console.info(`Resource change: ${changeType} - ${resource.name}`);

        switch (changeType) {
            case 'added':
                this.handleResourceAdded(resource);
                break;
            case 'modified':
                this.handleResourceModified(resource);
                break;
            case 'deleted':
                this.handleResourceDeleted(resource);
                break;
        }
    }

    private handleResourceAdded(resource: MediaResource): void {
        // 处理新增资源
        console.info(`New resource added: ${resource.name}`);
    }

    private handleResourceModified(resource: MediaResource): void {
        // 处理修改资源
        console.info(`Resource modified: ${resource.name}`);
    }

    private handleResourceDeleted(resource: MediaResource): void {
        // 处理删除资源
        console.info(`Resource deleted: ${resource.name}`);
    }

    onDestroy(): void {
        // 清理多媒体资源管理器
        this.mediaManager?.cleanup();
    }
}

// 多媒体资源管理器
class MediaResourceManager {
    private context: UIAbilityContext;
    private listeners: Array<(changeType: string, resource: MediaResource) => void> = [];
    private mediaScanner: MediaScanner | null = null;

    constructor(context: UIAbilityContext) {
        this.context = context;
        this.mediaScanner = new MediaScanner(context);
    }

    onResourceChange(listener: (changeType: string, resource: MediaResource) => void): void {
        this.listeners.push(listener);
    }

    startResourceScan(): void {
        console.info('Starting media resource scan');

        // 开始扫描媒体资源
        this.mediaScanner?.startScanning((resources) => {
            this.processScannedResources(resources);
        });
    }

    private processScannedResources(resources: MediaResource[]): void {
        console.info(`Processed ${resources.length} media resources`);

        // 通知监听器
        resources.forEach(resource => {
            this.listeners.forEach(listener => {
                listener('added', resource);
            });
        });
    }

    async getMediaThumbnail(resourceId: string): Promise<Uint8Array | null> {
        try {
            // 使用Context获取媒体缩略图
            const mediaLib = mediaLibrary.getMediaLibrary(this.context);
            const fileAsset = await mediaLib.getFileAsset(resourceId);

            if (fileAsset) {
                return await fileAsset.getThumbnail();
            }
        } catch (error) {
            console.error('Failed to get media thumbnail:', error);
        }

        return null;
    }

    async saveMediaResource(data: Uint8Array, filename: string, mimeType: string): Promise<string | null> {
        try {
            const filePath = `${this.context.filesDir}/media/${filename}`;

            // 确保目录存在
            await fileIo.mkdir(`${this.context.filesDir}/media`);

            // 保存文件
            await fileIo.write(filePath, data);

            // 添加到媒体库
            const mediaLib = mediaLibrary.getMediaLibrary(this.context);
            await mediaLib.storeMediaAsset(filePath, mimeType);

            return filePath;
        } catch (error) {
            console.error('Failed to save media resource:', error);
            return null;
        }
    }

    cleanup(): void {
        console.info('Cleaning up media resource manager');

        // 停止扫描
        this.mediaScanner?.stopScanning();

        // 清理监听器
        this.listeners = [];
    }
}

// 媒体扫描器
class MediaScanner {
    private context: UIAbilityContext;
    private isScanning: boolean = false;

    constructor(context: UIAbilityContext) {
        this.context = context;
    }

    startScanning(callback: (resources: MediaResource[]) => void): void {
        this.isScanning = true;

        // 模拟扫描过程
        setTimeout(() => {
            if (this.isScanning) {
                const mockResources: MediaResource[] = [
                    { id: '1', name: 'photo1.jpg', type: 'image', path: '/storage/photo1.jpg' },
                    { id: '2', name: 'video1.mp4', type: 'video', path: '/storage/video1.mp4' },
                    { id: '3', name: 'audio1.mp3', type: 'audio', path: '/storage/audio1.mp3' }
                ];

                callback(mockResources);
            }
        }, 1000);
    }

    stopScanning(): void {
        this.isScanning = false;
    }
}

interface MediaResource {
    id: string;
    name: string;
    type: 'image' | 'video' | 'audio';
    path: string;
}

六、总结与展望

6.1 Context 机制核心价值

  1. 统一交互入口：封装系统资源、权限、生命周期等能力，避免开发者直接调用底层 API；

  2. 安全隔离：通过层级化设计确保应用间资源隔离（如私有目录仅当前应用可访问）；

  3. 分布式适配：天然支持跨设备场景（如通过deviceManager获取远程 Context）；

  4. 生命周期绑定：与组件生命周期强绑定，自动管理资源释放（减少内存泄漏）。

6.2 资源管理最佳实践总结

资源类型 核心原则 实战建议 常见错误
内存 按需分配、及时释放 1. 监听内存级别变化，分级清理2. 避免存储大对象（如 PixelMap）3. 页面销毁时释放缓存 1. 长期存储 Context 导致内存泄漏2. 不释放图片资源导致 OOM
文件 安全存储、定期清理 1. 敏感文件加密存储（如 AES）2. 原子操作避免文件损坏3. 限制缓存大小 1. 存储到公共目录导致权限问题2. 不清理缓存导致空间不足
权限 最小权限、动态申请 1. 按功能分组申请权限2. 处理永久拒绝场景（引导至设置）3. 权限校验后再使用功能 1. 未声明权限直接调用 API2. 忽略权限申请失败的降级处理

6.3 开发建议

  1. 选对 Context 是关键：根据业务场景选择对应层级的 Context（如窗口操作用UIAbilityContext，全局配置用ApplicationContext）；

  2. 避免存储 Context：尤其是在页面、组件中，应动态获取（如getContext(this)），避免 Context 失效；

  3. 资源释放不遗漏：在onDestroy、onBackground等生命周期中释放资源（如图片PixelMap、文件句柄）；

  4. 权限处理要完整：覆盖 “未授予→申请→永久拒绝” 全流程，避免应用崩溃或功能异常。

Context机制作为鸿蒙应用开发的基础设施，其重要性不言而喻。掌握Context的使用技巧和资源管理的最佳实践，是构建高质量鸿蒙应用的关键。建议开发者在实际项目中不断实践和优化，为鸿蒙生态的繁荣贡献力量。

版权声明：本文为原创技术文章，转载请注明出处。

# harmonyos
Logo
HarmonyOS开发者社区

讨论HarmonyOS开发技术，专注于API与组件、DevEco Studio、测试、元服务和应用上架分发等。

更多推荐

cover

鸿蒙系统与 Electron 结合开发：从环境搭建到核心功能落地（附完整代码）

avatar HarmonyOS开发者社区
cover

为鸿蒙生态注入可观测动力：观测云 HarmonyOS SDK 重磅上线

avatar HarmonyOS开发者社区

Electron for 鸿蒙PC - DOM初始化时机与多重保险机制

本文记录了将MarkText适配到鸿蒙PC平台时遇到的DOM初始化问题及其解决方案。在鸿蒙PC上，DOM初始化时机不稳定，导致自定义菜单栏有时无法正常显示。通过分析发现，单一的事件监听方式（如DOMContentLoaded）不可靠，而固定延迟也不够智能。

avatar HarmonyOS开发者社区