diff --git a/bundle.json b/bundle.json index 516b163ee8..e54997537b 100644 --- a/bundle.json +++ b/bundle.json @@ -56,6 +56,7 @@ "dlp_permission_service", "dsoftbus", "eventhandler", + "ets_frontend", "ets_runtime", "ets_utils", "faultloggerd", @@ -83,8 +84,10 @@ "memory_utils", "napi", "netmanager_base", + "node", "os_account", "power_manager", + "preferences", "qos_manager", "relational_store", "resource_management", diff --git a/frameworks/c/ability_runtime/BUILD.gn b/frameworks/c/ability_runtime/BUILD.gn index 450ebd4920..1af0b60762 100644 --- a/frameworks/c/ability_runtime/BUILD.gn +++ b/frameworks/c/ability_runtime/BUILD.gn @@ -52,6 +52,7 @@ ohos_shared_library("ability_runtime") { external_deps = [ "c_utils:utils", "hilog:libhilog", + "ipc:ipc_core", ] output_extension = "so" diff --git a/frameworks/cj/ffi/BUILD.gn b/frameworks/cj/ffi/BUILD.gn index 22f7ef8fd3..9d1ec10aa5 100644 --- a/frameworks/cj/ffi/BUILD.gn +++ b/frameworks/cj/ffi/BUILD.gn @@ -43,7 +43,9 @@ ohos_shared_library("cj_ability_ffi") { "ability_base:want", "bundle_framework:appexecfwk_core", "c_utils:utils", + "eventhandler:libeventhandler", "hilog:libhilog", + "ipc:ipc_core", "napi:cj_bind_ffi", "napi:cj_bind_native", ] diff --git a/frameworks/cj/ffi/ark_interop_helper/BUILD.gn b/frameworks/cj/ffi/ark_interop_helper/BUILD.gn index bf0cc02472..e07419e960 100644 --- a/frameworks/cj/ffi/ark_interop_helper/BUILD.gn +++ b/frameworks/cj/ffi/ark_interop_helper/BUILD.gn @@ -20,7 +20,10 @@ ohos_shared_library("ark_interop_helper_ffi") { sources = [ "ark_interop_helper.cpp" ] external_deps = [ + "bundle_framework:appexecfwk_base", + "c_utils:utils", "ets_runtime:libark_jsruntime", + "eventhandler:libeventhandler", "hilog:libhilog", "napi:ace_napi", "napi:ark_interop", diff --git a/frameworks/js/napi/ability_auto_startup_callback/BUILD.gn b/frameworks/js/napi/ability_auto_startup_callback/BUILD.gn index 477aeb266d..876ebd20ad 100644 --- a/frameworks/js/napi/ability_auto_startup_callback/BUILD.gn +++ b/frameworks/js/napi/ability_auto_startup_callback/BUILD.gn @@ -40,9 +40,11 @@ ohos_shared_library("autostartupcallback") { external_deps = [ "ability_base:session_info", "c_utils:utils", + "eventhandler:libeventhandler", "hilog:libhilog", "ipc:ipc_core", "napi:ace_napi", + "window_manager:libwm", ] if (ability_runtime_graphics) { diff --git a/frameworks/js/napi/ability_auto_startup_manager/BUILD.gn b/frameworks/js/napi/ability_auto_startup_manager/BUILD.gn index 8fd346403f..964d6e3fe9 100644 --- a/frameworks/js/napi/ability_auto_startup_manager/BUILD.gn +++ b/frameworks/js/napi/ability_auto_startup_manager/BUILD.gn @@ -41,10 +41,10 @@ ohos_shared_library("autostartupmanager") { ] external_deps = [ - "ability_base:session_info", "access_token:libtokenid_sdk", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", "hilog:libhilog", "ipc:ipc_core", "napi:ace_napi", diff --git a/frameworks/js/napi/app/ability_delegator/BUILD.gn b/frameworks/js/napi/app/ability_delegator/BUILD.gn index 1af4ab7730..3d475bd072 100644 --- a/frameworks/js/napi/app/ability_delegator/BUILD.gn +++ b/frameworks/js/napi/app/ability_delegator/BUILD.gn @@ -50,10 +50,13 @@ template("delegator") { external_deps = [ "ability_base:want", + "bundle_framework:appexecfwk_base", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", "hilog:libhilog", "hitrace:hitrace_meter", + "ipc:ipc_napi", "napi:ace_napi", ] diff --git a/frameworks/js/napi/app/app_manager/BUILD.gn b/frameworks/js/napi/app/app_manager/BUILD.gn index f88d33ccb9..34cf5af97d 100644 --- a/frameworks/js/napi/app/app_manager/BUILD.gn +++ b/frameworks/js/napi/app/app_manager/BUILD.gn @@ -42,6 +42,7 @@ ohos_shared_library("appmanager_napi") { external_deps = [ "c_utils:utils", "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", "hilog:libhilog", "ipc:ipc_core", "napi:ace_napi", diff --git a/frameworks/js/napi/app/js_app_manager/BUILD.gn b/frameworks/js/napi/app/js_app_manager/BUILD.gn index ec4399628d..c64fa1cf9f 100644 --- a/frameworks/js/napi/app/js_app_manager/BUILD.gn +++ b/frameworks/js/napi/app/js_app_manager/BUILD.gn @@ -49,6 +49,8 @@ ohos_shared_library("appmanager") { external_deps = [ "c_utils:utils", "common_event_service:cesfwk_innerkits", + "ets_runtime:libark_jsruntime", + "eventhandler:libeventhandler", "hilog:libhilog", "ipc:ipc_core", "napi:ace_napi", diff --git a/frameworks/js/napi/app/recovery/BUILD.gn b/frameworks/js/napi/app/recovery/BUILD.gn index 4239c612ef..757c0f0e6e 100644 --- a/frameworks/js/napi/app/recovery/BUILD.gn +++ b/frameworks/js/napi/app/recovery/BUILD.gn @@ -46,6 +46,7 @@ ohos_shared_library("apprecovery_napi") { "ability_base:want", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", "hilog:libhilog", "napi:ace_napi", ] diff --git a/frameworks/js/napi/app/sendable_context_manager/BUILD.gn b/frameworks/js/napi/app/sendable_context_manager/BUILD.gn index da2ae4af2d..4a428dec7e 100644 --- a/frameworks/js/napi/app/sendable_context_manager/BUILD.gn +++ b/frameworks/js/napi/app/sendable_context_manager/BUILD.gn @@ -52,6 +52,7 @@ ohos_shared_library("sendablecontextmanager_napi") { "ability_base:want", "bundle_framework:appexecfwk_base", "c_utils:utils", + "eventhandler:libeventhandler", "hilog:libhilog", "napi:ace_napi", ] diff --git a/frameworks/js/napi/app_startup/startup_manager/BUILD.gn b/frameworks/js/napi/app_startup/startup_manager/BUILD.gn index 0ee3be5d5a..3724f9e454 100644 --- a/frameworks/js/napi/app_startup/startup_manager/BUILD.gn +++ b/frameworks/js/napi/app_startup/startup_manager/BUILD.gn @@ -46,6 +46,9 @@ ohos_shared_library("startupmanager_napi") { ] external_deps = [ + "c_utils:utils", + "ets_runtime:libark_jsruntime", + "eventhandler:libeventhandler", "hilog:libhilog", "napi:ace_napi", ] diff --git a/frameworks/js/napi/auto_fill_manager/BUILD.gn b/frameworks/js/napi/auto_fill_manager/BUILD.gn index 3cf609afa7..18a9d7e7b8 100644 --- a/frameworks/js/napi/auto_fill_manager/BUILD.gn +++ b/frameworks/js/napi/auto_fill_manager/BUILD.gn @@ -37,7 +37,12 @@ ohos_shared_library("autofillmanager_napi") { external_deps = [ "ability_base:view_data", + "ability_base:want", + "c_utils:utils", + "eventhandler:libeventhandler", "hilog:libhilog", + "ipc:ipc_core", + "json:nlohmann_json_static", "napi:ace_napi", ] diff --git a/frameworks/js/napi/dialog_request_info/BUILD.gn b/frameworks/js/napi/dialog_request_info/BUILD.gn index faad70ebf1..2ea20b912d 100755 --- a/frameworks/js/napi/dialog_request_info/BUILD.gn +++ b/frameworks/js/napi/dialog_request_info/BUILD.gn @@ -34,6 +34,7 @@ ohos_shared_library("dialog_request_info") { "ability_base:want", "c_utils:utils", "hilog:libhilog", + "ipc:ipc_core", "napi:ace_napi", ] diff --git a/frameworks/js/napi/featureAbility/BUILD.gn b/frameworks/js/napi/featureAbility/BUILD.gn index b25a7e483c..7023b33af6 100644 --- a/frameworks/js/napi/featureAbility/BUILD.gn +++ b/frameworks/js/napi/featureAbility/BUILD.gn @@ -67,20 +67,17 @@ ohos_shared_library("featureability") { } if (ability_runtime_relational) { - include_dirs += [ - "${relational_store_napi_path}/common/include", - "${relational_store_napi_path}/dataability/include", - "${relational_store_napi_path}/rdb/include", - ] + include_dirs += [ "data_ability/include" ] sources += [ - "${relational_store_napi_path}/common/src/js_df_manager.cpp", - "${relational_store_napi_path}/common/src/js_utils.cpp", - "${relational_store_napi_path}/dataability/src/napi_data_ability_predicates.cpp", - "${relational_store_napi_path}/rdb/src/napi_rdb_js_utils.cpp", - "${relational_store_napi_path}/rdb/src/napi_result_set.cpp", + "data_ability/js_utils.cpp", + "data_ability/napi_data_ability_predicates.cpp", + "data_ability/napi_rdb_js_utils.cpp", + "data_ability/napi_result_set.cpp", ] external_deps += [ + "eventhandler:libeventhandler", "kv_store:distributeddata_mgr", + "relational_store:native_appdatafwk", "relational_store:native_dataability", "relational_store:native_rdb", "relational_store:rdb_data_share_adapter", diff --git a/frameworks/js/napi/featureAbility/data_ability/include/js_utils.h b/frameworks/js/napi/featureAbility/data_ability/include/js_utils.h new file mode 100644 index 0000000000..920cfd17bc --- /dev/null +++ b/frameworks/js/napi/featureAbility/data_ability/include/js_utils.h @@ -0,0 +1,363 @@ +/* + * Copyright (c) 2021 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 DISTRIBUTEDDATAMGR_APPDATAMGR_JSUTILS_H +#define DISTRIBUTEDDATAMGR_APPDATAMGR_JSUTILS_H + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "napi/native_api.h" +#include "napi/native_common.h" +#include "napi/native_node_api.h" + +namespace OHOS { +namespace AppDataMgrJsKit { +namespace JSUtils { +#define DECLARE_JS_PROPERTY(env, key, value) \ + napi_property_descriptor(DECLARE_NAPI_DEFAULT_PROPERTY((key), Convert2JSValue((env), (value)))) + +#define ASSERT(condition, message, retVal) \ + do { \ + if (!(condition)) { \ + LOG_ERROR("test (" #condition ") failed: " message); \ + return retVal; \ + } \ + } while (0) +static constexpr int OK = 0; +static constexpr int ERR = -1; +static constexpr uint32_t ASYNC_RST_SIZE = 2; +static constexpr uint32_t DEFAULT_VALUE_LENGTH = 1024; +static constexpr uint32_t MAX_VALUE_LENGTH = 1024 * 1024 * 8; // the max length of all kand of out string value +static constexpr uint32_t SYNC_RESULT_ELEMENT_NUM = 2; +struct JsFeatureSpace { + const char *spaceName; + const char *nameBase64; + bool isComponent; +}; + +void SetHapVersion(int32_t hapversion); +int32_t GetHapVersion(); + +int32_t Convert2Value(napi_env env, napi_value jsValue, napi_value &output); +int32_t Convert2Value(napi_env env, napi_value jsValue, bool &output); +int32_t Convert2Value(napi_env env, napi_value jsValue, double &output); +int32_t Convert2Value(napi_env env, napi_value jsValue, int64_t &output); +int32_t Convert2Value(napi_env env, napi_value jsValue, std::string &output); +int32_t Convert2Value(napi_env env, napi_value jsValue, std::vector &output); +int32_t Convert2Value(napi_env env, napi_value jsValue, std::vector &output); +int32_t Convert2Value(napi_env env, napi_value jsValue, std::monostate &value); +int32_t Convert2Value(napi_env env, napi_value jsValue, std::map &output); +int32_t Convert2Value(napi_env env, napi_value jsValue, std::map &output); + +bool IsNull(napi_env env, napi_value value); + +bool Equal(napi_env env, napi_ref ref, napi_value value); + +template +int32_t Convert2Value(napi_env env, napi_value jsValue, T &output); + +template +int32_t Convert2ValueExt(napi_env env, napi_value jsValue, T &output); + +int32_t Convert2ValueExt(napi_env env, napi_value jsValue, uint32_t &output); +int32_t Convert2ValueExt(napi_env env, napi_value jsValue, int32_t &output); +int32_t Convert2ValueExt(napi_env env, napi_value jsValue, int64_t &output); + +template +int32_t Convert2Value(napi_env env, napi_value jsValue, std::vector &value); + +template +int32_t Convert2Value(napi_env env, napi_value jsValue, std::map &value); + +template +int32_t Convert2Value(napi_env env, napi_value jsValue, std::variant &value); + +using Descriptor = std::function()>; +const std::optional GetJsFeatureSpace(const std::string &name); +/* napi_define_class wrapper */ +napi_value DefineClass(napi_env env, const std::string &spaceName, const std::string &className, + const Descriptor &descriptor, napi_callback ctor); +napi_value GetClass(napi_env env, const std::string &spaceName, const std::string &className); +std::string Convert2String(napi_env env, napi_value jsStr); + +int32_t Convert2JSValue(napi_env env, std::string value, napi_value &output); +int32_t Convert2JSValue(napi_env env, bool value, napi_value &output); +int32_t Convert2JSValue(napi_env env, double value, napi_value &output); + +napi_value Convert2JSValue(napi_env env, const std::string &value); +napi_value Convert2JSValue(napi_env env, const std::vector &value); +napi_value Convert2JSValue(napi_env env, const std::vector &value); +napi_value Convert2JSValue(napi_env env, int32_t value); +napi_value Convert2JSValue(napi_env env, uint32_t value); +napi_value Convert2JSValue(napi_env env, int64_t value); +napi_value Convert2JSValue(napi_env env, double value); +napi_value Convert2JSValue(napi_env env, bool value); +napi_value Convert2JSValue(napi_env env, const std::map &value); +napi_value Convert2JSValue(napi_env env, const std::monostate &value); + +template +napi_value Convert2JSValue(napi_env env, const T &value); + +template +napi_value Convert2JSValue(napi_env env, const std::vector &value); + +template +napi_value Convert2JSValue(napi_env env, const std::map &value); + +template +napi_value Convert2JSValue(napi_env env, const std::tuple &value); + +template +napi_value Convert2JSValue(napi_env env, const std::variant &value); + +template +std::string ToString(const T &key); + +template +std::enable_if_t, std::string> ConvertMapKey(const K &key) +{ + return ToString(key); +} + +template +std::enable_if_t, const std::string &> ConvertMapKey(const K &key) +{ + return key; +} + +template +int32_t GetCPPValue(napi_env env, napi_value jsValue, T &value) +{ + return napi_invalid_arg; +} + +template +int32_t GetCPPValue(napi_env env, napi_value jsValue, T &value) +{ + First cValue; + auto ret = Convert2Value(env, jsValue, cValue); + if (ret == napi_ok) { + value = cValue; + return ret; + } + return GetCPPValue(env, jsValue, value); +} + +template +napi_value GetJSValue(napi_env env, const T &value) +{ + return nullptr; +} + +template +napi_value GetJSValue(napi_env env, const T &value) +{ + auto *val = std::get_if(&value); + if (val != nullptr) { + return Convert2JSValue(env, *val); + } + return GetJSValue(env, value); +} + +std::pair GetInnerValue(napi_env env, napi_value in, const std::string &prop, bool optional); + +template +inline std::enable_if_t || std::is_same_v, int32_t> GetNamedProperty( + napi_env env, napi_value in, const std::string &prop, T &value, bool optional = false) +{ + auto [status, jsValue] = GetInnerValue(env, in, prop, optional); + if (jsValue == nullptr) { + return status; + } + return Convert2ValueExt(env, jsValue, value); +}; + +template +inline std::enable_if_t && !std::is_same_v, int32_t> GetNamedProperty( + napi_env env, napi_value in, const std::string &prop, T &value, bool optional = false) +{ + auto [status, jsValue] = GetInnerValue(env, in, prop, optional); + if (jsValue == nullptr) { + return status; + } + return Convert2Value(env, jsValue, value); +}; + +template +inline int32_t SetNamedProperty(napi_env env, napi_value in, const std::string &prop, T value) +{ + return napi_set_named_property(env, in, prop.c_str(), Convert2JSValue(env, value)); +}; + +napi_value ToJsObject(napi_env env, napi_value sendableValue); +napi_value ToJsArray(napi_env env, napi_value sendableValue); +napi_value ToJsTypedArray(napi_env env, napi_value sendableValue); +napi_value Convert2JSValue(napi_env env, napi_value sendableValue); +} // namespace JSUtils + +template +int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, std::vector &value) +{ + bool isArray = false; + napi_is_array(env, jsValue, &isArray); + if (!isArray) { + return napi_invalid_arg; + } + + uint32_t arrLen = 0; + napi_get_array_length(env, jsValue, &arrLen); + if (arrLen == 0) { + return napi_ok; + } + + for (size_t i = 0; i < arrLen; ++i) { + napi_value element; + napi_get_element(env, jsValue, i, &element); + T item; + auto status = Convert2Value(env, element, item); + if (status != napi_ok) { + return napi_invalid_arg; + } + value.push_back(std::move(item)); + } + return napi_ok; +} + +template +int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, std::map &value) +{ + napi_value jsMapList = nullptr; + uint32_t jsCount = 0; + napi_status status = napi_get_property_names(env, jsValue, &jsMapList); + if (status != napi_ok) { + return napi_invalid_arg; + } + status = napi_get_array_length(env, jsMapList, &jsCount); + if (status != napi_ok || jsCount <= 0) { + return napi_invalid_arg; + } + napi_value jsKey = nullptr; + napi_value jsVal = nullptr; + for (uint32_t index = 0; index < jsCount; index++) { + status = napi_get_element(env, jsMapList, index, &jsKey); + if (status != napi_ok) { + return napi_invalid_arg; + } + std::string key; + int ret = Convert2Value(env, jsKey, key); + if (status != napi_ok) { + return napi_invalid_arg; + } + status = napi_get_property(env, jsValue, jsKey, &jsVal); + if (status != napi_ok || jsVal == nullptr) { + return napi_invalid_arg; + } + T val; + ret = Convert2Value(env, jsVal, val); + if (status != napi_ok) { + return napi_invalid_arg; + } + value.insert(std::pair(key, val)); + } + return napi_ok; +} + +template +napi_value JSUtils::Convert2JSValue(napi_env env, const std::map &value) +{ + napi_value jsValue; + napi_status status = napi_create_object(env, &jsValue); + if (status != napi_ok) { + return nullptr; + } + + for (const auto &[key, val] : value) { + const std::string &name = ConvertMapKey(key); + status = napi_set_named_property(env, jsValue, name.c_str(), Convert2JSValue(env, val)); + if (status != napi_ok) { + return nullptr; + } + } + return jsValue; +} + +template +napi_value JSUtils::Convert2JSValue(napi_env env, const std::tuple &value) +{ + napi_value jsValue; + napi_status status = napi_create_object(env, &jsValue); + if (status != napi_ok) { + return nullptr; + } + napi_value code = Convert2JSValue(env, std::get<0>(value)); + napi_value description = Convert2JSValue(env, std::get<1>(value)); + napi_value val = Convert2JSValue(env, std::get<2>(value)); + if (description == nullptr || val == nullptr) { + return nullptr; + } + napi_set_named_property(env, jsValue, "code", code); + napi_set_named_property(env, jsValue, "description", description); + napi_set_named_property(env, jsValue, "value", val); + return jsValue; +} + +template +int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, std::variant &value) +{ + napi_valuetype type = napi_undefined; + napi_status status = napi_typeof(env, jsValue, &type); + if (status != napi_ok) { + return napi_invalid_arg; + } + if (type == napi_undefined) { + return napi_generic_failure; + } + + return GetCPPValue(env, jsValue, value); +} + +template +napi_value JSUtils::Convert2JSValue(napi_env env, const std::vector &value) +{ + napi_value jsValue; + napi_status status = napi_create_array_with_length(env, value.size(), &jsValue); + if (status != napi_ok) { + return nullptr; + } + + for (size_t i = 0; i < value.size(); ++i) { + napi_set_element(env, jsValue, i, Convert2JSValue(env, value[i])); + } + return jsValue; +} + +template +napi_value JSUtils::Convert2JSValue(napi_env env, const std::variant &value) +{ + return GetJSValue(env, value); +} +} // namespace AppDataMgrJsKit +} // namespace OHOS +#endif // DISTRIBUTEDDATAMGR_APPDATAMGR_JSUTILS_H \ No newline at end of file diff --git a/frameworks/js/napi/featureAbility/data_ability/include/napi_async_proxy.h b/frameworks/js/napi/featureAbility/data_ability/include/napi_async_proxy.h new file mode 100644 index 0000000000..d04c84b58c --- /dev/null +++ b/frameworks/js/napi/featureAbility/data_ability/include/napi_async_proxy.h @@ -0,0 +1,177 @@ +/* + * Copyright (c) 2021 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 PREFERENCES_JSKIT_NAPI_ASYNC_PROXY_H +#define PREFERENCES_JSKIT_NAPI_ASYNC_PROXY_H +#include + +#include "napi/native_api.h" +#include "napi/native_common.h" +#include "napi/native_node_api.h" +#include "securec.h" + +namespace OHOS { +namespace AppDataMgrJsKit { +constexpr int MAX_INPUT_COUNT = 10; +constexpr int OK = 0; +constexpr int ERR = -1; + +// T inherits AysncContext +template class NapiAsyncProxy { +public: + constexpr static int RESULT_COUNT = 2; + using InputParser = void (*)(const napi_env &, const napi_value &, T *); + using NapiAsyncExecute = int (*)(T *); + using NapiAsyncComplete = int (*)(T *, napi_value &); + + // AsyncContext base + struct AysncContext { + AysncContext() + { + } + virtual ~AysncContext() + { + if (env == nullptr) { + return; + } + napi_delete_async_work(env, work); + napi_delete_reference(env, callbackRef); + } + napi_env env = nullptr; + napi_callback_info info = nullptr; + napi_async_work work = nullptr; + napi_deferred deferred = nullptr; + napi_ref callbackRef = nullptr; + NapiAsyncExecute execFunc = nullptr; + int execStatus = ERR; + NapiAsyncComplete completeFunc = nullptr; + void *boundObj = nullptr; + }; + +public: + void Init(napi_env env, napi_callback_info info) + { + asyncContext = new T(); + if (asyncContext == nullptr) { + return; + } + asyncContext->env = env; + asyncContext->info = info; + } + + ~NapiAsyncProxy() + { + if (asyncContext == nullptr) { + return; + } + + delete asyncContext; + asyncContext = nullptr; + } + + static void DefParserThis(const napi_env &env, const napi_value &self, T *context) + { + napi_unwrap(env, self, &context->boundObj); + } + + void ParseInputs(const std::vector &parsers, InputParser parserThis = DefParserThis) + { + if (asyncContext == nullptr) { + return; + } + + napi_value thisObj = nullptr; + size_t argc = parsers.size() + 1; + napi_value args[MAX_INPUT_COUNT] = { 0 }; + napi_get_cb_info(asyncContext->env, asyncContext->info, &argc, args, &thisObj, nullptr); + for (size_t i = 0; i < argc && argc <= MAX_INPUT_COUNT; i++) { + if (i >= parsers.size()) { + napi_valuetype valueType = napi_undefined; + napi_typeof(asyncContext->env, args[i], &valueType); + if (valueType == napi_function) { + napi_create_reference(asyncContext->env, args[i], 1, &asyncContext->callbackRef); + } + break; + } + auto *parserFunction = parsers[i]; + if (parserFunction != nullptr) { + parserFunction(asyncContext->env, args[i], this->asyncContext); + } + } + parserThis(asyncContext->env, thisObj, asyncContext); + } + + napi_value DoAsyncWork(std::string resourceName, NapiAsyncExecute execFunc, NapiAsyncComplete completeFunc) + { + if (asyncContext == nullptr) { + return nullptr; + } + + napi_value ret = nullptr; + if (asyncContext->callbackRef == nullptr) { + napi_create_promise(asyncContext->env, &asyncContext->deferred, &ret); + } else { + napi_get_undefined(asyncContext->env, &ret); + } + + napi_value resource = nullptr; + napi_create_string_utf8(asyncContext->env, resourceName.c_str(), NAPI_AUTO_LENGTH, &resource); + asyncContext->execFunc = execFunc; + asyncContext->completeFunc = completeFunc; + NAPI_CALL_BASE(asyncContext->env, napi_create_async_work(asyncContext->env, nullptr, resource, + [](napi_env env, void *data) { + T *context = (T *)data; + context->execStatus = context->execFunc(context); + }, + [](napi_env env, napi_status status, void *data) { + T *context = (T *)data; + napi_value output = nullptr; + int completeStatus = context->completeFunc(context, output); + napi_value result[RESULT_COUNT] = { 0 }; + if (context->execStatus == OK && completeStatus == OK) { + napi_get_undefined(env, &result[0]); + result[1] = output; + } else { + napi_value message = nullptr; + napi_create_string_utf8(env, "async call failed", NAPI_AUTO_LENGTH, &message); + napi_create_error(env, nullptr, message, &result[0]); + napi_get_undefined(env, &result[1]); + } + if (context->deferred) { + // promise + if (context->execStatus == OK && completeStatus == OK) { + napi_resolve_deferred(env, context->deferred, result[1]); + } else { + napi_reject_deferred(env, context->deferred, result[0]); + } + } else { + // callback + napi_value callback = nullptr; + napi_get_reference_value(env, context->callbackRef, &callback); + napi_value callbackResult = nullptr; + napi_call_function(env, nullptr, callback, RESULT_COUNT, result, &callbackResult); + } + delete context; + }, + (void *)asyncContext, &asyncContext->work), ret); + NAPI_CALL_BASE(asyncContext->env, napi_queue_async_work(asyncContext->env, asyncContext->work), ret); + return ret; + } + +private: + T *asyncContext; +}; +} // namespace AppDataMgrJsKit +} // namespace OHOS +#endif diff --git a/frameworks/js/napi/featureAbility/data_ability/include/napi_data_ability_predicates.h b/frameworks/js/napi/featureAbility/data_ability/include/napi_data_ability_predicates.h new file mode 100644 index 0000000000..b9044f1166 --- /dev/null +++ b/frameworks/js/napi/featureAbility/data_ability/include/napi_data_ability_predicates.h @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2021 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 DATAABILITY_JSKIT_NAPI_DATA_ABILITY_PREDICATES_H +#define DATAABILITY_JSKIT_NAPI_DATA_ABILITY_PREDICATES_H + +#include +#include "data_ability_predicates.h" +#include "napi/native_api.h" +#include "napi/native_common.h" +#include "napi/native_node_api.h" + +namespace OHOS { +namespace DataAbilityJsKit { +class DataAbilityPredicatesProxy { +public: + static void Init(napi_env env, napi_value exports); + static napi_value NewInstance(napi_env env, std::shared_ptr value); + static std::shared_ptr GetNativePredicates( + const napi_env env, const napi_value arg); + static void Destructor(napi_env env, void *nativeObject, void *finalize_hint); + + DataAbilityPredicatesProxy(); + std::shared_ptr GetPredicates() const; + +private: + ~DataAbilityPredicatesProxy(); + + static napi_value New(napi_env env, napi_callback_info info); + static std::shared_ptr GetNativePredicates(napi_env env, + napi_callback_info info); + static napi_value EqualTo(napi_env env, napi_callback_info info); + static napi_value NotEqualTo(napi_env env, napi_callback_info info); + static napi_value BeginWrap(napi_env env, napi_callback_info info); + static napi_value EndWrap(napi_env env, napi_callback_info info); + static napi_value Or(napi_env env, napi_callback_info info); + static napi_value And(napi_env env, napi_callback_info info); + static napi_value Contains(napi_env env, napi_callback_info info); + static napi_value BeginsWith(napi_env env, napi_callback_info info); + static napi_value EndsWith(napi_env env, napi_callback_info info); + static napi_value IsNull(napi_env env, napi_callback_info info); + static napi_value IsNotNull(napi_env env, napi_callback_info info); + static napi_value Like(napi_env env, napi_callback_info info); + static napi_value Glob(napi_env env, napi_callback_info info); + static napi_value Between(napi_env env, napi_callback_info info); + static napi_value NotBetween(napi_env env, napi_callback_info info); + static napi_value GreaterThan(napi_env env, napi_callback_info info); + static napi_value LessThan(napi_env env, napi_callback_info info); + static napi_value GreaterThanOrEqualTo(napi_env env, napi_callback_info info); + static napi_value LessThanOrEqualTo(napi_env env, napi_callback_info info); + static napi_value OrderByAsc(napi_env env, napi_callback_info info); + static napi_value OrderByDesc(napi_env env, napi_callback_info info); + static napi_value Distinct(napi_env env, napi_callback_info info); + static napi_value Limit(napi_env env, napi_callback_info info); + static napi_value Offset(napi_env env, napi_callback_info info); + static napi_value GroupBy(napi_env env, napi_callback_info info); + static napi_value IndexedBy(napi_env env, napi_callback_info info); + static napi_value In(napi_env env, napi_callback_info info); + static napi_value NotIn(napi_env env, napi_callback_info info); + static napi_value Clear(napi_env env, napi_callback_info info); + static napi_value IsRawSelection(napi_env env, napi_callback_info info); + static napi_value GetWhereClause(napi_env env, napi_callback_info info); + static napi_value SetWhereClause(napi_env env, napi_callback_info info); + static napi_value GetWhereArgs(napi_env env, napi_callback_info info); + static napi_value SetWhereArgs(napi_env env, napi_callback_info info); + static napi_value GetOrder(napi_env env, napi_callback_info info); + static napi_value SetOrder(napi_env env, napi_callback_info info); + static napi_value GetLimit(napi_env env, napi_callback_info info); + static napi_value GetOffset(napi_env env, napi_callback_info info); + static napi_value IsDistinct(napi_env env, napi_callback_info info); + static napi_value GetGroup(napi_env env, napi_callback_info info); + static napi_value GetIndex(napi_env env, napi_callback_info info); + static napi_value IsNeedAnd(napi_env env, napi_callback_info info); + static napi_value IsSorted(napi_env env, napi_callback_info info); + std::shared_ptr predicates_; +}; +} // namespace DataAbilityJsKit +} // namespace OHOS + +EXTERN_C_START +__attribute__((visibility("default"))) + napi_value NAPI_OHOS_Data_DataAbilityJsKit_DataAbilityPredicatesProxy_NewInstance(napi_env env, + OHOS::NativeRdb::DataAbilityPredicates *predicates); + +__attribute__((visibility("default"))) OHOS::NativeRdb::DataAbilityPredicates * +NAPI_OHOS_Data_DataAbilityJsKit_DataAbilityPredicatesProxy_GetNativeObject( + const napi_env env, const napi_value arg); +EXTERN_C_END +#endif // DATAABILITY_JSKIT_NAPI_DATA_ABILITY_PREDICATES_H \ No newline at end of file diff --git a/frameworks/js/napi/featureAbility/data_ability/include/napi_predicates_utils.h b/frameworks/js/napi/featureAbility/data_ability/include/napi_predicates_utils.h new file mode 100644 index 0000000000..08a6c6e666 --- /dev/null +++ b/frameworks/js/napi/featureAbility/data_ability/include/napi_predicates_utils.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2021 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 APPDATAMGR_NAPI_PREDICATES_UTILS_H +#define APPDATAMGR_NAPI_PREDICATES_UTILS_H + +#include "napi/native_api.h" +#include "napi/native_common.h" +#include "napi/native_node_api.h" + +namespace OHOS { +namespace DataAbilityJsKit { +napi_value InitPredicatesUtils(napi_env env, napi_value info); +#define RDB_CHECK_RETURN_NULLPTR(assertion, message) \ + do { \ + if (!(assertion)) { \ + LOG_ERROR("%{public}s", message); \ + return nullptr; \ + } \ + } while (0) +} // namespace DataAbilityJsKit +} // namespace OHOS +#endif // APPDATAMGR_NAPI_PREDICATES_UTILS_H diff --git a/frameworks/js/napi/featureAbility/data_ability/include/napi_rdb_error.h b/frameworks/js/napi/featureAbility/data_ability/include/napi_rdb_error.h new file mode 100644 index 0000000000..0f7e7cfb20 --- /dev/null +++ b/frameworks/js/napi/featureAbility/data_ability/include/napi_rdb_error.h @@ -0,0 +1,213 @@ +/* + * Copyright (c) 2022 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 RDB_JS_NAPI_ERROR_H +#define RDB_JS_NAPI_ERROR_H + +#include "logger.h" + +namespace OHOS { +namespace AppDataMgrJsKit { +constexpr int MAX_INPUT_COUNT = 10; +constexpr int OK = 0; +constexpr int ERR = -1; +constexpr int APIVERSION_V9 = 9; +constexpr int APIVERSION_8 = 8; + +constexpr int E_PARAM_ERROR = 401; +constexpr int E_INNER_ERROR = 14800000; + +constexpr int E_DB_INVALID = 14800010; +constexpr int E_DB_CORRUPTED = 14800011; +constexpr int E_RESULT_GET_ERROR = 14800013; +constexpr int E_RESULT_GOTO_ERROR = 14800012; + +#define RDB_NAPI_ASSERT_BASE_FROMV9(env, assertion, error, retVal, version) \ + do { \ + if (!(assertion)) { \ + if ((error) == nullptr) { \ + LOG_ERROR("throw error: error message is empty,version= %{public}d", version); \ + napi_throw_error((env), nullptr, "error message is empty"); \ + return retVal; \ + } \ + if (((version) > (APIVERSION_8)) || (((error)->GetCode()) == (401))) { \ + LOG_ERROR("throw error: code = %{public}d , message = %{public}s, version= %{public}d", \ + (error)->GetCode(), (error)->GetMessage().c_str(), version); \ + napi_throw_error((env), std::to_string((error)->GetCode()).c_str(), (error)->GetMessage().c_str()); \ + return retVal; \ + } \ + LOG_ERROR("nothrow error: code = %{public}d , message = %{public}s, version= %{public}d", \ + (error)->GetCode(), (error)->GetMessage().c_str(), version); \ + } \ + } while (0) + +#define RDB_REVT_NOTHING + +#define RDB_NAPI_ASSERT_FROMV9(env, assertion, error, version) \ + RDB_NAPI_ASSERT_BASE_FROMV9(env, assertion, error, nullptr, version) + +#define RDB_NAPI_ASSERT_RETURN_VOID_FROMV9(env, assertion, error, version) \ + RDB_NAPI_ASSERT_BASE_FROMV9(env, assertion, error, NAPI_RETVAL_NOTHING, version) + +#define RDB_ASYNC_PARAM_CHECK_FUNCTION(theCall) \ + do { \ + int err = (theCall); \ + if (err != OK) { \ + return err; \ + } \ + } while (0) + +#define RDB_CHECK_RETURN_NULLPTR(assertion, message) \ + do { \ + if (!(assertion)) { \ + LOG_ERROR("%{public}s", message); \ + return nullptr; \ + } \ + } while (0) + +#define RDB_CHECK_RETURN_VOID(assertion, message) \ + do { \ + if (!(assertion)) { \ + LOG_ERROR("%{public}s", message); \ + return; \ + } \ + } while (0) + +#define CHECK_RETURN_CORE(assertion, theCall, revt) \ + do { \ + if (!(assertion)) { \ + theCall; \ + return revt; \ + } \ + } while (0) + +#define CHECK_RETURN_ERR(assertion) \ + CHECK_RETURN_CORE(assertion, RDB_REVT_NOTHING, ERR) + +#define RDB_CHECK_RETURN_CALL_RESULT(assertion, theCall) \ + do { \ + if (!(assertion)) { \ + (theCall); \ + return ERR; \ + } \ + } while (0) + +class Error { +public: + virtual ~Error(){}; + virtual std::string GetMessage() = 0; + virtual int GetCode() = 0; +}; + +class InnerError : public Error { +public: + InnerError() = default; + std::string GetMessage() override + { + return "System error."; + }; + int GetCode() override + { + return E_INNER_ERROR; + }; +}; + +class ParamTypeError : public Error { +public: + ParamTypeError(const std::string &name, const std::string &wantType) : name(name), wantType(wantType){}; + std::string GetMessage() override + { + return "Parameter error. The type of '" + name + "' must be " + wantType; + }; + int GetCode() override + { + return E_PARAM_ERROR; + }; + +private: + std::string name; + std::string wantType; +}; + +class ParamNumError : public Error { +public: + ParamNumError(const std::string &wantNum) : wantNum(wantNum){}; + std::string GetMessage() override + { + return "Parameter error. Need " + wantNum + " parameters!"; + }; + int GetCode() override + { + return E_PARAM_ERROR; + }; + +private: + std::string wantNum; +}; + +class DbInvalidError : public Error { +public: + DbInvalidError() = default; + std::string GetMessage() override + { + return "Failed open database, invalid database name."; + }; + int GetCode() override + { + return E_DB_INVALID; + }; +}; + +class DbCorruptedError : public Error { +public: + DbCorruptedError() = default; + std::string GetMessage() override + { + return "Failed open database, database corrupted."; + }; + int GetCode() override + { + return E_DB_CORRUPTED; + }; +}; + +class ResultGetError : public Error { +public: + ResultGetError() = default; + std::string GetMessage() override + { + return "The column value is null or the column type is incompatible."; + }; + int GetCode() override + { + return E_RESULT_GET_ERROR; + }; +}; + +class ResultGotoError : public Error { +public: + ResultGotoError() = default; + std::string GetMessage() override + { + return "The result set is empty or the specified location is invalid."; + }; + int GetCode() override + { + return E_RESULT_GOTO_ERROR; + }; +}; +} // namespace AppDataMgrJsKit +} // namespace OHOS + +#endif // RDB_JS_NAPI_ERROR_H diff --git a/frameworks/js/napi/featureAbility/data_ability/include/napi_rdb_js_utils.h b/frameworks/js/napi/featureAbility/data_ability/include/napi_rdb_js_utils.h new file mode 100644 index 0000000000..cb22f0e9d0 --- /dev/null +++ b/frameworks/js/napi/featureAbility/data_ability/include/napi_rdb_js_utils.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2023 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 RDB_JSKIT_NAPI_RDB_JS_UTILS_H +#define RDB_JSKIT_NAPI_RDB_JS_UTILS_H +#include "asset_value.h" +#include "js_utils.h" +#include "result_set.h" +#include "value_object.h" +namespace OHOS::AppDataMgrJsKit { +namespace JSUtils { +using Asset = OHOS::NativeRdb::AssetValue; +using RowEntity = OHOS::NativeRdb::RowEntity; +using ValueObject = OHOS::NativeRdb::ValueObject; +using BigInt = OHOS::NativeRdb::BigInteger; +template<> +int32_t Convert2Value(napi_env env, napi_value input, Asset &output); +template<> +napi_value Convert2JSValue(napi_env env, const Asset &value); +template<> +napi_value Convert2JSValue(napi_env env, const RowEntity &value); +template<> +int32_t Convert2Value(napi_env env, napi_value jsValue, ValueObject &valueObject); +template<> +napi_value Convert2JSValue(napi_env env, const BigInt &value); +template<> +int32_t Convert2Value(napi_env env, napi_value jsValue, BigInt &value); +}; // namespace JSUtils +} // namespace OHOS::AppDataMgrJsKit +#endif // RDB_JSKIT_NAPI_RDB_JS_UTILS_H diff --git a/frameworks/js/napi/featureAbility/data_ability/include/napi_rdb_predicates.h b/frameworks/js/napi/featureAbility/data_ability/include/napi_rdb_predicates.h new file mode 100644 index 0000000000..81ba767f58 --- /dev/null +++ b/frameworks/js/napi/featureAbility/data_ability/include/napi_rdb_predicates.h @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2022 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 RDB_JSKIT_NAPI_RDB_PREDICATES_H +#define RDB_JSKIT_NAPI_RDB_PREDICATES_H + +#include + +#include "napi/native_api.h" +#include "napi/native_common.h" +#include "napi/native_node_api.h" +#include "napi_rdb_error.h" +#include "rdb_predicates.h" + +namespace OHOS { +namespace RdbJsKit { +class RdbPredicatesProxy { +public: + static void Init(napi_env env, napi_value exports); + static napi_value NewInstance( + napi_env env, std::shared_ptr value, int version = AppDataMgrJsKit::APIVERSION_8); + static void Destructor(napi_env env, void *nativeObject, void *finalize_hint); + + explicit RdbPredicatesProxy(std::string &tableName); + std::shared_ptr GetPredicates() const; + int apiversion = AppDataMgrJsKit::APIVERSION_8; + +private: + ~RdbPredicatesProxy(); + + static napi_value New(napi_env env, napi_callback_info info); + static napi_value NewV9(napi_env env, napi_callback_info info); + static napi_value InnerNew(napi_env env, napi_callback_info info, int version = AppDataMgrJsKit::APIVERSION_8); + static std::shared_ptr GetNativePredicates(napi_env env, napi_callback_info info); + + static RdbPredicatesProxy *ParseFieldArrayByName(napi_env env, napi_callback_info info, napi_value &thiz, + std::vector &fieldarray, const std::string fieldName, const std::string fieldType); + static RdbPredicatesProxy *ParseFieldByName( + napi_env env, napi_callback_info info, napi_value &thiz, std::string &field, const std::string fieldName); + static RdbPredicatesProxy *ParseInt32FieldByName( + napi_env env, napi_callback_info info, napi_value &thiz, int32_t &field, const std::string fieldName); + static RdbPredicatesProxy *ParseFieldAndValueArray(napi_env env, napi_callback_info info, napi_value &thiz, + std::string &field, std::vector &value, const std::string valueType); + static RdbPredicatesProxy *ParseFieldAndValue(napi_env env, napi_callback_info info, napi_value &thiz, + std::string &field, NativeRdb::ValueObject &value, const std::string valueType); + static RdbPredicatesProxy *ParseFieldAndStringValue(napi_env env, napi_callback_info info, napi_value &thiz, + std::string &field, std::string &value, const std::string valueType); + static RdbPredicatesProxy *ParseFieldLowAndHigh(napi_env env, napi_callback_info info, napi_value &thiz, + std::string &field, NativeRdb::ValueObject &low, NativeRdb::ValueObject &High); + + static napi_value EqualTo(napi_env env, napi_callback_info info); + static napi_value NotEqualTo(napi_env env, napi_callback_info info); + static napi_value BeginWrap(napi_env env, napi_callback_info info); + static napi_value EndWrap(napi_env env, napi_callback_info info); + static napi_value Or(napi_env env, napi_callback_info info); + static napi_value And(napi_env env, napi_callback_info info); + static napi_value Contains(napi_env env, napi_callback_info info); + static napi_value BeginsWith(napi_env env, napi_callback_info info); + static napi_value EndsWith(napi_env env, napi_callback_info info); + static napi_value IsNull(napi_env env, napi_callback_info info); + static napi_value IsNotNull(napi_env env, napi_callback_info info); + static napi_value Like(napi_env env, napi_callback_info info); + static napi_value Glob(napi_env env, napi_callback_info info); + static napi_value Between(napi_env env, napi_callback_info info); + static napi_value NotBetween(napi_env env, napi_callback_info info); + static napi_value GreaterThan(napi_env env, napi_callback_info info); + static napi_value LessThan(napi_env env, napi_callback_info info); + static napi_value GreaterThanOrEqualTo(napi_env env, napi_callback_info info); + static napi_value LessThanOrEqualTo(napi_env env, napi_callback_info info); + static napi_value OrderByAsc(napi_env env, napi_callback_info info); + static napi_value OrderByDesc(napi_env env, napi_callback_info info); + static napi_value Distinct(napi_env env, napi_callback_info info); + static napi_value Limit(napi_env env, napi_callback_info info); + static napi_value Offset(napi_env env, napi_callback_info info); + static napi_value GroupBy(napi_env env, napi_callback_info info); + static napi_value IndexedBy(napi_env env, napi_callback_info info); + static napi_value In(napi_env env, napi_callback_info info); + static napi_value NotIn(napi_env env, napi_callback_info info); + static napi_value Using(napi_env env, napi_callback_info info); + static napi_value Clear(napi_env env, napi_callback_info info); + static napi_value CrossJoin(napi_env env, napi_callback_info info); + static napi_value LeftOuterJoin(napi_env env, napi_callback_info info); + static napi_value GetJoinCount(napi_env env, napi_callback_info info); + static napi_value SetJoinConditions(napi_env env, napi_callback_info info); + static napi_value SetJoinTableNames(napi_env env, napi_callback_info info); + static napi_value SetJoinTypes(napi_env env, napi_callback_info info); + static napi_value SetJoinCount(napi_env env, napi_callback_info info); + static napi_value GetJoinTypes(napi_env env, napi_callback_info info); + static napi_value GetJoinTableNames(napi_env env, napi_callback_info info); + static napi_value GetJoinConditions(napi_env env, napi_callback_info info); + static napi_value InnerJoin(napi_env env, napi_callback_info info); + static napi_value On(napi_env env, napi_callback_info info); + static napi_value InDevices(napi_env env, napi_callback_info info); + static napi_value InAllDevices(napi_env env, napi_callback_info info); + + std::shared_ptr predicates_; +}; +} // namespace RdbJsKit +} // namespace OHOS + +#endif // RDB_JSKIT_NAPI_RDB_PREDICATES_H diff --git a/frameworks/js/napi/featureAbility/data_ability/include/napi_rdb_trace.h b/frameworks/js/napi/featureAbility/data_ability/include/napi_rdb_trace.h new file mode 100644 index 0000000000..0fbbb1888b --- /dev/null +++ b/frameworks/js/napi/featureAbility/data_ability/include/napi_rdb_trace.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2022 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 DISTRIBUTEDDATAMGR_NAPI_RDB_TRACE_H +#define DISTRIBUTEDDATAMGR_NAPI_RDB_TRACE_H + +#define DO_NOTHING + +#ifdef RDB_TRACE_ON +#include "hitrace.h" +#define DISTRIBUTED_DATA_HITRACE(trace) HiTrace hitrace(trace) +#else +#define DISTRIBUTED_DATA_HITRACE(trace) DO_NOTHING +#endif + +#endif \ No newline at end of file diff --git a/frameworks/js/napi/featureAbility/data_ability/include/napi_result_set.h b/frameworks/js/napi/featureAbility/data_ability/include/napi_result_set.h new file mode 100644 index 0000000000..4ad567b702 --- /dev/null +++ b/frameworks/js/napi/featureAbility/data_ability/include/napi_result_set.h @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2022 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 RDB_JSKIT_NAPI_RESULT_SET_H +#define RDB_JSKIT_NAPI_RESULT_SET_H + +#include + +#include "abs_shared_result_set.h" +#include "js_proxy.h" +#include "napi/native_api.h" +#include "napi/native_common.h" +#include "napi/native_node_api.h" +#include "napi_rdb_error.h" +#include "result_set_bridge.h" + +namespace OHOS { +namespace RdbJsKit { +class ResultSetProxy final : public JSProxy::JSEntity { +public: + ResultSetProxy() = default; + ~ResultSetProxy(); + ResultSetProxy(std::shared_ptr resultSet); + ResultSetProxy &operator=(std::shared_ptr resultSet); + static napi_value NewInstance(napi_env env, std::shared_ptr resultSet, + int version = AppDataMgrJsKit::APIVERSION_8); + static napi_value NewInstance(napi_env env, std::shared_ptr resultSet, + int version = AppDataMgrJsKit::APIVERSION_8); + static std::shared_ptr GetNativeObject(const napi_env env, const napi_value arg); + static napi_value GetConstructor(napi_env env, int version); + std::shared_ptr Create() override; + int apiversion = AppDataMgrJsKit::APIVERSION_8; + +private: + static ResultSetProxy *GetInnerResultSet(napi_env env, napi_callback_info info, int &version); + static ResultSetProxy *ParseInt32FieldByName( + napi_env env, napi_callback_info info, int32_t &field, const std::string& fieldName); + static ResultSetProxy *ParseFieldByName(napi_env env, napi_callback_info info, std::string &field); + + static napi_value InnerInitialize( + napi_env env, napi_callback_info info, int version = AppDataMgrJsKit::APIVERSION_8); + static napi_value Initialize(napi_env env, napi_callback_info info); + static napi_value InitializeV9(napi_env env, napi_callback_info info); + static napi_value GetAllColumnNames(napi_env env, napi_callback_info info); + static napi_value GoToRow(napi_env env, napi_callback_info info); + static napi_value GetColumnCount(napi_env env, napi_callback_info info); + static napi_value GetLong(napi_env env, napi_callback_info info); + static napi_value GetColumnType(napi_env env, napi_callback_info info); + static napi_value GoTo(napi_env env, napi_callback_info info); + static napi_value GetColumnIndex(napi_env env, napi_callback_info info); + static napi_value GetInt(napi_env env, napi_callback_info info); + static napi_value GetColumnName(napi_env env, napi_callback_info info); + static napi_value Close(napi_env env, napi_callback_info info); + static napi_value GetRowCount(napi_env env, napi_callback_info info); + static napi_value GetRowIndex(napi_env env, napi_callback_info info); + static napi_value IsEnded(napi_env env, napi_callback_info info); + static napi_value IsBegin(napi_env env, napi_callback_info info); + static napi_value GoToFirstRow(napi_env env, napi_callback_info info); + static napi_value GoToLastRow(napi_env env, napi_callback_info info); + static napi_value GoToNextRow(napi_env env, napi_callback_info info); + static napi_value GoToPreviousRow(napi_env env, napi_callback_info info); + static napi_value IsAtFirstRow(napi_env env, napi_callback_info info); + static napi_value IsAtLastRow(napi_env env, napi_callback_info info); + static napi_value GetBlob(napi_env env, napi_callback_info info); + static napi_value GetString(napi_env env, napi_callback_info info); + static napi_value GetDouble(napi_env env, napi_callback_info info); + static napi_value IsColumnNull(napi_env env, napi_callback_info info); + static napi_value IsClosed(napi_env env, napi_callback_info info); + + static napi_value GetSharedBlockName(napi_env env, napi_callback_info info); + static napi_value GetSharedBlockAshmemFd(napi_env env, napi_callback_info info); + + std::shared_ptr sharedResultSet_; + + std::string sharedBlockName_; + int32_t sharedBlockAshmemFd_ = -1; +}; +} // namespace RdbJsKit +} // namespace OHOS +#endif // RDB_JSKIT_NAPI_RESULT_SET_H \ No newline at end of file diff --git a/frameworks/js/napi/featureAbility/data_ability/js_utils.cpp b/frameworks/js/napi/featureAbility/data_ability/js_utils.cpp new file mode 100644 index 0000000000..53ecd2d4de --- /dev/null +++ b/frameworks/js/napi/featureAbility/data_ability/js_utils.cpp @@ -0,0 +1,716 @@ +/* + * Copyright (c) 2021 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. + */ +#define LOG_TAG "JSUtils" + +#include "js_utils.h" + +#include + +#include "js_native_api_types.h" +#include "logger.h" +#include "securec.h" +using namespace OHOS::Rdb; + +#define CHECK_RETURN_RET(assertion, message, revt) \ + do { \ + if (!(assertion)) { \ + LOG_WARN("assertion (" #assertion ") failed: " message); \ + return revt; \ + } \ + } while (0) + +namespace OHOS { +namespace AppDataMgrJsKit { +namespace JSUtils { + static int32_t g_hapVersion = -1; // the current apiVersion of hap +} + +static constexpr JSUtils::JsFeatureSpace FEATURE_NAME_SPACES[] = { + { "ohos.data.cloudData", "ZGF0YS5jbG91ZERhdGE=", true }, + { "ohos.data.dataAbility", "ZGF0YS5kYXRhQWJpbGl0eQ==", true }, + { "ohos.data.dataShare", "ZGF0YS5kYXRhU2hhcmU=", false }, + { "ohos.data.distributedDataObject", "ZGF0YS5kaXN0cmlidXRlZERhdGFPYmplY3Q=", false }, + { "ohos.data.distributedKVStore", "ZGF0YS5kaXN0cmlidXRlZEtWU3RvcmU=", false }, + { "ohos.data.rdb", "ZGF0YS5yZGI=", true }, + { "ohos.data.relationalStore", "ZGF0YS5yZWxhdGlvbmFsU3RvcmU=", true }, +}; + +void JSUtils::SetHapVersion(int32_t hapversion) +{ + g_hapVersion = hapversion; +} + +int32_t JSUtils::GetHapVersion() +{ + return g_hapVersion; +} + +const std::optional JSUtils::GetJsFeatureSpace(const std::string &name) +{ + auto jsFeature = JsFeatureSpace{ name.data(), nullptr, false }; + auto iter = std::lower_bound(FEATURE_NAME_SPACES, + FEATURE_NAME_SPACES + sizeof(FEATURE_NAME_SPACES) / sizeof(FEATURE_NAME_SPACES[0]), jsFeature, + [](const JsFeatureSpace &JsFeatureSpace1, const JsFeatureSpace &JsFeatureSpace2) { + return strcmp(JsFeatureSpace1.spaceName, JsFeatureSpace2.spaceName) < 0; + }); + if (iter < FEATURE_NAME_SPACES + sizeof(FEATURE_NAME_SPACES) / sizeof(FEATURE_NAME_SPACES[0]) && + strcmp(iter->spaceName, name.data()) == 0) { + return *iter; + } + return std::nullopt; +} + +std::pair JSUtils::GetInnerValue( + napi_env env, napi_value in, const std::string &prop, bool optional) +{ + bool hasProp = false; + napi_status status = napi_has_named_property(env, in, prop.c_str(), &hasProp); + if (status != napi_ok) { + return std::make_pair(napi_generic_failure, nullptr); + } + if (!hasProp) { + status = optional ? napi_ok : napi_generic_failure; + return std::make_pair(status, nullptr); + } + napi_value inner = nullptr; + status = napi_get_named_property(env, in, prop.c_str(), &inner); + if (status != napi_ok || inner == nullptr) { + return std::make_pair(napi_generic_failure, nullptr); + } + if (optional && JSUtils::IsNull(env, inner)) { + return std::make_pair(napi_ok, nullptr); + } + return std::make_pair(napi_ok, inner); +} + +std::string JSUtils::Convert2String(napi_env env, napi_value jsStr) +{ + std::string value = ""; // TD: need to check everywhere in use whether empty is work well. + JSUtils::Convert2Value(env, jsStr, value); + return value; +} + +int32_t JSUtils::Convert2ValueExt(napi_env env, napi_value jsValue, uint32_t &output) +{ + napi_valuetype type = napi_undefined; + napi_status status = napi_typeof(env, jsValue, &type); + if (status != napi_ok || type != napi_number) { + LOG_DEBUG("napi_typeof failed status = %{public}d type = %{public}d", status, type); + return napi_invalid_arg; + } + + status = napi_get_value_uint32(env, jsValue, &output); + if (status != napi_ok) { + LOG_DEBUG("napi_get_value_uint32 failed, status = %{public}d", status); + return status; + } + return status; +} + +int32_t JSUtils::Convert2ValueExt(napi_env env, napi_value jsValue, int32_t &output) +{ + napi_valuetype type = napi_undefined; + napi_status status = napi_typeof(env, jsValue, &type); + if (status != napi_ok || type != napi_number) { + LOG_DEBUG("napi_typeof failed status = %{public}d type = %{public}d", status, type); + return napi_invalid_arg; + } + + status = napi_get_value_int32(env, jsValue, &output); + if (status != napi_ok) { + LOG_DEBUG("napi_get_value_int32 failed, status = %{public}d", status); + return status; + } + return status; +} + +int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, napi_value &output) +{ + output = jsValue; + return napi_ok; +} + +int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, bool &output) +{ + napi_valuetype type = napi_undefined; + napi_status status = napi_typeof(env, jsValue, &type); + if (status != napi_ok || type != napi_boolean) { + LOG_DEBUG("napi_typeof failed status = %{public}d type = %{public}d", status, type); + return napi_invalid_arg; + } + + bool bValue = false; + status = napi_get_value_bool(env, jsValue, &bValue); + if (status != napi_ok) { + LOG_ERROR("napi_get_value_bool failed, status = %{public}d", status); + return status; + } + output = bValue; + return status; +} + +int32_t JSUtils::Convert2ValueExt(napi_env env, napi_value jsValue, int64_t &output) +{ + napi_valuetype type = napi_undefined; + napi_status status = napi_typeof(env, jsValue, &type); + if (status != napi_ok || type != napi_number) { + LOG_DEBUG("napi_typeof failed status = %{public}d type = %{public}d", status, type); + return napi_invalid_arg; + } + + status = napi_get_value_int64(env, jsValue, &output); + if (status != napi_ok) { + LOG_DEBUG("napi_get_value_int64 failed, status = %{public}d", status); + return status; + } + return status; +} + +int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, double &output) +{ + napi_valuetype type = napi_undefined; + napi_status status = napi_typeof(env, jsValue, &type); + if (status != napi_ok || type != napi_number) { + LOG_DEBUG("napi_typeof failed status = %{public}d type = %{public}d", status, type); + return napi_invalid_arg; + } + + double number = 0.0; + status = napi_get_value_double(env, jsValue, &number); + if (status != napi_ok) { + LOG_DEBUG("napi_get_value_double failed, status = %{public}d", status); + return status; + } + output = number; + return status; +} + +int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, int64_t &output) +{ + return napi_invalid_arg; +} + +int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, std::vector &output) +{ + bool isTypedArray = false; + napi_is_typedarray(env, jsValue, &isTypedArray); + if (!isTypedArray) { + return napi_invalid_arg; + } + + napi_typedarray_type type; + napi_value input_buffer = nullptr; + size_t byte_offset = 0; + size_t length = 0; + void *tmp = nullptr; + auto status = napi_get_typedarray_info(env, jsValue, &type, &length, &tmp, &input_buffer, &byte_offset); + if (status != napi_ok || type != napi_float32_array) { + return napi_invalid_arg; + } + + output = (tmp != nullptr + ? std::vector(static_cast(tmp), static_cast(tmp) + length / sizeof(float)) + : std::vector()); + return status; +} + +int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, std::string &output) +{ + napi_valuetype type = napi_undefined; + napi_status status = napi_typeof(env, jsValue, &type); + if (status != napi_ok || type != napi_string) { + LOG_DEBUG("napi_typeof failed status = %{public}d type = %{public}d", status, type); + return napi_invalid_arg; + } + + size_t buffSize = 0; + napi_get_value_string_utf8(env, jsValue, nullptr, 0, &buffSize); + + // cut down with 0 if more than MAX_VALUE_LENGTH + if (buffSize >= JSUtils::MAX_VALUE_LENGTH - 1) { + buffSize = JSUtils::MAX_VALUE_LENGTH - 1; + } + std::unique_ptr buffer = std::make_unique(buffSize + 1); + if (!buffer) { + LOG_ERROR("buffer data is nullptr."); + return napi_invalid_arg; + } + status = napi_get_value_string_utf8(env, jsValue, buffer.get(), buffSize + 1, &buffSize); + if (status != napi_ok) { + LOG_ERROR("napi_get_value_string_utf8 failed, status = %{public}d", status); + return status; + } + output = std::string(buffer.get()); + + return status; +} + +int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, std::vector &output) +{ + bool isTypedArray = false; + napi_is_typedarray(env, jsValue, &isTypedArray); + if (!isTypedArray) { + return napi_invalid_arg; + } + + napi_typedarray_type type; + napi_value input_buffer = nullptr; + size_t byte_offset = 0; + size_t length = 0; + void *tmp = nullptr; + auto status = napi_get_typedarray_info(env, jsValue, &type, &length, &tmp, &input_buffer, &byte_offset); + if (status != napi_ok || type != napi_uint8_array) { + return napi_invalid_arg; + } + + output = (tmp != nullptr ? std::vector(static_cast(tmp), static_cast(tmp) + length) + : std::vector()); + return status; +} + +int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, std::monostate &value) +{ + napi_value tempValue = nullptr; + napi_get_null(env, &tempValue); + bool equal = false; + napi_strict_equals(env, jsValue, tempValue, &equal); + if (equal) { + value = std::monostate(); + return napi_ok; + } + LOG_DEBUG("jsValue is not null."); + return napi_invalid_arg; +} + +int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, std::map &output) +{ + LOG_DEBUG("napi_value -> std::map "); + output.clear(); + napi_value jsMapList = nullptr; + uint32_t jsCount = 0; + napi_status status = napi_get_property_names(env, jsValue, &jsMapList); + CHECK_RETURN_RET(status == napi_ok, "get_property_names failed", napi_invalid_arg); + status = napi_get_array_length(env, jsMapList, &jsCount); + LOG_DEBUG("jsCOUNT: %{public}d", jsCount); + CHECK_RETURN_RET(status == napi_ok && jsCount > 0, "get_map failed", napi_invalid_arg); + napi_value jsKey = nullptr; + napi_value jsVal = nullptr; + for (uint32_t index = 0; index < jsCount; index++) { + status = napi_get_element(env, jsMapList, index, &jsKey); + CHECK_RETURN_RET(status == napi_ok && jsKey != nullptr, "no element", napi_invalid_arg); + std::string key; + int ret = Convert2Value(env, jsKey, key); + CHECK_RETURN_RET(ret == napi_ok, "convert key failed", ret); + status = napi_get_property(env, jsValue, jsKey, &jsVal); + CHECK_RETURN_RET(status == napi_ok && jsVal != nullptr, "no element", napi_invalid_arg); + int32_t val; + ret = Convert2ValueExt(env, jsVal, val); + CHECK_RETURN_RET(ret == napi_ok, "convert val failed", ret); + output.insert(std::pair(key, val)); + } + return napi_ok; +} + +int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, std::map &output) +{ + LOG_DEBUG("napi_value -> std::map "); + output.clear(); + napi_value jsMapList = nullptr; + uint32_t jsCount = 0; + napi_status status = napi_get_property_names(env, jsValue, &jsMapList); + CHECK_RETURN_RET(status == napi_ok, "get_property_names failed", napi_invalid_arg); + status = napi_get_array_length(env, jsMapList, &jsCount); + LOG_DEBUG("jsCount: %{public}d", jsCount); + CHECK_RETURN_RET(status == napi_ok && jsCount > 0, "get_map failed", napi_invalid_arg); + napi_value jsKey = nullptr; + napi_value jsVal = nullptr; + for (uint32_t index = 0; index < jsCount; index++) { + status = napi_get_element(env, jsMapList, index, &jsKey); + CHECK_RETURN_RET(status == napi_ok && jsKey != nullptr, "no element", napi_invalid_arg); + std::string key; + int ret = Convert2Value(env, jsKey, key); + CHECK_RETURN_RET(ret == napi_ok, "convert key failed", ret); + status = napi_get_property(env, jsValue, jsKey, &jsVal); + CHECK_RETURN_RET(status == napi_ok && jsVal != nullptr, "no element", napi_invalid_arg); + bool val; + ret = Convert2Value(env, jsVal, val); + CHECK_RETURN_RET(ret == napi_ok, "convert val failed", ret); + output.insert(std::pair(key, val)); + } + return napi_ok; +} + +napi_value JSUtils::Convert2JSValue(napi_env env, const std::string &value) +{ + napi_value jsValue = nullptr; + if (napi_create_string_utf8(env, value.c_str(), value.size(), &jsValue) != napi_ok) { + return nullptr; + } + return jsValue; +} + +napi_value JSUtils::Convert2JSValue(napi_env env, const std::vector &value) +{ + napi_value jsValue = nullptr; + void *native = nullptr; + napi_value buffer = nullptr; + napi_status status = napi_create_arraybuffer(env, value.size(), &native, &buffer); + if (status != napi_ok) { + return nullptr; + } + for (size_t i = 0; i < value.size(); i++) { + *(static_cast(native) + i) = value[i]; + } + status = napi_create_typedarray(env, napi_uint8_array, value.size(), buffer, 0, &jsValue); + if (status != napi_ok) { + return nullptr; + } + return jsValue; +} + +napi_value JSUtils::Convert2JSValue(napi_env env, int32_t value) +{ + napi_value jsValue = nullptr; + napi_status status = napi_create_int32(env, value, &jsValue); + if (status != napi_ok) { + return nullptr; + } + return jsValue; +} + +napi_value JSUtils::Convert2JSValue(napi_env env, uint32_t value) +{ + napi_value jsValue = nullptr; + napi_status status = napi_create_uint32(env, value, &jsValue); + if (status != napi_ok) { + return nullptr; + } + return jsValue; +} + +napi_value JSUtils::Convert2JSValue(napi_env env, int64_t value) +{ + napi_value jsValue = nullptr; + napi_status status = napi_create_int64(env, value, &jsValue); + if (status != napi_ok) { + return nullptr; + } + return jsValue; +} + +napi_value JSUtils::Convert2JSValue(napi_env env, double value) +{ + napi_value jsValue = nullptr; + napi_status status = napi_create_double(env, value, &jsValue); + if (status != napi_ok) { + return nullptr; + } + return jsValue; +} + +napi_value JSUtils::Convert2JSValue(napi_env env, bool value) +{ + napi_value jsValue = nullptr; + napi_status status = napi_get_boolean(env, value, &jsValue); + if (status != napi_ok) { + return nullptr; + } + return jsValue; +} + +napi_value JSUtils::Convert2JSValue(napi_env env, const std::vector &value) +{ + napi_value jsValue = nullptr; + float *native = nullptr; + napi_value buffer = nullptr; + napi_status status = napi_create_arraybuffer(env, value.size() * sizeof(float), (void **)&native, &buffer); + if (status != napi_ok) { + return nullptr; + } + if (native == nullptr) { + return nullptr; + } + for (size_t i = 0; i < value.size(); i++) { + *(native + i) = value[i]; + } + status = napi_create_typedarray(env, napi_float32_array, value.size(), buffer, 0, &jsValue); + if (status != napi_ok) { + return nullptr; + } + return jsValue; +} + +napi_value JSUtils::Convert2JSValue(napi_env env, const std::map &value) +{ + napi_value jsValue = nullptr; + napi_status status = napi_create_array_with_length(env, value.size(), &jsValue); + if (status != napi_ok) { + return nullptr; + } + + int index = 0; + for (const auto &[device, result] : value) { + napi_value jsElement = nullptr; + status = napi_create_array_with_length(env, SYNC_RESULT_ELEMENT_NUM, &jsElement); + if (status != napi_ok) { + return nullptr; + } + napi_set_element(env, jsElement, 0, Convert2JSValue(env, device)); + napi_set_element(env, jsElement, 1, Convert2JSValue(env, result)); + napi_set_element(env, jsValue, index++, jsElement); + } + + return jsValue; +} + +int32_t JSUtils::Convert2JSValue(napi_env env, std::string value, napi_value &output) +{ + std::string tempStr = std::string(value); + if (napi_create_string_utf8(env, tempStr.c_str(), tempStr.size(), &output) != napi_ok) { + LOG_ERROR("Convert2JSValue create JS string failed."); + return ERR; + } + return napi_ok; +} + +int32_t JSUtils::Convert2JSValue(napi_env env, bool value, napi_value &output) +{ + if (napi_get_boolean(env, value, &output) != napi_ok) { + LOG_ERROR("Convert2JSValue create JS bool failed."); + return ERR; + } + return napi_ok; +} + +int32_t JSUtils::Convert2JSValue(napi_env env, double value, napi_value &output) +{ + if (napi_create_double(env, value, &output) != napi_ok) { + LOG_ERROR("Convert2JSValue create JS double failed."); + return ERR; + } + return napi_ok; +} + +napi_value JSUtils::Convert2JSValue(napi_env env, const std::monostate &value) +{ + napi_value result = nullptr; + napi_get_null(env, &result); + return result; +} + +bool JSUtils::IsNull(napi_env env, napi_value value) +{ + napi_valuetype type = napi_undefined; + napi_status status = napi_typeof(env, value, &type); + return status == napi_ok && (type == napi_undefined || type == napi_null); +} + +napi_value JSUtils::DefineClass(napi_env env, const std::string &spaceName, const std::string &className, + const Descriptor &descriptor, napi_callback ctor) +{ + auto featureSpace = GetJsFeatureSpace(spaceName); + if (!featureSpace.has_value() || !featureSpace->isComponent) { + return nullptr; + } + auto constructor = GetClass(env, spaceName, className); + if (constructor != nullptr) { + return constructor; + } + auto rootPropName = std::string(featureSpace->nameBase64); + napi_value root = nullptr; + bool hasRoot = false; + napi_value global = nullptr; + napi_get_global(env, &global); + napi_has_named_property(env, global, rootPropName.c_str(), &hasRoot); + if (hasRoot) { + napi_get_named_property(env, global, rootPropName.c_str(), &root); + } else { + napi_create_object(env, &root); + napi_set_named_property(env, global, rootPropName.c_str(), root); + } + + std::string propName = "constructor_of_" + className; + bool hasProp = false; + napi_has_named_property(env, root, propName.c_str(), &hasProp); + if (hasProp) { + napi_get_named_property(env, root, propName.c_str(), &constructor); + if (constructor != nullptr) { + LOG_DEBUG("got %{public}s from %{public}s", propName.c_str(), featureSpace->spaceName); + return constructor; + } + hasProp = false; // no constructor. + } + auto properties = descriptor(); + NAPI_CALL(env, napi_define_class(env, className.c_str(), className.size(), ctor, nullptr, properties.size(), + properties.data(), &constructor)); + NAPI_ASSERT(env, constructor != nullptr, "napi_define_class failed!"); + + if (!hasProp) { + napi_set_named_property(env, root, propName.c_str(), constructor); + LOG_DEBUG("save %{public}s to %{public}s", propName.c_str(), featureSpace->spaceName); + } + return constructor; +} + +napi_value JSUtils::GetClass(napi_env env, const std::string &spaceName, const std::string &className) +{ + auto featureSpace = GetJsFeatureSpace(spaceName); + if (!featureSpace.has_value()) { + return nullptr; + } + auto rootPropName = std::string(featureSpace->nameBase64); + napi_value root = nullptr; + napi_value global = nullptr; + napi_get_global(env, &global); + bool hasRoot; + napi_has_named_property(env, global, rootPropName.c_str(), &hasRoot); + if (!hasRoot) { + return nullptr; + } + napi_get_named_property(env, global, rootPropName.c_str(), &root); + std::string propName = "constructor_of_" + className; + napi_value constructor = nullptr; + bool hasProp = false; + napi_has_named_property(env, root, propName.c_str(), &hasProp); + if (!hasProp) { + return nullptr; + } + napi_get_named_property(env, root, propName.c_str(), &constructor); + if (constructor != nullptr) { + LOG_DEBUG("got %{public}s from %{public}s", propName.c_str(), featureSpace->spaceName); + return constructor; + } + hasProp = false; // no constructor. + return constructor; +} + +bool JSUtils::Equal(napi_env env, napi_ref ref, napi_value value) +{ + napi_value callback = nullptr; + napi_get_reference_value(env, ref, &callback); + + bool isEquals = false; + napi_strict_equals(env, value, callback, &isEquals); + return isEquals; +} + +napi_value JSUtils::ToJsObject(napi_env env, napi_value sendableValue) +{ + LOG_DEBUG("sendableObject -> jsObject"); + napi_value keys = nullptr; + napi_status status = napi_get_all_property_names(env, sendableValue, napi_key_own_only, + static_cast(napi_key_enumerable | napi_key_skip_symbols), napi_key_numbers_to_strings, &keys); + ASSERT(status == napi_ok, "napi_get_all_property_names failed", nullptr); + uint32_t length = 0; + status = napi_get_array_length(env, keys, &length); + ASSERT(status == napi_ok, "napi_get_array_length failed", nullptr); + std::vector descriptors; + // keysHold guarantees that the string address is valid before create the sendable object. + std::vector keysHold(length, ""); + for (uint32_t i = 0; i < length; ++i) { + napi_value key = nullptr; + status = napi_get_element(env, keys, i, &key); + ASSERT(status == napi_ok, "napi_get_element failed", nullptr); + JSUtils::Convert2Value(env, key, keysHold[i]); + napi_value value = nullptr; + status = napi_get_named_property(env, sendableValue, keysHold[i].c_str(), &value); + ASSERT(status == napi_ok, "napi_get_named_property failed", nullptr); + descriptors.emplace_back(DECLARE_JS_PROPERTY(env, keysHold[i].c_str(), value)); + } + napi_value jsObject = nullptr; + status = napi_create_object_with_properties(env, &jsObject, descriptors.size(), descriptors.data()); + ASSERT(status == napi_ok, "napi_create_object_with_properties failed", nullptr); + return jsObject; +} + +napi_value JSUtils::ToJsArray(napi_env env, napi_value sendableValue) +{ + LOG_DEBUG("sendableArray -> jsArray"); + uint32_t arrLen = 0; + napi_status status = napi_get_array_length(env, sendableValue, &arrLen); + ASSERT(status == napi_ok, "napi_get_array_length failed", nullptr); + napi_value jsArray = nullptr; + status = napi_create_array_with_length(env, arrLen, &jsArray); + ASSERT(status == napi_ok, "napi_create_array_with_length failed", nullptr); + for (size_t i = 0; i < arrLen; ++i) { + napi_value element; + status = napi_get_element(env, sendableValue, i, &element); + ASSERT(status == napi_ok, "napi_get_element failed", nullptr); + status = napi_set_element(env, jsArray, i, Convert2JSValue(env, element)); + ASSERT(status == napi_ok, "napi_set_element failed", nullptr); + } + return jsArray; +} + +napi_value JSUtils::ToJsTypedArray(napi_env env, napi_value sendableValue) +{ + LOG_DEBUG("sendableTypedArray -> jsTypedArray"); + napi_typedarray_type type; + size_t length = 0; + void *tmp = nullptr; + napi_status status = napi_get_typedarray_info(env, sendableValue, &type, &length, &tmp, nullptr, nullptr); + ASSERT(status == napi_ok, "napi_get_typedarray_info failed", nullptr); + + if (type != napi_uint8_array && type != napi_float32_array) { + LOG_ERROR("type is invalid %{public}d", type); + return nullptr; + } + napi_value jsTypedArray = nullptr; + void *native = nullptr; + napi_value buffer = nullptr; + status = napi_create_arraybuffer(env, length, (void **)&native, &buffer); + ASSERT(status == napi_ok, "napi_create_arraybuffer failed", nullptr); + if (length > 0) { + errno_t result = memcpy_s(native, length, tmp, length); + if (result != EOK) { + LOG_ERROR("memcpy_s failed, result is %{public}d", result); + return nullptr; + } + } + auto size = (type == napi_uint8_array) ? length : length / sizeof(float); + status = napi_create_typedarray(env, type, size, buffer, 0, &jsTypedArray); + ASSERT(status == napi_ok, "napi_create_typedarray failed", nullptr); + return jsTypedArray; +} + +napi_value JSUtils::Convert2JSValue(napi_env env, napi_value sendableValue) +{ + napi_valuetype type = napi_undefined; + napi_status status = napi_typeof(env, sendableValue, &type); + ASSERT(status == napi_ok, "napi_typeof failed", nullptr); + if (type != napi_object) { + return sendableValue; + } + bool result = false; + status = napi_is_sendable(env, sendableValue, &result); + ASSERT(status == napi_ok, "napi_is_sendable failed", nullptr); + if (!result) { + return sendableValue; + } + + status = napi_is_array(env, sendableValue, &result); + ASSERT(status == napi_ok, "napi_is_array failed", nullptr); + if (result) { + return ToJsArray(env, sendableValue); + } + status = napi_is_typedarray(env, sendableValue, &result); + ASSERT(status == napi_ok, "napi_is_typedarray failed", nullptr); + if (result) { + return ToJsTypedArray(env, sendableValue); + } + return ToJsObject(env, sendableValue); +} +} // namespace AppDataMgrJsKit +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/napi/featureAbility/data_ability/napi_data_ability_predicates.cpp b/frameworks/js/napi/featureAbility/data_ability/napi_data_ability_predicates.cpp new file mode 100644 index 0000000000..93d528a012 --- /dev/null +++ b/frameworks/js/napi/featureAbility/data_ability/napi_data_ability_predicates.cpp @@ -0,0 +1,815 @@ +/* + * Copyright (c) 2021 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. + */ +#define LOG_TAG "DataAbilityPredicatesProxy" +#include "napi_data_ability_predicates.h" + +#include "js_utils.h" +#include "logger.h" +#include "napi_async_proxy.h" +#include "napi_predicates_utils.h" + +using namespace OHOS::Rdb; +using namespace OHOS::NativeRdb; +using namespace OHOS::AppDataMgrJsKit; + +namespace OHOS { +namespace DataAbilityJsKit { +static __thread napi_ref constructor_ = nullptr; + +void DataAbilityPredicatesProxy::Init(napi_env env, napi_value exports) +{ + LOG_INFO("Init DataAbilityPredicatesProxy"); + napi_property_descriptor descriptors[] = { + DECLARE_NAPI_FUNCTION("equalTo", EqualTo), + DECLARE_NAPI_FUNCTION("notEqualTo", NotEqualTo), + DECLARE_NAPI_FUNCTION("beginWrap", BeginWrap), + DECLARE_NAPI_FUNCTION("endWrap", EndWrap), + DECLARE_NAPI_FUNCTION("or", Or), + DECLARE_NAPI_FUNCTION("and", And), + DECLARE_NAPI_FUNCTION("contains", Contains), + DECLARE_NAPI_FUNCTION("beginsWith", BeginsWith), + DECLARE_NAPI_FUNCTION("endsWith", EndsWith), + DECLARE_NAPI_FUNCTION("isNull", IsNull), + DECLARE_NAPI_FUNCTION("isNotNull", IsNotNull), + DECLARE_NAPI_FUNCTION("like", Like), + DECLARE_NAPI_FUNCTION("glob", Glob), + DECLARE_NAPI_FUNCTION("between", Between), + DECLARE_NAPI_FUNCTION("notBetween", NotBetween), + DECLARE_NAPI_FUNCTION("greaterThan", GreaterThan), + DECLARE_NAPI_FUNCTION("lessThan", LessThan), + DECLARE_NAPI_FUNCTION("greaterThanOrEqualTo", GreaterThanOrEqualTo), + DECLARE_NAPI_FUNCTION("lessThanOrEqualTo", LessThanOrEqualTo), + DECLARE_NAPI_FUNCTION("orderByAsc", OrderByAsc), + DECLARE_NAPI_FUNCTION("orderByDesc", OrderByDesc), + DECLARE_NAPI_FUNCTION("distinct", Distinct), + DECLARE_NAPI_FUNCTION("limitAs", Limit), + DECLARE_NAPI_FUNCTION("offsetAs", Offset), + DECLARE_NAPI_FUNCTION("groupBy", GroupBy), + DECLARE_NAPI_FUNCTION("indexedBy", IndexedBy), + DECLARE_NAPI_FUNCTION("in", In), + DECLARE_NAPI_FUNCTION("notIn", NotIn), + DECLARE_NAPI_FUNCTION("clear", Clear), + DECLARE_NAPI_FUNCTION("isRawSelection", IsRawSelection), + DECLARE_NAPI_GETTER_SETTER("whereClause", GetWhereClause, SetWhereClause), + DECLARE_NAPI_GETTER_SETTER("whereArgs", GetWhereArgs, SetWhereArgs), + DECLARE_NAPI_GETTER_SETTER("order", GetOrder, SetOrder), + DECLARE_NAPI_GETTER("limit", GetLimit), + DECLARE_NAPI_GETTER("offset", GetOffset), + DECLARE_NAPI_GETTER("isDistinct", IsDistinct), + DECLARE_NAPI_GETTER("group", GetGroup), + DECLARE_NAPI_GETTER("index", GetIndex), + DECLARE_NAPI_GETTER("isNeedAnd", IsNeedAnd), + DECLARE_NAPI_GETTER("isSorted", IsSorted), + }; + + napi_value cons = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_define_class(env, "DataAbilityPredicates", NAPI_AUTO_LENGTH, New, nullptr, + sizeof(descriptors) / sizeof(napi_property_descriptor), descriptors, &cons)); + + NAPI_CALL_RETURN_VOID(env, napi_create_reference(env, cons, 1, &constructor_)); + + NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, exports, "DataAbilityPredicates", cons)); +} + +napi_value DataAbilityPredicatesProxy::New(napi_env env, napi_callback_info info) +{ + napi_value new_target = nullptr; + NAPI_CALL(env, napi_get_new_target(env, info, &new_target)); + bool is_constructor = (new_target != nullptr); + + napi_value thiz = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr)); + + if (is_constructor) { + auto *proxy = new (std::nothrow) DataAbilityPredicatesProxy(); + if (proxy == nullptr) { + LOG_ERROR("DataAbilityPredicatesProxy::New new failed, proxy is nullptr."); + return nullptr; + } + napi_status status = napi_wrap(env, thiz, proxy, DataAbilityPredicatesProxy::Destructor, nullptr, nullptr); + if (status != napi_ok) { + LOG_ERROR("DataAbilityPredicatesProxy::New napi_wrap failed! napi_status:%{public}d!", status); + delete proxy; + return nullptr; + } + return thiz; + } + + napi_value cons = nullptr; + NAPI_CALL(env, napi_get_reference_value(env, constructor_, &cons)); + + napi_value output = nullptr; + NAPI_CALL(env, napi_new_instance(env, cons, 0, nullptr, &output)); + + return output; +} + +napi_value DataAbilityPredicatesProxy::NewInstance( + napi_env env, std::shared_ptr value) +{ + napi_value cons = nullptr; + napi_status status = napi_get_reference_value(env, constructor_, &cons); + if (status != napi_ok) { + LOG_ERROR("DataAbilityPredicatesProxy get constructor failed! napi_status:%{public}d!", status); + return nullptr; + } + + napi_value instance = nullptr; + status = napi_new_instance(env, cons, 0, nullptr, &instance); + if (status != napi_ok) { + LOG_ERROR("DataAbilityPredicatesProxy napi_new_instance failed! napi_status:%{public}d!", status); + return nullptr; + } + + DataAbilityPredicatesProxy *proxy = nullptr; + status = napi_unwrap(env, instance, reinterpret_cast(&proxy)); + if (status != napi_ok) { + LOG_ERROR("DataAbilityPredicatesProxy native instance is nullptr! napi_status:%{public}d!", status); + return instance; + } + proxy->predicates_ = std::move(value); + return instance; +} + +std::shared_ptr DataAbilityPredicatesProxy::GetNativePredicates( + const napi_env env, const napi_value arg) +{ + if (arg == nullptr) { + LOG_ERROR("DataAbilityPredicatesProxy arg is null."); + return nullptr; + } + DataAbilityPredicatesProxy *proxy = nullptr; + napi_unwrap(env, arg, reinterpret_cast(&proxy)); + if (proxy == nullptr) { + LOG_ERROR("DataAbilityPredicatesProxy proxy is null."); + return nullptr; + } + return proxy->predicates_; +} + +void DataAbilityPredicatesProxy::Destructor(napi_env env, void *nativeObject, void *) +{ + DataAbilityPredicatesProxy *proxy = static_cast(nativeObject); + delete proxy; +} + +DataAbilityPredicatesProxy::~DataAbilityPredicatesProxy() +{ +} + +DataAbilityPredicatesProxy::DataAbilityPredicatesProxy() : predicates_(new DataAbilityPredicates()) +{ +} + +std::shared_ptr DataAbilityPredicatesProxy::GetNativePredicates( + napi_env env, napi_callback_info info) +{ + DataAbilityPredicatesProxy *predicatesProxy = nullptr; + napi_value thiz = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr); + napi_unwrap(env, thiz, reinterpret_cast(&predicatesProxy)); + if (predicatesProxy == nullptr) { + return nullptr; + } + return predicatesProxy->predicates_; +} + +napi_value DataAbilityPredicatesProxy::EqualTo(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::EqualTo Invalid argvs!"); + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + ValueObject value; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid"); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->EqualTo(field, value); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::NotEqualTo(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::NotEqualTo Invalid argvs!"); + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + ValueObject value; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid"); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->NotEqualTo(field, value); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::BeginWrap(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->BeginWrap(); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::EndWrap(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->EndWrap(); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::Or(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->Or(); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::And(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->And(); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::Contains(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Contains Invalid argvs!"); + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + std::string value; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid"); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->Contains(field, value); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::BeginsWith(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::BeginsWith Invalid argvs!"); + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + std::string value; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid"); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->BeginsWith(field, value); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::EndsWith(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::EndsWith Invalid argvs!"); + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + std::string value; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid"); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->EndsWith(field, value); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::IsNull(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::IsNull Invalid argvs!"); + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->IsNull(field); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::IsNotNull(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::IsNotNull Invalid argvs!"); + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->IsNotNull(field); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::Like(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Like Invalid argvs!"); + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + std::string value; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid"); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->Like(field, value); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::Glob(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Glob Invalid argvs!"); + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + std::string value; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid"); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->Glob(field, value); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::Between(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 3; + // 3 represents the number of parameters + napi_value args[3] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Between Invalid argvs!"); + std::string field; + // args[0] represents the first parameter + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + ValueObject low; + // args[1] represents the second parameter + JSUtils::Convert2Value(env, args[1], low); + ValueObject high; + // args[2] represents the third parameter + JSUtils::Convert2Value(env, args[2], high); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->Between(field, low, high); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::NotBetween(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 3; + // 3 represents the number of parameters + napi_value args[3] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::NotBetween Invalid argvs!"); + std::string field; + // args[0] represents the first parameter + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + ValueObject low; + // args[1] represents the second parameter + JSUtils::Convert2Value(env, args[1], low); + ValueObject high; + // args[2] represents the third parameter + JSUtils::Convert2Value(env, args[2], high); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->NotBetween(field, low, high); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::GreaterThan(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::GreaterThan Invalid argvs!"); + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + ValueObject value; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid"); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->GreaterThan(field, value); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::LessThan(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::LessThan Invalid argvs!"); + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + ValueObject value; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid"); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->LessThan(field, value); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::GreaterThanOrEqualTo(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::GreaterThanOrEqualTo Invalid argvs!"); + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + ValueObject value; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid"); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->GreaterThanOrEqualTo(field, value); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::LessThanOrEqualTo(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::LessThanOrEqualTo Invalid argvs!"); + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + ValueObject value; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid"); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->LessThanOrEqualTo(field, value); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::OrderByAsc(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::OrderByAsc Invalid argvs!"); + + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->OrderByAsc(field); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::OrderByDesc(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::OrderByDesc Invalid argvs!"); + + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->OrderByDesc(field); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::Distinct(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->Distinct(); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::Limit(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Limit Invalid argvs!"); + + int32_t limit = 0; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2ValueExt(env, args[0], limit) == napi_ok, "the limit is invalid"); + + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->Limit(limit); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::Offset(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Offset Invalid argvs!"); + + int32_t offset = 0; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2ValueExt(env, args[0], offset) == napi_ok, "the offset is invalid"); + + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->Offset(offset); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::GroupBy(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::GroupBy Invalid argvs!"); + + std::vector fields = {}; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], fields) == napi_ok, "the fields is invalid"); + + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->GroupBy(fields); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::IndexedBy(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::IndexedBy Invalid argvs!"); + + std::string indexName; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], indexName) == napi_ok, "the indexName is invalid"); + + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->IndexedBy(indexName); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::In(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::In Invalid argvs!"); + + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + + std::vector values; + NAPI_ASSERT(env, JSUtils::Convert2Value(env, args[1], values) == napi_ok, "Invalid values!"); + + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->In(field, values); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::NotIn(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::NotIn Invalid argvs!"); + + std::string field; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid"); + + std::vector values; + NAPI_ASSERT(env, JSUtils::Convert2Value(env, args[1], values) == napi_ok, "Invalid values"); + + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->NotIn(field, values); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::Clear(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->Clear(); + return thiz; +} + +napi_value DataAbilityPredicatesProxy::IsRawSelection(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr); + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + bool out = nativePredicates->IsRawSelection(); + return JSUtils::Convert2JSValue(env, out); +} + +std::shared_ptr DataAbilityPredicatesProxy::GetPredicates() const +{ + return this->predicates_; +} + +napi_value DataAbilityPredicatesProxy::GetWhereClause(napi_env env, napi_callback_info info) +{ + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + auto ret = nativePredicates->GetWhereClause(); + return JSUtils::Convert2JSValue(env, ret); +} + +napi_value DataAbilityPredicatesProxy::SetWhereClause(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::SetWhereClause Invalid argvs!"); + + std::string whereClause; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], whereClause) == napi_ok, "whereClause is invalid"); + + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->SetWhereClause(whereClause); + + return thiz; +} + +napi_value DataAbilityPredicatesProxy::GetWhereArgs(napi_env env, napi_callback_info info) +{ + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + auto ret = nativePredicates->GetWhereArgs(); + return JSUtils::Convert2JSValue(env, ret); +} + +napi_value DataAbilityPredicatesProxy::SetWhereArgs(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::SetWhereArgs Invalid argvs!"); + + std::vector whereArgs; + NAPI_ASSERT(env, JSUtils::Convert2Value(env, args[0], whereArgs) == napi_ok, "Invalid whereArgs!"); + + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->SetWhereArgs(whereArgs); + + return thiz; +} + +napi_value DataAbilityPredicatesProxy::GetOrder(napi_env env, napi_callback_info info) +{ + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + auto ret = nativePredicates->GetOrder(); + return JSUtils::Convert2JSValue(env, ret); +} + +napi_value DataAbilityPredicatesProxy::SetOrder(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &thiz, nullptr); + NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::SetOrder Invalid argvs!"); + + std::string order; + RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], order) != napi_ok, "the order is invalid"); + + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + nativePredicates->SetOrder(order); + + return thiz; +} + +napi_value DataAbilityPredicatesProxy::GetLimit(napi_env env, napi_callback_info info) +{ + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + return JSUtils::Convert2JSValue(env, nativePredicates->GetLimit()); +} + +napi_value DataAbilityPredicatesProxy::GetOffset(napi_env env, napi_callback_info info) +{ + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + return JSUtils::Convert2JSValue(env, nativePredicates->GetOffset()); +} + +napi_value DataAbilityPredicatesProxy::IsDistinct(napi_env env, napi_callback_info info) +{ + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + return JSUtils::Convert2JSValue(env, nativePredicates->IsDistinct()); +} + +napi_value DataAbilityPredicatesProxy::GetGroup(napi_env env, napi_callback_info info) +{ + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + auto ret = nativePredicates->GetGroup(); + return JSUtils::Convert2JSValue(env, ret); +} + +napi_value DataAbilityPredicatesProxy::GetIndex(napi_env env, napi_callback_info info) +{ + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + auto ret = nativePredicates->GetIndex(); + return JSUtils::Convert2JSValue(env, ret); +} + +napi_value DataAbilityPredicatesProxy::IsNeedAnd(napi_env env, napi_callback_info info) +{ + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + return JSUtils::Convert2JSValue(env, nativePredicates->IsNeedAnd()); +} + +napi_value DataAbilityPredicatesProxy::IsSorted(napi_env env, napi_callback_info info) +{ + auto nativePredicates = GetNativePredicates(env, info); + RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr"); + return JSUtils::Convert2JSValue(env, nativePredicates->IsSorted()); +} +} // namespace DataAbilityJsKit +} // namespace OHOS + +EXTERN_C_START +__attribute__((visibility("default"))) + napi_value NAPI_OHOS_Data_DataAbilityJsKit_DataAbilityPredicatesProxy_NewInstance( + napi_env env, OHOS::NativeRdb::DataAbilityPredicates *predicates) +{ + return OHOS::DataAbilityJsKit::DataAbilityPredicatesProxy::NewInstance( + env, std::shared_ptr(predicates)); +} + +__attribute__((visibility("default"))) OHOS::NativeRdb::DataAbilityPredicates * +NAPI_OHOS_Data_DataAbilityJsKit_DataAbilityPredicatesProxy_GetNativeObject(const napi_env env, const napi_value arg) +{ + auto predicates = OHOS::DataAbilityJsKit::DataAbilityPredicatesProxy::GetNativePredicates(env, arg); + return predicates.get(); +} +EXTERN_C_END \ No newline at end of file diff --git a/frameworks/js/napi/featureAbility/data_ability/napi_rdb_js_utils.cpp b/frameworks/js/napi/featureAbility/data_ability/napi_rdb_js_utils.cpp new file mode 100644 index 0000000000..f346f757bd --- /dev/null +++ b/frameworks/js/napi/featureAbility/data_ability/napi_rdb_js_utils.cpp @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2023 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. + */ +#define LOG_TAG "NapiRdbJsUtils" +#include "napi_rdb_js_utils.h" + +#include "logger.h" +#include "result_set.h" + +namespace OHOS::AppDataMgrJsKit { +namespace JSUtils { +using namespace OHOS::Rdb; +using namespace NativeRdb; + +template<> +int32_t Convert2Value(napi_env env, napi_value jsValue, Asset &output) +{ + napi_valuetype type = napi_undefined; + napi_status status = napi_typeof(env, jsValue, &type); + if (status != napi_ok || type != napi_object) { + LOG_DEBUG("napi_typeof failed status = %{public}d type = %{public}d", status, type); + return napi_invalid_arg; + } + + NAPI_CALL_BASE(env, GetNamedProperty(env, jsValue, "version", output.version), napi_invalid_arg); + NAPI_CALL_BASE(env, GetNamedProperty(env, jsValue, "name", output.name), napi_invalid_arg); + NAPI_CALL_BASE(env, GetNamedProperty(env, jsValue, "uri", output.uri), napi_invalid_arg); + NAPI_CALL_BASE(env, GetNamedProperty(env, jsValue, "createTime", output.createTime), napi_invalid_arg); + NAPI_CALL_BASE(env, GetNamedProperty(env, jsValue, "modifyTime", output.modifyTime), napi_invalid_arg); + NAPI_CALL_BASE(env, GetNamedProperty(env, jsValue, "size", output.size), napi_invalid_arg); + NAPI_CALL_BASE(env, GetNamedProperty(env, jsValue, "hash", output.hash), napi_invalid_arg); + return napi_ok; +} + +template<> +napi_value Convert2JSValue(napi_env env, const Asset &value) +{ + napi_value object = nullptr; + NAPI_CALL_BASE(env, napi_create_object(env, &object), object); + NAPI_CALL_BASE(env, SetNamedProperty(env, object, "version", value.version), object); + NAPI_CALL_BASE(env, SetNamedProperty(env, object, "name", value.name), object); + NAPI_CALL_BASE(env, SetNamedProperty(env, object, "uri", value.uri), object); + NAPI_CALL_BASE(env, SetNamedProperty(env, object, "createTime", value.createTime), object); + NAPI_CALL_BASE(env, SetNamedProperty(env, object, "modifyTime", value.modifyTime), object); + NAPI_CALL_BASE(env, SetNamedProperty(env, object, "size", value.size), object); + NAPI_CALL_BASE(env, SetNamedProperty(env, object, "hash", value.hash), object); + return object; +} + +template<> +napi_value Convert2JSValue(napi_env env, const RowEntity &rowEntity) +{ + napi_value ret = nullptr; + NAPI_CALL(env, napi_create_object(env, &ret)); + auto &values = rowEntity.Get(); + for (auto const &[key, object] : values) { + napi_value value = JSUtils::Convert2JSValue(env, object.value); + NAPI_CALL(env, napi_set_named_property(env, ret, key.c_str(), value)); + } + return ret; +} + +template<> +int32_t Convert2Value(napi_env env, napi_value jsValue, ValueObject &valueObject) +{ + auto status = Convert2Value(env, jsValue, valueObject.value); + if (status != napi_ok) { + return napi_invalid_arg; + } + return napi_ok; +} + +template<> +napi_value Convert2JSValue(napi_env env, const BigInt& value) +{ + napi_value val = nullptr; + napi_status status = napi_create_bigint_words(env, value.Sign(), value.Size(), value.TrueForm(), &val); + if (status != napi_ok) { + return nullptr; + } + return val; +} + +template<> +int32_t Convert2Value(napi_env env, napi_value jsValue, BigInt& value) +{ + napi_valuetype type = napi_undefined; + napi_status status = napi_typeof(env, jsValue, &type); + if (status != napi_ok || type != napi_bigint) { + return napi_invalid_arg; + } + int sign = 0; + size_t count = 0; + status = napi_get_value_bigint_words(env, jsValue, nullptr, &count, nullptr); + if (status != napi_ok) { + return napi_bigint_expected; + } + std::vector words(count, 0); + status = napi_get_value_bigint_words(env, jsValue, &sign, &count, words.data()); + if (status != napi_ok) { + return napi_bigint_expected; + } + value = BigInteger(sign, std::move(words)); + return napi_ok; +} +}; // namespace JSUtils +} // namespace OHOS::AppDataMgrJsKit \ No newline at end of file diff --git a/frameworks/js/napi/featureAbility/data_ability/napi_result_set.cpp b/frameworks/js/napi/featureAbility/data_ability/napi_result_set.cpp new file mode 100644 index 0000000000..1f12bd438e --- /dev/null +++ b/frameworks/js/napi/featureAbility/data_ability/napi_result_set.cpp @@ -0,0 +1,640 @@ +/* + * Copyright (c) 2022 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. + */ +#define LOG_TAG "ResultSetProxy" +#include "napi_result_set.h" + +#include + +#include "js_utils.h" +#include "logger.h" +#include "napi_rdb_error.h" +#include "napi_rdb_trace.h" +#include "rdb_errno.h" + +#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) +#include "abs_shared_result_set.h" +#include "rdb_result_set_bridge.h" +#include "shared_block.h" +#include "string_ex.h" +#endif + +using namespace OHOS::Rdb; +using namespace OHOS::NativeRdb; +using namespace OHOS::AppDataMgrJsKit; + +namespace OHOS { +namespace RdbJsKit { +static napi_ref __thread ctorRef_ = nullptr; +static napi_ref __thread ctorRefV9_ = nullptr; +static const int E_OK = 0; + +#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) +napi_value ResultSetProxy::NewInstance(napi_env env, std::shared_ptr resultSet, int version) +{ + auto instance = NewInstance(env, std::static_pointer_cast(resultSet), version); + ResultSetProxy *proxy = nullptr; + auto status = napi_unwrap(env, instance, reinterpret_cast(&proxy)); + if (proxy == nullptr) { + LOG_ERROR("NewInstance native instance is nullptr! code:%{public}d!", status); + return instance; + } + + if (resultSet != nullptr && resultSet->GetBlock() != nullptr) { + proxy->sharedBlockName_ = resultSet->GetBlock()->Name(); + proxy->sharedBlockAshmemFd_ = resultSet->GetBlock()->GetFd(); + } + proxy->sharedResultSet_ = resultSet; + return instance; +} +#endif + +napi_value ResultSetProxy::NewInstance(napi_env env, std::shared_ptr resultSet, int version) +{ + napi_value cons = GetConstructor(env, version); + if (cons == nullptr) { + LOG_ERROR("NewInstance GetConstructor is nullptr!"); + return nullptr; + } + napi_value instance = nullptr; + napi_status status = napi_new_instance(env, cons, 0, nullptr, &instance); + if (status != napi_ok) { + LOG_ERROR("NewInstance napi_new_instance failed! code:%{public}d!", status); + return nullptr; + } + + ResultSetProxy *proxy = nullptr; + status = napi_unwrap(env, instance, reinterpret_cast(&proxy)); + if (proxy == nullptr) { + LOG_ERROR("NewInstance native instance is nullptr! code:%{public}d!", status); + return instance; + } + *proxy = std::move(resultSet); + return instance; +} + +#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) +std::shared_ptr ResultSetProxy::GetNativeObject( + napi_env const env, napi_value const arg) +{ + if (arg == nullptr) { + LOG_ERROR("ResultSetProxy GetNativeObject arg is null."); + return nullptr; + } + ResultSetProxy *proxy = nullptr; + napi_unwrap(env, arg, reinterpret_cast(&proxy)); + if (proxy == nullptr || proxy->sharedResultSet_ == nullptr) { + LOG_ERROR("ResultSetProxy GetNativeObject proxy or sharedResultSet_ is null."); + return nullptr; + } + return proxy->sharedResultSet_; +} + +std::shared_ptr ResultSetProxy::Create() +{ + auto instance = GetInstance(); + if (instance == nullptr) { + LOG_ERROR("resultSet_ is null."); + return nullptr; + } + SetInstance(nullptr); + return std::make_shared(instance); +} +#endif + +napi_value ResultSetProxy::GetConstructor(napi_env env, int version) +{ + napi_value cons = nullptr; + if (version > APIVERSION_8 && ctorRefV9_ != nullptr) { + NAPI_CALL(env, napi_get_reference_value(env, ctorRefV9_, &cons)); + return cons; + } + if (version == APIVERSION_8 && ctorRef_ != nullptr) { + NAPI_CALL(env, napi_get_reference_value(env, ctorRef_, &cons)); + return cons; + } + + napi_property_descriptor clzDes[] = { + DECLARE_NAPI_FUNCTION("goToRow", GoToRow), + DECLARE_NAPI_FUNCTION("getLong", GetLong), + DECLARE_NAPI_FUNCTION("getColumnType", GetColumnType), + DECLARE_NAPI_FUNCTION("goTo", GoTo), + DECLARE_NAPI_FUNCTION("getColumnIndex", GetColumnIndex), + DECLARE_NAPI_FUNCTION("getInt", GetInt), + DECLARE_NAPI_FUNCTION("getColumnName", GetColumnName), + DECLARE_NAPI_FUNCTION("close", Close), + DECLARE_NAPI_FUNCTION("goToFirstRow", GoToFirstRow), + DECLARE_NAPI_FUNCTION("goToLastRow", GoToLastRow), + DECLARE_NAPI_FUNCTION("goToNextRow", GoToNextRow), + DECLARE_NAPI_FUNCTION("goToPreviousRow", GoToPreviousRow), + DECLARE_NAPI_FUNCTION("getBlob", GetBlob), + DECLARE_NAPI_FUNCTION("getString", GetString), + DECLARE_NAPI_FUNCTION("getDouble", GetDouble), + DECLARE_NAPI_FUNCTION("isColumnNull", IsColumnNull), + + DECLARE_NAPI_GETTER("columnNames", GetAllColumnNames), + DECLARE_NAPI_GETTER("columnCount", GetColumnCount), + DECLARE_NAPI_GETTER("isEnded", IsEnded), + DECLARE_NAPI_GETTER("isStarted", IsBegin), + DECLARE_NAPI_GETTER("isClosed", IsClosed), + DECLARE_NAPI_GETTER("rowCount", GetRowCount), + DECLARE_NAPI_GETTER("rowIndex", GetRowIndex), + DECLARE_NAPI_GETTER("isAtFirstRow", IsAtFirstRow), + DECLARE_NAPI_GETTER("isAtLastRow", IsAtLastRow), + }; + + if (version > APIVERSION_8) { + NAPI_CALL(env, napi_define_class(env, "ResultSetV9", NAPI_AUTO_LENGTH, InitializeV9, nullptr, + sizeof(clzDes) / sizeof(napi_property_descriptor), clzDes, &cons)); + NAPI_CALL(env, napi_create_reference(env, cons, 1, &ctorRefV9_)); + return cons; + } + + NAPI_CALL(env, napi_define_class(env, "ResultSet", NAPI_AUTO_LENGTH, Initialize, nullptr, + sizeof(clzDes) / sizeof(napi_property_descriptor), clzDes, &cons)); + NAPI_CALL(env, napi_create_reference(env, cons, 1, &ctorRef_)); + return cons; +} + +napi_value ResultSetProxy::InnerInitialize(napi_env env, napi_callback_info info, int version) +{ + napi_value self = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &self, nullptr)); + auto *proxy = new (std::nothrow) ResultSetProxy(); + if (proxy == nullptr) { + LOG_ERROR("ResultSetProxy::InnerInitialize new failed, proxy is nullptr."); + return nullptr; + } + proxy->apiversion = version; + auto finalize = [](napi_env env, void *data, void *hint) { + ResultSetProxy *proxy = reinterpret_cast(data); + delete proxy; + }; + napi_status status = napi_wrap(env, self, proxy, finalize, nullptr, nullptr); + if (status != napi_ok) { + LOG_ERROR("ResultSetProxy napi_wrap failed! code:%{public}d!, version:%{public}d.", status, version); + finalize(env, proxy, nullptr); + return nullptr; + } + return self; +} + +napi_value ResultSetProxy::Initialize(napi_env env, napi_callback_info info) +{ + return InnerInitialize(env, info, APIVERSION_8); +} + +napi_value ResultSetProxy::InitializeV9(napi_env env, napi_callback_info info) +{ + return InnerInitialize(env, info, APIVERSION_V9); +} + +ResultSetProxy::~ResultSetProxy() +{ + LOG_DEBUG("ResultSetProxy destructor!"); +} + +ResultSetProxy::ResultSetProxy(std::shared_ptr resultSet) +{ + if (GetInstance() == resultSet) { + return; + } + SetInstance(std::move(resultSet)); +} + +ResultSetProxy &ResultSetProxy::operator=(std::shared_ptr resultSet) +{ + if (GetInstance() == resultSet) { + return *this; + } + SetInstance(std::move(resultSet)); + return *this; +} + +ResultSetProxy *ResultSetProxy::GetInnerResultSet(napi_env env, napi_callback_info info, int &version) +{ + ResultSetProxy *resultSetProxy = nullptr; + napi_value self = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &self, nullptr); + napi_unwrap(env, self, reinterpret_cast(&resultSetProxy)); + RDB_NAPI_ASSERT_FROMV9(env, resultSetProxy && resultSetProxy->GetInstance(), std::make_shared(), + resultSetProxy->apiversion); + + version = resultSetProxy->apiversion; + return resultSetProxy; +} + +ResultSetProxy *ResultSetProxy::ParseInt32FieldByName( + napi_env env, napi_callback_info info, int32_t &field, const std::string& name) +{ + DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__)); + napi_value self = nullptr; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &self, nullptr); + ResultSetProxy *resultSetProxy = nullptr; + napi_unwrap(env, self, reinterpret_cast(&resultSetProxy)); + RDB_NAPI_ASSERT_FROMV9(env, resultSetProxy && resultSetProxy->GetInstance(), + std::make_shared("resultSet", "not null"), resultSetProxy->apiversion); + RDB_NAPI_ASSERT_FROMV9( + env, argc == 1, std::make_shared("1"), resultSetProxy->apiversion); + + napi_status status = napi_get_value_int32(env, args[0], &field); + RDB_NAPI_ASSERT_FROMV9( + env, status == napi_ok, std::make_shared(name, "a number."), resultSetProxy->apiversion); + return resultSetProxy; +} + +ResultSetProxy *ResultSetProxy::ParseFieldByName(napi_env env, napi_callback_info info, std::string &field) +{ + napi_value self = nullptr; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_get_cb_info(env, info, &argc, args, &self, nullptr); + ResultSetProxy *resultSetProxy = nullptr; + napi_unwrap(env, self, reinterpret_cast(&resultSetProxy)); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + RDB_NAPI_ASSERT_FROMV9( + env, argc == 1, std::make_shared("1"), resultSetProxy->apiversion); + + field = JSUtils::Convert2String(env, args[0]); + return resultSetProxy; +} + +napi_value ResultSetProxy::GetAllColumnNames(napi_env env, napi_callback_info info) +{ + std::vector colNames; + int version = 0; + auto resultSetProxy = GetInnerResultSet(env, info, version); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GetAllColumnNames(colNames); + if (errCode != E_OK) { + LOG_ERROR("GetAllColumnNames failed code:%{public}d, version:%{public}d.", errCode, version); + } + return JSUtils::Convert2JSValue(env, colNames); +} + +napi_value ResultSetProxy::GoToRow(napi_env env, napi_callback_info info) +{ + int32_t position; + auto resultSetProxy = ParseInt32FieldByName(env, info, position, "position"); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GoToRow(position); + return JSUtils::Convert2JSValue(env, (errCode == E_OK)); +} + +napi_value ResultSetProxy::GetColumnCount(napi_env env, napi_callback_info info) +{ + int32_t count = 0; + int version = 0; + auto resultSetProxy = GetInnerResultSet(env, info, version); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GetColumnCount(count); + if (errCode != E_OK) { + LOG_ERROR("GetColumnCount failed code:%{public}d, version:%{public}d.", errCode, version); + } + return JSUtils::Convert2JSValue(env, count); +} + +napi_value ResultSetProxy::GetLong(napi_env env, napi_callback_info info) +{ + int32_t columnIndex; + int64_t result; + auto resultSetProxy = ParseInt32FieldByName(env, info, columnIndex, "columnIndex"); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GetLong(columnIndex, result); + int version = resultSetProxy->apiversion; + RDB_NAPI_ASSERT_FROMV9(env, errCode == E_OK, std::make_shared(), version); + return JSUtils::Convert2JSValue(env, result); +} + +napi_value ResultSetProxy::GetColumnType(napi_env env, napi_callback_info info) +{ + int32_t columnIndex; + ColumnType columnType; + auto resultSetProxy = ParseInt32FieldByName(env, info, columnIndex, "columnIndex"); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GetColumnType(columnIndex, columnType); + if (errCode != E_OK) { + LOG_ERROR("GetColumnType failed code:%{public}d, version:%{public}d.", errCode, resultSetProxy->apiversion); + } + return JSUtils::Convert2JSValue(env, int32_t(columnType)); +} + +napi_value ResultSetProxy::GoTo(napi_env env, napi_callback_info info) +{ + int32_t offset; + auto resultSetProxy = ParseInt32FieldByName(env, info, offset, "offset"); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GoTo(offset); + return JSUtils::Convert2JSValue(env, (errCode == E_OK)); +} + +napi_value ResultSetProxy::GetColumnIndex(napi_env env, napi_callback_info info) +{ + std::string input; + int32_t result = -1; + auto resultSetProxy = ParseFieldByName(env, info, input); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GetColumnIndex(input, result); + if (errCode != E_OK) { + LOG_ERROR("GetColumnIndex failed code:%{public}d, version:%{public}d.", errCode, resultSetProxy->apiversion); + } + return JSUtils::Convert2JSValue(env, result); +} + +napi_value ResultSetProxy::GetInt(napi_env env, napi_callback_info info) +{ + int32_t columnIndex; + int32_t result; + auto resultSetProxy = ParseInt32FieldByName(env, info, columnIndex, "columnIndex"); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GetInt(columnIndex, result); + int version = resultSetProxy->apiversion; + RDB_NAPI_ASSERT_FROMV9(env, errCode == E_OK, std::make_shared(), version); + return JSUtils::Convert2JSValue(env, result); +} + +napi_value ResultSetProxy::GetColumnName(napi_env env, napi_callback_info info) +{ + int32_t columnIndex; + std::string result; + auto resultSetProxy = ParseInt32FieldByName(env, info, columnIndex, "columnIndex"); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GetColumnName(columnIndex, result); + if (errCode != E_OK) { + LOG_ERROR("GetColumnName failed code:%{public}d, version:%{public}d.", errCode, resultSetProxy->apiversion); + } + return JSUtils::Convert2JSValue(env, result); +} + +napi_value ResultSetProxy::Close(napi_env env, napi_callback_info info) +{ + int version = 0; + auto resultSetProxy = GetInnerResultSet(env, info, version); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->Close(); + RDB_NAPI_ASSERT_FROMV9(env, errCode == E_OK, std::make_shared(), version); + napi_value result = nullptr; + napi_get_null(env, &result); + return result; +} + +napi_value ResultSetProxy::GetRowCount(napi_env env, napi_callback_info info) +{ + int version = 0; + ResultSetProxy *resultSetProxy = GetInnerResultSet(env, info, version); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int32_t result; + int errCode = resultSetProxy->GetInstance()->GetRowCount(result); + if (errCode != E_OK) { + LOG_ERROR("GetRowCount failed code:%{public}d, version:%{public}d.", errCode, version); + } + return JSUtils::Convert2JSValue(env, result); +} + +napi_value ResultSetProxy::GetRowIndex(napi_env env, napi_callback_info info) +{ + int version = 0; + auto resultSetProxy = GetInnerResultSet(env, info, version); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int32_t result; + int errCode = resultSetProxy->GetInstance()->GetRowIndex(result); + if (errCode != E_OK) { + LOG_ERROR("GetRowIndex failed code:%{public}d, version:%{public}d.", errCode, version); + } + return JSUtils::Convert2JSValue(env, result); +} + +napi_value ResultSetProxy::IsEnded(napi_env env, napi_callback_info info) +{ + int version = 0; + auto resultSetProxy = GetInnerResultSet(env, info, version); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + bool result = false; + int errCode = resultSetProxy->GetInstance()->IsEnded(result); + if (errCode != E_OK) { + LOG_ERROR("IsEnded failed code:%{public}d, version:%{public}d.", errCode, version); + result = true; + } + return JSUtils::Convert2JSValue(env, result); +} + +napi_value ResultSetProxy::IsBegin(napi_env env, napi_callback_info info) +{ + int version = 0; + auto resultSetProxy = GetInnerResultSet(env, info, version); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + bool result = false; + int errCode = resultSetProxy->GetInstance()->IsStarted(result); + if (errCode != E_OK) { + LOG_ERROR("IsBegin failed code:%{public}d, version:%{public}d.", errCode, version); + } + return JSUtils::Convert2JSValue(env, result); +} + +napi_value ResultSetProxy::GoToFirstRow(napi_env env, napi_callback_info info) +{ + int version = 0; + auto resultSetProxy = GetInnerResultSet(env, info, version); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GoToFirstRow(); + return JSUtils::Convert2JSValue(env, (errCode == E_OK)); +} + +napi_value ResultSetProxy::GoToLastRow(napi_env env, napi_callback_info info) +{ + int version = 0; + auto resultSetProxy = GetInnerResultSet(env, info, version); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GoToLastRow(); + return JSUtils::Convert2JSValue(env, (errCode == E_OK)); +} + +napi_value ResultSetProxy::GoToNextRow(napi_env env, napi_callback_info info) +{ + int version = 0; + auto resultSetProxy = GetInnerResultSet(env, info, version); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GoToNextRow(); + return JSUtils::Convert2JSValue(env, (errCode == E_OK)); +} + +napi_value ResultSetProxy::GoToPreviousRow(napi_env env, napi_callback_info info) +{ + int version = 0; + auto resultSetProxy = GetInnerResultSet(env, info, version); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GoToPreviousRow(); + return JSUtils::Convert2JSValue(env, (errCode == E_OK)); +} + +napi_value ResultSetProxy::IsAtFirstRow(napi_env env, napi_callback_info info) +{ + int version = 0; + auto resultSetProxy = GetInnerResultSet(env, info, version); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + bool result = false; + int errCode = resultSetProxy->GetInstance()->IsAtFirstRow(result); + if (errCode != E_OK) { + LOG_ERROR("IsAtFirstRow failed code:%{public}d, version:%{public}d.", errCode, version); + } + return JSUtils::Convert2JSValue(env, result); +} + +napi_value ResultSetProxy::IsAtLastRow(napi_env env, napi_callback_info info) +{ + int version = 0; + auto resultSetProxy = GetInnerResultSet(env, info, version); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + bool result = false; + int errCode = resultSetProxy->GetInstance()->IsAtLastRow(result); + if (errCode != E_OK) { + LOG_ERROR("IsAtLastRow failed code:%{public}d, version:%{public}d.", errCode, version); + } + return JSUtils::Convert2JSValue(env, result); +} + +napi_value ResultSetProxy::GetBlob(napi_env env, napi_callback_info info) +{ + DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__)); + int32_t columnIndex; + std::vector result; + auto resultSetProxy = ParseInt32FieldByName(env, info, columnIndex, "columnIndex"); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GetBlob(columnIndex, result); + int version = resultSetProxy->apiversion; + RDB_NAPI_ASSERT_FROMV9(env, errCode == E_OK, std::make_shared(), version); + return JSUtils::Convert2JSValue(env, result); +} + +napi_value ResultSetProxy::GetString(napi_env env, napi_callback_info info) +{ + DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__)); + int32_t columnIndex; + std::string result; + auto resultSetProxy = ParseInt32FieldByName(env, info, columnIndex, "columnIndex"); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GetString(columnIndex, result); + int version = resultSetProxy->apiversion; + RDB_NAPI_ASSERT_FROMV9(env, errCode == E_OK, std::make_shared(), version); + return JSUtils::Convert2JSValue(env, result); +} + +napi_value ResultSetProxy::GetDouble(napi_env env, napi_callback_info info) +{ + int32_t columnIndex; + double result = 0.0; + auto resultSetProxy = ParseInt32FieldByName(env, info, columnIndex, "columnIndex"); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->GetDouble(columnIndex, result); + int version = resultSetProxy->apiversion; + RDB_NAPI_ASSERT_FROMV9(env, errCode == E_OK, std::make_shared(), version); + return JSUtils::Convert2JSValue(env, result); +} + +napi_value ResultSetProxy::IsColumnNull(napi_env env, napi_callback_info info) +{ + int32_t columnIndex; + bool result = false; + auto resultSetProxy = ParseInt32FieldByName(env, info, columnIndex, "columnIndex"); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int errCode = resultSetProxy->GetInstance()->IsColumnNull(columnIndex, result); + int version = resultSetProxy->apiversion; + RDB_NAPI_ASSERT_FROMV9(env, errCode == E_OK, std::make_shared(), version); + napi_value output = nullptr; + napi_get_boolean(env, result, &output); + return output; +} + +napi_value ResultSetProxy::IsClosed(napi_env env, napi_callback_info info) +{ + int version = 0; + auto resultSetProxy = GetInnerResultSet(env, info, version); + RDB_CHECK_RETURN_NULLPTR(resultSetProxy && resultSetProxy->GetInstance(), "Proxy or instance is nullptr"); + + int result = resultSetProxy->GetInstance()->IsClosed(); + napi_value output = nullptr; + napi_get_boolean(env, result, &output); + return output; +} + +napi_value ResultSetProxy::GetSharedBlockName(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr)); + + ResultSetProxy *proxy; + NAPI_CALL(env, napi_unwrap(env, thiz, reinterpret_cast(&proxy))); + RDB_CHECK_RETURN_NULLPTR(proxy != nullptr, + "ResultSetProxy::GetSharedBlockName proxy is nullptr"); + + return JSUtils::Convert2JSValue(env, proxy->sharedBlockName_); +} + +napi_value ResultSetProxy::GetSharedBlockAshmemFd(napi_env env, napi_callback_info info) +{ + napi_value thiz = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr)); + + ResultSetProxy *proxy; + NAPI_CALL(env, napi_unwrap(env, thiz, reinterpret_cast(&proxy))); + RDB_CHECK_RETURN_NULLPTR(proxy != nullptr, + "ResultSetProxy::GetSharedBlockAshmemFd proxy is nullptr"); + + return JSUtils::Convert2JSValue(env, proxy->sharedBlockAshmemFd_); +} +} // namespace RdbJsKit +} // namespace OHOS + +#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) + +__attribute__((visibility("default"))) napi_value NewCInstance(napi_env env, + napi_value arg) asm("NAPI_OHOS_Data_RdbJsKit_ResultSetProxy_NewInstance"); +napi_value NewCInstance(napi_env env, std::shared_ptr resultSet) +{ + return OHOS::RdbJsKit::ResultSetProxy::NewInstance(env, resultSet); +} + +__attribute__((visibility("default"))) std::shared_ptr GetCObject(napi_env env, + napi_value arg) asm("NAPI_OHOS_Data_RdbJsKit_ResultSetProxy_GetNativeObject"); +std::shared_ptr GetCObject(napi_env env, napi_value arg) +{ + return OHOS::RdbJsKit::ResultSetProxy::GetNativeObject(env, arg); +} +#endif \ No newline at end of file diff --git a/frameworks/js/napi/feature_ability/BUILD.gn b/frameworks/js/napi/feature_ability/BUILD.gn index 8984cf76fd..d85fae49c6 100644 --- a/frameworks/js/napi/feature_ability/BUILD.gn +++ b/frameworks/js/napi/feature_ability/BUILD.gn @@ -34,8 +34,10 @@ ohos_shared_library("featureability_napi") { external_deps = [ "ability_base:want", "ability_base:zuri", + "bundle_framework:appexecfwk_base", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", "hilog:libhilog", "napi:ace_napi", ] diff --git a/frameworks/js/napi/inner/napi_ability_common/BUILD.gn b/frameworks/js/napi/inner/napi_ability_common/BUILD.gn index 24ad4ca3b6..23962bc3fe 100644 --- a/frameworks/js/napi/inner/napi_ability_common/BUILD.gn +++ b/frameworks/js/napi/inner/napi_ability_common/BUILD.gn @@ -50,12 +50,14 @@ ohos_shared_library("napi_ability_common") { "ability_base:want", "access_token:libtokenid_sdk", "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_base", "c_utils:utils", "common_event_service:cesfwk_innerkits", "hilog:libhilog", "ipc:ipc_core", "ipc:ipc_napi", "napi:ace_napi", + "samgr:samgr_proxy", ] public_external_deps = [ diff --git a/frameworks/js/napi/inner/napi_common/BUILD.gn b/frameworks/js/napi/inner/napi_common/BUILD.gn index 709cc71afb..359215999c 100644 --- a/frameworks/js/napi/inner/napi_common/BUILD.gn +++ b/frameworks/js/napi/inner/napi_common/BUILD.gn @@ -56,6 +56,7 @@ ohos_shared_library("napi_common") { "access_token:libtokenid_sdk", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", "hilog:libhilog", "ipc:ipc_core", "ipc:ipc_napi", @@ -78,6 +79,7 @@ ohos_shared_library("napi_common") { ] public_external_deps += [ "form_fwk:form_manager", + "graphic_2d:EGL", "window_manager:libdm", ] } diff --git a/frameworks/js/napi/insight_intent/insight_intent_driver/BUILD.gn b/frameworks/js/napi/insight_intent/insight_intent_driver/BUILD.gn index 6f792a33a8..dcc0986299 100644 --- a/frameworks/js/napi/insight_intent/insight_intent_driver/BUILD.gn +++ b/frameworks/js/napi/insight_intent/insight_intent_driver/BUILD.gn @@ -40,6 +40,7 @@ ohos_shared_library("insightintentdriver_napi") { "eventhandler:libeventhandler", "hilog:libhilog", "ipc:ipc_core", + "ipc:ipc_napi", "napi:ace_napi", ] cflags_cc = [] diff --git a/frameworks/js/napi/js_child_process_manager/BUILD.gn b/frameworks/js/napi/js_child_process_manager/BUILD.gn index 87c91c1b6e..a74aa198d5 100644 --- a/frameworks/js/napi/js_child_process_manager/BUILD.gn +++ b/frameworks/js/napi/js_child_process_manager/BUILD.gn @@ -34,9 +34,10 @@ ohos_shared_library("childprocessmanager_napi") { ] external_deps = [ - "ability_base:session_info", "c_utils:utils", + "eventhandler:libeventhandler", "hilog:libhilog", + "ipc:ipc_core", "napi:ace_napi", ] diff --git a/frameworks/js/napi/js_dialog_request/BUILD.gn b/frameworks/js/napi/js_dialog_request/BUILD.gn index 82e3b32977..67289e22ac 100755 --- a/frameworks/js/napi/js_dialog_request/BUILD.gn +++ b/frameworks/js/napi/js_dialog_request/BUILD.gn @@ -45,8 +45,10 @@ ohos_shared_library("dialogrequest_napi") { "common_event_service:cesfwk_innerkits", "hilog:libhilog", "ipc:ipc_core", + "ipc:ipc_napi", "napi:ace_napi", ] + cflags_cc = [] if (os_dlp_part_enabled) { cflags_cc += [ "-DWITH_DLP" ] diff --git a/frameworks/js/napi/js_dialog_session/BUILD.gn b/frameworks/js/napi/js_dialog_session/BUILD.gn index ca35168eb7..fe6117de3e 100644 --- a/frameworks/js/napi/js_dialog_session/BUILD.gn +++ b/frameworks/js/napi/js_dialog_session/BUILD.gn @@ -37,7 +37,6 @@ ohos_shared_library("dialogsession_napi") { } external_deps = [ "ability_base:extractortool", - "ability_base:session_info", "ability_base:want", "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", @@ -47,10 +46,10 @@ ohos_shared_library("dialogsession_napi") { "hilog:libhilog", "init:libbegetutil", "ipc:ipc_core", - "json:nlohmann_json_static", - "jsoncpp:jsoncpp", + "ipc:ipc_napi", "napi:ace_napi", "samgr:samgr_proxy", + "window_manager:libwm", ] cflags_cc = [] diff --git a/frameworks/js/napi/js_mission_manager/BUILD.gn b/frameworks/js/napi/js_mission_manager/BUILD.gn index dd1ebdf378..ded57275cb 100755 --- a/frameworks/js/napi/js_mission_manager/BUILD.gn +++ b/frameworks/js/napi/js_mission_manager/BUILD.gn @@ -41,8 +41,10 @@ ohos_shared_library("missionmanager") { "ability_base:want", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", "hilog:libhilog", "ipc:ipc_core", + "ipc:ipc_napi", "napi:ace_napi", ] diff --git a/frameworks/js/napi/mission_manager/BUILD.gn b/frameworks/js/napi/mission_manager/BUILD.gn index dca37fe408..4809eefeea 100644 --- a/frameworks/js/napi/mission_manager/BUILD.gn +++ b/frameworks/js/napi/mission_manager/BUILD.gn @@ -40,8 +40,10 @@ ohos_shared_library("missionmanager_napi") { "ability_base:want", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", "hilog:libhilog", "ipc:ipc_core", + "ipc:ipc_napi", "napi:ace_napi", ] @@ -100,11 +102,14 @@ ohos_shared_library("distributedmissionmanager") { "bundle_framework:appexecfwk_core", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", "hilog:libhilog", "init:libbegetutil", "ipc:ipc_core", + "ipc:ipc_napi", "libuv:uv", "napi:ace_napi", + "node:node_header_notice", "samgr:samgr_proxy", ] diff --git a/frameworks/js/napi/particleAbility/BUILD.gn b/frameworks/js/napi/particleAbility/BUILD.gn index 9ccae15bb8..ff36e4f04a 100644 --- a/frameworks/js/napi/particleAbility/BUILD.gn +++ b/frameworks/js/napi/particleAbility/BUILD.gn @@ -58,23 +58,21 @@ ohos_shared_library("particleability") { "jsoncpp:jsoncpp", "libuv:uv", "napi:ace_napi", + "node:node_header_notice", ] if (ability_runtime_relational) { - include_dirs += [ - "${relational_store_napi_path}/common/include", - "${relational_store_napi_path}/dataability/include", - "${relational_store_napi_path}/rdb/include", - ] + include_dirs += [ "../featureAbility/data_ability/include" ] sources += [ - "${relational_store_napi_path}/common/src/js_df_manager.cpp", - "${relational_store_napi_path}/common/src/js_utils.cpp", - "${relational_store_napi_path}/dataability/src/napi_data_ability_predicates.cpp", - "${relational_store_napi_path}/rdb/src/napi_rdb_js_utils.cpp", - "${relational_store_napi_path}/rdb/src/napi_result_set.cpp", + "../featureAbility/data_ability/js_utils.cpp", + "../featureAbility/data_ability/napi_data_ability_predicates.cpp", + "../featureAbility/data_ability/napi_rdb_js_utils.cpp", + "../featureAbility/data_ability/napi_result_set.cpp", ] external_deps += [ + "eventhandler:libeventhandler", "kv_store:distributeddata_mgr", + "relational_store:native_appdatafwk", "relational_store:native_dataability", "relational_store:native_rdb", "relational_store:rdb_data_share_adapter", diff --git a/frameworks/js/napi/quick_fix/BUILD.gn b/frameworks/js/napi/quick_fix/BUILD.gn index 3def1c7002..bb8386d30f 100644 --- a/frameworks/js/napi/quick_fix/BUILD.gn +++ b/frameworks/js/napi/quick_fix/BUILD.gn @@ -38,6 +38,7 @@ ohos_shared_library("quickfixmanager_napi") { "bundle_framework:appexecfwk_base", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", "hilog:libhilog", "napi:ace_napi", ] diff --git a/frameworks/js/napi/uri_permission/BUILD.gn b/frameworks/js/napi/uri_permission/BUILD.gn index a18bd5ea03..ff699deffa 100644 --- a/frameworks/js/napi/uri_permission/BUILD.gn +++ b/frameworks/js/napi/uri_permission/BUILD.gn @@ -38,6 +38,7 @@ ohos_shared_library("uripermissionmanager_napi") { "bundle_framework:appexecfwk_base", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", "hilog:libhilog", "init:libbegetutil", "ipc:ipc_core", diff --git a/frameworks/js/napi/wantagent/BUILD.gn b/frameworks/js/napi/wantagent/BUILD.gn index f1c7d4e1dd..866c50aee3 100644 --- a/frameworks/js/napi/wantagent/BUILD.gn +++ b/frameworks/js/napi/wantagent/BUILD.gn @@ -44,10 +44,12 @@ ohos_shared_library("wantagent") { "access_token:libtokenid_sdk", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", "hilog:libhilog", "ipc:ipc_core", "libuv:uv", "napi:ace_napi", + "node:node_header_notice", ] cflags_cc = [] diff --git a/frameworks/js/napi/wantagent/ability_want_agent/BUILD.gn b/frameworks/js/napi/wantagent/ability_want_agent/BUILD.gn index 7d5cdc0f83..8126e8387e 100644 --- a/frameworks/js/napi/wantagent/ability_want_agent/BUILD.gn +++ b/frameworks/js/napi/wantagent/ability_want_agent/BUILD.gn @@ -49,6 +49,7 @@ ohos_shared_library("wantagent_napi") { "ipc:ipc_core", "libuv:uv", "napi:ace_napi", + "node:node_header_notice", ] relative_install_dir = "module/app/ability" diff --git a/frameworks/native/ability/BUILD.gn b/frameworks/native/ability/BUILD.gn index a4f823b94d..3dab9c55b3 100644 --- a/frameworks/native/ability/BUILD.gn +++ b/frameworks/native/ability/BUILD.gn @@ -84,6 +84,7 @@ ohos_shared_library("ability_context_native") { "access_token:libtoken_callback_sdk", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", "faultloggerd:libdfx_dumpcatcher", "hilog:libhilog", "hitrace:hitrace_meter", diff --git a/frameworks/native/ability/native/BUILD.gn b/frameworks/native/ability/native/BUILD.gn index fc16450614..5271daa93f 100644 --- a/frameworks/native/ability/native/BUILD.gn +++ b/frameworks/native/ability/native/BUILD.gn @@ -166,6 +166,7 @@ ohos_shared_library("abilitykit_utils") { public_external_deps = [ "bundle_framework:appexecfwk_core", + "icu:shared_icuuc", "jsoncpp:jsoncpp", "window_manager:libwm", ] @@ -173,11 +174,9 @@ ohos_shared_library("abilitykit_utils") { if (ability_runtime_graphics) { external_deps += [ "ability_base:session_info", - "icu:shared_icuuc", "window_manager:libwm", ] public_external_deps += [ - "form_fwk:form_manager", "graphic_2d:color_manager", "image_framework:image_native", "window_manager:libdm", @@ -350,8 +349,10 @@ ohos_shared_library("abilitykit_native") { "ipc:rpc", "json:nlohmann_json_static", "napi:ace_napi", + "node:node_header_notice", "resource_management:global_resmgr", "samgr:samgr_proxy", + "window_manager:windowstage_kit", ] if (!(host_os == "linux" && host_cpu == "arm64")) { external_deps += [ "relational_store:native_rdb" ] @@ -416,13 +417,9 @@ ohos_shared_library("abilitykit_native") { "input:libmmi-client", "window_manager:libwm", "window_manager:libwsutils", - "window_manager:windowstage_kit", ] - public_external_deps += [ - "form_fwk:form_manager", - "window_manager:libdm", - ] + public_external_deps += [ "window_manager:libdm" ] } innerapi_tags = [ "platformsdk" ] @@ -494,6 +491,7 @@ ohos_shared_library("extensionkit_native") { "hilog:libhilog", "hitrace:hitrace_meter", "ipc:ipc_core", + "ipc:ipc_napi", "json:nlohmann_json_static", "napi:ace_napi", ] @@ -509,7 +507,6 @@ ohos_shared_library("extensionkit_native") { if (ability_runtime_graphics) { external_deps += [ "ability_base:session_info" ] public_external_deps += [ - "form_fwk:form_manager", "graphic_2d:color_manager", "image_framework:image_native", "window_manager:libdm", @@ -556,6 +553,7 @@ ohos_shared_library("insight_intent_executor") { "ipc:ipc_core", "ipc:ipc_napi", "napi:ace_napi", + "window_manager:libwm", ] subsystem_name = "ability" @@ -641,6 +639,7 @@ ohos_shared_library("uiabilitykit_native") { "ets_runtime:libark_jsruntime", "eventhandler:libeventhandler", "hilog:libhilog", + "hisysevent:libhisysevent", "hitrace:hitrace_meter", "ipc:ipc_core", "ipc:ipc_napi", @@ -651,6 +650,8 @@ ohos_shared_library("uiabilitykit_native") { "bundle_framework:appexecfwk_core", "libuv:uv", "napi:ace_napi", + "node:node_header_notice", + "window_manager:libwm", ] cflags_cc = [] @@ -682,12 +683,10 @@ ohos_shared_library("uiabilitykit_native") { external_deps += [ "ability_base:session_info", "icu:shared_icuuc", - "window_manager:libwm", "window_manager:libwsutils", "window_manager:windowstage_kit", ] public_external_deps += [ - "form_fwk:form_manager", "graphic_2d:color_manager", "image_framework:image_native", "window_manager:libdm", @@ -734,6 +733,7 @@ ohos_shared_library("ability_thread") { "hilog:libhilog", "hitrace:hitrace_meter", "ipc:ipc_core", + "ipc:ipc_napi", "napi:ace_napi", ] @@ -824,7 +824,10 @@ ohos_shared_library("form_extension_module") { "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", "c_utils:utils", + "eventhandler:libeventhandler", "hilog:libhilog", + "ipc:ipc_core", + "ipc:ipc_napi", "json:nlohmann_json_static", "napi:ace_napi", "window_manager:libwm", @@ -833,7 +836,6 @@ ohos_shared_library("form_extension_module") { if (ability_runtime_graphics) { public_external_deps = [ "form_fwk:fmskit_provider_client", - "form_fwk:form_manager", "window_manager:libdm", ] } @@ -1083,6 +1085,8 @@ ohos_shared_library("ui_service_extension_module") { "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", "c_utils:utils", + "ets_runtime:libark_jsruntime", + "eventhandler:libeventhandler", "form_fwk:fmskit_native", "hilog:libhilog", "ipc:ipc_core", @@ -1093,21 +1097,17 @@ ohos_shared_library("ui_service_extension_module") { if (ability_runtime_graphics) { external_deps += [ "ace_engine:ace_uicontent", - "form_fwk:form_manager", "image_framework:image", "window_manager:libdm", "window_manager:libwm", "window_manager:libwsutils", "window_manager:scene_session", "window_manager:session_manager_lite", - "window_manager:window_native_kit", - "window_manager:windowstage_kit", ] public_external_deps = [ "form_fwk:fmskit_native", "form_fwk:fmskit_provider_client", - "form_fwk:form_manager", "window_manager:libdm", "window_manager:libwmutil", "window_manager:window_native_kit", @@ -1161,18 +1161,11 @@ ohos_shared_library("continuation_ipc") { "ipc:ipc_core", "json:nlohmann_json_static", "resource_management:global_resmgr", - "window_manager:libwm", - ] - public_external_deps = [ - "accessibility:accessibility_common", - "libuv:uv", ] + public_external_deps = [] if (ability_runtime_graphics) { - public_external_deps += [ - "form_fwk:form_manager", - "window_manager:libdm", - ] + public_external_deps += [] } defines = [] @@ -1204,6 +1197,7 @@ ohos_shared_library("data_ability_helper") { external_deps = [ "ability_base:zuri", + "bundle_framework:appexecfwk_base", "c_utils:utils", "common_event_service:cesfwk_innerkits", "data_share:datashare_common", @@ -1222,7 +1216,6 @@ ohos_shared_library("data_ability_helper") { if (ability_runtime_graphics) { public_external_deps = [ "form_fwk:fmskit_provider_client", - "form_fwk:form_manager", "window_manager:libdm", ] } @@ -1251,7 +1244,10 @@ ohos_shared_library("service_extension_module") { "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", "c_utils:utils", + "eventhandler:libeventhandler", "hilog:libhilog", + "ipc:ipc_core", + "ipc:ipc_napi", "json:nlohmann_json_static", "napi:ace_napi", ] @@ -1263,7 +1259,6 @@ ohos_shared_library("service_extension_module") { ] public_external_deps = [ "form_fwk:fmskit_provider_client", - "form_fwk:form_manager", "window_manager:libdm", ] } @@ -1463,13 +1458,17 @@ ohos_shared_library("ui_extension_module") { "ability_base:configuration", "ability_base:session_info", "ability_base:want", + "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", + "c_utils:utils", + "eventhandler:libeventhandler", "hilog:libhilog", + "ipc:ipc_napi", "napi:ace_napi", "window_manager:libwm", ] if (ability_runtime_graphics) { - external_deps += [ "form_fwk:form_manager" ] + external_deps += [] } relative_install_dir = "extensionability/" @@ -1596,16 +1595,18 @@ ohos_shared_library("share_extension_module") { "ability_base:configuration", "ability_base:session_info", "ability_base:want", + "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", + "c_utils:utils", + "eventhandler:libeventhandler", "hilog:libhilog", + "ipc:ipc_core", + "ipc:ipc_napi", "napi:ace_napi", ] if (ability_runtime_graphics) { - external_deps += [ - "form_fwk:form_manager", - "window_manager:libwm", - ] + external_deps += [ "window_manager:libwm" ] } relative_install_dir = "extensionability/" @@ -1657,16 +1658,18 @@ ohos_shared_library("action_extension_module") { "ability_base:configuration", "ability_base:session_info", "ability_base:want", + "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", + "c_utils:utils", + "eventhandler:libeventhandler", "hilog:libhilog", + "ipc:ipc_core", + "ipc:ipc_napi", "napi:ace_napi", ] if (ability_runtime_graphics) { - external_deps += [ - "form_fwk:form_manager", - "window_manager:libwm", - ] + external_deps += [ "window_manager:libwm" ] } relative_install_dir = "extensionability/" @@ -1818,8 +1821,13 @@ ohos_shared_library("embedded_ui_extension_module") { "ability_base:configuration", "ability_base:session_info", "ability_base:want", + "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", + "c_utils:utils", + "eventhandler:libeventhandler", "hilog:libhilog", + "ipc:ipc_core", + "ipc:ipc_napi", "napi:ace_napi", ] @@ -1909,13 +1917,18 @@ ohos_shared_library("auto_fill_extension_module") { "ability_base:configuration", "ability_base:session_info", "ability_base:want", + "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", + "c_utils:utils", + "eventhandler:libeventhandler", "hilog:libhilog", + "ipc:ipc_core", + "ipc:ipc_napi", "napi:ace_napi", "window_manager:libwm", ] if (ability_runtime_graphics) { - external_deps += [ "form_fwk:form_manager" ] + external_deps += [] } relative_install_dir = "extensionability/" @@ -2013,8 +2026,13 @@ ohos_shared_library("photo_editor_extension_module") { "ability_base:configuration", "ability_base:session_info", "ability_base:want", + "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", + "c_utils:utils", + "eventhandler:libeventhandler", "hilog:libhilog", + "ipc:ipc_core", + "ipc:ipc_napi", "napi:ace_napi", ] diff --git a/frameworks/native/ability/native/app_module_checker.cpp b/frameworks/native/ability/native/app_module_checker.cpp index d15b186958..20e0d6fcce 100644 --- a/frameworks/native/ability/native/app_module_checker.cpp +++ b/frameworks/native/ability/native/app_module_checker.cpp @@ -18,6 +18,7 @@ #include "hilog_tag_wrapper.h" #include "module_checker_delegate.h" #include "utils/log.h" +#include bool AppModuleChecker::CheckModuleLoadable(const char *moduleName, std::unique_ptr &apiAllowListChecker) diff --git a/frameworks/native/appkit/BUILD.gn b/frameworks/native/appkit/BUILD.gn index b6c352f317..a46aee2f6d 100644 --- a/frameworks/native/appkit/BUILD.gn +++ b/frameworks/native/appkit/BUILD.gn @@ -186,6 +186,10 @@ ohos_shared_library("appkit_native") { "faultloggerd:libdfx_procinfo", "faultloggerd:libfaultloggerd", "ffrt:libffrt", + "graphic_2d:2d_graphics", + "graphic_2d:EGL", + "graphic_2d:libcomposer", + "graphic_2d:librender_service_base", "hicollie:libhicollie", "hilog:libhilog", "hisysevent:libhisysevent", @@ -193,8 +197,11 @@ ohos_shared_library("appkit_native") { "i18n:preferred_language", "init:libbegetutil", "ipc:ipc_core", + "ipc:ipc_napi", + "ipc:ipc_single", "json:nlohmann_json_static", "napi:ace_napi", + "preferences:native_preferences", "resource_management:global_resmgr", "safwk:system_ability_fwk", "samgr:samgr_proxy", @@ -314,6 +321,7 @@ ohos_shared_library("app_context") { "hitrace:hitrace_meter", "init:libbegetutil", "ipc:ipc_core", + "ipc:ipc_napi", "json:nlohmann_json_static", "napi:ace_napi", "resource_management:global_resmgr", @@ -385,6 +393,7 @@ ohos_shared_library("app_context_utils") { "hilog:libhilog", "hitrace:hitrace_meter", "ipc:ipc_core", + "ipc:ipc_napi", "json:nlohmann_json_static", "napi:ace_napi", "resource_management:global_resmgr", @@ -455,9 +464,11 @@ ohos_shared_library("appkit_delegator") { "common_event_service:cesfwk_innerkits", "eventhandler:libeventhandler", "hilog:libhilog", + "image_framework:image_native", "ipc:ipc_core", "json:nlohmann_json_static", "napi:ace_napi", + "samgr:samgr_proxy", ] public_external_deps = [ "ability_base:configuration" ] @@ -546,7 +557,6 @@ ohos_shared_library("application_context_manager") { } external_deps = [ - "ets_runtime:libark_jsruntime", "hilog:libhilog", "napi:ace_napi", ] diff --git a/frameworks/native/appkit/app/main_thread.cpp b/frameworks/native/appkit/app/main_thread.cpp index 3ab912f52f..0d4aed6f81 100644 --- a/frameworks/native/appkit/app/main_thread.cpp +++ b/frameworks/native/appkit/app/main_thread.cpp @@ -62,7 +62,7 @@ #include "locale_config.h" #include "ace_forward_compatibility.h" #include "form_constants.h" -#include "include/private/EGL/cache.h" +#include "cache.h" #ifdef SUPPORT_APP_PREFERRED_LANGUAGE #include "preferred_language.h" #endif diff --git a/frameworks/native/insight_intent/insight_intent_context/BUILD.gn b/frameworks/native/insight_intent/insight_intent_context/BUILD.gn index 7bed55b40c..05110ba515 100644 --- a/frameworks/native/insight_intent/insight_intent_context/BUILD.gn +++ b/frameworks/native/insight_intent/insight_intent_context/BUILD.gn @@ -41,11 +41,11 @@ ohos_shared_library("insightintentcontext") { ] external_deps = [ - "ability_base:session_info", "ability_base:want", "c_utils:utils", "hilog:libhilog", "hitrace:hitrace_meter", + "ipc:ipc_core", "ipc:ipc_single", "napi:ace_napi", ] diff --git a/interfaces/inner_api/ability_manager/BUILD.gn b/interfaces/inner_api/ability_manager/BUILD.gn index f12f172c3b..04c3e610f4 100644 --- a/interfaces/inner_api/ability_manager/BUILD.gn +++ b/interfaces/inner_api/ability_manager/BUILD.gn @@ -143,9 +143,12 @@ ohos_shared_library("ability_manager") { "hisysevent:libhisysevent", "hitrace:hitrace_meter", "ipc:ipc_core", + "ipc:ipc_napi", + "jsoncpp:jsoncpp", "relational_store:native_dataability", "samgr:samgr_proxy", ] + if (host_cpu != "arm64") { external_deps += [ "relational_store:native_rdb" ] } @@ -273,6 +276,9 @@ ohos_shared_library("ability_manager_c") { external_deps = [ "ability_base:session_info", "c_utils:utils", + "image_framework:image_native", + "ipc:ipc_core", + "ipc:ipc_napi", ] innerapi_tags = [ "platformsdk" ] subsystem_name = "ability" diff --git a/interfaces/inner_api/app_manager/BUILD.gn b/interfaces/inner_api/app_manager/BUILD.gn index 028d740075..210326f3fd 100644 --- a/interfaces/inner_api/app_manager/BUILD.gn +++ b/interfaces/inner_api/app_manager/BUILD.gn @@ -154,7 +154,6 @@ ohos_shared_library("app_manager") { "bundle_framework:appexecfwk_base", "image_framework:image_native", "relational_store:native_rdb", - "skia:skia_canvaskit", ] if (background_task_mgr_continuous_task_enable) { diff --git a/interfaces/inner_api/auto_fill_manager/BUILD.gn b/interfaces/inner_api/auto_fill_manager/BUILD.gn index 90f33ca340..4f71d922c0 100644 --- a/interfaces/inner_api/auto_fill_manager/BUILD.gn +++ b/interfaces/inner_api/auto_fill_manager/BUILD.gn @@ -46,6 +46,7 @@ ohos_shared_library("auto_fill_manager") { "ability_base:base", "ability_base:view_data", "ability_base:want", + "bundle_framework:appexecfwk_base", "c_utils:utils", "eventhandler:libeventhandler", "hilog:libhilog", diff --git a/interfaces/inner_api/deps_wrapper/BUILD.gn b/interfaces/inner_api/deps_wrapper/BUILD.gn index b2acd41cf7..df5773767c 100644 --- a/interfaces/inner_api/deps_wrapper/BUILD.gn +++ b/interfaces/inner_api/deps_wrapper/BUILD.gn @@ -44,8 +44,10 @@ ohos_shared_library("ability_deps_wrapper") { external_deps = [ "ability_base:base", + "ability_base:want", "c_utils:utils", "hilog:libhilog", + "ipc:ipc_core", "samgr:samgr_proxy", ] diff --git a/interfaces/inner_api/quick_fix/BUILD.gn b/interfaces/inner_api/quick_fix/BUILD.gn index ff61927c3a..2797377046 100644 --- a/interfaces/inner_api/quick_fix/BUILD.gn +++ b/interfaces/inner_api/quick_fix/BUILD.gn @@ -11,9 +11,9 @@ # See the License for the specific language governing permissions and # limitations under the License. +import("//build/config/components/idl_tool/idl.gni") import("//build/ohos.gni") import("//foundation/ability/ability_runtime/ability_runtime.gni") -import("//foundation/ability/idl_tool/idl_config.gni") idl_interface_sources = [ "${target_gen_dir}/quick_fix_manager_proxy.cpp", diff --git a/interfaces/inner_api/runtime/BUILD.gn b/interfaces/inner_api/runtime/BUILD.gn index 67fe4c6b28..30b88e79cc 100644 --- a/interfaces/inner_api/runtime/BUILD.gn +++ b/interfaces/inner_api/runtime/BUILD.gn @@ -105,6 +105,7 @@ ohos_shared_library("runtime") { "ets_runtime:libark_jsruntime", "ets_utils:console", "ets_utils:timer", + "ets_utils:worker", "eventhandler:libeventhandler", "ffrt:libffrt", "hilog:libhilog", diff --git a/js_environment/frameworks/js_environment/BUILD.gn b/js_environment/frameworks/js_environment/BUILD.gn index febdf45d77..bc213113d1 100644 --- a/js_environment/frameworks/js_environment/BUILD.gn +++ b/js_environment/frameworks/js_environment/BUILD.gn @@ -42,8 +42,10 @@ ohos_shared_library("js_environment") { public_configs = [ ":public_js_environment_config" ] external_deps = [ + "c_utils:utils", "ets_runtime:libark_jsruntime", "ets_utils:console", + "ets_utils:worker", "eventhandler:libeventhandler", "faultloggerd:libunwinder", "ffrt:libffrt", diff --git a/service_router_framework/services/srms/BUILD.gn b/service_router_framework/services/srms/BUILD.gn index fc4ed26a2e..d5689fb71a 100755 --- a/service_router_framework/services/srms/BUILD.gn +++ b/service_router_framework/services/srms/BUILD.gn @@ -64,6 +64,7 @@ ohos_shared_library("libsrms") { "common_event_service:cesfwk_innerkits", "eventhandler:libeventhandler", "hilog:libhilog", + "image_framework:image_native", "ipc:ipc_single", "os_account:os_account_innerkits", "safwk:system_ability_fwk", diff --git a/services/abilitymgr/BUILD.gn b/services/abilitymgr/BUILD.gn index 4233c90dee..483f86f436 100644 --- a/services/abilitymgr/BUILD.gn +++ b/services/abilitymgr/BUILD.gn @@ -159,8 +159,8 @@ ohos_shared_library("abilityms") { "common_event_service:cesfwk_innerkits", "config_policy:configpolicy_util", "dsoftbus:softbus_client", + "eventhandler:libeventhandler", "ffrt:libffrt", - "graphic_2d:color_manager", "hicollie:libhicollie", "hilog:libhilog", "hisysevent:libhisysevent", @@ -423,6 +423,7 @@ ohos_shared_library("mission_list") { "common_event_service:cesfwk_innerkits", "config_policy:configpolicy_util", "dsoftbus:softbus_client", + "eventhandler:libeventhandler", "ffrt:libffrt", "graphic_2d:color_manager", "hicollie:libhicollie", diff --git a/services/appmgr/BUILD.gn b/services/appmgr/BUILD.gn index 89ad3618f2..9149c45806 100644 --- a/services/appmgr/BUILD.gn +++ b/services/appmgr/BUILD.gn @@ -122,6 +122,7 @@ ohos_shared_library("libappms") { "bundle_framework:appexecfwk_core", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", "ffrt:libffrt", "hicollie:libhicollie", "hilog:libhilog", diff --git a/services/common/BUILD.gn b/services/common/BUILD.gn index c2ebb1e8a2..c5fcef0bd9 100644 --- a/services/common/BUILD.gn +++ b/services/common/BUILD.gn @@ -91,6 +91,7 @@ ohos_shared_library("event_report") { sources = [ "src/event_report.cpp" ] external_deps = [ + "c_utils:utils", "hilog:libhilog", "hisysevent:libhisysevent", "hitrace:hitrace_meter", @@ -136,6 +137,7 @@ ohos_shared_library("app_util") { ] external_deps = [ + "c_utils:utils", "config_policy:configpolicy_util", "hilog:libhilog", "hisysevent:libhisysevent", @@ -170,7 +172,9 @@ ohos_shared_library("res_sched_util") { external_deps = [ "bundle_framework:appexecfwk_base", + "c_utils:utils", "hilog:libhilog", + "ipc:ipc_core", "samgr:samgr_proxy", ] diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index a362f63136..2651116071 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -253,6 +253,7 @@ ohos_source_set("abilityms_test_source") { "init:libbeget_proxy", "init:libbegetutil", "ipc:ipc_core", + "jsoncpp:jsoncpp", "kv_store:distributeddata_inner", "relational_store:native_appdatafwk", "relational_store:native_dataability", diff --git a/tools/aa/BUILD.gn b/tools/aa/BUILD.gn index 3d6bf5b8bc..45ca82c631 100644 --- a/tools/aa/BUILD.gn +++ b/tools/aa/BUILD.gn @@ -101,6 +101,7 @@ ohos_executable("aa") { "ability_base:base", "ability_base:configuration", "ability_base:session_info", + "c_utils:utils", "hicollie:libhicollie", "hilog:libhilog", "ipc:ipc_core", diff --git a/utils/server/startup/BUILD.gn b/utils/server/startup/BUILD.gn index 1dda2b6090..ef3ef5dd5d 100644 --- a/utils/server/startup/BUILD.gn +++ b/utils/server/startup/BUILD.gn @@ -52,6 +52,7 @@ ohos_shared_library("startup_util") { "ability_base:want", "bundle_framework:appexecfwk_base", "c_utils:utils", + "ipc:ipc_core", "ipc:ipc_single", ]