HarmonyOS应用开发：深入解析Stage模型与UIAbility

HarmonyOS应用开发：深入解析Stage模型与UIAbility

引言

随着HarmonyOS 4.0的发布和API 12的推出，华为的分布式操作系统进入了全新的发展阶段。对于开发者而言，深入理解HarmonyOS的应用模型是开发高质量应用的关键。本文将重点探讨基于Stage模型的应用开发，特别是UIAbility的核心概念、生命周期管理以及最佳实践。

Stage模型：新一代应用架构

模型概述

Stage模型是HarmonyOS 3.0（API 9）引入的现代化应用架构，相比传统的FA模型，它提供了更好的性能、更清晰的职责分离和更强的分布式能力。

// 示例：基本的UIAbility声明
// module.json5
{
  "module": {
    "name": "entry",
    "abilities": [
      {
        "name": "MainAbility",
        "srcEntry": "./ets/mainability/MainAbility.ts",
        "description": "$string:MainAbility_desc",
        "icon": "$media:icon",
        "label": "$string:MainAbility_label",
        "startWindowIcon": "$media:icon",
        "startWindowBackground": "$color:white",
        "exported": true,
        "skills": [
          {
            "actions": ["action.system.home"],
            "entities": ["entity.system.home"]
          }
        ]
      }
    ]
  }
}

Stage模型的核心优势

1. 进程隔离：每个UIAbility运行在独立的进程中，提高稳定性和安全性
2. 资源按需加载：减少内存占用，提升启动速度
3. 更好的分布式支持：为跨设备协同提供基础架构
4. 清晰的生命周期管理：简化状态管理复杂度

UIAbility深度解析

UIAbility生命周期

UIAbility的生命周期是Stage模型的核心概念，理解其状态转换对于开发稳定应用至关重要。

// UIAbility生命周期示例
import UIAbility from '@ohos.app.ability.UIAbility';
import window from '@ohos.window';

export default class MainAbility extends UIAbility {
  // 创建阶段
  onCreate(want, launchParam) {
    console.log('MainAbility onCreate');
    // 初始化资源
  }

  // 前台可见
  onWindowStageCreate(windowStage: window.WindowStage) {
    console.log('MainAbility onWindowStageCreate');
    
    // 设置UI页面加载
    windowStage.loadContent('pages/Index', (err, data) => {
      if (err.code) {
        console.error('Failed to load the content. Cause:' + JSON.stringify(err));
        return;
      }
      console.info('Succeeded in loading the content. Data: ' + JSON.stringify(data));
    });
  }

  // 前台不可见但仍在后台运行
  onForeground() {
    console.log('MainAbility onForeground');
    // 恢复业务操作
  }

  // 进入后台
  onBackground() {
    console.log('MainAbility onBackground');
    // 释放非必要资源
  }

  // 窗口销毁
  onWindowStageDestroy() {
    console.log('MainAbility onWindowStageDestroy');
    // 释放窗口相关资源
  }

  // 整体销毁
  onDestroy() {
    console.log('MainAbility onDestroy');
    // 清理所有资源
  }
}

UIAbility的启动模式

HarmonyOS提供了多种启动模式，满足不同场景需求：

// module.json5中配置启动模式
{
  "abilities": [
    {
      "name": "MainAbility",
      "launchType": "standard", // 标准模式
      // "launchType": "singleton", // 单例模式
      // "launchType": "specified", // 指定模式
    }
  ]
}

页面路由与导航最佳实践

页面跳转实现

在Stage模型中，页面跳转通过UIAbilityContext实现：

// 在当前页面中跳转到另一个UIAbility
import common from '@ohos.app.ability.common';
import { BusinessError } from '@ohos.base';

let context: common.UIAbilityContext = getContext(this) as common.UIAbilityContext;
let want = {
  deviceId: "", // 空表示本设备
  bundleName: "com.example.myapplication",
  abilityName: "SecondAbility",
  parameters: { // 传递参数
    message: "Hello from MainAbility"
  }
};

try {
  context.startAbility(want).then(() => {
    console.log('Start ability succeeded');
  }).catch((error: BusinessError) => {
    console.error(`Start ability failed with error code: ${error.code}, message: ${error.message}`);
  });
} catch (error) {
  console.error(`Start ability failed with error: ${error.code}, ${error.message}`);
}

参数传递与返回处理

// 启动Ability并期待返回结果
import promptAction from '@ohos.promptAction';

let want = {
  bundleName: "com.example.myapplication",
  abilityName: "SecondAbility",
  parameters: {
    requestCode: 1
  }
};

try {
  context.startAbilityForResult(want).then((data) => {
    // 处理返回结果
    if (data.resultCode === 0) {
      let result = data.want?.parameters?.result;
      promptAction.showToast({ message: `Result: ${result}` });
    }
  }).catch((error: BusinessError) => {
    console.error(`Start ability for result failed with error code: ${error.code}`);
  });
} catch (error) {
  console.error(`Start ability for result failed with error: ${error.code}`);
}

// 在目标Ability中返回结果
import { AbilityConstant } from '@ohos.app.ability.UIAbility';

const RESULT_CODE = 0;

onBackPress() {
  let want = {
    parameters: {
      result: "Data from SecondAbility"
    }
  };
  this.context.terminateSelfWithResult(want, (err) => {
    if (err.code) {
      console.error(`Failed to terminate self with result. Code: ${err.code}, message: ${err.message}`);
      return;
    }
    console.info('Succeeded in terminating self with result.');
  });
  return true; // 表示已处理返回事件
}

状态管理与数据持久化

AppStorage应用级状态管理

// 使用AppStorage进行应用级状态管理
import AppStorage from '@ohos.app.ability.AppStorage';

// 初始化状态
AppStorage.setOrCreate('userName', 'HarmonyOS User');
AppStorage.setOrCreate('isLoggedIn', false);

// 在UI组件中使用
@Entry
@Component
struct Index {
  @StorageLink('userName') userName: string = '';
  @StorageLink('isLoggedIn') isLoggedIn: boolean = false;

  build() {
    Column() {
      Text(`Hello ${this.userName}`)
        .fontSize(20)
        .margin(10)
      
      Button(this.isLoggedIn ? 'Logout' : 'Login')
        .onClick(() => {
          this.isLoggedIn = !this.isLoggedIn;
          // 状态变更会自动同步到AppStorage
        })
    }
  }
}

持久化数据存储

// 使用Preferences进行持久化存储
import dataPreferences from '@ohos.data.preferences';

class PreferencesManager {
  private preferences: dataPreferences.Preferences | null = null;

  // 初始化Preferences
  async initPreferences(context: common.Context) {
    try {
      this.preferences = await dataPreferences.getPreferences(context, 'myAppPreferences');
      console.log('Preferences initialized successfully');
    } catch (err) {
      console.error(`Failed to initialize preferences. Code: ${err.code}, message: ${err.message}`);
    }
  }

  // 存储数据
  async putPreferenceValue(key: string, value: dataPreferences.ValueType) {
    if (!this.preferences) return;
    
    try {
      await this.preferences.put(key, value);
      await this.preferences.flush();
      console.log(`Succeeded in putting value: ${value} for key: ${key}`);
    } catch (err) {
      console.error(`Failed to put value. Code: ${err.code}, message: ${err.message}`);
    }
  }

  // 读取数据
  async getPreferenceValue(key: string, defaultValue: dataPreferences.ValueType) {
    if (!this.preferences) return defaultValue;
    
    try {
      const value = await this.preferences.get(key, defaultValue);
      console.log(`Succeeded in getting value: ${value} for key: ${key}`);
      return value;
    } catch (err) {
      console.error(`Failed to get value. Code: ${err.code}, message: ${err.message}`);
      return defaultValue;
    }
  }
}

// 在UIAbility中使用
export default class MainAbility extends UIAbility {
  private prefsManager: PreferencesManager = new PreferencesManager();

  async onCreate(want, launchParam) {
    await this.prefsManager.initPreferences(this.context);
    
    // 读取用户偏好设置
    const theme = await this.prefsManager.getPreferenceValue('theme', 'light');
    console.log(`Current theme: ${theme}`);
  }
}

性能优化与最佳实践

资源懒加载

// 使用动态导入实现资源懒加载
@Component
struct LazyComponent {
  @State childComponent: Object | null = null;
  @State isLoaded: boolean = false;

  aboutToAppear() {
    if (!this.isLoaded) {
      // 动态导入子组件
      import('./LazyChildComponent').then((module) => {
        this.childComponent = module.LazyChildComponent;
        this.isLoaded = true;
      }).catch((err) => {
        console.error(`Failed to load component: ${err.message}`);
      });
    }
  }

  build() {
    Column() {
      if (this.isLoaded && this.childComponent) {
        // 渲染懒加载的组件
        this.childComponent()
      } else {
        // 加载中的占位符
        LoadingIndicator()
          .height(50)
          .width(50)
      }
    }
  }
}

内存管理最佳实践

// 使用WeakReference避免内存泄漏
import { BusinessError } from '@ohos.base';

class DataManager {
  private weakListeners: WeakRef<EventListener>[] = [];

  // 添加弱引用监听器
  addWeakListener(listener: EventListener) {
    this.weakListeners.push(new WeakRef(listener));
  }

  // 通知所有存活的监听器
  notifyListeners(eventData: string) {
    for (let i = this.weakListeners.length - 1; i >= 0; i--) {
      const listener = this.weakListeners[i].deref();
      if (listener) {
        try {
          listener.onEvent(eventData);
        } catch (err) {
          const error = err as BusinessError;
          console.error(`Listener error: ${error.code}, ${error.message}`);
        }
      } else {
        // 清理已被GC回收的引用
        this.weakListeners.splice(i, 1);
      }
    }
  }
}

interface EventListener {
  onEvent(data: string): void;
}

分布式能力实战

跨设备UIAbility调用

// 发现并连接远程设备
import deviceManager from '@ohos.distributedDeviceManager';

class DistributedManager {
  private deviceManager: deviceManager.DeviceManager | null = null;

  // 初始化设备管理
  async initDeviceManager() {
    try {
      this.deviceManager = await deviceManager.createDeviceManager('com.example.myapp');
      this.deviceManager.on('deviceStateChange', (data) => {
        console.log(`Device state changed: ${JSON.stringify(data)}`);
      });
      console.log('Device manager initialized successfully');
    } catch (err) {
      console.error(`Failed to create device manager: ${err.code}, ${err.message}`);
    }
  }

  // 获取在线设备列表
  getAvailableDevices(): deviceManager.DeviceInfo[] {
    if (!this.deviceManager) return [];
    
    try {
      return this.deviceManager.getAvailableDeviceListSync();
    } catch (err) {
      console.error(`Failed to get device list: ${err.code}, ${err.message}`);
      return [];
    }
  }

  // 启动远程UIAbility
  async startRemoteAbility(deviceId: string) {
    let want = {
      deviceId: deviceId, // 指定目标设备
      bundleName: "com.example.myapplication",
      abilityName: "RemoteServiceAbility",
      parameters: {
        message: "Call from remote device"
      }
    };

    try {
      await this.context.startAbility(want);
      console.log('Remote ability started successfully');
    } catch (err) {
      console.error(`Failed to start remote ability: ${err.code}, ${err.message}`);
    }
  }
}

总结

本文深入探讨了HarmonyOS Stage模型和UIAbility的核心概念，通过实际代码示例展示了生命周期管理、页面导航、状态管理、性能优化和分布式能力等关键主题。随着HarmonyOS 4.0和API 12的推出，这些技术为开发者提供了更强大、更灵活的工具来构建高质量的分布式应用。

最佳实践包括：

1. 合理使用UIAbility生命周期进行资源管理
2. 采用AppStorage进行应用级状态共享
3. 实现资源的懒加载和按需释放
4. 利用WeakReference等机制避免内存泄漏
5. 充分发挥HarmonyOS的分布式特性

通过掌握这些核心概念和最佳实践，开发者能够构建出性能优异、稳定可靠的HarmonyOS应用，充分利用分布式操作系统的优势。