HarmonyOS鸿蒙Next中申请长时任务报错code is 9800005 message is BussinessError 9800005: Continuous Task verification failed. The bgMode is invalid.

HarmonyOS鸿蒙Next中申请长时任务报错code is 9800005 message is BussinessError 9800005: Continuous Task verification failed. The bgMode is invalid. 已经申请了所需要的权限，同样的代码，把实现后台持续定位功能鸿蒙示例代码，复制到自己应用程序后，运行会报错code is 9800005 message is BussinessError 9800005: Continuous Task verification failed. The bgMode is invalid。

具体代码如下：

import {HMRouter, HMRouterMgr} from "@hadss/hmrouter"
import CommonConstants from '../common/Constants';
import { MapComponent, mapCommon, map } from '@kit.MapKit'
import { geoLocationManager } from '@kit.LocationKit'
import {MapUtil} from '../util/MapUtil'
import { AsyncCallback, BusinessError } from '@kit.BasicServicesKit';
import Logger from "../util/Logger";
import {LocationPoint} from "../viewmodel/LocationPoint"
import { backgroundTaskManager } from '@kit.BackgroundTasksKit';
import { BackgroundUtil } from "../util/BackgroundUtil";
import { hilog } from "@kit.PerformanceAnalysisKit"
import { abilityAccessCtrl, bundleManager, common, Permissions, wantAgent, WantAgent } from '@kit.AbilityKit';

@HMRouter({
  pageUrl: 'PracticalRoadTest',
})
@Entry
@Component
export struct PracticalRoadTest {
  @StorageLink('longitude') longitude: number = CommonConstants.LONGITUDE;
  @StorageLink('latitude') latitude: number = CommonConstants.LATITUDE;
  @State pointList: mapCommon.LatLng[] = []
  @State timeValue:number = 0
  @State currentSpeed:number = 0
  mapOption?: mapCommon.MapOptions = {
    position: {
      target: {
        latitude: this.latitude,
        longitude: this.longitude
      },
      zoom: CommonConstants.ZOOM
    },
    mapType: mapCommon.MapType.STANDARD,
    scaleControlsEnabled: false
  };
  private callback?: AsyncCallback<MapComponentController>;
  private mapController?: MapComponentController;
  private context: Context = getContext(this);

  locationCallback = (location: geoLocationManager.Location): void => {
    hilog.info(0x0000, 'testTag',`locationCallback: data: ${JSON.stringify(location)}`);
  };

  startContinuousTask() {
    let wantAgentInfo: wantAgent.WantAgentInfo = {
      wants: [
        {
          bundleName: "com.example.nzdrivingtestapp",
          abilityName: "EntryAbility"
        }
      ],
      actionType: wantAgent.OperationType.START_ABILITY,
      requestCode: 0,
      actionFlags: [wantAgent.WantAgentFlags.UPDATE_PRESENT_FLAG]
    };

    let request: geoLocationManager.ContinuousLocationRequest =
      {'interval': 5, 'locationScenario': geoLocationManager.UserActivityScenario.NAVIGATION};

    wantAgent.getWantAgent(wantAgentInfo).then((wantAgentObj: WantAgent) => {
      let list: Array<string> = ["location"];
      backgroundTaskManager.startBackgroundRunning(this.context, list, wantAgentObj)
        .then((res: backgroundTaskManager.ContinuousTaskNotification) => {
          hilog.info(0x0000, 'testTag',`Operation startBackgroundRunning succeeded`);
          try {
            geoLocationManager.on('locationChange', request, this.locationCallback);
          } catch (err) {
            hilog.error(0x0000, 'testTag',`errCode:${JSON.stringify(err)}`);
          }
        })
        .catch((error: BusinessError) => {
          hilog.error(0x0000, 'testTag',`Operation startBackgroundRunning failed. code is ${error.code} message is ${error.message}`);
        });
    });
  }

  stopContinuousTask() {
    geoLocationManager.off('locationChange', this.locationCallback);
    backgroundTaskManager.stopBackgroundRunning(this.context).then(() => {
      hilog.info(0x0000, 'testTag',`Succeeded in operationing stopBackgroundRunning.`);
    }).catch((err: BusinessError) => {
      hilog.error(0x0000, 'testTag',`Failed to operation stopBackgroundRunning. Code is ${err.code}, message is ${err.message}`);
    });
  }

  permissions: Array<Permissions> =
    ['ohos.permission.LOCATION', 'ohos.permission.APPROXIMATELY_LOCATION'];

  reqPermissionsFromUser(permissions: Array<Permissions>, context: common.UIAbilityContext): void {
    let atManager: abilityAccessCtrl.AtManager = abilityAccessCtrl.createAtManager();
    atManager.requestPermissionsFromUser(context, permissions).then((data) => {
      let grantStatus: Array<number> = data.authResults;
      let length: number = grantStatus.length;
      for (let i = 0; i < length; i++) {
        if (grantStatus[i] === 0) {
          // 用户授权，可以继续访问目标操作
        } else {
          // 用户拒绝授权，提示用户必须授权才能访问当前页面的功能，并引导用户到系统设置中打开相应的权限
          return;
        }
      }
      // 授权成功
    }).catch((err: BusinessError) => {
      hilog.error(0x0000, 'testTag',`Failed to request permissions from user. Code is ${err.code}, message is ${err.message}`);
    })
  }

  async checkPermissionGrant(permission: Permissions): Promise<abilityAccessCtrl.GrantStatus> {
    let atManager: abilityAccessCtrl.AtManager = abilityAccessCtrl.createAtManager();
    let grantStatus: abilityAccessCtrl.GrantStatus = abilityAccessCtrl.GrantStatus.PERMISSION_DENIED;

    let tokenId: number = 0;
    try {
      let bundleInfo: bundleManager.BundleInfo =
        await bundleManager.getBundleInfoForSelf(bundleManager.BundleFlag.GET_BUNDLE_INFO_WITH_APPLICATION);
      let appInfo: bundleManager.ApplicationInfo = bundleInfo.appInfo;
      tokenId = appInfo.accessTokenId;
    } catch (error) {
      const err: BusinessError = error as BusinessError;
      hilog.error(0x0000, 'testTag',`Failed to get bundle info for self. Code is ${err.code}, message is ${err.message}`);
    }

    try {
      grantStatus = await atManager.checkAccessToken(tokenId, permission);
    } catch (error) {
      const err: BusinessError = error as BusinessError;
      hilog.error(0x0000, 'testTag',`Failed to check access token. Code is ${err.code}, message is ${err.message}`);
    }

    return grantStatus;
  }

  aboutToAppear(): void {
    this.callback = async (err, mapController) => {
      let hasPermissions = false;
      if (!err) {
        this.mapController = mapController;
        this.mapController.on('mapLoad', async () => {
          hasPermissions = await MapUtil.checkPermissions(this.mapController);
          if (!hasPermissions) {
            this.RequestPermissions();
          }
          if (hasPermissions) {
            let requestInfo: geoLocationManager.CurrentLocationRequest = {
              priority: geoLocationManager.LocationRequestPriority.FIRST_FIX,
              scenario: geoLocationManager.LocationRequestScenario.UNSET,
              maxAccuracy: 0
            };
            let locationChange = async (): Promise<void> => {
            };
            geoLocationManager.on('locationChange', requestInfo, locationChange);
            geoLocationManager.getCurrentLocation(requestInfo).then(async (result) => {
              let mapPosition: mapCommon.LatLng =
                await map.convertCoordinate(mapCommon.CoordinateType.WGS84, mapCommon.CoordinateType.GCJ02, result);
              AppStorage.setOrCreate('longitude', mapPosition.longitude);
              AppStorage.setOrCreate('latitude', mapPosition.latitude);
              let cameraPosition: mapCommon.CameraPosition = {
                target: mapPosition,
                zoom: 15,
                tilt: 0,
                bearing: 0
              };
              let cameraUpdate = map.newCameraPosition(cameraPosition);
              mapController?.animateCamera(cameraUpdate, 1000);
            })
            mapController.setMyLocationControlsEnabled(false);
          }
        });
      }
    };
  }

  RequestPermissions(): void {
    let atManager: abilityAccessCtrl.AtManager = abilityAccessCtrl.createAtManager();
    atManager.requestPermissionsFromUser(getContext() as common.UIAbilityContext,
      ['ohos.permission.LOCATION', 'ohos.permission.APPROXIMATELY_LOCATION'])
      .then(() => {
        this.mapController?.setMyLocationEnabled(true);
        this.mapController?.setMyLocationControlsEnabled(true);
        this.mapController?.setCompassControlsEnabled(false);
        this.mapController?.setMyLocationStyle({ displayType: mapCommon.MyLocationDisplayType.FOLLOW });
        geoLocationManager.getCurrentLocation().then(async (result) => {
          let mapPosition: mapCommon.LatLng =
            await map.convertCoordinate(mapCommon.CoordinateType.WGS84, mapCommon.CoordinateType.GCJ02, result);
          AppStorage.setOrCreate('longitude', mapPosition.longitude);
          AppStorage.setOrCreate('latitude', mapPosition.latitude);
        })
      })
      .catch((err: BusinessError) => {
        Logger.error(`Failed to request permissions from user. Code is ${err.code}, message is ${err.message}`);
      })
  }

  onPageHide(): void {
    this.mapController?.clear();
  }

  build() {
    Column()
    {
      MapComponent({ mapOptions: this.mapOption, mapCallback: this.callback })
        .width('100%')
        .height('50%')
      Column({ space: 20 })
      {
        Button('申请权限')
          .type(ButtonType.Capsule)
          .backgroundColor('#0D9FFB')
          .width(250)
          .height(40)
          .onClick(async () => {
            const context: common.UIAbilityContext = getContext(this) as common.UIAbilityContext;
            let status = await this.checkPermissionGrant(this.permissions[0])
            if (status !== abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
              this.reqPermissionsFromUser(this.permissions, context);
            }
          })
        Image($r('app.media.Start'))
          .width(60)
          .height(60)
          .onClick(()=>{
            HMRouterMgr.push({ pageUrl: 'Map' })
            this.startContinuousTask()
          })
        Text('开始路试')
          .fontColor($r('app.color.font_color'))
        Button('取消长时任务')
          .type(ButtonType.Capsule)
          .backgroundColor('#0D9FFB')
          .width(250)
          .height(40)
          .onClick(() => {
            // 此处结束具体的长时任务的执行
            // 通过按钮取消长时任务
            this.stopContinuousTask();
          })
      }
      .justifyContent(FlexAlign.Center)
      .width('100%')
      .height('50%')
    }
  }
}