diff --git a/window_scene/interfaces/include/ws_common.h b/window_scene/interfaces/include/ws_common.h
index 6e5e9e6c7e2dd0aa363953cd53b9d2d76a0e8f17..7551483f8b92f530058cfbc38a9b8b92ef94d5de 100644
--- a/window_scene/interfaces/include/ws_common.h
+++ b/window_scene/interfaces/include/ws_common.h
@@ -46,6 +46,7 @@ using ScreenId = uint64_t;
 
 constexpr int32_t ROTATE_ANIMATION_DURATION = 400;
 constexpr int32_t INVALID_SESSION_ID = 0;
+constexpr int32_t MIN_REQUEST_ID_FROM_ABILITY = 1;
 constexpr int32_t DEFAULT_REQUEST_FROM_SCB_ID = -1;
 constexpr int32_t WINDOW_SUPPORT_MODE_MAX_SIZE = 4;
 constexpr int32_t DEFAULT_SCALE_RATIO = 100;
@@ -512,6 +513,10 @@ struct SessionInfo {
     std::shared_ptr<StartAnimationSystemOptions> startAnimationSystemOptions = nullptr;
 };
 
+struct RequestTaskInfo {
+    std::unordered_map<int32_t, AAFwk::Want> requestIdToWantMap;
+};
+
 enum class SessionFlag : uint32_t {
     SESSION_FLAG_NEED_AVOID = 1,
     SESSION_FLAG_PARENT_LIMIT = 1 << 1,
diff --git a/window_scene/interfaces/kits/napi/scene_session_manager/js_root_scene_session.cpp b/window_scene/interfaces/kits/napi/scene_session_manager/js_root_scene_session.cpp
index 56e5cd08cf5b2192a78e7c81b8e92fcf274e0bbc..783de2024d58b2e39206296c3bfb5cbd1f07dfd3 100644
--- a/window_scene/interfaces/kits/napi/scene_session_manager/js_root_scene_session.cpp
+++ b/window_scene/interfaces/kits/napi/scene_session_manager/js_root_scene_session.cpp
@@ -444,6 +444,7 @@ void JsRootSceneSession::PendingSessionActivation(SessionInfo& info)
 
     sceneSession->SetSessionInfo(info);
     std::shared_ptr<SessionInfo> sessionInfo = std::make_shared<SessionInfo>(info);
+    SceneSessionManager::GetInstance().AddRequestTaskInfo(info);
     auto task = [this, sessionInfo]() {
         PendingSessionActivationInner(sessionInfo);
     };
diff --git a/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_session.cpp b/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_session.cpp
index a35cb8653a52afc3f15f264c41d8aa75e9d43e51..ecac2e5e4edc0cb4d5b6b2d786170d5a7426de2f 100644
--- a/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_session.cpp
+++ b/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_session.cpp
@@ -4588,7 +4588,7 @@ void JsSceneSession::ChangeSessionVisibilityWithStatusBarInner(std::shared_ptr<S
         jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr);
 }
 
-sptr<SceneSession> JsSceneSession::GenSceneSession(SessionInfo& info)
+sptr<SceneSession> JsSceneSession::GenSceneSession(SessionInfo& info, bool needAddRequestInfo)
 {
     sptr<SceneSession> sceneSession = nullptr;
     if (info.persistentId_ == 0) {
@@ -4617,6 +4617,7 @@ sptr<SceneSession> JsSceneSession::GenSceneSession(SessionInfo& info)
             }
         } else {
             sceneSession->SetSessionInfo(info);
+            AddRequestTaskInfo(sceneSession, info, needAddRequestInfo);
         }
         info.persistentId_ = sceneSession->GetPersistentId();
         sceneSession->SetSessionInfoPersistentId(sceneSession->GetPersistentId());
@@ -4633,6 +4634,7 @@ sptr<SceneSession> JsSceneSession::GenSceneSession(SessionInfo& info)
             sceneSession->SetSessionInfoPersistentId(sceneSession->GetPersistentId());
         } else {
             sceneSession->SetSessionInfo(info);
+            AddRequestTaskInfo(sceneSession, info, needAddRequestInfo);
         }
     }
     return sceneSession;
@@ -4644,7 +4646,7 @@ void JsSceneSession::PendingSessionActivation(SessionInfo& info)
         "appIndex %{public}d, reuse %{public}d, requestId %{public}d, specifiedFlag %{public}s",
         info.bundleName_.c_str(), info.moduleName_.c_str(),
         info.abilityName_.c_str(), info.appIndex_, info.reuse, info.requestId, info.specifiedFlag_.c_str());
-    auto sceneSession = GenSceneSession(info);
+    auto sceneSession = GenSceneSession(info, true);
     if (sceneSession == nullptr) {
         TLOGE(WmsLogTag::WMS_LIFE, "GenSceneSession failed");
         return;
@@ -8127,4 +8129,13 @@ void JsSceneSession::OnAnimateToTargetProperty(const WindowAnimationProperty& an
         napi_call_function(env, NapiGetUndefined(env), jsCallback->GetNapiValue(), ArraySize(argv), argv, nullptr);
     }, __func__);
 }
+
+
+void JsSceneSession::AddRequestTaskInfo(sptr<SceneSession> sceneSession,
+    SessionInfo& info, bool needAddRequestInfo)
+{
+    if (needAddRequestInfo && sceneSession != nullptr) {
+        SceneSessionManager::GetInstance().AddRequestTaskInfo(sceneSession->GetPersistentId(), info);
+    }
+}
 } // namespace OHOS::Rosen
diff --git a/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_session.h b/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_session.h
index 8eea4aa1b245621f189e8b54d297a5806c06b174..6ef8959aaf27d4f29b594379f9242e67f9b7c1e9 100644
--- a/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_session.h
+++ b/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_session.h
@@ -144,7 +144,8 @@ private:
     void ProcessSessionLockStateChangeRegister();
     void ProcessSessionUpdateFollowScreenChange();
     void OnSessionLockStateChange(bool isLockedState);
-    sptr<SceneSession> GenSceneSession(SessionInfo& info);
+    sptr<SceneSession> GenSceneSession(SessionInfo& info, bool needAddRequestInfo = false);
+    void AddRequestTaskInfo(sptr<SceneSession> sceneSession, SessionInfo& info, bool needAddRequestInfo);
     void PendingSessionActivation(SessionInfo& info);
     void PendingSessionActivationInner(std::shared_ptr<SessionInfo> sessionInfo);
     void BatchPendingSessionsActivation(const std::vector<std::shared_ptr<SessionInfo>>& sessionInfos,
diff --git a/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_utils.cpp b/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_utils.cpp
index dc96cb876785e2dfbf1d37e531752ea6c4faf190..df8c80b2cea1773700da5ea3706733752f1dc067 100644
--- a/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_utils.cpp
+++ b/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_utils.cpp
@@ -1504,7 +1504,7 @@ void ProcessPendingSessionActivationResult(napi_env env, napi_value callResult,
     }
     if (resultCode >= static_cast<uint32_t>(RequestResultCode::FAIL)) {
         SceneSessionManager::GetInstance().NotifyAmsPendingSessionWhenFail(resultCode,
-            resultMessage, sessionInfo->requestId);
+            resultMessage, sessionInfo->requestId, sessionInfo->persistentId_);
     }
     TLOGI(WmsLogTag::WMS_LIFE, "persistentId:%{public}d, requestId:%{public}d,"
         "resultCode:%{public}d, resultMessage:%{public}s",
diff --git a/window_scene/session_manager/include/scene_session_manager.h b/window_scene/session_manager/include/scene_session_manager.h
index 3e4c67224508fb7f3728123afebb888eedb26795..6d9ac4fa9283b75a06f58daf0b11c40b929ab3a9 100644
--- a/window_scene/session_manager/include/scene_session_manager.h
+++ b/window_scene/session_manager/include/scene_session_manager.h
@@ -766,9 +766,14 @@ public:
     WMError GetRouterStackInfo(int32_t persistentId, const sptr<ISessionRouterStackListener>& listener);
     WMError CreateNewInstanceKey(const std::string& bundleName, std::string& instanceKey);
     WMError RemoveInstanceKey(const std::string& bundleName, const std::string& instanceKey);
+    void AddRequestTaskInfo(const SessionInfo& sessionInfo);
+    void AddRequestTaskInfo(int32_t requestId, const SessionInfo& sessionInfo);
+    std::shared_ptr<AAFwk::Want> GetRequestWantFromTaskInfoMap(int32_t persistentId, int32_t requestId);
+    void RemoveRequestTaskInfo(int32_t persistentId, int32_t requestId);
+    void ClearRequestTaskInfo(int32_t persistentId);
     void RefreshAllAppUseControlMap(const AppUseControlInfo& appUseControlInfo, ControlAppType type);
     void NotifyAmsPendingSessionWhenFail(uint32_t resultCode, std::string resultMessage,
-        int32_t requestId);
+        int32_t requestId, int32_t persistentId);
     WSError PendingSessionToBackgroundByPersistentId(const int32_t persistentId, bool shouldBackToCaller = true);
     WMError UpdateKioskAppList(const std::vector<std::string>& kioskAppList);
     WMError EnterKioskMode(const sptr<IRemoteObject>& token);
@@ -885,6 +890,8 @@ private:
     NotifySceneSessionDestructFunc onSceneSessionDestruct_;
     NotifyTransferSessionToTargetScreenFunc onTransferSessionToTargetScreen_;
     std::unordered_map<std::string, std::unordered_map<ControlAppType, ControlInfo>> allAppUseControlMap_;
+    std::unordered_map<int32_t, std::shared_ptr<RequestTaskInfo>> requestTaskInfoMap;
+    std::mutex requestTaskInfoMapMutex_;
     sptr<SceneSession> GetSceneSessionBySessionInfo(const SessionInfo& sessionInfo);
     void CreateRootSceneSession();
     void InitSceneSession(sptr<SceneSession>& sceneSession, const SessionInfo& sessionInfo,
@@ -902,7 +909,7 @@ private:
     bool IsSessionClearable(sptr<SceneSession> sceneSession);
     void GetAllClearableSessions(std::vector<sptr<SceneSession>>& sessionVector);
     sptr<AAFwk::SessionInfo> SetAbilitySessionInfo(const sptr<SceneSession>& sceneSession,
-        int32_t requestId = DEFAULT_REQUEST_FROM_SCB_ID);
+        int32_t requestId = DEFAULT_REQUEST_FROM_SCB_ID, bool useRequestTaskInfo = false);
     void ResetWantInfo(const sptr<SceneSession>& sceneSession);
     void ResetSceneSessionInfoWant(const sptr<AAFwk::SessionInfo>& sceneSessionInfo);
     int32_t StartUIAbilityBySCBTimeoutCheck(const sptr<SceneSession>& sceneSession,
diff --git a/window_scene/session_manager/src/scene_session_manager.cpp b/window_scene/session_manager/src/scene_session_manager.cpp
index 257ed963467aaf6e557aa8757f01a53ce5392966..dd8507f9369bf521cdc940f4c7ab64092c25ddca 100644
--- a/window_scene/session_manager/src/scene_session_manager.cpp
+++ b/window_scene/session_manager/src/scene_session_manager.cpp
@@ -2388,6 +2388,7 @@ sptr<SceneSession> SceneSessionManager::CreateSceneSession(const SessionInfo& se
     } else if (property == nullptr && SessionHelper::IsMainWindow(static_cast<WindowType>(sessionInfo.windowType_))) {
         sceneSession = new MainSession(sessionInfo, specificCb);
         TLOGI(WmsLogTag::WMS_MAIN, "Create MainSession, id: %{public}d", sceneSession->GetPersistentId());
+        AddRequestTaskInfo(sceneSession->GetPersistentId(), sessionInfo);
     } else if (property != nullptr && SessionHelper::IsSubWindow(property->GetWindowType())) {
         sceneSession = new SubSession(sessionInfo, specificCb);
         TLOGI(WmsLogTag::WMS_SUB, "Create SubSession, type: %{public}d", property->GetWindowType());
@@ -2858,6 +2859,7 @@ void SceneSessionManager::UpdateSceneSessionWant(const SessionInfo& sessionInfo)
             TLOGI(WmsLogTag::WMS_MAIN, "Get session id:%{public}d", sessionInfo.persistentId_);
             if (!CheckCollaboratorType(session->GetCollaboratorType())) {
                 session->SetSessionInfoWant(sessionInfo.want);
+                AddRequestTaskInfo(sessionInfo);
                 TLOGI(WmsLogTag::WMS_MAIN, "Want updated, id:%{public}d", sessionInfo.persistentId_);
             } else {
                 UpdateCollaboratorSessionWant(session, sessionInfo.persistentId_);
@@ -2882,7 +2884,7 @@ void SceneSessionManager::UpdateCollaboratorSessionWant(sptr<SceneSession>& sess
 }
 
 sptr<AAFwk::SessionInfo> SceneSessionManager::SetAbilitySessionInfo(const sptr<SceneSession>& sceneSession,
-    int32_t requestId)
+    int32_t requestId, bool useRequestTaskInfo)
 {
     const auto& sessionInfo = sceneSession->GetSessionInfo();
     auto abilitySessionInfo = sptr<AAFwk::SessionInfo>::MakeSptr();
@@ -2904,7 +2906,11 @@ sptr<AAFwk::SessionInfo> SceneSessionManager::SetAbilitySessionInfo(const sptr<S
     abilitySessionInfo->requestId = sessionInfo.requestId;
     abilitySessionInfo->reuseDelegatorWindow = sessionInfo.reuseDelegatorWindow;
     abilitySessionInfo->specifiedFlag = sessionInfo.specifiedFlag_;
-    if (sessionInfo.want != nullptr) {
+    std::shared_ptr<AAFwk::Want> requestWant = nullptr;
+    if (useRequestTaskInfo &&
+        (requestWant = GetRequestWantFromTaskInfoMap(sceneSession->GetPersistentId(), requestId)) != nullptr) {
+        abilitySessionInfo->want = *requestWant;
+    } else if (sessionInfo.want != nullptr) {
         abilitySessionInfo->want = sessionInfo.GetWantSafely();
     } else {
         abilitySessionInfo->want.SetElementName("", sessionInfo.bundleName_, sessionInfo.abilityName_,
@@ -3000,6 +3006,7 @@ WSError SceneSessionManager::RequestSceneSessionActivation(const sptr<SceneSessi
             sceneSession->SetExitSplitOnBackground(false);
         }
         abilityInfoMap_.clear(); // clear cache after terminate
+        RemoveRequestTaskInfo(sceneSession->GetPersistentId(), requestId);
         if (!isValid) {
             OHOS::HiviewDFX::HiTraceChain::End(hiTraceId);
         }
@@ -3012,9 +3019,10 @@ WSError SceneSessionManager::RequestSceneSessionActivation(const sptr<SceneSessi
 }
 
 void SceneSessionManager::NotifyAmsPendingSessionWhenFail(uint32_t resultCode, std::string resultMessage,
-        int32_t requestId)
+        int32_t requestId, int32_t persistentId)
 {
     TLOGE(WmsLogTag::WMS_LIFE, "failed, requestId:%{public}d", requestId);
+    RemoveRequestTaskInfo(persistentId, requestId);
     ffrtQueueHelper_->SubmitTask([requestId]{
          AAFwk::AbilityManagerClient::GetInstance()->NotifyStartupExceptionBySCB(requestId);
     });
@@ -3147,12 +3155,12 @@ WSError SceneSessionManager::RequestSceneSessionActivationInner(
             exceptionInfo.needRemoveSession = true;
             sceneSession->NotifySessionExceptionInner(SetAbilitySessionInfo(sceneSession), exceptionInfo);
             NotifyAmsPendingSessionWhenFail(static_cast<uint32_t>(RequestResultCode::FAIL),
-                "", sceneSession->GetSessionInfo().requestId);
+                "", sceneSession->GetSessionInfo().requestId, sceneSession->GetPersistentId());
             return WSError::WS_ERROR_PRE_HANDLE_COLLABORATOR_FAILED;
         }
     }
     sceneSession->NotifyActivation();
-    auto sceneSessionInfo = SetAbilitySessionInfo(sceneSession, requestId);
+    auto sceneSessionInfo = SetAbilitySessionInfo(sceneSession, requestId, true);
     sceneSessionInfo->isNewWant = isNewActive;
     if (CheckCollaboratorType(sceneSession->GetCollaboratorType())) {
         sceneSessionInfo->want.SetParam(AncoConsts::ANCO_MISSION_ID, sceneSessionInfo->persistentId);
@@ -3218,6 +3226,82 @@ WSError SceneSessionManager::RequestSceneSessionActivationInner(
     return WSError::WS_OK;
 }
 
+void SceneSessionManager::AddRequestTaskInfo(const SessionInfo& sessionInfo) {
+    AddRequestTaskInfo(sessionInfo.persistentId_, sessionInfo);
+}
+ 
+void SceneSessionManager::AddRequestTaskInfo(int32_t persistentId, const SessionInfo& sessionInfo) {
+    if (sessionInfo.requestId < MIN_REQUEST_ID_FROM_ABILITY ||
+        persistentId == INVALID_SESSION_ID ||
+        sessionInfo.want == nullptr) {
+        return;
+    }
+    AAFwk::Want wantTmp = sessionInfo.GetWantSafely();
+    size_t requestIdToWantMapSize = 0;
+    {
+        std::lock_guard<std::mutex> lock(requestTaskInfoMapMutex_);
+        if (requestTaskInfoMap.find(persistentId) == requestTaskInfoMap.end()) {
+            requestTaskInfoMap.emplace(persistentId, std::make_shared<RequestTaskInfo>());
+        }
+        auto& requestIdToWantMap = requestTaskInfoMap[persistentId]->requestIdToWantMap;
+        requestIdToWantMap[sessionInfo.requestId] = wantTmp;
+        requestIdToWantMapSize = requestIdToWantMap.size();
+    }
+    TLOGI(WmsLogTag::WMS_LIFE, "persistentId:%{public}d, requestId:%{public}d, "
+        "infoMap size:%{public}u, wantMap size:%{public}u",
+        persistentId, sessionInfo.requestId, requestTaskInfoMap.size(), requestIdToWantMapSize);
+}
+ 
+void SceneSessionManager::RemoveRequestTaskInfo(int32_t persistentId, int32_t requestId) {
+    if (requestId < MIN_REQUEST_ID_FROM_ABILITY || persistentId == INVALID_SESSION_ID) {
+        return;
+    }
+    {
+        std::lock_guard<std::mutex> lock(requestTaskInfoMapMutex_);
+        if (requestTaskInfoMap.find(persistentId) == requestTaskInfoMap.end()) {
+            return;
+        }
+        requestTaskInfoMap[persistentId]->requestIdToWantMap.erase(requestId);
+    }
+    TLOGI(WmsLogTag::WMS_LIFE, "persistentId:%{public}d, requestId:%{public}d, "
+        "infoMap size:%{public}u, wantMap size:%{public}u",
+        persistentId, requestId, requestTaskInfoMap.size(),
+        requestTaskInfoMap[persistentId]->requestIdToWantMap.size());
+}
+
+void SceneSessionManager::ClearRequestTaskInfo(int32_t persistentId) {
+    if (persistentId == INVALID_SESSION_ID) {
+        return;
+    }
+    {
+        std::lock_guard<std::mutex> lock(requestTaskInfoMapMutex_);
+        requestTaskInfoMap.erase(persistentId);
+    }
+    TLOGI(WmsLogTag::WMS_LIFE, "persistentId:%{public}d", persistentId);
+}
+
+std::shared_ptr<AAFwk::Want> SceneSessionManager::GetRequestWantFromTaskInfoMap(
+    int32_t persistentId, int32_t requestId) {
+    if (requestId < MIN_REQUEST_ID_FROM_ABILITY || persistentId == INVALID_SESSION_ID) {
+        return nullptr;
+    }
+    std::shared_ptr<AAFwk::Want> retPtr = nullptr;
+    {
+        std::lock_guard<std::mutex> lock(requestTaskInfoMapMutex_);
+        if (requestTaskInfoMap.find(persistentId) == requestTaskInfoMap.end()) {
+            return nullptr;
+        }
+        auto& requestIdToWantMap = requestTaskInfoMap[persistentId]->requestIdToWantMap;
+        if (requestIdToWantMap.find(requestId) == requestIdToWantMap.end()) {
+            return nullptr;
+        }
+        retPtr = std::make_shared<AAFwk::Want>(requestIdToWantMap[requestId]);
+    }
+    TLOGI(WmsLogTag::WMS_LIFE, "exsit, persistentId:%{public}d, requestId:%{public}d",
+        persistentId, requestId);
+    return retPtr;
+}
+
 void SceneSessionManager::NotifyCollaboratorAfterStart(sptr<SceneSession>& sceneSession,
     sptr<AAFwk::SessionInfo>& sceneSessionInfo)
 {
@@ -3691,6 +3775,7 @@ WSError SceneSessionManager::RequestSceneSessionDestructionInner(sptr<SceneSessi
         sceneSession->ResetSessionInfoResultCode();
         sceneSession->EditSessionInfo().isSetStartWindowType_ = false;
     }
+    ClearRequestTaskInfo(persistentId);
     NotifySessionForCallback(sceneSession, needRemoveSession);
     // Clear js cb map if needed.
     sceneSession->ClearJsSceneSessionCbMap(needRemoveSession);
@@ -10070,12 +10155,13 @@ WSError SceneSessionManager::RequestSceneSessionByCall(const sptr<SceneSession>&
         auto persistentId = sceneSession->GetPersistentId();
         if (!GetSceneSession(persistentId)) {
             TLOGNE(WmsLogTag::WMS_MAIN, "%{public}s: session is invalid, id:%{public}d", where, persistentId);
+            RemoveRequestTaskInfo(persistentId, requestId);
             return WSError::WS_ERROR_INVALID_SESSION;
         }
         const auto& sessionInfo = sceneSession->GetSessionInfo();
         TLOGNI(WmsLogTag::WMS_MAIN, "%{public}s: state:%{public}d, id:%{public}d",
             where, sessionInfo.callState_, persistentId);
-        auto abilitySessionInfo = SetAbilitySessionInfo(sceneSession, requestId);
+        auto abilitySessionInfo = SetAbilitySessionInfo(sceneSession, requestId, true);
         bool isColdStart = false;
         AAFwk::AbilityManagerClient::GetInstance()->CallUIAbilityBySCB(abilitySessionInfo, isColdStart);
         CloseAllFd(sessionInfo.want);
@@ -10086,6 +10172,7 @@ WSError SceneSessionManager::RequestSceneSessionByCall(const sptr<SceneSession>&
             sceneSession->ResetSessionConnectState();
             sceneSession->UpdatePrivacyModeControlInfo();
         }
+        RemoveRequestTaskInfo(persistentId, requestId);
         return WSError::WS_OK;
     };
     std::string taskName = "RequestSceneSessionByCall:PID:" +
diff --git a/window_scene/test/unittest/scene_session_manager_test3.cpp b/window_scene/test/unittest/scene_session_manager_test3.cpp
index b3791bf2dce6c3aa9c034bcfd9a94e1aadbb6b69..7d501442b8e0734431ef9903ce4c70c6a400a4f7 100644
--- a/window_scene/test/unittest/scene_session_manager_test3.cpp
+++ b/window_scene/test/unittest/scene_session_manager_test3.cpp
@@ -710,6 +710,108 @@ HWTEST_F(SceneSessionManagerTest3, SetAbilitySessionInfo, TestSize.Level1)
     ASSERT_EQ(retElementName.GetBundleName(), info.bundleName_);
 }
 
+/**
+ * @tc.name: SetAbilitySessionInfo2
+ * @tc.desc: SceneSesionManager set ability session info
+ * @tc.type: FUNC
+ */
+HWTEST_F(SceneSessionManagerTest3, SetAbilitySessionInfo2, TestSize.Level1)
+{
+    SessionInfo info;
+    info.abilityName_ = "SetAbilitySessionInfo";
+    info.bundleName_ = "SetAbilitySessionInfo";
+    std::shared_ptr<AAFwk::Want> wantPtr = std::make_shared<AAFwk::Want>();
+    wantPtr->SetBundle(info.bundleName_);
+    info.want = wantPtr;
+    info.persistentId_ = 1;
+    info.requestId = 1;
+    sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);;
+    ASSERT_NE(nullptr, sceneSession);
+    ssm_->SetAbilitySessionInfo(sceneSession, true);
+    ssm_->AddRequestTaskInfo(info);
+    sptr<OHOS::AAFwk::SessionInfo> ret = ssm_->SetAbilitySessionInfo(sceneSession, true);
+    ssm_->ClearRequestTaskInfo(1);
+    EXPECT_EQ(ret->want.GetBundle(), "SetAbilitySessionInfo");
+}
+ 
+/**
+ * @tc.name: AddRequestTaskInfo
+ * @tc.desc: SceneSesionManager add request
+ * @tc.type: FUNC
+ */
+HWTEST_F(SceneSessionManagerTest3, AddRequestTaskInfo, TestSize.Level1)
+{
+    SessionInfo info;
+    info.abilityName_ = "AddRequestTaskInfo";
+    info.bundleName_ = "AddRequestTaskInfo";
+    info.requestId = -1;
+    ssm_->AddRequestTaskInfo(info);
+    info.requestId = 1;
+    info.persistentId_ = INVALID_SESSION_ID;
+    ssm_->AddRequestTaskInfo(info);
+    info.persistentId_ = 1;
+    ssm_->AddRequestTaskInfo(info);
+    std::shared_ptr<AAFwk::Want> wantPtr = std::make_shared<AAFwk::Want>();
+    info.want = wantPtr;
+    ssm_->AddRequestTaskInfo(info);
+    ssm_->AddRequestTaskInfo(info);
+    std::shared_ptr<AAFwk::Want> wantRet = ssm_->GetRequestWantFromTaskInfoMap(1, 1);
+    EXPECT_NE(wantRet, nullptr);
+    ssm_->ClearRequestTaskInfo(1);
+}
+
+/**
+ * @tc.name: RemoveRequestTaskInfo
+ * @tc.desc: SceneSesionManager remove request task info
+ * @tc.type: FUNC
+ */
+HWTEST_F(SceneSessionManagerTest3, RemoveRequestTaskInfo, TestSize.Level1)
+{
+    SessionInfo info;
+    info.abilityName_ = "RemoveRequestTaskInfo";
+    info.bundleName_ = "RemoveRequestTaskInfo";
+    info.requestId = 1;
+    info.persistentId_ = 1;
+    std::shared_ptr<AAFwk::Want> wantPtr = std::make_shared<AAFwk::Want>();
+    info.want = wantPtr;
+    ssm_->ClearRequestTaskInfo(0);
+    ssm_->RemoveRequestTaskInfo(-1, 0);
+    ssm_->RemoveRequestTaskInfo(-1, 1);
+    ssm_->RemoveRequestTaskInfo(1, 0);
+    ssm_->RemoveRequestTaskInfo(1, 1);
+    ssm_->AddRequestTaskInfo(info);
+    ssm_->RemoveRequestTaskInfo(1, 1);
+    std::shared_ptr<AAFwk::Want> wantRet = ssm_->GetRequestWantFromTaskInfoMap(1, 1);
+    EXPECT_EQ(wantRet, nullptr);
+    ssm_->ClearRequestTaskInfo(1);
+}
+ 
+/**
+ * @tc.name: GetRequestWantFromTaskInfoMap
+ * @tc.desc: SceneSesionManager get request want from task info map
+ * @tc.type: FUNC
+ */
+HWTEST_F(SceneSessionManagerTest3, GetRequestWantFromTaskInfoMap, TestSize.Level1)
+{
+    SessionInfo info;
+    info.abilityName_ = "GetRequestWantFromTaskInfoMap";
+    info.bundleName_ = "GetRequestWantFromTaskInfoMap";
+    info.requestId = 1;
+    info.persistentId_ = 1;
+    std::shared_ptr<AAFwk::Want> wantPtr = std::make_shared<AAFwk::Want>();
+    info.want = wantPtr;
+    ssm_->GetRequestWantFromTaskInfoMap(-1, 0);
+    ssm_->GetRequestWantFromTaskInfoMap(-1, 1);
+    ssm_->GetRequestWantFromTaskInfoMap(1, 0);
+    ssm_->GetRequestWantFromTaskInfoMap(1, 1);
+    ssm_->AddRequestTaskInfo(info);
+    ssm_->GetRequestWantFromTaskInfoMap(1, 1);
+    ssm_->RemoveRequestTaskInfo(1, 1);
+    std::shared_ptr<AAFwk::Want> wantRet = ssm_->GetRequestWantFromTaskInfoMap(1, 1);
+    EXPECT_EQ(wantRet, nullptr);
+    ssm_->ClearRequestTaskInfo(1);
+}
+
 /**
  * @tc.name: PrepareTerminate
  * @tc.desc: SceneSesionManager prepare terminate