diff --git a/frameworks/common/include/bgtaskmgr_inner_errors.h b/frameworks/common/include/bgtaskmgr_inner_errors.h index c20f81a1406a55d44ebc3eafca980f1e22bbacb3..e183a03e1f4d04759261d29cd55a50cdfd5316ea 100644 --- a/frameworks/common/include/bgtaskmgr_inner_errors.h +++ b/frameworks/common/include/bgtaskmgr_inner_errors.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 @@ -49,12 +49,18 @@ enum : int32_t { ERR_BGTASK_KEEPING_TASK_VERIFY_ERR, ERR_BGTASK_INVALID_BGMODE, ERR_BGTASK_INVALID_UID, - ERR_BGTASK_CONTINUOUS_REQUESTINFO_NULL_OR_TYPE, - ERR_BGTASK_CONTINUOUS_INVALID_TASK_ID, - ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_NULL, + ERR_BGTASK_CONTINUOUS_REQUEST_NULL_OR_TYPE, + ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_IS_EMPTY, ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_LENGTH_MISMATCH, ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_CROSS_BORDER, ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_TYPE_MISMATCH, + ERR_BGTASK_CONTINUOUS_NOT_UPDATE_BY_OLD_INTERFACE, + ERR_BGTASK_CONTINUOUS_TASKID_INVALID, + ERR_BGTASK_CONTINUOUS_DATA_TRANSFER_NOT_MERGE_NOTIFICATION, + ERR_BGTASK_CONTINUOUS_NOT_MERGE_NOTIFICATION_NOT_EXIST, + ERR_BGTASK_CONTINUOUS_NOT_MERGE_COMBINED_FALSE, + ERR_BGTASK_CONTINUOUS_NOT_UPDATE_BECAUSE_MERGE, + ERR_BGTASK_CONTINUOUS_NOT_MERGE_CURRENTTASK_COMBINED_FALSE, ERR_BGTASK_NOTIFICATION_VERIFY_FAILED = 980000601, ERR_BGTASK_NOTIFICATION_ERR, ERR_BGTASK_CHECK_TASK_PARAM, diff --git a/frameworks/include/background_task_manager.h b/frameworks/include/background_task_manager.h index eb716adf9cc8968de02a1c5f8b10ffc2bda7dc7a..5c21c9ae7deba5132ece8e3ff1bfd88a4c2eb348 100644 --- a/frameworks/include/background_task_manager.h +++ b/frameworks/include/background_task_manager.h @@ -17,7 +17,7 @@ #define FOUNDATION_RESOURCESCHEDULE_BACKGROUND_TASK_MGR_FRAMEWORKS_INCLUDE_BACKGROUND_TASK_MANAGER_H #include "background_task_subscriber.h" -#include "continuous_task_request_info.h" +#include "continuous_task_request.h" #include "expired_callback.h" #include "ibackground_task_mgr.h" #include "iremote_object.h" @@ -267,13 +267,6 @@ public: */ ErrCode SuspendContinuousAudioTask(int32_t uid); - /** - * @brief Request create continuous task. - * @param requestInfo app uid. - * @return Returns ERR_OK if success, else failure. - */ - ErrCode CreateContinuousTaskRequest(const std::shared_ptr &requestInfo); - private: bool GetBackgroundTaskManagerProxy(); diff --git a/frameworks/src/background_task_manager.cpp b/frameworks/src/background_task_manager.cpp index ad67004f024e42e24bbdde5d10358800b6f9ae07..87a5b5aa4bee86f1fc27ea29f889f0d0274fba98 100644 --- a/frameworks/src/background_task_manager.cpp +++ b/frameworks/src/background_task_manager.cpp @@ -472,14 +472,6 @@ ErrCode BackgroundTaskManager::SuspendContinuousAudioTask(int32_t uid) return proxy_->SuspendContinuousAudioTask(uid); } -ErrCode BackgroundTaskManager::CreateContinuousTaskRequest( - const std::shared_ptr &requestInfo) -{ - std::lock_guard lock(mutex_); - GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN - return ERR_OK; -} - BackgroundTaskManager::BgTaskMgrDeathRecipient::BgTaskMgrDeathRecipient(BackgroundTaskManager &backgroundTaskManager) : backgroundTaskManager_(backgroundTaskManager) {} diff --git a/interfaces/innerkits/BUILD.gn b/interfaces/innerkits/BUILD.gn index c8268000eed3f5b65be67f37565813d95a10acbe..5779c5ae864948646bd7b2d1c2b31235459a8d58 100644 --- a/interfaces/innerkits/BUILD.gn +++ b/interfaces/innerkits/BUILD.gn @@ -65,7 +65,7 @@ ohos_shared_library("bgtaskmgr_innerkits") { "src/continuous_task_info.cpp", "src/continuous_task_mode.cpp", "src/continuous_task_param.cpp", - "src/continuous_task_request_info.cpp", + "src/continuous_task_request.cpp", "src/continuous_task_submode.cpp", "src/continuous_task_suspend_reason.cpp", "src/delay_suspend_info.cpp", diff --git a/interfaces/innerkits/IBackgroundTaskMgr.idl b/interfaces/innerkits/IBackgroundTaskMgr.idl index b935e422fbc60f78a126d2d39c59962c3109db19..c35e02aa3d68c342fe32ba41bf1845e52b0ed4be 100644 --- a/interfaces/innerkits/IBackgroundTaskMgr.idl +++ b/interfaces/innerkits/IBackgroundTaskMgr.idl @@ -17,6 +17,7 @@ sequenceable continuous_task_callback_info..OHOS.BackgroundTaskMgr.ContinuousTas sequenceable continuous_task_info..OHOS.BackgroundTaskMgr.ContinuousTaskInfo; sequenceable continuous_task_param..OHOS.BackgroundTaskMgr.ContinuousTaskParam; sequenceable continuous_task_param..OHOS.BackgroundTaskMgr.ContinuousTaskParamForInner; +sequenceable continuous_task_request..OHOS.BackgroundTaskMgr.ContinuousTaskRequest; sequenceable delay_suspend_info..OHOS.BackgroundTaskMgr.DelaySuspendInfo; sequenceable efficiency_resource_info..OHOS.BackgroundTaskMgr.EfficiencyResourceInfo; sequenceable resource_callback_info..OHOS.BackgroundTaskMgr.ResourceCallbackInfo; diff --git a/interfaces/innerkits/include/background_task_mgr_helper.h b/interfaces/innerkits/include/background_task_mgr_helper.h index f4e3510cfb5bc768fc13f5cd92c025251cc95255..826e5794fb99e5f1057a4db2c6a2d6d2b5eaee9c 100644 --- a/interfaces/innerkits/include/background_task_mgr_helper.h +++ b/interfaces/innerkits/include/background_task_mgr_helper.h @@ -19,7 +19,7 @@ #include "background_task_subscriber.h" #include "efficiency_resource_info.h" #include "bgtaskmgr_inner_errors.h" -#include "continuous_task_request_info.h" +#include "continuous_task_request.h" namespace OHOS { namespace BackgroundTaskMgr { @@ -211,12 +211,6 @@ public: */ static ErrCode SuspendContinuousAudioTask(int32_t uid); - /** - * @brief Request create continuous task. - * @param requestInfo app uid. - * @return Returns ERR_OK if success, else failure. - */ - static ErrCode CreateContinuousTaskRequest(const std::shared_ptr &requestInfo); }; } // namespace BackgroundTaskMgr } // namespace OHOS diff --git a/interfaces/innerkits/include/continuous_task_mode.h b/interfaces/innerkits/include/continuous_task_mode.h index b15a03129a6c244ac79ed06148aef570678cd7dd..8b53ce548a96dc89f349a9916807154611dd9101 100644 --- a/interfaces/innerkits/include/continuous_task_mode.h +++ b/interfaces/innerkits/include/continuous_task_mode.h @@ -35,8 +35,10 @@ public: }; static std::string GetContinuousTaskModeStr(uint32_t mode); - static bool IsSubModeTypeMatching(const uint32_t continuousTaskSubMode); + static uint32_t GetSubModeTypeMatching(const uint32_t continuousTaskSubMode); static bool IsModeTypeMatching(const uint32_t continuousTaskMode); + static uint32_t GetV9BackgroundModeByMode(const uint32_t continuousTaskMode); + static uint32_t GetV9BackgroundModeBySubMode(const uint32_t continuousTaskSubMode); }; } // namespace BackgroundTaskMgr } // namespace OHOS diff --git a/interfaces/innerkits/include/continuous_task_param.h b/interfaces/innerkits/include/continuous_task_param.h index ffc20be04d2ba5ea51d6aebdb47be25bfc3c097d..b0017bbe7bb2904af10ff780ffeec394a6916527 100644 --- a/interfaces/innerkits/include/continuous_task_param.h +++ b/interfaces/innerkits/include/continuous_task_param.h @@ -36,6 +36,10 @@ struct ContinuousTaskParam : public Parcelable { bool isBatchApi_ {false}; std::vector bgModeIds_ {}; int32_t abilityId_ {-1}; + std::vector bgSubModeIds_ {}; + bool isCombinedTaskNotification_ {false}; + int32_t combinedNotificationTaskId_ {-1}; + bool isByRequestObject_ {false}; int32_t notificationId_ {-1}; // out int32_t continuousTaskId_ {-1}; // out diff --git a/interfaces/innerkits/include/continuous_task_request_info.h b/interfaces/innerkits/include/continuous_task_request.h similarity index 83% rename from interfaces/innerkits/include/continuous_task_request_info.h rename to interfaces/innerkits/include/continuous_task_request.h index 00522e3de39bf8a65d19abb637f29a8c6dc8214c..113070ddec5cfd77ad2adb4d3979df6f1f8381d0 100644 --- a/interfaces/innerkits/include/continuous_task_request_info.h +++ b/interfaces/innerkits/include/continuous_task_request.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef FOUNDATION_RESOURCESCHEDULE_BACKGROUND_TASK_MGR_INTERFACES_INNERKITS_INCLUDE_CONTINUOUS_TASK_REQUEST_INFO_H -#define FOUNDATION_RESOURCESCHEDULE_BACKGROUND_TASK_MGR_INTERFACES_INNERKITS_INCLUDE_CONTINUOUS_TASK_REQUEST_INFO_H +#ifndef FOUNDATION_RESOURCESCHEDULE_BACKGROUND_TASK_MGR_INTERFACES_INNERKITS_INCLUDE_CONTINUOUS_TASK_REQUEST_H +#define FOUNDATION_RESOURCESCHEDULE_BACKGROUND_TASK_MGR_INTERFACES_INNERKITS_INCLUDE_CONTINUOUS_TASK_REQUEST_H #include @@ -23,10 +23,10 @@ namespace OHOS { namespace BackgroundTaskMgr { -class ContinuousTaskRequestInfo : public std::enable_shared_from_this, public Parcelable { +class ContinuousTaskRequest : public std::enable_shared_from_this, public Parcelable { public: - ~ContinuousTaskRequestInfo() = default; - ContinuousTaskRequestInfo(const std::vector &continuousTaskModes = {}, + ~ContinuousTaskRequest() = default; + ContinuousTaskRequest(const std::vector &continuousTaskModes = {}, const std::vector &continuousTaskSubmodes = {}, const std::shared_ptr wantAgent = nullptr, bool combinedTaskNotification = false, int32_t continuousTaskId = -1, bool isBuildByRequest = false) @@ -39,7 +39,7 @@ public: * @param in Indicates the parcel object for unmarshalling. * @return The info continuous task request. */ - static ContinuousTaskRequestInfo* Unmarshalling(Parcel& in); + static ContinuousTaskRequest* Unmarshalling(Parcel& in); /** * @brief Marshals a purpose into a parcel. @@ -93,9 +93,10 @@ public: void SetContinuousTaskId(const int32_t continuousTaskId); void SetCombinedTaskNotification(const bool combinedTaskNotification); - void AddContinuousTaskMode(const uint32_t mode); - void AddContinuousTaskSubMode(const int32_t subMode); void SetWantAgent(const std::shared_ptr wantAgent); + bool IsCombinedTaskNotification() const; + void SetContinuousTaskMode(const std::vector &continuousTaskMode); + void SetContinuousTaskSubMode(const std::vector &continuousTaskSubMode); private: bool ReadFromParcel(Parcel& in); @@ -108,4 +109,4 @@ private: }; } // namespace BackgroundTaskMgr } // namespace OHOS -#endif // FOUNDATION_RESOURCESCHEDULE_BACKGROUND_TASK_MGR_INTERFACES_INNERKITS_INCLUDE_CONTINUOUS_TASK_REQUEST_INFO_H \ No newline at end of file +#endif // FOUNDATION_RESOURCESCHEDULE_BACKGROUND_TASK_MGR_INTERFACES_INNERKITS_INCLUDE_CONTINUOUS_TASK_REQUEST_H \ No newline at end of file diff --git a/interfaces/innerkits/libbgtaskmgr_innerkits.versionscript b/interfaces/innerkits/libbgtaskmgr_innerkits.versionscript index 0ecb69c8c15383f47cc7b8e73f01405b51bba3ef..ba0286f34d723184f33e784174a32a709860be51 100644 --- a/interfaces/innerkits/libbgtaskmgr_innerkits.versionscript +++ b/interfaces/innerkits/libbgtaskmgr_innerkits.versionscript @@ -21,7 +21,7 @@ *ContinuousTaskInfo*; *ContinuousTaskMode*; *ContinuousTaskParam*; - *ContinuousTaskRequestInfo*; + *ContinuousTaskRequest*; *ContinuousTaskSubmode*; *ContinuousTaskSuspendReason*; *DelaySuspendInfo*; diff --git a/interfaces/innerkits/src/background_task_mgr_helper.cpp b/interfaces/innerkits/src/background_task_mgr_helper.cpp index e3b52440c3bc13927108e40360488b00513d3da8..f0559bfd7a080b79506f36aabd917b7f51397ce8 100644 --- a/interfaces/innerkits/src/background_task_mgr_helper.cpp +++ b/interfaces/innerkits/src/background_task_mgr_helper.cpp @@ -139,11 +139,5 @@ ErrCode BackgroundTaskMgrHelper::SuspendContinuousAudioTask(int32_t uid) { return DelayedSingleton::GetInstance()->SuspendContinuousAudioTask(uid); } - -ErrCode BackgroundTaskMgrHelper::CreateContinuousTaskRequest( - const std::shared_ptr &requestInfo) -{ - return DelayedSingleton::GetInstance()->CreateContinuousTaskRequest(requestInfo); -} } // namespace BackgroundTaskMgr } // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/src/continuous_task_mode.cpp b/interfaces/innerkits/src/continuous_task_mode.cpp index 54cc19a76e783bfe870e66a6076b07cbb085ff12..04aaad3d402075a3d8c6c008e2db4ff4dc57f756 100644 --- a/interfaces/innerkits/src/continuous_task_mode.cpp +++ b/interfaces/innerkits/src/continuous_task_mode.cpp @@ -50,6 +50,23 @@ const std::unordered_map PARAM_CONTINUOUS_TASK_SUBMODE_CORRE {ContinuousTaskMode::MODE_TASK_KEEPING, ContinuousTaskSubmode::SUBMODE_NORMAL_NOTIFICATION} }; +const std::unordered_map PARAM_CONTINUOUS_TASK_V9MODE_CORRESPONDENCE_V21MODE = { + {ContinuousTaskMode::MODE_SHARE_POSITION, BackgroundMode::LOCATION}, + {ContinuousTaskMode::MODE_ALLOW_BLUETOOTH_AWARE, BackgroundMode::BLUETOOTH_INTERACTION}, + {ContinuousTaskMode::MODE_MULTI_DEVICE_CONNECTION, BackgroundMode::MULTI_DEVICE_CONNECTION}, + {ContinuousTaskMode::MODE_ALLOW_WIFI_AWARE, BackgroundMode::WIFI_INTERACTION}, + {ContinuousTaskMode::MODE_TASK_KEEPING, BackgroundMode::TASK_KEEPING}, +}; + +const std::unordered_map PARAM_CONTINUOUS_TASK_V9MODE_CORRESPONDENCE_V21SUBMODE = { + {ContinuousTaskSubmode::SUBMODE_LIVE_VIEW_NOTIFICATION, BackgroundMode::DATA_TRANSFER}, + {ContinuousTaskSubmode::SUBMODE_CAR_KEY_NORMAL_NOTIFICATION, BackgroundMode::BLUETOOTH_INTERACTION}, + {ContinuousTaskSubmode::SUBMODE_AUDIO_PLAYBACK_NORMAL_NOTIFICATION, BackgroundMode::AUDIO_PLAYBACK}, + {ContinuousTaskSubmode::SUBMODE_AVSESSION_AUDIO_PLAYBACK, BackgroundMode::AUDIO_PLAYBACK}, + {ContinuousTaskSubmode::SUBMODE_AUDIO_RECORD_NORMAL_NOTIFICATION, BackgroundMode::AUDIO_RECORDING}, + {ContinuousTaskSubmode::SUBMODE_VOICE_CHAT_NORMAL_NOTIFICATION, BackgroundMode::VOIP}, +}; + std::string ContinuousTaskMode::GetContinuousTaskModeStr(uint32_t mode) { auto iter = PARAM_CONTINUOUS_TASK_MODE_STR_MAP.find(mode); @@ -59,10 +76,14 @@ std::string ContinuousTaskMode::GetContinuousTaskModeStr(uint32_t mode) return "default"; } -bool ContinuousTaskMode::IsSubModeTypeMatching(const uint32_t continuousTaskSubMode) +uint32_t ContinuousTaskMode::GetSubModeTypeMatching(const uint32_t continuousTaskSubMode) { auto iter = PARAM_CONTINUOUS_TASK_MODE_CORRESPONDENCE_SUBMODE.find(continuousTaskSubMode); - return iter != PARAM_CONTINUOUS_TASK_MODE_CORRESPONDENCE_SUBMODE.end(); + if (iter != PARAM_CONTINUOUS_TASK_MODE_CORRESPONDENCE_SUBMODE.end()) { + return iter->second; + } else { + return ContinuousTaskMode::END; + } } bool ContinuousTaskMode::IsModeTypeMatching(const uint32_t continuousTaskMode) @@ -70,5 +91,25 @@ bool ContinuousTaskMode::IsModeTypeMatching(const uint32_t continuousTaskMode) auto iter = PARAM_CONTINUOUS_TASK_SUBMODE_CORRESPONDENCE_MODE.find(continuousTaskMode); return iter != PARAM_CONTINUOUS_TASK_SUBMODE_CORRESPONDENCE_MODE.end(); } + +uint32_t ContinuousTaskMode::GetV9BackgroundModeByMode(const uint32_t continuousTaskMode) +{ + auto iter = PARAM_CONTINUOUS_TASK_V9MODE_CORRESPONDENCE_V21MODE.find(continuousTaskMode); + if (iter != PARAM_CONTINUOUS_TASK_V9MODE_CORRESPONDENCE_V21MODE.end()) { + return iter->second; + } else { + return BackgroundMode::END; + } +} + +uint32_t ContinuousTaskMode::GetV9BackgroundModeBySubMode(const uint32_t continuousTaskSubMode) +{ + auto iter = PARAM_CONTINUOUS_TASK_V9MODE_CORRESPONDENCE_V21SUBMODE.find(continuousTaskSubMode); + if (iter != PARAM_CONTINUOUS_TASK_V9MODE_CORRESPONDENCE_V21SUBMODE.end()) { + return iter->second; + } else { + return BackgroundMode::END; + } +} } // namespace BackgroundTaskMgr } // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/src/continuous_task_param.cpp b/interfaces/innerkits/src/continuous_task_param.cpp index efc0c8ebf5ac89a197788f6b939609a07b7aca69..2b43494bf05c83293eedc56292e592b253b3c511 100644 --- a/interfaces/innerkits/src/continuous_task_param.cpp +++ b/interfaces/innerkits/src/continuous_task_param.cpp @@ -93,6 +93,18 @@ bool ContinuousTaskParam::ReadFromParcel(Parcel &parcel) BGTASK_LOGE("Failed to read the abilityId"); return false; } + if (!parcel.ReadUInt32Vector(&bgSubModeIds_)) { + return false; + } + if (!parcel.ReadBool(isCombinedTaskNotification_)) { + return false; + } + if (!parcel.ReadInt32(combinedNotificationTaskId_)) { + return false; + } + if (!parcel.ReadBool(isByRequestObject_)) { + return false; + } return true; } @@ -202,6 +214,18 @@ bool ContinuousTaskParam::Marshalling(Parcel &parcel) const BGTASK_LOGE("Failed to write the abilityId"); return false; } + if (!parcel.WriteUInt32Vector(bgSubModeIds_)) { + return false; + } + if (!parcel.WriteBool(isCombinedTaskNotification_)) { + return false; + } + if (!parcel.WriteInt32(combinedNotificationTaskId_)) { + return false; + } + if (!parcel.WriteBool(isByRequestObject_)) { + return false; + } return true; } diff --git a/interfaces/innerkits/src/continuous_task_request_info.cpp b/interfaces/innerkits/src/continuous_task_request.cpp similarity index 73% rename from interfaces/innerkits/src/continuous_task_request_info.cpp rename to interfaces/innerkits/src/continuous_task_request.cpp index 40a8cac822def088f06b275a163e30b88ed2fb80..6983650f0eecf14de1cac3387b04db2763cbef4f 100644 --- a/interfaces/innerkits/src/continuous_task_request_info.cpp +++ b/interfaces/innerkits/src/continuous_task_request.cpp @@ -13,15 +13,15 @@ * limitations under the License. */ -#include "continuous_task_request_info.h" +#include "continuous_task_request.h" #include "continuous_task_log.h" namespace OHOS { namespace BackgroundTaskMgr { -ContinuousTaskRequestInfo* ContinuousTaskRequestInfo::Unmarshalling(Parcel& in) +ContinuousTaskRequest* ContinuousTaskRequest::Unmarshalling(Parcel& in) { - ContinuousTaskRequestInfo* info = new (std::nothrow) ContinuousTaskRequestInfo(); + ContinuousTaskRequest* info = new (std::nothrow) ContinuousTaskRequest(); if (info && !info->ReadFromParcel(in)) { BGTASK_LOGE("read from parcel failed"); delete info; @@ -30,7 +30,7 @@ ContinuousTaskRequestInfo* ContinuousTaskRequestInfo::Unmarshalling(Parcel& in) return info; } -bool ContinuousTaskRequestInfo::Marshalling(Parcel& out) const +bool ContinuousTaskRequest::Marshalling(Parcel& out) const { if (!out.WriteUInt32Vector(continuousTaskModes_)) { BGTASK_LOGE("Failed to write continuousTaskModes"); @@ -66,7 +66,7 @@ bool ContinuousTaskRequestInfo::Marshalling(Parcel& out) const return true; } -bool ContinuousTaskRequestInfo::ReadFromParcel(Parcel& in) +bool ContinuousTaskRequest::ReadFromParcel(Parcel& in) { if (!in.ReadUInt32Vector(&continuousTaskModes_)) { BGTASK_LOGE("read parcel continuousTaskModes error"); @@ -100,60 +100,65 @@ bool ContinuousTaskRequestInfo::ReadFromParcel(Parcel& in) return true; } -std::shared_ptr ContinuousTaskRequestInfo::GetWantAgent() const +std::shared_ptr ContinuousTaskRequest::GetWantAgent() const { return wantAgent_; } -std::vector ContinuousTaskRequestInfo::GetContinuousTaskModes() const +std::vector ContinuousTaskRequest::GetContinuousTaskModes() const { return continuousTaskModes_; } -std::vector ContinuousTaskRequestInfo::GetContinuousTaskSubmodes() const +std::vector ContinuousTaskRequest::GetContinuousTaskSubmodes() const { return continuousTaskSubmodes_; } -bool ContinuousTaskRequestInfo::IsBuildByRequest() const +bool ContinuousTaskRequest::IsBuildByRequest() const { return isBuildByRequest_; } -void ContinuousTaskRequestInfo::SetIsBuildByRequest(bool isBuildByRequest) +void ContinuousTaskRequest::SetIsBuildByRequest(bool isBuildByRequest) { isBuildByRequest_ = isBuildByRequest; } -int32_t ContinuousTaskRequestInfo::GetContinuousTaskId() const +int32_t ContinuousTaskRequest::GetContinuousTaskId() const { return continuousTaskId_; } -void ContinuousTaskRequestInfo::SetContinuousTaskId(const int32_t continuousTaskId) +void ContinuousTaskRequest::SetContinuousTaskId(const int32_t continuousTaskId) { continuousTaskId_ = continuousTaskId; } -void ContinuousTaskRequestInfo::SetCombinedTaskNotification(const bool combinedTaskNotification) +void ContinuousTaskRequest::SetCombinedTaskNotification(const bool combinedTaskNotification) { combinedTaskNotification_ = combinedTaskNotification; } -void ContinuousTaskRequestInfo::AddContinuousTaskMode(const uint32_t mode) +bool ContinuousTaskRequest::IsCombinedTaskNotification() const { - continuousTaskModes_.push_back(mode); + return combinedTaskNotification_; } -void ContinuousTaskRequestInfo::AddContinuousTaskSubMode(const int32_t subMode) +void ContinuousTaskRequest::SetWantAgent( + const std::shared_ptr wantAgent) { - continuousTaskSubmodes_.push_back(subMode); + wantAgent_ = wantAgent; } -void ContinuousTaskRequestInfo::SetWantAgent( - const std::shared_ptr wantAgent) +void ContinuousTaskRequest::SetContinuousTaskMode(const std::vector &continuousTaskMode) { - wantAgent_ = wantAgent; + continuousTaskModes_ = continuousTaskMode; +} + +void ContinuousTaskRequest::SetContinuousTaskSubMode(const std::vector &continuousTaskSubMode) +{ + continuousTaskSubmodes_ = continuousTaskSubMode; } } // namespace BackgroundTaskMgr } // namespace OHOS \ No newline at end of file diff --git a/interfaces/kits/napi/include/bg_continuous_task_napi_module.h b/interfaces/kits/napi/include/bg_continuous_task_napi_module.h index d587e737e09cee80fa938d060f7054df4aecf244..bb1cb612a7398726911b9fe895816721d1242802 100644 --- a/interfaces/kits/napi/include/bg_continuous_task_napi_module.h +++ b/interfaces/kits/napi/include/bg_continuous_task_napi_module.h @@ -29,7 +29,6 @@ napi_value StopBackgroundRunningThrow(napi_env env, napi_callback_info info); napi_value OnOnContinuousTaskCallback(napi_env env, napi_callback_info info); napi_value OffOnContinuousTaskCallback(napi_env env, napi_callback_info info); napi_value GetAllContinuousTasksThrow(napi_env env, napi_callback_info info); -napi_value CreateContinuousTaskRequestThrow(napi_env env, napi_callback_info info); } // namespace BackgroundTaskMgr } // namespace OHOS #endif // FOUNDATION_RESOURCESCHEDULE_BACKGROUND_TASK_MGR_INTERFACES_KITS_NAPI_INCLUDE_CANCEL_SUSPEND_DELAY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/common.h b/interfaces/kits/napi/include/common.h index 70c36fc9d679d03e7da7988fb2a745d1bc907fb4..57da680bff03e2fe4a8451ecdfd9735ef7a68a80 100644 --- a/interfaces/kits/napi/include/common.h +++ b/interfaces/kits/napi/include/common.h @@ -24,7 +24,7 @@ #include "bgtaskmgr_inner_errors.h" #include "continuous_task_info.h" -#include "continuous_task_request_info.h" +#include "continuous_task_request.h" #include "delay_suspend_info.h" #include "efficiency_resource_info.h" #include "js_runtime_utils.h" @@ -110,24 +110,24 @@ public: static napi_value GetNapiEfficiencyResourcesInfo(const napi_env &env, std::shared_ptr efficiencyResourceInfo); - static napi_value WrapWantAgentContinuousTask(napi_env env, AbilityRuntime::WantAgent::WantAgent *wantAgent, - napi_finalize finalizeCb); - static bool GetContinuousTaskRequestInfo(napi_env env, napi_value objValue, - std::shared_ptr &requestInfo); + static void TaskModeTypeConversion(std::shared_ptr &request); + + static bool GetContinuousTaskRequest(napi_env env, napi_value objValue, + std::shared_ptr &request); static int32_t GetIntProperty(napi_env env, napi_value object, const std::string &propertyName); static bool GetBoolProperty(napi_env env, napi_value object, const std::string &propertyName); static bool GetContinuousTaskModesProperty(napi_env env, napi_value object, const std::string &propertyName, - std::shared_ptr &requestInfo); + std::shared_ptr &request); static bool GetContinuousTaskSubmodesProperty(napi_env env, napi_value object, const std::string &propertyName, - std::shared_ptr &requestInfo); + std::shared_ptr &request); static bool GetWantAgentProperty(napi_env env, napi_value object, const std::string &propertyName, - std::shared_ptr &requestInfo); + std::shared_ptr &request); }; } // namespace BackgroundTaskMgr } // namespace OHOS 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 9d187d7ab6963945e69110caffebc7761ad56e91..1c90be193b3886509b1d18aa974bb39cf57a5fd5 100644 --- a/interfaces/kits/napi/src/bg_continuous_task_napi_module.cpp +++ b/interfaces/kits/napi/src/bg_continuous_task_napi_module.cpp @@ -34,7 +34,7 @@ #include "continuous_task_log.h" #include "continuous_task_mode.h" #include "continuous_task_param.h" -#include "continuous_task_request_info.h" +#include "continuous_task_request.h" #include "continuous_task_submode.h" #include "js_backgroundtask_subscriber.h" #include "js_runtime_utils.h" @@ -43,6 +43,7 @@ namespace OHOS { namespace BackgroundTaskMgr { namespace { static constexpr uint32_t MAX_START_BG_RUNNING_PARAMS = 4; +static constexpr uint32_t MAX_START_BG_RUNNING_BY_RQUEST_PARAMS = 2; static constexpr uint32_t MAX_STOP_BG_RUNNING_PARAMS = 2; static constexpr uint32_t MAX_UPDATE_BG_RUNNING_PARAMS = 2; static constexpr uint32_t MAX_GET_ALL_CONTINUOUSTASK_PARAMS = 2; @@ -86,17 +87,13 @@ struct AsyncCallbackInfo : public AsyncWorkData { std::vector bgModes {}; bool isBatchApi {false}; bool includeSuspended {false}; + std::shared_ptr request = std::make_shared(); + int32_t removeTaskId {-1}; // in int32_t notificationId {-1}; // out int32_t continuousTaskId {-1}; // out std::vector> list; // out }; -struct CreateContinuousTaskRequestCallbackInfo : public AsyncWorkData { - explicit CreateContinuousTaskRequestCallbackInfo(napi_env env) : AsyncWorkData(env) {} - std::shared_ptr abilityContext {nullptr}; - std::shared_ptr requestInfo = std::make_shared(); -}; - napi_value WrapVoidToJS(napi_env env) { napi_value result = nullptr; @@ -244,6 +241,30 @@ void UpdateBackgroundRunningExecuteCB(napi_env env, void *data) taskParam.continuousTaskId_); } +void UpdateBackgroundRunningByRequestExecuteCB(napi_env env, void *data) +{ + AsyncCallbackInfo *asyncCallbackInfo = static_cast(data); + if (asyncCallbackInfo == nullptr || asyncCallbackInfo->errCode != ERR_OK || + asyncCallbackInfo->request == nullptr) { + BGTASK_LOGE("input params error"); + return; + } + Common::TaskModeTypeConversion(asyncCallbackInfo->request); + std::vector continuousTaskModes = asyncCallbackInfo->request->GetContinuousTaskModes(); + const std::shared_ptr info = asyncCallbackInfo->abilityContext->GetAbilityInfo(); + ContinuousTaskParam taskParam = ContinuousTaskParam(true, continuousTaskModes[0], + asyncCallbackInfo->request->GetWantAgent(), info->name, asyncCallbackInfo->abilityContext->GetToken(), + "", true, continuousTaskModes, asyncCallbackInfo->abilityContext->GetAbilityRecordId()); + taskParam.isByRequestObject_ = true; + taskParam.isCombinedTaskNotification_ = asyncCallbackInfo->request->IsCombinedTaskNotification(); + taskParam.combinedNotificationTaskId_ = asyncCallbackInfo->request->GetContinuousTaskId(); + taskParam.bgSubModeIds_ = asyncCallbackInfo->request->GetContinuousTaskSubmodes(); + asyncCallbackInfo->errCode = BackgroundTaskMgrHelper::RequestUpdateBackgroundRunning(taskParam); + asyncCallbackInfo->bgModes = continuousTaskModes; + asyncCallbackInfo->notificationId = taskParam.notificationId_; + asyncCallbackInfo->continuousTaskId = taskParam.continuousTaskId_; +} + void StartBackgroundRunningExecuteCB(napi_env env, void *data) { HitraceScoped traceScoped(HITRACE_TAG_OHOS, @@ -398,6 +419,32 @@ napi_value UpdateBackgroundRunningPromise(napi_env env, AsyncCallbackInfo *async return promise; } +napi_value UpdateBackgroundRunningByRequestPromise(napi_env env, AsyncCallbackInfo *asyncCallbackInfo, bool isThrow) +{ + if (asyncCallbackInfo == nullptr) { + BGTASK_LOGE("param is nullptr"); + return nullptr; + } + if (!CheckBackgroundMode(env, asyncCallbackInfo, isThrow)) { + return nullptr; + } + napi_value resourceName; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + napi_deferred deferred; + napi_value promise {nullptr}; + NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); + asyncCallbackInfo->deferred = deferred; + NAPI_CALL(env, napi_create_async_work(env, + nullptr, + resourceName, + UpdateBackgroundRunningByRequestExecuteCB, + PromiseCompletedCB, + static_cast(asyncCallbackInfo), + &asyncCallbackInfo->asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork)); + return promise; +} + napi_value StartBackgroundRunningPromise(napi_env env, AsyncCallbackInfo *asyncCallbackInfo, bool isThrow) { if (asyncCallbackInfo == nullptr) { @@ -582,6 +629,63 @@ bool StartBackgroundRunningCheckParamBeforeSubmit(napi_env env, napi_value *argv return true; } +bool StartBackgroundRunningCheckRequest(napi_env env, napi_value *argv, bool isThrow, + AsyncCallbackInfo *asyncCallbackInfo) +{ + if (GetAbilityContext(env, argv[0], asyncCallbackInfo->abilityContext) == nullptr) { + BGTASK_LOGE("Get ability context failed"); + Common::HandleParamErr(env, ERR_CONTEXT_NULL_OR_TYPE_ERR, isThrow); + asyncCallbackInfo->errCode = ERR_CONTEXT_NULL_OR_TYPE_ERR; + return false; + } + const std::shared_ptr info = asyncCallbackInfo->abilityContext->GetAbilityInfo(); + if (info == nullptr) { + BGTASK_LOGE("abilityInfo is null"); + Common::HandleParamErr(env, ERR_ABILITY_INFO_EMPTY, isThrow); + asyncCallbackInfo->errCode = ERR_ABILITY_INFO_EMPTY; + return false; + } + if (!Common::GetContinuousTaskRequest(env, argv[1], asyncCallbackInfo->request)) { + Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_REQUEST_NULL_OR_TYPE, true); + asyncCallbackInfo->errCode = ERR_BGTASK_CONTINUOUS_REQUEST_NULL_OR_TYPE; + return false; + } + std::vector continuousTaskModes = asyncCallbackInfo->request->GetContinuousTaskModes(); + std::vector continuousTaskSubmodes = asyncCallbackInfo->request->GetContinuousTaskSubmodes(); + if (continuousTaskModes.size() == 0 || continuousTaskSubmodes.size() == 0) { + Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_IS_EMPTY, true); + asyncCallbackInfo->errCode = ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_IS_EMPTY; + return false; + } + if (continuousTaskModes.size() != continuousTaskSubmodes.size()) { + Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_LENGTH_MISMATCH, true); + asyncCallbackInfo->errCode = ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_LENGTH_MISMATCH; + return false; + } + for (uint32_t index = 0; index < continuousTaskSubmodes.size(); index++) { + uint32_t subMode = continuousTaskSubmodes[index]; + if (subMode >= ContinuousTaskSubmode::END || + subMode < ContinuousTaskSubmode::SUBMODE_CAR_KEY_NORMAL_NOTIFICATION) { + Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_CROSS_BORDER, true); + asyncCallbackInfo->errCode = ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_CROSS_BORDER; + return false; + } + if (subMode == ContinuousTaskSubmode::SUBMODE_NORMAL_NOTIFICATION) { + if (!ContinuousTaskMode::IsModeTypeMatching(continuousTaskModes[index])) { + Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_TYPE_MISMATCH, true); + asyncCallbackInfo->errCode = ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_TYPE_MISMATCH; + return false; + } + } else { + if (ContinuousTaskMode::GetSubModeTypeMatching(subMode) != continuousTaskModes[index]) { + Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_TYPE_MISMATCH, true); + asyncCallbackInfo->errCode = ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_TYPE_MISMATCH; + return false; + } + } + } + return true; +} napi_value UpdateBackgroundRunning(napi_env env, napi_callback_info info, bool isThrow) { @@ -603,25 +707,30 @@ napi_value UpdateBackgroundRunning(napi_env env, napi_callback_info info, bool i Common::HandleParamErr(env, ERR_PARAM_NUMBER_ERR, isThrow); return WrapVoidToJS(env); } + bool isArray = false; + napi_value value = argv[1]; + napi_is_array(env, value, &isArray); + napi_value ret {nullptr}; + if (isArray) { + // argv[0] : context : AbilityContext + if (GetAbilityContext(env, argv[0], asyncCallbackInfo->abilityContext) == nullptr) { + BGTASK_LOGE("Get ability context failed"); + Common::HandleParamErr(env, ERR_CONTEXT_NULL_OR_TYPE_ERR, isThrow); + asyncCallbackInfo->errCode = ERR_CONTEXT_NULL_OR_TYPE_ERR; + return WrapVoidToJS(env); + } - // argv[0] : context : AbilityContext - if (GetAbilityContext(env, argv[0], asyncCallbackInfo->abilityContext) == nullptr) { - BGTASK_LOGE("Get ability context failed"); - Common::HandleParamErr(env, ERR_CONTEXT_NULL_OR_TYPE_ERR, isThrow); - asyncCallbackInfo->errCode = ERR_CONTEXT_NULL_OR_TYPE_ERR; - return WrapVoidToJS(env); - } - - // argv[1] : bgMode : BackgroundMode - if (GetBackgroundMode(env, argv[1], asyncCallbackInfo) == nullptr) { - BGTASK_LOGE("input bgmode param not number"); - Common::HandleParamErr(env, ERR_BGMODE_NULL_OR_TYPE_ERR, isThrow); - asyncCallbackInfo->errCode = ERR_BGMODE_NULL_OR_TYPE_ERR; - return WrapVoidToJS(env); + // argv[1] : bgMode : BackgroundMode + if (GetBackgroundMode(env, argv[1], asyncCallbackInfo) == nullptr) { + BGTASK_LOGE("input bgmode param not number"); + Common::HandleParamErr(env, ERR_BGMODE_NULL_OR_TYPE_ERR, isThrow); + asyncCallbackInfo->errCode = ERR_BGMODE_NULL_OR_TYPE_ERR; + return WrapVoidToJS(env); + } + ret = UpdateBackgroundRunningPromise(env, asyncCallbackInfo, isThrow); + } else { + BGTASK_LOGE("UpdateBackgroundRunningByRequestPromise"); } - - napi_value ret {nullptr}; - ret = UpdateBackgroundRunningPromise(env, asyncCallbackInfo, isThrow); callbackPtr.release(); if (ret == nullptr) { BGTASK_LOGE("ret is nullpter"); @@ -634,6 +743,53 @@ napi_value UpdateBackgroundRunning(napi_env env, napi_callback_info info, bool i return ret; } +void StartBackgroundRunningByRequestExecuteCB(napi_env env, void *data) +{ + AsyncCallbackInfo *asyncCallbackInfo = static_cast(data); + if (asyncCallbackInfo == nullptr || asyncCallbackInfo->errCode != ERR_OK || + asyncCallbackInfo->request == nullptr) { + BGTASK_LOGE("input params error"); + return; + } + Common::TaskModeTypeConversion(asyncCallbackInfo->request); + std::vector continuousTaskModes = asyncCallbackInfo->request->GetContinuousTaskModes(); + const std::shared_ptr info = asyncCallbackInfo->abilityContext->GetAbilityInfo(); + ContinuousTaskParam taskParam = ContinuousTaskParam(true, continuousTaskModes[0], + asyncCallbackInfo->request->GetWantAgent(), info->name, asyncCallbackInfo->abilityContext->GetToken(), + "", true, continuousTaskModes, asyncCallbackInfo->abilityContext->GetAbilityRecordId()); + taskParam.isByRequestObject_ = true; + taskParam.isCombinedTaskNotification_ = asyncCallbackInfo->request->IsCombinedTaskNotification(); + taskParam.combinedNotificationTaskId_ = asyncCallbackInfo->request->GetContinuousTaskId(); + taskParam.bgSubModeIds_ = asyncCallbackInfo->request->GetContinuousTaskSubmodes(); + asyncCallbackInfo->errCode = BackgroundTaskMgrHelper::RequestStartBackgroundRunning(taskParam); + asyncCallbackInfo->bgModes = continuousTaskModes; + asyncCallbackInfo->notificationId = taskParam.notificationId_; + asyncCallbackInfo->continuousTaskId = taskParam.continuousTaskId_; +} + +napi_value StartBackgroundRunningByRequestPromise(napi_env env, AsyncCallbackInfo *asyncCallbackInfo, bool isThrow) +{ + if (asyncCallbackInfo == nullptr) { + BGTASK_LOGE("param is nullptr"); + return nullptr; + } + napi_value resourceName; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + napi_deferred deferred; + napi_value promise {nullptr}; + NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); + asyncCallbackInfo->deferred = deferred; + NAPI_CALL(env, napi_create_async_work(env, + nullptr, + resourceName, + StartBackgroundRunningByRequestExecuteCB, + PromiseCompletedCB, + static_cast(asyncCallbackInfo), + &asyncCallbackInfo->asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork)); + return promise; +} + napi_value StartBackgroundRunning(napi_env env, napi_callback_info info, bool isThrow) { HitraceScoped traceScoped(HITRACE_TAG_OHOS, @@ -654,19 +810,29 @@ napi_value StartBackgroundRunning(napi_env env, napi_callback_info info, bool is Common::HandleParamErr(env, ERR_PARAM_NUMBER_ERR, isThrow); return WrapVoidToJS(env); } - - if (!StartBackgroundRunningCheckParamBeforeSubmit(env, argv, MAX_START_BG_RUNNING_PARAMS, isThrow, - asyncCallbackInfo)) { - BGTASK_LOGE("failed to check parameters before start bgtask running."); - return WrapVoidToJS(env); - } - napi_value ret {nullptr}; - - if (argc == MAX_START_BG_RUNNING_PARAMS) { - ret = StartBackgroundRunningAsync(env, argv, MAX_START_BG_RUNNING_PARAMS - 1, asyncCallbackInfo, isThrow); + if (MAX_START_BG_RUNNING_BY_RQUEST_PARAMS == argc) { + if (!StartBackgroundRunningCheckRequest(env, argv, isThrow, asyncCallbackInfo)) { + callbackPtr.release(); + if (asyncCallbackInfo != nullptr) { + delete asyncCallbackInfo; + asyncCallbackInfo = nullptr; + } + return WrapVoidToJS(env); + } else { + ret = StartBackgroundRunningByRequestPromise(env, asyncCallbackInfo, isThrow); + } } else { - ret = StartBackgroundRunningPromise(env, asyncCallbackInfo, isThrow); + if (!StartBackgroundRunningCheckParamBeforeSubmit(env, argv, MAX_START_BG_RUNNING_PARAMS, isThrow, + asyncCallbackInfo)) { + BGTASK_LOGE("failed to check parameters before start bgtask running."); + return WrapVoidToJS(env); + } + if (argc == MAX_START_BG_RUNNING_PARAMS) { + ret = StartBackgroundRunningAsync(env, argv, MAX_START_BG_RUNNING_PARAMS - 1, asyncCallbackInfo, isThrow); + } else { + ret = StartBackgroundRunningPromise(env, asyncCallbackInfo, isThrow); + } } callbackPtr.release(); if (ret == nullptr) { @@ -789,6 +955,49 @@ napi_value StopBackgroundRunningPromise(napi_env env, AsyncCallbackInfo *asyncCa return promise; } +void StopBackgroundRunningByTaskIdExecuteCB(napi_env env, void *data) +{ + AsyncCallbackInfo *asyncCallbackInfo = static_cast(data); + if (asyncCallbackInfo == nullptr || asyncCallbackInfo->errCode != ERR_OK) { + BGTASK_LOGE("input param error"); + return; + } + const std::shared_ptr info = asyncCallbackInfo->abilityContext->GetAbilityInfo(); + sptr token = asyncCallbackInfo->abilityContext->GetToken(); + int32_t abilityId = asyncCallbackInfo->abilityContext->GetAbilityRecordId(); + int32_t continuousTaskId = asyncCallbackInfo->removeTaskId; + asyncCallbackInfo->errCode = BackgroundTaskMgrHelper::RequestStopBackgroundRunning(info->name, token, abilityId, + continuousTaskId); +} + +napi_value StopBackgroundRunningByTaskIdPromise(napi_env env, AsyncCallbackInfo *asyncCallbackInfo, bool isThrow) +{ + if (asyncCallbackInfo == nullptr) { + BGTASK_LOGE("param is nullptr"); + return nullptr; + } + napi_value resourceName {nullptr}; + napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName); + napi_deferred deferred; + napi_value promise {nullptr}; + napi_create_promise(env, &deferred, &promise); + + asyncCallbackInfo->deferred = deferred; + if (!StopBackgroundRunningCheckParam(env, asyncCallbackInfo, isThrow) && isThrow) { + return nullptr; + } + napi_create_async_work( + env, + nullptr, + resourceName, + StopBackgroundRunningByTaskIdExecuteCB, + PromiseCompletedCB, + static_cast(asyncCallbackInfo), + &asyncCallbackInfo->asyncWork); + napi_queue_async_work(env, asyncCallbackInfo->asyncWork); + return promise; +} + napi_value StopBackgroundRunning(napi_env env, napi_callback_info info, bool isThrow) { HitraceScoped traceScoped(HITRACE_TAG_OHOS, @@ -821,7 +1030,22 @@ napi_value StopBackgroundRunning(napi_env env, napi_callback_info info, bool isT napi_value ret {nullptr}; if (argc == MAX_STOP_BG_RUNNING_PARAMS) { - ret = StopBackgroundRunningAsync(env, argv, MAX_STOP_BG_RUNNING_PARAMS - 1, asyncCallbackInfo, isThrow); + napi_valuetype valueType = napi_undefined; + napi_value value = argv[1]; + napi_typeof(env, value, &valueType); + if (valueType == napi_number) { + int32_t taskIdValue = -1; + napi_get_value_int32(env, value, &taskIdValue); + if (taskIdValue < 0) { + Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_TASKID_INVALID, true); + asyncCallbackInfo->errCode = ERR_BGTASK_CONTINUOUS_TASKID_INVALID; + } else { + asyncCallbackInfo->removeTaskId = taskIdValue; + ret = StopBackgroundRunningByTaskIdPromise(env, asyncCallbackInfo, isThrow); + } + } else { + ret = StopBackgroundRunningAsync(env, argv, MAX_STOP_BG_RUNNING_PARAMS - 1, asyncCallbackInfo, isThrow); + } } else { ret = StopBackgroundRunningPromise(env, asyncCallbackInfo, isThrow); } @@ -1131,152 +1355,6 @@ napi_value GetAllContinuousTasks(napi_env env, napi_callback_info info, bool isT return ret; } -void CreateContinuousTaskRequestExecuteCB(napi_env env, void *data) -{ - CreateContinuousTaskRequestCallbackInfo *asyncCallbackInfo = - static_cast(data); - if (asyncCallbackInfo == nullptr || asyncCallbackInfo->errCode != ERR_OK) { - return; - } - asyncCallbackInfo->errCode = BackgroundTaskMgrHelper::CreateContinuousTaskRequest(asyncCallbackInfo->requestInfo); -} - -void CreateContinuousTaskRequestPromiseCompletedCB(napi_env env, napi_status status, void *data) -{ - CreateContinuousTaskRequestCallbackInfo *asyncCallbackInfo = - static_cast(data); - std::unique_ptr callbackPtr {asyncCallbackInfo}; - napi_value result {nullptr}; - if (asyncCallbackInfo->errCode == ERR_OK) { - napi_create_object(env, &result); - NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result)); - } else { - std::string errMsg = Common::FindErrMsg(env, asyncCallbackInfo->errCode); - int32_t errCodeInfo = Common::FindErrCode(env, asyncCallbackInfo->errCode); - result = Common::GetCallbackErrorValue(env, errCodeInfo, errMsg); - NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result)); - } - callbackPtr.release(); -} - -napi_value CreateContinuousTaskRequestPromise(napi_env env, - CreateContinuousTaskRequestCallbackInfo *asyncCallbackInfo, bool isThrow) -{ - if (asyncCallbackInfo == nullptr) { - BGTASK_LOGE("param is nullptr"); - return nullptr; - } - napi_value resourceName; - NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); - napi_deferred deferred; - napi_value promise {nullptr}; - NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); - asyncCallbackInfo->deferred = deferred; - NAPI_CALL(env, napi_create_async_work(env, - nullptr, - resourceName, - CreateContinuousTaskRequestExecuteCB, - CreateContinuousTaskRequestPromiseCompletedCB, - static_cast(asyncCallbackInfo), - &asyncCallbackInfo->asyncWork)); - NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork)); - return promise; -} - -napi_value CreateContinuousTaskRequestCheckParam(napi_env env, const napi_value &value, - std::shared_ptr &requestInfo) -{ - napi_valuetype valuetype = napi_undefined; - NAPI_CALL(env, napi_typeof(env, value, &valuetype)); - if (valuetype != napi_object) { - Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_REQUESTINFO_NULL_OR_TYPE, true); - return nullptr; - } - if (!Common::GetContinuousTaskRequestInfo(env, value, requestInfo)) { - Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_REQUESTINFO_NULL_OR_TYPE, true); - return nullptr; - } - if (requestInfo->IsBuildByRequest() && requestInfo->GetContinuousTaskId() == -1) { - Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_INVALID_TASK_ID, true); - return nullptr; - } - std::vector continuousTaskModes = requestInfo->GetContinuousTaskModes(); - std::vector continuousTaskSubmodes = requestInfo->GetContinuousTaskSubmodes(); - if (continuousTaskModes.size() == 0 || continuousTaskSubmodes.size() == 0) { - Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_NULL, true); - return nullptr; - } - if (continuousTaskModes.size() != continuousTaskSubmodes.size()) { - Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_LENGTH_MISMATCH, true); - return nullptr; - } - for (uint32_t index = 0; index < continuousTaskSubmodes.size(); index++) { - uint32_t subMode = continuousTaskSubmodes[index]; - if (subMode >= ContinuousTaskSubmode::END) { - Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_CROSS_BORDER, true); - return nullptr; - } - if (subMode == ContinuousTaskSubmode::SUBMODE_NORMAL_NOTIFICATION) { - if (!ContinuousTaskMode::IsModeTypeMatching(continuousTaskModes[index])) { - Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_CROSS_BORDER, true); - return nullptr; - } - } else { - if (!ContinuousTaskMode::IsSubModeTypeMatching(subMode)) { - Common::HandleErrCode(env, ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_CROSS_BORDER, true); - return nullptr; - } - } - } - return WrapVoidToJS(env); -} - -napi_value CreateContinuousTaskRequest(napi_env env, napi_callback_info info, bool isThrow) -{ - if (env == nullptr) { - BGTASK_LOGE("env param invaild."); - return WrapVoidToJS(env); - } - CreateContinuousTaskRequestCallbackInfo *asyncCallbackInfo = - new (std::nothrow) CreateContinuousTaskRequestCallbackInfo(env); - if (asyncCallbackInfo == nullptr) { - BGTASK_LOGE("asyncCallbackInfo == nullpter"); - return WrapVoidToJS(env); - } - std::unique_ptr callbackPtr {asyncCallbackInfo}; - size_t argc = ARGC_ONE; - napi_value argv[ARGC_ONE] = {nullptr}; - NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL)); - if (argc > ARGC_ONE || argc < ARGC_ONE) { - Common::HandleParamErr(env, ERR_PARAM_NUMBER_ERR, isThrow); - callbackPtr.release(); - if (asyncCallbackInfo != nullptr) { - delete asyncCallbackInfo; - asyncCallbackInfo = nullptr; - } - return WrapVoidToJS(env); - } - if (CreateContinuousTaskRequestCheckParam(env, argv[0], asyncCallbackInfo->requestInfo) == nullptr) { - callbackPtr.release(); - if (asyncCallbackInfo != nullptr) { - delete asyncCallbackInfo; - asyncCallbackInfo = nullptr; - } - return WrapVoidToJS(env); - } - napi_value ret = CreateContinuousTaskRequestPromise(env, asyncCallbackInfo, isThrow); - callbackPtr.release(); - if (ret == nullptr) { - BGTASK_LOGE("ret is nullpter"); - if (asyncCallbackInfo != nullptr) { - delete asyncCallbackInfo; - asyncCallbackInfo = nullptr; - } - ret = WrapVoidToJS(env); - } - return ret; -} - napi_value StartBackgroundRunning(napi_env env, napi_callback_info info) { return StartBackgroundRunning(env, info, false); @@ -1306,10 +1384,5 @@ napi_value GetAllContinuousTasksThrow(napi_env env, napi_callback_info info) { return GetAllContinuousTasks(env, info, true); } - -napi_value CreateContinuousTaskRequestThrow(napi_env env, napi_callback_info info) -{ - return CreateContinuousTaskRequest(env, info, true); -} } // namespace BackgroundTaskMgr } // namespace OHOS \ No newline at end of file diff --git a/interfaces/kits/napi/src/common.cpp b/interfaces/kits/napi/src/common.cpp index b8efac579713e3f3eb9407c92cf61d3914f3e46b..bb7a4c6472d318698d251eec0204aa50e15e8dc1 100644 --- a/interfaces/kits/napi/src/common.cpp +++ b/interfaces/kits/napi/src/common.cpp @@ -18,6 +18,8 @@ #include "background_mode.h" #include "background_sub_mode.h" #include "cancel_suspend_delay.h" +#include "continuous_task_mode.h" +#include "continuous_task_submode.h" #include "transient_task_log.h" namespace OHOS { @@ -84,11 +86,10 @@ const std::map SA_ERRCODE_MSG_MAP = { {ERR_BGTASK_TRANSIENT_SERVICE_NOT_CONNECTED, "System service operation failed. The system service is not connected."}, {ERR_BGTASK_INVALID_PROCESS_NAME, "Transient task verification failed. caller process name invaild."}, - {ERR_BGTASK_CONTINUOUS_REQUESTINFO_NULL_OR_TYPE, + {ERR_BGTASK_CONTINUOUS_REQUEST_NULL_OR_TYPE, "Continuous Task verification failed. " "The continuousRequestInfo cannot be null and its type must be continuousRequestInfo object."}, - {ERR_BGTASK_CONTINUOUS_INVALID_TASK_ID, "Continuous Task verification failed. The continuous task id is Illegal."}, - {ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_NULL, + {ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_IS_EMPTY, "Continuous Task verification failed. The continuousTaskModes or continuousTaskSubmodes cannot be empty."}, {ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_LENGTH_MISMATCH, "Continuous Task verification failed. " @@ -97,7 +98,23 @@ const std::map SA_ERRCODE_MSG_MAP = { "Continuous Task verification failed. The continuousTaskModes or continuousTaskSubmodes are out of scope."}, {ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_TYPE_MISMATCH, "Continuous Task verification failed. " - "The sequence of continuousTaskModes does not match the continuousTaskSubmodes."} + "The sequence of continuousTaskModes does not match the continuousTaskSubmodes."}, + {ERR_BGTASK_CONTINUOUS_NOT_UPDATE_BY_OLD_INTERFACE, + "Continuous Task verification failed. " + "This task is requested through a new interface, and update operations are not permitted via this interface."}, + {ERR_BGTASK_CONTINUOUS_TASKID_INVALID, + "Continuous Task verification failed. The continuous task Id is invalid."}, + {ERR_BGTASK_CONTINUOUS_DATA_TRANSFER_NOT_MERGE_NOTIFICATION, + "Continuous Task verification failed. " + "This continuous task mode: DATA_TRANSFER type do not support merged notification."}, + {ERR_BGTASK_CONTINUOUS_NOT_MERGE_NOTIFICATION_NOT_EXIST, + "Continuous Task verification failed. This continuous task notification does not exist and cannot be merged."}, + {ERR_BGTASK_CONTINUOUS_NOT_MERGE_COMBINED_FALSE, + "Continuous Task verification failed. Corresponding to continuous task do not support merged."}, + {ERR_BGTASK_CONTINUOUS_NOT_UPDATE_BECAUSE_MERGE, + "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."}, }; const std::map PARAM_ERRCODE_MSG_MAP = { @@ -603,126 +620,28 @@ napi_value Common::GetNapiEfficiencyResourcesInfo(const napi_env &env, return napiInfo; } -void *DetachCallbackFunc(napi_env env, void *value, void *) -{ - return value; -} - -napi_value AttachWantAgentFunc(napi_env env, void *value, void *) -{ - if (value == nullptr) { - return nullptr; - } - - napi_value jsObject = nullptr; - NAPI_CALL(env, napi_create_object(env, &jsObject)); - - if (!AbilityRuntime::WantAgent::WantAgent::GetIsMultithreadingSupported()) { - return jsObject; - } - - auto wantAgent = new (std::nothrow) AbilityRuntime::WantAgent::WantAgent( - reinterpret_cast(value)->GetPendingWant()); - if (wantAgent == nullptr) { - return jsObject; - } - - napi_value wantAgentClass = nullptr; - napi_define_class(env, "WantAgentClass", NAPI_AUTO_LENGTH, - [](napi_env env, napi_callback_info info) -> napi_value { - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr); - - return thisVar; - }, nullptr, 0, nullptr, &wantAgentClass); - napi_value result = nullptr; - napi_new_instance(env, wantAgentClass, 0, nullptr, &result); - if (result == nullptr) { - delete wantAgent; - wantAgent = nullptr; - return jsObject; - } - - napi_coerce_to_native_binding_object(env, result, DetachCallbackFunc, AttachWantAgentFunc, value, nullptr); - auto res = napi_wrap(env, result, reinterpret_cast(wantAgent), - [](napi_env env, void* data, void* hint) { - auto agent = static_cast(data); - delete agent; - agent = nullptr; - }, nullptr, nullptr); - if (res != napi_ok && wantAgent != nullptr) { - delete wantAgent; - wantAgent = nullptr; - return jsObject; - } - return result; -} - -napi_value WrapWantAgentContinuousTask(napi_env env, AbilityRuntime::WantAgent::WantAgent *wantAgent, - napi_finalize finalizeCb) -{ - napi_value wantAgentClass = nullptr; - napi_define_class( - env, - "WantAgentClass", - NAPI_AUTO_LENGTH, - [](napi_env env, napi_callback_info info) -> napi_value { - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr); - return thisVar; - }, - nullptr, - 0, - nullptr, - &wantAgentClass); - napi_value result = nullptr; - napi_new_instance(env, wantAgentClass, 0, nullptr, &result); - if (result == nullptr) { - return nullptr; - } - - napi_coerce_to_native_binding_object(env, result, DetachCallbackFunc, AttachWantAgentFunc, wantAgent, nullptr); - - napi_finalize finalize = [](napi_env env, void* data, void* hint) { - if (data != nullptr) { - auto agent = static_cast(data); - delete agent; - agent = nullptr; - } - }; - if (finalizeCb != nullptr) { - finalize = finalizeCb; - } - - auto res = napi_wrap(env, result, reinterpret_cast(wantAgent), finalize, nullptr, nullptr); - if (res != napi_ok && wantAgent != nullptr) { - return nullptr; - } - return result; -} - -bool Common::GetContinuousTaskRequestInfo(napi_env env, napi_value objValue, - std::shared_ptr &requestInfo) +bool Common::GetContinuousTaskRequest(napi_env env, napi_value objValue, + std::shared_ptr &request) { // Get continuousTaskModes. - if (!GetContinuousTaskModesProperty(env, objValue, "continuousTaskModes", requestInfo)) { + if (!GetContinuousTaskModesProperty(env, objValue, "continuousTaskModes", request)) { return false; } // Get continuousTaskSubmodes. - if (!GetContinuousTaskSubmodesProperty(env, objValue, "continuousTaskSubmodes", requestInfo)) { + if (!GetContinuousTaskSubmodesProperty(env, objValue, "continuousTaskSubmodes", request)) { return false; } // Get wantAgent. - if (!GetWantAgentProperty(env, objValue, "wantAgent", requestInfo)) { + if (!GetWantAgentProperty(env, objValue, "wantAgent", request)) { return false; } // Get continuousTaskId. int32_t continuousTaskId = GetIntProperty(env, objValue, "continuousTaskId"); if (continuousTaskId != INVALID_CONTINUOUSTASK_ID) { - requestInfo->SetContinuousTaskId(continuousTaskId); + request->SetContinuousTaskId(continuousTaskId); } else { return false; } @@ -730,13 +649,13 @@ bool Common::GetContinuousTaskRequestInfo(napi_env env, napi_value objValue, // Get combinedTaskNotification. bool combinedTaskNotification = GetBoolProperty(env, objValue, "combinedTaskNotification"); if (combinedTaskNotification) { - requestInfo->SetCombinedTaskNotification(combinedTaskNotification); + request->SetCombinedTaskNotification(combinedTaskNotification); } return true; } bool Common::GetContinuousTaskModesProperty(napi_env env, napi_value object, const std::string &propertyName, - std::shared_ptr &requestInfo) + std::shared_ptr &request) { bool boolValue = false; napi_value value = nullptr; @@ -750,6 +669,7 @@ bool Common::GetContinuousTaskModesProperty(napi_env env, napi_value object, con } uint32_t length; napi_get_array_length(env, value, &length); + std::vector continuousTaskModes {}; for (uint32_t i = 0; i < length; i++) { napi_value napiMode; if (napi_get_element(env, value, i, &napiMode) != napi_ok) { @@ -768,14 +688,15 @@ bool Common::GetContinuousTaskModesProperty(napi_env env, napi_value object, con return false; } uint32_t mode = static_cast(intValue); - requestInfo->AddContinuousTaskMode(mode); + continuousTaskModes.push_back(mode); } } + request->SetContinuousTaskMode(continuousTaskModes); return boolValue; } bool Common::GetContinuousTaskSubmodesProperty(napi_env env, napi_value object, const std::string &propertyName, - std::shared_ptr &requestInfo) + std::shared_ptr &request) { bool boolValue = false; napi_value value = nullptr; @@ -789,6 +710,7 @@ bool Common::GetContinuousTaskSubmodesProperty(napi_env env, napi_value object, } uint32_t length; napi_get_array_length(env, value, &length); + std::vector continuousTaskSubModes {}; for (uint32_t i = 0; i < length; i++) { napi_value napiSubMode; if (napi_get_element(env, value, i, &napiSubMode) != napi_ok) { @@ -807,14 +729,15 @@ bool Common::GetContinuousTaskSubmodesProperty(napi_env env, napi_value object, return false; } uint32_t subMode = static_cast(intValue); - requestInfo->AddContinuousTaskSubMode(subMode); + continuousTaskSubModes.push_back(subMode); } } + request->SetContinuousTaskSubMode(continuousTaskSubModes); return boolValue; } bool Common::GetWantAgentProperty(napi_env env, napi_value object, const std::string &propertyName, - std::shared_ptr &requestInfo) + std::shared_ptr &request) { napi_value value = nullptr; napi_status getNameStatus = napi_get_named_property(env, object, propertyName.c_str(), &value); @@ -833,7 +756,7 @@ bool Common::GetWantAgentProperty(napi_env env, napi_value object, const std::st } std::shared_ptr wantAgent = std::make_shared(*wantAgentPtr); - requestInfo->SetWantAgent(wantAgent); + request->SetWantAgent(wantAgent); return true; } @@ -847,12 +770,11 @@ int32_t Common::GetIntProperty(napi_env env, napi_value object, const std::strin } napi_valuetype valueType = napi_undefined; napi_typeof(env, value, &valueType); - if (valueType == napi_undefined) { - return intValue; + if (valueType != napi_undefined && valueType == napi_number) { + napi_get_value_int32(env, value, &intValue); } else if (valueType != napi_number) { - return intValue; + intValue = -1; } - napi_get_value_int32(env, value, &intValue); return intValue; } @@ -866,13 +788,34 @@ bool Common::GetBoolProperty(napi_env env, napi_value object, const std::string } napi_valuetype valueType = napi_undefined; napi_typeof(env, value, &valueType); - if (valueType == napi_undefined) { - return boolValue; - } else if (valueType != napi_boolean) { - return boolValue; + if (valueType != napi_undefined && valueType == napi_boolean) { + napi_get_value_bool(env, value, &boolValue); } - napi_get_value_bool(env, value, &boolValue); return boolValue; } + +void Common::TaskModeTypeConversion(std::shared_ptr &request) +{ + if (request == nullptr) { + return; + } + std::vector continuousTaskSubModes = request->GetContinuousTaskSubmodes(); + std::vector continuousTaskModes = request->GetContinuousTaskModes(); + std::vector modes {}; + std::vector subModes {}; + for (uint32_t index = 0; index < continuousTaskSubModes.size(); index++) { + uint32_t subMode = continuousTaskSubModes[index]; + subModes.push_back(subMode); + uint32_t mode = 0; + if (subMode == ContinuousTaskSubmode::SUBMODE_NORMAL_NOTIFICATION) { + mode = ContinuousTaskMode::GetV9BackgroundModeByMode(continuousTaskModes[index]); + } else { + mode = ContinuousTaskMode::GetV9BackgroundModeBySubMode(subMode); + } + modes.push_back(mode); + } + request->SetContinuousTaskMode(modes); + request->SetContinuousTaskSubMode(subModes); +} } // namespace BackgroundTaskMgr } // namespace OHOS 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 45dc366cd219879f138be17dcb629958863b10d4..dd8e6f7a0a1f584c8b5d92bd83cffab498b414a8 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 @@ -29,7 +29,7 @@ #include "continuous_task_cancel_reason.h" #include "continuous_task_mode.h" #include "continuous_task_param.h" -#include "continuous_task_request_info.h" +#include "continuous_task_request.h" #include "continuous_task_submode.h" #include "continuous_task_suspend_reason.h" #include "delay_suspend_info.h" @@ -942,8 +942,13 @@ HWTEST_F(BgTaskClientUnitTest, ContinuousTaskMode_001, TestSize.Level0) EXPECT_EQ(MODE_AV_PLAYBACK_AND_RECORD, (int32_t)ContinuousTaskMode::MODE_AV_PLAYBACK_AND_RECORD); EXPECT_EQ(MODE_END, (int32_t)ContinuousTaskMode::END); ContinuousTaskMode::GetContinuousTaskModeStr(MODE_DATA_TRANSFER); - EXPECT_TRUE(ContinuousTaskMode::IsSubModeTypeMatching(SUBMODE_LIVE_VIEW_NOTIFICATION)); EXPECT_TRUE(ContinuousTaskMode::IsModeTypeMatching(MODE_SHARE_POSITION)); + EXPECT_NE(ContinuousTaskMode::GetSubModeTypeMatching(SUBMODE_LIVE_VIEW_NOTIFICATION), + ContinuousTaskMode::END); + EXPECT_NE(ContinuousTaskMode::GetV9BackgroundModeByMode(MODE_SHARE_POSITION), + BackgroundMode::END); + EXPECT_NE(ContinuousTaskMode::GetV9BackgroundModeBySubMode(SUBMODE_LIVE_VIEW_NOTIFICATION), + BackgroundMode::END); } /** @@ -971,34 +976,22 @@ HWTEST_F(BgTaskClientUnitTest, ContinuousTaskSubmode_001, TestSize.Level0) } /** - * @tc.name: CreateContinuousTaskRequest_001 - * @tc.desc: test CreateContinuousTaskRequest interface. - * @tc.type: FUNC - * @tc.require: issueICT1ZV - */ -HWTEST_F(BgTaskClientUnitTest, CreateContinuousTaskRequest_001, TestSize.Level1) -{ - std::shared_ptr requestInfo = std::make_shared(); - EXPECT_EQ(BackgroundTaskMgrHelper::CreateContinuousTaskRequest(requestInfo), ERR_OK); -} - -/** - * @tc.name: ContinuousTaskRequestInfo_001 - * @tc.desc: test ContinuousTaskRequestInfo. + * @tc.name: ContinuousTaskRequest_001 + * @tc.desc: test ContinuousTaskRequest. * @tc.type: FUNC * @tc.require: issueIBY0DN */ -HWTEST_F(BgTaskClientUnitTest, ContinuousTaskRequestInfo_001, TestSize.Level1) +HWTEST_F(BgTaskClientUnitTest, ContinuousTaskRequest_001, TestSize.Level1) { - std::shared_ptr info1 = std::make_shared(); + std::shared_ptr info1 = std::make_shared(); std::vector backgroundModes {1}; std::vector backgroundSubModes {1}; - std::shared_ptr info2 = std::make_shared( + std::shared_ptr info2 = std::make_shared( backgroundModes, backgroundSubModes, std::make_shared(), true, 10, true); MessageParcel parcel = MessageParcel(); info2->Marshalling(parcel); - sptr info3 = ContinuousTaskRequestInfo::Unmarshalling(parcel); + sptr info3 = ContinuousTaskRequest::Unmarshalling(parcel); info3->GetWantAgent(); info3->GetContinuousTaskModes(); info3->GetContinuousTaskSubmodes(); @@ -1007,8 +1000,10 @@ HWTEST_F(BgTaskClientUnitTest, ContinuousTaskRequestInfo_001, TestSize.Level1) info3->GetContinuousTaskId(); info3->SetContinuousTaskId(1); info3->SetCombinedTaskNotification(false); - info3->AddContinuousTaskMode(2); - info3->AddContinuousTaskSubMode(2); + std::vector continuousTaskSubMode {1}; + std::vector continuousTaskMode {1}; + info3->SetContinuousTaskSubMode(continuousTaskSubMode); + info3->SetContinuousTaskMode(continuousTaskMode); info3->SetWantAgent(std::make_shared()); EXPECT_EQ(info3->GetContinuousTaskId(), 1); } diff --git a/services/common/include/common_utils.h b/services/common/include/common_utils.h index b965957bdf07d9f4c33e00151ee800c1c9bfbe01..8869ed27b8d60be198b79480243ac49e5ce963fc 100644 --- a/services/common/include/common_utils.h +++ b/services/common/include/common_utils.h @@ -39,6 +39,12 @@ public: return iter != bgModeIds.end(); } + static bool CheckExistNotification(const std::vector ¬ificaitonIds, const int32_t notificaitonId) + { + auto iter = std::find(notificaitonIds.begin(), notificaitonIds.end(), notificaitonId); + return iter == notificaitonIds.end(); + } + static bool CheckModesSame(const std::vector &oldBgModeIds, const std::vector &newBgModeIds) { std::set oldModesSet(oldBgModeIds.begin(), oldBgModeIds.end()); @@ -46,6 +52,15 @@ public: return oldModesSet == newModesSet; } + static std::string ModesToString(const std::vector &bgmodes) + { + std::string modeStr; + for (const auto &mode : bgmodes) { + modeStr += std::to_string(mode); + } + return modeStr; + } + public: static constexpr int32_t jsonFormat_ = 4; }; diff --git a/services/continuous_task/include/bg_continuous_task_mgr.h b/services/continuous_task/include/bg_continuous_task_mgr.h index ca044ac12938e169d666cdf28270187366e332b5..d2e51506758799bb8fa46ffa2f288b56728146cc 100644 --- a/services/continuous_task/include/bg_continuous_task_mgr.h +++ b/services/continuous_task/include/bg_continuous_task_mgr.h @@ -32,8 +32,11 @@ #include "task_notification_subscriber.h" #endif #include "continuous_task_info.h" +#include "continuous_task_mode.h" #include "continuous_task_param.h" #include "continuous_task_record.h" +#include "continuous_task_request.h" +#include "continuous_task_submode.h" #include "ibackground_task_subscriber.h" #include "remote_death_recipient.h" #include "system_event_observer.h" @@ -78,7 +81,7 @@ class BgContinuousTaskMgr : public DelayedSingleton, public: ErrCode StartBackgroundRunning(const sptr &taskParam); ErrCode UpdateBackgroundRunning(const sptr &taskParam); - ErrCode StopBackgroundRunning(const std::string &abilityName, int32_t abilityId); + ErrCode StopBackgroundRunning(const std::string &abilityName, int32_t abilityId, int32_t continuousTaskId = -1); ErrCode GetAllContinuousTasks(std::vector> &list); ErrCode GetAllContinuousTasks(std::vector> &list, bool includeSuspended); ErrCode RequestBackgroundRunningForInner(const sptr &taskParam); @@ -114,7 +117,8 @@ private: ErrCode UpdateBackgroundRunningInner(const std::string &taskInfoMapKey, const sptr &taskParam); ErrCode StartBackgroundRunningForInner(const sptr &taskParam); - ErrCode StopBackgroundRunningInner(int32_t uid, const std::string &abilityName, int32_t abilityId); + ErrCode StopBackgroundRunningInner(int32_t uid, const std::string &abilityName, int32_t abilityId, + int32_t continuousTaskId = -1); ErrCode StopBackgroundRunningForInner(const sptr &taskParam); ErrCode GetAllContinuousTasksInner(int32_t uid, std::vector> &list, bool includeSuspended = true); @@ -125,11 +129,12 @@ private: ErrCode SendContinuousTaskNotification(std::shared_ptr &ContinuousTaskRecordPtr); ErrCode GetContinuousTaskAppsInner(std::vector> &list, int32_t uid); ErrCode AVSessionNotifyUpdateNotificationInner(int32_t uid, int32_t pid, bool isPublish = false); + ErrCode StopBackgroundRunningByContext(int32_t uid, const std::string &abilityName, int32_t abilityId); + ErrCode StopBackgroundRunningByTask(const std::shared_ptr &task); void HandlePersistenceData(); void CheckPersistenceData(const std::vector &allProcesses); void DumpAllTaskInfo(std::vector &dumpInfo); void DumpCancelTask(const std::vector &dumpOption, bool cleanAll); - bool RemoveContinuousTaskRecord(const std::string &mapKey); bool AddAppNameInfos(const AppExecFwk::BundleInfo &bundleInfo, CachedBundleInfo &cachedBundleInfo); bool CheckProcessUidInfo(const std::vector &allProcesses, int32_t uid); uint32_t GetBackgroundModeInfo(int32_t uid, const std::string &abilityName); @@ -178,6 +183,8 @@ 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); + bool StopContinuousTaskByUserInner(const std::string &key); private: std::atomic isSysReady_ {false}; int32_t bgTaskUid_ {-1}; diff --git a/services/continuous_task/include/continuous_task_record.h b/services/continuous_task/include/continuous_task_record.h index be9e1d46b0d8a0524988c3b8f2dc52f1ae6e904b..48957d609ef8d51444600ce9880ab4525182cd5d 100644 --- a/services/continuous_task/include/continuous_task_record.h +++ b/services/continuous_task/include/continuous_task_record.h @@ -91,6 +91,9 @@ private: bool suspendState_ {false}; int32_t suspendReason_ {0}; int32_t suspendAudioTaskTimes_ {0}; + bool isCombinedTaskNotification_ {false}; + int32_t combinedNotificationTaskId_ {-1}; + bool isByRequestObject_ {false}; friend class BgContinuousTaskMgr; friend class NotificationTools; diff --git a/services/continuous_task/src/bg_continuous_task_mgr.cpp b/services/continuous_task/src/bg_continuous_task_mgr.cpp index dd12947c9f987e9215714a7867a4161c811ac5ae..8e1ef6f7139618ea1d76abb20a0326f1245e3356 100644 --- a/services/continuous_task/src/bg_continuous_task_mgr.cpp +++ b/services/continuous_task/src/bg_continuous_task_mgr.cpp @@ -90,6 +90,7 @@ static constexpr uint32_t PC_BGMODE_TASK_KEEPING = 256; static constexpr int32_t DELAY_TIME = 2000; static constexpr int32_t RECLAIM_MEMORY_DELAY_TIME = 20 * 60 * 1000; static constexpr int32_t MAX_DUMP_PARAM_NUMS = 3; +static constexpr int32_t ILLELG_NOTIFICATION_ID = -2; static constexpr uint32_t INVALID_BGMODE = 0; static constexpr uint32_t BG_MODE_INDEX_HEAD = 1; static constexpr uint32_t BGMODE_NUMS = 10; @@ -580,6 +581,10 @@ bool CheckTaskParam(const sptr &taskParam) BGTASK_LOGE("continuous task params invalid!"); return false; } + if (taskParam->isByRequestObject_ && (taskParam->bgModeIds_.empty() || taskParam->bgSubModeIds_.empty())) { + BGTASK_LOGE("request param modes or submodes is empty"); + return false; + } if (taskParam->isBatchApi_ && taskParam->bgModeIds_.empty()) { BGTASK_LOGE("bgModeIds_ is empty"); return false; @@ -739,6 +744,10 @@ void BgContinuousTaskMgr::InitRecordParam(std::shared_ptr continuousTaskRecord->appName_ = taskParam->appName_; continuousTaskRecord->fullTokenId_ = fullTokenId; continuousTaskRecord->isSystem_ = BundleManagerHelper::GetInstance()->IsSystemApp(fullTokenId); + continuousTaskRecord->bgSubModeIds_ = taskParam->bgSubModeIds_; + continuousTaskRecord->isCombinedTaskNotification_ = taskParam->isCombinedTaskNotification_; + continuousTaskRecord->combinedNotificationTaskId_ = taskParam->combinedNotificationTaskId_; + continuousTaskRecord->isByRequestObject_ = taskParam->isByRequestObject_; } ErrCode BgContinuousTaskMgr::CheckSubMode(const std::shared_ptr want, @@ -746,7 +755,7 @@ ErrCode BgContinuousTaskMgr::CheckSubMode(const std::shared_ptr wan { if (want->HasParameter(BG_TASK_SUB_MODE_TYPE)) { if (CommonUtils::CheckExistMode(record->bgModeIds_, BackgroundMode::BLUETOOTH_INTERACTION) && - want->GetIntParam(BG_TASK_SUB_MODE_TYPE, 0) == BackgroundSubMode::CAR_KEY) { + want->GetIntParam(BG_TASK_SUB_MODE_TYPE, 0) == BackgroundSubMode::CAR_KEY && !record->isByRequestObject_) { record->bgSubModeIds_.push_back(BackgroundSubMode::CAR_KEY); } else { BGTASK_LOGE("subMode is invaild."); @@ -844,6 +853,9 @@ ErrCode BgContinuousTaskMgr::StartBackgroundRunningInner(std::shared_ptruid_) + SEPARATOR + continuousTaskRecord->abilityName_ + SEPARATOR + std::to_string(continuousTaskRecord->abilityId_); + if (continuousTaskRecord->isByRequestObject_) { + taskInfoMapKey = taskInfoMapKey + SEPARATOR + CommonUtils::ModesToString(continuousTaskRecord->bgModeIds_); + } if (continuousTaskInfosMap_.find(taskInfoMapKey) != continuousTaskInfosMap_.end()) { if (continuousTaskInfosMap_[taskInfoMapKey]->suspendState_) { HandleActiveContinuousTask(continuousTaskRecord->uid_, continuousTaskRecord->pid_, taskInfoMapKey); @@ -878,8 +890,12 @@ ErrCode BgContinuousTaskMgr::StartBackgroundRunningInner(std::shared_ptrisFromWebview_) { + bool sendNotification = true; + ret = CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification); + if (ret != ERR_OK) { + return ret; + } + if (!continuousTaskRecord->isFromWebview_ && sendNotification) { ret = SendContinuousTaskNotification(continuousTaskRecord); if (ret != ERR_OK) { BGTASK_LOGE("publish error"); @@ -892,6 +908,76 @@ ErrCode BgContinuousTaskMgr::StartBackgroundRunningInner(std::shared_ptr &recordParam, + bool &sendNotification) +{ + // 无需合并，新申请 + int32_t mergeNotificationTaskId = recordParam->combinedNotificationTaskId_; + if (recordParam->isByRequestObject_) { + if (mergeNotificationTaskId == -1) { + sendNotification = true; + return ERR_OK; + } else if (!recordParam->isCombinedTaskNotification_) { + BGTASK_LOGE("current continuous task not support merge, uid: %{public}d", recordParam->uid_); + return ERR_BGTASK_CONTINUOUS_NOT_MERGE_CURRENTTASK_COMBINED_FALSE; + } + } else { + sendNotification = true; + return ERR_OK; + } + ErrCode ret = ERR_BGTASK_CONTINUOUS_TASKID_INVALID; + for (const auto &record : continuousTaskInfosMap_) { + if (!record.second) { + BGTASK_LOGE("task is null"); + continue; + } + if (record.second->uid_ != recordParam->uid_) { + BGTASK_LOGE("task uid is not equal, task uid: %{public}d, param uid: %{public}d", + record.second->uid_, recordParam->uid_); + continue; + } + if (record.second->GetContinuousTaskId() != mergeNotificationTaskId) { + BGTASK_LOGE("task id is not equal, task id: %{public}d, param combined task id: %{public}d", + record.second->GetContinuousTaskId(), mergeNotificationTaskId); + continue; + } + if (!record.second->isCombinedTaskNotification_) { + ret = ERR_BGTASK_CONTINUOUS_NOT_MERGE_COMBINED_FALSE; + BGTASK_LOGE("continuous task not support merge, taskId: %{public}d", mergeNotificationTaskId); + return ret; + } + if (record.second->GetNotificationId() == -1) { + ret = ERR_BGTASK_CONTINUOUS_NOT_MERGE_NOTIFICATION_NOT_EXIST; + BGTASK_LOGE("continuous task notification not exist, taskId: %{public}d", mergeNotificationTaskId); + return ret; + } + if (!CommonUtils::CheckModesSame(record.second->bgModeIds_, recordParam->bgModeIds_)) { + ret = ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_TYPE_MISMATCH; + BGTASK_LOGE("continuous task modes mismatch, taskId: %{public}d", mergeNotificationTaskId); + return ret; + } + if (!CommonUtils::CheckModesSame(record.second->bgSubModeIds_, recordParam->bgSubModeIds_)) { + ret = ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_TYPE_MISMATCH; + BGTASK_LOGE("continuous task submodes mismatch, taskId: %{public}d", mergeNotificationTaskId); + return ret; + } + if (CommonUtils::CheckExistMode(recordParam->bgModeIds_, BackgroundMode::DATA_TRANSFER)) { + ret = ERR_BGTASK_CONTINUOUS_DATA_TRANSFER_NOT_MERGE_NOTIFICATION; + BGTASK_LOGE("continuous task mode: DATA_TRANSFER not support merge, taskId: %{public}d", + mergeNotificationTaskId); + return ret; + } else { + ret = ERR_OK; + sendNotification = false; + recordParam->notificationId_ = record.second->GetNotificationId(); + recordParam->notificationLabel_ = record.second->GetNotificationLabel(); + record.second->combinedNotificationTaskId_ = mergeNotificationTaskId; + break; + } + } + return ret; +} + uint32_t GetBgModeNameIndex(uint32_t bgModeId, bool isNewApi) { if (!isNewApi) { @@ -934,9 +1020,11 @@ ErrCode BgContinuousTaskMgr::SendContinuousTaskNotification( BGTASK_LOGD("notificationText %{public}s", notificationText.c_str()); auto iter = avSessionNotification_.find(continuousTaskRecord->uid_); bool isPublish = (iter != avSessionNotification_.end()) ? iter->second : false; + bool isPublishAvsession = isPublish || (CommonUtils::CheckExistMode(continuousTaskRecord->bgSubModeIds_, + ContinuousTaskSubmode::SUBMODE_AVSESSION_AUDIO_PLAYBACK) && continuousTaskRecord->isByRequestObject_); if (continuousTaskRecord->bgModeIds_.size() == 1 && continuousTaskRecord->bgModeIds_[0] == BackgroundMode::AUDIO_PLAYBACK) { - if (isPublish) { + if (isPublishAvsession) { return ERR_OK; } } @@ -950,8 +1038,11 @@ ErrCode BgContinuousTaskMgr::CheckNotificationText(std::string ¬ificationText auto iter = avSessionNotification_.find(continuousTaskRecord->uid_); bool isPublish = (iter != avSessionNotification_.end()) ? iter->second : false; BGTASK_LOGD("AVSession Notification isPublish: %{public}d", isPublish); + // 子类型带有avsession,不发通知 + bool isPublishAvsession = isPublish || (CommonUtils::CheckExistMode(continuousTaskRecord->bgSubModeIds_, + ContinuousTaskSubmode::SUBMODE_AVSESSION_AUDIO_PLAYBACK) && continuousTaskRecord->isByRequestObject_); for (auto mode : continuousTaskRecord->bgModeIds_) { - if ((mode == BackgroundMode::AUDIO_PLAYBACK && isPublish) || ((mode == BackgroundMode::VOIP || + if ((mode == BackgroundMode::AUDIO_PLAYBACK && isPublishAvsession) || ((mode == BackgroundMode::VOIP || mode == BackgroundMode::AUDIO_RECORDING) && continuousTaskRecord->IsSystem())) { continue; } @@ -1000,7 +1091,8 @@ ErrCode BgContinuousTaskMgr::StopBackgroundRunningForInner(const sptrPostSyncTask([this, callingUid, abilityName, abilityId, &result]() { - result = this->StopBackgroundRunningInner(callingUid, abilityName, abilityId); + handler_->PostSyncTask([this, callingUid, abilityName, abilityId, continuousTaskId, &result]() { + result = this->StopBackgroundRunningInner(callingUid, abilityName, abilityId, continuousTaskId); }, AppExecFwk::EventQueue::Priority::HIGH); return result; } ErrCode BgContinuousTaskMgr::StopBackgroundRunningInner(int32_t uid, const std::string &abilityName, - int32_t abilityId) + int32_t abilityId, int32_t continuousTaskId) { BgTaskHiTraceChain traceChain(__func__); - std::string mapKey = std::to_string(uid) + SEPARATOR + abilityName + SEPARATOR + std::to_string(abilityId); + if (continuousTaskId != -1) { + // 新街口取消 + auto findTask = [continuousTaskId, uid, abilityName, abilityId](const auto &target) { + return continuousTaskId == target.second->continuousTaskId_ && target.second->uid_ == uid && + target.second->abilityName_ == abilityName && target.second->abilityId_ == abilityId; + }; + 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; + } + return StopBackgroundRunningByTask(findTaskIter->second); + } else { + std::string mapKey = std::to_string(uid) + SEPARATOR + abilityName + SEPARATOR + std::to_string(abilityId); + auto iter = continuousTaskInfosMap_.find(mapKey); + if (iter == continuousTaskInfosMap_.end()) { + BGTASK_LOGD("%{public}s continuous task not exists", mapKey.c_str()); + return ERR_BGTASK_OBJECT_NOT_EXIST; + } + return StopBackgroundRunningByTask(iter->second); + } +} +ErrCode BgContinuousTaskMgr::StopBackgroundRunningByContext(int32_t uid, const std::string &abilityName, + int32_t abilityId) +{ + std::vector> tasklist {}; + auto iter = continuousTaskInfosMap_.begin(); + while (iter != continuousTaskInfosMap_.end()) { + if (iter->second->uid_ == uid && iter->second->abilityName_ == abilityName && + iter->second->abilityId_ == abilityId) { + auto record = iter->second; + tasklist.push_back(record); + } + iter++; + } + ErrCode ret = ERR_OK; + for (const auto &record : tasklist) { + ret = StopBackgroundRunningByTask(record); + if (ret != ERR_OK) { + return ret; + } + } + return ret; +} + +ErrCode BgContinuousTaskMgr::StopBackgroundRunningByTask(const std::shared_ptr &task) +{ + if (!task) { + BGTASK_LOGE("task is null"); + return ERR_BGTASK_CHECK_TASK_PARAM; + } + std::string mapKey = std::to_string(task->uid_) + SEPARATOR + task->abilityName_ + SEPARATOR + + std::to_string(task->abilityId_); + if (task->isByRequestObject_) { + mapKey = mapKey + SEPARATOR + CommonUtils::ModesToString(task->bgModeIds_); + } auto iter = continuousTaskInfosMap_.find(mapKey); if (iter == continuousTaskInfosMap_.end()) { - BGTASK_LOGD("%{public}s continuous task not exists", mapKey.c_str()); + BGTASK_LOGE("not have task, taskKey: %{public}s", mapKey.c_str()); return ERR_BGTASK_OBJECT_NOT_EXIST; } - BGTASK_LOGI("TASK STOP: user: %{public}s stop continuous task, continuousTaskId: %{public}d, " - "notificationId: %{public}d", mapKey.c_str(), iter->second->GetContinuousTaskId(), - iter->second->GetNotificationId()); + auto record = iter->second; + OnContinuousTaskChanged(record, ContinuousTaskEventTriggerType::TASK_CANCEL); + int32_t notificationId = record->GetNotificationId(); + BGTASK_LOGI("continuous task key: %{public}s stop, continuousTaskId: %{public}d, " + "notificationId: %{public}d", mapKey.c_str(), record->GetContinuousTaskId(), notificationId); + continuousTaskInfosMap_.erase(mapKey); ErrCode result = ERR_OK; - if (iter->second->GetNotificationId() != -1) { - result = NotificationTools::GetInstance()->CancelNotification( - iter->second->GetNotificationLabel(), iter->second->GetNotificationId()); + if (notificationId != -1) { + std::string notificationLabel = record->GetNotificationLabel(); + auto findNotification = [notificationId, notificationLabel](const auto &target) { + return notificationId == target.second->notificationId_ && + notificationLabel == target.second->notificationLabel_; + }; + auto findNotificationIter = find_if(continuousTaskInfosMap_.begin(), continuousTaskInfosMap_.end(), + findNotification); + if (findNotificationIter == continuousTaskInfosMap_.end()) { + result = NotificationTools::GetInstance()->CancelNotification(notificationLabel, notificationId); + } } - RemoveContinuousTaskRecord(mapKey); + HandleAppContinuousTaskStop(record->uid_); + RefreshTaskRecord(); return result; } @@ -1155,10 +1313,9 @@ void BgContinuousTaskMgr::HandleStopContinuousTask(int32_t uid, int32_t pid, uin if (continuousTaskInfosMap_.find(key) == continuousTaskInfosMap_.end()) { return; } - NotificationTools::GetInstance()->CancelNotification(continuousTaskInfosMap_[key]->GetNotificationLabel(), - continuousTaskInfosMap_[key]->GetNotificationId()); + auto record = continuousTaskInfosMap_.at(key); SetReason(key, FREEZE_CANCEL); - RemoveContinuousTaskRecord(key); + StopBackgroundRunningByTask(record); } void BgContinuousTaskMgr::SuspendContinuousTask(int32_t uid, int32_t pid, int32_t reason, const std::string &key) @@ -1239,6 +1396,16 @@ void BgContinuousTaskMgr::ActiveContinuousTask(int32_t uid, int32_t pid, const s void BgContinuousTaskMgr::HandleActiveContinuousTask(int32_t uid, int32_t pid, const std::string &key) { + auto findTask = [uid](const auto &target) { + return uid == target.second->uid_ && target.second->suspendState_; + }; + auto findTaskIter = find_if(continuousTaskInfosMap_.begin(), continuousTaskInfosMap_.end(), findTask); + if (findTaskIter == continuousTaskInfosMap_.end()) { + return; + } + std::string notificationLabel = "default"; + int32_t notificationId = ILLELG_NOTIFICATION_ID; + std::vector notificationOldIds {}; auto iter = continuousTaskInfosMap_.begin(); while (iter != continuousTaskInfosMap_.end()) { if (iter->second->GetUid() != uid || !iter->second->suspendState_) { @@ -1248,7 +1415,18 @@ void BgContinuousTaskMgr::HandleActiveContinuousTask(int32_t uid, int32_t pid, c BGTASK_LOGI("ActiveContinuousTask uid: %{public}d, pid: %{public}d", uid, pid); iter->second->suspendState_ = false; OnContinuousTaskChanged(iter->second, ContinuousTaskEventTriggerType::TASK_ACTIVE); - SendContinuousTaskNotification(iter->second); + if (iter->second->notificationId_ != -1) { + if (notificationId == ILLELG_NOTIFICATION_ID || + CommonUtils::CheckExistNotification(notificationOldIds, iter->second->notificationId_)) { + notificationOldIds.push_back(iter->second->notificationId_); + SendContinuousTaskNotification(iter->second); + notificationLabel = iter->second->notificationLabel_; + notificationId = iter->second->notificationId_; + } else { + iter->second->notificationLabel_ = notificationLabel; + iter->second->notificationId_ = notificationId; + } + } RefreshTaskRecord(); break; } @@ -1447,6 +1625,13 @@ ErrCode BgContinuousTaskMgr::AVSessionNotifyUpdateNotificationInner(int32_t uid, ErrCode result = ERR_OK; auto record = findUidIter->second; + + // 子类型包含avsession，不发通知 + if (!isPublish && + CommonUtils::CheckExistMode(record->bgSubModeIds_, ContinuousTaskSubmode::SUBMODE_AVSESSION_AUDIO_PLAYBACK)) { + return ERR_OK; + } + // 只有播音类型长时任务，并且没有AVSession通知 if (!isPublish && record->bgModeIds_.size() == 1 && record->bgModeIds_[0] == BackgroundMode::AUDIO_PLAYBACK) { result = SendContinuousTaskNotification(record); @@ -1585,6 +1770,10 @@ void BgContinuousTaskMgr::DumpAllTaskInfo(std::vector &dumpInfo) stream << "\t\twantAgentBundleName: " << "NULL" << "\n"; stream << "\t\twantAgentAbilityName: " << "NULL" << "\n"; } + stream << "\t\tisCombinedTaskNotification: " << + (iter->second->isCombinedTaskNotification_ ? "true" : "false") << "\n"; + stream << "\t\tcombinedNotificationTaskId: " << iter->second->combinedNotificationTaskId_ << "\n"; + stream << "\t\tisByRequestObject: " << (iter->second->isByRequestObject_ ? "true" : "false") << "\n"; stream << "\n"; dumpInfo.emplace_back(stream.str()); index++; @@ -1615,9 +1804,7 @@ void BgContinuousTaskMgr::DumpCancelTask(const std::vector &dumpOpt if (iter == continuousTaskInfosMap_.end()) { return; } - NotificationTools::GetInstance()->CancelNotification(iter->second->GetNotificationLabel(), - iter->second->GetNotificationId()); - RemoveContinuousTaskRecord(taskKey); + StopBackgroundRunningByTask(iter->second); } } @@ -1632,21 +1819,6 @@ void BgContinuousTaskMgr::SetReason(const std::string &mapKey, int32_t reason) } } -bool BgContinuousTaskMgr::RemoveContinuousTaskRecord(const std::string &mapKey) -{ - if (continuousTaskInfosMap_.find(mapKey) == continuousTaskInfosMap_.end()) { - BGTASK_LOGW("remove TaskInfo failure, no matched task: %{public}s", mapKey.c_str()); - return false; - } - BGTASK_LOGI("erase task info: %{public}s", mapKey.c_str()); - auto record = continuousTaskInfosMap_.at(mapKey); - OnContinuousTaskChanged(record, ContinuousTaskEventTriggerType::TASK_CANCEL); - continuousTaskInfosMap_.erase(mapKey); - HandleAppContinuousTaskStop(record->uid_); - RefreshTaskRecord(); - return true; -} - bool BgContinuousTaskMgr::StopContinuousTaskByUser(const std::string &mapKey) { if (!isSysReady_.load()) { @@ -1656,11 +1828,23 @@ bool BgContinuousTaskMgr::StopContinuousTaskByUser(const std::string &mapKey) bool result = true; handler_->PostSyncTask([this, mapKey, &result]() { SetReason(mapKey, REMOVE_NOTIFICATION_CANCEL); - result = RemoveContinuousTaskRecord(mapKey); + result = StopContinuousTaskByUserInner(mapKey); }); return result; } +bool BgContinuousTaskMgr::StopContinuousTaskByUserInner(const std::string &key) +{ + auto removeTask = continuousTaskInfosMap_.find(key); + if (removeTask == continuousTaskInfosMap_.end()) { + return false; + } + if (StopBackgroundRunningByTask(removeTask->second) == ERR_OK) { + return true; + } + return true; +} + void BgContinuousTaskMgr::OnRemoteSubscriberDied(const wptr &object) { if (!isSysReady_.load()) { @@ -1698,27 +1882,11 @@ void BgContinuousTaskMgr::OnAbilityStateChanged(int32_t uid, const std::string & BGTASK_LOGW("manager is not ready"); return; } - auto iter = continuousTaskInfosMap_.begin(); - while (iter != continuousTaskInfosMap_.end()) { - if (iter->second->uid_ == uid && iter->second->abilityName_ == abilityName && - iter->second->abilityId_ == abilityId) { - auto record = iter->second; - BGTASK_LOGI("OnAbilityStateChanged uid: %{public}d, bundleName: %{public}s abilityName: %{public}s" - "bgModeId: %{public}d, abilityId: %{public}d", uid, record->bundleName_.c_str(), - record->abilityName_.c_str(), record->bgModeId_, record->abilityId_); - record->reason_ = SYSTEM_CANCEL; - OnContinuousTaskChanged(record, ContinuousTaskEventTriggerType::TASK_CANCEL); - if (!iter->second->isFromWebview_) { - NotificationTools::GetInstance()->CancelNotification( - record->GetNotificationLabel(), record->GetNotificationId()); - } - iter = continuousTaskInfosMap_.erase(iter); - HandleAppContinuousTaskStop(record->uid_); - RefreshTaskRecord(); - } else { - iter++; - } + if (abilityName.empty()) { + BGTASK_LOGE("abilityName is empty!"); + return; } + StopBackgroundRunningByContext(uid, abilityName, abilityId); } void BgContinuousTaskMgr::OnAppStopped(int32_t uid) diff --git a/services/continuous_task/src/continuous_task_record.cpp b/services/continuous_task/src/continuous_task_record.cpp index 608720f926e271ace8d059c9541d3adb19149f95..143d3638ba9141edcdd914c85fc6070b31ddc9a2 100644 --- a/services/continuous_task/src/continuous_task_record.cpp +++ b/services/continuous_task/src/continuous_task_record.cpp @@ -179,6 +179,9 @@ std::string ContinuousTaskRecord::ParseToJsonStr() root["abilityId"] = abilityId_; root["suspendState"] = suspendState_; root["suspendReason"] = suspendReason_; + root["isCombinedTaskNotification"] = isCombinedTaskNotification_; + root["combinedNotificationTaskId"] = combinedNotificationTaskId_; + root["isByRequestObject"] = isByRequestObject_; return root.dump(CommonUtils::jsonFormat_); } @@ -190,14 +193,17 @@ bool CheckContinuousRecod(const nlohmann::json &value) || !value["isNewApi"].is_boolean() || !value["isFromWebview"].is_boolean() || !value["notificationLabel"].is_string() || !value["isSystem"].is_boolean() || !value["continuousTaskId"].is_number_integer() || !value["abilityId"].is_number_integer() - || !value["suspendState"].is_boolean() || !value["suspendReason"].is_number_integer(); + || !value["suspendState"].is_boolean() || !value["suspendReason"].is_number_integer() + || !value["isCombinedTaskNotification"].is_boolean() || !value["combinedNotificationTaskId"].is_number_integer() + || !value["isByRequestObject"].is_boolean(); } bool ContinuousTaskRecord::ParseFromJson(const nlohmann::json &value) { if (value.is_null() || !value.is_object() || !CommonUtils::CheckJsonValue(value, { "bundleName", "abilityName", "userId", "uid", "pid", "bgModeId", "isNewApi", "isFromWebview", "notificationLabel", - "isSystem", "continuousTaskId", "abilityId", "suspendState", "suspendReason"})) { + "isSystem", "continuousTaskId", "abilityId", "suspendState", "suspendReason", "isCombinedTaskNotification", + "combinedNotificationTaskId", "isByRequestObject"})) { BGTASK_LOGE("continuoustaskrecord no key"); return false; } @@ -237,6 +243,11 @@ void ContinuousTaskRecord::SetRecordValue(const nlohmann::json &value) this->isSystem_ = value.at("isSystem").get(); this->continuousTaskId_ = value.at("continuousTaskId").get(); this->abilityId_ = value.at("abilityId").get(); + this->suspendState_ = value.at("suspendState").get(); + this->suspendReason_ = value.at("suspendReason").get(); + this->isCombinedTaskNotification_ = value.at("isCombinedTaskNotification").get(); + this->combinedNotificationTaskId_ = value.at("combinedNotificationTaskId").get(); + this->isByRequestObject_ = value.at("isByRequestObject").get(); if (value.contains("isBatchApi") && value["isBatchApi"].is_boolean()) { this->isBatchApi_ = value.at("isBatchApi").get(); } diff --git a/services/continuous_task/src/notification_tools.cpp b/services/continuous_task/src/notification_tools.cpp index fe7503af24320bfe358469170d2d6b34dcf13211..11f9a1471eb3610a560c486edf2290191ce386ba 100644 --- a/services/continuous_task/src/notification_tools.cpp +++ b/services/continuous_task/src/notification_tools.cpp @@ -20,6 +20,7 @@ #include "notification_helper.h" #endif #include "continuous_task_log.h" +#include "common_utils.h" #include "string_wrapper.h" #ifdef BGTASK_MGR_UNIT_TEST @@ -54,14 +55,17 @@ void NotificationTools::SetNotificationIdIndex(const int32_t id) notificationIdIndex_ = id; } -std::string CreateNotificationLabel(int32_t uid, const std::string &bundleName, - const std::string &abilityName, int32_t abilityId) +std::string CreateNotificationLabel(int32_t uid, const std::string &abilityName, int32_t abilityId, + bool isByRequestObject, const std::vector &bgModeIds) { std::stringstream stream; stream.clear(); stream.str(""); stream << NOTIFICATION_PREFIX << SEPARATOR << uid << SEPARATOR << std::hash()(abilityName) << SEPARATOR << abilityId; + if (isByRequestObject) { + stream << SEPARATOR << CommonUtils::ModesToString(bgModeIds); + } std::string label = stream.str(); BGTASK_LOGD("notification label: %{public}s", label.c_str()); return label; @@ -91,8 +95,8 @@ WEAK_FUNC ErrCode NotificationTools::PublishNotification( extraInfo->SetParam("abilityName", AAFwk::String::Box(continuousTaskRecord->abilityName_)); std::string notificationLabel = CreateNotificationLabel(continuousTaskRecord->uid_, - continuousTaskRecord->bundleName_, continuousTaskRecord->abilityName_, - continuousTaskRecord->abilityId_); + continuousTaskRecord->abilityName_, continuousTaskRecord->abilityId_, + continuousTaskRecord->isByRequestObject_, continuousTaskRecord->bgModeIds_); Notification::NotificationRequest notificationRequest = Notification::NotificationRequest(); notificationRequest.SetContent(std::make_shared(liveContent)); diff --git a/services/continuous_task/src/task_notification_subscriber.cpp b/services/continuous_task/src/task_notification_subscriber.cpp index a13c6c7d3190260c1b0809a45850116e3cb0ddc8..cbc126bc98fdda3c7ab9232e841caf624bb2fc43 100644 --- a/services/continuous_task/src/task_notification_subscriber.cpp +++ b/services/continuous_task/src/task_notification_subscriber.cpp @@ -30,8 +30,9 @@ static constexpr char LABEL_SPLITER = '_'; static constexpr char NOTIFICATION_PREFIX[] = "bgmode"; static constexpr uint32_t LABEL_BGMODE_PREFIX_POS = 0; static constexpr uint32_t LABEL_APP_UID_POS = 1; -static constexpr uint32_t LABEL_SIZE = 4; +static constexpr uint32_t LABEL_SIZE = 5; static constexpr uint32_t LABEL_ABILITYID_INDEX = 3; +static constexpr uint32_t LABEL_MODE_INDEX = 4; } std::shared_ptr TaskNotificationSubscriber::continuousTaskMgr_ @@ -63,7 +64,7 @@ void TaskNotificationSubscriber::OnCanceled(const std::shared_ptr labelSplits = StringSplit(notificationLabel, LABEL_SPLITER); if (labelSplits.empty() || labelSplits[LABEL_BGMODE_PREFIX_POS] != NOTIFICATION_PREFIX - || labelSplits.size() != LABEL_SIZE) { + || labelSplits.size() > LABEL_SIZE || labelSplits.size() < LABEL_SIZE - 1) { BGTASK_LOGW("callback notification label is invalid"); return; } @@ -84,7 +85,9 @@ void TaskNotificationSubscriber::OnCanceled(const std::shared_ptrGetParam("abilityName"))); std::string taskInfoMapKey = labelSplits[LABEL_APP_UID_POS] + LABEL_SPLITER + abilityName + LABEL_SPLITER + labelSplits[LABEL_ABILITYID_INDEX]; - + if (labelSplits.size() == LABEL_SIZE) { + taskInfoMapKey = taskInfoMapKey + LABEL_SPLITER + labelSplits[LABEL_MODE_INDEX]; + } if (continuousTaskMgr_->StopContinuousTaskByUser(taskInfoMapKey)) { BGTASK_LOGI("remove continuous task record Key: %{public}s", taskInfoMapKey.c_str()); } diff --git a/services/core/src/background_task_mgr_service.cpp b/services/core/src/background_task_mgr_service.cpp index 9d0d0ca04c2ffa293f685741a68c4133386d1b22..3f1f5b325a975ff581b249366bf6fd55a8b40f0f 100644 --- a/services/core/src/background_task_mgr_service.cpp +++ b/services/core/src/background_task_mgr_service.cpp @@ -200,6 +200,9 @@ ErrCode BackgroundTaskMgrService::StartBackgroundRunning(const ContinuousTaskPar int32_t& notificationId, int32_t& continuousTaskId) { if (CheckAtomicService()) { + if (taskParam.isByRequestObject_) { + return ERR_BGTASK_PERMISSION_DENIED; + } for (const auto mode : taskParam.bgModeIds_) { if (mode != BackgroundMode::AUDIO_PLAYBACK && mode != BackgroundMode::MULTI_DEVICE_CONNECTION) { pid_t callingPid = IPCSkeleton::GetCallingPid(); @@ -223,6 +226,9 @@ ErrCode BackgroundTaskMgrService::UpdateBackgroundRunning(const ContinuousTaskPa int32_t& notificationId, int32_t& continuousTaskId) { if (CheckAtomicService()) { + if (taskParam.isByRequestObject_) { + return ERR_BGTASK_PERMISSION_DENIED; + } for (const auto mode : taskParam.bgModeIds_) { if (mode != BackgroundMode::AUDIO_PLAYBACK && mode != BackgroundMode::MULTI_DEVICE_CONNECTION) { pid_t callingPid = IPCSkeleton::GetCallingPid(); diff --git a/services/test/unittest/bg_continuous_task_mgr_test.cpp b/services/test/unittest/bg_continuous_task_mgr_test.cpp index 995cfa39e23681a5eba4d41ee3a26558020b41bf..fcd082fe2036e61e19ae37c687dff0ecf6847dd4 100644 --- a/services/test/unittest/bg_continuous_task_mgr_test.cpp +++ b/services/test/unittest/bg_continuous_task_mgr_test.cpp @@ -50,6 +50,7 @@ static constexpr int32_t TEST_NUM_TWO = 2; static constexpr int32_t TEST_NUM_THREE = 3; static constexpr uint32_t CONFIGURE_ALL_MODES = 0x1FF; static constexpr char BG_TASK_SUB_MODE_TYPE[] = "subMode"; +static constexpr char SEPARATOR[] = "_"; } class BgContinuousTaskMgrTest : public testing::Test { public: @@ -573,20 +574,6 @@ HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_008, TestSize.Level1) EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK); } -/** - * @tc.name: BgTaskManagerUnitTest_009 - * @tc.desc: test RemoveContinuousTaskRecord. - * @tc.type: FUNC - * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V - */ -HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_009, TestSize.Level1) -{ - EXPECT_FALSE(bgContinuousTaskMgr_->RemoveContinuousTaskRecord("key")); - std::shared_ptr continuousTaskRecord = std::make_shared(); - bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord; - EXPECT_TRUE(bgContinuousTaskMgr_->RemoveContinuousTaskRecord("key")); -} - /** * @tc.name: BgTaskManagerUnitTest_010 * @tc.desc: test StopContinuousTaskByUser. @@ -849,9 +836,11 @@ HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_035, TestSize.Level1) bgContinuousTaskMgr_->HandleStopContinuousTask(1, 0, 0xFF, ""); EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0); - bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1; + std::string mapKey = std::to_string(continuousTaskRecord1->uid_) + SEPARATOR + continuousTaskRecord1->abilityName_ + + SEPARATOR + std::to_string(continuousTaskRecord1->abilityId_); + bgContinuousTaskMgr_->continuousTaskInfosMap_[mapKey] = continuousTaskRecord1; EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 1); - bgContinuousTaskMgr_->HandleStopContinuousTask(1, 0, 0, "key1"); + bgContinuousTaskMgr_->HandleStopContinuousTask(1, 0, 0, mapKey); EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0); } @@ -1442,5 +1431,163 @@ HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_058, TestSize.Level1) bgContinuousTaskMgr_->HandleSuspendContinuousAudioTask(1); EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0); } + +/** + * @tc.name: BgTaskManagerUnitTest_059 + * @tc.desc: test CheckCombinedTaskNotifacation. + * @tc.type: FUNC + * @tc.require: issueICUX92 + */ +HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_059, TestSize.Level1) +{ + bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); + bool sendNotification = true; + std::shared_ptr continuousTaskRecord = std::make_shared(); + continuousTaskRecord->uid_ = TEST_NUM_ONE; + continuousTaskRecord->bgModeId_ = 2; + continuousTaskRecord->isByRequestObject_ = true; + continuousTaskRecord->bgModeIds_.push_back(continuousTaskRecord->bgModeId_); + // 不需要合并 + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), ERR_OK); + + continuousTaskRecord->combinedNotificationTaskId_ = TEST_NUM_ONE; + continuousTaskRecord->isCombinedTaskNotification_ = true; + bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = nullptr; + // 需要合并，但没有任务 + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + ERR_BGTASK_CONTINUOUS_TASKID_INVALID); + + bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); + std::shared_ptr continuousTaskRecord2 = std::make_shared(); + continuousTaskRecord2->uid_ = TEST_NUM_ONE + 1; + continuousTaskRecord2->bgModeId_ = 2; + continuousTaskRecord2->bgModeIds_.push_back(continuousTaskRecord->bgModeId_); + bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; + // 需要合并，任务uid不相等 + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + ERR_BGTASK_CONTINUOUS_TASKID_INVALID); + + bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); + continuousTaskRecord2->continuousTaskId_ = TEST_NUM_ONE + 1; + // 需要合并，任务id不相等 + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + ERR_BGTASK_CONTINUOUS_TASKID_INVALID); +} + +/** + * @tc.name: BgTaskManagerUnitTest_060 + * @tc.desc: test CheckCombinedTaskNotifacation. + * @tc.type: FUNC + * @tc.require: issueICUX92 + */ +HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_060, TestSize.Level1) +{ + bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); + bool sendNotification = true; + std::shared_ptr continuousTaskRecord = std::make_shared(); + continuousTaskRecord->uid_ = TEST_NUM_ONE; + continuousTaskRecord->combinedNotificationTaskId_ = TEST_NUM_ONE; + continuousTaskRecord->isCombinedTaskNotification_ = true; + continuousTaskRecord->isByRequestObject_ = true; + std::shared_ptr continuousTaskRecord2 = std::make_shared(); + continuousTaskRecord2->uid_ = TEST_NUM_ONE; + continuousTaskRecord2->continuousTaskId_ = TEST_NUM_ONE; + continuousTaskRecord2->isCombinedTaskNotification_ = false; + bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; + // 需要合并，任务不支持合并 + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(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), + ERR_BGTASK_CONTINUOUS_NOT_MERGE_NOTIFICATION_NOT_EXIST); + bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); + continuousTaskRecord->bgModeId_ = 2; + continuousTaskRecord->bgModeIds_.clear(); + continuousTaskRecord->bgModeIds_.push_back(2); + continuousTaskRecord2->bgModeId_ = 3; + continuousTaskRecord2->bgModeIds_.clear(); + continuousTaskRecord2->bgModeIds_.push_back(3); + continuousTaskRecord2->notificationId_ = 1; + bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; + // 需要合并，任务主类型不相等 + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_TYPE_MISMATCH); + bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); + continuousTaskRecord->bgSubModeIds_.clear(); + continuousTaskRecord->bgSubModeIds_.push_back(2); + continuousTaskRecord2->bgSubModeIds_.clear(); + continuousTaskRecord2->bgSubModeIds_.push_back(3); + bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; + // 需要合并，任务子类型不相等 + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + ERR_BGTASK_CONTINUOUS_MODE_OR_SUBMODE_TYPE_MISMATCH); +} + +/** + * @tc.name: BgTaskManagerUnitTest_061 + * @tc.desc: test CheckCombinedTaskNotifacation. + * @tc.type: FUNC + * @tc.require: issueICUX92 + */ +HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_061, TestSize.Level1) +{ + bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); + bool sendNotification = true; + std::shared_ptr continuousTaskRecord = std::make_shared(); + continuousTaskRecord->uid_ = TEST_NUM_ONE; + continuousTaskRecord->combinedNotificationTaskId_ = TEST_NUM_ONE; + continuousTaskRecord->isCombinedTaskNotification_ = true; + continuousTaskRecord->bgModeId_ = 1; + continuousTaskRecord->bgModeIds_.clear(); + continuousTaskRecord->bgModeIds_.push_back(1); + continuousTaskRecord->bgSubModeIds_.clear(); + continuousTaskRecord->bgSubModeIds_.push_back(2); + continuousTaskRecord->isByRequestObject_ = true; + + std::shared_ptr continuousTaskRecord2 = std::make_shared(); + continuousTaskRecord2->uid_ = TEST_NUM_ONE; + continuousTaskRecord2->continuousTaskId_ = TEST_NUM_ONE; + continuousTaskRecord2->isCombinedTaskNotification_ = true; + continuousTaskRecord2->bgModeId_ = 1; + continuousTaskRecord2->bgModeIds_.clear(); + continuousTaskRecord2->bgModeIds_.push_back(1); + continuousTaskRecord2->bgSubModeIds_.clear(); + continuousTaskRecord2->bgSubModeIds_.push_back(2); + continuousTaskRecord2->notificationId_ = 1; + bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; + // 需要合并，任务类型包含上传下载，不能合并 + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + ERR_BGTASK_CONTINUOUS_DATA_TRANSFER_NOT_MERGE_NOTIFICATION); + + bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); + continuousTaskRecord->bgModeId_ = 4; + continuousTaskRecord->bgModeIds_.clear(); + continuousTaskRecord->bgModeIds_.push_back(4); + continuousTaskRecord->bgSubModeIds_.clear(); + continuousTaskRecord->bgSubModeIds_.push_back(1); + + continuousTaskRecord2->bgModeId_ = 4; + continuousTaskRecord2->bgModeIds_.clear(); + continuousTaskRecord2->bgModeIds_.push_back(4); + continuousTaskRecord2->bgSubModeIds_.clear(); + continuousTaskRecord2->bgSubModeIds_.push_back(1); + bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord2; + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), ERR_OK); +} + +/** + * @tc.name: BgTaskManagerUnitTest_062 + * @tc.desc: start background runnging use api 21 api test. + * @tc.type: FUNC + * @tc.require: issueICUX92 + */ +HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_062, TestSize.Level1) +{ + EXPECT_EQ(bgContinuousTaskMgr_->StopBackgroundRunning("ability1", 1, 1), ERR_BGTASK_OBJECT_NOT_EXIST); +} } // namespace BackgroundTaskMgr } // namespace OHOS \ No newline at end of file