Overview of Context Types

In the HarmonyOS Stage model, Context provides access to application resources, paths, and configurations. Several specialized context classes inherit from the base Context class, including ApplicationContext, AbilityStageContext, UIAbilityContext, and ExtensionContext. These subclasses provide specific capabilities while maintaining core functionalities such as accessing resourceManager, applicationInfo, and directory paths.

Acquiring Context Instances

UIAbilityContext

UIAbilityContext allows manipulation of the Ability lifecycle, retrieval of configuration details, and permission requests. It is accessible directly within the UIAbility instance.

import UIAbility from '@ohos.app.ability.UIAbility';
import Want from '@ohos.app.ability.Want';

export default class MainAbility extends UIAbility {
    onCreate(want: Want, launchParam: object) {
        const abilityCtx = this.context;
        console.info('Ability Context acquired: ' + abilityCtx.abilityInfo.name);
    }
}

AbilityStageContext

Unlike the base context, AbilityStageContext provides access to HapModuleInfo and system configuration details. It is retrieved from the AbilityStage instance.

import AbilityStage from '@ohos.app.ability.AbilityStage';

export default class AppStage extends AbilityStage {
    onCreate() {
        const stageCtx = this.context;
        console.info('Module Info: ' + stageCtx.currentHapModuleInfo.name);
    }
}

ApplicationContext

ApplicationContext extends the base context to support application-wide events, such as monitoring memory changes and ability lifecycles. It can be obtained from any UIAbility, ExtensionAbility, or AbilityStage.

import UIAbility from '@ohos.app.ability.UIAbility';

export default class MainAbility extends UIAbility {
    onCreate(want, launchParam) {
        const appCtx = this.context.getApplicationContext();
        console.info('Application Context retrieved successfully.');
    }
}

Typical Usage Scenarios

Accessing Application Directories

Context objects provide properties to access various storage directories specific to the application.

import UIAbility from '@ohos.app.ability.UIAbility';

export default class MainAbility extends UIAbility {
    onCreate(want, launchParam) {
        const paths = {
            cache: this.context.cacheDir,
            temp: this.context.tempDir,
            files: this.context.filesDir,
            database: this.context.databaseDir,
            bundleCode: this.context.bundleCodeDir,
            distributed: this.context.distributedFilesDir,
            preferences: this.context.preferencesDir
        };
        console.info('Available paths: ' + JSON.stringify(paths));
    }
}

Managing Encryption Areas

HarmonyOS supports different encryption levels for data security. AreaMode.EL1 refers to device-level encryption (accessible after boot), while AreaMode.EL2 refers to user-level encryption (accessible after the first unlock). You can switch between these areas based on data sensitivity.

import UIAbility from '@ohos.app.ability.UIAbility';
import common from '@ohos.app.ability.common';

export default class MainAbility extends UIAbility {
    onCreate(want, launchParam) {
        // Switch to EL1 for non-sensitive data
        if (this.context.area === common.AreaMode.EL2) {
            this.context.area = common.AreaMode.EL1;
        }
        // Store non-sensitive data...

        // Switch to EL2 for sensitive data
        if (this.context.area === common.AreaMode.EL1) {
            this.context.area = common.AreaMode.EL2;
        }
        // Store sensitive credentials...
    }
}

Creating Module Contexts

To access resources or paths from another HAP module within the same application, use createModuleContext.

import UIAbility from '@ohos.app.ability.UIAbility';

export default class MainAbility extends UIAbility {
    onCreate(want, launchParam) {
        const moduleName = 'entry';
        const moduleCtx = this.context.createModuleContext(moduleName);
        console.info('Module Context created for: ' + moduleName);
    }
}

Subscribing to Ability Lifecycle Changes

The ApplicationContext allows registering callbacks to monitor lifecycle changes of abilities within the process.

import UIAbility from '@ohos.app.ability.UIAbility';
import AbilityLifecycleCallback from '@ohos.app.ability.AbilityLifecycleCallback';
import window from '@ohos.window';

export default class MainAbility extends UIAbility {
    lifecycleId: number = -1;

    onCreate(want, launchParam) {
        const appContext = this.context.getApplicationContext();
        
        const lifecycleCallback: AbilityLifecycleCallback = {
            onAbilityCreate: (ability) => {
                console.info(`[Lifecycle] Ability Created: ${ability}`);
            },
            onWindowStageCreate: (ability, stage) => {
                console.info('[Lifecycle] WindowStage Created');
            },
            onWindowStageDestroy: (ability, stage) => {
                console.info('[Lifecycle] WindowStage Destroyed');
            },
            onAbilityDestroy: (ability) => {
                console.info(`[Lifecycle] Ability Destroyed: ${ability}`);
            },
            onAbilityForeground: (ability) => {
                console.info(`[Lifecycle] Ability Foreground: ${ability}`);
            },
            onAbilityBackground: (ability) => {
                console.info(`[Lifecycle] Ability Background: ${ability}`);
            }
        };

        this.lifecycleId = appContext.registerAbilityLifecycleCallback(lifecycleCallback);
    }

    onDestroy() {
        const appContext = this.context.getApplicationContext();
        appContext.unregisterAbilityLifecycleCallback(this.lifecycleId);
    }
}