HarmonyOS鸿蒙Next中关于长时任务更新通知报202错误

尊敬的开发者您好，当前仅支持数据传输类型的长时任务使用实况窗，您这边的蓝牙相关场景建议使用普通通知。
数据传输类型的长时任务代码可参考：

【解决方案】

以下载网络视频到应用本地为例，具体步骤如下：

1. 添加后台运行权限ohos.permission.KEEP_BACKGROUND_RUNNING和网络权限ohos.permission.INTERNET。

2. 声明数据传输后台模式类型。在module.json5文件中为需要使用长时任务的UIAbility声明相应的长时任务类型，配置文件中填写长时任务类型的配置项。示例如下：

"backgroundModes": [
  // 配置长时任务类型为数据传输
  "dataTransfer"
]

1. 在UI页面申请数据传输长时任务，并且通知worker线程下载视频。

2. 在worker中使用request.downloadFile接口下载视频。

完整代码示例如下：

Index.ets文件：

import { notificationManager } from '@kit.NotificationKit';
import { BusinessError } from '@kit.BasicServicesKit';
import { backgroundTaskManager } from '@kit.BackgroundTasksKit';
import { common, WantAgent, wantAgent } from '@kit.AbilityKit';
import { MessageEvents, worker } from '@kit.ArkTS';

const workerInstance = new worker.ThreadWorker('entry/ets/workers/Worker.ets');

@Entry
@Component
struct Index {
  context: common.UIAbilityContext = this.getUIContext().getHostContext() as common.UIAbilityContext;
  private notificationId: number = 0; // 保存通知id
  private filePath: string = '';
  private fileCount: number = 2;
  @State fileNameArr: Array<string> = new Array(this.fileCount);
  private fileUrl: string = 'https://xxx/xxx.mp4';

  aboutToAppear(): void {
    workerInstance.onmessage = (e: MessageEvents): void => {
      if (e.data.code == 100) {
        this.updateProcess(e.data.percent, e.data.currentName, e.data.completeCount);
      }
      if (e.data.code == 200) {
        this.stopContinuousTask();
      }
    };
  }

  build() {
    Column() {
      Button('开始下载')
        .type(ButtonType.Capsule)
        .margin({ top: 10 })
        .backgroundColor('#0A59F7')
        .width(300)
        .height(40)
        .onClick(() => {
          this.filePath = this.context.filesDir;
          let fileUrlArrTemp: Array<string> = new Array(this.fileCount);
          let fileNameArrTemp: Array<string> = new Array(this.fileCount);
          for (let index = 0; index < this.fileCount; index++) {
            this.fileNameArr[index] = `trailer${index}.mp4`;
            fileUrlArrTemp[index] = this.fileUrl;
            fileNameArrTemp[index] = `trailer${index + 1}.mp4`;
          }
          workerInstance.postMessage({
            code: 200,
            context: this.context,
            fileUrlArr: fileUrlArrTemp,
            filePath: this.filePath,
            fileNameArr: fileNameArrTemp
          });
          this.startContinuousTask();
        })
    }
    .height('100%')
    .width('100%')
    .justifyContent(FlexAlign.SpaceAround)
  }

  startContinuousTask() {
    let wantAgentInfo: wantAgent.WantAgentInfo = {
      // 点击通知后，将要执行的动作列表
      // 添加需要被拉起应用的bundleName和abilityName
      wants: [
        {
          bundleName: this.context.abilityInfo.bundleName,
          abilityName: 'MainAbility'
        }
      ],
      // 指定点击通知栏消息后的动作是拉起ability
      actionType: wantAgent.OperationType.START_ABILITY,
      // 使用者自定义的一个私有值
      requestCode: 0,
      // 点击通知后，动作执行属性
      actionFlags: [wantAgent.WantAgentFlags.UPDATE_PRESENT_FLAG],
    };

    try {
      // 通过wantAgent模块下getWantAgent方法获取WantAgent对象
      wantAgent.getWantAgent(wantAgentInfo).then((wantAgentObj: WantAgent) => {
        try {
          let list: Array<string> = ['dataTransfer'];
          backgroundTaskManager.startBackgroundRunning(this.context, list, wantAgentObj)
            .then((res: backgroundTaskManager.ContinuousTaskNotification) => {
              console.info('Operation startBackgroundRunning succeeded');
              // 保存通知id，用于更新进度条
              this.notificationId = res.notificationId;
            })
            .catch((error: BusinessError) => {
              console.error(`Failed to Operation startBackgroundRunning. code is ${error.code} message is ${error.message}`);
            });
        } catch (error) {
          console.error(`Failed to Operation startBackgroundRunning. code is ${(error as BusinessError).code} message is ${(error as BusinessError).message}`);
        }
      });
    } catch (error) {
      console.error(`Failed to Operation getWantAgent. code is ${(error as BusinessError).code} message is ${(error as BusinessError).message}`);
    }
  }

  // 停止长时任务
  stopContinuousTask() {
    backgroundTaskManager.stopBackgroundRunning(this.context).then(() => {
      console.info(`Succeeded in operationing stopBackgroundRunning.`);
    }).catch((err: BusinessError) => {
      console.error(`Failed to operation stopBackgroundRunning. Code is ${err.code}, message is ${err.message}`);
    });
  }

  // 应用更新进度
  updateProcess(process: Number, fileName: string, completeCount: number) {
    // 应用定义下载类通知模版
    let downLoadTemplate: notificationManager.NotificationTemplate = {
      name: 'downloadTemplate', // 当前只支持downloadTemplate，保持不变
      data: {
        title: `已下载${completeCount}个/共${this.fileNameArr.length}个`, // 必填
        fileName: `正在下载：${fileName}`, // 必填
        progressValue: process, // 应用更新进度值，自定义
      }
    };
    let request: notificationManager.NotificationRequest = {
      content: {
        // 系统实况类型，保持不变
        notificationContentType: notificationManager.ContentType.NOTIFICATION_CONTENT_SYSTEM_LIVE_VIEW,
        systemLiveView: {
          typeCode: 8, // 上传下载类型需要填写 8，当前仅支持此类型。保持不变
          title: `保存视频到相册`, // 应用自定义
          text: `正在下载：${fileName}`, // 应用自定义
        }
      },
      id: this.notificationId, // 必须是申请长时任务返回的id，否则应用更新通知失败
      notificationSlotType: notificationManager.SlotType.LIVE_VIEW, // 实况窗类型，保持不变
      template: downLoadTemplate // 应用需要设置的模版名称
    };

    try {
      notificationManager.publish(request).then(() => {
        console.info(`publish success, id= ${this.id}`);
      }).catch((err: BusinessError) => {
        console.error(`publish fail. code is ${(err as BusinessError).code} message is ${(err as BusinessError).message}`);
      });
    } catch (err) {
      console.error(`publish fail. code is ${(err as BusinessError).code} message is ${(err as BusinessError).message}`);
    }
  }
}

Worker.ets文件：

import { MessageEvents, ThreadWorkerGlobalScope, worker } from '@kit.ArkTS';
import { common } from '@kit.AbilityKit';
import { request } from '@kit.BasicServicesKit';

const workerPort: ThreadWorkerGlobalScope = worker.workerPort;
let completeCount: number = 0;
let isDownLoading: boolean = false;
let IntervalID: number = 0;

/**
 * Defines the event handler to be called when the worker thread receives a message sent by the host thread.
 * The event handler is executed in the worker thread.
 *
 * @param event message data
 */
workerPort.onmessage = (event: MessageEvents) => {
  completeCount = 0;
  let context: common.UIAbilityContext = event.data.context;
  let fileUrlArr: string = event.data.fileUrlArr;
  let filePath: string = event.data.filePath;
  let fileNameArr: Array<string> = event.data.fileNameArr;
  let totalCount: number = fileNameArr.length;
  console.info('------ start ------------');
  // 开启定时器，定时扫描当前是否下载完成，或者是否正在下载
  IntervalID = setInterval(() => {
    if (completeCount < totalCount) {
      if (isDownLoading === false) {
        downLoadFile(context, fileUrlArr[completeCount], filePath, fileNameArr[completeCount]);
      }
    } else {
      console.info('------ end ------------');
      workerPort.postMessage({ code: 200, data: 20 });
      clearInterval(IntervalID);
    }
  }, 500);
};

/**
 * Defines the event handler to be called when the worker receives a message that cannot be deserialized.
 * The event handler is executed in the worker thread.
 *
 * @param event message data
 */
workerPort.onmessageerror = (event: MessageEvents) => {
  console.log(`MessageEvents => ${JSON.stringify(event)}`);
};

/**
 * Defines the event handler to be called when an exception occurs during worker execution.
 * The event handler is executed in the worker thread.
 *
 * @param event error message
 */
workerPort.onerror = () => {
};

function downLoadFile(context: common.UIAbilityContext, fileUrl: string, filePath: string, fileName: string) {
  console.info(`download fileUrl: ${fileUrl}, fileName: ${fileName}, filePath: ${filePath}`);
  try {
    // 需要手动将url替换为真实服务器的HTTP协议地址
    isDownLoading = true;
    request.downloadFile(context, {
      url: fileUrl,
      filePath: context.filesDir + `/${fileName}`
    }, (err: BusinessError, data: request.DownloadTask) => {
      if (err) {
        console.error(`Failed to request the download. Code: ${err.code}, message: ${err.message}`);
        return;
      }
      let downloadTask: request.DownloadTask = data;
      downloadTask.on('progress', (receivedSize: number, totalSize: number) => {
        console.info(`download receivedSize: ${receivedSize}, totalSize: ${totalSize}`);
        let percent = Math.ceil((receivedSize / totalSize) * 100); // 计算进度值
        workerPort.postMessage({
          code: 100,
          percent: percent, // 当前正在下载的文件进度
          currentName: fileName, // 当前正在下载的文件名
          completeCount: completeCount // 下载完成的个数
        });
      });

      downloadTask.on('complete', () => {
        completeCount++;
        console.info('download complete');
        isDownLoading = false;
      });
    });
  } catch (err) {
    console.error(`Failed to request the download. Code: ${err.code}, message: ${err.message}`);
  }
}

是不是在后台调用startAbility了。仅这段代码不会202的。

可以贴出完整代码。

之前就是用的长时任务加普通通知，但是显得很傻，有个后台任务的通知在那里，然后下面再加个普通通知，之后看到官方文档能在长时任务返回的通知id上更新信息，觉得华为是不是真的解决这个问题了，结果试了后报错，如果不开发给大家用，就不要在官方文档里展示这个示例吧，太失望了。

错误202 “Not system application to call the interface” 不是权限问题，而是API使用方式错了。普通应用只能通过通知发布/更新机制，不能直接操控系统通知控制器