From e263f8342d42cef8b86f1e1a0e822b2eb8619746 Mon Sep 17 00:00:00 2001 From: hubijie Date: Thu, 10 Jul 2025 23:34:20 +0800 Subject: [PATCH] =?UTF-8?q?=E8=8E=B7=E5=8F=96=E5=85=83=E6=9C=8D=E5=8A=A1?= =?UTF-8?q?=E5=85=8D=E5=AE=89=E8=A3=85=E5=85=BC=E5=AE=B9=E6=A8=A1=E5=BC=8F?= =?UTF-8?q?=E4=BF=A1=E6=81=AF=20Signed-off-by:=20hubijie=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- bundle.json | 3 +- window_scene/interfaces/include/ws_common.h | 10 + .../scene_session_manager/js_scene_utils.cpp | 36 +++ .../scene_session_manager/js_scene_utils.h | 1 + window_scene/session/BUILD.gn | 11 + .../atomicservice_basic_engine_plugin.h | 93 ++++++++ .../src/atomicservice_basic_engine_plugin.cpp | 205 ++++++++++++++++++ .../session/host/src/scene_session.cpp | 22 ++ window_scene/test/unittest/BUILD.gn | 14 ++ .../unittest/scene_session_lifecycle_test.cpp | 31 +++ windowmanager_aafwk.gni | 9 + 11 files changed, 434 insertions(+), 1 deletion(-) create mode 100644 window_scene/session/host/include/atomicservice_basic_engine_plugin.h create mode 100644 window_scene/session/host/src/atomicservice_basic_engine_plugin.cpp diff --git a/bundle.json b/bundle.json index 0d265a0d1a..28c9d7f1ac 100755 --- a/bundle.json +++ b/bundle.json @@ -31,7 +31,8 @@ "window_manager_feature_multi_screen_frame_ctl", "window_manager_feature_cam_mode", "window_manager_feature_multi_usr", - "window_manager_feature_screenless" + "window_manager_feature_screenless", + "window_manager_feature_asbng_path" ], "adapted_system_type": [ "standard" ], "rom": "8000KB", diff --git a/window_scene/interfaces/include/ws_common.h b/window_scene/interfaces/include/ws_common.h index cfecd09188..8523ba5fd2 100644 --- a/window_scene/interfaces/include/ws_common.h +++ b/window_scene/interfaces/include/ws_common.h @@ -358,6 +358,15 @@ enum class StartWindowType : uint32_t { REMOVE_NODE_INVISIBLE, }; +struct AtomicServiceInfo { + std::string appNameInfo_ = ""; + std::string eyelashRingIcon_ = ""; + std::string circleIcon_ = ""; + int32_t resizable_ = 0; + std::vector deviceTypes_; + std::vector supportWindowMode_; +}; + struct SessionInfo { std::string bundleName_ = ""; std::string moduleName_ = ""; @@ -371,6 +380,7 @@ struct SessionInfo { uint64_t screenId_ = -1; bool isPersistentRecover_ = false; bool isFromIcon_ = false; + AtomicServiceInfo atomicServiceInfo_; mutable std::shared_ptr want = nullptr; // want for ability start std::shared_ptr wantMutex_ = std::make_shared(); 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 2ef13d3a81..bb010860da 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 @@ -491,6 +491,40 @@ static bool IsJsIsAbilityHookUndefind(napi_env env, napi_value jsIsAbilityHook, return true; } +static napi_value CreateJsValueFromStringArray(napi_env env, const std::vector& stringArray) +{ + napi_value arrayValue = nullptr; + napi_create_array_with_length(env, stringArray.size(), &arrayValue); + if (arrayValue == nullptr) { + TLOGE(WmsLogTag::WMS_LIFE, "Failed to create napi array"); + return NapiGetUndefined(env); + } + int32_t index = 0; + for (const auto& iter : stringArray) { + napi_set_element(env, arrayValue, index++, CreateJsValue(env, iter)); + } + return arrayValue; +} + +napi_value CreateJsAtomicServiceInfo(napi_env env, const AtomicServiceInfo& atomicServiceInfo) +{ + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + if (objValue == nullptr) { + TLOGE(WmsLogTag::WMS_LIFE, "Failed to get object"); + return nullptr; + } + + napi_set_named_property(env, objValue, "resizable", + CreateJsValue(env, atomicServiceInfo.resizable_)); + napi_set_named_property(env, objValue, "deviceTypes", + CreateJsValueFromStringArray(env, atomicServiceInfo.deviceTypes_)); + napi_set_named_property(env, objValue, "supportWindowMode", + CreateJsValueFromStringArray(env, atomicServiceInfo.supportWindowMode_)); + + return objValue; +} + bool ConvertSessionInfoName(napi_env env, napi_value jsObject, SessionInfo& sessionInfo) { napi_value jsBundleName = nullptr; @@ -1387,6 +1421,8 @@ napi_value CreateJsSessionInfo(napi_env env, const SessionInfo& sessionInfo) TLOGE(WmsLogTag::WMS_ANIMATION, "Failed to set startAnimationSystemOptions"); } } + napi_set_named_property(env, objValue, "atomicServiceInfo", + CreateJsAtomicServiceInfo(env, sessionInfo.atomicServiceInfo_)); return objValue; } diff --git a/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_utils.h b/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_utils.h index 43e9c8e124..45900a1351 100644 --- a/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_utils.h +++ b/window_scene/interfaces/kits/napi/scene_session_manager/js_scene_utils.h @@ -216,6 +216,7 @@ napi_value CreateJsSessionInfo(napi_env env, const SessionInfo& sessionInfo); napi_value CreateJsExceptionInfo(napi_env env, const ExceptionInfo& exceptionInfo); napi_value CreateSupportWindowModes(napi_env env, const std::vector& supportedWindowModes); +napi_value CreateJsAtomicServiceInfo(napi_env env, const AtomicServiceInfo& atomicServiceInfo); napi_value CreateJsSessionRecoverInfo( napi_env env, const SessionInfo& sessionInfo, const sptr property); void SetJsSessionInfoByWant(napi_env env, const SessionInfo& sessionInfo, napi_value objValue); diff --git a/window_scene/session/BUILD.gn b/window_scene/session/BUILD.gn index f51783a2bf..6557dc9c39 100644 --- a/window_scene/session/BUILD.gn +++ b/window_scene/session/BUILD.gn @@ -31,6 +31,13 @@ config("session_public_config") { # for WMError Code "${window_base_path}/interfaces/innerkits/wm", ] + + cflags = [] + defines = [] + if (window_manager_feature_asbng_path_enable) { + defines += [ "WINDOW_ATOMIC_SERVICE_ATTRIBUTION_ENABLE" ] + cflags += [ "-DACE_ENGINE_PLUGIN_PATH=\"${window_manager_feature_asbng_path}\"" ] + } } config("ui_effect_public_config") { @@ -123,6 +130,10 @@ ohos_shared_library("scene_session") { "host/src/zidl/session_stub.cpp", ] + if (window_manager_feature_asbng_path_enable) { + sources += [ "host/src/atomicservice_basic_engine_plugin.cpp" ] + } + public_configs = [ ":session_public_config" ] deps = [ diff --git a/window_scene/session/host/include/atomicservice_basic_engine_plugin.h b/window_scene/session/host/include/atomicservice_basic_engine_plugin.h new file mode 100644 index 0000000000..ec1d3648c3 --- /dev/null +++ b/window_scene/session/host/include/atomicservice_basic_engine_plugin.h @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ATOMICSERVICE_BASIC_ENGINE_PLUGIN +#define ATOMICSERVICE_BASIC_ENGINE_PLUGIN + +#include +#include +#include + +#include "parcel.h" + +namespace OHOS::Rosen { +#ifdef WINDOW_ATOMIC_SERVICE_ATTRIBUTION_ENABLE +class AtomicserviceIconInfo : public virtual Parcelable { +public: + AtomicserviceIconInfo(); + virtual ~AtomicserviceIconInfo() = default; + + // The following functions are used to get data + std::string GetBundleName() const; + std::string GetModuleName() const; + std::string GetAbilityName() const; + std::string GetCircleIcon() const; + std::string GetEyelashRingIcon() const; + std::string GetAppName() const; + std::vector GetDeviceTypes() const; + int32_t GetResizable() const; + std::vector GetSupportWindowMode() const; + + // The following functions are used to set data + void SetBundleName(const std::string& val); + void SetModuleName(const std::string& val); + void SetAbilityName(const std::string& val); + void SetCircleIcon(const std::string& val); + void SetEyelashRingIcon(const std::string& val); + void SetAppName(const std::string& val); + void SetDeviceTypes(const std::vector& val); + void SetResizable(int32_t val); + void SetSupportWindowMode(const std::vector& val); + + // The following functions are used for serialization and deserialization + bool Marshalling(Parcel& parcel) const override; + static AtomicserviceIconInfo* Unmarshalling(Parcel& parcel); + +private: + // Member variable + std::string bundleName_; + std::string moduleName_; + std::string abilityName_; + std::string circleIcon_; + std::string eyelashRingIcon_; + std::string appName_; + std::vector deviceTypes_; + int32_t resizable_; + std::vector supportWindowMode_; +}; + +class AtomicServiceBasicEnginePlugin { +public: + static AtomicServiceBasicEnginePlugin& GetInstance(); + int32_t ReleaseData(); + AtomicserviceIconInfo* GetParamsFromAtomicServiceBasicEngine(const std::string& bundleName); + +private: + AtomicServiceBasicEnginePlugin(); + ~AtomicServiceBasicEnginePlugin(); + + typedef int32_t GetAtomicserviceIconInfoPlugin( + std::string bundleName, AtomicserviceIconInfo** atomicserviceIconInfo); + typedef void FreeData(AtomicserviceIconInfo* data); + + std::mutex mutex_; + void* atomicServiceBasicEngine_ = nullptr; + AtomicserviceIconInfo* atomicserviceIconInfo_ = nullptr; + GetAtomicserviceIconInfoPlugin* getAtomicserviceIconInfoPlugin_ = nullptr; + FreeData* freeData_ = nullptr; +}; // AtomicServiceBasicEnginePlugin +#endif // WINDOW_ATOMIC_SERVICE_ATTRIBUTION_ENABLE +} // namespace OHOS::Rosen +#endif // ATOMICSERVICE_BASIC_ENGINE_PLUGIN diff --git a/window_scene/session/host/src/atomicservice_basic_engine_plugin.cpp b/window_scene/session/host/src/atomicservice_basic_engine_plugin.cpp new file mode 100644 index 0000000000..678a8508c9 --- /dev/null +++ b/window_scene/session/host/src/atomicservice_basic_engine_plugin.cpp @@ -0,0 +1,205 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "session/host/include/atomicservice_basic_engine_plugin.h" +#include "window_manager_hilog.h" + +namespace OHOS::Rosen { +#ifdef WINDOW_ATOMIC_SERVICE_ATTRIBUTION_ENABLE +AtomicserviceIconInfo::AtomicserviceIconInfo() : bundleName_(""), moduleName_(""), abilityName_(""), circleIcon_(""), + eyelashRingIcon_(""), appName_(""), deviceTypes_({}), resizable_(0), supportWindowMode_({}) +{} + +std::string AtomicserviceIconInfo::GetBundleName() const +{ + return bundleName_; +} + +std::string AtomicserviceIconInfo::GetModuleName() const +{ + return moduleName_; +} + +std::string AtomicserviceIconInfo::GetAbilityName() const +{ + return abilityName_; +} + +std::string AtomicserviceIconInfo::GetCircleIcon() const +{ + return circleIcon_; +} + +std::string AtomicserviceIconInfo::GetEyelashRingIcon() const +{ + return eyelashRingIcon_; +} + +std::string AtomicserviceIconInfo::GetAppName() const +{ + return appName_; +} + +std::vector AtomicserviceIconInfo::GetDeviceTypes() const +{ + return deviceTypes_; +} + +std::vector AtomicserviceIconInfo::GetSupportWindowMode() const +{ + return supportWindowMode_; +} + +int32_t AtomicserviceIconInfo::GetResizable() const +{ + return resizable_; +} + +void AtomicserviceIconInfo::SetBundleName(const std::string& val) +{ + bundleName_ = val; +} + +void AtomicserviceIconInfo::SetModuleName(const std::string& val) +{ + moduleName_ = val; +} + +void AtomicserviceIconInfo::SetAbilityName(const std::string& val) +{ + abilityName_ = val; +} + +void AtomicserviceIconInfo::SetCircleIcon(const std::string& val) +{ + circleIcon_ = val; +} + +void AtomicserviceIconInfo::SetEyelashRingIcon(const std::string& val) +{ + eyelashRingIcon_ = val; +} + +void AtomicserviceIconInfo::SetAppName(const std::string& val) +{ + appName_ = val; +} + +void AtomicserviceIconInfo::SetDeviceTypes(const std::vector& val) +{ + deviceTypes_ = val; +} + +void AtomicserviceIconInfo::SetSupportWindowMode(const std::vector& val) +{ + supportWindowMode_ = val; +} + +void AtomicserviceIconInfo::SetResizable(int32_t val) +{ + resizable_ = val; +} + +bool AtomicserviceIconInfo::Marshalling(Parcel& parcel) const +{ + return true; +} + +AtomicserviceIconInfo *AtomicserviceIconInfo::Unmarshalling(Parcel& parcel) +{ + AtomicserviceIconInfo *data = new AtomicserviceIconInfo(); + return data; +} + +AtomicServiceBasicEnginePlugin::AtomicServiceBasicEnginePlugin() +{ + // if ACE_ENGINE_PLUGIN_PATH is defined, load so pack +#ifdef ACE_ENGINE_PLUGIN_PATH + atomicServiceBasicEngine_ = dlopen( + (char*)ACE_ENGINE_PLUGIN_PATH, RTLD_LAZY); + if (atomicServiceBasicEngine_ == nullptr) { + TLOGW(WmsLogTag::WMS_LIFE, + "dlopen lib %{public}s false", (char*)ACE_ENGINE_PLUGIN_PATH); + return; + } +#else + TLOGW(WmsLogTag::WMS_LIFE, "ACE_ENGINE_PLUGIN_PATH is not defined"); + return; +#endif + // load function GetAtomicserviceIconInfoPlugin + getAtomicserviceIconInfoPlugin_ = (GetAtomicserviceIconInfoPlugin*)(dlsym( + atomicServiceBasicEngine_, "GetAtomicserviceIconInfoPlugin")); + if (getAtomicserviceIconInfoPlugin_ == nullptr) { + TLOGW(WmsLogTag::WMS_LIFE, + "fail to dlsym GetAtomicserviceIconInfoPlugin, reason: %{public}s", dlerror()); + return; + } + // load function FreeData + freeData_ = (FreeData*)(dlsym(atomicServiceBasicEngine_, "FreeAtomicserviceIconInfoPlugin")); + if (freeData_ == nullptr) { + TLOGW(WmsLogTag::WMS_LIFE, + "fail to dlsym FreeData, reason: %{public}s", dlerror()); + return; + } +} + +AtomicServiceBasicEnginePlugin::~AtomicServiceBasicEnginePlugin() +{ + // close dlopen so pack + if (atomicServiceBasicEngine_ != nullptr) { + dlclose(atomicServiceBasicEngine_); + atomicServiceBasicEngine_ = nullptr; + } + ReleaseData(); + getAtomicserviceIconInfoPlugin_ = nullptr; + freeData_ = nullptr; +} + +AtomicServiceBasicEnginePlugin& AtomicServiceBasicEnginePlugin::GetInstance() +{ + static AtomicServiceBasicEnginePlugin instance; + return instance; +} + +AtomicserviceIconInfo* AtomicServiceBasicEnginePlugin::GetParamsFromAtomicServiceBasicEngine( + const std::string& bundleName) +{ + std::lock_guard lock(mutex_); + if (getAtomicserviceIconInfoPlugin_ == nullptr) { + TLOGE(WmsLogTag::WMS_LIFE, "getAtomicserviceIconInfoPlugin_ is nullptr"); + return nullptr; + } + int32_t ret = getAtomicserviceIconInfoPlugin_(bundleName, &atomicserviceIconInfo_); + if (ret != 0) { + TLOGE(WmsLogTag::WMS_LIFE, "failed, bundleName:%{public}s", bundleName.c_str()); + return nullptr; + } + return atomicserviceIconInfo_; +} + +int32_t AtomicServiceBasicEnginePlugin::ReleaseData() +{ + std::lock_guard lock(mutex_); + // free data + if (freeData_ != nullptr && atomicserviceIconInfo_ != nullptr) { + freeData_(atomicserviceIconInfo_); + atomicserviceIconInfo_ = nullptr; + return 0; + } + TLOGW(WmsLogTag::WMS_LIFE, "dlsym FreeData interface failed, can't release data"); + return -1; +} +#endif // WINDOW_ATOMIC_SERVICE_ATTRIBUTION_ENABLE +} //namespace OHOS::Rosen diff --git a/window_scene/session/host/src/scene_session.cpp b/window_scene/session/host/src/scene_session.cpp index edb53f3b88..a79c52295c 100644 --- a/window_scene/session/host/src/scene_session.cpp +++ b/window_scene/session/host/src/scene_session.cpp @@ -66,6 +66,7 @@ #include "fold_screen_state_internel.h" #include "fold_screen_common.h" #include "session/host/include/ability_info_manager.h" +#include "session/host/include/atomicservice_basic_engine_plugin.h" #include "session/host/include/multi_instance_manager.h" #include "session/host/include/pc_fold_screen_controller.h" @@ -5282,6 +5283,23 @@ WSError SceneSession::ChangeSessionVisibilityWithStatusBar( return WSError::WS_OK; } +static void SetAtomicServiceInfo(SessionInfo& sessionInfo) +{ +#ifdef ACE_ENGINE_PLUGIN_PATH + AtomicServiceInfo* atomicServiceInfo = AtomicServiceBasicEnginePlugin::GetInstance(). + GetParamsFromAtomicServiceBasicEngine(sessionInfo.bundleName_); + if (atomicServiceInfo != nullptr) { + sessionInfo.atomicServiceInfo_.appNameInfo_ = atomicServiceInfo->GetAppName(); + sessionInfo.atomicServiceInfo_.circleIcon_ = atomicServiceInfo->GetCircleIcon(); + sessionInfo.atomicServiceInfo_.eyelashRingIcon_ = atomicServiceInfo->GetEyelashRingIcon(); + sessionInfo.atomicServiceInfo_.deviceTypes_ = atomicServiceInfo->GetDeviceTypes(); + sessionInfo.atomicServiceInfo_.resizable_ = atomicServiceInfo->GetResizable(); + sessionInfo.atomicServiceInfo_.supportWindowMode_ = atomicServiceInfo->GetSupportWindowMode(); + } + AtomicServiceBasicEnginePlugin::GetInstance().ReleaseData(); +#endif +} + static SessionInfo MakeSessionInfoDuringPendingActivation(const sptr& abilitySessionInfo, const sptr& session, bool isFoundationCall) { @@ -5330,6 +5348,10 @@ static SessionInfo MakeSessionInfoDuringPendingActivation(const sptrsupportWindowModes.end()); } } + if (info.isAtomicService_ && info.want != nullptr && + (info.want->GetFlags() & AAFwk::Want::FLAG_INSTALL_ON_DEMAND) == AAFwk::Want::FLAG_INSTALL_ON_DEMAND) { + SetAtomicServiceInfo(info); + } if (info.want != nullptr) { info.windowMode = info.want->GetIntParam(AAFwk::Want::PARAM_RESV_WINDOW_MODE, 0); info.sessionAffinity = info.want->GetStringParam(Rosen::PARAM_KEY::PARAM_MISSION_AFFINITY_KEY); diff --git a/window_scene/test/unittest/BUILD.gn b/window_scene/test/unittest/BUILD.gn index 3c5425840f..1ef6de2ea8 100644 --- a/window_scene/test/unittest/BUILD.gn +++ b/window_scene/test/unittest/BUILD.gn @@ -405,6 +405,13 @@ ohos_unittest("ws_session_test") { "accessibility:accessibility_common", "eventhandler:libeventhandler", ] + + cflags = [] + defines = [] + if (window_manager_feature_asbng_path_enable) { + defines += [ "WINDOW_ATOMIC_SERVICE_ATTRIBUTION_ENABLE" ] + cflags += [ "-DACE_ENGINE_PLUGIN_PATH=\"${window_manager_feature_asbng_path}\"" ] + } } ohos_unittest("ws_session_lifecycle_test") { @@ -941,6 +948,13 @@ ohos_unittest("ws_scene_session_lifecycle_test") { external_deps = test_external_deps external_deps += [ "ability_base:session_info" ] + + cflags = [] + defines = [] + if (window_manager_feature_asbng_path_enable) { + defines += [ "WINDOW_ATOMIC_SERVICE_ATTRIBUTION_ENABLE" ] + cflags += [ "-DACE_ENGINE_PLUGIN_PATH=\"${window_manager_feature_asbng_path}\"" ] + } } ohos_unittest("ws_window_session_property_test") { diff --git a/window_scene/test/unittest/scene_session_lifecycle_test.cpp b/window_scene/test/unittest/scene_session_lifecycle_test.cpp index 7c6ef314ac..6bdd7e0e89 100644 --- a/window_scene/test/unittest/scene_session_lifecycle_test.cpp +++ b/window_scene/test/unittest/scene_session_lifecycle_test.cpp @@ -1094,6 +1094,37 @@ HWTEST_F(SceneSessionLifecycleTest, NotifySessionBackground, TestSize.Level0) ASSERT_EQ(ret, 1); } +/** + * @tc.name: BatchPendingSessionsActivation + * @tc.desc: BatchPendingSessionsActivation, with atomicService + * @tc.type: FUNC + */ +HWTEST_F(SceneSessionLifecycleTest, BatchPendingSessionsActivation, TestSize.Level0) +{ + SessionInfo info; + info.abilityName_ = "BatchPendingSessionsActivation"; + info.bundleName_ = "BatchPendingSessionsActivation"; + sptr sceneSession; + sceneSession = sptr::MakeSptr(info, nullptr); + ASSERT_NE(sceneSession, nullptr); + sceneSession->isActive_ = true; + sptr property = sptr::MakeSptr(); + property->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT); + sceneSession->SetSessionProperty(property); + + sptr sessionInfo = sptr::MakeSptr(); + std::vector> abilitySessionInfos; + unsigned int flags = 11111111; + AAFwk::Want want; + sessionInfo->want = want; + sessionInfo->want.SetFlags(flags); + sessionInfo->isAtomicService = true; + abilitySessionInfos.emplace_back(sessionInfo); + WSError result = sceneSession->BatchPendingSessionsActivation(abilitySessionInfos); + + EXPECT_EQ(result, WSError::WS_OK); +} + /** * @tc.name: CalculatedStartWindowType01 * @tc.desc: CalculatedStartWindowType when getStartWindowConfigFunc_ is null. diff --git a/windowmanager_aafwk.gni b/windowmanager_aafwk.gni index f8e5268dec..720ace020d 100644 --- a/windowmanager_aafwk.gni +++ b/windowmanager_aafwk.gni @@ -45,11 +45,20 @@ declare_args() { window_manager_feature_multi_usr = true window_manager_feature_screenless = false + # Set atomicservice basic engine so path + window_manager_feature_asbng_path = "" + if (defined(global_parts_info) && !defined(global_parts_info.msdp_device_status)) { device_status_enable = false } } +if (window_manager_feature_asbng_path == "") { + window_manager_feature_asbng_path_enable = false +} else { + window_manager_feature_asbng_path_enable = true +} + print( "window_manager_feature_subscribe_motion = ${window_manager_feature_subscribe_motion}") -- Gitee