In the Stage model, different contexts offer varying scopes of data and capabillities. AbilityStageContext extends the base Context by exposing HapModuleInfo and Configuration details specific to the module stage. Meanwhile, ApplicationContext serves as the global hub, allowing deveolpers to monitor ability lifecycles, memory shifts, and system environment updates across the entire application.

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

export default class AppAbilityStage extends AbilityStage {
    onCreate() {
        const stageContext = this.context;
        // Access HapModuleInfo or Configuration here
    }
}

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

export default class MainAbility extends UIAbility {
    onCreate(want, launchParam) {
        const globalContext = this.context.getApplicationContext();
        // Subscribe to global events using globalContext
    }
}

Retrieving Application File Paths

Accessing application-specific file directories is a primary function of the Context object. You can resolve various storage paths such as caching, temporary files, databases, and distributed file directories directly from the ability context.

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

export default class MainAbility extends UIAbility {
    onCreate(want, launchParam) {
        const appCachePath = this.context.cacheDir;
        const appTempPath = this.context.tempDir;
        const appFilesPath = this.context.filesDir;
        const appDbPath = this.context.databaseDir;
        const appBundlePath = this.context.bundleCodeDir;
        const appDistributedPath = this.context.distributedFilesDir;
        const appPrefsPath = this.context.preferencesDir;
    }
}

Managing Encryption Areas

Context allows managing data security by switching between encryption levels. AreaMode.EL1 represents device-level encryption, making data accessible immediately after boot. AreaMode.EL2 represents user-level encryption, requiring the first unlock after boot to access the data. You can read and assign the area property to ensure data is stored in the appropriate secure partition.

import { UIAbility } from '@ohos.app.ability.UIAbility';
import { AreaMode } from '@ohos.app.ability.AbilityConstant';

export default class MainAbility extends UIAbility {
    onCreate(want, launchParam) {
        // Switch to device-level encryption for general data
        if (this.context.area === AreaMode.EL2) {
            this.context.area = AreaMode.EL1;
        }

        // Switch to user-level encryption for sensitive data
        if (this.context.area === AreaMode.EL1) {
            this.context.area = AreaMode.EL2;
        }
    }
}

Creating Module Contexts

To interact with resources or configurations from a different module within the same app, use createModuleContext. This method generates a localized context bound to the specified module name, enabling cross-module resource access and communication.

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

export default class MainAbility extends UIAbility {
    onCreate(want, launchParam) {
        const targetModuleName = 'feature_module';
        const moduleContext = this.context.createModuleContext(targetModuleName);
        // Utilize moduleContext to access module-specific paths or configurations
    }
}

Subscribing to Ability Lifecycle Changes

The ApplicationContext enables monitoring of ability lifecycle transitions throughout the entire process. By registering an abilityLifecycle callback, you can observe state changes like creation, foregrounding, backgrounding, and destruction. Unregister these callbacks during the ability's destruction phase to prevent memory leaks.

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

const LOG_TAG = '[LifecycleMonitor]';

export default class MainAbility extends UIAbility {
    private lifecycleMonitorId: number;

    onCreate(want, launchParam) {
        const lifecycleTracker: AbilityLifecycleCallback = {
            onAbilityCreate(ability) {
                console.info(`${LOG_TAG} Ability Created: ${ability}`);
            },
            onWindowStageCreate(ability, winStage) {
                console.info(`${LOG_TAG} WindowStage Created for: ${ability}`);
            },
            onWindowStageActive(ability, winStage) {
                console.info(`${LOG_TAG} WindowStage Active for: ${ability}`);
            },
            onWindowStageInactive(ability, winStage) {
                console.info(`${LOG_TAG} WindowStage Inactive for: ${ability}`);
            },
            onWindowStageDestroy(ability, winStage) {
                console.info(`${LOG_TAG} WindowStage Destroyed for: ${ability}`);
            },
            onAbilityDestroy(ability) {
                console.info(`${LOG_TAG} Ability Destroyed: ${ability}`);
            },
            onAbilityForeground(ability) {
                console.info(`${LOG_TAG} Ability Foregrounded: ${ability}`);
            },
            onAbilityBackground(ability) {
                console.info(`${LOG_TAG} Ability Backgrounded: ${ability}`);
            },
            onAbilityContinue(ability) {
                console.info(`${LOG_TAG} Ability Continued: ${ability}`);
            }
        };

        const globalContext = this.context.getApplicationContext();
        this.lifecycleMonitorId = globalContext.on('abilityLifecycle', lifecycleTracker);
    }

    onDestroy() {
        const globalContext = this.context.getApplicationContext();
        globalContext.off('abilityLifecycle', this.lifecycleMonitorId);
    }
}