openharmony/window_window_manager
1
0
Fork 0
mirror of https://gitee.com/openharmony/window_window_manager synced 2025-02-25 18:31:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

!8087 新增批量获取info接口

Browse Source 
Merge pull request !8087 from LiPeng/splitAndfloat
This commit is contained in:
openharmony_ci 2024-08-13 09:32:24 +00:00 committed by Gitee
commit c7b47acf02
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
5 changed files with 229 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

208
window_scene/interfaces/kits/napi/scene_session_manager/js_scene_session_manager.cpp
View File

@ -135,6 +135,7 @@ napi_value JsSceneSessionManager::Init(napi_env env, napi_value exportObj)
BindNativeFunction(env, exportObj, "InitWithRenderServiceAdded", moduleName,
JsSceneSessionManager::InitWithRenderServiceAdded);
BindNativeFunction(env, exportObj, "getAllAbilityInfo", moduleName, JsSceneSessionManager::GetAllAbilityInfos);
BindNativeFunction(env, exportObj, "getBatchAbilityInfos", moduleName, JsSceneSessionManager::GetBatchAbilityInfos);
BindNativeFunction(env, exportObj, "getAllWindowVisibilityInfos", moduleName,
JsSceneSessionManager::GetAllWindowVisibilityInfos);
BindNativeFunction(env, exportObj, "prepareTerminate", moduleName, JsSceneSessionManager::PrepareTerminate);
@ -707,6 +708,13 @@ napi_value JsSceneSessionManager::GetAllAbilityInfos(napi_env env, napi_callback
return (me != nullptr) ? me->OnGetAllAbilityInfos(env, info) : nullptr;
}
napi_value JsSceneSessionManager::GetBatchAbilityInfos(napi_env env, napi_callback_info info)
{
TLOGI(WmsLogTag::WMS_SCB, "[NAPI]");
JsSceneSessionManager* me = CheckParamsAndGetThis<JsSceneSessionManager>(env, info);
return (me != nullptr) ? me->OnGetBatchAbilityInfos(env, info) : nullptr;
}
napi_value JsSceneSessionManager::PrepareTerminate(napi_env env, napi_callback_info info)
{
WLOGFD("[NAPI]");
@ -1027,6 +1035,88 @@ napi_value JsSceneSessionManager::OnCheckSceneZOrder(napi_env env, napi_callback
return NapiGetUndefined(env);
}
static napi_value CreateWindowModes(napi_env env,
const std::vector<AppExecFwk::SupportWindowMode>& windowModes)
{
napi_value arrayValue = nullptr;
napi_create_array_with_length(env, windowModes.size(), &arrayValue);
auto index = 0;
for (const auto& windowMode : windowModes) {
napi_set_element(env, arrayValue, index++, CreateJsValue(env, static_cast<int32_t>(windowMode)));
}
return arrayValue;
}
static napi_value CreateWindowSize(napi_env env, const AppExecFwk::AbilityInfo& abilityInfo)
{
napi_value objValue = nullptr;
napi_create_object(env, &objValue);
if (objValue == nullptr) {
WLOGFE("CreateObject failed");
return NapiGetUndefined(env);
}
napi_set_named_property(env, objValue, "maxWindowRatio", CreateJsValue(env, abilityInfo.maxWindowRatio));
napi_set_named_property(env, objValue, "minWindowRatio", CreateJsValue(env, abilityInfo.minWindowRatio));
napi_set_named_property(env, objValue, "maxWindowWidth", CreateJsValue(env, abilityInfo.maxWindowWidth));
napi_set_named_property(env, objValue, "minWindowWidth", CreateJsValue(env, abilityInfo.minWindowWidth));
napi_set_named_property(env, objValue, "maxWindowHeight", CreateJsValue(env, abilityInfo.maxWindowHeight));
napi_set_named_property(env, objValue, "minWindowHeight", CreateJsValue(env, abilityInfo.minWindowHeight));
return objValue;
}
static napi_value CreateAbilityItemInfo(napi_env env, const AppExecFwk::AbilityInfo& abilityInfo)
{
napi_value objValue = nullptr;
napi_create_object(env, &objValue);
if (objValue == nullptr) {
WLOGFE("CreateObject failed");
return NapiGetUndefined(env);
}
napi_set_named_property(env, objValue, "appIconId", CreateJsValue(env, abilityInfo.iconId));
napi_set_named_property(env, objValue, "appLabelId", CreateJsValue(env, abilityInfo.labelId));
napi_set_named_property(env, objValue, "bundleName", CreateJsValue(env, abilityInfo.bundleName));
napi_set_named_property(env, objValue, "moduleName", CreateJsValue(env, abilityInfo.moduleName));
napi_set_named_property(env, objValue, "name", CreateJsValue(env, abilityInfo.name));
napi_set_named_property(env, objValue, "launchType",
CreateJsValue(env, static_cast<int32_t>(abilityInfo.launchMode)));
napi_set_named_property(env, objValue, "supportWindowModes", CreateWindowModes(env, abilityInfo.windowModes));
napi_set_named_property(env, objValue, "windowSize", CreateWindowSize(env, abilityInfo));
napi_set_named_property(env, objValue, "orientation",
CreateJsValue(env, static_cast<int32_t>(abilityInfo.orientation)));
napi_set_named_property(env, objValue, "excludeFromSession", CreateJsValue(env, abilityInfo.excludeFromMissions));
napi_set_named_property(env, objValue, "unclearableSession", CreateJsValue(env, abilityInfo.unclearableMission));
napi_set_named_property(env, objValue, "continuable", CreateJsValue(env, abilityInfo.continuable));
napi_set_named_property(env, objValue, "removeSessionAfterTerminate",
CreateJsValue(env, abilityInfo.removeMissionAfterTerminate));
napi_set_named_property(env, objValue, "preferMultiWindowOrientation",
CreateJsValue(env, abilityInfo.preferMultiWindowOrientation));
return objValue;
}
static napi_value CreateSCBAbilityInfo(napi_env env, const SCBAbilityInfo& scbAbilityInfo)
{
napi_value objValue = nullptr;
napi_create_object(env, &objValue);
if (objValue == nullptr) {
WLOGFE("CreateObject failed");
return NapiGetUndefined(env);
}
napi_set_named_property(env, objValue, "abilityItemInfo", CreateAbilityItemInfo(env, scbAbilityInfo.abilityInfo_));
napi_set_named_property(env, objValue, "sdkVersion", CreateJsValue(env, scbAbilityInfo.sdkVersion_));
return objValue;
}
static napi_value CreateAbilityInfos(napi_env env, const std::vector<SCBAbilityInfo>& scbAbilityInfos)
{
napi_value arrayValue = nullptr;
napi_create_array_with_length(env, scbAbilityInfos.size(), &arrayValue);
auto index = 0;
for (const auto& scbAbilityInfo : scbAbilityInfos) {
napi_set_element(env, arrayValue, index++, CreateSCBAbilityInfo(env, scbAbilityInfo));
}
return arrayValue;
}
napi_value JsSceneSessionManager::OnGetAllAbilityInfos(napi_env env, napi_callback_info info)
{
size_t argc = 4;
@ -1055,12 +1145,12 @@ napi_value JsSceneSessionManager::OnGetAllAbilityInfos(napi_env env, napi_callba
}
auto errCode = std::make_shared<int32_t>(static_cast<int32_t>(WSErrorCode::WS_OK));
auto scbAbilityInfos = std::make_shared<std::vector<SCBAbilityInfo>>();
auto execute = [obj = this, want, userId, infos = scbAbilityInfos, errCode] () {
auto execute = [want, userId, infos = scbAbilityInfos, errCode] () {
auto code = WS_JS_TO_ERROR_CODE_MAP.at(
SceneSessionManager::GetInstance().GetAllAbilityInfos(want, userId, *infos));
*errCode = static_cast<int32_t>(code);
};
auto complete = [obj = this, errCode, infos = scbAbilityInfos]
auto complete = [errCode, infos = scbAbilityInfos]
(napi_env env, NapiAsyncTask& task, int32_t status) {
if (*errCode != static_cast<int32_t>(WSErrorCode::WS_OK)) {
std::string errMsg = "invalid params can not get All AbilityInfos!";
@ -1068,7 +1158,7 @@ napi_value JsSceneSessionManager::OnGetAllAbilityInfos(napi_env env, napi_callba
return;
}
task.ResolveWithCustomize(env, CreateJsValue(env, static_cast<int32_t>(WSErrorCode::WS_OK)),
obj->CreateAbilityInfos(env, *infos));
CreateAbilityInfos(env, *infos));
};
napi_value result = nullptr;
napi_value callback = (argc == 2) ? nullptr : argv[2];
@ -1077,87 +1167,51 @@ napi_value JsSceneSessionManager::OnGetAllAbilityInfos(napi_env env, napi_callba
return result;
}
napi_value JsSceneSessionManager::CreateAbilityInfos(napi_env env,
const std::vector<SCBAbilityInfo>& scbAbilityInfos)
napi_value JsSceneSessionManager::OnGetBatchAbilityInfos(napi_env env, napi_callback_info info)
{
napi_value arrayValue = nullptr;
napi_create_array_with_length(env, scbAbilityInfos.size(), &arrayValue);
auto index = 0;
for (const auto& scbAbilityInfo : scbAbilityInfos) {
napi_set_element(env, arrayValue, index++, CreateSCBAbilityInfo(env, scbAbilityInfo));
}
return arrayValue;
}
napi_value JsSceneSessionManager::CreateSCBAbilityInfo(napi_env env, const SCBAbilityInfo& scbAbilityInfo)
{
napi_value objValue = nullptr;
napi_create_object(env, &objValue);
if (objValue == nullptr) {
WLOGFE("CreateObject failed");
size_t argc = 4;
napi_value argv[4] = { nullptr };
napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
if (argc != ARGC_TWO) {
TLOGE(WmsLogTag::DEFAULT, "[NAPI]Argc is invalid: %{public}zu", argc);
napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
"Input parameter is missing or invalid"));
return NapiGetUndefined(env);
}
napi_set_named_property(env, objValue, "abilityItemInfo", CreateAbilityItemInfo(env, scbAbilityInfo.abilityInfo_));
napi_set_named_property(env, objValue, "sdkVersion", CreateJsValue(env, scbAbilityInfo.sdkVersion_));
return objValue;
}
napi_value JsSceneSessionManager::CreateAbilityItemInfo(napi_env env, const AppExecFwk::AbilityInfo& abilityInfo)
{
napi_value objValue = nullptr;
napi_create_object(env, &objValue);
if (objValue == nullptr) {
WLOGFE("CreateObject failed");
int32_t userId;
if (!ConvertFromJsValue(env, argv[0], userId)) {
TLOGE(WmsLogTag::DEFAULT, "[NAPI]Failed to convert parameter to userId");
napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
"Input parameter is missing or invalid"));
return NapiGetUndefined(env);
}
napi_set_named_property(env, objValue, "appIconId", CreateJsValue(env, abilityInfo.iconId));
napi_set_named_property(env, objValue, "appLabelId", CreateJsValue(env, abilityInfo.labelId));
napi_set_named_property(env, objValue, "bundleName", CreateJsValue(env, abilityInfo.bundleName));
napi_set_named_property(env, objValue, "moduleName", CreateJsValue(env, abilityInfo.moduleName));
napi_set_named_property(env, objValue, "name", CreateJsValue(env, abilityInfo.name));
napi_set_named_property(env, objValue, "launchType",
CreateJsValue(env, static_cast<int32_t>(abilityInfo.launchMode)));
napi_set_named_property(env, objValue, "supportWindowModes", CreateWindowModes(env, abilityInfo.windowModes));
napi_set_named_property(env, objValue, "windowSize", CreateWindowSize(env, abilityInfo));
napi_set_named_property(env, objValue, "orientation",
CreateJsValue(env, static_cast<int32_t>(abilityInfo.orientation)));
napi_set_named_property(env, objValue, "excludeFromSession", CreateJsValue(env, abilityInfo.excludeFromMissions));
napi_set_named_property(env, objValue, "unclearableSession", CreateJsValue(env, abilityInfo.unclearableMission));
napi_set_named_property(env, objValue, "continuable", CreateJsValue(env, abilityInfo.continuable));
napi_set_named_property(env, objValue, "removeSessionAfterTerminate",
CreateJsValue(env, abilityInfo.removeMissionAfterTerminate));
napi_set_named_property(env, objValue, "preferMultiWindowOrientation",
CreateJsValue(env, abilityInfo.preferMultiWindowOrientation));
return objValue;
}
napi_value JsSceneSessionManager::CreateWindowModes(napi_env env,
const std::vector<AppExecFwk::SupportWindowMode>& windowModes)
{
napi_value arrayValue = nullptr;
napi_create_array_with_length(env, windowModes.size(), &arrayValue);
auto index = 0;
for (const auto& windowMode : windowModes) {
napi_set_element(env, arrayValue, index++, CreateJsValue(env, static_cast<int32_t>(windowMode)));
}
return arrayValue;
}
napi_value JsSceneSessionManager::CreateWindowSize(napi_env env, const AppExecFwk::AbilityInfo& abilityInfo)
{
napi_value objValue = nullptr;
napi_create_object(env, &objValue);
if (objValue == nullptr) {
WLOGFE("CreateObject failed");
std::vector<std::string> bundleNames;
if (!ParseArrayStringValue(env, argv[1], bundleNames)) {
TLOGE(WmsLogTag::DEFAULT, "[NAPI]Failed to convert parameter to bundleNames");
napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
"Input parameter is missing or invalid"));
return NapiGetUndefined(env);
}
napi_set_named_property(env, objValue, "maxWindowRatio", CreateJsValue(env, abilityInfo.maxWindowRatio));
napi_set_named_property(env, objValue, "minWindowRatio", CreateJsValue(env, abilityInfo.minWindowRatio));
napi_set_named_property(env, objValue, "maxWindowWidth", CreateJsValue(env, abilityInfo.maxWindowWidth));
napi_set_named_property(env, objValue, "minWindowWidth", CreateJsValue(env, abilityInfo.minWindowWidth));
napi_set_named_property(env, objValue, "maxWindowHeight", CreateJsValue(env, abilityInfo.maxWindowHeight));
napi_set_named_property(env, objValue, "minWindowHeight", CreateJsValue(env, abilityInfo.minWindowHeight));
return objValue;
auto errCode = std::make_shared<WSErrorCode>(WSErrorCode::WS_OK);
auto scbAbilityInfos = std::make_shared<std::vector<SCBAbilityInfo>>();
auto execute = [bundleNames, userId, infos = scbAbilityInfos, errCode] {
*errCode = WS_JS_TO_ERROR_CODE_MAP.at(
SceneSessionManager::GetInstance().GetBatchAbilityInfos(bundleNames, userId, *infos));
};
auto complete = [errCode, infos = scbAbilityInfos](napi_env env, NapiAsyncTask& task, int32_t status) {
if (*errCode != WSErrorCode::WS_OK) {
std::string errMsg = "invalid params can not get batch AbilityInfos!";
task.RejectWithCustomize(env, CreateJsValue(env, *errCode), CreateJsValue(env, errMsg));
return;
}
task.ResolveWithCustomize(env, CreateJsValue(env, static_cast<int32_t>(WSErrorCode::WS_OK)),
CreateAbilityInfos(env, *infos));
};
napi_value result = nullptr;
napi_value callback = nullptr;
NapiAsyncTask::Schedule("JsSceneSessionManager::OnGetBatchAbilityInfos",
env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
return result;
}
napi_value JsSceneSessionManager::OnInitUserInfo(napi_env env, napi_callback_info info)

7
window_scene/interfaces/kits/napi/scene_session_manager/js_scene_session_manager.h
View File

@ -72,6 +72,7 @@ public:
static napi_value InitWithRenderServiceAdded(napi_env env, napi_callback_info info);
static napi_value GetAllWindowVisibilityInfos(napi_env env, napi_callback_info info);
static napi_value GetAllAbilityInfos(napi_env env, napi_callback_info info);
static napi_value GetBatchAbilityInfos(napi_env env, napi_callback_info info);
static napi_value PrepareTerminate(napi_env env, napi_callback_info info);
static napi_value PerfRequestEx(napi_env env, napi_callback_info info);
static napi_value UpdateWindowMode(napi_env env, napi_callback_info info);
@ -126,11 +127,7 @@ private:
napi_value OnInitWithRenderServiceAdded(napi_env env, napi_callback_info info);
napi_value OnGetAllWindowVisibilityInfos(napi_env env, napi_callback_info info);
napi_value OnGetAllAbilityInfos(napi_env env, napi_callback_info info);
napi_value CreateAbilityInfos(napi_env env, const std::vector<SCBAbilityInfo>& scbAbilityInfos);
napi_value CreateSCBAbilityInfo(napi_env env, const SCBAbilityInfo& scbAbilityInfo);
napi_value CreateAbilityItemInfo(napi_env env, const AppExecFwk::AbilityInfo& abilityInfo);
napi_value CreateWindowModes(napi_env env, const std::vector<AppExecFwk::SupportWindowMode>& windowModes);
napi_value CreateWindowSize(napi_env env, const AppExecFwk::AbilityInfo& abilityInfo);
napi_value OnGetBatchAbilityInfos(napi_env env, napi_callback_info info);
napi_value OnPrepareTerminate(napi_env env, napi_callback_info info);
napi_value OnPerfRequestEx(napi_env env, napi_callback_info info);
napi_value OnUpdateWindowMode(napi_env env, napi_callback_info info);

2
window_scene/session_manager/include/scene_session_manager.h
View File

@ -233,6 +233,8 @@ public:
WSError DumpSessionWithId(int32_t persistentId, std::vector<std::string>& infos) override;
WSError GetAllAbilityInfos(const AAFwk::Want& want, int32_t userId,
std::vector<SCBAbilityInfo>& scbAbilityInfos);
WSError GetBatchAbilityInfos(const std::vector<std::string>& bundleNames, int32_t userId,
std::vector<SCBAbilityInfo>& scbAbilityInfos);
WSError PrepareTerminate(int32_t persistentId, bool& isPrepareTerminate);
WSError GetIsLayoutFullScreen(bool& isLayoutFullScreen);

25
window_scene/session_manager/src/scene_session_manager.cpp
View File

@ -6199,6 +6199,31 @@ __attribute__((no_sanitize("cfi"))) WSError SceneSessionManager::GetAllAbilityIn
return GetAbilityInfosFromBundleInfo(bundleInfos, scbAbilityInfos);
}
__attribute__((no_sanitize("cfi"))) WSError SceneSessionManager::GetBatchAbilityInfos(
const std::vector<std::string>& bundleNames, int32_t userId, std::vector<SCBAbilityInfo>& scbAbilityInfos)
{
if (bundleMgr_ == nullptr) {
TLOGE(WmsLogTag::DEFAULT, "bundleMgr is nullptr");
return WSError::WS_ERROR_NULLPTR;
}
if (bundleNames.empty()) {
TLOGE(WmsLogTag::DEFAULT, "bundleNames is empty");
return WSError::WS_ERROR_INVALID_PARAM;
}
auto flag = AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_APPLICATION |
AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_PERMISSION |
AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_METADATA |
static_cast<int32_t>(AppExecFwk::GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_ABILITY) |
static_cast<int32_t>(AppExecFwk::GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_HAP_MODULE);
std::vector<AppExecFwk::BundleInfo> bundleInfos;
auto ret = static_cast<int32_t>(bundleMgr_->BatchGetBundleInfo(bundleNames, flag, bundleInfos, userId));
if (ret) {
TLOGE(WmsLogTag::DEFAULT, "Query batch ability infos from BMS failed!");
return WSError::WS_ERROR_INVALID_PARAM;
}
return GetAbilityInfosFromBundleInfo(bundleInfos, scbAbilityInfos);
}
WSError SceneSessionManager::GetAbilityInfosFromBundleInfo(std::vector<AppExecFwk::BundleInfo>& bundleInfos,
std::vector<SCBAbilityInfo>& scbAbilityInfos)
{

69
window_scene/test/unittest/scene_session_manager_test5.cpp
View File

@ -16,6 +16,7 @@
#include <gtest/gtest.h>
#include <regex>
#include <bundle_mgr_interface.h>
#include <bundle_mgr_proxy.h>
#include <bundlemgr/launcher_service.h>
#include "iremote_object_mocker.h"
#include "interfaces/include/ws_common.h"
@ -1192,6 +1193,74 @@ HWTEST_F(SceneSessionManagerTest5, GetAllAbilityInfos02, Function | SmallTest |
ssm_->GetAllAbilityInfos(want, userId, scbAbilityInfos);
}
/**
* @tc.name: GetBatchAbilityInfos01
* @tc.desc: GetBatchAbilityInfos01
* @tc.type: FUNC
*/
HWTEST_F(SceneSessionManagerTest5, GetBatchAbilityInfos01, Function | SmallTest | Level3)
{
ASSERT_NE(ssm_, nullptr);
auto bundleMgr = ssm_->bundleMgr_;
ssm_->bundleMgr_ = nullptr;
int32_t userId = 100;
std::vector<std::string> bundleNames = { "test1", "test2" };
auto scbAbilityInfos = std::make_shared<std::vector<SCBAbilityInfo>>();
WSError ret = ssm_->GetBatchAbilityInfos(bundleNames, userId, *scbAbilityInfos);
ASSERT_EQ(ret, WSError::WS_ERROR_NULLPTR);
}
/**
* @tc.name: GetBatchAbilityInfos02
* @tc.desc: GetBatchAbilityInfos02
* @tc.type: FUNC
*/
HWTEST_F(SceneSessionManagerTest5, GetBatchAbilityInfos02, Function | SmallTest | Level3)
{
ASSERT_NE(ssm_, nullptr);
sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
ssm_->bundleMgr_ = sptr<AppExecFwk::BundleMgrProxy>::MakeSptr(iRemoteObjectMocker);
int32_t userId = 100;
std::vector<std::string> bundleNames = {};
auto scbAbilityInfos = std::make_shared<std::vector<SCBAbilityInfo>>();
WSError ret = ssm_->GetBatchAbilityInfos(bundleNames, userId, *scbAbilityInfos);
ASSERT_EQ(ret, WSError::WS_ERROR_INVALID_PARAM);
}
/**
* @tc.name: GetBatchAbilityInfos03
* @tc.desc: GetBatchAbilityInfos03
* @tc.type: FUNC
*/
HWTEST_F(SceneSessionManagerTest5, GetBatchAbilityInfos03, Function | SmallTest | Level3)
{
ASSERT_NE(ssm_, nullptr);
sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
ssm_->bundleMgr_ = sptr<AppExecFwk::BundleMgrProxy>::MakeSptr(iRemoteObjectMocker);
int32_t userId = 100;
std::vector<std::string> bundleNames = { "" };
auto scbAbilityInfos = std::make_shared<std::vector<SCBAbilityInfo>>();
WSError ret = ssm_->GetBatchAbilityInfos(bundleNames, userId, *scbAbilityInfos);
ASSERT_EQ(ret, WSError::WS_ERROR_INVALID_PARAM);
}
/**
* @tc.name: GetBatchAbilityInfos04
* @tc.desc: GetBatchAbilityInfos04
* @tc.type: FUNC
*/
HWTEST_F(SceneSessionManagerTest5, GetBatchAbilityInfos04, Function | SmallTest | Level3)
{
ASSERT_NE(ssm_, nullptr);
sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
ssm_->bundleMgr_ = sptr<AppExecFwk::BundleMgrProxy>::MakeSptr(iRemoteObjectMocker);
int32_t userId = 100;
std::vector<std::string> bundleNames = { "test1", "test2" };
auto scbAbilityInfos = std::make_shared<std::vector<SCBAbilityInfo>>();
WSError ret = ssm_->GetBatchAbilityInfos(bundleNames, userId, *scbAbilityInfos);
ASSERT_EQ(ret, WSError::WS_ERROR_INVALID_PARAM);
}
/**
* @tc.name: FindMainWindowWithToken
* @tc.desc: SceneSesionManager find main window with token