HarmonyOS 鸿蒙Next支不支持无UI应用在后台运行

核心思路是使用 ServiceAbility 组件并在配置文件中声明必要的权限和后台模式。

步骤 1：配置应用信息 (module.json5)

// entry/src/main/module.json5
{
  "module": {
    "name": "entry",
    "type": "entry",
    "description": "$string:module_desc",
    "mainElement": "MainAbility",
    "deviceTypes": [
      "default",
      "tablet"
    ],
    "abilities": [
      {
        "name": "MainAbility",
        "srcEntry": "./ets/mainability/MainAbility.ts",
        "description": "$string:MainAbility_desc",
        "icon": "$media:icon",
        "label": "$string:MainAbility_label",
        "startWindowIcon": "$media:icon",
        "startWindowBackground": "$color:start_window_background",
        "visible": true, // PageAbility，提供UI界面
        "skills": [
          {
            "entities": [
              "entity.system.home"
            ],
            "actions": [
              "action.system.home"
            ]
          }
        ]
      },
      {
        "name": "BackgroundServiceAbility",
        "srcEntry": "./ets/backgroundserviceability/BackgroundServiceAbility.ts",
        "description": "$string:BackgroundServiceAbility_desc",
        "icon": "$media:icon",
        "label": "$string:BackgroundServiceAbility_label",
        "visible": false, // 【关键】ServiceAbility，无UI界面
        "backgroundModes": [
          "dataTransfer", // 【关键】声明后台运行模式
          "location"      // 根据实际业务需求添加
        ]
      }
    ],
    "requestPermissions": [
      {
        "name": "ohos.permission.KEEP_BACKGROUND_RUNNING" // 【关键】申请长时任务权限
      },
      // 根据实际业务需求添加其他权限
      {
        "name": "ohos.permission.INTERNET"
      }
    ]
  }
}

步骤 2：创建并实现 ServiceAbility

// entry/src/main/ets/backgroundserviceability/BackgroundServiceAbility.ts
import { ServiceAbility } from '@kit.AbilityKit';
import { backgroundTaskManager } from '@kit.BackgroundTaskManager';
import { hilog } from '@kit.HiLogKit';
import { timer } from '@kit.ArkUI';

const TAG = 'BackgroundService';
const DOMAIN = 0xF00D; // 自定义日志域

export default class BackgroundServiceAbility extends ServiceAbility {
  private taskId: number = -1;
  private backgroundTimer: number | null = null;
  private counter: number = 0;

  // Service被创建时调用
  onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
    hilog.info(DOMAIN, TAG, 'ServiceAbility onCreate');
    // 初始化资源
  }

  // Service被启动时调用
  onStart(want: Want, startId: number): void {
    hilog.info(DOMAIN, TAG, 'ServiceAbility onStart, startId: %{public}d', startId);

    // 【关键】申请延迟挂起，防止系统挂起后台任务
    this.requestSuspendDelay();

    // 启动后台任务
    this.startBackgroundWork();
  }

  // Service被销毁时调用
  onDestroy(): void {
    hilog.info(DOMAIN, TAG, 'ServiceAbility onDestroy');
    
    // 清理资源
    this.stopBackgroundWork();
    
    // 取消延迟挂起申请
    this.cancelSuspendDelay();
  }

  // 申请延迟挂起
  private requestSuspendDelay(): void {
    try {
      const delayInfo: backgroundTaskManager.DelaySuspendInfo = {
        reason: 'Performing background data sync', // 申请原因
        requestTime: new Date().getTime()
      };

      backgroundTaskManager.requestSuspendDelay(delayInfo)
        .then((result: backgroundTaskManager.DelaySuspendResult) => {
          hilog.info(DOMAIN, TAG, 'Suspend delay requested successfully, taskId: %{public}d', result.taskId);
          this.taskId = result.taskId;
        })
        .catch((error: BusinessError) => {
          hilog.error(DOMAIN, TAG, 'Failed to request suspend delay: %{public}s', error.message);
        });
    } catch (error) {
      hilog.error(DOMAIN, TAG, 'Exception when requesting suspend delay: %{public}s', error.message);
    }
  }

  // 取消延迟挂起
  private cancelSuspendDelay(): void {
    if (this.taskId !== -1) {
      try {
        backgroundTaskManager.cancelSuspendDelay(this.taskId);
        hilog.info(DOMAIN, TAG, 'Suspend delay cancelled for taskId: %{public}d', this.taskId);
        this.taskId = -1;
      } catch (error) {
        hilog.error(DOMAIN, TAG, 'Failed to cancel suspend delay: %{public}s', error.message);
      }
    }
  }

  // 启动后台工作任务
  private startBackgroundWork(): void {
    hilog.info(DOMAIN, TAG, 'Starting background work...');

    // 示例：创建一个定时器，模拟后台任务
    this.backgroundTimer = timer.setInterval(() => {
      this.counter++;
      hilog.info(DOMAIN, TAG, 'Background task executing, count: %{public}d', this.counter);
      
      // 这里可以执行实际的后台任务，例如：
      // 1. 数据同步
      // 2. 位置上报
      // 3. 文件下载
      // 4. 消息推送处理
      
      this.performDataSync(); // 模拟数据同步
    }, 10000); // 每10秒执行一次
  }

  // 停止后台工作任务
  private stopBackgroundWork(): void {
    if (this.backgroundTimer !== null) {
      timer.clearInterval(this.backgroundTimer);
      this.backgroundTimer = null;
      hilog.info(DOMAIN, TAG, 'Background work stopped');
    }
  }

  // 模拟数据同步任务
  private async performDataSync(): Promise<void> {
    try {
      // 这里可以添加实际的数据同步逻辑
      // 例如使用 @kit.NetworkKit 进行网络请求
      hilog.debug(DOMAIN, TAG, 'Performing data sync operation...');
      
      // 模拟异步操作
      await this.mockAsyncOperation();
      
      hilog.debug(DOMAIN, TAG, 'Data sync completed successfully');
    } catch (error) {
      hilog.error(DOMAIN, TAG, 'Data sync failed: %{public}s', error.message);
    }
  }

  // 模拟异步操作
  private async mockAsyncOperation(): Promise<void> {
    return new Promise((resolve) => {
      setTimeout(() => {
        resolve();
      }, 1000);
    });
  }

  // 当使用connectAbility时触发
  onConnect(want: Want): IRemoteObject {
    hilog.info(DOMAIN, TAG, 'ServiceAbility onConnect');
    // 返回IRemoteObject用于IPC通信
    // 可以根据需要实现具体逻辑
    return new MyRemoteObject();
  }

  // 当断开连接时触发
  onDisconnect(want: Want): void {
    hilog.info(DOMAIN, TAG, 'ServiceAbility onDisconnect');
  }

  // 当使用Command方式启动时触发
  onCommand(want: Want, startId: number, restart: number): void {
    hilog.info(DOMAIN, TAG, 'ServiceAbility onCommand, startId: %{public}d', startId);
  }
}

// 简单的IRemoteObject实现示例
class MyRemoteObject extends rpc.RemoteObject {
  constructor() {
    super();
  }

  // 可以在这里添加远程调用的方法
}

步骤 3：从 PageAbility 启动 Service

// entry/src/main/ets/mainability/MainAbility.ts
import { UIAbility, Want } from '@kit.AbilityKit';
import { hilog } from '@kit.HiLogKit';
import { window } from '@kit.ArkUI';

const TAG = 'MainAbility';
const DOMAIN = 0xF00D;

export default class MainAbility extends UIAbility {
  onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
    hilog.info(DOMAIN, TAG, 'MainAbility onCreate');
  }

  onWindowStageCreate(windowStage: window.WindowStage): void {
    hilog.info(DOMAIN, TAG, 'MainAbility onWindowStageCreate');
    
    // 加载UI页面
    windowStage.loadContent('pages/Index', (err) => {
      if (err) {
        hilog.error(DOMAIN, TAG, 'Failed to load content: %{public}s', err.message);
        return;
      }
      hilog.info(DOMAIN, TAG, 'Succeeded in loading content');
      
      // 启动后台服务
      this.startBackgroundService();
    });
  }

  // 启动后台服务
  private startBackgroundService(): void {
    const want: Want = {
      bundleName: 'com.yourcompany.yourapp', // 替换为你的包名
      abilityName: 'BackgroundServiceAbility'
    };

    try {
      this.context.startAbility(want)
        .then(() => {
          hilog.info(DOMAIN, TAG, 'Background service started successfully');
        })
        .catch((error: BusinessError) => {
          hilog.error(DOMAIN, TAG, 'Failed to start background service: %{public}s', error.message);
        });
    } catch (error) {
      hilog.error(DOMAIN, TAG, 'Exception when starting background service: %{public}s', error.message);
    }
  }

  onWindowStageDestroy(): void {
    hilog.info(DOMAIN, TAG, 'MainAbility onWindowStageDestroy');
  }

  onDestroy(): void {
    hilog.info(DOMAIN, TAG, 'MainAbility onDestroy');
  }
}

步骤 4：在UI页面中添加控制按钮 (可选)

// entry/src/main/ets/pages/Index.ets
import { hilog } from '@kit.HiLogKit';

const TAG = 'IndexPage';
const DOMAIN = 0xF00D;

@Entry
@Component
struct Index {
  private context = getContext(this) as common.UIAbilityContext;

  build() {
    Column() {
      Text('Background Service Demo')
        .fontSize(20)
        .margin(10)

      Button('Start Background Service')
        .width(200)
        .height(40)
        .margin(10)
        .onClick(() => {
          this.startService();
        })

      Button('Stop Background Service')
        .width(200)
        .height(40)
        .margin(10)
        .onClick(() => {
          this.stopService();
        })
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
  }

  // 启动服务
  private startService(): void {
    const want: Want = {
      bundleName: 'com.yourcompany.yourapp', // 替换为你的包名
      abilityName: 'BackgroundServiceAbility'
    };

    try {
      this.context.startAbility(want)
        .then(() => {
          hilog.info(DOMAIN, TAG, 'Service started via UI');
        })
        .catch((error: BusinessError) => {
          hilog.error(DOMAIN, TAG, 'Failed to start service: %{public}s', error.message);
        });
    } catch (error) {
      hilog.error(DOMAIN, TAG, 'Exception when starting service: %{public}s', error.message);
    }
  }

  // 停止服务
  private stopService(): void {
    const want: Want = {
      bundleName: 'com.yourcompany.yourapp', // 替换为你的包名
      abilityName: 'BackgroundServiceAbility'
    };

    try {
      this.context.stopAbility(want)
        .then(() => {
          hilog.info(DOMAIN, TAG, 'Service stopped via UI');
        })
        .catch((error: BusinessError) => {
          hilog.error(DOMAIN, TAG, 'Failed to stop service: %{public}s', error.message);
        });
    } catch (error) {
      hilog.error(DOMAIN, TAG, 'Exception when stopping service: %{public}s', error.message);
    }
  }
}

关键要点说明

1. 权限配置：必须在 module.json5 中声明 ohos.permission.KEEP_BACKGROUND_RUNNING 权限。
2. 后台模式声明：在 abilities 中配置 backgroundModes 字段，声明后台任务类型。
3. 延迟挂起申请：使用 backgroundTaskManager.requestSuspendDelay() 防止系统挂起后台任务。
4. 资源管理：在 onDestroy 中正确清理定时器和取消延迟挂起申请。

这个实现提供了完整的后台服务框架，您可以根据实际需求在 performDataSync 方法中添加具体的后台业务逻辑。

你好，鸿蒙系统支持无UI应用在后台运行，开发者可以通过创建Service Ability 进行无显示界面应用的后台运行，这是鸿蒙原生能力之一