diff --git a/frameworks/common/include/bgtaskmgr_inner_errors.h b/frameworks/common/include/bgtaskmgr_inner_errors.h index e183a03e1f4d04759261d29cd55a50cdfd5316ea..d9708c1c9f81a8f95d1c2e3344d0f10633b77e72 100644 --- a/frameworks/common/include/bgtaskmgr_inner_errors.h +++ b/frameworks/common/include/bgtaskmgr_inner_errors.h @@ -61,6 +61,7 @@ enum : int32_t { ERR_BGTASK_CONTINUOUS_NOT_MERGE_COMBINED_FALSE, ERR_BGTASK_CONTINUOUS_NOT_UPDATE_BECAUSE_MERGE, ERR_BGTASK_CONTINUOUS_NOT_MERGE_CURRENTTASK_COMBINED_FALSE, + ERR_BGTASK_CONTINUOUS_UPDATE_FAIL_SAME_MODE_AND_MERGED, ERR_BGTASK_NOTIFICATION_VERIFY_FAILED = 980000601, ERR_BGTASK_NOTIFICATION_ERR, ERR_BGTASK_CHECK_TASK_PARAM, diff --git a/interfaces/innerkits/include/continuous_task_callback_info.h b/interfaces/innerkits/include/continuous_task_callback_info.h index 5f35aac8ef5dfed4503c9d385f82c9867da56e65..47bcd47fcca7e1dbeb437723ba30796a9f1d409f 100644 --- a/interfaces/innerkits/include/continuous_task_callback_info.h +++ b/interfaces/innerkits/include/continuous_task_callback_info.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -28,10 +28,11 @@ public: ContinuousTaskCallbackInfo(); ContinuousTaskCallbackInfo(uint32_t typeId, int32_t creatorUid, pid_t creatorPid, std::string abilityName, bool isFromWebview = false, bool isBatchApi = false, - const std::vector &typeIds = {}, int32_t abilityId = -1, uint64_t tokenId = 0) + const std::vector &typeIds = {}, int32_t abilityId = -1, uint64_t tokenId = 0, + bool isByRequestObject = false) : typeId_(typeId), creatorUid_(creatorUid), creatorPid_(creatorPid), abilityName_(abilityName), isFromWebview_(isFromWebview), isBatchApi_(isBatchApi), typeIds_(typeIds), abilityId_(abilityId), - tokenId_(tokenId) {} + tokenId_(tokenId), isByRequestObject_(isByRequestObject) {} /** * @brief Get the id of type. @@ -152,6 +153,20 @@ public: */ void SetSuspendState(const bool suspendState); + /** + * @brief By new api 21 operation. + * + * @return True if success, else false. + */ + bool IsByRequestObject() const; + + /** + * @brief Set the operation new api. + * + * @param suspendState The by request operation. + */ + void SetByRequestObject(const bool isByRequestObject); + /** * @brief Marshals a purpose into a parcel. * @@ -178,6 +193,7 @@ private: int32_t cancelReason_ {-1}; bool suspendState_ {false}; int32_t suspendReason_ {-1}; + bool isByRequestObject_ {false}; }; } // namespace BackgroundTaskMgr } // namespace OHOS diff --git a/interfaces/innerkits/src/continuous_task_callback_info.cpp b/interfaces/innerkits/src/continuous_task_callback_info.cpp index 0c5c4f1f1a59b086a3c5e171e1b12d545d2d2a5c..d404636fd0351a690e8cf9daeff9a4faec51bd63 100644 --- a/interfaces/innerkits/src/continuous_task_callback_info.cpp +++ b/interfaces/innerkits/src/continuous_task_callback_info.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -107,6 +107,16 @@ bool ContinuousTaskCallbackInfo::GetSuspendState() const return suspendState_; } +bool ContinuousTaskCallbackInfo::IsByRequestObject() const +{ + return isByRequestObject_ ; +} + +void ContinuousTaskCallbackInfo::SetByRequestObject(const bool isByRequestObject) +{ + isByRequestObject_ = isByRequestObject; +} + bool ContinuousTaskCallbackInfo::Marshalling(Parcel &parcel) const { WRITE_PARCEL_WITH_RET(parcel, Uint32, typeId_, false); @@ -123,6 +133,7 @@ bool ContinuousTaskCallbackInfo::Marshalling(Parcel &parcel) const WRITE_PARCEL_WITH_RET(parcel, Int32, cancelReason_, false); WRITE_PARCEL_WITH_RET(parcel, Bool, suspendState_, false); WRITE_PARCEL_WITH_RET(parcel, Int32, suspendReason_, false); + WRITE_PARCEL_WITH_RET(parcel, Bool, isByRequestObject_, false); return true; } @@ -154,6 +165,7 @@ bool ContinuousTaskCallbackInfo::ReadFromParcel(Parcel &parcel) READ_PARCEL_WITH_RET(parcel, Int32, cancelReason_, false); READ_PARCEL_WITH_RET(parcel, Bool, suspendState_, false); READ_PARCEL_WITH_RET(parcel, Int32, suspendReason_, false); + READ_PARCEL_WITH_RET(parcel, Bool, isByRequestObject_, false); return true; } } // namespace BackgroundTaskMgr diff --git a/interfaces/innerkits/src/continuous_task_mode.cpp b/interfaces/innerkits/src/continuous_task_mode.cpp index 04aaad3d402075a3d8c6c008e2db4ff4dc57f756..edc18831a27803c252cbf6912cc32be376be90cd 100644 --- a/interfaces/innerkits/src/continuous_task_mode.cpp +++ b/interfaces/innerkits/src/continuous_task_mode.cpp @@ -71,7 +71,7 @@ std::string ContinuousTaskMode::GetContinuousTaskModeStr(uint32_t mode) { auto iter = PARAM_CONTINUOUS_TASK_MODE_STR_MAP.find(mode); if (iter != PARAM_CONTINUOUS_TASK_MODE_STR_MAP.end()) { - return iter->second.c_str(); + return iter->second; } return "default"; } diff --git a/interfaces/kits/napi/src/bg_continuous_task_napi_module.cpp b/interfaces/kits/napi/src/bg_continuous_task_napi_module.cpp index 39466dfe3ce25993d813e38675695b1869c00d24..24c51d4089a41fed4006fff247bc3cd37bad2725 100644 --- a/interfaces/kits/napi/src/bg_continuous_task_napi_module.cpp +++ b/interfaces/kits/napi/src/bg_continuous_task_napi_module.cpp @@ -257,7 +257,7 @@ void UpdateBackgroundRunningByRequestExecuteCB(napi_env env, void *data) "", true, continuousTaskModes, asyncCallbackInfo->abilityContext->GetAbilityRecordId()); taskParam.isByRequestObject_ = true; taskParam.isCombinedTaskNotification_ = asyncCallbackInfo->request->IsCombinedTaskNotification(); - taskParam.combinedNotificationTaskId_ = asyncCallbackInfo->request->GetContinuousTaskId(); + taskParam.updateTaskId_ = asyncCallbackInfo->request->GetContinuousTaskId(); taskParam.bgSubModeIds_ = asyncCallbackInfo->request->GetContinuousTaskSubmodes(); asyncCallbackInfo->errCode = BackgroundTaskMgrHelper::RequestUpdateBackgroundRunning(taskParam); asyncCallbackInfo->bgModes = continuousTaskModes; @@ -425,7 +425,9 @@ napi_value UpdateBackgroundRunningByRequestPromise(napi_env env, AsyncCallbackIn BGTASK_LOGE("param is nullptr"); return nullptr; } - if (!CheckBackgroundMode(env, asyncCallbackInfo, isThrow)) { + if (asyncCallbackInfo->request->GetContinuousTaskId() < 0) { + Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_TASKID_INVALID, true); + asyncCallbackInfo->errCode = ERR_BGTASK_CONTINUOUS_TASKID_INVALID; return nullptr; } napi_value resourceName; @@ -746,7 +748,9 @@ napi_value UpdateBackgroundRunning(napi_env env, napi_callback_info info, bool i ret = UpdateBackgroundRunningPromise(env, asyncCallbackInfo, isThrow); } } else { - BGTASK_LOGE("UpdateBackgroundRunningByRequestPromise"); + if (StartBackgroundRunningCheckRequest(env, argv, isThrow, asyncCallbackInfo)) { + ret = UpdateBackgroundRunningByRequestPromise(env, asyncCallbackInfo, isThrow); + } } callbackPtr.release(); if (ret == nullptr) { diff --git a/interfaces/kits/napi/src/common.cpp b/interfaces/kits/napi/src/common.cpp index bb7a4c6472d318698d251eec0204aa50e15e8dc1..56e754fe34ac454d7a8f30a6b49a88eb573e8c31 100644 --- a/interfaces/kits/napi/src/common.cpp +++ b/interfaces/kits/napi/src/common.cpp @@ -115,6 +115,8 @@ const std::map SA_ERRCODE_MSG_MAP = { "Continuous Task verification failed. The continuous task not update because of merged."}, {ERR_BGTASK_CONTINUOUS_NOT_MERGE_CURRENTTASK_COMBINED_FALSE, "Continuous Task verification failed. Current continuous task do not support merged."}, + {ERR_BGTASK_CONTINUOUS_UPDATE_FAIL_SAME_MODE_AND_MERGED, + "Continuous Task verification failed. Current continuous task support merged but the modes are inconsistent."}, }; const std::map PARAM_ERRCODE_MSG_MAP = { diff --git a/interfaces/test/unittest/bgtask_manager_client_test/bgtask_client_unit_test.cpp b/interfaces/test/unittest/bgtask_manager_client_test/bgtask_client_unit_test.cpp index dd8e6f7a0a1f584c8b5d92bd83cffab498b414a8..950c0b6eff149d4c7905c3be2ef344bade9361d2 100644 --- a/interfaces/test/unittest/bgtask_manager_client_test/bgtask_client_unit_test.cpp +++ b/interfaces/test/unittest/bgtask_manager_client_test/bgtask_client_unit_test.cpp @@ -623,6 +623,7 @@ HWTEST_F(BgTaskClientUnitTest, ContinuousTaskCallbackInfo_001, TestSize.Level1) new ContinuousTaskCallbackInfo(1, 1, 1, "test")); info2->SetContinuousTaskId(1); info2->SetCancelReason(1); + info2->SetByRequestObject(true); Parcel parcel = Parcel(); info2->Marshalling(parcel); sptr info3 = sptr( @@ -637,6 +638,7 @@ HWTEST_F(BgTaskClientUnitTest, ContinuousTaskCallbackInfo_001, TestSize.Level1) EXPECT_EQ(info3->GetCancelReason(), 1); EXPECT_EQ(info3->GetSuspendState(), false); EXPECT_EQ(info3->GetSuspendReason(), -1); + EXPECT_EQ(info3->IsByRequestObject(), true); } /** diff --git a/services/continuous_task/include/bg_continuous_task_mgr.h b/services/continuous_task/include/bg_continuous_task_mgr.h index f2f43aeda79954c7acbe6c94c8fd1073b09b81a3..921e82991c99be7a818e93a8bfcf0826867b3769 100644 --- a/services/continuous_task/include/bg_continuous_task_mgr.h +++ b/services/continuous_task/include/bg_continuous_task_mgr.h @@ -116,6 +116,10 @@ private: ErrCode StartBackgroundRunningInner(std::shared_ptr &continuousTaskRecordPtr); ErrCode UpdateBackgroundRunningInner(const std::string &taskInfoMapKey, const sptr &taskParam); + ErrCode UpdateTaskInfo(std::shared_ptr record, const sptr &taskParam); + ErrCode UpdateTaskNotification(std::shared_ptr record, + const sptr &taskParam); + ErrCode UpdateBackgroundRunningByTaskIdInner(int32_t uid, const sptr &taskParam); ErrCode StartBackgroundRunningForInner(const sptr &taskParam); ErrCode StopBackgroundRunningInner(int32_t uid, const std::string &abilityName, int32_t abilityId, int32_t continuousTaskId = -1); @@ -183,7 +187,7 @@ private: bool CanNotifyHap(const std::shared_ptr subscriberInfo, const std::shared_ptr &callbackInfo); bool IsExistCallback(int32_t uid, uint32_t type); - ErrCode CheckCombinedTaskNotifacation(std::shared_ptr &record, bool &sendNotification); + ErrCode CheckCombinedTaskNotification(std::shared_ptr &record, bool &sendNotification); bool StopContinuousTaskByUserInner(const std::string &key); ErrCode DetermineMatchCombinedTaskNotifacation(std::shared_ptr recordParam, bool &sendNotification); diff --git a/services/continuous_task/include/notification_tools.h b/services/continuous_task/include/notification_tools.h index 529714ed0d67d796666e4c6e095f44ab157486e1..6e14182f65d72cb974eb5875ba0cca9aab8061ce 100644 --- a/services/continuous_task/include/notification_tools.h +++ b/services/continuous_task/include/notification_tools.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -31,6 +31,9 @@ public: void GetAllActiveNotificationsLabels(std::set ¬ificationLabels); void RefreshContinuousNotifications( const std::map> &newPromptInfos, int32_t serviceUid); + ErrCode RefreshContinuousNotificationWantAndContext(int32_t serviceUid, + const std::map> &newPromptInfos, + const std::shared_ptr continuousTaskRecord, bool updateContent = false); private: static int32_t notificationIdIndex_; diff --git a/services/continuous_task/src/bg_continuous_task_mgr.cpp b/services/continuous_task/src/bg_continuous_task_mgr.cpp index d2e96a7fd856e4727ade527cf835b5a30c6efd8f..aa051f44d3268e76b0ae5dfa21fecb4dd9c9abca 100644 --- a/services/continuous_task/src/bg_continuous_task_mgr.cpp +++ b/services/continuous_task/src/bg_continuous_task_mgr.cpp @@ -773,23 +773,130 @@ ErrCode BgContinuousTaskMgr::UpdateBackgroundRunning(const sptrabilityName_ + SEPARATOR + - std::to_string(taskParam->abilityId_); - auto self = shared_from_this(); - handler_->PostSyncTask([self, &taskInfoMapKey, &result, taskParam]() mutable { - if (!self) { - BGTASK_LOGE("self is null"); - result = ERR_BGTASK_SERVICE_INNER_ERROR; - return; - } - result = self->UpdateBackgroundRunningInner(taskInfoMapKey, taskParam); - }, AppExecFwk::EventQueue::Priority::HIGH); + if (taskParam->isByRequestObject_) { + // 根据任务id更新 + handler_->PostSyncTask([this, callingUid, taskParam, &result]() { + result = this->UpdateBackgroundRunningByTaskIdInner(callingUid, taskParam); + }, AppExecFwk::EventQueue::Priority::HIGH); + } else { + std::string taskInfoMapKey = std::to_string(callingUid) + SEPARATOR + taskParam->abilityName_ + SEPARATOR + + std::to_string(taskParam->abilityId_); + auto self = shared_from_this(); + handler_->PostSyncTask([self, &taskInfoMapKey, &result, taskParam]() mutable { + if (!self) { + BGTASK_LOGE("self is null"); + result = ERR_BGTASK_SERVICE_INNER_ERROR; + return; + } + result = self->UpdateBackgroundRunningInner(taskInfoMapKey, taskParam); + }, AppExecFwk::EventQueue::Priority::HIGH); + } return result; } +ErrCode BgContinuousTaskMgr::UpdateTaskInfo(std::shared_ptr record, + const sptr &taskParam) +{ + record->wantAgent_ = taskParam->wantAgent_; + if (record->wantAgent_ != nullptr && record->wantAgent_->GetPendingWant() != nullptr) { + auto target = record->wantAgent_->GetPendingWant()->GetTarget(); + auto want = record->wantAgent_->GetPendingWant()->GetWant(target); + if (want != nullptr) { + std::shared_ptr info = std::make_shared(); + info->bundleName_ = want->GetOperation().GetBundleName(); + info->abilityName_ = want->GetOperation().GetAbilityName(); + record->wantAgentInfo_ = info; + } + } + ErrCode ret = UpdateTaskNotification(record, taskParam); + if (ret != ERR_OK) { + return ret; + } + record->isCombinedTaskNotification_ = taskParam->isCombinedTaskNotification_; + if (record->suspendState_) { + std::string taskInfoMapKey = std::to_string(record->uid_) + SEPARATOR + record->abilityName_ + SEPARATOR + + std::to_string(record->abilityId_) + SEPARATOR + CommonUtils::ModesToString(record->bgModeIds_); + HandleActiveContinuousTask(record->uid_, record->pid_, taskInfoMapKey); + } + OnContinuousTaskChanged(record, ContinuousTaskEventTriggerType::TASK_UPDATE); + taskParam->notificationId_ = record->GetNotificationId(); + taskParam->continuousTaskId_ = record->GetContinuousTaskId(); + return RefreshTaskRecord(); +} + +ErrCode BgContinuousTaskMgr::UpdateTaskNotification(std::shared_ptr record, + const sptr &taskParam) +{ + auto oldModes = record->bgModeIds_; + if (!record->isCombinedTaskNotification_) { + // 不支持合并的任务，才更新任务类型 + record->bgModeId_ = taskParam->bgModeId_; + record->bgModeIds_ = taskParam->bgModeIds_; + record->bgSubModeIds_ = taskParam->bgSubModeIds_; + } + std::map> newPromptInfos; + if (CommonUtils::CheckExistMode(oldModes, BackgroundMode::DATA_TRANSFER) && + CommonUtils::CheckExistMode(taskParam->bgModeIds_, BackgroundMode::DATA_TRANSFER)) { + BGTASK_LOGI("uid: %{public}d, bundleName: %{public}s, abilityId: %{public}d have same mode: DATA_TRANSFER", + record->uid_, record->bundleName_.c_str(), record->abilityId_); + } else if (record->isCombinedTaskNotification_) { + if (CommonUtils::CheckModesSame(oldModes, taskParam->bgModeIds_)) { + return NotificationTools::GetInstance()->RefreshContinuousNotificationWantAndContext(bgTaskUid_, + newPromptInfos, record); + } else { + return ERR_BGTASK_CONTINUOUS_UPDATE_FAIL_SAME_MODE_AND_MERGED; + } + } else { + std::string mainAbilityLabel = GetMainAbilityLabel(record->bundleName_, record->userId_); + std::string notificationText = GetNotificationText(record); + if (mainAbilityLabel == "") { + BGTASK_LOGE("uid: %{public}d, bundleName: %{public}s get main ability label or notification text fail.", + record->uid_, record->bundleName_.c_str()); + return ERR_BGTASK_NOTIFICATION_VERIFY_FAILED; + } else if (notificationText.empty()) { + std::string modeStr = CommonUtils::ModesToString(record->bgModeIds_); + BGTASK_LOGE("notificationText is empty, bgmode : %{public}s", modeStr.c_str()); + } else { + newPromptInfos.emplace(record->notificationLabel_, std::make_pair(mainAbilityLabel, notificationText)); + // 刷新text,want + return NotificationTools::GetInstance()->RefreshContinuousNotificationWantAndContext(bgTaskUid_, + newPromptInfos, record, true); + } + } + return ERR_OK; +} + +ErrCode BgContinuousTaskMgr::UpdateBackgroundRunningByTaskIdInner(int32_t uid, + const sptr &taskParam) +{ + int32_t continuousTaskId = taskParam->updateTaskId_; + if (continuousTaskId < 0) { + BGTASK_LOGE("update task fail, taskId: %{public}d", taskParam->updateTaskId_); + return ERR_BGTASK_CONTINUOUS_TASKID_INVALID; + } + auto findTask = [continuousTaskId](const auto &target) { + return continuousTaskId == target.second->continuousTaskId_ && target.second->isByRequestObject_; + }; + auto findTaskIter = find_if(continuousTaskInfosMap_.begin(), continuousTaskInfosMap_.end(), findTask); + if (findTaskIter == continuousTaskInfosMap_.end()) { + BGTASK_LOGE("uid: %{public}d not have task, taskId: %{public}d", uid, continuousTaskId); + return ERR_BGTASK_OBJECT_NOT_EXIST; + } + auto record = findTaskIter->second; + uint32_t configuredBgMode = GetBackgroundModeInfo(uid, record->abilityName_); + ErrCode ret = ERR_OK; + for (auto it = taskParam->bgModeIds_.begin(); it != taskParam->bgModeIds_.end(); it++) { + ret = CheckBgmodeType(configuredBgMode, *it, true, record); + if (ret != ERR_OK) { + BGTASK_LOGE("CheckBgmodeType error, mode: %{public}u, apply mode: %{public}u.", configuredBgMode, *it); + return ret; + } + } + return UpdateTaskInfo(record, taskParam); +} + ErrCode BgContinuousTaskMgr::UpdateBackgroundRunningInner(const std::string &taskInfoMapKey, const sptr &taskParam) { @@ -896,7 +1003,7 @@ ErrCode BgContinuousTaskMgr::StartBackgroundRunningSubmit(std::shared_ptr &recordParam, +ErrCode BgContinuousTaskMgr::CheckCombinedTaskNotification(std::shared_ptr &recordParam, bool &sendNotification) { // 无需合并，新申请 @@ -2079,6 +2186,7 @@ void BgContinuousTaskMgr::OnContinuousTaskChanged(const std::shared_ptrSetCancelReason(continuousTaskInfo->reason_); continuousTaskCallbackInfo->SetSuspendState(continuousTaskInfo->suspendState_); continuousTaskCallbackInfo->SetSuspendReason(continuousTaskInfo->suspendReason_); + continuousTaskCallbackInfo->SetByRequestObject(continuousTaskInfo->isByRequestObject_); NotifySubscribers(changeEventType, continuousTaskCallbackInfo); ReportHisysEvent(changeEventType, continuousTaskInfo); } diff --git a/services/continuous_task/src/notification_tools.cpp b/services/continuous_task/src/notification_tools.cpp index 11f9a1471eb3610a560c486edf2290191ce386ba..80e781ff655323d4f4048484d1d07e8d0baf2caf 100644 --- a/services/continuous_task/src/notification_tools.cpp +++ b/services/continuous_task/src/notification_tools.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -179,5 +179,50 @@ WEAK_FUNC void NotificationTools::RefreshContinuousNotifications( } #endif } + +WEAK_FUNC ErrCode NotificationTools::RefreshContinuousNotificationWantAndContext(int32_t serviceUid, + const std::map> &newPromptInfos, + const std::shared_ptr continuousTaskRecord, bool updateContent) +{ +#ifdef DISTRIBUTED_NOTIFICATION_ENABLE + std::vector> notificationRequests; + ErrCode ret = Notification::NotificationHelper::GetActiveNotifications(notificationRequests); + if (ret != ERR_OK) { + BGTASK_LOGE("refresh task, get all active notification fail!"); + return ERR_BGTASK_NOTIFICATION_VERIFY_FAILED; + } + for (Notification::NotificationRequest *var : notificationRequests) { + if (!var) { + BGTASK_LOGE("NotificationRequest is null!"); + return ERR_BGTASK_NOTIFICATION_VERIFY_FAILED; + } + std::string label = var->GetLabel(); + if (newPromptInfos.count(label) == 0 || var->GetCreatorUid() != serviceUid) { + continue; + } + var->SetWantAgent(continuousTaskRecord->GetWantAgent()); + if (updateContent) { + auto &content = var->GetContent(); + if (!content) { + BGTASK_LOGE("content is null!"); + return ERR_BGTASK_NOTIFICATION_VERIFY_FAILED; + } + auto const &normalContent = content->GetNotificationContent(); + if (!normalContent) { + BGTASK_LOGE("normalContent is null!"); + return ERR_BGTASK_NOTIFICATION_VERIFY_FAILED; + } + normalContent->SetTitle(newPromptInfos.at(label).first); + normalContent->SetText(newPromptInfos.at(label).second); + } + ret = Notification::NotificationHelper::PublishContinuousTaskNotification(*var); + if (ret != ERR_OK) { + BGTASK_LOGE("refresh notification error, label: %{public}s", label.c_str()); + return ERR_BGTASK_NOTIFICATION_VERIFY_FAILED; + } + } +#endif + return ERR_OK; +} } } diff --git a/services/test/unittest/bg_continuous_task_mgr_test.cpp b/services/test/unittest/bg_continuous_task_mgr_test.cpp index 57594dcb48d658d93cbccd12fd76d1adaa9a329d..8c26e025abd917f73bc3facd769adb14cb8f1777 100644 --- a/services/test/unittest/bg_continuous_task_mgr_test.cpp +++ b/services/test/unittest/bg_continuous_task_mgr_test.cpp @@ -1434,7 +1434,7 @@ HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_058, TestSize.Level1) /** * @tc.name: BgTaskManagerUnitTest_059 - * @tc.desc: test CheckCombinedTaskNotifacation. + * @tc.desc: test CheckCombinedTaskNotification. * @tc.type: FUNC * @tc.require: issueICUX92 */ @@ -1448,13 +1448,13 @@ HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_059, TestSize.Level1) continuousTaskRecord->isByRequestObject_ = true; continuousTaskRecord->bgModeIds_.push_back(continuousTaskRecord->bgModeId_); // 不需要合并 - EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), ERR_OK); + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotification(continuousTaskRecord, sendNotification), ERR_OK); continuousTaskRecord->combinedNotificationTaskId_ = TEST_NUM_ONE; continuousTaskRecord->isCombinedTaskNotification_ = true; bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = nullptr; // 需要合并，但没有任务 - EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotification(continuousTaskRecord, sendNotification), ERR_BGTASK_CONTINUOUS_TASKID_INVALID); bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); @@ -1464,19 +1464,19 @@ HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_059, TestSize.Level1) continuousTaskRecord2->bgModeIds_.push_back(continuousTaskRecord->bgModeId_); bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; // 需要合并，任务uid不相等 - EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotification(continuousTaskRecord, sendNotification), ERR_BGTASK_CONTINUOUS_TASKID_INVALID); bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); continuousTaskRecord2->continuousTaskId_ = TEST_NUM_ONE + 1; // 需要合并，任务id不相等 - EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotification(continuousTaskRecord, sendNotification), ERR_BGTASK_CONTINUOUS_TASKID_INVALID); } /** * @tc.name: BgTaskManagerUnitTest_060 - * @tc.desc: test CheckCombinedTaskNotifacation. + * @tc.desc: test CheckCombinedTaskNotification. * @tc.type: FUNC * @tc.require: issueICUX92 */ @@ -1495,14 +1495,14 @@ HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_060, TestSize.Level1) continuousTaskRecord2->isCombinedTaskNotification_ = false; bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; // 需要合并，任务不支持合并 - EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotification(continuousTaskRecord, sendNotification), ERR_BGTASK_CONTINUOUS_NOT_MERGE_COMBINED_FALSE); bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); continuousTaskRecord2->isCombinedTaskNotification_ = true; continuousTaskRecord2->notificationId_ = -1; bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; // 需要合并，任务没有通知 - EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotification(continuousTaskRecord, sendNotification), ERR_BGTASK_CONTINUOUS_NOT_MERGE_NOTIFICATION_NOT_EXIST); bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); continuousTaskRecord->bgModeId_ = 2; @@ -1514,7 +1514,7 @@ HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_060, TestSize.Level1) continuousTaskRecord2->notificationId_ = 1; bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; // 需要合并，任务主类型不相等 - EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotification(continuousTaskRecord, sendNotification), ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_TYPE_MISMATCH); bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); continuousTaskRecord->bgSubModeIds_.clear(); @@ -1523,13 +1523,13 @@ HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_060, TestSize.Level1) continuousTaskRecord2->bgSubModeIds_.push_back(3); bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; // 需要合并，任务子类型不相等 - EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotification(continuousTaskRecord, sendNotification), ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_TYPE_MISMATCH); } /** * @tc.name: BgTaskManagerUnitTest_061 - * @tc.desc: test CheckCombinedTaskNotifacation. + * @tc.desc: test CheckCombinedTaskNotification. * @tc.type: FUNC * @tc.require: issueICUX92 */ @@ -1560,7 +1560,7 @@ HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_061, TestSize.Level1) continuousTaskRecord2->notificationId_ = 1; bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; // 需要合并，任务类型包含上传下载，不能合并 - EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotification(continuousTaskRecord, sendNotification), ERR_BGTASK_CONTINUOUS_DATA_TRANSFER_NOT_MERGE_NOTIFICATION); bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); @@ -1576,7 +1576,7 @@ HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_061, TestSize.Level1) continuousTaskRecord2->bgSubModeIds_.clear(); continuousTaskRecord2->bgSubModeIds_.push_back(1); bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; - EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), ERR_OK); + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotification(continuousTaskRecord, sendNotification), ERR_OK); } /** @@ -1589,5 +1589,153 @@ HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_062, TestSize.Level1) { EXPECT_EQ(bgContinuousTaskMgr_->StopBackgroundRunning("ability1", 1, 1), ERR_BGTASK_OBJECT_NOT_EXIST); } + +/** + * @tc.name: UpdateBackgroundRunning_63 + * @tc.desc: use api 21. + * @tc.type: FUNC + * @tc.require: issueICWHAG + */ +HWTEST_F(BgContinuousTaskMgrTest, UpdateBackgroundRunning_63, TestSize.Level1) +{ + sptr taskParam1 = new (std::nothrow) ContinuousTaskParam(true, 4, + std::make_shared(), + "ability1", nullptr, "Entry", true, {4}); + taskParam1->isByRequestObject_ = true; + taskParam1->abilityId_ = 1; + taskParam1->updateTaskId_ = -1; + taskParam1->bgSubModeIds_.clear(); + taskParam1->bgSubModeIds_.push_back(1); + // 更新的任务id为-1，非法参数 + EXPECT_EQ(bgContinuousTaskMgr_->UpdateBackgroundRunning(taskParam1), ERR_BGTASK_CONTINUOUS_TASKID_INVALID); + + bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); + taskParam1->updateTaskId_ = 1; + // 更新的任务id为1，但没有对应任务 + EXPECT_EQ(bgContinuousTaskMgr_->UpdateBackgroundRunning(taskParam1), ERR_BGTASK_OBJECT_NOT_EXIST); + + std::shared_ptr continuousTaskRecord2 = std::make_shared(); + continuousTaskRecord2->uid_ = TEST_NUM_ONE; + continuousTaskRecord2->continuousTaskId_ = TEST_NUM_ONE; + continuousTaskRecord2->bgModeId_ = 4; + continuousTaskRecord2->bgModeIds_.clear(); + continuousTaskRecord2->bgModeIds_.push_back(4); + continuousTaskRecord2->bgSubModeIds_.clear(); + continuousTaskRecord2->bgSubModeIds_.push_back(1); + continuousTaskRecord2->abilityName_ = "ability1"; + continuousTaskRecord2->bundleName_ = "Entry"; + continuousTaskRecord2->abilityId_ = 1; + continuousTaskRecord2->isByRequestObject_ = true; + bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; + // 更新的任务id为1，有对应任务，但mode检查不通过 + EXPECT_EQ(bgContinuousTaskMgr_->UpdateBackgroundRunning(taskParam1), ERR_BGTASK_INVALID_BGMODE); + + bgContinuousTaskMgr_->cachedBundleInfos_.clear(); + CachedBundleInfo info = CachedBundleInfo(); + info.abilityBgMode_["ability1"] = CONFIGURE_ALL_MODES; + info.appName_ = "Entry"; + bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info); + continuousTaskRecord2->notificationId_ = -1; + // 通知不存在，直接更新内容 + EXPECT_EQ(bgContinuousTaskMgr_->UpdateBackgroundRunning(taskParam1), ERR_OK); +} + +/** + * @tc.name: UpdateBackgroundRunning_64 + * @tc.desc: use api 21. + * @tc.type: FUNC + * @tc.require: issueICWHAG + */ +HWTEST_F(BgContinuousTaskMgrTest, UpdateBackgroundRunning_64, TestSize.Level1) +{ + bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); + std::shared_ptr continuousTaskRecord2 = std::make_shared(); + continuousTaskRecord2->uid_ = TEST_NUM_ONE; + continuousTaskRecord2->continuousTaskId_ = TEST_NUM_ONE; + continuousTaskRecord2->bgModeId_ = 1; + continuousTaskRecord2->bgModeIds_.clear(); + continuousTaskRecord2->bgModeIds_.push_back(1); + continuousTaskRecord2->bgSubModeIds_.clear(); + continuousTaskRecord2->bgSubModeIds_.push_back(1); + continuousTaskRecord2->abilityName_ = "ability1"; + continuousTaskRecord2->bundleName_ = "Entry"; + continuousTaskRecord2->abilityId_ = 1; + continuousTaskRecord2->notificationId_ = 1; + continuousTaskRecord2->isByRequestObject_ = true; + bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; + + bgContinuousTaskMgr_->cachedBundleInfos_.clear(); + CachedBundleInfo info = CachedBundleInfo(); + info.abilityBgMode_["ability1"] = CONFIGURE_ALL_MODES; + info.appName_ = "Entry"; + bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info); + + sptr taskParam1 = new (std::nothrow) ContinuousTaskParam(true, 1, + std::make_shared(), + "ability1", nullptr, "Entry", true, {1}); + taskParam1->isByRequestObject_ = true; + taskParam1->abilityId_ = 1; + taskParam1->updateTaskId_ = 1; + taskParam1->bgSubModeIds_.clear(); + taskParam1->bgSubModeIds_.push_back(1); + // 通知存在，但前后都是上传下载 + EXPECT_EQ(bgContinuousTaskMgr_->UpdateBackgroundRunning(taskParam1), ERR_OK); +} + +/** + * @tc.name: UpdateBackgroundRunning_65 + * @tc.desc: use api 21. + * @tc.type: FUNC + * @tc.require: issueICWHAG + */ +HWTEST_F(BgContinuousTaskMgrTest, UpdateBackgroundRunning_65, TestSize.Level1) +{ + bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); + std::shared_ptr continuousTaskRecord2 = std::make_shared(); + continuousTaskRecord2->uid_ = TEST_NUM_ONE; + continuousTaskRecord2->continuousTaskId_ = TEST_NUM_ONE; + continuousTaskRecord2->bgModeId_ = 4; + continuousTaskRecord2->bgModeIds_.clear(); + continuousTaskRecord2->bgModeIds_.push_back(4); + continuousTaskRecord2->bgSubModeIds_.clear(); + continuousTaskRecord2->bgSubModeIds_.push_back(3); + continuousTaskRecord2->abilityName_ = "ability1"; + continuousTaskRecord2->bundleName_ = "Entry"; + continuousTaskRecord2->abilityId_ = 1; + continuousTaskRecord2->notificationId_ = 1; + continuousTaskRecord2->isByRequestObject_ = true; + bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; + + bgContinuousTaskMgr_->cachedBundleInfos_.clear(); + CachedBundleInfo info = CachedBundleInfo(); + info.abilityBgMode_["ability1"] = CONFIGURE_ALL_MODES; + info.appName_ = "Entry"; + bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info); + + sptr taskParam1 = new (std::nothrow) ContinuousTaskParam(true, 4, + std::make_shared(), + "ability1", nullptr, "Entry", true, {4}); + taskParam1->isByRequestObject_ = true; + taskParam1->abilityId_ = 1; + taskParam1->updateTaskId_ = 1; + taskParam1->bgSubModeIds_.clear(); + taskParam1->bgSubModeIds_.push_back(3); + + bgContinuousTaskMgr_->continuousTaskText_.clear(); + // 通知存在，获取不到对应类型的通知文字 + EXPECT_EQ(bgContinuousTaskMgr_->UpdateBackgroundRunning(taskParam1), ERR_BGTASK_NOTIFICATION_VERIFY_FAILED); + + std::fill_n(std::back_inserter(bgContinuousTaskMgr_->continuousTaskText_), PROMPT_NUMS, "bgmode_test"); + bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); + bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; + // 通知存在，只更新want + EXPECT_EQ(bgContinuousTaskMgr_->UpdateBackgroundRunning(taskParam1), ERR_OK); + + bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); + continuousTaskRecord2->isCombinedTaskNotification_ = true; + bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; + // 通知存在，更新want与content + EXPECT_EQ(bgContinuousTaskMgr_->UpdateBackgroundRunning(taskParam1), ERR_OK); +} } // namespace BackgroundTaskMgr } // namespace OHOS \ No newline at end of file diff --git a/services/test/unittest/mock/mock_notification_tools.cpp b/services/test/unittest/mock/mock_notification_tools.cpp index 437a4b3146dfeab6e8a991d1b555c2bcb9c79fed..74b23d284755678ca95c0b0cc14ef7704dcaf48f 100644 --- a/services/test/unittest/mock/mock_notification_tools.cpp +++ b/services/test/unittest/mock/mock_notification_tools.cpp @@ -32,5 +32,12 @@ void NotificationTools::GetAllActiveNotificationsLabels(std::set &n void NotificationTools::RefreshContinuousNotifications( const std::map> &newPromptInfos, int32_t serviceUid) {} + +ErrCode NotificationTools::RefreshContinuousNotificationWantAndContext(int32_t serviceUid, + const std::map> &newPromptInfos, + const std::shared_ptr continuousTaskRecord, bool updateContent) +{ + return ERR_OK; +} } }