From e5b48b63e19ef88cc2b89099820e6e4f45fa6a45 Mon Sep 17 00:00:00 2001 From: sunjie Date: Fri, 12 Sep 2025 09:39:38 +0800 Subject: [PATCH] =?UTF-8?q?1.2=E6=A1=A5=E9=98=B6=E5=B1=82=E4=BC=98?= =?UTF-8?q?=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: sunjie --- bundle.json | 2 - .../resmgr/include/resource_manager_impl.h | 14 + frameworks/resmgr/include/utils/utils.h | 13 +- .../resmgr/src/resource_manager_impl.cpp | 10 + frameworks/resmgr/src/utils/utils.cpp | 15 + interfaces/ets/ani/BUILD.gn | 4 +- interfaces/ets/ani/resourceManager/BUILD.gn | 54 +- .../ets/@ohos.resourceManager.ets | 20 + .../resourceManager/include/ani_signature.h | 45 + ...source_manager_ani_utils.h => ani_utils.h} | 34 +- .../ani/resourceManager/include/resmgr_ani.h | 131 ++ .../resourceManager/include/resourceManager.h | 111 +- .../include/resource_manager_data_context.h | 76 - .../ets/ani/resourceManager/src/ani_utils.cpp | 639 ++++++ .../ani/resourceManager/src/resmgr_ani.cpp | 1205 ++++++++++- .../resourceManager/src/resourceManager.cpp | 1814 +---------------- .../src/resource_manager_ani_utils.cpp | 90 - .../core/include/resource_manager_addon.h | 3 + .../core/src/resource_manager_addon.cpp | 8 + 19 files changed, 2193 insertions(+), 2095 deletions(-) create mode 100644 interfaces/ets/ani/resourceManager/include/ani_signature.h rename interfaces/ets/ani/resourceManager/include/{resource_manager_ani_utils.h => ani_utils.h} (36%) create mode 100644 interfaces/ets/ani/resourceManager/include/resmgr_ani.h delete mode 100644 interfaces/ets/ani/resourceManager/include/resource_manager_data_context.h create mode 100644 interfaces/ets/ani/resourceManager/src/ani_utils.cpp delete mode 100644 interfaces/ets/ani/resourceManager/src/resource_manager_ani_utils.cpp diff --git a/bundle.json b/bundle.json index ae3400e..5912919 100755 --- a/bundle.json +++ b/bundle.json @@ -169,8 +169,6 @@ "header": { "header_base": "//base/global/resource_management/interfaces/ets/ani/resourceManager/include", "header_files": [ - "resource_manager_ani_utils.h", - "resource_manager_data_context.h", "resourceManager.h" ] }, diff --git a/frameworks/resmgr/include/resource_manager_impl.h b/frameworks/resmgr/include/resource_manager_impl.h index 39c0a1f..cf273d1 100644 --- a/frameworks/resmgr/include/resource_manager_impl.h +++ b/frameworks/resmgr/include/resource_manager_impl.h @@ -851,6 +851,20 @@ public: */ std::shared_ptr GetHapManager(); + /** + * Determine whether it is system resourceManager + * + * @return true if system resourceManager, else not system resourceManager + */ + bool IsSystem(); + + /** + * Determine whether it is override resourceManager + * + * @return true if override resourceManager, else not override resourceManager + */ + bool IsOverride(); + private: RState GetString(const std::shared_ptr idItem, std::string &outValue); diff --git a/frameworks/resmgr/include/utils/utils.h b/frameworks/resmgr/include/utils/utils.h index b75eaf8..ff20499 100644 --- a/frameworks/resmgr/include/utils/utils.h +++ b/frameworks/resmgr/include/utils/utils.h @@ -16,11 +16,14 @@ #define OHOS_RESOURCE_MANAGER_UTILS_H #include #include +#include +#include + +#include + #include "res_locale.h" #include "rstate.h" -#include -#include -#include +#include "res_common.h" namespace OHOS { namespace Global { @@ -119,6 +122,10 @@ public: static bool convertToDouble(const std::string& str, double& outValue); static bool IsSystemPath(const std::string& path); + + EXPORT_FUNC static std::string GetSystemParameter(const std::string& paramKey); + + EXPORT_FUNC static bool SupportSingleLayerThemeIcon(); private: static bool IsValidValue(const char* end, const std::string& str); diff --git a/frameworks/resmgr/src/resource_manager_impl.cpp b/frameworks/resmgr/src/resource_manager_impl.cpp index 5f7205c..730dda3 100644 --- a/frameworks/resmgr/src/resource_manager_impl.cpp +++ b/frameworks/resmgr/src/resource_manager_impl.cpp @@ -2074,6 +2074,16 @@ std::shared_ptr ResourceManagerImpl::GetHapManager() return hapManager_; } +bool ResourceManagerImpl::IsSystem() +{ + return isSystemResMgr_; +} + +bool ResourceManagerImpl::IsOverride() +{ + return isOverrideResMgr_; +} + std::shared_ptr ResourceManagerImpl::GetOverrideResourceManager( std::shared_ptr overrideResConfig) { diff --git a/frameworks/resmgr/src/utils/utils.cpp b/frameworks/resmgr/src/utils/utils.cpp index ba1c8ea..924231e 100644 --- a/frameworks/resmgr/src/utils/utils.cpp +++ b/frameworks/resmgr/src/utils/utils.cpp @@ -27,6 +27,7 @@ #if !defined(__WINNT__) && !defined(__IDE_PREVIEW__) && !defined(__ARKUI_CROSS__) #include "hitrace_meter.h" +#include "parameters.h" #endif #ifdef __WINNT__ @@ -590,6 +591,20 @@ bool Utils::IsSystemPath(const std::string& path) || Utils::endWithTail(path, "\\resources\\resources.index") || Utils::endWithTail(path, "/resources/resources.index"); } + +std::string Utils::GetSystemParameter(const std::string& paramKey) +{ + std::string paramValue; +#if !defined(__WINNT__) && !defined(__IDE_PREVIEW__) && !defined(__ARKUI_CROSS__) + paramValue = system::GetParameter(paramKey, ""); +#endif + return paramValue; +} + +bool Utils::SupportSingleLayerThemeIcon() +{ + return GetSystemParameter("const.global.support_single_icon_theme") == "true"; +} } // namespace Resource } // namespace Global } // namespace OHOS diff --git a/interfaces/ets/ani/BUILD.gn b/interfaces/ets/ani/BUILD.gn index 688a2d6..3721a6f 100644 --- a/interfaces/ets/ani/BUILD.gn +++ b/interfaces/ets/ani/BUILD.gn @@ -15,10 +15,10 @@ import("//build/ohos.gni") group("ani_package_resmgr") { deps = [ - "./resourceManager:rawFileDescriptor_etc", "./resourceManager:resmgr_ani", "./resourceManager:resourceManager_ani", - "./resourceManager:resourceManager_etc", "./resourceManager:resource_etc", + "./resourceManager:rawFileDescriptor_etc", + "./resourceManager:resourceManager_etc", ] } diff --git a/interfaces/ets/ani/resourceManager/BUILD.gn b/interfaces/ets/ani/resourceManager/BUILD.gn index 63a7fee..48c5aa4 100644 --- a/interfaces/ets/ani/resourceManager/BUILD.gn +++ b/interfaces/ets/ani/resourceManager/BUILD.gn @@ -23,42 +23,70 @@ config("resourceManager_config") { ohos_shared_library("resourceManager_ani") { public_configs = [ ":resourceManager_config" ] - include_dirs = [ - "./include", - "../../../../frameworks/resmgr/include", - ] + sources = [ "./src/resourceManager.cpp", - "./src/resource_manager_ani_utils.cpp", ] defines = [ "CONFIG_HILOG" ] deps = [ - "../../../js/innerkits/core:resmgr_napi_core", "../../../../frameworks/resmgr:global_resmgr" ] external_deps = [ "ability_runtime:app_context", - "ace_engine:drawable_inner_ani", "hilog:libhilog", - "napi:ace_napi", "runtime_core:ani", - "runtime_core:ani_helpers", ] + branch_protector_ret = "pac_ret" + sanitize = { + boundary_sanitize = true + cfi = true + cfi_cross_dso = true + debug = false + integer_overflow = true + ubsan = true + } + part_name = "resource_management" subsystem_name = "global" } ohos_shared_library("resmgr_ani") { - include_dirs = [ "./include" ] - sources = [ "./src/resmgr_ani.cpp" ] + public_configs = [ ":resourceManager_config" ] + + sources = [ + "./src/resmgr_ani.cpp", + "./src/ani_utils.cpp", + ] + defines = [ "CONFIG_HILOG" ] - deps = [ ":resourceManager_ani" ] + + shlib_type = "ani" + + deps = [ + ":resourceManager_ani", + "../../../js/innerkits/core:resmgr_napi_core", + "../../../../frameworks/resmgr:global_resmgr", + ] + external_deps = [ - "ability_runtime:app_context", "hilog:libhilog", + "ability_runtime:app_context", + "ace_engine:drawable_inner_ani", + "napi:ace_napi", "runtime_core:ani", + "runtime_core:ani_helpers", ] + + branch_protector_ret = "pac_ret" + sanitize = { + boundary_sanitize = true + cfi = true + cfi_cross_dso = true + debug = false + integer_overflow = true + ubsan = true + } part_name = "resource_management" subsystem_name = "global" diff --git a/interfaces/ets/ani/resourceManager/ets/@ohos.resourceManager.ets b/interfaces/ets/ani/resourceManager/ets/@ohos.resourceManager.ets index 4d07f26..0c40bf7 100644 --- a/interfaces/ets/ani/resourceManager/ets/@ohos.resourceManager.ets +++ b/interfaces/ets/ani/resourceManager/ets/@ohos.resourceManager.ets @@ -19,6 +19,23 @@ import { Resource as _Resource } from 'global.resource'; import { RawFileDescriptorInner } from 'global.rawFileDescriptorInner'; import { DrawableDescriptor } from '@ohos.arkui.drawableDescriptor'; +class ResMgrCleaner { + private nativeResMgr: long = 0; + + constructor(ptr:long) { + this.nativeResMgr = ptr; + } + + native destoryResMgr(): void; +} + +function cleanCallback(cleanner:ResMgrCleaner): void { + cleanner.destoryResMgr(); +} + +let destoryRegister = new FinalizationRegistry(cleanCallback); +let unregisterToken = new object(); + export default namespace resourceManager { loadLibrary("resmgr_ani.z"); @@ -191,11 +208,14 @@ export default namespace resourceManager { static { loadLibrary("resmgr_ani.z"); } private nativeResMgr: long = 0; + private cleaner: ResMgrCleaner | null = null; constructor(context: long) { if (this.nativeResMgr == 0) { this.nativeResMgr = context; } + this.cleaner = new ResMgrCleaner(this.nativeResMgr); + destoryRegister.register(this, this.cleaner!, unregisterToken); } native getStringSync(resId: long): string; diff --git a/interfaces/ets/ani/resourceManager/include/ani_signature.h b/interfaces/ets/ani/resourceManager/include/ani_signature.h new file mode 100644 index 0000000..fd7bac1 --- /dev/null +++ b/interfaces/ets/ani/resourceManager/include/ani_signature.h @@ -0,0 +1,45 @@ +/* + * 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 RESOURCE_MANAGER_ANI_SIGN_H +#define RESOURCE_MANAGER_ANI_SIGN_H + +namespace OHOS { +namespace Global { +namespace Resource { +class AniSignature { +public: + + static constexpr const char *ANI_ARRAY = "escompat.Array"; + static constexpr const char *ANI_STRING = "std.core.String"; + static constexpr const char *ANI_UINT8ARRAY = "escompat.Uint8Array"; + static constexpr const char *BUSINESSERROR = "@ohos.base.BusinessError"; + + static constexpr const char *NAMESPACE = "@ohos.resourceManager.resourceManager"; + static constexpr const char *RESOURCE_MANAGER_INNER = + "@ohos.resourceManager.resourceManager.ResourceManagerInner"; + static constexpr const char *RAWFILE_DESCRIPTOR_INNER = "global.rawFileDescriptorInner.RawFileDescriptorInner"; + static constexpr const char *CONFIGURATION = "@ohos.resourceManager.resourceManager.Configuration"; + static constexpr const char *DIRECTION = "@ohos.resourceManager.resourceManager.Direction"; + static constexpr const char *DEVICE_TYPE = "@ohos.resourceManager.resourceManager.DeviceType"; + static constexpr const char *SCREEN_DENSITY = "@ohos.resourceManager.resourceManager.ScreenDensity"; + static constexpr const char *COLOR_MODE = "@ohos.resourceManager.resourceManager.ColorMode"; + static constexpr const char *DEVICE_CAPABILITY = "@ohos.resourceManager.resourceManager.DeviceCapability"; + static constexpr const char *RESMGR_CLEANER = "@ohos.resourceManager.ResMgrCleaner"; +}; +} +} +} +#endif diff --git a/interfaces/ets/ani/resourceManager/include/resource_manager_ani_utils.h b/interfaces/ets/ani/resourceManager/include/ani_utils.h similarity index 36% rename from interfaces/ets/ani/resourceManager/include/resource_manager_ani_utils.h rename to interfaces/ets/ani/resourceManager/include/ani_utils.h index a7fcc3c..054f773 100644 --- a/interfaces/ets/ani/resourceManager/include/resource_manager_ani_utils.h +++ b/interfaces/ets/ani/resourceManager/include/ani_utils.h @@ -16,21 +16,47 @@ #ifndef RESOURCE_MANAGER_ANI_UTILS_H #define RESOURCE_MANAGER_ANI_UTILS_H +#include #include -#include +#include + #include "ani.h" +#include "resource_manager.h" + namespace OHOS { namespace Global { namespace Resource { -class ResourceManagerAniUtils { +class AniUtils { public: static void AniThrow(ani_env *env, int32_t errCode); -private: - static const std::unordered_map ErrorCodeToMsg; + static std::shared_ptr GetResourceManager(ani_env* env, ani_object jsResMgr); + static bool InitAniParameters(ani_env *env, ani_object args, + std::vector> ¶ms); + static std::string AniStrToString(ani_env *env, ani_string aniStr); + static RState ConfigurationToResConfig(ani_env *env, + ani_object configuration, std::shared_ptr &resConfig); + static bool GetOptionalInt(ani_env *env, ani_object optionalInt, int& result); + + static ani_string CreateAniString(ani_env *env, const std::string &str); + static ani_object CreateConfig(ani_env* env, std::unique_ptr &cfg); + static ani_object CreateAniArray(ani_env *env, const std::vector &strs); + static ani_object CreateAniUint8Array(ani_env* env, std::unique_ptr &mediaData, size_t len); + static ani_object CreateDeviceCapability(ani_env *env, std::unique_ptr &cfg); + static ani_object CreateAniRawFileDescriptor(ani_env *env, const ResourceManager::RawFileDescriptor& descriptor); + +private: static std::string FindErrMsg(int32_t errCode); static void ThrowAniError(ani_env *env, ani_int code, const std::string &message); + static bool GetEnumParamOfConfig(ani_env* env, std::shared_ptr configPtr, ani_object configuration); + static bool GetEnumMember(ani_env *env, ani_object options, const std::string name, int& member); + static bool GetLocaleOfConfig(ani_env* env, std::shared_ptr configPtr, ani_object configuration); + static bool SetEnumMember(ani_env *env, ani_object obj, const char* memberName, const char* enumName, + const int index); + static std::string GetLocale(std::unique_ptr &cfg); + static int GetScreenDensityIndex(ScreenDensity value); + static bool GetNumberMember(ani_env *env, ani_object options, const std::string name, int& value); }; } // namespace Resource } // namespace Global diff --git a/interfaces/ets/ani/resourceManager/include/resmgr_ani.h b/interfaces/ets/ani/resourceManager/include/resmgr_ani.h new file mode 100644 index 0000000..0ec0f15 --- /dev/null +++ b/interfaces/ets/ani/resourceManager/include/resmgr_ani.h @@ -0,0 +1,131 @@ +/* + * 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 RESMGR_ANI_H +#define RESMGR_ANI_H + +#include "ani.h" + +namespace OHOS { +namespace Global { +namespace Resource { +class ResMgrAni { +public: + static ani_string GetStringSyncById(ani_env* env, ani_object object, ani_long resId); + + static ani_string GetFormatStringSyncById(ani_env *env, ani_object object, ani_long resId, ani_object args); + + static ani_string GetStringByNameSync(ani_env* env, ani_object object, ani_string aniName); + + static ani_string GetFormatStringByNameSync(ani_env *env, ani_object object, ani_string aniName, ani_object args); + + static ani_boolean GetBooleanById(ani_env* env, ani_object object, ani_long resId); + + static ani_boolean GetBooleanByName(ani_env* env, ani_object object, ani_string aniName); + + static ani_int GetIntById(ani_env* env, ani_object object, ani_long resId); + + static ani_int GetIntByName(ani_env* env, ani_object object, ani_string aniName); + + static ani_double GetDoubleById(ani_env* env, ani_object object, ani_long resId); + + static ani_double GetDoubleByName(ani_env* env, ani_object object, ani_string aniName); + + static ani_string GetIntPluralStringValueSyncById(ani_env* env, ani_object object, + ani_long resId, ani_int num, ani_object args); + + static ani_string GetIntPluralStringByNameSync(ani_env* env, ani_object object, + ani_string aniName, ani_int num, ani_object args); + + static ani_string GetDoublePluralStringValueSyncById(ani_env* env, ani_object object, + ani_long resId, ani_double num, ani_object args); + + static ani_string GetDoublePluralStringByNameSync(ani_env* env, ani_object object, + ani_string aniName, ani_double num, ani_object args); + + static ani_object GetDrawableDescriptorById(ani_env* env, ani_object object, + ani_long resId, ani_object density, ani_object type); + + static ani_object GetDrawableDescriptorByName(ani_env* env, ani_object object, + ani_string aniName, ani_object density, ani_object type); + + static ani_long GetColorSyncById(ani_env* env, ani_object object, ani_long resId); + + static ani_long GetColorByNameSync(ani_env* env, ani_object object, ani_string aniName); + + static void AddResource(ani_env* env, ani_object object, ani_string path); + + static void RemoveResource(ani_env* env, ani_object object, ani_string path); + + static ani_object GetRawFdSync(ani_env* env, ani_object object, ani_string path); + + static void CloseRawFdSync(ani_env* env, ani_object object, ani_string path); + + static ani_boolean IsRawDir(ani_env* env, ani_object object, ani_string path); + + static ani_object GetRawFileListSync(ani_env* env, ani_object object, ani_string path); + + static ani_object GetRawFileContentSync(ani_env* env, ani_object object, ani_string path); + + static ani_object GetMediaContentSyncById(ani_env* env, ani_object object, + ani_long resId, ani_object density); + + static ani_string GetMediaContentBase64SyncById(ani_env* env, ani_object object, + ani_long resId, ani_object density); + + static ani_object GetStringArrayValueSyncById(ani_env* env, ani_object object, ani_long resId); + + static ani_object GetStringArrayByNameSync(ani_env* env, ani_object object, ani_string aniName); + + static ani_object GetMediaByNameSync(ani_env* env, ani_object object, ani_string aniName, ani_object density); + + static ani_string GetMediaBase64ByNameSync(ani_env* env, ani_object object, ani_string aniName, ani_object density); + + static ani_object GetConfigurationSync(ani_env* env, ani_object object); + + static ani_object GetDeviceCapabilitySync(ani_env* env, ani_object object); + + static ani_object GetLocales(ani_env* env, ani_object object, ani_object includeSystem); + + static ani_long GetSymbolById(ani_env* env, ani_object object, ani_long resId); + + static ani_long GetSymbolByName(ani_env* env, ani_object object, ani_string aniName); + + static ani_object GetOverrideResourceManager(ani_env* env, ani_object object, ani_object configuration); + + static ani_object GetOverrideConfiguration(ani_env* env, ani_object object); + + static void UpdateOverrideConfiguration(ani_env* env, ani_object object, ani_object configuration); + + static ani_object GetSysResourceManager(ani_env* env); + + static ani_ref TransferToDynamicResource(ani_env* env, ani_object input); + + static ani_object TransferToStaticResource(ani_env* env, ani_object input); + + static void DestoryResMgr(ani_env* env, ani_object nativePtr); + + static ani_status BindResMgr(ani_env* env); + + static ani_status BindResMgrCleaner(ani_env* env); + + static ani_status BindStaticFunc(ani_env* env); + + static ani_status BindContext(ani_env* env); +}; +} +} +} +#endif \ No newline at end of file diff --git a/interfaces/ets/ani/resourceManager/include/resourceManager.h b/interfaces/ets/ani/resourceManager/include/resourceManager.h index 4ff7098..0f2140a 100644 --- a/interfaces/ets/ani/resourceManager/include/resourceManager.h +++ b/interfaces/ets/ani/resourceManager/include/resourceManager.h @@ -16,10 +16,12 @@ #ifndef RESOURCEMANAGER_H #define RESOURCEMANAGER_H -#include -#include +#include +#include + #include "ani.h" #include "application_context.h" + #include "resource_manager.h" namespace OHOS { @@ -27,112 +29,9 @@ namespace Global { namespace Resource { class ResMgrAddon { public: - ResMgrAddon(const std::string& bundleName, const std::shared_ptr& resMgr, - const std::shared_ptr& context, bool isSystem = false); - ResMgrAddon(const std::shared_ptr& resMgr, bool isSystem = false); - ani_object CreateOverrideAddon(ani_env* env, const std::shared_ptr& resMgr); - static ani_object CreateResMgr(ani_env* env, const std::string& bundleName, const std::shared_ptr& resMgr, std::shared_ptr context); - static ani_object GetSysResourceManager(ani_env* env); - - static ani_string GetStringSyncById(ani_env* env, ani_object object, ani_long resId); - static ani_string GetFormatStringSyncById(ani_env *env, ani_object object, ani_long resId, ani_object args); - - static ani_string GetStringByNameSync(ani_env* env, ani_object object, ani_string resName); - static ani_string GetFormatStringByNameSync(ani_env *env, ani_object object, ani_string resName, ani_object args); - - static ani_boolean GetBooleanById(ani_env* env, ani_object object, ani_long resId); - static ani_boolean GetBooleanByName(ani_env* env, ani_object object, ani_string resName); - - static ani_int GetIntById(ani_env* env, ani_object object, ani_long resId); - static ani_int GetIntByName(ani_env* env, ani_object object, ani_string resName); - - static ani_double GetDoubleById(ani_env* env, ani_object object, ani_long resId); - static ani_double GetDoubleByName(ani_env* env, ani_object object, ani_string resName); - - static ani_string GetIntPluralStringValueSyncById(ani_env* env, ani_object object, - ani_long resId, ani_int num, ani_object args); - static ani_string GetIntPluralStringByNameSync(ani_env* env, ani_object object, - ani_string resName, ani_int num, ani_object args); - - static ani_string GetDoublePluralStringValueSyncById(ani_env* env, ani_object object, - ani_long resId, ani_double num, ani_object args); - static ani_string GetDoublePluralStringByNameSync(ani_env* env, ani_object object, - ani_string resName, ani_double num, ani_object args); - - static ani_object GetDrawableDescriptorById(ani_env* env, ani_object object, - ani_long resId, ani_object density, ani_object type); - static ani_object GetDrawableDescriptorByName(ani_env* env, ani_object object, - ani_string resName, ani_object density, ani_object type); - - static ani_long GetColorSyncById(ani_env* env, ani_object object, ani_long resId); - static ani_long GetColorByNameSync(ani_env* env, ani_object object, ani_string resName); - - static void AddResource(ani_env* env, ani_object object, ani_string path); - static void RemoveResource(ani_env* env, ani_object object, ani_string path); - - static ani_object GetRawFdSync(ani_env* env, ani_object object, ani_string path); - static void CloseRawFdSync(ani_env* env, ani_object object, ani_string path); - static ani_boolean IsRawDir(ani_env* env, ani_object object, ani_string path); - - static ani_object GetRawFileListSync(ani_env* env, ani_object object, ani_string path); - static ani_object GetRawFileContentSync(ani_env* env, ani_object object, ani_string path); - - static ani_object GetMediaContentSyncById(ani_env* env, ani_object object, - ani_long resId, ani_object density); - - static ani_string GetMediaContentBase64SyncById(ani_env* env, ani_object object, - ani_long resId, ani_object density); - - static ani_object GetStringArrayValueSyncById(ani_env* env, ani_object object, ani_long resId); - static ani_object GetStringArrayByNameSync(ani_env* env, ani_object object, ani_string resName); - - static ani_object GetMediaByNameSync(ani_env* env, ani_object object, ani_string resName, ani_object density); - static ani_string GetMediaBase64ByNameSync(ani_env* env, ani_object object, ani_string resName, ani_object density); - - static ani_object GetConfigurationSync(ani_env* env, ani_object object); - static ani_object GetDeviceCapabilitySync(ani_env* env, ani_object object); - static ani_object GetLocales(ani_env* env, ani_object object, ani_object includeSystem); - - static ani_long GetSymbolById(ani_env* env, ani_object object, ani_long resId); - static ani_long GetSymbolByName(ani_env* env, ani_object object, ani_string resName); - - static ani_object GetOverrideResourceManager(ani_env* env, ani_object object, ani_object configuration); - static ani_object GetOverrideConfiguration(ani_env* env, ani_object object); - static void UpdateOverrideConfiguration(ani_env* env, ani_object object, ani_object configuration); - static ani_ref TransferToDynamicResource(ani_env* env, ani_object input); - static ani_object TransferToStaticResource(ani_env* env, ani_object input); - static ani_status BindContext(ani_env* env); - - inline std::shared_ptr GetResMgr() - { - return resMgr_; - } - - inline std::shared_ptr GetContext() - { - return context_; - } - - inline bool IsSystem() - { - return isSystem_; - } - - bool isOverrideAddon() - { - return isOverrideAddon_; - } - -private: - static ani_object WrapResourceManager(ani_env* env, std::shared_ptr &addon); - - std::string bundleName_; - std::shared_ptr resMgr_; - std::shared_ptr context_; - bool isSystem_ = false; - bool isOverrideAddon_ = false; + static ani_object WrapResourceManager(ani_env* env, std::shared_ptr resMgr); }; } // namespace Resource } // namespace Global diff --git a/interfaces/ets/ani/resourceManager/include/resource_manager_data_context.h b/interfaces/ets/ani/resourceManager/include/resource_manager_data_context.h deleted file mode 100644 index f8124f5..0000000 --- a/interfaces/ets/ani/resourceManager/include/resource_manager_data_context.h +++ /dev/null @@ -1,76 +0,0 @@ -/* - * 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 RESOURCE_MANAGER_DATA_CONTEXT_H -#define RESOURCE_MANAGER_DATA_CONTEXT_H - -#include "hilog_wrapper.h" -#include "resource_manager.h" - -namespace OHOS { -namespace Global { -namespace Resource { -struct ResMgrDataContext { - std::string bundleName_; - uint32_t resId_; - int32_t param_; - ResourceManager::Quantity quantity_; - - std::string path_; - std::string resName_; - int iValue_; - float fValue_; - bool bValue_; - uint32_t colorValue_; - - std::string value_; - std::vector arrayValue_; - std::vector> jsParams_; - - std::unique_ptr mediaData; - size_t len_; - - std::string errMsg_; - int success_; - int errCode_; - uint32_t density_; - uint32_t iconType_; - uint32_t symbolValue_; - - ResourceManager::RawFileDescriptor descriptor_; - std::shared_ptr addon_; - std::shared_ptr resMgr_; - std::shared_ptr resource_; - std::shared_ptr overrideResConfig_; - - ResMgrDataContext() : resId_(0), param_(0), iValue_(0), fValue_(0.0f), bValue_(false), - colorValue_(0), len_(0), success_(true), errCode_(0), density_(0), iconType_(0), symbolValue_(0) {} - - void SetErrorMsg(const std::string &msg, bool withResId = false, int32_t errCode = 0) - { - errMsg_ = msg; - success_ = false; - errCode_ = errCode; - if (withResId) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "%{public}s id = %{public}d", msg.c_str(), resId_); - } else { - RESMGR_HILOGE(RESMGR_ANI_TAG, "%{public}s name = %{public}s", msg.c_str(), resName_.c_str()); - } - } -}; -} // namespace Resource -} // namespace Global -} // namespace OHOS -#endif diff --git a/interfaces/ets/ani/resourceManager/src/ani_utils.cpp b/interfaces/ets/ani/resourceManager/src/ani_utils.cpp new file mode 100644 index 0000000..1be25d9 --- /dev/null +++ b/interfaces/ets/ani/resourceManager/src/ani_utils.cpp @@ -0,0 +1,639 @@ +/* + * 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 "ani_utils.h" + +#include +#include +#include +#include + +#include "hilog_wrapper.h" +#include "ani_signature_builder.h" +#include "ani_signature.h" +#include "rstate.h" + +namespace OHOS { +namespace Global { +namespace Resource { + +constexpr int SCREEN_DENSITY_SDPI_ORDER = 0; +constexpr int SCREEN_DENSITY_MDPI_ORDER = 1; +constexpr int SCREEN_DENSITY_LDPI_ORDER = 2; +constexpr int SCREEN_DENSITY_XLDPI_ORDER = 3; +constexpr int SCREEN_DENSITY_XXLDPI_ORDER = 4; +constexpr int SCREEN_DENSITY_XXXLDPI_ORDER = 5; + +const std::unordered_map errorMsg { + {ERROR_CODE_INVALID_INPUT_PARAMETER, "Invalid input parameter"}, + {ERROR_CODE_RES_ID_NOT_FOUND, "Invalid resource ID"}, + {ERROR_CODE_RES_NAME_NOT_FOUND, "Invalid resource name"}, + {ERROR_CODE_RES_NOT_FOUND_BY_ID, "No matching resource is found based on the resource ID"}, + {ERROR_CODE_RES_NOT_FOUND_BY_NAME, "No matching resource is found based on the resource name"}, + {ERROR_CODE_RES_PATH_INVALID, "Invalid relative path"}, + {ERROR_CODE_RES_REF_TOO_MUCH, "The resource is referenced cyclically"}, + {ERROR_CODE_RES_ID_FORMAT_ERROR, "Failed to format the resource obtained based on the resource ID"}, + {ERROR_CODE_RES_NAME_FORMAT_ERROR, "Failed to format the resource obtained based on the resource Name"}, + {ERROR_CODE_SYSTEM_RES_MANAGER_GET_FAILED, "Failed to access the system resource"}, + {ERROR_CODE_OVERLAY_RES_PATH_INVALID, "Invalid overlay path"}, + {ERROR, "Unknow error"} +}; + +std::string AniUtils::FindErrMsg(int32_t errCode) +{ + auto iter = errorMsg.find(errCode); + if (iter == errorMsg.end()) { + return ""; + } + return iter->second; +} + +void AniUtils::ThrowAniError(ani_env *env, ani_int code, const std::string &message) +{ + ani_class cls; + ani_status status = env->FindClass(AniSignature::BUSINESSERROR, &cls); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class %{public}s failed, status %{public}d", + AniSignature::BUSINESSERROR, status); + return; + } + ani_method ctor; + arkts::ani_signature::SignatureBuilder sb; + status = env->Class_FindMethod(cls, "", sb.BuildSignatureDescriptor().c_str(), &ctor); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method BusinessError constructor failed, status: %{public}d.", status); + return; + } + ani_object error; + status = env->Object_New(cls, ctor, &error); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Create BusinessError failed, status: %{public}d.", status); + return; + } + status = env->Object_SetPropertyByName_Int(error, "code", code); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set BusinessError.code = %{public}d failed, status: %{public}d.", code, status); + return; + } + ani_string messageRef; + status = env->String_NewUTF8(message.c_str(), message.size(), &messageRef); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Create message string failed, status: %{public}d.", status); + return; + } + status = env->Object_SetPropertyByName_Ref(error, "message", static_cast(messageRef)); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set BusinessError message failed, status:%{public}d.", status); + return; + } + status = env->ThrowError(static_cast(error)); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "ThrowError BusinessError failed, status:%{public}d.", status); + } +} + +void AniUtils::AniThrow(ani_env *env, int32_t errCode) +{ + std::string errMsg = FindErrMsg(errCode); + if (errMsg != "") { + ThrowAniError(env, errCode, errMsg); + } +} + +std::shared_ptr AniUtils::GetResourceManager(ani_env* env, ani_object jsResMgr) +{ + ani_long nativePtr; + ani_status status = env->Object_GetFieldByName_Long(jsResMgr, "nativeResMgr", &nativePtr); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Get nativeResMgr failed from etsResMgr, status: %{public}d.", status); + return nullptr; + } + std::shared_ptr* resMgr = reinterpret_cast*>(nativePtr); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "NativePtr is nullptr, unknown error."); + return nullptr; + } + return *reinterpret_cast*>(nativePtr); +} + +ani_string AniUtils::CreateAniString(ani_env *env, const std::string &str) +{ + ani_string result; + ani_status status = env->String_NewUTF8(str.c_str(), str.size(), &result); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to create ani_string, status: %{public}d", status); + return nullptr; + } + return result; +} + +std::string AniUtils::AniStrToString(ani_env *env, ani_string aniStr) +{ + ani_size size = 0; + ani_status status = env->String_GetUTF8Size(aniStr, &size); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Get string size failed, status: %{public}d.", status); + return ""; + } + std::string result; + result.resize(size, 0); + ani_size written; + status = env->String_GetUTF8(aniStr, result.data(), size + 1, &written); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Get string data failed, status: %{public}d.", status); + return ""; + } + return result; +} + +ani_object AniUtils::CreateAniRawFileDescriptor(ani_env *env, const ResourceManager::RawFileDescriptor& descriptor) +{ + ani_class cls; + ani_status status = env->FindClass(AniSignature::RAWFILE_DESCRIPTOR_INNER, &cls); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class RawFileDescriptor failed, status: %{public}d.", status); + return nullptr; + } + + ani_method ctor; + status = env->Class_FindMethod(cls, "", nullptr, &ctor); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method RawFileDescriptor.constructor failed, status: %{public}d.", status); + return nullptr; + } + + ani_object obj; + status = env->Object_New(cls, ctor, &obj); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Create RawFileDescriptor failed, status: %{public}d.", status); + return nullptr; + } + status = env->Object_SetPropertyByName_Int(obj, "fd", descriptor.fd); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set RawFileDescriptor property 'fd' failed, status: %{public}d.", status); + return nullptr; + } + status = env->Object_SetPropertyByName_Long(obj, "offset", descriptor.offset); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set RawFileDescriptor property 'offset' failed, status: %{public}d.", status); + return nullptr; + } + status = env->Object_SetPropertyByName_Long(obj, "length", descriptor.length); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set RawFileDescriptor property 'length' failed, status: %{public}d.", status); + return nullptr; + } + return obj; +} + +RState AniUtils::ConfigurationToResConfig(ani_env *env, ani_object configuration, + std::shared_ptr &resConfig) +{ + ani_boolean isUndefined; + ani_status status = env->Reference_IsUndefined(configuration, &isUndefined); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Get configuration is undefined failed , status: %{public}d.", status); + return ERROR; + } + + if (isUndefined) { + return SUCCESS; + } + + ResConfig *config = CreateDefaultResConfig(); + if (config == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Create resConfig failed."); + return ERROR_CODE_INVALID_INPUT_PARAMETER; + } + resConfig.reset(config); + + if (!GetEnumParamOfConfig(env, resConfig, configuration)) { + return ERROR_CODE_INVALID_INPUT_PARAMETER; + } + if (!GetLocaleOfConfig(env, resConfig, configuration)) { + return ERROR_CODE_INVALID_INPUT_PARAMETER; + } + return SUCCESS; +} + +ani_object AniUtils::CreateConfig(ani_env* env, std::unique_ptr &cfg) +{ + ani_class cls; + ani_status status = env->FindClass(AniSignature::CONFIGURATION, &cls); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class Configuration failed, status: %{public}d.", status); + return nullptr; + } + + ani_method ctor; + status = env->Class_FindMethod(cls, "", nullptr, &ctor); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method in Configuration failed, status: %{public}d.", status); + return nullptr; + } + + ani_object obj; + status = env->Object_New(cls, ctor, &obj); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Create Configuration failed, status: %{public}d.", status); + return nullptr; + } + + if (!SetEnumMember(env, obj, "direction", AniSignature::DIRECTION, static_cast(cfg->GetDirection()))) { + return nullptr; + } + if (!SetEnumMember(env, obj, "deviceType", AniSignature::DEVICE_TYPE, static_cast(cfg->GetDeviceType()))) { + return nullptr; + } + if (!SetEnumMember(env, obj, "colorMode", AniSignature::COLOR_MODE, static_cast(cfg->GetColorMode()))) { + return nullptr; + } + if (!SetEnumMember(env, obj, "screenDensity", AniSignature::SCREEN_DENSITY, + GetScreenDensityIndex(cfg->GetScreenDensityDpi()))) { + return nullptr; + } + + status = env->Object_SetPropertyByName_Int(obj, "mcc", static_cast(cfg->GetMcc())); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set Configuration property 'mcc' failed, status: %{public}d.", status); + return nullptr; + } + status = env->Object_SetPropertyByName_Int(obj, "mnc", static_cast(cfg->GetMnc())); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set Configuration property 'mnc' failed, status: %{public}d.", status); + return nullptr; + } + + std::string value = GetLocale(cfg); + status = env->Object_SetPropertyByName_Ref(obj, "locale", CreateAniString(env, value)); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set Configuration property 'locale' failed, status: %{public}d.", status); + return nullptr; + } + return obj; +} + +bool AniUtils::GetEnumParamOfConfig(ani_env* env, std::shared_ptr configPtr, ani_object configuration) +{ + int intEnum; + if (!GetEnumMember(env, configuration, "direction", intEnum)) { + return false; + } + configPtr->SetDirection(static_cast(intEnum)); + + if (!GetEnumMember(env, configuration, "deviceType", intEnum)) { + return false; + } + configPtr->SetDeviceType(static_cast(intEnum)); + + if (!GetEnumMember(env, configuration, "screenDensity", intEnum)) { + return false; + } + configPtr->SetScreenDensityDpi(static_cast(intEnum)); + + if (!GetEnumMember(env, configuration, "colorMode", intEnum)) { + return false; + } + configPtr->SetColorMode(static_cast(intEnum)); + + int value; + if (!GetNumberMember(env, configuration, "mcc", value)) { + return false; + } + configPtr->SetMcc(value); + if (!GetNumberMember(env, configuration, "mnc", value)) { + return false; + } + configPtr->SetMnc(value); + return true; +} + +bool AniUtils::GetEnumMember(ani_env *env, ani_object options, const std::string name, int& member) +{ + ani_ref ref; + ani_status status = env->Object_GetPropertyByName_Ref(options, name.c_str(), &ref); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Get Configuration property '%{public}s' failed, status: %{public}d.", + name.c_str(), status); + return false; + } + status = env->EnumItem_GetValue_Int(static_cast(ref), &member); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Get Configuration property '%{public}s' value failed, status: %{public}d.", + name.c_str(), status); + return false; + } + return true; +} + +bool AniUtils::GetLocaleOfConfig(ani_env* env, std::shared_ptr configPtr, ani_object configuration) +{ +#ifdef SUPPORT_GRAPHICS + ani_ref ret; + ani_status status = env->Object_GetPropertyByName_Ref(configuration, "locale", &ret); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Get Configuration property 'locale' failed, status: %{public}d.", status); + return false; + } + if (configPtr->SetLocaleInfo(AniStrToString(env, static_cast(ret)).c_str()) != SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetLocaleOfConfig failed to SetLocaleInfo."); + return false; + } +#endif + return true; +} + +bool AniUtils::SetEnumMember(ani_env *env, ani_object obj, const char* memberName, const char* enumName, + const int index) +{ + int realIndex = index; + if (index < 0) { + RESMGR_HILOGW(RESMGR_TAG, "Set Enum %{public}s invalid index %{public}d, reset index to zero.", + enumName, index); + realIndex = 0; + } + + ani_enum aniEnum; + ani_status status = env->FindEnum(enumName, &aniEnum); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find enum '%{public}s' failed, status: %{public}d.", enumName, status); + return false; + } + + ani_enum_item enumItem; + status = env->Enum_GetEnumItemByIndex(aniEnum, realIndex, &enumItem); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Get enumItem '%{public}s' failed, status: %{public}d.", enumName, status); + return false; + } + status = env->Object_SetPropertyByName_Ref(obj, memberName, enumItem); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set Configuration property '%{public}s' failed, status: %{public}d.", + memberName, status); + return false; + } + return true; +} + +std::string AniUtils::GetLocale(std::unique_ptr &cfg) +{ + std::string result; +#ifdef SUPPORT_GRAPHICS + const icu::Locale *localeInfo = cfg->GetLocaleInfo(); + if (localeInfo == nullptr) { + return result; + } + + const char *lang = localeInfo->getLanguage(); + if (lang == nullptr) { + return result; + } + result = lang; + + const char *script = localeInfo->getScript(); + if (script != nullptr) { + result += std::string("_") + script; + } + + const char *region = localeInfo->getCountry(); + if (region != nullptr) { + result += std::string("_") + region; + } +#endif + return result; +} + +ani_object AniUtils::CreateAniArray(ani_env *env, const std::vector &strs) +{ + ani_class cls; + ani_status status = env->FindClass(AniSignature::ANI_ARRAY, &cls); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class %{public}s failed, status: %{public}d.", + AniSignature::ANI_ARRAY, status); + return nullptr; + } + + ani_method ctor; + status = env->Class_FindMethod(cls, "", "i:", &ctor); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method in %{public}s failed, status: %{public}d", + AniSignature::ANI_ARRAY, status); + return nullptr; + } + + ani_object ret; + status = env->Object_New(cls, ctor, &ret, strs.size()); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "New object %{public}s failed, status: %{public}d", + AniSignature::ANI_ARRAY, status); + return nullptr; + } + + ani_method set; + status = env->Class_FindMethod(cls, "$_set", "iC{std.core.Object}:", &set); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method set in array failed, status %{public}d.", status); + return nullptr; + } + + for (size_t i = 0; i < strs.size(); i++) { + status = env->Object_CallMethod_Void(ret, set, i, CreateAniString(env, strs[i])); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Call method '$_set' failed, status :%{}d, currentIndex: %{}d.", status, i); + return nullptr; + } + } + return ret; +} + +ani_object AniUtils::CreateAniUint8Array(ani_env* env, std::unique_ptr &mediaData, size_t len) +{ + ani_class cls; + ani_status status = env->FindClass(AniSignature::ANI_UINT8ARRAY, &cls); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class %{public}s failed, status: %{public}d", + AniSignature::ANI_UINT8ARRAY, status); + return nullptr; + } + + ani_method ctor; + status = env->Class_FindMethod(cls, "", "i:", &ctor); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method in %{public}s failed, status: %{public}d.", + AniSignature::ANI_UINT8ARRAY, status); + return nullptr; + } + + ani_object ret; + status = env->Object_New(cls, ctor, &ret, len); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "New object %{public}s failed, status: %{public}d", + AniSignature::ANI_UINT8ARRAY, status); + return nullptr; + } + + ani_method set; + status = env->Class_FindMethod(cls, "$_set", "ii:", &set); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method 'set' in %{public}s failed, status :%{public}d.", + AniSignature::ANI_UINT8ARRAY, status); + return nullptr; + } + + for (size_t i = 0; i < len; i++) { + if (ANI_OK != env->Object_CallMethod_Void(ret, set, i, mediaData[i])) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Call method 'set' in %{public}s failed, status :%{public}d.", + AniSignature::ANI_UINT8ARRAY, status); + return nullptr; + } + } + return ret; +} + +int AniUtils::GetScreenDensityIndex(ScreenDensity value) +{ + switch (value) { + case ScreenDensity::SCREEN_DENSITY_SDPI: return SCREEN_DENSITY_SDPI_ORDER; + case ScreenDensity::SCREEN_DENSITY_MDPI: return SCREEN_DENSITY_MDPI_ORDER; + case ScreenDensity::SCREEN_DENSITY_LDPI: return SCREEN_DENSITY_LDPI_ORDER; + case ScreenDensity::SCREEN_DENSITY_XLDPI: return SCREEN_DENSITY_XLDPI_ORDER; + case ScreenDensity::SCREEN_DENSITY_XXLDPI: return SCREEN_DENSITY_XXLDPI_ORDER; + case ScreenDensity::SCREEN_DENSITY_XXXLDPI: return SCREEN_DENSITY_XXXLDPI_ORDER; + default: return -1; + } +} + +bool AniUtils::GetNumberMember(ani_env *env, ani_object options, const std::string name, int& value) +{ + ani_status status = env->Object_GetPropertyByName_Int(options, name.c_str(), &value); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Get property '%{public}s' failed, status: %{public}d.", name.c_str(), status); + return false; + } + return true; +} + +bool AniUtils::InitAniParameters(ani_env *env, ani_object args, + std::vector> ¶ms) +{ + ani_size len; + ani_status status = env->Array_GetLength(static_cast(args), &len); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Get args Array length failed, status: %{public}d.", status); + return false; + } + + if (len == 0) { + return true; + } + ani_class stringClass; + status = env->FindClass(AniSignature::ANI_STRING, &stringClass); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class %{public}s failed, status: %{public}d.", + AniSignature::ANI_STRING, status); + return false; + } + + for (size_t i = 0; i < len; ++i) { + ani_ref value; + status = env->Array_Get(static_cast(args), i, &value); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Call get args array value failed, index: %{public}d, status: %{public}d", + i, status); + return false; + } + + ani_boolean isString; + status = env->Object_InstanceOf(static_cast(value), stringClass, &isString); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Check args value isString failed, index: %{public}d, status: %{public}d", + i, status); + return false; + } + + if (isString) { + params.emplace_back(ResourceManager::NapiValueType::NAPI_STRING, + AniStrToString(env, static_cast(value))); + } else { + ani_double param; + ani_status status = + env->Object_CallMethodByName_Double(static_cast(value), "unboxed", ":d", ¶m); + if (ANI_OK != status) { + return false; + } + params.emplace_back(ResourceManager::NapiValueType::NAPI_NUMBER, std::to_string(param)); + } + } + return true; +} + +ani_object AniUtils::CreateDeviceCapability(ani_env *env, std::unique_ptr &cfg) +{ + ani_class cls; + ani_status status = env->FindClass(AniSignature::DEVICE_CAPABILITY, &cls); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class %{public}s failed, status: %{public}d.", + AniSignature::DEVICE_CAPABILITY, status); + return nullptr; + } + + ani_method ctor; + status = env->Class_FindMethod(cls, "", nullptr, &ctor); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method in %{public}s failed, status: %{public}d.", + AniSignature::DEVICE_CAPABILITY, status); + return nullptr; + } + + ani_object obj; + status = env->Object_New(cls, ctor, &obj); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "New object %{public}s failed, status: %{public}d.", + AniSignature::DEVICE_CAPABILITY, status); + return nullptr; + } + int index = GetScreenDensityIndex(cfg->GetScreenDensityDpi()); + if (!SetEnumMember(env, obj, "screenDensity", AniSignature::SCREEN_DENSITY, index)) { + return nullptr; + }; + index = static_cast(cfg->GetDeviceType()); + if (!SetEnumMember(env, obj, "deviceType", AniSignature::DEVICE_TYPE, index)) { + return nullptr; + }; + return obj; +} + +bool AniUtils::GetOptionalInt(ani_env *env, ani_object optionalInt, int& result) +{ + ani_boolean isUndefined; + ani_status status = env->Reference_IsUndefined(optionalInt, &isUndefined); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to judge int is undefined, status: %{public}d.", status); + return false; + } + ani_int value = 0; + if (!isUndefined) { + status = env->Object_CallMethodByName_Int(optionalInt, "unboxed", ":i", &value); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get int, status: %{public}d.", status); + return false; + } + } + result = value; + return true; +} +} // namespace Resource +} // namespace Global +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/ets/ani/resourceManager/src/resmgr_ani.cpp b/interfaces/ets/ani/resourceManager/src/resmgr_ani.cpp index 89d08a8..545db11 100644 --- a/interfaces/ets/ani/resourceManager/src/resmgr_ani.cpp +++ b/interfaces/ets/ani/resourceManager/src/resmgr_ani.cpp @@ -13,8 +13,1211 @@ * limitations under the License. */ +#include "resmgr_ani.h" + +#include +#include +#include +#include +#include +#include + +#include "application_context.h" +#include "application_context.h" +#include "drawable_descriptor_ani.h" +#include "interop_js/arkts_esvalue.h" +#include "interop_js/arkts_interop_js_api.h" +#include "ani_signature_builder.h" + +#include "ani_utils.h" +#include "ani_signature.h" #include "hilog_wrapper.h" #include "resourceManager.h" +#include "utils/utils.h" +#include "resource_manager_impl.h" +#include "resource_manager_addon.h" +#include "system_resource_manager.h" + +namespace OHOS { +namespace Global { +namespace Resource { + +constexpr ani_int ABNORMAL_NUMBER_RETURN_VALUE = -1; + +constexpr int NUM_NAPI_VALUES_TO_WRAP = 1; + +constexpr int LAYER_ICON = 1; +constexpr int DYNAMIC_ICON = 2; + +static std::array methods = { + ani_native_function { "getStringSync", "l:C{std.core.String}", + reinterpret_cast(ResMgrAni::GetStringSyncById) }, + ani_native_function { "getStringSync", "lC{escompat.Array}:C{std.core.String}", + reinterpret_cast(ResMgrAni::GetFormatStringSyncById) }, + ani_native_function { "getStringByNameSync", "C{std.core.String}:C{std.core.String}", + reinterpret_cast(ResMgrAni::GetStringByNameSync) }, + ani_native_function { "getStringByNameSync", "C{std.core.String}C{escompat.Array}:C{std.core.String}", + reinterpret_cast(ResMgrAni::GetFormatStringByNameSync) }, + + ani_native_function { "getBoolean", nullptr, reinterpret_cast(ResMgrAni::GetBooleanById) }, + ani_native_function { "getBooleanByName", nullptr, reinterpret_cast(ResMgrAni::GetBooleanByName) }, + + ani_native_function { "getInt", nullptr, reinterpret_cast(ResMgrAni::GetIntById) }, + ani_native_function { "getIntByName", nullptr, reinterpret_cast(ResMgrAni::GetIntByName) }, + ani_native_function { "getDouble", nullptr, reinterpret_cast(ResMgrAni::GetDoubleById) }, + ani_native_function { "getDoubleByName", nullptr, reinterpret_cast(ResMgrAni::GetDoubleByName) }, + + ani_native_function { "getIntPluralStringValueSync", nullptr, + reinterpret_cast(ResMgrAni::GetIntPluralStringValueSyncById) }, + ani_native_function { "getIntPluralStringByNameSync", nullptr, + reinterpret_cast(ResMgrAni::GetIntPluralStringByNameSync) }, + + ani_native_function { "getDoublePluralStringValueSync", nullptr, + reinterpret_cast(ResMgrAni::GetDoublePluralStringValueSyncById) }, + ani_native_function { "getDoublePluralStringByNameSync", nullptr, + reinterpret_cast(ResMgrAni::GetDoublePluralStringByNameSync) }, + + ani_native_function { "getColorSync", nullptr, reinterpret_cast(ResMgrAni::GetColorSyncById) }, + ani_native_function { "getColorByNameSync", nullptr, reinterpret_cast(ResMgrAni::GetColorByNameSync) }, + + ani_native_function { "addResource", nullptr, reinterpret_cast(ResMgrAni::AddResource) }, + ani_native_function { "removeResource", nullptr, reinterpret_cast(ResMgrAni::RemoveResource) }, + + ani_native_function { "getRawFdSync", nullptr, reinterpret_cast(ResMgrAni::GetRawFdSync) }, + ani_native_function { "closeRawFdSync", nullptr, reinterpret_cast(ResMgrAni::CloseRawFdSync) }, + ani_native_function { "isRawDir", nullptr, reinterpret_cast(ResMgrAni::IsRawDir) }, + + ani_native_function { "getRawFileListSync", nullptr, reinterpret_cast(ResMgrAni::GetRawFileListSync) }, + ani_native_function { "getRawFileContentSync", nullptr, + reinterpret_cast(ResMgrAni::GetRawFileContentSync) }, + + ani_native_function { "getMediaContentSync", nullptr, + reinterpret_cast(ResMgrAni::GetMediaContentSyncById) }, + + ani_native_function { "getMediaContentBase64Sync", nullptr, + reinterpret_cast(ResMgrAni::GetMediaContentBase64SyncById) }, + + ani_native_function { "getStringArrayValueSync", nullptr, + reinterpret_cast(ResMgrAni::GetStringArrayValueSyncById) }, + + ani_native_function { "getStringArrayByNameSync", nullptr, + reinterpret_cast(ResMgrAni::GetStringArrayByNameSync) }, + + ani_native_function { "getMediaByNameSync", nullptr, reinterpret_cast(ResMgrAni::GetMediaByNameSync) }, + ani_native_function { "getMediaBase64ByNameSync", nullptr, + reinterpret_cast(ResMgrAni::GetMediaBase64ByNameSync) }, + + ani_native_function { "getDrawableDescriptor", nullptr, + reinterpret_cast(ResMgrAni::GetDrawableDescriptorById) }, + ani_native_function { "getDrawableDescriptorByName", nullptr, + reinterpret_cast(ResMgrAni::GetDrawableDescriptorByName) }, + + ani_native_function { "getConfigurationSync", nullptr, reinterpret_cast(ResMgrAni::GetConfigurationSync) }, + ani_native_function { "getDeviceCapabilitySync", nullptr, + reinterpret_cast(ResMgrAni::GetDeviceCapabilitySync) }, + ani_native_function { "getLocales", nullptr, reinterpret_cast(ResMgrAni::GetLocales) }, + + ani_native_function { "getSymbol", nullptr, reinterpret_cast(ResMgrAni::GetSymbolById) }, + ani_native_function { "getSymbolByName", nullptr, reinterpret_cast(ResMgrAni::GetSymbolByName) }, + + ani_native_function { "getOverrideResourceManager", nullptr, + reinterpret_cast(ResMgrAni::GetOverrideResourceManager) }, + ani_native_function { "getOverrideConfiguration", nullptr, + reinterpret_cast(ResMgrAni::GetOverrideConfiguration) }, + ani_native_function { "updateOverrideConfiguration", nullptr, + reinterpret_cast(ResMgrAni::UpdateOverrideConfiguration) }, +}; + +ani_string ResMgrAni::GetStringSyncById(ani_env* env, ani_object object, ani_long resId) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetStringById."); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + std::string result; + RState state = resMgr->GetStringById(resId, result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetStringById failed, state: %{public}d, id: %{public}lld", state, resId); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniString(env, result); +} + +ani_string ResMgrAni::GetFormatStringSyncById(ani_env *env, ani_object object, ani_long resId, ani_object args) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetFormatStringSyncById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + + std::vector> params; + if (!AniUtils::InitAniParameters(env, args, params)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetFormatStringSyncById get params failed"); + AniUtils::AniThrow(env, ERROR_CODE_RES_ID_FORMAT_ERROR); + return nullptr; + } + std::string result; + RState state = resMgr->GetStringFormatById(resId, result, params); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetFormatStringSyncById failed, state: %{public}d, id: %{public}lld", + state, resId); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniString(env, result); +} + +ani_string ResMgrAni::GetStringByNameSync(ani_env* env, ani_object object, ani_string aniName) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getStringByNameSync"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return nullptr; + } + std::string name = AniUtils::AniStrToString(env, aniName); + std::string result; + RState state = resMgr->GetStringByName(name.c_str(), result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetStringByNameSync failed, state: %{public}d, name: %{public}s", + state, name.c_str()); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniString(env, result); +} + +ani_string ResMgrAni::GetFormatStringByNameSync(ani_env *env, ani_object object, ani_string aniName, ani_object args) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getStringByNameSync"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return nullptr; + } + std::vector> params; + if (!AniUtils::InitAniParameters(env, args, params)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "getFormatStringByNameSync get params failed"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NAME_FORMAT_ERROR); + return nullptr; + } + std::string name = AniUtils::AniStrToString(env, aniName); + std::string result; + RState state = resMgr->GetStringFormatByName(name.c_str(), result, params); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetStringFormatByName failed, state: %{public}d, name: %{public}s", + state, name.c_str()); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniString(env, result); +} + +ani_boolean ResMgrAni::GetBooleanById(ani_env* env, ani_object object, ani_long resId) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getBooleanById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return false; + } + bool result; + RState state = resMgr->GetBooleanById(resId, result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetBooleanById failed, state: %{public}d, id: %{public}lld", + state, resId); + AniUtils::AniThrow(env, state); + return false; + } + return result; +} + +ani_boolean ResMgrAni::GetBooleanByName(ani_env* env, ani_object object, ani_string aniName) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getBooleanByName"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return false; + } + std::string name = AniUtils::AniStrToString(env, aniName); + bool result; + RState state = resMgr->GetBooleanByName(name.c_str(), result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetBooleanByName failed, state: %{public}d, name: %{public}s", + state, name.c_str()); + AniUtils::AniThrow(env, state); + return false; + } + return result; +} + +ani_int ResMgrAni::GetIntById(ani_env* env, ani_object object, ani_long resId) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetIntById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + int result; + RState state = resMgr->GetIntegerById(resId, result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetIntById failed, state: %{public}d, id: %{public}lld", + state, resId); + AniUtils::AniThrow(env, state); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + return result; +} + +ani_int ResMgrAni::GetIntByName(ani_env* env, ani_object object, ani_string aniName) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetIntByName"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + std::string name = AniUtils::AniStrToString(env, aniName); + int result; + RState state = resMgr->GetIntegerByName(name.c_str(), result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetIntByName failed, state: %{public}d, name: %{public}s", + state, name.c_str()); + AniUtils::AniThrow(env, state); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + return result; +} + +ani_double ResMgrAni::GetDoubleById(ani_env* env, ani_object object, ani_long resId) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetDoubleById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + float result; + RState state = resMgr->GetFloatById(resId, result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetDoubleById failed, state: %{public}d, id: %{public}lld", + state, resId); + AniUtils::AniThrow(env, state); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + return result; +} + +ani_double ResMgrAni::GetDoubleByName(ani_env* env, ani_object object, ani_string aniName) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetDoubleByName"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + + std::string name = AniUtils::AniStrToString(env, aniName); + float result; + RState state = resMgr->GetFloatByName(name.c_str(), result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetDoubleByName failed, state: %{public}d, name: %{public}s", + state, name.c_str()); + AniUtils::AniThrow(env, state); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + return result; +} + +ani_string ResMgrAni::GetIntPluralStringValueSyncById(ani_env* env, ani_object object, + ani_long resId, ani_int num, ani_object args) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getIntPluralStringValueSyncById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + std::vector> params; + if (!AniUtils::InitAniParameters(env, args, params)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "InitOptionalParameters formatting error"); + AniUtils::AniThrow(env, ERROR_CODE_RES_ID_FORMAT_ERROR); + return nullptr; + } + std::string result; + RState state = resMgr->GetFormatPluralStringById(result, resId, { true, num, 0.0 }, params); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetFormatPluralStringById failed, state: %{public}d, id: %{public}lld", + state, resId); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniString(env, result); +} + +ani_string ResMgrAni::GetIntPluralStringByNameSync(ani_env* env, ani_object object, + ani_string aniName, ani_int num, ani_object args) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in getIntPluralStringByNameSync"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return nullptr; + } + + std::vector> params; + if (!AniUtils::InitAniParameters(env, args, params)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "InitOptionalParameters formatting error"); + AniUtils::AniThrow(env, ERROR_CODE_RES_ID_FORMAT_ERROR); + return nullptr; + } + + std::string name = AniUtils::AniStrToString(env, aniName); + std::string result; + RState state = resMgr->GetFormatPluralStringByName(result, name.c_str(), { true, num, 0.0 }, params); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetFormatPluralStringByName failed, state: %{public}d, name: %{public}s", + state, name.c_str()); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniString(env, result); +} + +ani_string ResMgrAni::GetDoublePluralStringValueSyncById(ani_env* env, ani_object object, + ani_long resId, ani_double num, ani_object args) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getIntPluralStringValueSyncById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + + std::vector> params; + if (!AniUtils::InitAniParameters(env, args, params)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "InitOptionalParameters formatting error"); + AniUtils::AniThrow(env, ERROR_CODE_RES_ID_FORMAT_ERROR); + return nullptr; + } + std::string result; + RState state = resMgr->GetFormatPluralStringById(result, resId, { false, 0, num }, params); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetFormatPluralStringById failed, state: %{public}d, id: %{public}lld", + state, resId); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniString(env, result); +} + +ani_string ResMgrAni::GetDoublePluralStringByNameSync(ani_env* env, ani_object object, + ani_string aniName, ani_double num, ani_object args) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in getDoublePluralStringByNameSync"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return nullptr; + } + + std::vector> params; + if (!AniUtils::InitAniParameters(env, args, params)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "InitOptionalParameters formatting error"); + AniUtils::AniThrow(env, ERROR_CODE_RES_ID_FORMAT_ERROR); + return nullptr; + } + + std::string resName = AniUtils::AniStrToString(env, aniName); + std::string result; + RState state = resMgr->GetFormatPluralStringByName(result, resName.c_str(), { false, 0, num }, params); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetStringByNameSync failed, state: %{public}d, name: %{public}s", + state, resName.c_str()); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniString(env, result); +} + +ani_long ResMgrAni::GetColorSyncById(ani_env* env, ani_object object, ani_long resId) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getColorSyncById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + uint32_t result; + RState state = resMgr->GetColorById(resId, result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetColorSyncById failed, state: %{public}d, id: %{public}lld", + state, resId); + AniUtils::AniThrow(env, state); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + return result; +} + +ani_long ResMgrAni::GetColorByNameSync(ani_env* env, ani_object object, ani_string aniName) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getColorByNameSync"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + std::string name = AniUtils::AniStrToString(env, aniName); + uint32_t result; + RState state = resMgr->GetColorByName(name.c_str(), result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "getColorByNameSync failed, state: %{public}d, name: %{public}s", + state, name.c_str()); + AniUtils::AniThrow(env, state); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + return result; +} + +void ResMgrAni::AddResource(ani_env* env, ani_object object, ani_string aniPath) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get resMgr in AddResource."); + return; + } + + std::string path = AniUtils::AniStrToString(env, aniPath); + if (!resMgr->AddAppOverlay(path)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to add overlay path."); + AniUtils::AniThrow(env, ERROR_CODE_OVERLAY_RES_PATH_INVALID); + return; + } +} + +void ResMgrAni::RemoveResource(ani_env* env, ani_object object, ani_string aniPath) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get resMgr in RemoveResource."); + return; + } + std::string path = AniUtils::AniStrToString(env, aniPath); + if (!resMgr->RemoveAppOverlay(path)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to remove overlay path."); + AniUtils::AniThrow(env, ERROR_CODE_OVERLAY_RES_PATH_INVALID); + return; + } +} + +ani_object ResMgrAni::GetRawFdSync(ani_env* env, ani_object object, ani_string aniPath) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getRawFdSync"); + AniUtils::AniThrow(env, NOT_FOUND); + return nullptr; + } + std::string path = AniUtils::AniStrToString(env, aniPath); + ResourceManager::RawFileDescriptor descriptor; + RState state = resMgr->GetRawFileDescriptorFromHap(path, descriptor); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to GetRawFileDescriptorFromHap."); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniRawFileDescriptor(env, descriptor); +} + +void ResMgrAni::CloseRawFdSync(ani_env* env, ani_object object, ani_string aniPath) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in closeRawFdSync"); + AniUtils::AniThrow(env, NOT_FOUND); + return; + } + + std::string path = AniUtils::AniStrToString(env, aniPath); + RState state = resMgr->CloseRawFileDescriptor(path); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to close rawfd."); + AniUtils::AniThrow(env, state); + return; + } +} + +ani_object ResMgrAni::GetRawFileListSync(ani_env* env, ani_object object, ani_string aniPath) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in getRawFileListSync"); + AniUtils::AniThrow(env, NOT_FOUND); + return nullptr; + } + std::string path = AniUtils::AniStrToString(env, aniPath); + std::vector result; + RState state = resMgr->GetRawFileList(path.c_str(), result); + if (state != RState::SUCCESS || result.empty()) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get rawfile list."); + AniUtils::AniThrow(env, ERROR_CODE_RES_PATH_INVALID); + return nullptr; + } + + return AniUtils::CreateAniArray(env, result); +} + +ani_object ResMgrAni::GetRawFileContentSync(ani_env* env, ani_object object, ani_string aniPath) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getRawFileContentSync"); + AniUtils::AniThrow(env, NOT_FOUND); + return nullptr; + } + std::string path = AniUtils::AniStrToString(env, aniPath); + size_t len = 0; + std::unique_ptr mediaData; + RState state = resMgr->GetRawFileFromHap(path, len, mediaData); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get rawfile."); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniUint8Array(env, mediaData, len); +} + +ani_object ResMgrAni::GetMediaContentSyncById(ani_env* env, ani_object object, + ani_long resId, ani_object aniDensity) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getMediaContentSyncById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + int density = 0; + if (!AniUtils::GetOptionalInt(env, aniDensity, density)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get density in getMediaContentSyncById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + + size_t len = 0; + std::unique_ptr mediaData; + RState state = resMgr->GetMediaDataById(resId, len, mediaData, density); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetMediaContentSync failed, state: %{public}d, id: %{public}lld", + state, resId); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniUint8Array(env, mediaData, len); +} + +ani_string ResMgrAni::GetMediaContentBase64SyncById(ani_env* env, ani_object object, + ani_long resId, ani_object aniDensity) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getMediaContentBase64SyncById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + int density = 0; + if (!AniUtils::GetOptionalInt(env, aniDensity, density)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get density in GetMediaContentBase64Sync"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + + std::string result; + RState state = resMgr->GetMediaBase64DataById(resId, result, density); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetMediaContentBase64Sync failed, state: %{public}d, id: %{public}lld", + state, resId); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniString(env, result); +} + +ani_object ResMgrAni::GetStringArrayValueSyncById(ani_env* env, ani_object object, ani_long resId) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetStringArrayValueSyncById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + std::vector result; + RState state = resMgr->GetStringArrayById(resId, result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetStringArrayValueSync failed, state: %{public}d, id: %{public}lld", + state, resId); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniArray(env, result); +} + +ani_object ResMgrAni::GetMediaByNameSync(ani_env* env, ani_object object, ani_string aniName, ani_object aniDensity) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetMediaByNameSync"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return nullptr; + } + int density = 0; + if (!AniUtils::GetOptionalInt(env, aniDensity, density)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get density in GetMediaByNameSync"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return nullptr; + } + + std::string name = AniUtils::AniStrToString(env, aniName); + size_t len = 0; + std::unique_ptr mediaData; + RState state = resMgr->GetMediaDataByName(name.c_str(), len, mediaData, density); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetMediaByNameSync failed, state: %{public}d, name: %{public}s", + state, name.c_str()); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniUint8Array(env, mediaData, len); +} + +ani_string ResMgrAni::GetMediaBase64ByNameSync(ani_env* env, ani_object object, + ani_string aniName, ani_object aniDensity) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetMediaBase64ByNameSync"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return nullptr; + } + + int density = 0; + if (!AniUtils::GetOptionalInt(env, aniDensity, density)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get density in GetMediaBase64ByNameSync"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return nullptr; + } + + std::string name = AniUtils::AniStrToString(env, aniName); + std::string result; + RState state = resMgr->GetMediaBase64DataByName(name.c_str(), result, density); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetMediaBase64ByNameSync failed, state: %{public}d, name: %{public}s", + state, name.c_str()); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniString(env, result); +} + +RState CreateThemeIcon(ani_env *env, Ace::Ani::DrawableInfo &drawableInfo, ani_object *drawable) +{ + std::pair, size_t> foregroundInfo; + std::pair, size_t> backgroundInfo; + RState state = drawableInfo.manager->GetThemeIcons(0, foregroundInfo, backgroundInfo, drawableInfo.density); + if (state == SUCCESS) { + drawableInfo.firstBuffer.data = std::move(foregroundInfo.first); + drawableInfo.firstBuffer.len = foregroundInfo.second; + if (Utils::SupportSingleLayerThemeIcon() && backgroundInfo.first == nullptr) { + *drawable = Ace::Ani::DrawableDescriptorAni::CreateDrawableDescriptor(env, drawableInfo); + return SUCCESS; + } + drawableInfo.secondBuffer.data = std::move(backgroundInfo.first); + drawableInfo.secondBuffer.len = backgroundInfo.second; + drawableInfo.type = "layered"; + *drawable = Ace::Ani::DrawableDescriptorAni::CreateDrawableDescriptor(env, drawableInfo); + } + return state; +} + +ani_object CreateDrawableDescriptorbyId(ani_env* env, std::shared_ptr resMgr, + uint32_t resId, uint32_t density, uint32_t iconType) +{ + Ace::Ani::DrawableInfo drawableInfo; + drawableInfo.density = density; + drawableInfo.manager = resMgr; + RState state = SUCCESS; + if (iconType == LAYER_ICON) { + ani_object result; + if (SUCCESS == CreateThemeIcon(env, drawableInfo, &result)) { + return result; + } + } + state = resMgr->GetDrawableInfoById(resId, drawableInfo.type, + drawableInfo.firstBuffer.len, drawableInfo.firstBuffer.data, density); + if (SUCCESS != state) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "drawableDescriptor failed, state: %{public}d, id: %{public}u", state, resId); + AniUtils::AniThrow(env, state); + return nullptr; + }; + return Ace::Ani::DrawableDescriptorAni::CreateDrawableDescriptor(env, drawableInfo); +} + +ani_object ResMgrAni::GetDrawableDescriptorById(ani_env* env, ani_object object, + ani_long resId, ani_object aniDensity, ani_object aniType) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetDrawableDescriptorById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + int density = 0; + if (!AniUtils::GetOptionalInt(env, aniDensity, density)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get density in GetDrawableDescriptorById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + int type = 0; + if (!AniUtils::GetOptionalInt(env, aniType, type)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get type in GetDrawableDescriptorById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + return CreateDrawableDescriptorbyId(env, resMgr, resId, density, type); +} + +ani_object CreateDrawableDescriptorbyName(ani_env* env, std::shared_ptr resMgr, + const std::string& resName, uint32_t density, uint32_t iconType) +{ + Ace::Ani::DrawableInfo drawableInfo; + drawableInfo.density = density; + drawableInfo.manager = resMgr; + RState state = SUCCESS; + if (iconType == LAYER_ICON) { + ani_object result; + if (SUCCESS == CreateThemeIcon(env, drawableInfo, &result)) { + return result; + } + } + + if (iconType == DYNAMIC_ICON) { + std::pair, size_t> iconInfo; + if (resMgr->GetDynamicIcon(resName, iconInfo, density) == SUCCESS) { + drawableInfo.firstBuffer.data = std::move(iconInfo.first); + drawableInfo.firstBuffer.len = iconInfo.second; + return Ace::Ani::DrawableDescriptorAni::CreateDrawableDescriptor(env, drawableInfo); + } + } + + state = resMgr->GetDrawableInfoByName(resName.c_str(), drawableInfo.type, + drawableInfo.firstBuffer.len, drawableInfo.firstBuffer.data, density); + if (SUCCESS != state) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetDrawableInfoByName failed, state: %{public}d, name: %{public}s", + state, resName.c_str()); + AniUtils::AniThrow(env, state); + return nullptr; + }; + return Ace::Ani::DrawableDescriptorAni::CreateDrawableDescriptor(env, drawableInfo); +} + +ani_object ResMgrAni::GetDrawableDescriptorByName(ani_env* env, ani_object object, + ani_string aniName, ani_object aniDensity, ani_object aniType) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetDrawableDescriptorByName"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return nullptr; + } + int density = 0; + if (!AniUtils::GetOptionalInt(env, aniDensity, density)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get density in GetDrawableDescriptorByName"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return nullptr; + } + int type = 0; + if (!AniUtils::GetOptionalInt(env, aniType, type)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get type in GetDrawableDescriptorByName"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return nullptr; + } + + std::string resName = AniUtils::AniStrToString(env, aniName); + return CreateDrawableDescriptorbyName(env, resMgr, resName, density, type); +} + +ani_object ResMgrAni::GetStringArrayByNameSync(ani_env* env, ani_object object, ani_string aniName) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getStringArrayByNameSync"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return nullptr; + } + std::string resName = AniUtils::AniStrToString(env, aniName); + std::vector result; + RState state = resMgr->GetStringArrayByName(resName.c_str(), result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetStringArrayByName failed, state: %{public}d, name: %{public}s", + state, resName.c_str()); + AniUtils::AniThrow(env, state); + return nullptr; + } + return AniUtils::CreateAniArray(env, result); +} + + +ani_long ResMgrAni::GetSymbolById(ani_env* env, ani_object object, ani_long resId) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getSymbolById"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + uint32_t result; + RState state = resMgr->GetSymbolById(resId, result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetSymbolById failed, state: %{public}d, id: %{public}lld", state, resId); + AniUtils::AniThrow(env, state); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + return result; +} + +ani_long ResMgrAni::GetSymbolByName(ani_env* env, ani_object object, ani_string aniName) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getSymbolByName"); + AniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_NAME); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + std::string resName = AniUtils::AniStrToString(env, aniName); + uint32_t result; + RState state = resMgr->GetSymbolByName(resName.c_str(), result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetSymbolByName failed, state: %{public}d, name: %{public}s", + state, resName.c_str()); + AniUtils::AniThrow(env, state); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + return result; +} + +ani_object ResMgrAni::GetConfigurationSync(ani_env* env, ani_object object) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in GetConfigurationSync"); + return nullptr; + } + + std::unique_ptr cfg(CreateResConfig()); + if (cfg == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to create ResConfig object."); + return nullptr; + } + resMgr->GetResConfig(*cfg); + return AniUtils::CreateConfig(env, cfg); +} + +ani_object ResMgrAni::GetOverrideResourceManager(ani_env* env, ani_object object, ani_object configuration) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetOverrideResourceManager"); + AniUtils::AniThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER); + return nullptr; + } + std::shared_ptr overrideResConfig; + int32_t state = AniUtils::ConfigurationToResConfig(env, configuration, overrideResConfig); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resconfig in GetOverrideResourceManager"); + AniUtils::AniThrow(env, state); + return nullptr; + } + + std::shared_ptr overrideResMgr = resMgr->GetOverrideResourceManager(overrideResConfig); + if (overrideResMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get overrideResMgr in GetOverrideResourceManager"); + AniUtils::AniThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER); + return nullptr; + } + + return ResMgrAddon::WrapResourceManager(env, overrideResMgr); +} + + +ani_object ResMgrAni::GetOverrideConfiguration(ani_env* env, ani_object object) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetOverrideConfiguration"); + return nullptr; + } + + std::unique_ptr cfg(CreateResConfig()); + if (!cfg) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to create ResConfig object."); + return nullptr; + } + resMgr->GetOverrideResConfig(*cfg); + return AniUtils::CreateConfig(env, cfg); +} + +void ResMgrAni::UpdateOverrideConfiguration(ani_env* env, ani_object object, ani_object configuration) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in updateOverrideConfiguration"); + AniUtils::AniThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER); + return; + } + std::shared_ptr overrideResConfig; + RState state = AniUtils::ConfigurationToResConfig(env, configuration, overrideResConfig); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get config in GetOverrideResourceManager"); + AniUtils::AniThrow(env, state); + return; + } + + state = resMgr->UpdateOverrideResConfig(*overrideResConfig); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to update override configuration failed, status: %{public}d.", state); + AniUtils::AniThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER); + return; + } +} + +ani_object ResMgrAni::GetDeviceCapabilitySync(ani_env* env, ani_object object) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetConfigurationSync"); + return nullptr; + } + + std::unique_ptr cfg(CreateResConfig()); + if (!cfg) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to create ResConfig object."); + return nullptr; + } + resMgr->GetResConfig(*cfg); + return AniUtils::CreateDeviceCapability(env, cfg); +} + +ani_object ResMgrAni::GetLocales(ani_env* env, ani_object object, ani_object includeSystem) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetConfigurationSync"); + return nullptr; + } + + ani_boolean isUndefined; + ani_status status = env->Reference_IsUndefined(includeSystem, &isUndefined); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to judge includeSystem is undefined, status: %{public}d.", status); + return nullptr; + } + ani_boolean includeSys = false; + if (!isUndefined) { + status = env->Object_CallMethodByName_Boolean(includeSystem, "unboxed", ":z", &includeSys); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get includeSystem, status: %{public}d.", status); + return nullptr; + } + } + std::vector result; + resMgr->GetLocales(result, includeSys); + return AniUtils::CreateAniArray(env, result); +} + +ani_boolean ResMgrAni::IsRawDir(ani_env* env, ani_object object, ani_string aniPath) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in isRawDir"); + AniUtils::AniThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER); + return false; + } + std::string path = AniUtils::AniStrToString(env, aniPath); + bool result = false; + RState state = resMgr->IsRawDirFromHap(path, result); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to determine the raw file is directory."); + AniUtils::AniThrow(env, state); + return false; + } + return result; +} + +ani_object ResMgrAni::GetSysResourceManager(ani_env* env) +{ + std::shared_ptr sysResMgr(SystemResourceManager::CreateSysResourceManager()); + return ResMgrAddon::WrapResourceManager(env, sysResMgr); +} + +void ResMgrAni::DestoryResMgr(ani_env* env, ani_object jsResMgr) +{ + ani_long nativeResMgrPtr; + ani_status status = env->Object_GetFieldByName_Long(jsResMgr, "nativeResMgr", &nativeResMgrPtr); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get nativeResMgr in DestoryResMgr, status: %{public}d.", status); + return; + } + std::shared_ptr* resMgr = reinterpret_cast*>(nativeResMgrPtr); + if (resMgr != nullptr) { + delete resMgr; + status = env->Object_SetPropertyByName_Long(jsResMgr, "nativeResMgr", 0); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to reset nativeResMgr in DestoryResMgr, status: %{public}d.", status); + return; + } + } +} + +ani_ref ResMgrAni::TransferToDynamicResource(ani_env *env, ani_object etsResMgr) +{ + std::shared_ptr resMgr = AniUtils::GetResourceManager(env, etsResMgr); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in TransferToDynamicResource."); + return nullptr; + } + std::shared_ptr impl = std::static_pointer_cast(resMgr); + std::shared_ptr resourceManagerAddon = std::make_shared(resMgr, + AbilityRuntime::ApplicationContext::GetInstance(), impl->IsSystem(), impl->IsOverride()); + + ani_ref resAny; + { + napi_env jsenv; + if (!arkts_napi_scope_open(env, &jsenv)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to open napi js env."); + return nullptr; + } + napi_value resNapi = ResourceManagerAddon::WrapResourceManager(jsenv, resourceManagerAddon); + if (!arkts_napi_scope_close_n(jsenv, NUM_NAPI_VALUES_TO_WRAP, &resNapi, &resAny)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to close napi js env."); + return nullptr; + } + } + return resAny; +} + +ani_object ResMgrAni::TransferToStaticResource(ani_env *env, ani_object esValue) +{ + void *nativePtr = nullptr; + if (!arkts_esvalue_unwrap(env, esValue, &nativePtr) || nativePtr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "arkts_esvalue_unwrap failed."); + return nullptr; + } + std::shared_ptr addon = *reinterpret_cast*>(nativePtr); + if (addon == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "reinterpret_cast failed."); + return nullptr; + } + std::shared_ptr resMgr = addon->GetResMgr(); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in TransferToStaticResource."); + return nullptr; + } + return ResMgrAddon::WrapResourceManager(env, resMgr); +} + +ani_status ResMgrAni::BindResMgr(ani_env* env) +{ + ani_class cls; + ani_status status = env->FindClass(AniSignature::RESOURCE_MANAGER_INNER, &cls); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class '%{public}s' failed, status: %{public}d", + AniSignature::RESOURCE_MANAGER_INNER, status); + return status; + } + status = env->Class_BindNativeMethods(cls, methods.data(), methods.size()); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Can't bind native methods to %{public}s, status: %{public}d.", + AniSignature::RESOURCE_MANAGER_INNER, status); + return status; + }; + return ANI_OK; +} + +ani_status ResMgrAni::BindResMgrCleaner(ani_env* env) +{ + ani_class cls; + ani_status status = env->FindClass(AniSignature::RESMGR_CLEANER, &cls); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class '%{public}s' failed, status: %{public}d.", + AniSignature::RESMGR_CLEANER, status); + return status; + } + std::array methods = { + ani_native_function { "destoryResMgr", nullptr, reinterpret_cast(DestoryResMgr) }, + }; + status = env->Class_BindNativeMethods(cls, methods.data(), methods.size()); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Can't bind native methods to '%{public}s', status: %{public}d", + AniSignature::RESMGR_CLEANER, status); + return status; + }; + return ANI_OK; +} + +ani_status ResMgrAni::BindStaticFunc(ani_env* env) +{ + ani_namespace ns; + ani_status status = env->FindNamespace(AniSignature::NAMESPACE, &ns); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find namespace '%{public}s' failed, status: %{public}d.", + AniSignature::NAMESPACE, status); + return status; + } + + std::array nsMethods = { + ani_native_function { "getSysResourceManager", nullptr, reinterpret_cast(GetSysResourceManager) }, + ani_native_function{ "transferToDynamicResource", nullptr, + reinterpret_cast(TransferToDynamicResource) }, + ani_native_function{ "transferToStaticResource", nullptr, reinterpret_cast(TransferToStaticResource) }, + }; + status = env->Namespace_BindNativeFunctions(ns, nsMethods.data(), nsMethods.size()); + if (ANI_OK != status) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Cannot bind native methods to '%{public}s', status: %{public}d.", + AniSignature::NAMESPACE, status); + return status; + }; + return ANI_OK; +} + +ani_status ResMgrAni::BindContext(ani_env* env) +{ + ani_status status = BindStaticFunc(env); + if (ANI_OK != status) { + return status; + } + + status = BindResMgr(env); + if (ANI_OK != status) { + return status; + } + + status = BindResMgrCleaner(env); + if (ANI_OK != status) { + return status; + } + + return ANI_OK; +} +} // namespace Resource +} // namespace Global +} // namespace OHOS ANI_EXPORT ani_status ANI_Constructor(ani_vm* vm, uint32_t* result) { @@ -24,7 +1227,7 @@ ANI_EXPORT ani_status ANI_Constructor(ani_vm* vm, uint32_t* result) return (ani_status)ANI_ERROR; } - auto status = OHOS::Global::Resource::ResMgrAddon::BindContext(env); + auto status = OHOS::Global::Resource::ResMgrAni::BindContext(env); if (status != ANI_OK) { return status; } diff --git a/interfaces/ets/ani/resourceManager/src/resourceManager.cpp b/interfaces/ets/ani/resourceManager/src/resourceManager.cpp index 418d491..7558b60 100644 --- a/interfaces/ets/ani/resourceManager/src/resourceManager.cpp +++ b/interfaces/ets/ani/resourceManager/src/resourceManager.cpp @@ -14,150 +14,28 @@ */ #include "resourceManager.h" -#include "drawable_descriptor_ani.h" + +#include "ani_signature.h" #include "hilog_wrapper.h" -#include "interop_js/arkts_esvalue.h" -#include "interop_js/arkts_interop_js_api.h" -#include "ani_signature_builder.h" -#include "resource_manager_addon.h" -#include "resource_manager_ani_utils.h" -#include "resource_manager_data_context.h" #include "resource_manager.h" -#include "system_resource_manager.h" - -using namespace OHOS; -using namespace Global; -using namespace Resource; - -constexpr ani_int ABNORMAL_NUMBER_RETURN_VALUE = -1; - -const int NUM_NAPI_VALUES_TO_WRAP = 1; - -enum ScreenDensityIndex { - SCREEN_DENSITY_ONE = 0, - SCREEN_DENSITY_TWO = 1, - SCREEN_DENSITY_THREE = 2, - SCREEN_DENSITY_FOUR = 3, - SCREEN_DENSITY_FIVE = 4, - SCREEN_DENSITY_SIX = 5, -}; - -struct ArrayElement { - enum class ElementType { NUMBER, STRING } type; - std::variant value; - - ArrayElement(ElementType type, double number) : type(type), value(number) {} - ArrayElement(ElementType type, const std::string& str) : type(type), value(str) {} -}; - -static std::array methods = { - ani_native_function { "getStringSync", "l:C{std.core.String}", - reinterpret_cast(ResMgrAddon::GetStringSyncById) }, - ani_native_function { "getStringSync", "lC{escompat.Array}:C{std.core.String}", - reinterpret_cast(ResMgrAddon::GetFormatStringSyncById) }, - ani_native_function { "getStringByNameSync", "C{std.core.String}:C{std.core.String}", - reinterpret_cast(ResMgrAddon::GetStringByNameSync) }, - ani_native_function { "getStringByNameSync", "C{std.core.String}C{escompat.Array}:C{std.core.String}", - reinterpret_cast(ResMgrAddon::GetFormatStringByNameSync) }, - - ani_native_function { "getBoolean", nullptr, reinterpret_cast(ResMgrAddon::GetBooleanById) }, - ani_native_function { "getBooleanByName", nullptr, reinterpret_cast(ResMgrAddon::GetBooleanByName) }, - - ani_native_function { "getInt", nullptr, reinterpret_cast(ResMgrAddon::GetIntById) }, - ani_native_function { "getIntByName", nullptr, reinterpret_cast(ResMgrAddon::GetIntByName) }, - ani_native_function { "getDouble", nullptr, reinterpret_cast(ResMgrAddon::GetDoubleById) }, - ani_native_function { "getDoubleByName", nullptr, reinterpret_cast(ResMgrAddon::GetDoubleByName) }, - - ani_native_function { "getIntPluralStringValueSync", nullptr, - reinterpret_cast(ResMgrAddon::GetIntPluralStringValueSyncById) }, - ani_native_function { "getIntPluralStringByNameSync", nullptr, - reinterpret_cast(ResMgrAddon::GetIntPluralStringByNameSync) }, - - ani_native_function { "getDoublePluralStringValueSync", nullptr, - reinterpret_cast(ResMgrAddon::GetDoublePluralStringValueSyncById) }, - ani_native_function { "getDoublePluralStringByNameSync", nullptr, - reinterpret_cast(ResMgrAddon::GetDoublePluralStringByNameSync) }, - - ani_native_function { "getColorSync", nullptr, reinterpret_cast(ResMgrAddon::GetColorSyncById) }, - ani_native_function { "getColorByNameSync", nullptr, reinterpret_cast(ResMgrAddon::GetColorByNameSync) }, - - ani_native_function { "addResource", nullptr, reinterpret_cast(ResMgrAddon::AddResource) }, - ani_native_function { "removeResource", nullptr, reinterpret_cast(ResMgrAddon::RemoveResource) }, - - ani_native_function { "getRawFdSync", nullptr, reinterpret_cast(ResMgrAddon::GetRawFdSync) }, - ani_native_function { "closeRawFdSync", nullptr, reinterpret_cast(ResMgrAddon::CloseRawFdSync) }, - ani_native_function { "isRawDir", nullptr, reinterpret_cast(ResMgrAddon::IsRawDir) }, - - ani_native_function { "getRawFileListSync", nullptr, reinterpret_cast(ResMgrAddon::GetRawFileListSync) }, - ani_native_function { "getRawFileContentSync", nullptr, - reinterpret_cast(ResMgrAddon::GetRawFileContentSync) }, - - ani_native_function { "getMediaContentSync", nullptr, - reinterpret_cast(ResMgrAddon::GetMediaContentSyncById) }, - - ani_native_function { "getMediaContentBase64Sync", nullptr, - reinterpret_cast(ResMgrAddon::GetMediaContentBase64SyncById) }, - - ani_native_function { "getStringArrayValueSync", nullptr, - reinterpret_cast(ResMgrAddon::GetStringArrayValueSyncById) }, - - ani_native_function { "getStringArrayByNameSync", nullptr, - reinterpret_cast(ResMgrAddon::GetStringArrayByNameSync) }, - - ani_native_function { "getMediaByNameSync", nullptr, reinterpret_cast(ResMgrAddon::GetMediaByNameSync) }, - ani_native_function { "getMediaBase64ByNameSync", nullptr, - reinterpret_cast(ResMgrAddon::GetMediaBase64ByNameSync) }, - - ani_native_function { "getDrawableDescriptor", nullptr, - reinterpret_cast(ResMgrAddon::GetDrawableDescriptorById) }, - ani_native_function { "getDrawableDescriptorByName", nullptr, - reinterpret_cast(ResMgrAddon::GetDrawableDescriptorByName) }, - - ani_native_function { "getConfigurationSync", nullptr, reinterpret_cast(ResMgrAddon::GetConfigurationSync) }, - ani_native_function { "getDeviceCapabilitySync", nullptr, - reinterpret_cast(ResMgrAddon::GetDeviceCapabilitySync) }, - ani_native_function { "getLocales", nullptr, reinterpret_cast(ResMgrAddon::GetLocales) }, - ani_native_function { "getSymbol", nullptr, reinterpret_cast(ResMgrAddon::GetSymbolById) }, - ani_native_function { "getSymbolByName", nullptr, reinterpret_cast(ResMgrAddon::GetSymbolByName) }, - - ani_native_function { "getOverrideResourceManager", nullptr, - reinterpret_cast(ResMgrAddon::GetOverrideResourceManager) }, - ani_native_function { "getOverrideConfiguration", nullptr, - reinterpret_cast(ResMgrAddon::GetOverrideConfiguration) }, - ani_native_function { "updateOverrideConfiguration", nullptr, - reinterpret_cast(ResMgrAddon::UpdateOverrideConfiguration) }, -}; - -ResMgrAddon::ResMgrAddon( - const std::string& bundleName, const std::shared_ptr& resMgr, - const std::shared_ptr& context, bool isSystem) - : bundleName_(bundleName), resMgr_(resMgr), context_(context), isSystem_(isSystem) -{ - RESMGR_HILOGD(RESMGR_ANI_TAG, "create ResMgrAddon %{public}s", bundleName_.c_str()); -} - -ResMgrAddon::ResMgrAddon(const std::shared_ptr& resMgr, bool isSystem) - : resMgr_(resMgr), isSystem_(isSystem) -{ - RESMGR_HILOGD(RESMGR_ANI_TAG, "create ResMgrAddon."); -} +namespace OHOS { +namespace Global { +namespace Resource { ani_object ResMgrAddon::CreateResMgr( ani_env* env, const std::string& bundleName, const std::shared_ptr& resMgr, std::shared_ptr context) { - std::shared_ptr addon = std::make_shared(bundleName, resMgr, context); - return WrapResourceManager(env, addon); + return WrapResourceManager(env, resMgr); } -ani_object ResMgrAddon::WrapResourceManager(ani_env* env, std::shared_ptr &addon) +ani_object ResMgrAddon::WrapResourceManager(ani_env* env, std::shared_ptr resMgr) { ani_object nativeResMgr; - static const char *className = "@ohos.resourceManager.resourceManager.ResourceManagerInner"; ani_class cls; - if (ANI_OK != env->FindClass(className, &cls)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class '%{public}s' failed", className); + if (ANI_OK != env->FindClass(AniSignature::RESOURCE_MANAGER_INNER, &cls)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class '%{public}s' failed", AniSignature::RESOURCE_MANAGER_INNER); return nullptr; } @@ -167,1674 +45,14 @@ ani_object ResMgrAddon::WrapResourceManager(ani_env* env, std::shared_ptr>(addon); - if (ANI_OK != env->Object_New(cls, ctor, &nativeResMgr, reinterpret_cast(addonPtr.get()))) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "New object '%{public}s' failed", className); + auto resMgrPtr = std::make_unique>(resMgr); + if (ANI_OK != env->Object_New(cls, ctor, &nativeResMgr, reinterpret_cast(resMgrPtr.get()))) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "New object '%{public}s' failed", AniSignature::RESOURCE_MANAGER_INNER); return nullptr; } - addonPtr.release(); + resMgrPtr.release(); return nativeResMgr; } - -static std::string AniStrToString(ani_env *env, ani_ref aniStr) -{ - ani_string str = static_cast(aniStr); - ani_size size = 0; - env->String_GetUTF8Size(str, &size); - - std::string result; - result.resize(size); - ani_size written; - env->String_GetUTF8(str, result.data(), size + 1, &written); - return result; -} - -static ani_string StringToAniStr(ani_env *env, const std::string &str) -{ - ani_string ret; - if (ANI_OK != env->String_NewUTF8(str.c_str(), str.size(), &ret)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Create ani string failed"); - return nullptr; - } - return ret; -} - -static ani_object CreateAniArray(ani_env *env, const std::vector strs) -{ - static const char *className = "escompat.Array"; - ani_class cls; - if (ANI_OK != env->FindClass(className, &cls)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class '%{public}s' failed", className); - return nullptr; - } - - ani_method ctor; - if (ANI_OK != env->Class_FindMethod(cls, "", "i:", &ctor)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method '' failed"); - return nullptr; - } - - ani_object ret; - if (ANI_OK != env->Object_New(cls, ctor, &ret, strs.size())) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "New object '%{public}s' failed", className); - return nullptr; - } - - ani_method set; - if (ANI_OK != env->Class_FindMethod(cls, "$_set", "iC{std.core.Object}:", &set)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method '$_set' failed"); - return ret; - } - - for (size_t i = 0; i < strs.size(); i++) { - if (ANI_OK != env->Object_CallMethod_Void(ret, set, i, StringToAniStr(env, strs[i]))) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Call method '$_set' failed"); - return ret; - } - } - return ret; -} - -static ani_object CreateAniUint8Array(ani_env* env, ResMgrDataContext &context) -{ - size_t length = context.len_; - static const char *className = "escompat.Uint8Array"; - ani_class cls; - if (ANI_OK != env->FindClass(className, &cls)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class '%{public}s' failed", className); - return nullptr; - } - - ani_method ctor; - if (ANI_OK != env->Class_FindMethod(cls, "", "i:", &ctor)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method '' failed"); - return nullptr; - } - - ani_object ret = {}; - if (ANI_OK != env->Object_New(cls, ctor, &ret, length)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "New object '%{public}s' failed", className); - return nullptr; - } - - ani_method set; - if (ANI_OK != env->Class_FindMethod(cls, "$_set", "ii:", &set)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method '$_set' failed"); - return nullptr; - } - - for (size_t i = 0; i < length; i++) { - if (ANI_OK != env->Object_CallMethod_Void(ret, set, i, context.mediaData[i])) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Call method '$_set' failed"); - return nullptr; - } - } - return ret; -} - -static std::shared_ptr UnwrapAddon(ani_env* env, ani_object object) -{ - ani_long ptr; - if (ANI_OK != env->Object_GetFieldByName_Long(object, "nativeResMgr", &ptr)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Get Long 'nativeResMgr' failed"); - return nullptr; - } - return *reinterpret_cast*>(ptr); -} - -static ani_string CreateAniString(ani_env *env, ResMgrDataContext& context) -{ - ani_string result; - std::string str = context.value_; - if (ANI_OK != env->String_NewUTF8(str.c_str(), str.size(), &result)) { - context.SetErrorMsg("Failed to create result"); - return nullptr; - } - return result; -} - -ani_object ResMgrAddon::GetSysResourceManager(ani_env* env) -{ - std::shared_ptr sysResMgr(SystemResourceManager::CreateSysResourceManager()); - std::shared_ptr addon = std::make_shared(sysResMgr, true); - return WrapResourceManager(env, addon); -} - -static bool GetHapResourceManager(const ResMgrDataContext* dataContext, - std::shared_ptr &resMgr, uint32_t &resId) -{ - std::shared_ptr resource = dataContext->resource_; - // In fa module, resource is null. - if (resource == nullptr) { - resMgr = dataContext->addon_->GetResMgr(); - resId = dataContext->resId_; - return true; - } - - // In stage module and isSystem is true, resId is the resource object id. - if (dataContext->addon_->IsSystem()) { - resMgr = dataContext->addon_->GetResMgr(); - resId = resource->id; - return true; - } - - resId = resource->id; - if (dataContext->addon_->isOverrideAddon()) { - resMgr = dataContext->addon_->GetResMgr(); - return true; - } - - auto context = dataContext->addon_->GetContext(); - if (context == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "GetHapResourceManager context == nullptr"); - return false; - } - - std::string bundleName(resource->bundleName); - if (bundleName.empty()) { - auto applicationInfo = context->GetApplicationInfo(); - if (applicationInfo != nullptr) { - bundleName = applicationInfo->name; - } - } - auto moduleContext = context->CreateModuleContext(bundleName, resource->moduleName); - if (moduleContext == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "GetHapResourceManager moduleContext == nullptr, bundleName = %{public}s," \ - "moduleName = %{public}s", bundleName.c_str(), resource->moduleName.c_str()); - return false; - } - resMgr = moduleContext->GetResourceManager(); - return true; -} - -ani_string ResMgrAddon::GetStringSyncById(ani_env* env, ani_object object, ani_long resId) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - - std::shared_ptr resMgr = nullptr; - uint32_t notUse = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getStringSyncById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - RState state = resMgr->GetStringFormatById(resId, dataContext->value_, dataContext->jsParams_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("getStringSyncById failed state", true); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniString(env, *dataContext); -} - -static ArrayElement GetArrayElement(ani_env* env, ani_object args, const int index) -{ - ani_ref value; - if (ANI_OK != env->Array_Get_Ref(static_cast(args), index, &value)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Call get failed"); - return ArrayElement{ArrayElement::ElementType::NUMBER, 0}; - } - - ani_class stringClass; - if (ANI_OK != env->FindClass("std.core.String", &stringClass)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class 'C{std.core.String}' failed"); - return ArrayElement{ArrayElement::ElementType::NUMBER, 0}; - } - - ani_boolean isString; - env->Object_InstanceOf(static_cast(value), stringClass, &isString); - - if (isString) { - return ArrayElement{ArrayElement::ElementType::STRING, AniStrToString(env, value)}; - } else { - ani_double param; - env->Object_CallMethodByName_Double(static_cast(value), "unboxed", ":d", ¶m); - return ArrayElement{ArrayElement::ElementType::NUMBER, param}; - } -} - -static bool InitAniParameters(ani_env *env, ani_object args, - std::vector> &jsParams) -{ - ani_size size; - if (ANI_OK != env->Array_GetLength(static_cast(args), &size)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Get length failed"); - return false; - } - - if (size <= 0) { - return true; - } - - for (size_t i = 0; i < size; ++i) { - auto param = GetArrayElement(env, args, i); - if (param.type == ArrayElement::ElementType::NUMBER) { - jsParams.push_back(std::make_tuple(ResourceManager::NapiValueType::NAPI_NUMBER, - std::to_string(std::get(param.value)))); - } else if (param.type == ArrayElement::ElementType::STRING) { - jsParams.push_back(std::make_tuple(ResourceManager::NapiValueType::NAPI_STRING, - std::get(param.value))); - } else { - return false; - } - } - return true; -} - -ani_string ResMgrAddon::GetFormatStringSyncById(ani_env *env, ani_object object, ani_long resId, ani_object args) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - std::shared_ptr resMgr = nullptr; - uint32_t notUse = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getStringSyncById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - if (!InitAniParameters(env, args, dataContext->jsParams_)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "getFormatStringSyncById formatting error"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_ID_FORMAT_ERROR); - return nullptr; - } - RState state = resMgr->GetStringFormatById(resId, dataContext->value_, dataContext->jsParams_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("getFormatStringSyncById failed state", true); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniString(env, *dataContext); -} - -ani_string ResMgrAddon::GetStringByNameSync(ani_env* env, ani_object object, ani_string resName) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resName_ = AniStrToString(env, static_cast(resName)); - - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getStringByNameSync"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - RState state = resMgr->GetStringFormatByName(dataContext->resName_.c_str(), - dataContext->value_, dataContext->jsParams_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("GetStringByNameSync failed state", false); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniString(env, *dataContext); -} - -ani_string ResMgrAddon::GetFormatStringByNameSync(ani_env *env, ani_object object, ani_string resName, ani_object args) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resName_ = AniStrToString(env, static_cast(resName)); - - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getFormatStringByNameSync"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - if (!InitAniParameters(env, args, dataContext->jsParams_)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "getFormatStringByNameSync formatting error"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NAME_FORMAT_ERROR); - return nullptr; - } - - RState state = resMgr->GetStringFormatByName(dataContext->resName_.c_str(), - dataContext->value_, dataContext->jsParams_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("GetStringByNameSync failed state", false); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniString(env, *dataContext); -} - -ani_boolean ResMgrAddon::GetBooleanById(ani_env* env, ani_object object, ani_long resId) -{ - std::unique_ptr dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - - std::shared_ptr resMgr = nullptr; - uint32_t notUse = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getBooleanById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return false; - } - - RState state = resMgr->GetBooleanById(resId, dataContext->bValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to GetBoolean state", true); - ResourceManagerAniUtils::AniThrow(env, state); - return false; - } - return dataContext->bValue_; -} - -ani_boolean ResMgrAddon::GetBooleanByName(ani_env* env, ani_object object, ani_string resName) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resName_ = AniStrToString(env, static_cast(resName)); - - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getBooleanByName"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return false; - } - - RState state = resMgr->GetBooleanByName(dataContext->resName_.c_str(), dataContext->bValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("GetBooleanByName failed state", false); - ResourceManagerAniUtils::AniThrow(env, state); - return false; - } - return dataContext->bValue_; -} - -ani_int ResMgrAddon::GetIntById(ani_env* env, ani_object object, ani_long resId) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - - std::shared_ptr resMgr = nullptr; - uint32_t notUse = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetIntById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - RState state = resMgr->GetIntegerById(resId, dataContext->iValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to process string in GetIntById", true); - ResourceManagerAniUtils::AniThrow(env, state); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - return dataContext->iValue_; -} - -ani_int ResMgrAddon::GetIntByName(ani_env* env, ani_object object, ani_string resName) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resName_ = AniStrToString(env, static_cast(resName)); - - if (dataContext->addon_ == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in GetIntByName"); - ResourceManagerAniUtils::AniThrow(env, NOT_FOUND); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - auto resMgr = dataContext->addon_->GetResMgr(); - if (resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in GetIntByName"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - RState state = resMgr->GetIntegerByName(dataContext->resName_.c_str(), dataContext->iValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to process number in GetIntByName", false); - ResourceManagerAniUtils::AniThrow(env, state); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - return dataContext->iValue_; -} - -ani_double ResMgrAddon::GetDoubleById(ani_env* env, ani_object object, ani_long resId) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - - std::shared_ptr resMgr = nullptr; - uint32_t notUse = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getNumberById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - RState state = resMgr->GetFloatById(resId, dataContext->fValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to process string in getNumberById", true); - ResourceManagerAniUtils::AniThrow(env, state); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - return dataContext->fValue_; -} - -ani_double ResMgrAddon::GetDoubleByName(ani_env* env, ani_object object, ani_string resName) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resName_ = AniStrToString(env, static_cast(resName)); - - if (dataContext->addon_ == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in getNumberByName"); - ResourceManagerAniUtils::AniThrow(env, NOT_FOUND); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - auto resMgr = dataContext->addon_->GetResMgr(); - if (resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getNumberByName"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - RState state = resMgr->GetFloatByName(dataContext->resName_.c_str(), dataContext->fValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to process number in getNumberByName", false); - ResourceManagerAniUtils::AniThrow(env, state); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - return dataContext->fValue_; -} - -ani_string ResMgrAddon::GetIntPluralStringValueSyncById(ani_env* env, ani_object object, - ani_long resId, ani_int num, ani_object args) -{ - std::unique_ptr dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - double number = num; - if (number > INT_MAX) { - number = INT_MAX; - } else if (number < INT_MIN) { - number = INT_MIN; - } - dataContext->quantity_ = { true, number, 0.0 }; - - std::shared_ptr resMgr = nullptr; - uint32_t notUse = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getIntPluralStringValueSyncById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - if (!InitAniParameters(env, args, dataContext->jsParams_)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "InitOptionalParameters formatting error"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_ID_FORMAT_ERROR); - return nullptr; - } - - RState state = resMgr->GetFormatPluralStringById(dataContext->value_, resId, dataContext->quantity_, - dataContext->jsParams_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to GetFormatPluralStringById state", true, state); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniString(env, *dataContext); -} - -ani_string ResMgrAddon::GetIntPluralStringByNameSync(ani_env* env, ani_object object, - ani_string resName, ani_int num, ani_object args) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resName_ = AniStrToString(env, static_cast(resName)); - double number = num; - if (number > INT_MAX) { - number = INT_MAX; - } else if (number < INT_MIN) { - number = INT_MIN; - } - dataContext->quantity_ = { true, number, 0.0 }; - - if (!InitAniParameters(env, args, dataContext->jsParams_)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "InitOptionalParameters formatting error"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_ID_FORMAT_ERROR); - return nullptr; - } - - if (dataContext->addon_ == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in getIntPluralStringByNameSync"); - ResourceManagerAniUtils::AniThrow(env, NOT_FOUND); - return nullptr; - } - - RState state = dataContext->addon_->GetResMgr()->GetFormatPluralStringByName(dataContext->value_, - dataContext->resName_.c_str(), dataContext->quantity_, dataContext->jsParams_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("GetFormatPluralStringByName failed state", false); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniString(env, *dataContext); -} - -ani_string ResMgrAddon::GetDoublePluralStringValueSyncById(ani_env* env, ani_object object, - ani_long resId, ani_double num, ani_object args) -{ - std::unique_ptr dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->quantity_ = { false, 0, num }; - - std::shared_ptr resMgr = nullptr; - uint32_t notUse = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getIntPluralStringValueSyncById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - if (!InitAniParameters(env, args, dataContext->jsParams_)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "InitOptionalParameters formatting error"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_ID_FORMAT_ERROR); - return nullptr; - } - - RState state = resMgr->GetFormatPluralStringById(dataContext->value_, resId, dataContext->quantity_, - dataContext->jsParams_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to GetFormatPluralStringById state", true, state); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniString(env, *dataContext); -} - -ani_string ResMgrAddon::GetDoublePluralStringByNameSync(ani_env* env, ani_object object, - ani_string resName, ani_double num, ani_object args) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resName_ = AniStrToString(env, static_cast(resName)); - dataContext->quantity_ = { false, 0, num }; - - if (!InitAniParameters(env, args, dataContext->jsParams_)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "InitOptionalParameters formatting error"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_ID_FORMAT_ERROR); - return nullptr; - } - - if (dataContext->addon_ == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in getDoublePluralStringByNameSync"); - ResourceManagerAniUtils::AniThrow(env, NOT_FOUND); - return nullptr; - } - - RState state = dataContext->addon_->GetResMgr()->GetFormatPluralStringByName(dataContext->value_, - dataContext->resName_.c_str(), dataContext->quantity_, dataContext->jsParams_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("GetFormatPluralStringByName failed state", false); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniString(env, *dataContext); -} - -ani_long ResMgrAddon::GetColorSyncById(ani_env* env, ani_object object, ani_long resId) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - - std::shared_ptr resMgr = nullptr; - uint32_t notUse = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getColorSyncById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - RState state = resMgr->GetColorById(resId, dataContext->colorValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("getColorSyncById failed state", true); - ResourceManagerAniUtils::AniThrow(env, state); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - return dataContext->colorValue_; -} - -ani_long ResMgrAddon::GetColorByNameSync(ani_env* env, ani_object object, ani_string resName) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resName_ = AniStrToString(env, static_cast(resName)); - - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getColorByNameSync"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - RState state = resMgr->GetColorByName(dataContext->resName_.c_str(), dataContext->colorValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to process number in getColorByNameSync", false); - ResourceManagerAniUtils::AniThrow(env, state); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - return dataContext->colorValue_; -} - -void ResMgrAddon::AddResource(ani_env* env, ani_object object, ani_string path) -{ - auto dataContext = std::make_unique(); - dataContext->path_ = AniStrToString(env, path); - - auto resMgr = UnwrapAddon(env, object); - if (resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_JS_TAG, "resMgr is null, add overlay path = %{public}s", dataContext->path_.c_str()); - return; - } - - if (!resMgr->GetResMgr()->AddAppOverlay(dataContext->path_)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to add overlay path = %{public}s", dataContext->path_.c_str()); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_OVERLAY_RES_PATH_INVALID); - return; - } -} - -void ResMgrAddon::RemoveResource(ani_env* env, ani_object object, ani_string path) -{ - auto dataContext = std::make_unique(); - dataContext->path_ = AniStrToString(env, path); - - auto resMgr = UnwrapAddon(env, object); - if (resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_JS_TAG, "resMgr is null, overlay path = %{public}s", dataContext->path_.c_str()); - return; - } - - if (!resMgr->GetResMgr()->RemoveAppOverlay(dataContext->path_)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to add overlay path = %{public}s", dataContext->path_.c_str()); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_OVERLAY_RES_PATH_INVALID); - return; - } -} - -ani_object ResMgrAddon::GetRawFdSync(ani_env* env, ani_object object, ani_string path) -{ - auto dataContext = std::make_unique(); - dataContext->path_ = AniStrToString(env, path); - dataContext->addon_ = UnwrapAddon(env, object); - - if (dataContext->addon_ == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in getRawFdSync"); - ResourceManagerAniUtils::AniThrow(env, NOT_FOUND); - return nullptr; - } - - RState state = dataContext->addon_->GetResMgr()->GetRawFileDescriptorFromHap(dataContext->path_, - dataContext->descriptor_); - if (state != RState::SUCCESS) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get rawfd by %{public}s", dataContext->path_.c_str()); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - - static const char *className = "global.rawFileDescriptorInner.RawFileDescriptorInner"; - ani_class cls; - if (ANI_OK != env->FindClass(className, &cls)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class '%{public}s' failed", className); - return nullptr; - } - - ani_method ctor; - if (ANI_OK != env->Class_FindMethod(cls, "", nullptr, &ctor)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method '' failed"); - return nullptr; - } - - ani_object obj; - if (ANI_OK != env->Object_New(cls, ctor, &obj)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "New object '%{public}s' failed", className); - return nullptr; - } - - if (ANI_OK != env->Object_SetPropertyByName_Int(obj, "fd", dataContext->descriptor_.fd)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Set property 'fd' failed"); - } - - if (ANI_OK != env->Object_SetPropertyByName_Long(obj, "offset", dataContext->descriptor_.offset)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Set property 'offset' failed"); - } - - if (ANI_OK != env->Object_SetPropertyByName_Long(obj, "length", dataContext->descriptor_.length)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Set property 'length' failed"); - } - return obj; -} - -void ResMgrAddon::CloseRawFdSync(ani_env* env, ani_object object, ani_string path) -{ - auto dataContext = std::make_unique(); - dataContext->path_ = AniStrToString(env, path); - dataContext->addon_ = UnwrapAddon(env, object); - - if (dataContext->addon_ == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in closeRawFdSync"); - ResourceManagerAniUtils::AniThrow(env, NOT_FOUND); - return; - } - - RState state = dataContext->addon_->GetResMgr()->CloseRawFileDescriptor(dataContext->path_); - if (state != RState::SUCCESS) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to close rawfd by %{public}s", dataContext->path_.c_str()); - ResourceManagerAniUtils::AniThrow(env, state); - return; - } -} - -ani_object ResMgrAddon::GetRawFileListSync(ani_env* env, ani_object object, ani_string path) -{ - std::unique_ptr dataContext = std::make_unique(); - dataContext->path_ = AniStrToString(env, path); - dataContext->addon_ = UnwrapAddon(env, object); - - if (dataContext->addon_ == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in getRawFileListSync"); - ResourceManagerAniUtils::AniThrow(env, NOT_FOUND); - return nullptr; - } - - RState state = dataContext->addon_->GetResMgr()->GetRawFileList(dataContext->path_.c_str(), - dataContext->arrayValue_); - if (state != RState::SUCCESS || dataContext->arrayValue_.empty()) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get rawfile list by %{public}s", dataContext->path_.c_str()); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_PATH_INVALID); - return nullptr; - } - - return CreateAniArray(env, dataContext->arrayValue_); -} - -ani_object ResMgrAddon::GetRawFileContentSync(ani_env* env, ani_object object, ani_string path) -{ - std::unique_ptr dataContext = std::make_unique(); - dataContext->path_ = AniStrToString(env, path); - dataContext->addon_ = UnwrapAddon(env, object); - - if (dataContext->addon_ == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in getRawFileContentSync"); - ResourceManagerAniUtils::AniThrow(env, NOT_FOUND); - return nullptr; - } - - RState state = dataContext->addon_->GetResMgr()->GetRawFileFromHap(dataContext->path_, - dataContext->len_, dataContext->mediaData); - if (state != RState::SUCCESS) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get rawfile by %{public}s", dataContext->path_.c_str()); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniUint8Array(env, *dataContext); -} - -ani_object ResMgrAddon::GetMediaContentSyncById(ani_env* env, ani_object object, - ani_long resId, ani_object density) -{ - std::unique_ptr dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - - ani_boolean isUndefined; - env->Reference_IsUndefined(density, &isUndefined); - ani_int densityInner = 0; - if (!isUndefined) { - env->Object_CallMethodByName_Int(density, "unboxed", ":i", &densityInner); - } - - std::shared_ptr resMgr = nullptr; - uint32_t notUse = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getMediaContentSyncById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - RState state = resMgr->GetMediaDataById(resId, dataContext->len_, dataContext->mediaData, densityInner); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to GetMediaContentSync state", true); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniUint8Array(env, *dataContext); -} - -ani_string ResMgrAddon::GetMediaContentBase64SyncById(ani_env* env, ani_object object, - ani_long resId, ani_object density) -{ - std::unique_ptr dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - - ani_boolean isUndefined; - env->Reference_IsUndefined(density, &isUndefined); - ani_int densityInner = 0; - if (!isUndefined) { - env->Object_CallMethodByName_Int(density, "unboxed", ":i", &densityInner); - } - - std::shared_ptr resMgr = nullptr; - uint32_t notUse = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getMediaContentBase64SyncById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - RState state = resMgr->GetMediaBase64DataById(resId, dataContext->value_, densityInner); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to GetMediaContentBase64Sync state", true); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniString(env, *dataContext); -} - -ani_object ResMgrAddon::GetStringArrayValueSyncById(ani_env* env, ani_object object, ani_long resId) -{ - std::unique_ptr dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - - std::shared_ptr resMgr = nullptr; - uint32_t notUse = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getStringArrayValueSyncById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - RState state = resMgr->GetStringArrayById(resId, dataContext->arrayValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to GetStringArrayValueSync state", true); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniArray(env, dataContext->arrayValue_); -} - -ani_object ResMgrAddon::GetMediaByNameSync(ani_env* env, ani_object object, ani_string resName, ani_object density) -{ - std::unique_ptr dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resName_ = AniStrToString(env, static_cast(resName)); - - ani_boolean isUndefined; - env->Reference_IsUndefined(density, &isUndefined); - ani_int densityInner = 0; - if (!isUndefined) { - env->Object_CallMethodByName_Int(density, "unboxed", ":i", &densityInner); - } - - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getMediaByNameSync"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - RState state = resMgr->GetMediaDataByName(dataContext->resName_.c_str(), - dataContext->len_, dataContext->mediaData, densityInner); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("GetMediaByNameSync failed state", false); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniUint8Array(env, *dataContext); -} - -ani_string ResMgrAddon::GetMediaBase64ByNameSync(ani_env* env, ani_object object, - ani_string resName, ani_object density) -{ - std::unique_ptr dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resName_ = AniStrToString(env, static_cast(resName)); - - ani_boolean isUndefined; - env->Reference_IsUndefined(density, &isUndefined); - ani_int densityInner = 0; - if (!isUndefined) { - env->Object_CallMethodByName_Int(density, "unboxed", ":i", &densityInner); - } - - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getMediaBase64ByNameSync"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - RState state = resMgr->GetMediaBase64DataByName(dataContext->resName_.c_str(), - dataContext->value_, densityInner); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to get media data in GetMediaBase64ByNameSync", false); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniString(env, *dataContext); -} - -ani_object CreateDrawableDescriptorbyId(ani_env* env, std::unique_ptr& dataContext) -{ - std::shared_ptr resMgr = nullptr; - uint32_t resId; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getDrawableDescriptorById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - Ace::Ani::DrawableInfo drawableInfo; - drawableInfo.density = dataContext->density_; - drawableInfo.manager = resMgr; - RState state = SUCCESS; - if (dataContext->iconType_ == 1) { - std::pair, size_t> foregroundInfo; - std::pair, size_t> backgroundInfo; - state = resMgr->GetThemeIcons(resId, foregroundInfo, backgroundInfo, dataContext->density_); - if (state == SUCCESS) { - drawableInfo.firstBuffer.data = std::move(foregroundInfo.first); - drawableInfo.firstBuffer.len = foregroundInfo.second; - drawableInfo.secondBuffer.data = std::move(backgroundInfo.first); - drawableInfo.secondBuffer.len = backgroundInfo.second; - drawableInfo.type = "layered"; - return Ace::Ani::DrawableDescriptorAni::CreateDrawableDescriptor(env, drawableInfo); - } - } - state = resMgr->GetDrawableInfoById(resId, drawableInfo.type, - drawableInfo.firstBuffer.len, drawableInfo.firstBuffer.data, dataContext->density_); - if (SUCCESS != state) { - dataContext->SetErrorMsg("Failed to Create drawableDescriptor", true); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - }; - return Ace::Ani::DrawableDescriptorAni::CreateDrawableDescriptor(env, drawableInfo); -} - -ani_object ResMgrAddon::GetDrawableDescriptorById(ani_env* env, ani_object object, - ani_long resId, ani_object density, ani_object type) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resId_ = static_cast(resId); - - ani_boolean isUndefined; - env->Reference_IsUndefined(density, &isUndefined); - if (!isUndefined) { - ani_int densityInner; - env->Object_CallMethodByName_Int(density, "unboxed", ":i", &densityInner); - dataContext->density_ = static_cast(densityInner); - } - - env->Reference_IsUndefined(type, &isUndefined); - if (!isUndefined) { - ani_int typeInner; - env->Object_CallMethodByName_Int(type, "unboxed", ":i", &typeInner); - dataContext->iconType_ = static_cast(typeInner); - } - return CreateDrawableDescriptorbyId(env, dataContext); -} - -ani_object CreateDrawableDescriptorbyName(ani_env* env, std::unique_ptr& dataContext) -{ - auto resMgr = dataContext->addon_->GetResMgr(); - if (resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getDrawableDescriptorByName"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - Ace::Ani::DrawableInfo drawableInfo; - drawableInfo.density = dataContext->density_; - drawableInfo.manager = resMgr; - RState state = SUCCESS; - if (dataContext->iconType_ == 1) { - std::pair, size_t> foregroundInfo; - std::pair, size_t> backgroundInfo; - state = resMgr->GetThemeIcons(0, foregroundInfo, backgroundInfo, dataContext->density_); - if (state == SUCCESS) { - drawableInfo.firstBuffer.data = std::move(foregroundInfo.first); - drawableInfo.firstBuffer.len = foregroundInfo.second; - drawableInfo.secondBuffer.data = std::move(backgroundInfo.first); - drawableInfo.secondBuffer.len = backgroundInfo.second; - drawableInfo.type = "layered"; - return Ace::Ani::DrawableDescriptorAni::CreateDrawableDescriptor(env, drawableInfo); - } - } - - if (dataContext->iconType_ == 2) { // 2 means get the dynamic icon from theme - std::pair, size_t> iconInfo; - if (resMgr->GetDynamicIcon(dataContext->resName_, iconInfo, dataContext->density_) == SUCCESS) { - drawableInfo.firstBuffer.data = std::move(iconInfo.first); - drawableInfo.firstBuffer.len = iconInfo.second; - return Ace::Ani::DrawableDescriptorAni::CreateDrawableDescriptor(env, drawableInfo); - } - } - - state = resMgr->GetDrawableInfoByName(dataContext->resName_.c_str(), drawableInfo.type, - drawableInfo.firstBuffer.len, drawableInfo.firstBuffer.data, dataContext->density_); - if (SUCCESS != state) { - dataContext->SetErrorMsg("Failed to Create drawableDescriptor"); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - }; - return Ace::Ani::DrawableDescriptorAni::CreateDrawableDescriptor(env, drawableInfo); -} - -ani_object ResMgrAddon::GetDrawableDescriptorByName(ani_env* env, ani_object object, - ani_string resName, ani_object density, ani_object type) -{ - auto dataContext = std::make_unique(); - ani_boolean isUndefined; - env->Reference_IsUndefined(density, &isUndefined); - if (!isUndefined) { - ani_int densityInner; - env->Object_CallMethodByName_Int(density, "unboxed", ":i", &densityInner); - dataContext->density_ = static_cast(densityInner); - } - - env->Reference_IsUndefined(type, &isUndefined); - if (!isUndefined) { - ani_int typeInner; - env->Object_CallMethodByName_Int(type, "unboxed", ":i", &typeInner); - dataContext->iconType_ = static_cast(typeInner); - } - - dataContext->addon_ = UnwrapAddon(env, object); - if (dataContext->addon_ == nullptr) { - return nullptr; - } - dataContext->resName_ = AniStrToString(env, resName); - return CreateDrawableDescriptorbyName(env, dataContext); -} - -ani_object ResMgrAddon::GetStringArrayByNameSync(ani_env* env, ani_object object, ani_string resName) -{ - std::unique_ptr dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resName_ = AniStrToString(env, static_cast(resName)); - - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getStringArrayByNameSync"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - RState state = resMgr->GetStringArrayByName(dataContext->resName_.c_str(), dataContext->arrayValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("GetStringArrayByNameSync failed state", false); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniArray(env, dataContext->arrayValue_); -} - -static int GetScreenDensityIndex(ScreenDensity value) -{ - switch (value) { - case ScreenDensity::SCREEN_DENSITY_SDPI: return static_cast(ScreenDensityIndex::SCREEN_DENSITY_ONE); - case ScreenDensity::SCREEN_DENSITY_MDPI: return static_cast(ScreenDensityIndex::SCREEN_DENSITY_TWO); - case ScreenDensity::SCREEN_DENSITY_LDPI: return static_cast(ScreenDensityIndex::SCREEN_DENSITY_THREE); - case ScreenDensity::SCREEN_DENSITY_XLDPI: return static_cast(ScreenDensityIndex::SCREEN_DENSITY_FOUR); - case ScreenDensity::SCREEN_DENSITY_XXLDPI: return static_cast(ScreenDensityIndex::SCREEN_DENSITY_FIVE); - case ScreenDensity::SCREEN_DENSITY_XXXLDPI: return static_cast(ScreenDensityIndex::SCREEN_DENSITY_SIX); - default: return -1; - } -} - -static void SetEnumMember(ani_env *env, ani_object obj, const char* memberName, const char* enumName, const int index) -{ - int realIndex = index; - if (index < 0) { - RESMGR_HILOGE(RESMGR_TAG, "SetEnumMember: invalid index %{public}d, set index to zero.", index); - realIndex = 0; - } - - ani_enum aniEnum; - if (ANI_OK != env->FindEnum(enumName, &aniEnum)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find enum '%{public}s' failed", enumName); - return; - } - - ani_enum_item enumItem; - if (ANI_OK != env->Enum_GetEnumItemByIndex(aniEnum, realIndex, &enumItem)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Get enumItem '%{public}s' failed", enumName); - return; - } - - if (ANI_OK != env->Object_SetPropertyByName_Ref(obj, memberName, enumItem)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Set property '%{public}s' failed", enumName); - return; - } -} - -static std::string GetLocale(std::unique_ptr &cfg) -{ - std::string result; -#ifdef SUPPORT_GRAPHICS - const icu::Locale *localeInfo = cfg->GetLocaleInfo(); - if (localeInfo == nullptr) { - return result; - } - - const char *lang = localeInfo->getLanguage(); - if (lang == nullptr) { - return result; - } - result = lang; - - const char *script = localeInfo->getScript(); - if (script != nullptr) { - result += std::string("_") + script; - } - - const char *region = localeInfo->getCountry(); - if (region != nullptr) { - result += std::string("_") + region; - } -#endif - return result; -} - -static ani_object CreateConfig(ani_env* env, std::unique_ptr &cfg) -{ - static const char *className = "@ohos.resourceManager.resourceManager.Configuration"; - ani_class cls; - if (ANI_OK != env->FindClass(className, &cls)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class '%{public}s' failed", className); - return nullptr; - } - - ani_method ctor; - if (ANI_OK != env->Class_FindMethod(cls, "", nullptr, &ctor)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method '' failed"); - return nullptr; - } - - ani_object obj; - if (ANI_OK != env->Object_New(cls, ctor, &obj)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "New object '%{public}s' failed", className); - return nullptr; - } - - SetEnumMember(env, obj, "direction", "@ohos.resourceManager.resourceManager.Direction", - static_cast(cfg->GetDirection())); - SetEnumMember(env, obj, "deviceType", "@ohos.resourceManager.resourceManager.DeviceType", - static_cast(cfg->GetDeviceType())); - SetEnumMember(env, obj, "screenDensity", "@ohos.resourceManager.resourceManager.ScreenDensity", - GetScreenDensityIndex(cfg->GetScreenDensityDpi())); - SetEnumMember(env, obj, "colorMode", "@ohos.resourceManager.resourceManager.ColorMode", - static_cast(cfg->GetColorMode())); - - if (ANI_OK != env->Object_SetPropertyByName_Int(obj, "mcc", static_cast(cfg->GetMcc()))) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Set property 'mcc' failed"); - return obj; - } - - if (ANI_OK != env->Object_SetPropertyByName_Int(obj, "mnc", static_cast(cfg->GetMnc()))) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Set property 'mnc' failed"); - return obj; - } - - std::string value = GetLocale(cfg); - if (ANI_OK != env->Object_SetPropertyByName_Ref(obj, "locale", StringToAniStr(env, value))) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Set property 'locale' failed"); - return obj; - } - return obj; -} - -ani_object ResMgrAddon::GetConfigurationSync(ani_env* env, ani_object object) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - if (dataContext->addon_ == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in GetConfigurationSync"); - return nullptr; - } - - std::unique_ptr cfg(CreateResConfig()); - if (!cfg) { - dataContext->SetErrorMsg("Failed to create ResConfig object."); - return nullptr; - } - dataContext->addon_->GetResMgr()->GetResConfig(*cfg); - return CreateConfig(env, cfg); -} - -ani_object ResMgrAddon::GetDeviceCapabilitySync(ani_env* env, ani_object object) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - if (dataContext->addon_ == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in GetConfigurationSync"); - return nullptr; - } - - std::unique_ptr cfg(CreateResConfig()); - if (!cfg) { - dataContext->SetErrorMsg("Failed to create ResConfig object."); - return nullptr; - } - dataContext->addon_->GetResMgr()->GetResConfig(*cfg); - - static const char *className = "@ohos.resourceManager.resourceManager.DeviceCapability"; - ani_class cls; - if (ANI_OK != env->FindClass(className, &cls)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class '%{public}s' failed", className); - return nullptr; - } - - ani_method ctor; - if (ANI_OK != env->Class_FindMethod(cls, "", nullptr, &ctor)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method '' failed"); - return nullptr; - } - - ani_object obj; - if (ANI_OK != env->Object_New(cls, ctor, &obj)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "New object '%{public}s' failed", className); - return nullptr; - } - - SetEnumMember(env, obj, "screenDensity", "@ohos.resourceManager.resourceManager.ScreenDensity", - GetScreenDensityIndex(cfg->GetScreenDensityDpi())); - SetEnumMember(env, obj, "deviceType", "@ohos.resourceManager.resourceManager.DeviceType", - static_cast(cfg->GetDeviceType())); - return obj; -} - -ani_object ResMgrAddon::GetLocales(ani_env* env, ani_object object, ani_object includeSystem) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - if (dataContext->addon_ == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in GetConfigurationSync"); - return nullptr; - } - - ani_boolean isUndefined; - env->Reference_IsUndefined(includeSystem, &isUndefined); - if (!isUndefined) { - ani_boolean includeSys; - env->Object_CallMethodByName_Boolean(includeSystem, "unboxed", ":z", &includeSys); - dataContext->bValue_ = includeSys; - } - - dataContext->addon_->GetResMgr()->GetLocales(dataContext->arrayValue_, dataContext->bValue_); - return CreateAniArray(env, dataContext->arrayValue_); -} - -ani_long ResMgrAddon::GetSymbolById(ani_env* env, ani_object object, ani_long resId) -{ - std::unique_ptr dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - - std::shared_ptr resMgr = nullptr; - uint32_t notUse = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getSymbolById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - RState state = resMgr->GetSymbolById(resId, dataContext->symbolValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("GetSymbol failed state", true); - ResourceManagerAniUtils::AniThrow(env, state); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - return dataContext->symbolValue_; -} - -ani_long ResMgrAddon::GetSymbolByName(ani_env* env, ani_object object, ani_string resName) -{ - std::unique_ptr dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resName_ = AniStrToString(env, static_cast(resName)); - - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getSymbolByName"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - RState state = resMgr->GetSymbolByName(dataContext->resName_.c_str(), dataContext->symbolValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("GetSymbolByName failed state", false); - ResourceManagerAniUtils::AniThrow(env, state); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - return dataContext->symbolValue_; -} - -ani_boolean ResMgrAddon::IsRawDir(ani_env* env, ani_object object, ani_string path) -{ - std::unique_ptr dataContext = std::make_unique(); - dataContext->path_ = AniStrToString(env, path); - dataContext->addon_ = UnwrapAddon(env, object); - - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in isRawDir"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return false; - } - - RState state = resMgr->IsRawDirFromHap(dataContext->path_, dataContext->bValue_); - if (state != RState::SUCCESS) { - RESMGR_HILOGE(RESMGR_ANI_TAG, - "Failed to determine the raw file is directory by %{public}s", dataContext->path_.c_str()); - ResourceManagerAniUtils::AniThrow(env, state); - return false; - } - return dataContext->bValue_; -} - -static bool GetEnumMember(ani_env *env, ani_object options, const std::string name, int& member) -{ - ani_ref ref; - if (ANI_OK != env->Object_GetPropertyByName_Ref(options, name.c_str(), &ref)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Get property '%{public}s' failed", name.c_str()); - return false; - } - - ani_boolean isUndefined; - env->Reference_IsUndefined(ref, &isUndefined); - if (isUndefined) { - return false; - } - - if (ANI_OK != env->EnumItem_GetValue_Int(static_cast(ref), &member)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Enum '%{public}s' get value int failed", name.c_str()); - return false; - } - return true; -} - -static bool GetNumberMember(ani_env *env, ani_object options, const std::string name, int& value) -{ - if (ANI_OK != env->Object_GetPropertyByName_Int(options, name.c_str(), &value)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Get property '%{public}s' failed", name.c_str()); - return false; - } - return true; -} - -static bool GetEnumParamOfConfig(ani_env* env, std::shared_ptr configPtr, ani_object configuration) -{ - int intEnum; - if (GetEnumMember(env, configuration, "direction", intEnum)) { - configPtr->SetDirection(static_cast(intEnum)); - } - if (GetEnumMember(env, configuration, "deviceType", intEnum)) { - configPtr->SetDeviceType(static_cast(intEnum)); - } - if (GetEnumMember(env, configuration, "screenDensity", intEnum)) { - configPtr->SetScreenDensityDpi(static_cast(intEnum)); - } - if (GetEnumMember(env, configuration, "colorMode", intEnum)) { - configPtr->SetColorMode(static_cast(intEnum)); - } - - int value; - if (GetNumberMember(env, configuration, "mcc", value)) { - configPtr->SetMcc(value); - } - if (GetNumberMember(env, configuration, "mnc", value)) { - configPtr->SetMnc(value); - } - return true; -} - -static bool GetLocaleOfConfig(ani_env* env, std::shared_ptr configPtr, ani_object configuration) -{ -#ifdef SUPPORT_GRAPHICS - ani_ref ret; - if (ANI_OK != env->Object_GetPropertyByName_Ref(configuration, "locale", &ret)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Get property 'locale' failed"); - return false; - } - if (ret == nullptr) { - RESMGR_HILOGD(RESMGR_JS_TAG, "GetLocaleOfConfig property locale not set"); - return true; - } - if (configPtr->SetLocaleInfo(AniStrToString(env, static_cast(ret)).c_str()) != SUCCESS) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "GetLocaleOfConfig failed to SetLocaleInfo"); - return false; - } -#endif - return true; -} - -static RState GetAddonAndConfig(ani_env* env, ani_object object, - ani_object configuration, std::unique_ptr &dataContext) -{ - dataContext->addon_ = UnwrapAddon(env, object); - if (dataContext->addon_ == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "GetAddonAndConfig failed to get addon"); - return ERROR_CODE_INVALID_INPUT_PARAMETER; - } - - ani_boolean isUndefined; - env->Reference_IsUndefined(configuration, &isUndefined); - if (isUndefined) { - RESMGR_HILOGD(RESMGR_ANI_TAG, "GetConfigObject, no config"); - return SUCCESS; - } - - ResConfig *config = CreateDefaultResConfig(); - if (config == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "GetConfigObject, new config failed"); - return ERROR_CODE_INVALID_INPUT_PARAMETER; - } - dataContext->overrideResConfig_.reset(config); - - if (!GetEnumParamOfConfig(env, dataContext->overrideResConfig_, configuration)) { - return ERROR_CODE_INVALID_INPUT_PARAMETER; - } - if (!GetLocaleOfConfig(env, dataContext->overrideResConfig_, configuration)) { - return ERROR_CODE_INVALID_INPUT_PARAMETER; - } - return SUCCESS; -} - -ani_object ResMgrAddon::CreateOverrideAddon(ani_env* env, const std::shared_ptr& resMgr) -{ - std::shared_ptr addon = std::make_shared(bundleName_, resMgr, context_); - addon->isOverrideAddon_ = true; - return WrapResourceManager(env, addon); -} - -ani_object ResMgrAddon::GetOverrideResourceManager(ani_env* env, ani_object object, ani_object configuration) -{ - auto dataContext = std::make_unique(); - int32_t state = GetAddonAndConfig(env, object, configuration, dataContext); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to get param in GetOverrideResourceManager", false); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - - std::shared_ptr resMgr = dataContext->addon_->GetResMgr(); - if (resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getOverrideResourceManager"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - std::shared_ptr overrideResMgr = resMgr->GetOverrideResourceManager( - dataContext->overrideResConfig_); - if (overrideResMgr == nullptr) { - dataContext->SetErrorMsg("GetOverrideResourceManager, overrideResMgr is null", false); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER); - return nullptr; - } - - return dataContext->addon_->CreateOverrideAddon(env, overrideResMgr); -} - -ani_object ResMgrAddon::GetOverrideConfiguration(ani_env* env, ani_object object) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - if (dataContext->addon_ == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "GetOverrideConfiguration failed to get addon"); - return nullptr; - } - - std::unique_ptr cfg(CreateResConfig()); - if (!cfg) { - dataContext->SetErrorMsg("Failed to create ResConfig object."); - return nullptr; - } - dataContext->addon_->GetResMgr()->GetOverrideResConfig(*cfg); - return CreateConfig(env, cfg); -} - -void ResMgrAddon::UpdateOverrideConfiguration(ani_env* env, ani_object object, ani_object configuration) -{ - auto dataContext = std::make_unique(); - int32_t state = GetAddonAndConfig(env, object, configuration, dataContext); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to get param in GetOverrideResourceManager", false); - ResourceManagerAniUtils::AniThrow(env, state); - return; - } - - std::shared_ptr resMgr = dataContext->addon_->GetResMgr(); - if (resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in updateOverrideConfiguration"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return; - } - - state = resMgr->UpdateOverrideResConfig(*dataContext->overrideResConfig_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("UpdateOverrideConfiguration failed due to invalid config", false); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER); - return; - } -} - -ani_ref ResMgrAddon::TransferToDynamicResource(ani_env *env, ani_object input) -{ - std::shared_ptr addon = UnwrapAddon(env, input); - if (addon == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "UnwrapAddon failed."); - return nullptr; - } - std::shared_ptr resMgr = addon->GetResMgr(); - if (resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "resMgr is null."); - return nullptr; - } - std::shared_ptr resourceManagerAddon = std::make_shared(resMgr, true); - - ani_ref resAny; - { - napi_env jsenv; - if (!arkts_napi_scope_open(env, &jsenv)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "arkts_napi_scope_open failed."); - return nullptr; - } - napi_value resNapi = ResourceManagerAddon::WrapResourceManager(jsenv, resourceManagerAddon); - if (!arkts_napi_scope_close_n(jsenv, NUM_NAPI_VALUES_TO_WRAP, &resNapi, &resAny)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "arkts_napi_scope_close_n failed."); - return nullptr; - } - } - return resAny; -} - -ani_object ResMgrAddon::TransferToStaticResource(ani_env *env, ani_object esValue) -{ - void *nativePtr = nullptr; - if (!arkts_esvalue_unwrap(env, esValue, &nativePtr) || nativePtr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "arkts_esvalue_unwrap failed."); - return nullptr; - } - std::shared_ptr addon = *reinterpret_cast*>(nativePtr); - if (addon == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "reinterpret_cast failed."); - return nullptr; - } - std::shared_ptr resMgr = addon->GetResMgr(); - if (resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "GetResMgr failed."); - return nullptr; - } - std::shared_ptr resMgrAddon = std::make_shared(resMgr, true); - return WrapResourceManager(env, resMgrAddon); -} - -ani_status ResMgrAddon::BindContext(ani_env* env) -{ - static const char* className = "@ohos.resourceManager.resourceManager.ResourceManagerInner"; - ani_class cls; - if (ANI_OK != env->FindClass(className, &cls)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class '%{public}s' failed", className); - return (ani_status)ANI_ERROR; - } - - if (ANI_OK != env->Class_BindNativeMethods(cls, methods.data(), methods.size())) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Cannot bind native methods to '%{public}s'", className); - return (ani_status)ANI_ERROR; - }; - - static const char* nameSpaceName = "@ohos.resourceManager.resourceManager"; - ani_namespace ns; - if (ANI_OK != env->FindNamespace(nameSpaceName, &ns)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Find namespace '%{public}s' failed", nameSpaceName); - return (ani_status)ANI_ERROR; - } - - std::array nsMethods = { - ani_native_function { "getSysResourceManager", nullptr, reinterpret_cast(GetSysResourceManager) }, - ani_native_function{ "transferToDynamicResource", nullptr, - reinterpret_cast(TransferToDynamicResource) }, - ani_native_function{ "transferToStaticResource", nullptr, reinterpret_cast(TransferToStaticResource) }, - }; - - if (ANI_OK != env->Namespace_BindNativeFunctions(ns, nsMethods.data(), nsMethods.size())) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Cannot bind native methods to '%{public}s'", nameSpaceName); - return (ani_status)ANI_ERROR; - }; - return ANI_OK; -} +} // namespace Resource +} // namespace Global +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/ets/ani/resourceManager/src/resource_manager_ani_utils.cpp b/interfaces/ets/ani/resourceManager/src/resource_manager_ani_utils.cpp deleted file mode 100644 index 4291e7c..0000000 --- a/interfaces/ets/ani/resourceManager/src/resource_manager_ani_utils.cpp +++ /dev/null @@ -1,90 +0,0 @@ -/* - * 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 "resource_manager_ani_utils.h" - -#include "hilog_wrapper.h" -#include "rstate.h" - -using namespace OHOS; -using namespace Global; -using namespace Resource; - -static const char* CLASS_NAME_BUSINESSERROR = "@ohos.base.BusinessError"; - -const std::unordered_map ResourceManagerAniUtils::ErrorCodeToMsg { - {ERROR_CODE_INVALID_INPUT_PARAMETER, "Invalid input parameter"}, - {ERROR_CODE_RES_ID_NOT_FOUND, "Invalid resource ID"}, - {ERROR_CODE_RES_NAME_NOT_FOUND, "Invalid resource name"}, - {ERROR_CODE_RES_NOT_FOUND_BY_ID, "No matching resource is found based on the resource ID"}, - {ERROR_CODE_RES_NOT_FOUND_BY_NAME, "No matching resource is found based on the resource name"}, - {ERROR_CODE_RES_PATH_INVALID, "Invalid relative path"}, - {ERROR_CODE_RES_REF_TOO_MUCH, "The resource is referenced cyclically"}, - {ERROR_CODE_RES_ID_FORMAT_ERROR, "Failed to format the resource obtained based on the resource ID"}, - {ERROR_CODE_RES_NAME_FORMAT_ERROR, "Failed to format the resource obtained based on the resource Name"}, - {ERROR_CODE_SYSTEM_RES_MANAGER_GET_FAILED, "Failed to access the system resource"}, - {ERROR_CODE_OVERLAY_RES_PATH_INVALID, "Invalid overlay path"}, - {ERROR, "Unknow error"} -}; - -std::string ResourceManagerAniUtils::FindErrMsg(int32_t errCode) -{ - auto iter = ResourceManagerAniUtils::ErrorCodeToMsg.find(errCode); - std::string errMsg = iter != ResourceManagerAniUtils::ErrorCodeToMsg.end() ? iter->second : ""; - return errMsg; -} - -void ResourceManagerAniUtils::ThrowAniError(ani_env *env, ani_int code, const std::string &message) -{ - ani_class cls {}; - if (ANI_OK != env->FindClass(CLASS_NAME_BUSINESSERROR, &cls)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "find class %{public}s failed", CLASS_NAME_BUSINESSERROR); - return; - } - ani_method ctor {}; - if (ANI_OK != env->Class_FindMethod(cls, "", ":V", &ctor)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "find method BusinessError constructor failed"); - return; - } - ani_object error {}; - if (ANI_OK != env->Object_New(cls, ctor, &error)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "new object %{public}s failed", CLASS_NAME_BUSINESSERROR); - return; - } - if (ANI_OK != env->Object_SetPropertyByName_Int(error, "code", code)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "set property BusinessError.code failed"); - return; - } - ani_string messageRef {}; - if (ANI_OK != env->String_NewUTF8(message.c_str(), message.size(), &messageRef)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "new message string failed"); - return; - } - if (ANI_OK != env->Object_SetPropertyByName_Ref(error, "message", static_cast(messageRef))) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "set property BusinessError.message failed"); - return; - } - if (ANI_OK != env->ThrowError(static_cast(error))) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "throwError ani_error object failed"); - } -} - -void ResourceManagerAniUtils::AniThrow(ani_env *env, int32_t errCode) -{ - std::string errMsg = FindErrMsg(errCode); - if (errMsg != "") { - ThrowAniError(env, errCode, errMsg); - } -} diff --git a/interfaces/js/innerkits/core/include/resource_manager_addon.h b/interfaces/js/innerkits/core/include/resource_manager_addon.h index f38f4a6..eb4b9b9 100644 --- a/interfaces/js/innerkits/core/include/resource_manager_addon.h +++ b/interfaces/js/innerkits/core/include/resource_manager_addon.h @@ -49,6 +49,9 @@ public: ResourceManagerAddon(const std::shared_ptr& resMgr, bool isSystem = false); + ResourceManagerAddon(const std::shared_ptr& resMgr, + const std::shared_ptr& context, bool isSystem, bool isOverride); + static napi_value GetSystemResMgr(napi_env env); static napi_value GetSysResourceManager(napi_env env); diff --git a/interfaces/js/innerkits/core/src/resource_manager_addon.cpp b/interfaces/js/innerkits/core/src/resource_manager_addon.cpp index 45b0672..f065ed4 100644 --- a/interfaces/js/innerkits/core/src/resource_manager_addon.cpp +++ b/interfaces/js/innerkits/core/src/resource_manager_addon.cpp @@ -113,6 +113,14 @@ ResourceManagerAddon::ResourceManagerAddon( napiContext_ = std::make_shared(); } +ResourceManagerAddon::ResourceManagerAddon(const std::shared_ptr& resMgr, + const std::shared_ptr& context, bool isSystem, bool isOverride) + : resMgr_(resMgr), context_(context), isSystem_(isSystem), isOverrideAddon_(isOverride) +{ + RESMGR_HILOGD(RESMGR_JS_TAG, "create ResourceManagerAddon, ets to js."); + napiContext_ = std::make_shared(); +} + ResourceManagerAddon::ResourceManagerAddon(const std::shared_ptr& resMgr, bool isSystem) : resMgr_(resMgr), isSystem_(isSystem) { -- Gitee