From 1417bf202411d6600ba50623a8f6d990f41cf0c9 Mon Sep 17 00:00:00 2001 From: maokelong95 Date: Sat, 16 Jul 2022 09:59:50 +0800 Subject: [PATCH] =?UTF-8?q?file=5Fapi=E5=8A=9F=E8=83=BD=E4=BD=BF=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: maokelong95 --- bundle.json | 34 ++ figures/file-api-architecture.png | Bin 0 -> 28417 bytes ...-\346\236\266\346\236\204\345\233\276.png" | Bin 0 -> 27688 bytes file_api.gni | 15 + utils/filemgmt_libhilog/BUILD.gn | 29 ++ utils/filemgmt_libhilog/filemgmt_libhilog.h | 52 +++ utils/filemgmt_libn/BUILD.gn | 44 +++ utils/filemgmt_libn/include/filemgmt_libn.h | 25 ++ .../include/n_async/n_async_context.h | 63 ++++ .../include/n_async/n_async_work.h | 36 ++ .../include/n_async/n_async_work_callback.h | 37 +++ .../include/n_async/n_async_work_promise.h | 37 +++ utils/filemgmt_libn/include/n_async/n_ref.h | 40 +++ utils/filemgmt_libn/include/n_class.h | 82 +++++ utils/filemgmt_libn/include/n_error.h | 49 +++ utils/filemgmt_libn/include/n_exporter.h | 43 +++ utils/filemgmt_libn/include/n_func_arg.h | 71 ++++ utils/filemgmt_libn/include/n_napi.h | 26 ++ utils/filemgmt_libn/include/n_val.h | 86 +++++ .../src/n_async/n_async_work_callback.cpp | 103 ++++++ .../src/n_async/n_async_work_promise.cpp | 93 ++++++ utils/filemgmt_libn/src/n_async/n_ref.cpp | 55 ++++ utils/filemgmt_libn/src/n_class.cpp | 95 ++++++ utils/filemgmt_libn/src/n_error.cpp | 72 ++++ utils/filemgmt_libn/src/n_func_arg.cpp | 110 +++++++ utils/filemgmt_libn/src/n_val.cpp | 307 ++++++++++++++++++ 26 files changed, 1604 insertions(+) create mode 100644 bundle.json create mode 100644 figures/file-api-architecture.png create mode 100644 "figures/file-api-\346\236\266\346\236\204\345\233\276.png" create mode 100644 file_api.gni create mode 100644 utils/filemgmt_libhilog/BUILD.gn create mode 100644 utils/filemgmt_libhilog/filemgmt_libhilog.h create mode 100644 utils/filemgmt_libn/BUILD.gn create mode 100644 utils/filemgmt_libn/include/filemgmt_libn.h create mode 100644 utils/filemgmt_libn/include/n_async/n_async_context.h create mode 100644 utils/filemgmt_libn/include/n_async/n_async_work.h create mode 100644 utils/filemgmt_libn/include/n_async/n_async_work_callback.h create mode 100644 utils/filemgmt_libn/include/n_async/n_async_work_promise.h create mode 100644 utils/filemgmt_libn/include/n_async/n_ref.h create mode 100644 utils/filemgmt_libn/include/n_class.h create mode 100644 utils/filemgmt_libn/include/n_error.h create mode 100644 utils/filemgmt_libn/include/n_exporter.h create mode 100644 utils/filemgmt_libn/include/n_func_arg.h create mode 100644 utils/filemgmt_libn/include/n_napi.h create mode 100644 utils/filemgmt_libn/include/n_val.h create mode 100644 utils/filemgmt_libn/src/n_async/n_async_work_callback.cpp create mode 100644 utils/filemgmt_libn/src/n_async/n_async_work_promise.cpp create mode 100644 utils/filemgmt_libn/src/n_async/n_ref.cpp create mode 100644 utils/filemgmt_libn/src/n_class.cpp create mode 100644 utils/filemgmt_libn/src/n_error.cpp create mode 100644 utils/filemgmt_libn/src/n_func_arg.cpp create mode 100644 utils/filemgmt_libn/src/n_val.cpp diff --git a/bundle.json b/bundle.json new file mode 100644 index 000000000..ab34a9cc7 --- /dev/null +++ b/bundle.json @@ -0,0 +1,34 @@ +{ + "name": "file_api", + "description": "provides the application with JS interfaces for IO", + "version": "3.1", + "license": "Apache License 2.0", + "publishAs": "code-segment", + "segment": { + "destPath": "foundation/filemanagement/file_api" + }, + "dirs": {}, + "scripts": {}, + "component": { + "name": "file_api", + "subsystem": "filemanagement", + "syscap": [], + "features": [], + "adapted_system_type": ["standard"], + "rom": "", + "ram": "", + "deps": { + "components": [ + "ability_manager", + "libhilog", + "ace_napi", + "samgr_proxy" + ] + }, + "build": { + "sub_component": [ + "//foundation/filemanagement/file_api/interfaces/kits/js:build_kits_js" + ] + } + } + } diff --git a/figures/file-api-architecture.png b/figures/file-api-architecture.png new file mode 100644 index 0000000000000000000000000000000000000000..83bc5b800c948a2c54f7b7ecf5b76af6e573525d GIT binary patch literal 28417 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 literal 0 HcmV?d00001 diff --git "a/figures/file-api-\346\236\266\346\236\204\345\233\276.png" "b/figures/file-api-\346\236\266\346\236\204\345\233\276.png" new file mode 100644 index 0000000000000000000000000000000000000000..c4bfb07625753881797a818029ca7d9a44f8b7f5 GIT binary patch literal 27688 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 Ux6ScaQh`5O8hS^H)vV9|KgZf2q5uE@ literal 0 HcmV?d00001 diff --git a/file_api.gni b/file_api.gni new file mode 100644 index 000000000..039aa4ed6 --- /dev/null +++ b/file_api.gni @@ -0,0 +1,15 @@ +# 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. + +aafwk_kits_path = "//foundation/ability/ability_runtime/frameworks/kits" +aafwk_path = "//foundation/ability/ability_runtime" diff --git a/utils/filemgmt_libhilog/BUILD.gn b/utils/filemgmt_libhilog/BUILD.gn new file mode 100644 index 000000000..48d6be334 --- /dev/null +++ b/utils/filemgmt_libhilog/BUILD.gn @@ -0,0 +1,29 @@ +# 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. + +import("//build/ohos.gni") + +config("log_public_config") { + visibility = [ ":*" ] + + include_dirs = [ "." ] +} + +ohos_shared_library("filemgmt_libhilog") { + public_configs = [ ":log_public_config" ] + public_deps = + [ "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog" ] + + subsystem_name = "filemanagement" + part_name = "file_api" +} diff --git a/utils/filemgmt_libhilog/filemgmt_libhilog.h b/utils/filemgmt_libhilog/filemgmt_libhilog.h new file mode 100644 index 000000000..0cdf4267e --- /dev/null +++ b/utils/filemgmt_libhilog/filemgmt_libhilog.h @@ -0,0 +1,52 @@ +/* + * 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 FILEMGMT_LIBHILOG_H +#define FILEMGMT_LIBHILOG_H + +#include "hilog/log.h" + +#include + +namespace OHOS { +#ifndef LOG_DOMAIN +#define LOG_DOMAIN 0xD001600 +#endif + +#ifndef LOG_TAG +#define LOG_TAG "FileManagement" +#endif + +static constexpr HiviewDFX::HiLogLabel FILEMGMT_LOG_LABEL = {LOG_CORE, LOG_DOMAIN, LOG_TAG}; + +#if defined __FILE_NAME__ +#define FILEMGMT_FILE_NAME __FILE_NAME__ +#else +#include +#define FILEMGMT_FILE_NAME (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__) +#endif + +#define FILEMGMT_PRINT_LOG(Level, fmt, ...) \ + HiviewDFX::HiLog::Level(FILEMGMT_LOG_LABEL, "[%{public}s:%{public}d->%{public}s] " fmt, FILEMGMT_FILE_NAME, \ + __LINE__, __FUNCTION__, ##__VA_ARGS__) + +#define HILOGD(fmt, ...) FILEMGMT_PRINT_LOG(Debug, fmt, ##__VA_ARGS__) +#define HILOGI(fmt, ...) FILEMGMT_PRINT_LOG(Info, fmt, ##__VA_ARGS__) +#define HILOGW(fmt, ...) FILEMGMT_PRINT_LOG(Warn, fmt, ##__VA_ARGS__) +#define HILOGE(fmt, ...) FILEMGMT_PRINT_LOG(Error, fmt, ##__VA_ARGS__) +#define HILOGF(fmt, ...) FILEMGMT_PRINT_LOG(Fatal, fmt, ##__VA_ARGS__) +} // namespace OHOS + +#endif // FILEMGMT_LIBHILOG_H \ No newline at end of file diff --git a/utils/filemgmt_libn/BUILD.gn b/utils/filemgmt_libn/BUILD.gn new file mode 100644 index 000000000..ffb8aafc0 --- /dev/null +++ b/utils/filemgmt_libn/BUILD.gn @@ -0,0 +1,44 @@ +# 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. + +import("//build/ohos.gni") + +config("libn_public_config") { + visibility = [ ":*" ] + + include_dirs = [ + "include", + "include/n_async", + ] +} + +ohos_shared_library("filemgmt_libn") { + sources = [ + "src/n_async/n_async_work_callback.cpp", + "src/n_async/n_async_work_promise.cpp", + "src/n_async/n_ref.cpp", + "src/n_class.cpp", + "src/n_error.cpp", + "src/n_func_arg.cpp", + "src/n_val.cpp", + ] + + public_configs = [ ":libn_public_config" ] + public_deps = [ + "//foundation/arkui/napi:ace_napi", + "//foundation/filemanagement/file_api/utils/filemgmt_libhilog", + ] + + subsystem_name = "filemanagement" + part_name = "file_api" +} diff --git a/utils/filemgmt_libn/include/filemgmt_libn.h b/utils/filemgmt_libn/include/filemgmt_libn.h new file mode 100644 index 000000000..28b1a8e85 --- /dev/null +++ b/utils/filemgmt_libn/include/filemgmt_libn.h @@ -0,0 +1,25 @@ +/* + * 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 FILEMGMT_LIBN_FILEMGMT_LIBN_H +#define FILEMGMT_LIBN_FILEMGMT_LIBN_H + +#include "n_async_work_callback.h" +#include "n_async_work_promise.h" +#include "n_error.h" +#include "n_exporter.h" +#include "n_func_arg.h" + +#endif // FILEMGMT_LIBN_FILEMGMT_LIBN_H \ No newline at end of file diff --git a/utils/filemgmt_libn/include/n_async/n_async_context.h b/utils/filemgmt_libn/include/n_async/n_async_context.h new file mode 100644 index 000000000..2d0b206aa --- /dev/null +++ b/utils/filemgmt_libn/include/n_async/n_async_context.h @@ -0,0 +1,63 @@ +/* + * 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 FILEMGMT_LIBN_N_ASYNC_CONTEXT_H +#define FILEMGMT_LIBN_N_ASYNC_CONTEXT_H + +#include + +#include "n_error.h" +#include "n_ref.h" +#include "n_val.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +using NContextCBExec = std::function; +using NContextCBComplete = std::function; + +class NAsyncContext { +public: + NError err_; + NVal res_; + NContextCBExec cbExec_; + NContextCBComplete cbComplete_; + napi_async_work awork_; + NRef thisPtr_; + + NAsyncContext(NVal thisPtr) + : err_(0), res_(NVal()), cbExec_(nullptr), cbComplete_(nullptr), awork_(nullptr), thisPtr_(thisPtr) + { + } + virtual ~NAsyncContext() = default; +}; + +class NAsyncContextPromise : public NAsyncContext { +public: + napi_deferred deferred_ = nullptr; + explicit NAsyncContextPromise(NVal thisPtr) : NAsyncContext(thisPtr) {} + ~NAsyncContextPromise() = default; +}; + +class NAsyncContextCallback : public NAsyncContext { +public: + NRef cb_; + NAsyncContextCallback(NVal thisPtr, NVal cb) : NAsyncContext(thisPtr), cb_(cb) {} + ~NAsyncContextCallback() = default; +}; +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS +#endif // FILEMGMT_LIBN_N_ASYNC_CONTEXT_H \ No newline at end of file diff --git a/utils/filemgmt_libn/include/n_async/n_async_work.h b/utils/filemgmt_libn/include/n_async/n_async_work.h new file mode 100644 index 000000000..d3bf6f7a9 --- /dev/null +++ b/utils/filemgmt_libn/include/n_async/n_async_work.h @@ -0,0 +1,36 @@ +/* + * 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 FILEMGMT_LIBN_N_ASYNC_WORK_H +#define FILEMGMT_LIBN_N_ASYNC_WORK_H + +#include "n_async_context.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +class NAsyncWork { +public: + NAsyncWork(napi_env env) : env_(env) {} + virtual ~NAsyncWork() = default; + virtual NVal Schedule(std::string procedureName, NContextCBExec cbExec, NContextCBComplete cbComplete) = 0; + + napi_env env_ = nullptr; +}; +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS + +#endif // FILEMGMT_LIBN_N_ASYNC_WORK_H \ No newline at end of file diff --git a/utils/filemgmt_libn/include/n_async/n_async_work_callback.h b/utils/filemgmt_libn/include/n_async/n_async_work_callback.h new file mode 100644 index 000000000..66af8fbf8 --- /dev/null +++ b/utils/filemgmt_libn/include/n_async/n_async_work_callback.h @@ -0,0 +1,37 @@ +/* + * 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 FILEMGMT_LIBN_N_ASYNC_WORK_CALLBACK_H +#define FILEMGMT_LIBN_N_ASYNC_WORK_CALLBACK_H + +#include "n_async_work.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +class NAsyncWorkCallback : public NAsyncWork { +public: + NAsyncWorkCallback(napi_env env, NVal thisPtr, NVal cb); + ~NAsyncWorkCallback() = default; + NVal Schedule(std::string procedureName, NContextCBExec cbExec, NContextCBComplete cbComplete) final; + +private: + NAsyncContextCallback *ctx_ = nullptr; +}; +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS + +#endif // FILEMGMT_LIBN_N_ASYNC_WORK_CALLBACK_H \ No newline at end of file diff --git a/utils/filemgmt_libn/include/n_async/n_async_work_promise.h b/utils/filemgmt_libn/include/n_async/n_async_work_promise.h new file mode 100644 index 000000000..da8bc723e --- /dev/null +++ b/utils/filemgmt_libn/include/n_async/n_async_work_promise.h @@ -0,0 +1,37 @@ +/* + * 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 FILEMGMT_LIBN_N_ASYNC_WORK_PROMISE_H +#define FILEMGMT_LIBN_N_ASYNC_WORK_PROMISE_H + +#include "n_async_work.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +class NAsyncWorkPromise : public NAsyncWork { +public: + NAsyncWorkPromise(napi_env env, NVal thisPtr); + ~NAsyncWorkPromise() = default; + NVal Schedule(std::string procedureName, NContextCBExec cbExec, NContextCBComplete cbComplete) final; + +private: + NAsyncContextPromise *ctx_; +}; +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS + +#endif // FILEMGMT_LIBN_N_ASYNC_WORK_PROMISE_H \ No newline at end of file diff --git a/utils/filemgmt_libn/include/n_async/n_ref.h b/utils/filemgmt_libn/include/n_async/n_ref.h new file mode 100644 index 000000000..83cc6a666 --- /dev/null +++ b/utils/filemgmt_libn/include/n_async/n_ref.h @@ -0,0 +1,40 @@ +/* + * 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 FILEMGMT_LIBN_N_REF_H +#define FILEMGMT_LIBN_N_REF_H + +#include "n_val.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +class NRef { +public: + NRef(); + NRef(NVal val); + ~NRef(); + explicit operator bool() const; + NVal Deref(napi_env env); + +private: + napi_env env_ = nullptr; + napi_ref ref_ = nullptr; +}; +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS + +#endif // FILEMGMT_LIBN_N_REF_H \ No newline at end of file diff --git a/utils/filemgmt_libn/include/n_class.h b/utils/filemgmt_libn/include/n_class.h new file mode 100644 index 000000000..b4ec8c75a --- /dev/null +++ b/utils/filemgmt_libn/include/n_class.h @@ -0,0 +1,82 @@ +/* + * 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 FILEMGMT_LIBN_N_CLASS_H +#define FILEMGMT_LIBN_N_CLASS_H + +#include +#include +#include +#include +#include +#include + +#include "n_napi.h" +#include "filemgmt_libhilog.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +class NClass final { +public: + NClass(const NClass&) = delete; + NClass &operator=(const NClass&) = delete; + static std::tuple DefineClass(napi_env env, + std::string className, + napi_callback constructor, + std::vector &&properties); + static bool SaveClass(napi_env env, std::string className, napi_value exClass); + static napi_value InstantiateClass(napi_env env, const std::string& className, const std::vector& args); + + template static T *GetEntityOf(napi_env env, napi_value objStat) + { + if (!env || !objStat) { + HILOGE("Empty input: env %d, obj %d", env == nullptr, objStat == nullptr); + return nullptr; + } + T *t = nullptr; + napi_status status = napi_unwrap(env, objStat, (void **)&t); + if (status != napi_ok) { + HILOGE("Cannot umwarp for pointer: %d", status); + return nullptr; + } + return t; + } + + template static bool SetEntityFor(napi_env env, napi_value obj, std::unique_ptr entity) + { + napi_status status = napi_wrap( + env, obj, entity.get(), + [](napi_env env, void *data, void *hint) { + auto entity = static_cast(data); + delete entity; + }, + nullptr, nullptr); + entity.release(); + return status == napi_ok; + } + +private: + NClass() = default; + ~NClass() = default; + static NClass &GetInstance(); + std::map exClassMap; + std::mutex exClassMapLock; +}; +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS + +#endif // FILEMGMT_LIBN_N_CLASS_H diff --git a/utils/filemgmt_libn/include/n_error.h b/utils/filemgmt_libn/include/n_error.h new file mode 100644 index 000000000..82343d367 --- /dev/null +++ b/utils/filemgmt_libn/include/n_error.h @@ -0,0 +1,49 @@ +/* + * 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 FILEMGMT_LIBN_N_ERROR_H +#define FILEMGMT_LIBN_N_ERROR_H + +#include +#include +#include + +#include "n_napi.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +constexpr int ERRNO_NOERR = 0; + +class NError { +public: + NError(); + NError(int ePosix); + NError(std::function()> errGen); + ~NError() = default; + explicit operator bool() const; + napi_value GetNapiErr(napi_env env); + void ThrowErr(napi_env env); + void ThrowErr(napi_env env, std::string errMsg); + +private: + int errno_ = ERRNO_NOERR; + std::string errMsg_; +}; +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS + +#endif // FILEMGMT_LIBN_N_ERROR_H \ No newline at end of file diff --git a/utils/filemgmt_libn/include/n_exporter.h b/utils/filemgmt_libn/include/n_exporter.h new file mode 100644 index 000000000..2734dc0c2 --- /dev/null +++ b/utils/filemgmt_libn/include/n_exporter.h @@ -0,0 +1,43 @@ +/* + * 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 FILEMGMT_LIBN_N_EXPORTER_H +#define FILEMGMT_LIBN_N_EXPORTER_H + +#include "n_napi.h" + +#include +#include + +#include "n_val.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +class NExporter { +public: + NExporter(napi_env env, napi_value exports) : exports_(env, exports) {}; + virtual ~NExporter() = default; + virtual bool Export() = 0; + virtual std::string GetClassName() = 0; + +protected: + NVal exports_; +}; +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS + +#endif // FILEMGMT_LIBN_N_EXPORTER_H \ No newline at end of file diff --git a/utils/filemgmt_libn/include/n_func_arg.h b/utils/filemgmt_libn/include/n_func_arg.h new file mode 100644 index 000000000..a51b92475 --- /dev/null +++ b/utils/filemgmt_libn/include/n_func_arg.h @@ -0,0 +1,71 @@ +/* + * 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 FILEMGMT_LIBN_N_FUNC_ARG_H +#define FILEMGMT_LIBN_N_FUNC_ARG_H + +#include +#include +#include + +#include "n_napi.h" +#include "n_val.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +enum NARG_CNT { + ZERO = 0, + ONE, + TWO, + THREE, + FOUR, +}; + +enum NARG_POS { + FIRST = 0, + SECOND, + THIRD, + FOURTH, +}; + +class NFuncArg final { +public: + NFuncArg(napi_env env, napi_callback_info info); + virtual ~NFuncArg(); + + bool InitArgs(size_t argc); + bool InitArgs(size_t minArgc, size_t maxArgc); + size_t GetArgc() const; + napi_value GetThisVar() const; + napi_value operator[](size_t idx) const; + napi_value GetArg(size_t argPos) const; + +private: + napi_env env_ = nullptr; + napi_callback_info info_ = nullptr; + size_t argc_ = 0; + std::unique_ptr argv_ = {nullptr}; + napi_value thisVar_ = nullptr; + + bool InitArgs(std::function argcChecker); + void SetArgc(size_t argc); + void SetThisVar(napi_value thisVar); +}; +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS + +#endif // FILEMGMT_LIBN_N_FUNC_ARG_H \ No newline at end of file diff --git a/utils/filemgmt_libn/include/n_napi.h b/utils/filemgmt_libn/include/n_napi.h new file mode 100644 index 000000000..61704ef6d --- /dev/null +++ b/utils/filemgmt_libn/include/n_napi.h @@ -0,0 +1,26 @@ +/* + * 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 FILEMGMT_LIBN_N_NAPI_H +#define FILEMGMT_LIBN_N_NAPI_H + +#ifdef FILE_SUBSYSTEM_DEBUG_LOCAL +#include +#else +#include "napi/native_api.h" +#include "napi/native_node_api.h" +#endif + +#endif // FILEMGMT_LIBN_N_NAPI_H \ No newline at end of file diff --git a/utils/filemgmt_libn/include/n_val.h b/utils/filemgmt_libn/include/n_val.h new file mode 100644 index 000000000..29f9597c0 --- /dev/null +++ b/utils/filemgmt_libn/include/n_val.h @@ -0,0 +1,86 @@ +/* + * 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 FILEMGMT_LIBN_N_VAL_H +#define FILEMGMT_LIBN_N_VAL_H + +#include +#include +#include +#include + +#include "n_napi.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +class NVal final { +public: + NVal() = default; + NVal(napi_env nEnv, napi_value nVal); + NVal(const NVal &) = default; + NVal &operator=(const NVal &) = default; + virtual ~NVal() = default; + + /* NOTE! env_ and val_ is LIKELY to be null */ + napi_env env_ = nullptr; + napi_value val_ = nullptr; + + explicit operator bool() const; + bool TypeIs(napi_valuetype expType) const; + bool TypeIsError(bool checkErrno = false) const; + + /* SHOULD ONLY BE USED FOR EXPECTED TYPE */ + std::tuple, size_t> ToUTF8String() const; + std::tuple, size_t> ToUTF16String() const; + std::tuple ToPointer() const; + std::tuple ToBool() const; + std::tuple ToInt32() const; + std::tuple ToInt64() const; + std::tuple ToArraybuffer() const; + std::tuple ToTypedArray() const; + + /* Static helpers to create js objects */ + static NVal CreateUndefined(napi_env env); + static NVal CreateInt64(napi_env env, int64_t val); + static NVal CreateInt32(napi_env env, int32_t val); + static NVal CreateObject(napi_env env); + static NVal CreateBool(napi_env env, bool val); + static NVal CreateUTF8String(napi_env env, std::string str); + static NVal CreateUTF8String(napi_env env, const char *str, ssize_t len); + static NVal CreateUint8Array(napi_env env, void *buf, size_t bufLen); + static std::tuple CreateArrayBuffer(napi_env env, size_t len); + + /* SHOULD ONLY BE USED FOR OBJECT */ + bool HasProp(std::string propName) const; + NVal GetProp(std::string propName) const; + bool AddProp(std::vector &&propVec) const; + bool AddProp(std::string propName, napi_value nVal) const; + + /* Static helpers to create prop of js objects */ + static napi_property_descriptor DeclareNapiProperty(const char *name, napi_value val); + static napi_property_descriptor DeclareNapiStaticProperty(const char *name, napi_value val); + static napi_property_descriptor DeclareNapiFunction(const char *name, napi_callback func); + static napi_property_descriptor DeclareNapiStaticFunction(const char *name, napi_callback func); + static napi_property_descriptor DeclareNapiGetter(const char *name, napi_callback getter); + static napi_property_descriptor DeclareNapiSetter(const char *name, napi_callback setter); + static inline napi_property_descriptor + DeclareNapiGetterSetter(const char *name, napi_callback getter, napi_callback setter); +}; +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS + +#endif // FILEMGMT_LIBN_N_VAL_H diff --git a/utils/filemgmt_libn/src/n_async/n_async_work_callback.cpp b/utils/filemgmt_libn/src/n_async/n_async_work_callback.cpp new file mode 100644 index 000000000..291d183d4 --- /dev/null +++ b/utils/filemgmt_libn/src/n_async/n_async_work_callback.cpp @@ -0,0 +1,103 @@ +/* + * 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. + */ + +#include "n_async_work_callback.h" +#include "filemgmt_libhilog.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +using namespace std; + +NAsyncWorkCallback::NAsyncWorkCallback(napi_env env, NVal thisPtr, NVal cb) : NAsyncWork(env) +{ + ctx_ = new NAsyncContextCallback(thisPtr, cb); +} + +static void CallbackExecute(napi_env env, void *data) +{ + auto ctx = static_cast(data); + if (ctx != nullptr && ctx->cbExec_ != nullptr) { + ctx->err_ = ctx->cbExec_(); + } else { + HILOGE("Callback execute function, This pointer or function address is empty."); + } +} + +static void CallbackComplete(napi_env env, napi_status status, void *data) +{ + napi_handle_scope scope = nullptr; + napi_open_handle_scope(env, &scope); + auto ctx = static_cast(data); + if (ctx == nullptr) { + HILOGE("This pointer address is empty"); + return; + } + if (ctx->cbComplete_ != nullptr) { + ctx->res_ = ctx->cbComplete_(env, ctx->err_); + ctx->cbComplete_ = nullptr; + } + + vector argv; + if (!ctx->res_.TypeIsError(true)) { + argv = {NError(ERRNO_NOERR).GetNapiErr(env), ctx->res_.val_}; + } else { + argv = {ctx->res_.val_}; + } + + napi_value global = nullptr; + napi_value callback = ctx->cb_.Deref(env).val_; + napi_value tmp = nullptr; + napi_get_global(env, &global); + napi_status stat = napi_call_function(env, global, callback, argv.size(), argv.data(), &tmp); + if (stat != napi_ok) { + HILOGE("Failed to call function for %{public}d", stat); + } + napi_close_handle_scope(env, scope); + napi_delete_async_work(env, ctx->awork_); + delete ctx; +} + +NVal NAsyncWorkCallback::Schedule(string procedureName, NContextCBExec cbExec, NContextCBComplete cbComplete) +{ + if (!ctx_->cb_ || !ctx_->cb_.Deref(env_).TypeIs(napi_function)) { + NError(EINVAL).ThrowErr(env_, "The callback should be a function"); + return NVal(); + } + + ctx_->cbExec_ = move(cbExec); + ctx_->cbComplete_ = move(cbComplete); + + napi_value resource = NVal::CreateUTF8String(env_, procedureName).val_; + + napi_status status = + napi_create_async_work(env_, nullptr, resource, CallbackExecute, CallbackComplete, ctx_, &ctx_->awork_); + if (status != napi_ok) { + HILOGE("INNER BUG. Failed to create async work for %{public}d", status); + return NVal(); + } + + status = napi_queue_async_work(env_, ctx_->awork_); + if (status != napi_ok) { + HILOGE("INNER BUG. Failed to queue async work for %{public}d", status); + return NVal(); + } + + ctx_ = nullptr; // The ownership of ctx_ has been transferred + return NVal::CreateUndefined(env_); +} +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS diff --git a/utils/filemgmt_libn/src/n_async/n_async_work_promise.cpp b/utils/filemgmt_libn/src/n_async/n_async_work_promise.cpp new file mode 100644 index 000000000..443c450ef --- /dev/null +++ b/utils/filemgmt_libn/src/n_async/n_async_work_promise.cpp @@ -0,0 +1,93 @@ +/* + * 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. + */ + +#include "n_async_work_promise.h" +#include "filemgmt_libhilog.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +using namespace std; + +NAsyncWorkPromise::NAsyncWorkPromise(napi_env env, NVal thisPtr) : NAsyncWork(env) +{ + ctx_ = new NAsyncContextPromise(thisPtr); +} + +static void PromiseOnExec(napi_env env, void *data) +{ + auto ctx = static_cast(data); + if (ctx != nullptr && ctx->cbExec_ != nullptr) { + ctx->err_ = ctx->cbExec_(); + } +} + +static void PromiseOnComplete(napi_env env, napi_status status, void *data) +{ + auto ctx = static_cast(data); + if (ctx == nullptr) { + return; + } + if (ctx->cbComplete_ != nullptr) { + ctx->res_ = ctx->cbComplete_(env, ctx->err_); + } + if (!ctx->res_.TypeIsError(true)) { + napi_status status = napi_resolve_deferred(env, ctx->deferred_, ctx->res_.val_); + if (status != napi_ok) { + HILOGE("Internal BUG, cannot resolve promise for %{public}d", status); + } + } else { + napi_status status = napi_reject_deferred(env, ctx->deferred_, ctx->res_.val_); + if (status != napi_ok) { + HILOGE("Internal BUG, cannot reject promise for %{public}d", status); + } + } + ctx->deferred_ = nullptr; + napi_delete_async_work(env, ctx->awork_); + delete ctx; +} + +NVal NAsyncWorkPromise::Schedule(string procedureName, NContextCBExec cbExec, NContextCBComplete cbComplete) +{ + ctx_->cbExec_ = move(cbExec); + ctx_->cbComplete_ = move(cbComplete); + + napi_status status; + napi_value result = nullptr; + status = napi_create_promise(env_, &ctx_->deferred_, &result); + if (status != napi_ok) { + HILOGE("INNER BUG. Cannot create promise for %{public}d", status); + return NVal(); + } + + napi_value resource = NVal::CreateUTF8String(env_, procedureName).val_; + status = napi_create_async_work(env_, nullptr, resource, PromiseOnExec, PromiseOnComplete, ctx_, &ctx_->awork_); + if (status != napi_ok) { + HILOGE("INNER BUG. Failed to create async work for %{public}d", status); + return NVal(); + } + + status = napi_queue_async_work(env_, ctx_->awork_); + if (status != napi_ok) { + HILOGE("INNER BUG. Failed to queue async work for %{public}d", status); + return NVal(); + } + + ctx_ = nullptr; // The ownership of ctx_ has been transferred + return {env_, result}; +} +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS diff --git a/utils/filemgmt_libn/src/n_async/n_ref.cpp b/utils/filemgmt_libn/src/n_async/n_ref.cpp new file mode 100644 index 000000000..bd5ebc900 --- /dev/null +++ b/utils/filemgmt_libn/src/n_async/n_ref.cpp @@ -0,0 +1,55 @@ +/* + * 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. + */ + +#include "n_ref.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +NRef::NRef() {} + +NRef::NRef(NVal val) +{ + if (val) { + env_ = val.env_; + napi_create_reference(val.env_, val.val_, 1, &ref_); + } +} + +NRef::~NRef() +{ + if (ref_) { + napi_delete_reference(env_, ref_); + } +} + +NRef::operator bool() const +{ + return ref_ != nullptr; +} + +NVal NRef::Deref(napi_env env) +{ + if (!ref_) { + return NVal(); + } + + napi_value val = nullptr; + napi_get_reference_value(env, ref_, &val); + return {env, val}; +} +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS diff --git a/utils/filemgmt_libn/src/n_class.cpp b/utils/filemgmt_libn/src/n_class.cpp new file mode 100644 index 000000000..b8a76bd68 --- /dev/null +++ b/utils/filemgmt_libn/src/n_class.cpp @@ -0,0 +1,95 @@ +/* + * 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. + */ + +#include "n_class.h" + +#include "filemgmt_libhilog.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +using namespace std; +NClass &NClass::GetInstance() +{ + static thread_local NClass nClass; + return nClass; +} + +tuple NClass::DefineClass(napi_env env, + string className, + napi_callback constructor, + vector &&properties) +{ + napi_value classVal = nullptr; + napi_status stat = napi_define_class(env, className.c_str(), className.length(), constructor, nullptr, + properties.size(), properties.data(), &classVal); + if (stat != napi_ok) { + HILOGE("INNER BUG. Cannot define class %{public}s because of %{public}d", className.c_str(), stat); + } + + return {stat == napi_ok, classVal}; +} + +bool NClass::SaveClass(napi_env env, string className, napi_value exClass) +{ + NClass &nClass = NClass::GetInstance(); + lock_guard(nClass.exClassMapLock); + + if (nClass.exClassMap.find(className) != nClass.exClassMap.end()) { + return true; + } + + napi_ref constructor; + napi_status res = napi_create_reference(env, exClass, 1, &constructor); + if (res == napi_ok) { + nClass.exClassMap.insert({className, constructor}); + HILOGI("Class %{public}s has been saved", className.c_str()); + } else { + HILOGE("INNER BUG. Cannot ref class constructor %{public}s because of %{public}d", className.c_str(), res); + } + + return res == napi_ok; +} + +napi_value NClass::InstantiateClass(napi_env env, const string& className, const vector& args) +{ + NClass &nClass = NClass::GetInstance(); + lock_guard(nClass.exClassMapLock); + + auto it = nClass.exClassMap.find(className); + if (it == nClass.exClassMap.end()) { + HILOGE("Class %{public}s hasn't been saved yet", className.c_str()); + return nullptr; + } + + napi_value cons = nullptr; + napi_status status = napi_get_reference_value(env, it->second, &cons); + if (status != napi_ok) { + HILOGE("INNER BUG. Cannot deref class %{public}s because of %{public}d", className.c_str(), status); + return nullptr; + } + + napi_value instance = nullptr; + status = napi_new_instance(env, cons, args.size(), args.data(), &instance); + if (status != napi_ok) { + HILOGE("INNER BUG. Cannot instantiate the class %{public}s because of %{public}d", className.c_str(), status); + return nullptr; + } + + return instance; +} +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS diff --git a/utils/filemgmt_libn/src/n_error.cpp b/utils/filemgmt_libn/src/n_error.cpp new file mode 100644 index 000000000..88fff79c0 --- /dev/null +++ b/utils/filemgmt_libn/src/n_error.cpp @@ -0,0 +1,72 @@ +/* + * 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. + */ + +#include "n_error.h" + +#include + +#include "n_val.h" +#include "filemgmt_libhilog.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +using namespace std; + +NError::NError() {} + +NError::NError(int ePosix) : errno_(ePosix), errMsg_(strerror(errno_)) {} + +NError::NError(std::function()> errGen) +{ + tie(errno_, errMsg_) = errGen(); +} + +NError::operator bool() const +{ + return errno_ != ERRNO_NOERR; +} + +napi_value NError::GetNapiErr(napi_env env) +{ + napi_value code = NVal::CreateUTF8String(env, to_string(errno_)).val_; + napi_value msg = NVal::CreateUTF8String(env, errMsg_).val_; + + napi_value res = nullptr; + napi_status createRes = napi_create_error(env, code, msg, &res); + if (createRes) { + HILOGE("Failed to create an exception, msg = %{public}s", errMsg_.c_str()); + } + return res; +} + +void NError::ThrowErr(napi_env env, string errMsg) +{ + napi_value tmp = nullptr; + napi_get_and_clear_last_exception(env, &tmp); + // Note that ace engine cannot thow errors created by napi_create_error so far + napi_status throwStatus = napi_throw_error(env, nullptr, errMsg.c_str()); + if (throwStatus != napi_ok) { + HILOGE("Failed to throw an exception, %{public}d, code = %{public}s", throwStatus, errMsg.c_str()); + } +} + +void NError::ThrowErr(napi_env env) +{ + ThrowErr(env, errMsg_); +} +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS \ No newline at end of file diff --git a/utils/filemgmt_libn/src/n_func_arg.cpp b/utils/filemgmt_libn/src/n_func_arg.cpp new file mode 100644 index 000000000..0e4fdfc47 --- /dev/null +++ b/utils/filemgmt_libn/src/n_func_arg.cpp @@ -0,0 +1,110 @@ +/* + * 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. + */ + +#include "n_func_arg.h" + +#include "n_error.h" +#include "filemgmt_libhilog.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +using namespace std; + +NFuncArg::NFuncArg(napi_env env, napi_callback_info info) : env_(env), info_(info) {} + +NFuncArg::~NFuncArg() {} + +void NFuncArg::SetArgc(size_t argc) +{ + argc_ = argc; +} +void NFuncArg::SetThisVar(napi_value thisVar) +{ + thisVar_ = thisVar; +} + +size_t NFuncArg::GetArgc(void) const +{ + return argc_; +} + +napi_value NFuncArg::GetThisVar(void) const +{ + return thisVar_; +} + +napi_value NFuncArg::GetArg(size_t argPos) const +{ + return (argPos < GetArgc()) ? argv_[argPos] : nullptr; +} + +napi_value NFuncArg::operator[](size_t argPos) const +{ + return GetArg(argPos); +} + +bool NFuncArg::InitArgs(std::function argcChecker) +{ + SetArgc(0); + argv_.reset(); + + size_t argc; + napi_value thisVar; + napi_status status = napi_get_cb_info(env_, info_, &argc, nullptr, &thisVar, nullptr); + if (status != napi_ok) { + HILOGE("Cannot get num of func args for %{public}d", status); + return false; + } + if (argc) { + argv_ = make_unique(argc); + status = napi_get_cb_info(env_, info_, &argc, argv_.get(), &thisVar, nullptr); + if (status != napi_ok) { + HILOGE("Cannot get func args for %{public}d", status); + return false; + } + } + SetArgc(argc); + SetThisVar(thisVar); + + return argcChecker(); +} + +bool NFuncArg::InitArgs(size_t argc) +{ + return InitArgs([argc, this]() { + size_t realArgc = GetArgc(); + if (argc != realArgc) { + HILOGE("Num of args recved eq %zu while expecting %{public}zu", realArgc, argc); + return false; + } + return true; + }); +} + +bool NFuncArg::InitArgs(size_t minArgc, size_t maxArgc) +{ + return InitArgs([minArgc, maxArgc, this]() { + size_t realArgc = GetArgc(); + if (minArgc > realArgc || maxArgc < realArgc) { + HILOGE("Num of args recved eq %zu while expecting %{public}zu ~ %{public}zu", realArgc, minArgc, maxArgc); + return false; + } + return true; + }); +} +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS diff --git a/utils/filemgmt_libn/src/n_val.cpp b/utils/filemgmt_libn/src/n_val.cpp new file mode 100644 index 000000000..2ac3b941d --- /dev/null +++ b/utils/filemgmt_libn/src/n_val.cpp @@ -0,0 +1,307 @@ +/* + * 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. + */ + +#include "n_val.h" + +#include + +#include "n_error.h" +#include "filemgmt_libhilog.h" + +namespace OHOS { +namespace FileManagement { +namespace LibN { +using namespace std; + +NVal::NVal(napi_env nEnv, napi_value nVal = nullptr) : env_(nEnv), val_(nVal) {} + +NVal::operator bool() const +{ + return env_ && val_; +} + +bool NVal::TypeIs(napi_valuetype expType) const +{ + if (!*this) { + return false; + } + napi_valuetype valueType; + napi_typeof(env_, val_, &valueType); + + if (expType != valueType) { + return false; + } + return true; +} + +bool NVal::TypeIsError(bool checkErrno) const +{ + if (!*this) { + return false; + } + + bool res = false; + napi_is_error(env_, val_, &res); + + return res; +} + +tuple, size_t> NVal::ToUTF8String() const +{ + size_t strLen = 0; + napi_status status = napi_get_value_string_utf8(env_, val_, nullptr, -1, &strLen); + if (status != napi_ok) { + return {false, nullptr, 0}; + } + + size_t bufLen = strLen + 1; + unique_ptr str = make_unique(bufLen); + status = napi_get_value_string_utf8(env_, val_, str.get(), bufLen, &strLen); + return make_tuple(status == napi_ok, move(str), strLen); +} + +tuple, size_t> NVal::ToUTF16String() const +{ +#ifdef FILE_SUBSYSTEM_DEBUG_LOCAL + size_t strLen = 0; + napi_status status = napi_get_value_string_utf16(env_, val_, nullptr, -1, &strLen); + if (status != napi_ok) { + return {false, nullptr, 0}; + } + + auto str = make_unique(++strLen); + status = napi_get_value_string_utf16(env_, val_, str.get(), strLen, nullptr); + if (status != napi_ok) { + return {false, nullptr, 0}; + } + + strLen = reinterpret_cast(str.get() + strLen) - reinterpret_cast(str.get()); + auto strRet = unique_ptr(reinterpret_cast(str.release())); + return {true, move(strRet), strLen}; +#else + // Note that quickjs doesn't support utf16 + return ToUTF8String(); +#endif +} + +tuple NVal::ToPointer() const +{ + void *res = nullptr; + napi_status status = napi_get_value_external(env_, val_, &res); + return make_tuple(status == napi_ok, res); +} + +tuple NVal::ToBool() const +{ + bool flag = false; + napi_status status = napi_get_value_bool(env_, val_, &flag); + return make_tuple(status == napi_ok, flag); +} + +tuple NVal::ToInt32() const +{ + int32_t res = 0; + napi_status status = napi_get_value_int32(env_, val_, &res); + return make_tuple(status == napi_ok, res); +} + +tuple NVal::ToInt64() const +{ + int64_t res = 0; + napi_status status = napi_get_value_int64(env_, val_, &res); + return make_tuple(status == napi_ok, res); +} + +tuple NVal::ToArraybuffer() const +{ + void *buf = nullptr; + size_t bufLen = 0; + bool status = napi_get_arraybuffer_info(env_, val_, &buf, &bufLen); + return make_tuple(status == napi_ok, buf, bufLen); +} + +tuple NVal::ToTypedArray() const +{ + napi_typedarray_type type; + napi_value in_array_buffer = nullptr; + size_t byte_offset; + size_t length; + void *data = nullptr; + napi_status status = + napi_get_typedarray_info(env_, val_, &type, &length, (void **)&data, &in_array_buffer, &byte_offset); + return make_tuple(status == napi_ok, data, length); +} + +bool NVal::HasProp(string propName) const +{ + bool res = false; + + if (!env_ || !val_ || !TypeIs(napi_object)) { + return false; + } + + napi_status status = napi_has_named_property(env_, val_, propName.c_str(), &res); + return (status == napi_ok) && res; +} + +NVal NVal::GetProp(string propName) const +{ + if (!HasProp(propName)) { + return {env_, nullptr}; + } + + napi_value prop = nullptr; + napi_status status = napi_get_named_property(env_, val_, propName.c_str(), &prop); + if (status != napi_ok) { + return {env_, nullptr}; + } + return NVal(env_, prop); +} + +bool NVal::AddProp(vector &&propVec) const +{ + if (!TypeIs(napi_valuetype::napi_object)) { + HILOGE("INNER BUG. Prop should only be added to objects"); + return false; + } + + napi_status status = napi_define_properties(env_, val_, propVec.size(), propVec.data()); + if (status != napi_ok) { + HILOGE("INNER BUG. Cannot define properties because of %{public}d", status); + return false; + } + return true; +} + +bool NVal::AddProp(string propName, napi_value val) const +{ + if (!TypeIs(napi_valuetype::napi_object) || HasProp(propName)) { + HILOGE("INNER BUG. Prop should only be added to objects"); + return false; + } + + napi_status status = napi_set_named_property(env_, val_, propName.c_str(), val); + if (status != napi_ok) { + HILOGE("INNER BUG. Cannot set named property because of %{public}d", status); + return false; + } + return true; +} + +NVal NVal::CreateUndefined(napi_env env) +{ + napi_value res = nullptr; + napi_get_undefined(env, &res); + return {env, res}; +} + +NVal NVal::CreateInt64(napi_env env, int64_t val) +{ + napi_value res = nullptr; + napi_create_int64(env, val, &res); + return {env, res}; +} + +NVal NVal::CreateInt32(napi_env env, int32_t val) +{ + napi_value res = nullptr; + napi_create_int32(env, val, &res); + return {env, res}; +} + +NVal NVal::CreateObject(napi_env env) +{ + napi_value res = nullptr; + napi_create_object(env, &res); + return {env, res}; +} + +NVal NVal::CreateBool(napi_env env, bool val) +{ + napi_value res = nullptr; + napi_get_boolean(env, val, &res); + return {env, res}; +} + +NVal NVal::CreateUTF8String(napi_env env, std::string str) +{ + napi_value res = nullptr; + napi_create_string_utf8(env, str.c_str(), str.length(), &res); + return {env, res}; +} + +NVal NVal::CreateUTF8String(napi_env env, const char *str, ssize_t len) +{ + napi_value res = nullptr; + napi_create_string_utf8(env, str, len, &res); + return {env, res}; +} + +NVal NVal::CreateUint8Array(napi_env env, void *buf, size_t bufLen) +{ + napi_value output_buffer = nullptr; + napi_create_external_arraybuffer( + env, buf, bufLen, [](napi_env env, void *finalize_data, void *finalize_hint) { free(finalize_data); }, NULL, + &output_buffer); + napi_value output_array = nullptr; + napi_create_typedarray(env, napi_uint8_array, bufLen, output_buffer, 0, &output_array); + return {env, output_array}; +} + +tuple NVal::CreateArrayBuffer(napi_env env, size_t len) +{ + napi_value val; + void *buf = nullptr; + napi_create_arraybuffer(env, len, &buf, &val); + return {{env, val}, {buf}}; +} + +napi_property_descriptor NVal::DeclareNapiProperty(const char *name, napi_value val) +{ + return {(name), nullptr, nullptr, nullptr, nullptr, val, napi_default, nullptr}; +} + +napi_property_descriptor NVal::DeclareNapiStaticProperty(const char *name, napi_value val) +{ + return {(name), nullptr, nullptr, nullptr, nullptr, val, napi_static, nullptr}; +} + +napi_property_descriptor NVal::DeclareNapiFunction(const char *name, napi_callback func) +{ + return {(name), nullptr, (func), nullptr, nullptr, nullptr, napi_default, nullptr}; +} + +napi_property_descriptor NVal::DeclareNapiStaticFunction(const char *name, napi_callback func) +{ + return {(name), nullptr, (func), nullptr, nullptr, nullptr, napi_static, nullptr}; +} + +napi_property_descriptor NVal::DeclareNapiGetter(const char *name, napi_callback getter) +{ + return {(name), nullptr, nullptr, (getter), nullptr, nullptr, napi_default, nullptr}; +} + +napi_property_descriptor NVal::DeclareNapiSetter(const char *name, napi_callback setter) +{ + return {(name), nullptr, nullptr, nullptr, (setter), nullptr, napi_default, nullptr}; +} + +napi_property_descriptor NVal::DeclareNapiGetterSetter(const char *name, napi_callback getter, napi_callback setter) +{ + return {(name), nullptr, nullptr, (getter), (setter), nullptr, napi_default, nullptr}; +} +} // namespace LibN +} // namespace FileManagement +} // namespace OHOS -- Gitee