diff --git a/frameworks/common/include/bgtaskmgr_inner_errors.h b/frameworks/common/include/bgtaskmgr_inner_errors.h index c20f81a1406a55d44ebc3eafca980f1e22bbacb3..63d631fe2b8d79f879065868ab8a86a7342db541 100644 --- a/frameworks/common/include/bgtaskmgr_inner_errors.h +++ b/frameworks/common/include/bgtaskmgr_inner_errors.h @@ -49,12 +49,16 @@ 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, + ERR_BGTASK_CONTINUOUS_NOT_MERGE_NOTIFICATION_NOT_EXIST, + ERR_BGTASK_CONTINUOUS_NOT_MERGE_COMINED_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 2c8f8f7093f7c3dfc7f704fae14aeb84beec964e..cc25b58243ced0d8fb7849cf63df758b9072643d 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" @@ -266,13 +266,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 a690fd16a2ac54e7c53aebb0f49db7239d24b330..6c7d5b2a382ae80d482a5fefb1669bb7f99d29ec 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 8c1afab209f7098c28b55c14d582c7b584e989a6..ba7b073d151fc8d2c520c055fb00faa845f67027 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 4f9bde23a185a9ef3cdefd4556f4291275751d05..b5e35becf82eb617fcfd2cb2fbd48e9c83e640d6 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 { @@ -208,13 +208,6 @@ public: * @return Returns ERR_OK if success, else failure. */ 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 cec64e69f4fa15a9a7f2db9c23b035c73f066aad..218619e6bf7af392218e7a1dc60b3cf56494a818 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..1ef2c4493577609e6fba931edbe51859ace3660b 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,12 @@ struct AsyncCallbackInfo : public AsyncWorkData { std::vector bgModes {}; bool isBatchApi {false}; bool includeSuspended {false}; + std::shared_ptr request = std::make_shared(); 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; @@ -634,6 +630,104 @@ 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_; +} + +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; + } + 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 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 +748,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) { @@ -1131,152 +1235,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 +1264,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..5d9a546359e02cdecafde133dabd68911fafa9c1 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,18 @@ 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, + "Continuous Task verification failed. This continuous task mode: DATA_TRANSFER type do not support merged."}, + {ERR_BGTASK_CONTINUOUS_NOT_MERGE_NOTIFICATION_NOT_EXIST, + "Continuous Task verification failed. This continuous task notification dose not exist and cannot be merged."}, + {ERR_BGTASK_CONTINUOUS_NOT_MERGE_COMINED_FALSE, + "Continuous Task verification failed. This continuous task do not support merged."}, }; const std::map PARAM_ERRCODE_MSG_MAP = { @@ -603,126 +615,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 +644,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 +664,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 +683,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 +705,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 +724,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 +751,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; } @@ -874,5 +792,29 @@ bool Common::GetBoolProperty(napi_env env, napi_value object, const std::string 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/continuous_task/include/bg_continuous_task_mgr.h b/services/continuous_task/include/bg_continuous_task_mgr.h index ca044ac12938e169d666cdf28270187366e332b5..8eb16564d57a5fd601bee0f340efb9d96c2e7526 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" @@ -178,6 +181,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..36db343a2f5968753883ab54ecc176e20d4e654d 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."); @@ -793,6 +802,10 @@ ErrCode BgContinuousTaskMgr::UpdateBackgroundRunningInner(const std::string &tas } auto continuousTaskRecord = iter->second; + if (continuousTaskRecord->isByRequestObject_) { + BGTASK_LOGE("continuous task: %{public}s is apply by new interface, cannot update", taskInfoMapKey.c_str()); + return ERR_BGTASK_CONTINUOUS_NOT_UPDATE_BY_OLD_INTERFACE; + } auto oldModes = continuousTaskRecord->bgModeIds_; BGTASK_LOGI("continuous task mode %{public}d, old modes: %{public}s, new modes %{public}s, isBatchApi %{public}d," @@ -878,8 +891,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 +909,58 @@ ErrCode BgContinuousTaskMgr::StartBackgroundRunningInner(std::shared_ptr &recordParam, + bool &sendNotification) +{ + // 无需合并，新申请 + int32_t mergeNotificationTaskId = recordParam->combinedNotificationTaskId_; + if (mergeNotificationTaskId == -1) { + sendNotification = true; + return ERR_OK; + } + ErrCode ret = ERR_BGTASK_CONTINUOUS_TASKID_INVALID; + for (const auto &record : continuousTaskInfosMap_) { + if (!record.second || record.second->uid_ != recordParam->uid_ || + record.second->GetContinuousTaskId() != mergeNotificationTaskId) { + continue; + } + if (!record.second->isCombinedTaskNotification_) { + ret = ERR_BGTASK_CONTINUOUS_NOT_MERGE_COMINED_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; + 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 +1003,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); if (continuousTaskRecord->bgModeIds_.size() == 1 && continuousTaskRecord->bgModeIds_[0] == BackgroundMode::AUDIO_PLAYBACK) { - if (isPublish) { + if (isPublishAvsession) { return ERR_OK; } } @@ -950,8 +1021,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); 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; } @@ -1011,9 +1085,7 @@ ErrCode BgContinuousTaskMgr::StopBackgroundRunning(const std::string &abilityNam return ERR_BGTASK_INVALID_PARAM; } int32_t callingUid = IPCSkeleton::GetCallingUid(); - ErrCode result = ERR_OK; - HitraceScoped traceScoped(HITRACE_TAG_OHOS, "BackgroundTaskManager::ContinuousTask::Service::StopBackgroundRunningInner"); handler_->PostSyncTask([this, callingUid, abilityName, abilityId, &result]() { @@ -1037,12 +1109,24 @@ ErrCode BgContinuousTaskMgr::StopBackgroundRunningInner(int32_t uid, const std:: 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 recond = continuousTaskInfosMap_.at(mapKey); + std::string notificationLabel = recond->GetNotificationLabel(); + int32_t notificationId = recond->GetNotificationId(); + OnContinuousTaskChanged(recond, ContinuousTaskEventTriggerType::TASK_CANCEL); + continuousTaskInfosMap_.erase(mapKey); + 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); ErrCode result = ERR_OK; - if (iter->second->GetNotificationId() != -1) { - result = NotificationTools::GetInstance()->CancelNotification( - iter->second->GetNotificationLabel(), iter->second->GetNotificationId()); + if (findNotificationIter == continuousTaskInfosMap_.end() && notificationId != -1) { + result = NotificationTools::GetInstance()->CancelNotification(notificationLabel, notificationId); } - RemoveContinuousTaskRecord(mapKey); + + HandleAppContinuousTaskStop(recond->uid_); + RefreshTaskRecord(); return result; } @@ -1155,10 +1239,23 @@ 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 recond = continuousTaskInfosMap_.at(key); + std::string notificationLabel = recond->GetNotificationLabel(); + int32_t notificationId = recond->GetNotificationId(); SetReason(key, FREEZE_CANCEL); - RemoveContinuousTaskRecord(key); + OnContinuousTaskChanged(recond, ContinuousTaskEventTriggerType::TASK_CANCEL); + continuousTaskInfosMap_.erase(key); + 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() && notificationId != -1) { + NotificationTools::GetInstance()->CancelNotification(notificationLabel, notificationId); + } + HandleAppContinuousTaskStop(recond->uid_); + RefreshTaskRecord(); } void BgContinuousTaskMgr::SuspendContinuousTask(int32_t uid, int32_t pid, int32_t reason, const std::string &key) @@ -1239,6 +1336,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; + int32_t notificationOldId = ILLELG_NOTIFICATION_ID; auto iter = continuousTaskInfosMap_.begin(); while (iter != continuousTaskInfosMap_.end()) { if (iter->second->GetUid() != uid || !iter->second->suspendState_) { @@ -1248,7 +1355,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 || notificationOldId == ILLELG_NOTIFICATION_ID || + notificationOldId != iter->second->notificationId_) { + notificationOldId = 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 +1565,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 +1710,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 +1744,22 @@ void BgContinuousTaskMgr::DumpCancelTask(const std::vector &dumpOpt if (iter == continuousTaskInfosMap_.end()) { return; } - NotificationTools::GetInstance()->CancelNotification(iter->second->GetNotificationLabel(), - iter->second->GetNotificationId()); - RemoveContinuousTaskRecord(taskKey); + auto record = continuousTaskInfosMap_.at(taskKey); + std::string notificationLabel = record->GetNotificationLabel(); + int32_t notificationId = record->GetNotificationId(); + OnContinuousTaskChanged(record, ContinuousTaskEventTriggerType::TASK_CANCEL); + continuousTaskInfosMap_.erase(taskKey); + auto findNotification = [notificationId, notificationLabel](const auto &target) { + return notificationId == target.second->GetNotificationId() && + notificationLabel == target.second->GetNotificationLabel(); + }; + auto findNotificationIter = find_if(continuousTaskInfosMap_.begin(), continuousTaskInfosMap_.end(), + findNotification); + if (findNotificationIter == continuousTaskInfosMap_.end() && notificationId != -1) { + NotificationTools::GetInstance()->CancelNotification(notificationLabel, notificationId); + } + HandleAppContinuousTaskStop(record->uid_); + RefreshTaskRecord(); } } @@ -1656,11 +1798,34 @@ 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; + } + std::string notificationLabel = removeTask->second->GetNotificationLabel(); + int32_t notificationId = removeTask->second->GetNotificationId(); + auto iter = continuousTaskInfosMap_.begin(); + while (iter != continuousTaskInfosMap_.end()) { + if (iter->second->GetNotificationId() == notificationId && + iter->second->GetNotificationLabel() == notificationLabel) { + OnContinuousTaskChanged(iter->second, ContinuousTaskEventTriggerType::TASK_CANCEL); + HandleAppContinuousTaskStop(iter->second->uid_); + iter = continuousTaskInfosMap_.erase(iter); + RefreshTaskRecord(); + } else { + iter++; + } + } + return true; +} + void BgContinuousTaskMgr::OnRemoteSubscriberDied(const wptr &object) { if (!isSysReady_.load()) { @@ -1698,6 +1863,16 @@ void BgContinuousTaskMgr::OnAbilityStateChanged(int32_t uid, const std::string & BGTASK_LOGW("manager is not ready"); return; } + auto findTask = [uid, abilityName, abilityId](const auto &target) { + return uid == target.second->uid_ && abilityName == target.second->abilityName_ && + abilityId == target.second->abilityId_; + }; + auto findTaskIter = find_if(continuousTaskInfosMap_.begin(), continuousTaskInfosMap_.end(), findTask); + if (findTaskIter == continuousTaskInfosMap_.end()) { + return; + } + std::string notificationLabel = findTaskIter->second->GetNotificationLabel(); + int32_t notificationId = findTaskIter->second->GetNotificationId(); auto iter = continuousTaskInfosMap_.begin(); while (iter != continuousTaskInfosMap_.end()) { if (iter->second->uid_ == uid && iter->second->abilityName_ == abilityName && @@ -1708,11 +1883,16 @@ void BgContinuousTaskMgr::OnAbilityStateChanged(int32_t uid, const std::string & 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); + auto findNotification = [notificationId, notificationLabel](const auto &target) { + return notificationId == target.second->GetNotificationId() && + notificationLabel == target.second->GetNotificationLabel(); + }; + auto findNotificationIter = find_if(continuousTaskInfosMap_.begin(), continuousTaskInfosMap_.end(), + findNotification); + if (findNotificationIter == continuousTaskInfosMap_.end() && notificationId != -1) { + NotificationTools::GetInstance()->CancelNotification(notificationLabel, notificationId); + } HandleAppContinuousTaskStop(record->uid_); RefreshTaskRecord(); } else { 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/core/src/background_task_mgr_service.cpp b/services/core/src/background_task_mgr_service.cpp index d2d698ac34c3e60cbaa639f18c7068e27b962348..24fffec13cc509290fd9e59b7d7f10b5ebd3c811 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..4f3ac04a8e2a782c14d16b73898f2cb2c62633b2 100644 --- a/services/test/unittest/bg_continuous_task_mgr_test.cpp +++ b/services/test/unittest/bg_continuous_task_mgr_test.cpp @@ -1442,5 +1442,140 @@ 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->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; + EXPECT_EQ(bgContinuousTaskMgr_->CheckCombinedTaskNotifacation(continuousTaskRecord, sendNotification), + ERR_BGTASK_CONTINUOUS_TASKID_INVALID); + + bgContinuousTaskMgr_->continuousTaskInfosMap_.clear(); + continuousTaskRecord2->continuousTaskId_ = TEST_NUM_ONE + 1; + 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; + 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_COMINED_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); + + 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); + + 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); +} } // namespace BackgroundTaskMgr } // namespace OHOS \ No newline at end of file