diff --git a/frameworks/ets/ani/BUILD.gn b/frameworks/ets/ani/BUILD.gn index 4bccd1b37cae1e4f74949455b0920dd1010e1650..b58f886c1caa1ef12a0a8b22be270d5da57b9081 100644 --- a/frameworks/ets/ani/BUILD.gn +++ b/frameworks/ets/ani/BUILD.gn @@ -24,6 +24,7 @@ group("ani_packages") { "${ability_runtime_path}/frameworks/ets/ani/app/application_context:application_context_ani_kit", "${ability_runtime_path}/frameworks/ets/ani/app/context:context_ani_kit", "${ability_runtime_path}/frameworks/ets/ani/app_manager:ability_app_manager_ani_kit", + "${ability_runtime_path}/frameworks/ets/ani/auto_fill_manager:ability_auto_fill_manager_ani_kit", "${ability_runtime_path}/frameworks/ets/ani/form_extension_ability:form_extension_ability_etc", "${ability_runtime_path}/frameworks/ets/ani/insight_intent/insight_intent_driver:insight_intent_driver_ani_kit", "${ability_runtime_path}/frameworks/ets/ani/native_constructor:context_ani", diff --git a/frameworks/ets/ani/auto_fill_manager/BUILD.gn b/frameworks/ets/ani/auto_fill_manager/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..5cb48d5602f89cd5a1662648c31c7e4594735bd3 --- /dev/null +++ b/frameworks/ets/ani/auto_fill_manager/BUILD.gn @@ -0,0 +1,64 @@ +# 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. + +import("//build/ohos.gni") +import("//foundation/ability/ability_runtime/ability_runtime.gni") + +ohos_shared_library("ability_auto_fill_manager_ani_kit") { + branch_protector_ret = "pac_ret" + sanitize = { + cfi = true + cfi_cross_dso = true + cfi_vcall_icall_only = true + debug = false + } + + include_dirs = [ + "./include", + ] + + configs = [] + + public_configs = [] + + sources = [ + "./src/ets_auto_fill_manager.cpp", + "./src/ets_auto_save_request_callback.cpp", + ] + + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + + deps = [ + "${ability_runtime_innerkits_path}/auto_fill_manager:auto_fill_manager", + "${ability_runtime_innerkits_path}/runtime:runtime", + "${ability_runtime_native_path}/ability/native:abilitykit_native", + ] + + external_deps = [ + "ability_base:view_data", + "hilog:libhilog", + "ace_engine:ace_container_scope", + ] + + if (ability_runtime_graphics) { + defines = [ "SUPPORT_GRAPHICS" ] + external_deps += [ "ace_engine:ace_uicontent" ] + } + + innerapi_tags = [ "platformsdk" ] + subsystem_name = "ability" + part_name = "ability_runtime" +} \ No newline at end of file diff --git a/frameworks/ets/ani/auto_fill_manager/include/ets_auto_fill_manager.h b/frameworks/ets/ani/auto_fill_manager/include/ets_auto_fill_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..92f26e8147ae041c21d5d05a017306acf94d2a4a --- /dev/null +++ b/frameworks/ets/ani/auto_fill_manager/include/ets_auto_fill_manager.h @@ -0,0 +1,46 @@ +/* + * 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 OHOS_ABILITY_RUNTIME_ETS_AUTO_FILL_MANAGER_H +#define OHOS_ABILITY_RUNTIME_ETS_AUTO_FILL_MANAGER_H + +#include + +#include "ets_auto_save_request_callback.h" +#include "sts_runtime.h" + +namespace OHOS { +namespace AutoFillManagerEts { +class EtsAutoFillManager { +public: + EtsAutoFillManager() = default; + ~EtsAutoFillManager() = default; + static EtsAutoFillManager &GetInstance(); + static void RequestAutoSave(ani_env *env, ani_object uiContextObj, ani_object autoSaveCallbackObj); + +private: + void OnRequestAutoSave(ani_env *env, ani_object uiContextObj, ani_object autoSaveCallbackObj); + void OnRequestAutoSaveInner(ani_env *env, int32_t instanceId, + const std::shared_ptr &saveRequestCallback); + std::shared_ptr GetCallbackByInstanceId(int32_t instanceId); + void OnRequestAutoSaveDone(int32_t instanceId); + + std::mutex mutexLock_; + std::map> saveRequestObject_; +}; +void EtsAutoFillManagerInit(ani_env *env); +} // namespace AutoFillManagerEts +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_ETS_AUTO_FILL_MANAGER_H \ No newline at end of file diff --git a/frameworks/ets/ani/auto_fill_manager/include/ets_auto_save_request_callback.h b/frameworks/ets/ani/auto_fill_manager/include/ets_auto_save_request_callback.h new file mode 100644 index 0000000000000000000000000000000000000000..ff38565bfccede76e4150ab07c4d74cdad9d675b --- /dev/null +++ b/frameworks/ets/ani/auto_fill_manager/include/ets_auto_save_request_callback.h @@ -0,0 +1,47 @@ +/* + * 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 OHOS_ABILITY_RUNTIME_ETS_AUTO_SAVE_REQUEST_CALLBACK_H +#define OHOS_ABILITY_RUNTIME_ETS_AUTO_SAVE_REQUEST_CALLBACK_H + +#include "native_engine/native_value.h" +#include "save_request_callback_interface.h" +#include "sts_runtime.h" + +namespace OHOS { +namespace AutoFillManagerEts { +using AutoFillManagerFunc = std::function; +class EtsAutoSaveRequestCallback : public AbilityRuntime::ISaveRequestCallback, + public std::enable_shared_from_this { +public: + EtsAutoSaveRequestCallback(ani_env *env, int32_t instanceId, AutoFillManagerFunc autoFillManagerFunc); + virtual ~EtsAutoSaveRequestCallback(); + + void Register(ani_object object); + void OnSaveRequestSuccess() override; + void OnSaveRequestFailed() override; + +private: + void ETSCallFunction(const std::string &methodName); + bool IsEtsCallbackEquals(std::shared_ptr callback, ani_object object); + + ani_env *env_ = nullptr; + std::shared_ptr callback_ = nullptr; + int32_t instanceId_ = -1; + AutoFillManagerFunc autoFillManagerFunc_ = nullptr; +}; +} // namespace AutoFillManagerEts +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_ETS_AUTO_SAVE_REQUEST_CALLBACK_H \ No newline at end of file diff --git a/frameworks/ets/ani/auto_fill_manager/src/ets_auto_fill_manager.cpp b/frameworks/ets/ani/auto_fill_manager/src/ets_auto_fill_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..afebfe273a60450fa6e59bdcf77784af5d58578c --- /dev/null +++ b/frameworks/ets/ani/auto_fill_manager/src/ets_auto_fill_manager.cpp @@ -0,0 +1,184 @@ +/* + * 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 "ets_auto_fill_manager.h" + +#include "ability_business_error.h" +#include "auto_fill_manager.h" +#include "core/common/container_scope.h" +#include "hilog_tag_wrapper.h" +#include "sts_error_utils.h" + +namespace OHOS { +namespace AutoFillManagerEts { +namespace { +constexpr const char* AUTO_FILL_MANAGER_NAME_SPACE = "L@ohos/app/ability/autoFillManager/autoFillManager;"; +} // namespace + +EtsAutoFillManager &EtsAutoFillManager::GetInstance() +{ + static EtsAutoFillManager instance; + return instance; +} + +void EtsAutoFillManager::RequestAutoSave(ani_env *env, ani_object uiContextObj, ani_object autoSaveCallbackObj) +{ + GetInstance().OnRequestAutoSave(env, uiContextObj, autoSaveCallbackObj); +} + +void EtsAutoFillManager::OnRequestAutoSave(ani_env *env, ani_object uiContextObj, ani_object autoSaveCallbackObj) +{ + TAG_LOGD(AAFwkTag::AUTOFILLMGR, "requestAutoSave called"); + if (env == nullptr) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "null env"); + return; + } + if (uiContextObj == nullptr || autoSaveCallbackObj == nullptr) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "null uiContextObj or autoSaveCallbackObj"); + return; + } + ani_status status = ANI_OK; + int32_t instanceId = Ace::ContainerScope::CurrentId(); + auto saveCallback = GetCallbackByInstanceId(instanceId); + if (saveCallback != nullptr) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "there are other requests in progress"); + AbilityRuntime::ThrowStsError(env, AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER); + return; + } + auto autoSaveMangerFunc = [this](const int32_t arg) { this->OnRequestAutoSaveDone(arg); }; + saveCallback = std::make_shared(env, instanceId, autoSaveMangerFunc); + if (saveCallback == nullptr) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "null saveCallback"); + AbilityRuntime::ThrowStsError(env, AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER); + return; + } + ani_boolean isCallbackUndefined; + if ((status = env->Reference_IsUndefined(autoSaveCallbackObj, &isCallbackUndefined)) != ANI_OK) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "Falied to check undefinde status: %{public}d", status); + AbilityRuntime::ThrowStsError(env, + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_PARAM), + "Parameter error. The second parameter is not of type autoSaveCallbackObj."); + return; + } + if (!isCallbackUndefined) { + saveCallback->Register(autoSaveCallbackObj); + } + OnRequestAutoSaveInner(env, instanceId, saveCallback); +} + +void EtsAutoFillManager::OnRequestAutoSaveInner(ani_env *env, int32_t instanceId, + const std::shared_ptr &saveRequestCallback) +{ +#ifdef SUPPORT_GRAPHICS + auto uiContent = Ace::UIContent::GetUIContent(instanceId); + if (uiContent == nullptr) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "null uiContent"); + AbilityRuntime::ThrowStsError(env, AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER); + return; + } + if (uiContent->CheckNeedAutoSave()) { + AbilityRuntime::AutoFill::AutoFillRequest request; + uiContent->DumpViewData(request.viewData, request.autoFillType); + request.autoFillCommand = AbilityRuntime::AutoFill::AutoFillCommand::SAVE; + AbilityRuntime::AutoFill::AutoFillResult result; + auto ret = AbilityRuntime::AutoFillManager::GetInstance().RequestAutoSave(uiContent, request, + saveRequestCallback, result); + if (ret != ERR_OK) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "RequestAutoSave error[%{public}d]", ret); + AbilityRuntime::ThrowStsError(env, AbilityRuntime::CreateStsErrorByNativeErr(env, + static_cast(ret))); + return; + } + std::lock_guard lock(mutexLock_); + saveRequestObject_.emplace(instanceId, saveRequestCallback); + } +#endif // SUPPORT_GRAPHICS +} + +std::shared_ptr EtsAutoFillManager::GetCallbackByInstanceId(int32_t instanceId) +{ + std::lock_guard lock(mutexLock_); + auto iter = saveRequestObject_.find(instanceId); + if (iter != saveRequestObject_.end()) { + return iter->second.lock(); + } + return nullptr; +} + +void EtsAutoFillManager::OnRequestAutoSaveDone(int32_t instanceId) +{ + std::lock_guard lock(mutexLock_); + auto iter = saveRequestObject_.find(instanceId); + if (iter != saveRequestObject_.end()) { + saveRequestObject_.erase(iter); + } +} + +void EtsAutoFillManagerInit(ani_env *env) +{ + TAG_LOGD(AAFwkTag::AUTOFILLMGR, "EtsAutoFillManagerInit call"); + if (env == nullptr) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "null env"); + return; + } + if (env->ResetError() != ANI_OK) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "ResetError failed"); + } + ani_status status = ANI_ERROR; + ani_namespace ns; + status = env->FindNamespace(AUTO_FILL_MANAGER_NAME_SPACE, &ns); + if (status != ANI_OK) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "FindNamespace autoFillManager failed status : %{public}d", status); + return; + } + std::array kitFunctions = {ani_native_function{ + "requestAutoSaveWithScope", + "L@ohos/arkui/UIContext/UIContext;" + "L@ohos/app/ability/autoFillManager/autoFillManager/AutoSaveCallback;:V", + reinterpret_cast(EtsAutoFillManager::RequestAutoSave)}}; + status = env->Namespace_BindNativeFunctions(ns, kitFunctions.data(), kitFunctions.size()); + if (status != ANI_OK) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "Namespace_BindNativeFunctions failed status : %{public}d", status); + } + if (env->ResetError() != ANI_OK) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "ResetError failed"); + } + TAG_LOGD(AAFwkTag::AUTOFILLMGR, "EtsAutoFillManagerInit end"); +} + +extern "C" { +ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result) +{ + TAG_LOGD(AAFwkTag::AUTOFILLMGR, "in AutoFillManagerEts.ANI_Constructor"); + if (vm == nullptr || result == nullptr) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "null vm or result"); + return ANI_INVALID_ARGS; + } + + ani_env *env = nullptr; + ani_status status = ANI_ERROR; + status = vm->GetEnv(ANI_VERSION_1, &env); + if (status != ANI_OK) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "GetEnv failed, status=%{public}d", status); + return ANI_NOT_FOUND; + } + EtsAutoFillManagerInit(env); + *result = ANI_VERSION_1; + TAG_LOGD(AAFwkTag::AUTOFILLMGR, "AutoFillManagerEts.ANI_Constructor finished"); + return ANI_OK; +} +} +} // namespace AutoFillManagerEts +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/ets/ani/auto_fill_manager/src/ets_auto_save_request_callback.cpp b/frameworks/ets/ani/auto_fill_manager/src/ets_auto_save_request_callback.cpp new file mode 100644 index 0000000000000000000000000000000000000000..53d86e4071ac9193875e6b655e9856b99b22c11c --- /dev/null +++ b/frameworks/ets/ani/auto_fill_manager/src/ets_auto_save_request_callback.cpp @@ -0,0 +1,126 @@ +/* + * 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 "ets_auto_save_request_callback.h" + +#include "hilog_tag_wrapper.h" + +namespace OHOS { +namespace AutoFillManagerEts { +namespace { +const std::string METHOD_ON_SAVE_REQUEST_SUCCESS = "onSuccess"; +const std::string METHOD_ON_SAVE_REQUEST_FAILED = "onFailure"; +} // namespace + +EtsAutoSaveRequestCallback::EtsAutoSaveRequestCallback(ani_env *env, int32_t instanceId, + AutoFillManagerFunc autoFillManagerFunc) + : env_(env), instanceId_(instanceId), autoFillManagerFunc_(autoFillManagerFunc) {} + +EtsAutoSaveRequestCallback::~EtsAutoSaveRequestCallback() {} + +void EtsAutoSaveRequestCallback::OnSaveRequestSuccess() +{ + TAG_LOGD(AAFwkTag::AUTOFILLMGR, "onSuccess called"); + ETSCallFunction(METHOD_ON_SAVE_REQUEST_SUCCESS); + if (autoFillManagerFunc_ != nullptr) { + autoFillManagerFunc_(instanceId_); + } +} + +void EtsAutoSaveRequestCallback::OnSaveRequestFailed() +{ + TAG_LOGD(AAFwkTag::AUTOFILLMGR, "onFailure called"); + ETSCallFunction(METHOD_ON_SAVE_REQUEST_FAILED); + if (autoFillManagerFunc_ != nullptr) { + autoFillManagerFunc_(instanceId_); + } +} + +void EtsAutoSaveRequestCallback::Register(ani_object object) +{ + TAG_LOGD(AAFwkTag::AUTOFILLMGR, "called"); + if (env_ == nullptr || object == nullptr) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "null env_ or object"); + return; + } + + if (IsEtsCallbackEquals(callback_, object)) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "callback exist"); + return; + } + + ani_ref objRef = nullptr; + if (env_->GlobalReference_Create(object, &objRef) != ANI_OK) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "GlobalReference_Create failed"); + return; + } + + callback_ = std::make_shared(); + if (callback_ == nullptr) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "null callback_"); + return; + } + callback_->aniObj = object; + callback_->aniRef = objRef; +} + +void EtsAutoSaveRequestCallback::ETSCallFunction(const std::string &methodName) +{ + if (env_ == nullptr || callback_ == nullptr) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "null env_ or callback_"); + return; + } + + ani_status status = ANI_OK; + ani_ref funRef; + status = env_->Object_GetPropertyByName_Ref(reinterpret_cast(callback_->aniRef), methodName.c_str(), + &funRef); + if (status != ANI_OK) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "Object_GetField_Ref failed status: %{public}d", status); + return; + } + + ani_ref resutlt; + if ((status = env_->FunctionalObject_Call(reinterpret_cast(funRef), 0, nullptr, &resutlt)) != + ANI_OK) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "FunctionalObject_Call failed, status: %{public}d", status); + return; + } +} + +bool EtsAutoSaveRequestCallback::IsEtsCallbackEquals(std::shared_ptr callback, + ani_object object) +{ + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "Invalid etsCallback"); + return false; + } + + if (env_ == nullptr || object == nullptr) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "null env_ or object"); + return false; + } + + ani_boolean isEquals = false; + if ((env_->Reference_StrictEquals(reinterpret_cast(object), reinterpret_cast(callback->aniObj), + &isEquals)) != ANI_OK) { + TAG_LOGE(AAFwkTag::AUTOFILLMGR, "Object not match"); + return false; + } + + return isEquals; +} +} // namespace AutoFillManagerEts +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/ets/ets/@ohos.app.ability.autoFillManager.ets b/frameworks/ets/ets/@ohos.app.ability.autoFillManager.ets new file mode 100644 index 0000000000000000000000000000000000000000..2a411e40dfc5df4129fd1f142894e3b042089d60 --- /dev/null +++ b/frameworks/ets/ets/@ohos.app.ability.autoFillManager.ets @@ -0,0 +1,39 @@ +/* + * 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. + */ + +import { UIContext } from '@ohos.arkui.UIContext'; + +namespace autoFillManager { + loadLibrary("ability_auto_fill_manager_ani_kit.z"); + + export interface AutoSaveCallback { + onSuccess(): void; + onFailure(): void; + } + + class AutoSaveCallbackInner implements AutoSaveCallback { + public onSuccess() {}; + public onFailure() {}; + } + + export native function requestAutoSaveWithScope(context: UIContext, callback?: AutoSaveCallback): void; + export function requestAutoSave(context: UIContext, callback?: AutoSaveCallback): void { + context.runScopedTask(() => { + requestAutoSaveWithScope(context, callback); + }); + } +} + +export default autoFillManager; diff --git a/frameworks/ets/ets/BUILD.gn b/frameworks/ets/ets/BUILD.gn index e692229ae8e6afface32d379d3c467c820e8081c..b2b1c00abebfd4cf083a284282dcb33ce699f26e 100644 --- a/frameworks/ets/ets/BUILD.gn +++ b/frameworks/ets/ets/BUILD.gn @@ -631,6 +631,22 @@ ohos_prebuilt_etc("ability_runtime_app_manager_abc_etc") { deps = [ ":ability_runtime_app_manager_abc" ] } +generate_static_abc("ability_runtime_auto_fill_manager_abc") { + base_url = "./" + files = [ "./@ohos.app.ability.autoFillManager.ets" ] + + is_boot_abc = "True" + device_dst_file = "/system/framework/ability_runtime_auto_fill_manager_abc.abc" +} + +ohos_prebuilt_etc("ability_runtime_auto_fill_manager_abc_etc") { + source = "$target_out_dir/ability_runtime_auto_fill_manager_abc.abc" + module_install_dir = "framework" + subsystem_name = "ability" + part_name = "ability_runtime" + deps = [ ":ability_runtime_auto_fill_manager_abc" ] +} + generate_static_abc("ui_extension_ability_ani_abc") { base_url = "./" @@ -969,6 +985,7 @@ group("ets_packages") { ":ability_runtime_ability_state_data_abc_etc", ":ability_runtime_ability_utils_abc_etc", ":ability_runtime_app_manager_abc_etc", + ":ability_runtime_auto_fill_manager_abc_etc", ":ability_runtime_app_state_data_abc_etc", ":ability_runtime_application_context_abc_etc", ":ability_runtime_application_state_change_callback_abc_etc",