From e8330bfcdc4741d1b608fb60c2a15727e2cd05c6 Mon Sep 17 00:00:00 2001 From: wangjianqiang Date: Wed, 22 Jun 2022 10:19:27 +0800 Subject: [PATCH 1/4] add Function code Signed-off-by: wangjianqiang --- bundle.json | 3 +- frameworks/innerkits/BUILD.gn | 21 + frameworks/innerkits/file_access/BUILD.gn | 117 ++++++ .../file_access/include/file_access_helper.h | 85 ++++ .../file_access/include/file_ext_ability.h | 63 +++ .../include/file_ext_ability_module_loader.h | 33 ++ .../file_access/include/file_ext_connection.h | 56 +++ .../file_access/include/file_ext_proxy.h | 47 +++ .../file_access/include/file_ext_stub.h | 49 +++ .../file_access/include/file_ext_stub_impl.h | 51 +++ .../file_access/include/file_extension_info.h | 146 +++++++ .../file_access/include/ifile_ext_base.h | 56 +++ .../file_access/include/js_file_ext_ability.h | 64 +++ .../include/napi_common_fileaccess.h | 54 +++ .../file_access/src/file_access_helper.cpp | 377 +++++++++++++++++ .../file_access/src/file_ext_ability.cpp | 119 ++++++ .../src/file_ext_ability_module_loader.cpp | 49 +++ .../file_access/src/file_ext_connection.cpp | 93 +++++ .../file_access/src/file_ext_proxy.cpp | 363 ++++++++++++++++ .../file_access/src/file_ext_stub.cpp | 316 ++++++++++++++ .../file_access/src/file_ext_stub_impl.cpp | 144 +++++++ .../file_access/src/js_file_ext_ability.cpp | 390 ++++++++++++++++++ .../src/napi_common_fileaccess.cpp | 362 ++++++++++++++++ utils/hilog_wrapper.h | 81 ++++ 24 files changed, 3138 insertions(+), 1 deletion(-) create mode 100644 frameworks/innerkits/BUILD.gn create mode 100644 frameworks/innerkits/file_access/BUILD.gn create mode 100644 frameworks/innerkits/file_access/include/file_access_helper.h create mode 100644 frameworks/innerkits/file_access/include/file_ext_ability.h create mode 100644 frameworks/innerkits/file_access/include/file_ext_ability_module_loader.h create mode 100644 frameworks/innerkits/file_access/include/file_ext_connection.h create mode 100644 frameworks/innerkits/file_access/include/file_ext_proxy.h create mode 100644 frameworks/innerkits/file_access/include/file_ext_stub.h create mode 100644 frameworks/innerkits/file_access/include/file_ext_stub_impl.h create mode 100644 frameworks/innerkits/file_access/include/file_extension_info.h create mode 100644 frameworks/innerkits/file_access/include/ifile_ext_base.h create mode 100644 frameworks/innerkits/file_access/include/js_file_ext_ability.h create mode 100644 frameworks/innerkits/file_access/include/napi_common_fileaccess.h create mode 100644 frameworks/innerkits/file_access/src/file_access_helper.cpp create mode 100644 frameworks/innerkits/file_access/src/file_ext_ability.cpp create mode 100644 frameworks/innerkits/file_access/src/file_ext_ability_module_loader.cpp create mode 100644 frameworks/innerkits/file_access/src/file_ext_connection.cpp create mode 100644 frameworks/innerkits/file_access/src/file_ext_proxy.cpp create mode 100644 frameworks/innerkits/file_access/src/file_ext_stub.cpp create mode 100644 frameworks/innerkits/file_access/src/file_ext_stub_impl.cpp create mode 100644 frameworks/innerkits/file_access/src/js_file_ext_ability.cpp create mode 100644 frameworks/innerkits/file_access/src/napi_common_fileaccess.cpp create mode 100644 utils/hilog_wrapper.h diff --git a/bundle.json b/bundle.json index 1b615582..b73e9a8b 100644 --- a/bundle.json +++ b/bundle.json @@ -36,7 +36,8 @@ "sub_component": [ "//foundation/filemanagement/user_file_service/services:fms", "//foundation/filemanagement/user_file_service/services/sa_profile:filemanager_service_sa_profile", - "//foundation/filemanagement/user_file_service/interfaces/kits/js:filemanager" + "//foundation/filemanagement/user_file_service/interfaces/kits/js:filemanager", + "//foundation/filemanagement/user_file_service/frameworks/innerkits:frameworks_innerkits" ], "test": [ "//foundation/filemanagement/user_file_service/services/test:user_file_manager_test" diff --git a/frameworks/innerkits/BUILD.gn b/frameworks/innerkits/BUILD.gn new file mode 100644 index 00000000..50ab31b3 --- /dev/null +++ b/frameworks/innerkits/BUILD.gn @@ -0,0 +1,21 @@ +# 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") + +group("frameworks_innerkits") { + deps = [ + "file_access:file_extension_ability_kit", + "file_access:file_extension_ability_module", + ] +} diff --git a/frameworks/innerkits/file_access/BUILD.gn b/frameworks/innerkits/file_access/BUILD.gn new file mode 100644 index 00000000..086f31a0 --- /dev/null +++ b/frameworks/innerkits/file_access/BUILD.gn @@ -0,0 +1,117 @@ +# 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") +import("//foundation/filemanagement/user_file_service/filemanagement_aafwk.gni") + +BASE_DIR = "//foundation/filemanagement/user_file_service" + +config("ability_config") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "${BASE_DIR}/utils", + "${aafwk_services_path}/common/include", + "${aafwk_kits_path}/ability/native/include/continuation/distributed", + "${aafwk_kits_path}/ability/native/include/continuation/kits", + "${aafwk_kits_path}/appkit/native/app/include", + "${aafwk_path}/frameworks/js/napi/aafwk/inner/napi_common", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base/include", + ] + + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } +} + +config("ability_public_config") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "${BASE_DIR}/utils", + "${aafwk_kits_path}/appkit/native/ability_runtime/app", + "${aafwk_kits_path}/appkit/native/app/include", + "${aafwk_kits_path}/appkit/native/ability_runtime/context", + ] +} + +ohos_shared_library("file_extension_ability_kit") { + include_dirs = [] + + sources = [ + "src/file_access_helper.cpp", + "src/file_ext_ability.cpp", + "src/file_ext_connection.cpp", + "src/file_ext_proxy.cpp", + "src/file_ext_stub.cpp", + "src/file_ext_stub_impl.cpp", + "src/js_file_ext_ability.cpp", + "src/napi_common_fileaccess.cpp" + ] + configs = [ ":ability_config" ] + public_configs = [ + ":ability_public_config", + "${aafwk_kits_path}/ability/ability_runtime:ability_context_public_config", + ] + + deps = [ + "${aafwk_kits_path}/ability/native:abilitykit_native", + "${aafwk_kits_path}/appkit:app_context", + ] + + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_context_native", + "ability_runtime:ability_manager", + "ability_runtime:app_manager", + "ability_runtime:runtime", + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "ipc:ipc_core", + "ipc_js:rpc", + "utils_base:utils", + ] + + public_deps = [ + "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog", + "//foundation/arkui/napi:ace_napi", + ] + + subsystem_name = "filemanagement" + part_name = "user_file_service" +} + +ohos_shared_library("file_extension_ability_module") { + sources = [ "src/file_ext_ability_module_loader.cpp" ] + + configs = [ ":ability_config" ] + public_configs = [ ":ability_public_config" ] + + deps = [ + ":file_extension_ability_kit", + "${aafwk_kits_path}/ability/native:abilitykit_native", + ] + + external_deps = [ + "ability_base:want", + "ability_runtime:runtime", + "hiviewdfx_hilog_native:libhilog", + "utils_base:utils", + ] + + relative_install_dir = "extensionability/" + subsystem_name = "filemanagement" + part_name = "user_file_service" +} diff --git a/frameworks/innerkits/file_access/include/file_access_helper.h b/frameworks/innerkits/file_access/include/file_access_helper.h new file mode 100644 index 00000000..59be925c --- /dev/null +++ b/frameworks/innerkits/file_access/include/file_access_helper.h @@ -0,0 +1,85 @@ +/* + * 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 FILE_ACCESS_HELPER_H +#define FILE_ACCESS_HELPER_H + +#include +#include +#include + +#include "file_ext_connection.h" +#include "foundation/ability/ability_runtime/frameworks/kits/appkit/native/ability_runtime/context/context.h" +#include "ifile_ext_base.h" +#include "file_extension_info.h" +#include "uri.h" +#include "want.h" +#include "hilog_wrapper.h" + +using Uri = OHOS::Uri; + +namespace OHOS { +namespace FileAccessFwk { +using string = std::string; +class FileAccessHelper final : public std::enable_shared_from_this { +public: + ~FileAccessHelper() = default; + + static std::shared_ptr Creator(const std::shared_ptr &context, + const AAFwk::Want &want); + + static std::shared_ptr Creator(const sptr &token, const AAFwk::Want &want); + bool Release(); + int OpenFile(Uri &uri, int flags); + int CreateFile(Uri &parentUri, const std::string &displayName, Uri &newFileUri); + int Mkdir(Uri &parentUri, const std::string &displayName, Uri &newDirUri); + int Delete(Uri &selectFileUri); + int Move(Uri &sourceFileUri, Uri &targetParentUri, Uri &newFileUri); + int Rename(Uri &sourceFileUri, const std::string &displayName, Uri &newFileUri); + + std::vector ListFile(Uri &sourceFileUri); + std::vector GetRoots(); +private: + FileAccessHelper(const std::shared_ptr &context, const AAFwk::Want &want, + const sptr &fileExtProxy); + FileAccessHelper(const sptr &token, + const AAFwk::Want &want, const sptr &fileExtProxy); + void AddFileAccessDeathRecipient(const sptr &token); + void OnSchedulerDied(const wptr &remote); + + sptr token_ = {}; + AAFwk::Want want_ = {}; + sptr fileExtProxy_ = nullptr; + bool isSystemCaller_ = false; + sptr callerDeathRecipient_ = nullptr; + sptr fileExtConnection_ = nullptr; +}; + +class FileAccessDeathRecipient : public IRemoteObject::DeathRecipient { +public: + using RemoteDiedHandler = std::function &)>; + + explicit FileAccessDeathRecipient(RemoteDiedHandler handler); + + virtual ~FileAccessDeathRecipient(); + + virtual void OnRemoteDied(const wptr &remote); + +private: + RemoteDiedHandler handler_; +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_ACCESS_HELPER_H diff --git a/frameworks/innerkits/file_access/include/file_ext_ability.h b/frameworks/innerkits/file_access/include/file_ext_ability.h new file mode 100644 index 00000000..8eec212d --- /dev/null +++ b/frameworks/innerkits/file_access/include/file_ext_ability.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 FILE_EXT_ABILITY_H +#define FILE_EXT_ABILITY_H + +#include "extension_base.h" +#include "file_extension_info.h" + +namespace OHOS { +namespace AbilityRuntime { +class Runtime; +} +namespace FileAccessFwk { +using namespace AbilityRuntime; +class FileExtAbility; +using CreatorFunc = std::function& runtime)>; +class FileExtAbility : public ExtensionBase<> { +public: + FileExtAbility() = default; + virtual ~FileExtAbility() = default; + + virtual void Init(const std::shared_ptr &record, + const std::shared_ptr &application, + std::shared_ptr &handler, + const sptr &token) override; + + static FileExtAbility* Create(const std::unique_ptr& runtime); + + virtual int OpenFile(const Uri &uri, int flags); + virtual int CreateFile(const Uri &parentUri, const std::string &displayName, Uri &newFileUri); + virtual int Mkdir(const Uri &parentUri, const std::string &displayName, Uri &newFileUri); + virtual int Delete(const Uri &sourceFileUri); + virtual int Move(const Uri &sourceFileUri, const Uri &targetParentUri, Uri &newFileUri); + virtual int Rename(const Uri &sourceFileUri, const std::string &displayName, Uri &newFileUri); + + virtual std::vector ListFile(const Uri &sourceFileUri); + virtual std::vector GetRoots(); + + /** + * @brief Set a creator function. + * + * @param creator The function for create a file extension ability. + */ + static void SetCreator(const CreatorFunc& creator); +private: + static CreatorFunc creator_; +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_EXT_ABILITY_H \ No newline at end of file diff --git a/frameworks/innerkits/file_access/include/file_ext_ability_module_loader.h b/frameworks/innerkits/file_access/include/file_ext_ability_module_loader.h new file mode 100644 index 00000000..6f0a67ab --- /dev/null +++ b/frameworks/innerkits/file_access/include/file_ext_ability_module_loader.h @@ -0,0 +1,33 @@ +/* + * 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 FILE_EXT_ABILITY_MODULE_LOADER_H +#define FILE_EXT_ABILITY_MODULE_LOADER_H + +#include "extension_module_loader.h" +namespace OHOS { +namespace FileAccessFwk { +using namespace AbilityRuntime; +class FileExtAbilityModuleLoader : public ExtensionModuleLoader, + public Singleton { + DECLARE_SINGLETON(FileExtAbilityModuleLoader); + +public: + virtual Extension *Create(const std::unique_ptr& runtime) const override; + virtual std::map GetParams() override; +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_EXT_ABILITY_MODULE_LOADER_H \ No newline at end of file diff --git a/frameworks/innerkits/file_access/include/file_ext_connection.h b/frameworks/innerkits/file_access/include/file_ext_connection.h new file mode 100644 index 00000000..9777cde9 --- /dev/null +++ b/frameworks/innerkits/file_access/include/file_ext_connection.h @@ -0,0 +1,56 @@ +/* + * 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 FILE_EXT_CONNECTION_H +#define FILE_EXT_CONNECTION_H + +#include + +#include "ability_connect_callback_stub.h" +#include "event_handler.h" +#include "ifile_ext_base.h" +#include "want.h" + +namespace OHOS { +namespace FileAccessFwk { +class FileExtConnection : public AAFwk::AbilityConnectionStub { +public: + FileExtConnection() = default; + virtual ~FileExtConnection() = default; + + static sptr GetInstance(); + + void OnAbilityConnectDone( + const AppExecFwk::ElementName &element, const sptr &remoteObject, int resultCode) override; + + void OnAbilityDisconnectDone(const AppExecFwk::ElementName &element, int resultCode) override; + + void ConnectFileExtAbility(const AAFwk::Want &want, const sptr &token); + + void DisconnectFileExtAbility(); + + bool IsExtAbilityConnected(); + + sptr GetFileExtProxy(); + +private: + static sptr instance_; + static std::mutex mutex_; + std::atomic isConnected_ = {false}; + sptr fileExtProxy_; +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_EXT_CONNECTION_H diff --git a/frameworks/innerkits/file_access/include/file_ext_proxy.h b/frameworks/innerkits/file_access/include/file_ext_proxy.h new file mode 100644 index 00000000..2bb521df --- /dev/null +++ b/frameworks/innerkits/file_access/include/file_ext_proxy.h @@ -0,0 +1,47 @@ +/* + * 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 FILE_EXT_PROXY_H +#define FILE_EXT_PROXY_H + +#include + +#include "file_extension_info.h" +#include "ifile_ext_base.h" + +namespace OHOS { +namespace FileAccessFwk { +class FileExtProxy : public IRemoteProxy { +public: + explicit FileExtProxy(const sptr& remote) : IRemoteProxy(remote) {} + + virtual ~FileExtProxy() {} + + virtual int OpenFile(const Uri &uri, int flags) override; + virtual int CreateFile(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) override; + virtual int Mkdir(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) override; + virtual int Delete(const Uri &sourceFileUri) override; + virtual int Move(const Uri &sourceFileUri, const Uri &targetParentUri, Uri &newFileUri) override; + virtual int Rename(const Uri &sourceFileUri, const std::string &displayName, Uri &newFileUri) override; + + virtual std::vector ListFile(const Uri &sourceFileUri) override; + virtual std::vector GetRoots() override; +private: + static inline BrokerDelegator delegator_; +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_EXT_PROXY_H + diff --git a/frameworks/innerkits/file_access/include/file_ext_stub.h b/frameworks/innerkits/file_access/include/file_ext_stub.h new file mode 100644 index 00000000..101f7c55 --- /dev/null +++ b/frameworks/innerkits/file_access/include/file_ext_stub.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 FILE_EXT_STUB_H +#define FILE_EXT_STUB_H + +#include +#include + +#include "file_extension_info.h" +#include "ifile_ext_base.h" + +namespace OHOS { +namespace FileAccessFwk { +class FileExtStub : public IRemoteStub { +public: + FileExtStub(); + ~FileExtStub(); + int OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override; +private: + ErrCode CmdOpenFile(MessageParcel &data, MessageParcel &reply); + ErrCode CmdCreateFile(MessageParcel &data, MessageParcel &reply); + ErrCode CmdMkdir(MessageParcel &data, MessageParcel &reply); + ErrCode CmdDelete(MessageParcel &data, MessageParcel &reply); + ErrCode CmdMove(MessageParcel &data, MessageParcel &reply); + ErrCode CmdRename(MessageParcel &data, MessageParcel &reply); + + ErrCode CmdListFile(MessageParcel &data, MessageParcel &reply); + ErrCode CmdGetRoots(MessageParcel &data, MessageParcel &reply); + + using RequestFuncType = int (FileExtStub::*)(MessageParcel &data, MessageParcel &reply); + std::map stubFuncMap_; +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_EXT_STUB_H + diff --git a/frameworks/innerkits/file_access/include/file_ext_stub_impl.h b/frameworks/innerkits/file_access/include/file_ext_stub_impl.h new file mode 100644 index 00000000..d0247efa --- /dev/null +++ b/frameworks/innerkits/file_access/include/file_ext_stub_impl.h @@ -0,0 +1,51 @@ +/* + * 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 FILE_EXT_STUB_IMPL_H +#define FILE_EXT_STUB_IMPL_H + +#include +#include "file_ext_stub.h" +#include "file_extension_info.h" +#include "file_ext_ability.h" +#include "native_engine/native_value.h" + +namespace OHOS { +namespace FileAccessFwk { +class FileExtStubImpl : public FileExtStub { +public: + explicit FileExtStubImpl(const std::shared_ptr& extension, napi_env env) + : extension_(extension) {} + + virtual ~FileExtStubImpl() {} + + int OpenFile(const Uri &uri, int flags) override; + int CreateFile(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) override; + int Mkdir(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) override; + int Delete(const Uri &sourceFileUri) override; + int Move(const Uri &sourceFileUri, const Uri &targetParentUri, Uri &newFileUri) override; + int Rename(const Uri &sourceFileUri, const std::string &displayName, Uri &newFileUri) override; + + std::vector ListFile(const Uri &sourceFileUri) override; + std::vector GetRoots() override; +private: + std::shared_ptr GetOwner(); + +private: + std::shared_ptr extension_; +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_EXT_STUB_IMPL_H diff --git a/frameworks/innerkits/file_access/include/file_extension_info.h b/frameworks/innerkits/file_access/include/file_extension_info.h new file mode 100644 index 00000000..9cd7faae --- /dev/null +++ b/frameworks/innerkits/file_access/include/file_extension_info.h @@ -0,0 +1,146 @@ +/* + * 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 FILE_EXTENSION_INFO_H +#define FILE_EXTENSION_INFO_H + +#include +#include + +#include "parcel.h" +#include "uri.h" + +namespace OHOS { +namespace FileAccessFwk { +struct FileInfo : public virtual OHOS::Parcelable { +public: + Uri uri = Uri(""); + std::string fileName; + std::string mode; + int64_t size {0}; + int64_t mtime {0}; + std::string mimiType; + + bool ReadFromParcel(Parcel &parcel) + { + std::unique_ptr uriInfo(parcel.ReadParcelable()); + if (uriInfo == nullptr) { + return false; + } + uri = *uriInfo; + + fileName = parcel.ReadString(); + mode = parcel.ReadString(); + size = parcel.ReadUint64(); + mtime = parcel.ReadInt64(); + mimiType = parcel.ReadString(); + return true; + } + virtual bool Marshalling(Parcel &parcel) const override + { + if (!parcel.WriteParcelable(&uri)) { + return false; + } + if (!parcel.WriteString(fileName)) { + return false; + } + if (!parcel.WriteString(mode)) { + return false; + } + if (!parcel.WriteUint64(size)) { + return false; + } + if (!parcel.WriteInt64(mtime)) { + return false; + } + if (!parcel.WriteString(mimiType)) { + return false; + } + return true; + } + static FileInfo *Unmarshalling(Parcel &parcel) + { + FileInfo *info = new (std::nothrow) FileInfo(); + if (info == nullptr) { + return nullptr; + } + + if (!info->ReadFromParcel(parcel)) { + delete info; + info = nullptr; + } + return info; + } +}; + +struct DeviceInfo : public virtual OHOS::Parcelable { +public: + Uri uri = Uri(""); + std::string displayName; + std::string deviceId; + uint32_t flags {0}; + + bool ReadFromParcel(Parcel &parcel) + { + std::unique_ptr uriInfo(parcel.ReadParcelable()); + if (uriInfo == nullptr) { + return false; + } + uri = *uriInfo; + + displayName = parcel.ReadString(); + deviceId = parcel.ReadString(); + flags = parcel.ReadUint32(); + return true; + } + virtual bool Marshalling(Parcel &parcel) const override + { + if (!parcel.WriteParcelable(&uri)) { + return false; + } + if (!parcel.WriteString(displayName)) { + return false; + } + if (!parcel.WriteString(deviceId)) { + return false; + } + if (!parcel.WriteUint32(flags)) { + return false; + } + return true; + } + static DeviceInfo *Unmarshalling(Parcel &parcel) + { + DeviceInfo *info = new (std::nothrow) DeviceInfo(); + if (info == nullptr) { + return nullptr; + } + + if (!info->ReadFromParcel(parcel)) { + delete info; + info = nullptr; + } + return info; + } +}; + +const uint32_t FLAG_SUPPORTS_THUMBNAIL = 1; +const uint32_t FLAG_SUPPORTS_WRITE = 1 << 1; +const uint32_t FLAG_SUPPORTS_READ = 1 << 2; +const uint32_t FLAG_SUPPORTS_DELETE = 1 << 3; +const uint32_t FLAG_SUPPORTS_RENAME = 1 << 4; +const uint32_t FLAG_SUPPORTS_MOVE = 1 << 5; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_EXTENSION_INFO_H \ No newline at end of file diff --git a/frameworks/innerkits/file_access/include/ifile_ext_base.h b/frameworks/innerkits/file_access/include/ifile_ext_base.h new file mode 100644 index 00000000..3c7ba272 --- /dev/null +++ b/frameworks/innerkits/file_access/include/ifile_ext_base.h @@ -0,0 +1,56 @@ +/* + * 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 I_FILE_EXT_BASE_H +#define I_FILE_EXT_BASE_H + +#include +#include +#include +#include + +#include "file_extension_info.h" +#include "uri.h" + +namespace OHOS { +namespace FileAccessFwk { +class IFileExtBase : public IRemoteBroker { +public: + DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.FileAccessFwk.IFileExtBase"); + + enum { + CMD_OPEN_FILE = 1, + CMD_CREATE_FILE = 2, + CMD_MKDIR = 3, + CMD_DELETE = 4, + CMD_MOVE = 5, + CMD_RENAME = 6, + CMD_LIST_FILE = 7, + CMD_GET_ROOTS = 8 + }; + + virtual int OpenFile(const Uri &uri, int flags) = 0; + virtual int CreateFile(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) = 0; + virtual int Mkdir(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) = 0; + virtual int Delete(const Uri &sourceFileUri) = 0; + virtual int Move(const Uri &sourceFileUri, const Uri &targetParentUri, Uri &newFileUri) = 0; + virtual int Rename(const Uri &sourceFileUri, const std::string &displayName, Uri &newFileUri) = 0; + + virtual std::vector ListFile(const Uri &sourceFileUri) = 0; + virtual std::vector GetRoots() = 0; +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // I_FILE_EXT_BASE_H diff --git a/frameworks/innerkits/file_access/include/js_file_ext_ability.h b/frameworks/innerkits/file_access/include/js_file_ext_ability.h new file mode 100644 index 00000000..14ff3942 --- /dev/null +++ b/frameworks/innerkits/file_access/include/js_file_ext_ability.h @@ -0,0 +1,64 @@ +/* + * 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 JS_FILE_EXT_ABILITY_H +#define JS_FILE_EXT_ABILITY_H + +#include "file_ext_ability.h" + +#include "napi_common_fileaccess.h" +#include "file_extension_info.h" +#include "js_runtime.h" +#include "native_engine/native_reference.h" +#include "native_engine/native_value.h" + +namespace OHOS { +namespace FileAccessFwk { +using namespace AbilityRuntime; +class JsFileExtAbility : public FileExtAbility { +public: + JsFileExtAbility(JsRuntime& jsRuntime); + virtual ~JsFileExtAbility() override; + + static JsFileExtAbility* Create(const std::unique_ptr& runtime); + + void Init(const std::shared_ptr &record, + const std::shared_ptr &application, + std::shared_ptr &handler, + const sptr &token) override; + + void OnStart(const AAFwk::Want &want) override; + + sptr OnConnect(const AAFwk::Want &want) override; + + int OpenFile(const Uri &uri, int flags) override; + int CreateFile(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) override; + int Mkdir(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) override; + int Delete(const Uri &sourceFileUri) override; + int Move(const Uri &sourceFileUri, const Uri &targetParentUri, Uri &newFileUri) override; + int Rename(const Uri &sourceFileUri, const std::string &displayName, Uri &newFileUri) override; + + std::vector ListFile(const Uri &sourceFileUri) override; + std::vector GetRoots() override; +private: + NativeValue* CallObjectMethod(const char *name, NativeValue * const *argv = nullptr, size_t argc = 0); + void GetSrcPath(std::string &srcPath); + + JsRuntime& jsRuntime_; + std::unique_ptr jsObj_; +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // JS_FILE_EXT_ABILITY_H \ No newline at end of file diff --git a/frameworks/innerkits/file_access/include/napi_common_fileaccess.h b/frameworks/innerkits/file_access/include/napi_common_fileaccess.h new file mode 100644 index 00000000..9ac9d64e --- /dev/null +++ b/frameworks/innerkits/file_access/include/napi_common_fileaccess.h @@ -0,0 +1,54 @@ +/* + * 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 NAPI_COMMON_FILE_ACCESS_H +#define NAPI_COMMON_FILE_ACCESS_H + +#include +#include +#include + +#include "file_extension_info.h" +#include "napi_common_data.h" +#include "napi_common_util.h" + +namespace OHOS { +namespace FileAccessFwk { +bool UnwrapInt64ByPropertyName(napi_env env, napi_value param, const char *propertyName, int64_t &value); + +napi_value WrapUint32ToJS(napi_env env, uint32_t value); +uint32_t UnwrapUint32FromJS(napi_env env, napi_value param, uint32_t defaultValue = 0); +bool UnwrapUint32FromJS2(napi_env env, napi_value param, uint32_t &value); +bool UnwrapUint32ByPropertyName(napi_env env, napi_value param, const char *propertyName, uint32_t &value); + +napi_value WrapBigIntUint64ToJS(napi_env env, uint64_t value); +uint64_t UnwrapBigIntUint64FromJS(napi_env env, napi_value param, uint64_t defaultValue = 0); +bool UnwrapBigIntUint64FromJS2(napi_env env, napi_value param, uint64_t &defaultValue); +bool UnwrapBigIntUint64ByPropertyName(napi_env env, napi_value param, const char *propertyName, uint64_t &value); + +napi_value WrapFileInfo(napi_env env, const FileInfo &fileInfo); +bool UnwrapFileInfo(napi_env env, napi_value param, FileInfo &fileInfo); + +napi_value WrapArrayFileInfoToJS(napi_env env, const std::vector &fileInfoVec); +bool UnwrapArrayFileInfoFromJS(napi_env env, napi_value param, std::vector &fileInfoVec); + +napi_value WrapDeviceInfo(napi_env env, const DeviceInfo &deviceInfo); +bool UnwrapDeviceInfo(napi_env env, napi_value param, DeviceInfo &deviceInfo); + +napi_value WrapArrayDeviceInfoToJS(napi_env env, const std::vector &deviceInfoVec); +bool UnwrapArrayDeviceInfoFromJS(napi_env env, napi_value param, std::vector &deviceInfoVec); +} // namespace FileAccessFwk +} // namespace OHOS +#endif // NAPI_COMMON_FILE_ACCESS_H diff --git a/frameworks/innerkits/file_access/src/file_access_helper.cpp b/frameworks/innerkits/file_access/src/file_access_helper.cpp new file mode 100644 index 00000000..56c753a1 --- /dev/null +++ b/frameworks/innerkits/file_access/src/file_access_helper.cpp @@ -0,0 +1,377 @@ +/* + * 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 "file_access_helper.h" + +#include "hilog_wrapper.h" +#include "ifile_ext_base.h" + +namespace OHOS { +namespace FileAccessFwk { +FileAccessHelper::FileAccessHelper(const std::shared_ptr &context, + const AAFwk::Want &want, const sptr &fileExtProxy) +{ + HILOG_INFO("%{public}s start", __func__); + token_ = context->GetToken(); + want_ = want; + fileExtProxy_ = fileExtProxy; + fileExtConnection_ = FileExtConnection::GetInstance(); + HILOG_INFO("%{public}s end", __func__); +} + +void FileAccessHelper::AddFileAccessDeathRecipient(const sptr &token) +{ + HILOG_INFO("%{public}s called begin", __func__); + if (token != nullptr && callerDeathRecipient_ != nullptr) { + HILOG_INFO("token RemoveDeathRecipient."); + token->RemoveDeathRecipient(callerDeathRecipient_); + } + if (callerDeathRecipient_ == nullptr) { + callerDeathRecipient_ = + new FileAccessDeathRecipient(std::bind(&FileAccessHelper::OnSchedulerDied, this, std::placeholders::_1)); + } + if (token != nullptr) { + HILOG_INFO("token AddDeathRecipient."); + token->AddDeathRecipient(callerDeathRecipient_); + } + HILOG_INFO("%{public}s called end", __func__); +} + +void FileAccessHelper::OnSchedulerDied(const wptr &remote) +{ + HILOG_INFO("%{public}s called begin", __func__); + auto object = remote.promote(); + object = nullptr; + fileExtProxy_ = nullptr; + HILOG_INFO("%{public}s called end", __func__); +} + +FileAccessHelper::FileAccessHelper(const sptr &token, + const AAFwk::Want &want, const sptr &fileExtProxy) +{ + HILOG_INFO("FileAccessHelper::FileAccessHelper start"); + token_ = token; + want_ = want; + fileExtProxy_ = fileExtProxy; + fileExtConnection_ = FileExtConnection::GetInstance(); + HILOG_INFO("FileAccessHelper::FileAccessHelper end"); +} + +std::shared_ptr FileAccessHelper::Creator( + const sptr &token, const AAFwk::Want &want) +{ + HILOG_INFO("FileAccessHelper::Creator with runtime context, want and uri called start."); + + HILOG_INFO("FileAccessHelper::Creator before ConnectFileExtAbility."); + sptr fileExtProxy = nullptr; + + sptr fileExtConnection = FileExtConnection::GetInstance(); + if (!fileExtConnection->IsExtAbilityConnected()) { + fileExtConnection->ConnectFileExtAbility(want, token); + } + fileExtProxy = fileExtConnection->GetFileExtProxy(); + if (fileExtProxy == nullptr) { + HILOG_WARN("FileAccessHelper::Creator get invalid fileExtProxy"); + } + HILOG_INFO("FileAccessHelper::Creator after ConnectFileExtAbility."); + + FileAccessHelper *ptrDataShareHelper = new (std::nothrow) FileAccessHelper(token, want, fileExtProxy); + if (ptrDataShareHelper == nullptr) { + HILOG_ERROR("FileAccessHelper::Creator failed, create FileAccessHelper failed"); + return nullptr; + } + + HILOG_INFO("FileAccessHelper::Creator with runtime context, want and uri called end."); + return std::shared_ptr(ptrDataShareHelper); +} + +std::shared_ptr FileAccessHelper::Creator( + const std::shared_ptr &context, const AAFwk::Want &want) +{ + HILOG_INFO("%{public}s with runtime context, want and uri called start.", __func__); + if (context == nullptr) { + HILOG_ERROR("%{public}s failed, context == nullptr", __func__); + return nullptr; + } + + HILOG_INFO("%{public}s before ConnectFileExtAbility.", __func__); + sptr fileExtProxy = nullptr; + + sptr fileExtConnection = FileExtConnection::GetInstance(); + if (!fileExtConnection->IsExtAbilityConnected()) { + fileExtConnection->ConnectFileExtAbility(want, context->GetToken()); + } + fileExtProxy = fileExtConnection->GetFileExtProxy(); + if (fileExtProxy == nullptr) { + HILOG_WARN("%{public}s get invalid fileExtProxy", __func__); + } + HILOG_INFO("%{public}s after ConnectFileExtAbility.", __func__); + + FileAccessHelper *ptrFileAccessHelper = new (std::nothrow) FileAccessHelper(context, want, fileExtProxy); + if (ptrFileAccessHelper == nullptr) { + HILOG_ERROR("%{public}s failed, create FileAccessHelper failed", __func__); + return nullptr; + } + + HILOG_INFO("%{public}s with runtime context, want and uri called end.", __func__); + return std::shared_ptr(ptrFileAccessHelper); +} + +bool FileAccessHelper::Release() +{ + HILOG_INFO("%{public}s called begin", __func__); + + HILOG_INFO("FileAccessHelper::Release before DisconnectFileExtAbility."); + if (fileExtConnection_->IsExtAbilityConnected()) { + fileExtConnection_->DisconnectFileExtAbility(); + } + HILOG_INFO("FileAccessHelper::Release after DisconnectFileExtAbility."); + fileExtProxy_ = nullptr; + HILOG_INFO("%{public}s called end", __func__); + return true; +} + +int FileAccessHelper::OpenFile(Uri &uri, int flags) +{ + HILOG_INFO("%{public}s begin.", __func__); + + int fd = -1; + + HILOG_INFO("FileAccessHelper::OpenFile before ConnectFileExtAbility."); + if (!fileExtConnection_->IsExtAbilityConnected()) { + fileExtConnection_->ConnectFileExtAbility(want_, token_); + } + fileExtProxy_ = fileExtConnection_->GetFileExtProxy(); + HILOG_INFO("FileAccessHelper::OpenFile after ConnectFileExtAbility."); + if (isSystemCaller_ && fileExtProxy_) { + AddFileAccessDeathRecipient(fileExtProxy_->AsObject()); + } + + if (fileExtProxy_ == nullptr) { + HILOG_ERROR("%{public}s failed with invalid fileExtProxy_", __func__); + return fd; + } + + HILOG_INFO("FileAccessHelper::OpenFile before fileExtProxy_->OpenFile."); + fd = fileExtProxy_->OpenFile(uri, flags); + HILOG_INFO("FileAccessHelper::OpenFile after fileExtProxy_->OpenFile."); + HILOG_INFO("%{public}s end.", __func__); + return fd; +} + +int FileAccessHelper::CreateFile(Uri &parentUri, const std::string &displayName, Uri &newFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + + int index = -1; + + HILOG_INFO("FileAccessHelper::CreateFile before ConnectDataShareExtAbility."); + if (!fileExtConnection_->IsExtAbilityConnected()) { + fileExtConnection_->ConnectFileExtAbility(want_, token_); + } + fileExtProxy_ = fileExtConnection_->GetFileExtProxy(); + HILOG_INFO("FileAccessHelper::CreateFile after ConnectDataShareExtAbility."); + if (isSystemCaller_ && fileExtProxy_) { + AddFileAccessDeathRecipient(fileExtProxy_->AsObject()); + } + + if (fileExtProxy_ == nullptr) { + HILOG_ERROR("%{public}s failed with invalid fileExtProxy_", __func__); + return index; + } + + HILOG_INFO("FileAccessHelper::CreateFile before fileExtProxy_->CreateFile."); + index = fileExtProxy_->CreateFile(parentUri, displayName, newFileUri); + HILOG_INFO("FileAccessHelper::CreateFile after fileExtProxy_->CreateFile."); + HILOG_INFO("%{public}s end.", __func__); + return index; +} + +int FileAccessHelper::Mkdir(Uri &parentUri, const std::string &displayName, Uri &newDirUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + + int index = -1; + + HILOG_INFO("FileAccessHelper::Mkdir before ConnectFileExtAbility."); + if (!fileExtConnection_->IsExtAbilityConnected()) { + fileExtConnection_->ConnectFileExtAbility(want_, token_); + } + fileExtProxy_ = fileExtConnection_->GetFileExtProxy(); + HILOG_INFO("FileAccessHelper::Mkdir after ConnectFileExtAbility."); + if (isSystemCaller_ && fileExtProxy_) { + AddFileAccessDeathRecipient(fileExtProxy_->AsObject()); + } + + if (fileExtProxy_ == nullptr) { + HILOG_ERROR("%{public}s failed with invalid fileExtProxy_", __func__); + return index; + } + + HILOG_INFO("FileAccessHelper::Mkdir before fileExtProxy_->Mkdir."); + index = fileExtProxy_->Mkdir(parentUri, displayName, newDirUri); + HILOG_INFO("FileAccessHelper::Mkdir after fileExtProxy_->Mkdir."); + HILOG_INFO("%{public}s end.", __func__); + return index; +} + +int FileAccessHelper::Delete(Uri &selectFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + + int index = -1; + + HILOG_INFO("FileAccessHelper::Delete before ConnectFileExtAbility."); + if (!fileExtConnection_->IsExtAbilityConnected()) { + fileExtConnection_->ConnectFileExtAbility(want_, token_); + } + fileExtProxy_ = fileExtConnection_->GetFileExtProxy(); + HILOG_INFO("FileAccessHelper::Delete after ConnectFileExtAbility."); + if (isSystemCaller_ && fileExtProxy_) { + AddFileAccessDeathRecipient(fileExtProxy_->AsObject()); + } + + if (fileExtProxy_ == nullptr) { + HILOG_ERROR("%{public}s failed with invalid fileExtProxy_", __func__); + return index; + } + + HILOG_INFO("FileAccessHelper::Delete before fileExtProxy_->Delete."); + index = fileExtProxy_->Delete(selectFileUri); + HILOG_INFO("FileAccessHelper::Delete after fileExtProxy_->Delete."); + HILOG_INFO("%{public}s end.", __func__); + return index; +} + +int FileAccessHelper::Move(Uri &sourceFileUri, Uri &targetParentUri, Uri &newFileUri) +{ + HILOG_INFO("FileAccessHelper::Move start."); + int index = -1; + + if (!fileExtConnection_->IsExtAbilityConnected()) { + fileExtConnection_->ConnectFileExtAbility(want_, token_); + } + fileExtProxy_ = fileExtConnection_->GetFileExtProxy(); + if (isSystemCaller_ && fileExtProxy_) { + AddFileAccessDeathRecipient(fileExtProxy_->AsObject()); + } + + if (fileExtProxy_ == nullptr) { + HILOG_ERROR("%{public}s failed with invalid fileExtProxy_", __func__); + return index; + } + + index = fileExtProxy_->Move(sourceFileUri, targetParentUri, newFileUri); + return index; +} + +int FileAccessHelper::Rename(Uri &sourceFileUri, const std::string &displayName, Uri &newFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + + int index = -1; + + HILOG_INFO("FileAccessHelper::Rename before ConnectFileExtAbility."); + if (!fileExtConnection_->IsExtAbilityConnected()) { + fileExtConnection_->ConnectFileExtAbility(want_, token_); + } + fileExtProxy_ = fileExtConnection_->GetFileExtProxy(); + HILOG_INFO("FileAccessHelper::Rename after ConnectFileExtAbility."); + if (isSystemCaller_ && fileExtProxy_) { + AddFileAccessDeathRecipient(fileExtProxy_->AsObject()); + } + + if (fileExtProxy_ == nullptr) { + HILOG_ERROR("%{public}s failed with invalid fileExtProxy_", __func__); + return index; + } + + HILOG_INFO("FileAccessHelper::Rename before fileExtProxy_->Rename."); + index = fileExtProxy_->Rename(sourceFileUri, displayName, newFileUri); + HILOG_INFO("FileAccessHelper::Rename after fileExtProxy_->Rename."); + HILOG_INFO("%{public}s end.", __func__); + return index; +} + +std::vector FileAccessHelper::ListFile(Uri &sourceFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + std::vector results; + + HILOG_INFO("FileAccessHelper::ListFile before ConnectFileExtAbility."); + if (!fileExtConnection_->IsExtAbilityConnected()) { + fileExtConnection_->ConnectFileExtAbility(want_, token_); + } + fileExtProxy_ = fileExtConnection_->GetFileExtProxy(); + HILOG_INFO("FileAccessHelper::ListFile after ConnectFileExtAbility."); + if (isSystemCaller_ && fileExtProxy_) { + AddFileAccessDeathRecipient(fileExtProxy_->AsObject()); + } + + if (fileExtProxy_ == nullptr) { + HILOG_ERROR("%{public}s failed with invalid fileExtProxy_", __func__); + return results; + } + + results = fileExtProxy_->ListFile(sourceFileUri); + HILOG_INFO("%{public}s end size=%{public}zu.", __func__, results.size()); + return results; +} + +std::vector FileAccessHelper::GetRoots() +{ + HILOG_INFO("%{public}s begin.", __func__); + std::vector results; + + HILOG_INFO("FileAccessHelper::GetRoots before ConnectFileExtAbility."); + if (!fileExtConnection_->IsExtAbilityConnected()) { + fileExtConnection_->ConnectFileExtAbility(want_, token_); + } + fileExtProxy_ = fileExtConnection_->GetFileExtProxy(); + HILOG_INFO("FileAccessHelper::GetRoots after ConnectFileExtAbility."); + if (isSystemCaller_ && fileExtProxy_) { + AddFileAccessDeathRecipient(fileExtProxy_->AsObject()); + } + + if (fileExtProxy_ == nullptr) { + HILOG_ERROR("%{public}s failed with invalid fileExtProxy_", __func__); + return results; + } + + results = fileExtProxy_->GetRoots(); + HILOG_INFO("%{public}s end.", __func__); + return results; +} + +void FileAccessDeathRecipient::OnRemoteDied(const wptr &remote) +{ + HILOG_INFO("%{public}s begin.", __func__); + if (handler_) { + handler_(remote); + } + HILOG_INFO("%{public}s end.", __func__); +} + +FileAccessDeathRecipient::FileAccessDeathRecipient(RemoteDiedHandler handler) : handler_(handler) +{ + HILOG_INFO("%{public}s .", __func__); +} + +FileAccessDeathRecipient::~FileAccessDeathRecipient() +{ + HILOG_INFO("%{public}s .", __func__); +} +} // namespace FileAccessFwk +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/innerkits/file_access/src/file_ext_ability.cpp b/frameworks/innerkits/file_access/src/file_ext_ability.cpp new file mode 100644 index 00000000..8cd07d2e --- /dev/null +++ b/frameworks/innerkits/file_access/src/file_ext_ability.cpp @@ -0,0 +1,119 @@ +/* + * 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 "file_ext_ability.h" + +#include "ability_loader.h" +#include "connection_manager.h" +#include "extension_context.h" +#include "hilog_wrapper.h" +#include "js_file_ext_ability.h" +#include "runtime.h" + +namespace OHOS { +namespace FileAccessFwk { +using namespace OHOS::AppExecFwk; + +CreatorFunc FileExtAbility::creator_ = nullptr; +void FileExtAbility::SetCreator(const CreatorFunc& creator) +{ + creator_ = creator; +} + +FileExtAbility* FileExtAbility::Create(const std::unique_ptr& runtime) +{ + HILOG_INFO("%{public}s begin.", __func__); + if (!runtime) { + return new FileExtAbility(); + } + if (creator_) { + return creator_(runtime); + } + HILOG_INFO("%{public}s runtime", __func__); + switch (runtime->GetLanguage()) { + case Runtime::Language::JS: + HILOG_INFO("%{public}s Runtime::Language::JS --> JsFileExtAbility", __func__); + return JsFileExtAbility::Create(runtime); + + default: + HILOG_INFO("%{public}s default --> FileExtAbility", __func__); + return new FileExtAbility(); + } + HILOG_INFO("%{public}s begin.", __func__); +} + +void FileExtAbility::Init(const std::shared_ptr &record, + const std::shared_ptr &application, + std::shared_ptr &handler, + const sptr &token) +{ + HILOG_INFO("%{public}s begin.", __func__); + ExtensionBase<>::Init(record, application, handler, token); + HILOG_INFO("%{public}s end.", __func__); +} + +int FileExtAbility::OpenFile(const Uri &uri, int flags) +{ + HILOG_INFO("%{public}s begin.", __func__); + HILOG_INFO("%{public}s end.", __func__); + return 0; +} + +int FileExtAbility::CreateFile(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + HILOG_INFO("%{public}s end.", __func__); + return 0; +} + +int FileExtAbility::Mkdir(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + HILOG_INFO("%{public}s end.", __func__); + return 0; +} + +int FileExtAbility::Delete(const Uri &sourceFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + HILOG_INFO("%{public}s end.", __func__); + return 0; +} + +int FileExtAbility::Move(const Uri &sourceFileUri, const Uri &targetParentUri, Uri &newFileUri) +{ + return 0; +} + +int FileExtAbility::Rename(const Uri &sourceFileUri, const std::string &displayName, Uri &newFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + HILOG_INFO("%{public}s end.", __func__); + return 0; +} + +std::vector FileExtAbility::ListFile(const Uri &sourceFileUri) +{ + std::vector vec; + return vec; +} + +std::vector FileExtAbility::GetRoots() +{ + std::vector vec; + return vec; +} +} // namespace FileAccessFwk +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/innerkits/file_access/src/file_ext_ability_module_loader.cpp b/frameworks/innerkits/file_access/src/file_ext_ability_module_loader.cpp new file mode 100644 index 00000000..8c889174 --- /dev/null +++ b/frameworks/innerkits/file_access/src/file_ext_ability_module_loader.cpp @@ -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. + */ + +#include "file_ext_ability_module_loader.h" +#include "file_ext_ability.h" + +namespace OHOS { +namespace FileAccessFwk { +FileExtAbilityModuleLoader::FileExtAbilityModuleLoader() = default; +FileExtAbilityModuleLoader::~FileExtAbilityModuleLoader() = default; + +Extension *FileExtAbilityModuleLoader::Create(const std::unique_ptr& runtime) const +{ + HILOG_INFO("FileExtAbilityModuleLoader %{public}s.", __func__); + return FileExtAbility::Create(runtime); +} + +extern "C" __attribute__((visibility("default"))) void* OHOS_EXTENSION_GetExtensionModule() +{ + HILOG_INFO("FileExtAbilityModuleLoader %{public}s .", __func__); + return &FileExtAbilityModuleLoader::GetInstance(); +} + +extern "C" __attribute__((visibility("default"))) void SetCreator(const CreatorFunc& creator) +{ + return FileExtAbility::SetCreator(creator); +} + +std::map FileExtAbilityModuleLoader::GetParams() +{ + std::map params; + params.insert(std::pair("type", "11")); + params.insert(std::pair("name", "FileExtAbility")); + return params; +} +} // namespace FileAccessFwk +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/innerkits/file_access/src/file_ext_connection.cpp b/frameworks/innerkits/file_access/src/file_ext_connection.cpp new file mode 100644 index 00000000..bff9e5f3 --- /dev/null +++ b/frameworks/innerkits/file_access/src/file_ext_connection.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 "file_ext_connection.h" + +#include "ability_manager_client.h" +#include "hilog_wrapper.h" +#include "file_ext_proxy.h" + +namespace OHOS { +namespace FileAccessFwk { +sptr FileExtConnection::instance_ = nullptr; +std::mutex FileExtConnection::mutex_; + +sptr FileExtConnection::GetInstance() +{ + HILOG_INFO("%{public}s begin.", __func__); + if (instance_ == nullptr) { + std::lock_guard lock(mutex_); + if (instance_ == nullptr) { + instance_ = sptr(new (std::nothrow) FileExtConnection()); + } + } + HILOG_INFO("%{public}s end.", __func__); + return instance_; +} + +void FileExtConnection::OnAbilityConnectDone( + const AppExecFwk::ElementName &element, const sptr &remoteObject, int resultCode) +{ + HILOG_INFO("%{public}s called begin", __func__); + if (remoteObject == nullptr) { + HILOG_ERROR("%{public}s failed, remote is nullptr", __func__); + return; + } + fileExtProxy_ = iface_cast(remoteObject); + if (fileExtProxy_ == nullptr) { + HILOG_ERROR("%{public}s failed, fileExtProxy_ is nullptr", __func__); + return; + } + isConnected_.store(true); + HILOG_INFO("%{public}s end.", __func__); +} + +void FileExtConnection::OnAbilityDisconnectDone(const AppExecFwk::ElementName &element, int resultCode) +{ + HILOG_INFO("%{public}s called begin", __func__); + fileExtProxy_ = nullptr; + isConnected_.store(false); + HILOG_INFO("%{public}s called end", __func__); +} + +void FileExtConnection::ConnectFileExtAbility(const AAFwk::Want &want, const sptr &token) +{ + HILOG_INFO("%{public}s called begin", __func__); + ErrCode ret = AAFwk::AbilityManagerClient::GetInstance()->ConnectAbility(want, this, token); + HILOG_INFO("%{public}s called end, ret=%{public}d", __func__, ret); +} + +void FileExtConnection::DisconnectFileExtAbility() +{ + HILOG_INFO("%{public}s called begin", __func__); + fileExtProxy_ = nullptr; + isConnected_.store(false); + ErrCode ret = AAFwk::AbilityManagerClient::GetInstance()->DisconnectAbility(this); + HILOG_INFO("%{public}s called end, ret=%{public}d", __func__, ret); +} + +bool FileExtConnection::IsExtAbilityConnected() +{ + HILOG_INFO("%{public}s called ", __func__); + return isConnected_.load(); +} + +sptr FileExtConnection::GetFileExtProxy() +{ + HILOG_INFO("%{public}s called ", __func__); + return fileExtProxy_; +} +} // namespace FileAccessFwk +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/innerkits/file_access/src/file_ext_proxy.cpp b/frameworks/innerkits/file_access/src/file_ext_proxy.cpp new file mode 100644 index 00000000..da789946 --- /dev/null +++ b/frameworks/innerkits/file_access/src/file_ext_proxy.cpp @@ -0,0 +1,363 @@ +/* + * 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 "file_ext_proxy.h" + +#include "hilog_wrapper.h" + +namespace OHOS { +namespace FileAccessFwk { +int FileExtProxy::OpenFile(const Uri &uri, int flags) +{ + HILOG_INFO("%{public}s begin.", __func__); + int fd = -1; + MessageParcel data; + if (!data.WriteInterfaceToken(FileExtProxy::GetDescriptor())) { + HILOG_ERROR("%{public}s WriteInterfaceToken failed", __func__); + return fd; + } + + if (!data.WriteParcelable(&uri)) { + HILOG_ERROR("%{public}s fail to WriteParcelable uri", __func__); + return fd; + } + + if (!data.WriteInt32(flags)) { + HILOG_ERROR("%{public}s fail to WriteString mode", __func__); + return fd; + } + + MessageParcel reply; + MessageOption option; + int32_t err = Remote()->SendRequest(CMD_OPEN_FILE, data, reply, option); + if (err != NO_ERROR) { + HILOG_ERROR("%{public}s fail to SendRequest. err: %d", __func__, err); + return fd; + } + + fd = reply.ReadFileDescriptor(); + if (fd == -1) { + HILOG_ERROR("%{public}s fail to ReadFileDescriptor fd", __func__); + return fd; + } + + HILOG_INFO("%{public}s end successfully, return fd=%{public}d", __func__, fd); + return fd; +} + +int FileExtProxy::CreateFile(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + int ret = -1; + MessageParcel data; + if (!data.WriteInterfaceToken(FileExtProxy::GetDescriptor())) { + HILOG_ERROR("%{public}s WriteInterfaceToken failed", __func__); + return ret; + } + + if (!data.WriteParcelable(&parentUri)) { + HILOG_ERROR("%{public}s fail to WriteParcelable parentUri", __func__); + return ret; + } + + if (!data.WriteString(displayName)) { + HILOG_ERROR("%{public}s fail to WriteString mode", __func__); + return ret; + } + + if (!data.WriteParcelable(&newFileUri)) { + HILOG_ERROR("%{public}s fail to WriteParcelable newFileUri", __func__); + return ret; + } + + MessageParcel reply; + MessageOption option; + int32_t err = Remote()->SendRequest(CMD_CREATE_FILE, data, reply, option); + if (err != NO_ERROR) { + HILOG_ERROR("%{public}s fail to SendRequest. err: %d", __func__, err); + return ret; + } + + ret = reply.ReadInt32(); + if (ret < 0) { + HILOG_ERROR("%{public}s fail to ReadInt32 ret", __func__); + return ret; + } + + std::unique_ptr tempUri(reply.ReadParcelable()); + if (!tempUri) { + HILOG_ERROR("%{public}s ReadParcelable value is nullptr.", __func__); + ret = -1; + return ret; + } + + newFileUri = Uri(*tempUri); + HILOG_INFO("%{public}s end successfully, tempUri=%{public}s", __func__, tempUri->ToString().c_str()); + return ret; +} + +int FileExtProxy::Mkdir(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + int ret = -1; + MessageParcel data; + if (!data.WriteInterfaceToken(FileExtProxy::GetDescriptor())) { + HILOG_ERROR("%{public}s WriteInterfaceToken failed", __func__); + return ret; + } + + if (!data.WriteParcelable(&parentUri)) { + HILOG_ERROR("%{public}s fail to WriteParcelable parentUri", __func__); + return ret; + } + + if (!data.WriteString(displayName)) { + HILOG_ERROR("%{public}s fail to WriteString displayName", __func__); + return ret; + } + + if (!data.WriteParcelable(&newFileUri)) { + HILOG_ERROR("%{public}s fail to WriteParcelable newFileUri", __func__); + return ret; + } + + MessageParcel reply; + MessageOption option; + int32_t err = Remote()->SendRequest(CMD_MKDIR, data, reply, option); + if (err != NO_ERROR) { + HILOG_ERROR("%{public}s fail to SendRequest. err: %d", __func__, err); + return ret; + } + + ret = reply.ReadInt32(); + if (ret < 0) { + HILOG_ERROR("%{public}s fail to ReadInt32 ret", __func__); + return ret; + } + + std::unique_ptr tempUri(reply.ReadParcelable()); + if (!tempUri) { + HILOG_ERROR("%{public}s ReadParcelable value is nullptr.", __func__); + ret = -1; + return ret; + } + + newFileUri = Uri(*tempUri); + HILOG_INFO("%{public}s end successfully, tempUri=%{public}s", __func__, tempUri->ToString().c_str()); + return ret; +} + +int FileExtProxy::Delete(const Uri &sourceFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + int ret = -1; + MessageParcel data; + if (!data.WriteInterfaceToken(FileExtProxy::GetDescriptor())) { + HILOG_ERROR("%{public}s WriteInterfaceToken failed", __func__); + return ret; + } + + if (!data.WriteParcelable(&sourceFileUri)) { + HILOG_ERROR("%{public}s fail to WriteParcelable sourceFileUri", __func__); + return ret; + } + + MessageParcel reply; + MessageOption option; + int32_t err = Remote()->SendRequest(CMD_DELETE, data, reply, option); + if (err != NO_ERROR) { + HILOG_ERROR("%{public}s fail to SendRequest. err: %d", __func__, err); + return ret; + } + + ret = reply.ReadInt32(); + if (ret < 0) { + HILOG_ERROR("%{public}s fail to ReadInt32 ret", __func__); + return ret; + } + + HILOG_INFO("%{public}s end successfully, return ret=%{public}d", __func__, ret); + return ret; +} + +int FileExtProxy::Move(const Uri &sourceFileUri, const Uri &targetParentUri, Uri &newFileUri) +{ + int ret = -1; + MessageParcel data; + if (!data.WriteInterfaceToken(FileExtProxy::GetDescriptor())) { + HILOG_ERROR("tag dsa %{public}s WriteInterfaceToken failed", __func__); + return ret; + } + + if (!data.WriteParcelable(&sourceFileUri)) { + HILOG_ERROR("tag dsa %{public}s fail to WriteParcelable sourceFileUri", __func__); + return ret; + } + + if (!data.WriteParcelable(&targetParentUri)) { + HILOG_ERROR("tag dsa %{public}s fail to WriteParcelable targetParentUri", __func__); + return ret; + } + + if (!data.WriteParcelable(&newFileUri)) { + HILOG_ERROR("tag dsa %{public}s fail to WriteParcelable newFileUri", __func__); + return ret; + } + + MessageParcel reply; + MessageOption option; + int32_t err = Remote()->SendRequest(CMD_MOVE, data, reply, option); + if (err != NO_ERROR) { + HILOG_ERROR("tag dsa %{public}s fail to SendRequest. err: %d", __func__, err); + return ret; + } + + ret = reply.ReadInt32(); + if (ret < 0) { + HILOG_ERROR("tag dsa %{public}s fail to ReadInt32 ret", __func__); + return ret; + } + + std::unique_ptr tempUri(reply.ReadParcelable()); + if (!tempUri) { + HILOG_ERROR("tag dsa %{public}s ReadParcelable value is nullptr.", __func__); + ret = -1; + return ret; + } + + newFileUri = Uri(*tempUri); + HILOG_INFO(" tag dsa %{public}s end successfully, newFileUri=%{public}s", __func__, tempUri->ToString().c_str()); + return ret; +} + +int FileExtProxy::Rename(const Uri &sourceFileUri, const std::string &displayName, Uri &newFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + int ret = -1; + MessageParcel data; + if (!data.WriteInterfaceToken(FileExtProxy::GetDescriptor())) { + HILOG_ERROR("%{public}s WriteInterfaceToken failed", __func__); + return ret; + } + + if (!data.WriteParcelable(&sourceFileUri)) { + HILOG_ERROR("%{public}s fail to WriteParcelable sourceFileUri", __func__); + return ret; + } + + if (!data.WriteString(displayName)) { + HILOG_ERROR("%{public}s fail to WriteString displayName", __func__); + return ret; + } + + if (!data.WriteParcelable(&newFileUri)) { + HILOG_ERROR("%{public}s fail to WriteParcelable newFileUri", __func__); + return ret; + } + + MessageParcel reply; + MessageOption option; + int32_t err = Remote()->SendRequest(CMD_RENAME, data, reply, option); + if (err != NO_ERROR) { + HILOG_ERROR("%{public}s fail to SendRequest. err: %d", __func__, err); + return ret; + } + + ret = reply.ReadInt32(); + if (ret < 0) { + HILOG_ERROR("%{public}s fail to ReadInt32 ret", __func__); + return ret; + } + + std::unique_ptr tempUri(reply.ReadParcelable()); + if (!tempUri) { + HILOG_ERROR("%{public}s ReadParcelable value is nullptr.", __func__); + ret = -1; + return ret; + } + + newFileUri = Uri(*tempUri); + HILOG_INFO("%{public}s end successfully, tempUri=%{public}s", __func__, tempUri->ToString().c_str()); + return ret; +} + +std::vector FileExtProxy::ListFile(const Uri &sourceFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + std::vector vec; + MessageParcel data; + if (!data.WriteInterfaceToken(FileExtProxy::GetDescriptor())) { + HILOG_ERROR("%{public}s WriteInterfaceToken failed", __func__); + return vec; + } + + if (!data.WriteParcelable(&sourceFileUri)) { + HILOG_ERROR("%{public}s fail to WriteParcelable sourceFileUri", __func__); + return vec; + } + + MessageParcel reply; + MessageOption option; + int32_t err = Remote()->SendRequest(CMD_LIST_FILE, data, reply, option); + if (err != NO_ERROR) { + HILOG_ERROR("%{public}s fail to SendRequest. err: %d", __func__, err); + return vec; + } + + vec.clear(); + int64_t count = reply.ReadInt64(); + for (int32_t i = 0; i < count; i++) { + std::unique_ptr fileInfo(reply.ReadParcelable()); + if (fileInfo != nullptr) { + vec.push_back(*fileInfo); + } + } + + HILOG_INFO("%{public}s end successfully, return vec.size=%{public}zu", __func__, vec.size()); + return vec; +} + +std::vector FileExtProxy::GetRoots() +{ + HILOG_INFO("%{public}s begin.", __func__); + std::vector vec; + MessageParcel data; + if (!data.WriteInterfaceToken(FileExtProxy::GetDescriptor())) { + HILOG_ERROR("%{public}s WriteInterfaceToken failed", __func__); + return vec; + } + + MessageParcel reply; + MessageOption option; + int32_t err = Remote()->SendRequest(CMD_GET_ROOTS, data, reply, option); + if (err != NO_ERROR) { + HILOG_ERROR("%{public}s fail to SendRequest. err: %d", __func__, err); + return vec; + } + + vec.clear(); + uint64_t count = reply.ReadUint64(); + for (uint64_t i = 0; i < count; i++) { + std::unique_ptr deviceInfo(reply.ReadParcelable()); + if (deviceInfo != nullptr) { + vec.push_back(*deviceInfo); + } + } + + HILOG_INFO("%{public}s end successfully, return vec.size=%{public}zu", __func__, vec.size()); + return vec; +} +} // namespace FileAccessFwk +} // namespace OHOS diff --git a/frameworks/innerkits/file_access/src/file_ext_stub.cpp b/frameworks/innerkits/file_access/src/file_ext_stub.cpp new file mode 100644 index 00000000..1dfa9adc --- /dev/null +++ b/frameworks/innerkits/file_access/src/file_ext_stub.cpp @@ -0,0 +1,316 @@ +/* + * 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 "file_ext_stub.h" + +#include "hilog_wrapper.h" + +namespace OHOS { +namespace FileAccessFwk { +FileExtStub::FileExtStub() +{ + stubFuncMap_[CMD_OPEN_FILE] = &FileExtStub::CmdOpenFile; + stubFuncMap_[CMD_CREATE_FILE] = &FileExtStub::CmdCreateFile; + stubFuncMap_[CMD_MKDIR] = &FileExtStub::CmdMkdir; + stubFuncMap_[CMD_DELETE] = &FileExtStub::CmdDelete; + stubFuncMap_[CMD_MOVE] = &FileExtStub::CmdMove; + stubFuncMap_[CMD_RENAME] = &FileExtStub::CmdRename; + stubFuncMap_[CMD_LIST_FILE] = &FileExtStub::CmdListFile; + stubFuncMap_[CMD_GET_ROOTS] = &FileExtStub::CmdGetRoots; +} + +FileExtStub::~FileExtStub() +{ + HILOG_INFO("%{public}s begin.", __func__); + HILOG_INFO("%{public}s end.", __func__); + stubFuncMap_.clear(); +} + +int FileExtStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, + MessageOption& option) +{ + HILOG_INFO("%{public}s Received stub message: %{public}d", __func__, code); + std::u16string descriptor = FileExtStub::GetDescriptor(); + std::u16string remoteDescriptor = data.ReadInterfaceToken(); + if (descriptor != remoteDescriptor) { + HILOG_INFO("%{public}s local descriptor is not equal to remote", __func__); + return ERR_INVALID_STATE; + } + + const auto &itFunc = stubFuncMap_.find(code); + if (itFunc != stubFuncMap_.end()) { + return (this->*(itFunc->second))(data, reply); + } + + HILOG_INFO("%{public}s remote request unhandled: %{public}d", __func__, code); + return IPCObjectStub::OnRemoteRequest(code, data, reply, option); +} + +ErrCode FileExtStub::CmdOpenFile(MessageParcel &data, MessageParcel &reply) +{ + HILOG_INFO("%{public}s begin.", __func__); + std::shared_ptr uri(data.ReadParcelable()); + if (uri == nullptr) { + HILOG_ERROR("%{public}s uri is nullptr", __func__); + return ERR_INVALID_VALUE; + } + int flags = data.ReadInt32(); + if (flags < 0) { + HILOG_ERROR("%{public}s mode is invalid", __func__); + return ERR_INVALID_VALUE; + } + int fd = OpenFile(*uri, flags); + if (fd < 0) { + HILOG_ERROR("%{public}s OpenFile fail, fd is %{pubilc}d", __func__, fd); + return ERR_INVALID_VALUE; + } + HILOG_INFO("%{public}s retutn fd: %{public}d.", __func__, fd); + + if (!reply.WriteFileDescriptor(fd)) { + HILOG_ERROR("%{public}s fail to WriteFileDescriptor fd", __func__); + return ERR_INVALID_VALUE; + } + HILOG_INFO("%{public}s end.", __func__); + return NO_ERROR; +} + +ErrCode FileExtStub::CmdCreateFile(MessageParcel &data, MessageParcel &reply) +{ + HILOG_INFO("%{public}s begin.", __func__); + std::shared_ptr parentUri(data.ReadParcelable()); + if (parentUri == nullptr) { + HILOG_ERROR("%{public}s parentUri is nullptr", __func__); + return ERR_INVALID_VALUE; + } + std::string displayName = data.ReadString(); + if (displayName.empty()) { + HILOG_ERROR("%{public}s mode is nullptr", __func__); + return ERR_INVALID_VALUE; + } + std::shared_ptr fileUriNew(data.ReadParcelable()); + if (fileUriNew == nullptr) { + HILOG_ERROR("%{public}s fileUriNew is nullptr", __func__); + return ERR_INVALID_VALUE; + } + + int ret = CreateFile(*parentUri, displayName, *fileUriNew); + if (ret < 0) { + HILOG_ERROR("%{public}s CreateFile fail, ret is %{pubilc}d", __func__, ret); + return ERR_INVALID_VALUE; + } + + if (!reply.WriteInt32(ret)) { + HILOG_ERROR("%{public}s fail to WriteInt32 ret", __func__); + return ERR_INVALID_VALUE; + } + + if (!reply.WriteParcelable(&(*fileUriNew))) { + HILOG_ERROR("%{public}s fail to WriteParcelable type", __func__); + return ERR_INVALID_VALUE; + } + HILOG_INFO("%{public}s end. ret:%d, fileUriNew = %{public}s", __func__, ret, fileUriNew->ToString().c_str()); + HILOG_INFO("%{public}s end. fileUriNew = %{public}s", __func__, fileUriNew->ToString().c_str()); + return NO_ERROR; +} + +ErrCode FileExtStub::CmdMkdir(MessageParcel &data, MessageParcel &reply) +{ + HILOG_INFO("%{public}s begin.", __func__); + std::shared_ptr parentUri(data.ReadParcelable()); + if (parentUri == nullptr) { + HILOG_ERROR("%{public}s parentUri is nullptr", __func__); + return ERR_INVALID_VALUE; + } + std::string displayName = data.ReadString(); + if (displayName.empty()) { + HILOG_ERROR("%{public}s mode is nullptr", __func__); + return ERR_INVALID_VALUE; + } + std::shared_ptr fileUriNew(data.ReadParcelable()); + if (fileUriNew == nullptr) { + HILOG_ERROR("%{public}s fileUriNew is nullptr", __func__); + return ERR_INVALID_VALUE; + } + + int ret = Mkdir(*parentUri, displayName, *fileUriNew); + if (ret < 0) { + HILOG_ERROR("%{public}s Mkdir fail, ret is %{pubilc}d", __func__, ret); + return ERR_INVALID_VALUE; + } + + if (!reply.WriteInt32(ret)) { + HILOG_ERROR("%{public}s fail to WriteInt32 ret", __func__); + return ERR_INVALID_VALUE; + } + + if (!reply.WriteParcelable(&(*fileUriNew))) { + HILOG_ERROR("%{public}s fail to WriteParcelable type", __func__); + return ERR_INVALID_VALUE; + } + + HILOG_INFO("%{public}s end. ret:%d, fileUriNew = %{public}s", __func__, ret, fileUriNew->ToString().c_str()); + HILOG_INFO("%{public}s end. fileUriNew = %{public}s", __func__, fileUriNew->ToString().c_str()); + return NO_ERROR; +} + +ErrCode FileExtStub::CmdDelete(MessageParcel &data, MessageParcel &reply) +{ + HILOG_INFO("%{public}s begin.", __func__); + std::shared_ptr uri(data.ReadParcelable()); + if (uri == nullptr) { + HILOG_ERROR("%{public}s uri is nullptr", __func__); + return ERR_INVALID_VALUE; + } + + int ret = Delete(*uri); + if (ret < 0) { + HILOG_ERROR("%{public}s Delete fail, ret is %{pubilc}d", __func__, ret); + return ERR_INVALID_VALUE; + } + + if (!reply.WriteInt32(ret)) { + HILOG_ERROR("%{public}s fail to WriteFileDescriptor ret", __func__); + return ERR_INVALID_VALUE; + } + HILOG_INFO("%{public}s end.", __func__); + return NO_ERROR; +} + +ErrCode FileExtStub::CmdMove(MessageParcel &data, MessageParcel &reply) +{ + std::shared_ptr sourceFileUri(data.ReadParcelable()); + if (sourceFileUri == nullptr) { + HILOG_ERROR("tag dsa %{public}s sourceFileUri is nullptr", __func__); + return ERR_INVALID_VALUE; + } + std::shared_ptr targetParentUri(data.ReadParcelable()); + if (targetParentUri == nullptr) { + HILOG_ERROR("tag dsa %{public}s targetParentUri is nullptr", __func__); + return ERR_INVALID_VALUE; + } + std::shared_ptr fileUriNew(data.ReadParcelable()); + if (fileUriNew == nullptr) { + HILOG_ERROR("tag dsa %{public}s fileUriNew is nullptr", __func__); + return ERR_INVALID_VALUE; + } + + int ret = Move(*sourceFileUri, *targetParentUri, *fileUriNew); + if (ret < 0) { + HILOG_ERROR("tag dsa %{public}s fail, ret is %{pubilc}d", __func__, ret); + return ERR_INVALID_VALUE; + } + + if (!reply.WriteInt32(ret)) { + HILOG_ERROR("tag dsa %{public}s fail to WriteInt32 ret", __func__); + return ERR_INVALID_VALUE; + } + + if (!reply.WriteParcelable(&(*fileUriNew))) { + HILOG_ERROR("tag dsa %{public}s fail to WriteParcelable type", __func__); + return ERR_INVALID_VALUE; + } + + HILOG_INFO("tag dsa %{public}s end. ret:%d, newFileUri = %{public}s", __func__, ret, fileUriNew->ToString().c_str()); + return NO_ERROR; +} + +ErrCode FileExtStub::CmdRename(MessageParcel &data, MessageParcel &reply) +{ + HILOG_INFO("%{public}s begin.", __func__); + std::shared_ptr sourceFileUri(data.ReadParcelable()); + if (sourceFileUri == nullptr) { + HILOG_ERROR("%{public}s sourceFileUri is nullptr", __func__); + return ERR_INVALID_VALUE; + } + std::string displayName = data.ReadString(); + if (displayName.empty()) { + HILOG_ERROR("%{public}s mode is nullptr", __func__); + return ERR_INVALID_VALUE; + } + std::shared_ptr fileUriNew(data.ReadParcelable()); + if (fileUriNew == nullptr) { + HILOG_ERROR("%{public}s fileUriNew is nullptr", __func__); + return ERR_INVALID_VALUE; + } + + int ret = Rename(*sourceFileUri, displayName, *fileUriNew); + if (ret < 0) { + HILOG_ERROR("%{public}s Rename fail, ret is %{pubilc}d", __func__, ret); + return ERR_INVALID_VALUE; + } + + if (!reply.WriteInt32(ret)) { + HILOG_ERROR("%{public}s fail to WriteInt32 ret", __func__); + return ERR_INVALID_VALUE; + } + + if (!reply.WriteParcelable(&(*fileUriNew))) { + HILOG_ERROR("%{public}s fail to WriteParcelable type", __func__); + return ERR_INVALID_VALUE; + } + + HILOG_INFO("%{public}s end. ret:%d, fileUriNew = %{public}s", __func__, ret, fileUriNew->ToString().c_str()); + HILOG_INFO("%{public}s end. fileUriNew = %{public}s", __func__, fileUriNew->ToString().c_str()); + return NO_ERROR; +} + +ErrCode FileExtStub::CmdListFile(MessageParcel &data, MessageParcel &reply) +{ + HILOG_INFO("%{public}s begin.", __func__); + std::shared_ptr uri(data.ReadParcelable()); + if (uri == nullptr) { + HILOG_ERROR("%{public}s uri is nullptr", __func__); + return ERR_INVALID_VALUE; + } + + std::vector vec = ListFile(*uri); + uint64_t count {vec.size()}; + if (!reply.WriteUint64(count)) { + HILOG_ERROR("%{public}s fail to WriteInt32 count", __func__); + return ERR_INVALID_VALUE; + } + for (uint64_t i = 0; i < count; i++) { + if (!reply.WriteParcelable(&vec[i])) { + HILOG_ERROR("%{public}s fail to WriteParcelable vec", __func__); + return ERR_INVALID_VALUE; + } + } + + HILOG_INFO("%{public}s end.", __func__); + return NO_ERROR; +} + +ErrCode FileExtStub::CmdGetRoots(MessageParcel &data, MessageParcel &reply) +{ + HILOG_INFO("%{public}s begin.", __func__); + + std::vector vec = GetRoots(); + uint64_t count {vec.size()}; + if (!reply.WriteUint64(count)) { + HILOG_ERROR("%{public}s fail to WriteInt32 count", __func__); + return ERR_INVALID_VALUE; + } + for (uint64_t i = 0; i < count; i++) { + if (!reply.WriteParcelable(&vec[i])) { + HILOG_ERROR("%{public}s fail to WriteParcelable ret", __func__); + return ERR_INVALID_VALUE; + } + } + + HILOG_INFO("%{public}s end.", __func__); + return NO_ERROR; +} +} // namespace FileAccessFwk +} // namespace OHOS diff --git a/frameworks/innerkits/file_access/src/file_ext_stub_impl.cpp b/frameworks/innerkits/file_access/src/file_ext_stub_impl.cpp new file mode 100644 index 00000000..7e709588 --- /dev/null +++ b/frameworks/innerkits/file_access/src/file_ext_stub_impl.cpp @@ -0,0 +1,144 @@ +/* + * 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 "file_ext_stub_impl.h" + +#include "hilog_wrapper.h" + +namespace OHOS { +namespace FileAccessFwk { +std::shared_ptr FileExtStubImpl::GetOwner() +{ + HILOG_INFO("%{public}s begin.", __func__); + HILOG_INFO("%{public}s end.", __func__); + return extension_; +} + +int FileExtStubImpl::OpenFile(const Uri &uri, int flags) +{ + HILOG_INFO("%{public}s begin.", __func__); + int ret = -1; + auto extension = GetOwner(); + if (extension == nullptr) { + HILOG_ERROR("%{public}s end failed.", __func__); + return ret; + } + ret = extension->OpenFile(uri, flags); + HILOG_INFO("%{public}s end successfully, return fd:%{public}d", __func__, ret); + return ret; +} + +int FileExtStubImpl::CreateFile(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + int ret = -1; + auto extension = GetOwner(); + if (extension == nullptr) { + HILOG_ERROR("%{public}s end failed.", __func__); + return ret; + } + ret = extension->CreateFile(parentUri, displayName, newFileUri); + HILOG_INFO("%{public}s end successfully, return ret:%{public}d, %{public}s", + __func__, ret, newFileUri.ToString().c_str()); + return ret; +} + +int FileExtStubImpl::Mkdir(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + int ret = -1; + auto extension = GetOwner(); + if (extension == nullptr) { + HILOG_ERROR("%{public}s end failed.", __func__); + return ret; + } + ret = extension->Mkdir(parentUri, displayName, newFileUri); + HILOG_INFO("%{public}s end successfully, return ret:%{public}d, %{public}s", + __func__, ret, newFileUri.ToString().c_str()); + return ret; +} + +int FileExtStubImpl::Delete(const Uri &sourceFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + int ret = -1; + auto extension = GetOwner(); + if (extension == nullptr) { + HILOG_ERROR("%{public}s end failed.", __func__); + return ret; + } + ret = extension->Delete(sourceFileUri); + HILOG_INFO("%{public}s end successfully, return fd:%{public}d", __func__, ret); + return ret; +} + +int FileExtStubImpl::Move(const Uri &sourceFileUri, const Uri &targetParentUri, Uri &newFileUri) +{ + int ret = -1; + auto extension = GetOwner(); + if (extension == nullptr) { + HILOG_ERROR("%{public}s end failed.", __func__); + return ret; + } + ret = extension->Move(sourceFileUri, targetParentUri, newFileUri); + HILOG_INFO("tag dsa %{public}s end successfully, return ret:%{public}d, %{public}s", + __func__, ret, newFileUri.ToString().c_str()); + return ret; +} + +int FileExtStubImpl::Rename(const Uri &sourceFileUri, const std::string &displayName, Uri &newFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + int ret = -1; + auto extension = GetOwner(); + if (extension == nullptr) { + HILOG_ERROR("%{public}s end failed.", __func__); + return ret; + } + ret = extension->Rename(sourceFileUri, displayName, newFileUri); + HILOG_INFO("%{public}s end successfully, return ret:%{public}d, %{public}s", + __func__, ret, newFileUri.ToString().c_str()); + return ret; +} + +std::vector FileExtStubImpl::ListFile(const Uri &sourceFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + std::vector vec; + auto extension = GetOwner(); + if (extension == nullptr) { + HILOG_ERROR("%{public}s end failed.", __func__); + return vec; + } + vec = extension->ListFile(sourceFileUri); + HILOG_INFO("%{public}s end", __func__); + return vec; +} + +std::vector FileExtStubImpl::GetRoots() +{ + HILOG_INFO("%{public}s begin.", __func__); + std::vector vec; + auto extension = GetOwner(); + if (extension == nullptr) { + HILOG_ERROR("%{public}s end failed.", __func__); + return vec; + } + vec = extension->GetRoots(); + HILOG_INFO("%{public}s end.", __func__); + return vec; +} +} // namespace FileAccessFwk +} // namespace OHOS diff --git a/frameworks/innerkits/file_access/src/js_file_ext_ability.cpp b/frameworks/innerkits/file_access/src/js_file_ext_ability.cpp new file mode 100644 index 00000000..26d729b3 --- /dev/null +++ b/frameworks/innerkits/file_access/src/js_file_ext_ability.cpp @@ -0,0 +1,390 @@ +/* + * 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 "js_file_ext_ability.h" + +#include "extension_context.h" +#include "ability_info.h" +#include "accesstoken_kit.h" +#include "file_ext_stub_impl.h" +#include "hilog_wrapper.h" +#include "ipc_skeleton.h" +#include "js_runtime.h" +#include "js_runtime_utils.h" +#include "napi/native_api.h" +#include "napi/native_node_api.h" +#include "napi_common_fileaccess.h" +#include "napi_common_util.h" +#include "napi_common_want.h" +#include "napi_remote_object.h" + +namespace OHOS { +namespace FileAccessFwk { +namespace { +constexpr size_t ARGC_ZERO = 0; +constexpr size_t ARGC_ONE = 1; +constexpr size_t ARGC_TWO = 2; +} + +using namespace OHOS::AppExecFwk; +using namespace OHOS::AbilityRuntime; +using OHOS::Security::AccessToken::AccessTokenKit; + +JsFileExtAbility* JsFileExtAbility::Create(const std::unique_ptr& runtime) +{ + HILOG_INFO("%{public}s begin.", __func__); + HILOG_INFO("%{public}s end.", __func__); + return new JsFileExtAbility(static_cast(*runtime)); +} + +JsFileExtAbility::JsFileExtAbility(JsRuntime& jsRuntime) : jsRuntime_(jsRuntime) {} +JsFileExtAbility::~JsFileExtAbility() = default; + +void JsFileExtAbility::Init(const std::shared_ptr &record, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) +{ + HILOG_INFO("%{public}s begin.", __func__); + FileExtAbility::Init(record, application, handler, token); + std::string srcPath = ""; + GetSrcPath(srcPath); + if (srcPath.empty()) { + HILOG_ERROR("%{public}s Failed to get srcPath", __func__); + return; + } + + std::string moduleName(Extension::abilityInfo_->moduleName); + moduleName.append("::").append(abilityInfo_->name); + HILOG_INFO("%{public}s module:%{public}s, srcPath:%{public}s.", + __func__, moduleName.c_str(), srcPath.c_str()); + HandleScope handleScope(jsRuntime_); + + jsObj_ = jsRuntime_.LoadModule(moduleName, srcPath); + if (jsObj_ == nullptr) { + HILOG_ERROR("%{public}s Failed to get jsObj_", __func__); + return; + } + HILOG_INFO("%{public}s ConvertNativeValueTo.", __func__); + NativeObject* obj = ConvertNativeValueTo(jsObj_->Get()); + if (obj == nullptr) { + HILOG_ERROR("%{public}s Failed to get JsFileExtAbility object", __func__); + return; + } + HILOG_INFO("%{public}s end.", __func__); +} + +void JsFileExtAbility::OnStart(const AAFwk::Want &want) +{ + HILOG_INFO("%{public}s begin.", __func__); + Extension::OnStart(want); + HandleScope handleScope(jsRuntime_); + napi_env env = reinterpret_cast(&jsRuntime_.GetNativeEngine()); + napi_value napiWant = OHOS::AppExecFwk::WrapWant(env, want); + NativeValue* nativeWant = reinterpret_cast(napiWant); + NativeValue* argv[] = {nativeWant}; + CallObjectMethod("onCreate", argv, ARGC_ONE); + HILOG_INFO("%{public}s end.", __func__); +} + +sptr JsFileExtAbility::OnConnect(const AAFwk::Want &want) +{ + HILOG_INFO("%{public}s begin.", __func__); + Extension::OnConnect(want); + sptr remoteObject = new (std::nothrow) FileExtStubImpl( + std::static_pointer_cast(shared_from_this()), + reinterpret_cast(&jsRuntime_.GetNativeEngine())); + if (remoteObject == nullptr) { + HILOG_ERROR("%{public}s No memory allocated for FileExtStubImpl", __func__); + return nullptr; + } + HILOG_INFO("%{public}s end. ", __func__); + return remoteObject->AsObject(); +} + +NativeValue* JsFileExtAbility::CallObjectMethod(const char* name, NativeValue* const* argv, size_t argc) +{ + HILOG_INFO("%{public}s name = %{public}s, begin", __func__, name); + + if (!jsObj_) { + HILOG_WARN("%{public}s Not found FileExtAbility.js", __func__); + return nullptr; + } + + HandleScope handleScope(jsRuntime_); + auto& nativeEngine = jsRuntime_.GetNativeEngine(); + + NativeValue* value = jsObj_->Get(); + NativeObject* obj = ConvertNativeValueTo(value); + if (obj == nullptr) { + HILOG_ERROR("%{public}s Failed to get FileExtAbility object", __func__); + return nullptr; + } + + NativeValue* method = obj->GetProperty(name); + if (method == nullptr) { + HILOG_ERROR("%{public}s Failed to get '%{public}s' from FileExtAbility object", __func__, name); + return nullptr; + } + HILOG_INFO("%{public}s, name = %{public}s, success", __func__, name); + return handleScope.Escape(nativeEngine.CallFunction(value, method, argv, argc)); +} + +void JsFileExtAbility::GetSrcPath(std::string &srcPath) +{ + HILOG_INFO("%{public}s begin.", __func__); + if (!Extension::abilityInfo_->isStageBasedModel) { + /* temporary compatibility api8 + config.json */ + srcPath.append(Extension::abilityInfo_->package); + srcPath.append("/assets/js/"); + if (!Extension::abilityInfo_->srcPath.empty()) { + srcPath.append(Extension::abilityInfo_->srcPath); + } + srcPath.append("/").append(Extension::abilityInfo_->name).append(".abc"); + HILOG_INFO("%{public}s end1, srcPath:%{public}s", __func__, srcPath.c_str()); + return; + } + + if (!Extension::abilityInfo_->srcEntrance.empty()) { + srcPath.append(Extension::abilityInfo_->moduleName + "/"); + srcPath.append(Extension::abilityInfo_->srcEntrance); + srcPath.erase(srcPath.rfind('.')); + srcPath.append(".abc"); + } + HILOG_INFO("%{public}s end2, srcPath:%{public}s", __func__, srcPath.c_str()); +} + +int JsFileExtAbility::OpenFile(const Uri &uri, int flags) +{ + HILOG_INFO("%{public}s begin.", __func__); + HandleScope handleScope(jsRuntime_); + napi_env env = reinterpret_cast(&jsRuntime_.GetNativeEngine()); + + napi_value napiUri = nullptr; + napi_create_string_utf8(env, uri.ToString().c_str(), NAPI_AUTO_LENGTH, &napiUri); + napi_value napiFlags = nullptr; + napi_create_int32(env, flags, &napiFlags); + + NativeValue* nativeUri = reinterpret_cast(napiUri); + NativeValue* nativeFlags = reinterpret_cast(napiFlags); + NativeValue* argv[] = {nativeUri, nativeFlags}; + NativeValue* nativeResult = CallObjectMethod("openFile", argv, ARGC_TWO); + int ret = -1; + if (nativeResult == nullptr) { + HILOG_ERROR("%{public}s call openFile with return null.", __func__); + return ret; + } + ret = OHOS::AppExecFwk::UnwrapInt32FromJS(env, reinterpret_cast(nativeResult)); + HILOG_INFO("%{public}s end. return fd:%{public}d", __func__, ret); + return ret; +} + +int JsFileExtAbility::CreateFile(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + HandleScope handleScope(jsRuntime_); + napi_env env = reinterpret_cast(&jsRuntime_.GetNativeEngine()); + + napi_value napiParentUri = nullptr; + napi_create_string_utf8(env, parentUri.ToString().c_str(), NAPI_AUTO_LENGTH, &napiParentUri); + napi_value napiDisplayName = nullptr; + napi_create_string_utf8(env, displayName.c_str(), NAPI_AUTO_LENGTH, &napiDisplayName); + + NativeValue* nativeParentUri = reinterpret_cast(napiParentUri); + NativeValue* nativeDisplayName = reinterpret_cast(napiDisplayName); + NativeValue* argv[] = {nativeParentUri, nativeDisplayName}; + NativeValue* nativeResult = CallObjectMethod("createFile", argv, ARGC_TWO); + int ret = -1; + if (nativeResult == nullptr) { + HILOG_ERROR("%{public}s call createFile with return null.", __func__); + return ret; + } + std::string uriStr = OHOS::AppExecFwk::UnwrapStringFromJS(env, reinterpret_cast(nativeResult)); + if (uriStr.empty()) { + HILOG_ERROR("%{public}s call Mkdir with return empty.", __func__); + return ret; + } else { + ret = NO_ERROR; + } + newFileUri = Uri(uriStr); + HILOG_INFO("%{public}s end. return fd:%{public}d, newFileUri = %{public}s", __func__, ret, uriStr.c_str()); + return ret; +} + +int JsFileExtAbility::Mkdir(const Uri &parentUri, const std::string &displayName, Uri &newFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + HandleScope handleScope(jsRuntime_); + napi_env env = reinterpret_cast(&jsRuntime_.GetNativeEngine()); + + napi_value napiParentUri = nullptr; + napi_create_string_utf8(env, parentUri.ToString().c_str(), NAPI_AUTO_LENGTH, &napiParentUri); + napi_value napiDisplayName = nullptr; + napi_create_string_utf8(env, displayName.c_str(), NAPI_AUTO_LENGTH, &napiDisplayName); + + NativeValue* nativeParentUri = reinterpret_cast(napiParentUri); + NativeValue* nativeDisplayName = reinterpret_cast(napiDisplayName); + NativeValue* argv[] = {nativeParentUri, nativeDisplayName}; + NativeValue* nativeResult = CallObjectMethod("mkdir", argv, ARGC_TWO); + int ret = -1; + if (nativeResult == nullptr) { + HILOG_ERROR("%{public}s call Mkdir with return null.", __func__); + return ret; + } + std::string uriStr = OHOS::AppExecFwk::UnwrapStringFromJS(env, reinterpret_cast(nativeResult)); + if (uriStr.empty()) { + HILOG_ERROR("%{public}s call Mkdir with return empty.", __func__); + return ret; + } else { + ret = NO_ERROR; + } + newFileUri = Uri(uriStr); + HILOG_INFO("%{public}s end. return fd:%{public}d, newFileUri = %{public}s", __func__, ret, uriStr.c_str()); + return ret; +} + +int JsFileExtAbility::Delete(const Uri &sourceFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + HandleScope handleScope(jsRuntime_); + napi_env env = reinterpret_cast(&jsRuntime_.GetNativeEngine()); + + napi_value napiUri = nullptr; + napi_create_string_utf8(env, sourceFileUri.ToString().c_str(), NAPI_AUTO_LENGTH, &napiUri); + + NativeValue* nativeUri = reinterpret_cast(napiUri); + NativeValue* argv[] = {nativeUri}; + NativeValue* nativeResult = CallObjectMethod("delete", argv, ARGC_ONE); + int ret = -1; + if (nativeResult == nullptr) { + HILOG_ERROR("%{public}s call delete with return null.", __func__); + return ret; + } + ret = OHOS::AppExecFwk::UnwrapInt32FromJS(env, reinterpret_cast(nativeResult)); + HILOG_INFO("%{public}s end. return fd:%{public}d", __func__, ret); + return ret; +} + +int JsFileExtAbility::Move(const Uri &sourceFileUri, const Uri &targetParentUri, Uri &newFileUri) +{ + HandleScope handleScope(jsRuntime_); + napi_env env = reinterpret_cast(&jsRuntime_.GetNativeEngine()); + + napi_value napiSourceFileUri = nullptr; + napi_create_string_utf8(env, sourceFileUri.ToString().c_str(), NAPI_AUTO_LENGTH, &napiSourceFileUri); + napi_value napiTargetParentUri = nullptr; + napi_create_string_utf8(env, targetParentUri.ToString().c_str(), NAPI_AUTO_LENGTH, &napiTargetParentUri); + + NativeValue* nativeSourceFileUri = reinterpret_cast(napiSourceFileUri); + NativeValue* nativeTargetParentUri = reinterpret_cast(napiTargetParentUri); + NativeValue* argv[] = {nativeSourceFileUri, nativeTargetParentUri}; + NativeValue* nativeResult = CallObjectMethod("move", argv, ARGC_TWO); + int ret = -1; + if (nativeResult == nullptr) { + HILOG_ERROR("tag dsa %{public}s call move with return null.", __func__); + return ret; + } + std::string uriStr = OHOS::AppExecFwk::UnwrapStringFromJS(env, reinterpret_cast(nativeResult)); + if (uriStr.empty()) { + HILOG_ERROR("tag dsa %{public}s call move with return empty.", __func__); + return ret; + } else { + ret = NO_ERROR; + } + newFileUri = Uri(uriStr); + HILOG_INFO("tag dsa %{public}s end. return fd:%{public}d, newFileUri = %{public}s", __func__, ret, uriStr.c_str()); + return ret; +} + +int JsFileExtAbility::Rename(const Uri &sourceFileUri, const std::string &displayName, Uri &newFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + HandleScope handleScope(jsRuntime_); + napi_env env = reinterpret_cast(&jsRuntime_.GetNativeEngine()); + + napi_value napiSourceFileUri = nullptr; + napi_create_string_utf8(env, sourceFileUri.ToString().c_str(), NAPI_AUTO_LENGTH, &napiSourceFileUri); + napi_value napiDisplayName = nullptr; + napi_create_string_utf8(env, displayName.c_str(), NAPI_AUTO_LENGTH, &napiDisplayName); + + NativeValue* nativeSourceFileUri = reinterpret_cast(napiSourceFileUri); + NativeValue* nativeDisplayName = reinterpret_cast(napiDisplayName); + NativeValue* argv[] = {nativeSourceFileUri, nativeDisplayName}; + NativeValue* nativeResult = CallObjectMethod("rename", argv, ARGC_TWO); + int ret = -1; + if (nativeResult == nullptr) { + HILOG_ERROR("%{public}s call rename with return null.", __func__); + return ret; + } + std::string uriStr = OHOS::AppExecFwk::UnwrapStringFromJS(env, reinterpret_cast(nativeResult)); + if (uriStr.empty()) { + HILOG_ERROR("%{public}s call rename with return empty.", __func__); + return ret; + } else { + ret = NO_ERROR; + } + newFileUri = Uri(uriStr); + HILOG_INFO("%{public}s end. return fd:%{public}d, newFileUri = %{public}s", __func__, ret, uriStr.c_str()); + return ret; +} + +std::vector JsFileExtAbility::ListFile(const Uri &sourceFileUri) +{ + HILOG_INFO("%{public}s begin.", __func__); + HandleScope handleScope(jsRuntime_); + napi_env env = reinterpret_cast(&jsRuntime_.GetNativeEngine()); + + napi_value napiUri = nullptr; + std::vector vec; + napi_create_string_utf8(env, sourceFileUri.ToString().c_str(), NAPI_AUTO_LENGTH, &napiUri); + + NativeValue* nativeUri = reinterpret_cast(napiUri); + NativeValue* argv[] = {nativeUri}; + NativeValue* nativeResult = CallObjectMethod("listFile", argv, ARGC_ONE); + if (nativeResult == nullptr) { + HILOG_ERROR("%{public}s call listFile with return null.", __func__); + return vec; + } + if (UnwrapArrayFileInfoFromJS(env, reinterpret_cast(nativeResult), vec)) { + HILOG_INFO("%{public}s end vec.size:%{public}zu.", __func__, vec.size()); + return vec; + } else { + HILOG_ERROR("%{public}s end with faild.", __func__); + return vec; + } +} + +std::vector JsFileExtAbility::GetRoots() +{ + HILOG_INFO("%{public}s begin.", __func__); + HandleScope handleScope(jsRuntime_); + napi_env env = reinterpret_cast(&jsRuntime_.GetNativeEngine()); + + std::vector vec; + NativeValue* argv[] = {}; + NativeValue* nativeResult = CallObjectMethod("getRoots", argv, ARGC_ZERO); + if (nativeResult == nullptr) { + HILOG_ERROR("%{public}s call getRoots with return null.", __func__); + return vec; + } + if (UnwrapArrayDeviceInfoFromJS(env, reinterpret_cast(nativeResult), vec)) { + HILOG_INFO("%{public}s end vec.size:%{public}zu.", __func__, vec.size()); + return vec; + } else { + HILOG_ERROR("%{public}s end with faild.", __func__); + return vec; + } +} +} // namespace FileAccessFwk +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/innerkits/file_access/src/napi_common_fileaccess.cpp b/frameworks/innerkits/file_access/src/napi_common_fileaccess.cpp new file mode 100644 index 00000000..cdd1dffb --- /dev/null +++ b/frameworks/innerkits/file_access/src/napi_common_fileaccess.cpp @@ -0,0 +1,362 @@ +/* + * 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 "hilog_wrapper.h" +#include "napi_common_fileaccess.h" + +namespace OHOS { +namespace FileAccessFwk { +using namespace OHOS::AppExecFwk; +bool UnwrapInt64ByPropertyName(napi_env env, napi_value param, const char *propertyName, int64_t &value) +{ + napi_value jsValue = GetPropertyValueByPropertyName(env, param, propertyName, napi_number); + if (jsValue != nullptr) { + return UnwrapInt64FromJS2(env, jsValue, value); + } else { + return false; + } +} + +napi_value WrapUint32ToJS(napi_env env, uint32_t value) +{ + napi_value result = nullptr; + NAPI_CALL(env, napi_create_uint32(env, value, &result)); + return result; +} + +uint32_t UnwrapUint32FromJS(napi_env env, napi_value param, uint32_t defaultValue) +{ + uint32_t value = defaultValue; + if (napi_get_value_uint32(env, param, &value) == napi_ok) { + return value; + } else { + return defaultValue; + } +} + +bool UnwrapUint32FromJS2(napi_env env, napi_value param, uint32_t &value) +{ + HILOG_INFO("%{public}s,called begin", __func__); + bool result = false; + if (napi_get_value_uint32(env, param, &value) == napi_ok) { + result = true; + } + HILOG_INFO("%{public}s,called end, value: %{public}u", __func__, value); + return result; +} + +bool UnwrapUint32ByPropertyName(napi_env env, napi_value param, const char *propertyName, uint32_t &value) +{ + HILOG_INFO("%{public}s,called begin", __func__); + napi_value jsValue = GetPropertyValueByPropertyName(env, param, propertyName, napi_number); + if (jsValue != nullptr) { + HILOG_INFO("%{public}s,called end.", __func__); + return UnwrapUint32FromJS2(env, jsValue, value); + } else { + HILOG_INFO("%{public}s,called faild.", __func__); + return false; + } +} + +napi_value WrapBigIntUint64ToJS(napi_env env, uint64_t value) +{ + napi_value result = nullptr; + NAPI_CALL(env, napi_create_bigint_uint64(env, value, &result)); + return result; +} + +uint64_t UnwrapBigIntUint64FromJS(napi_env env, napi_value param, uint64_t defaultValue) +{ + HILOG_INFO("%{public}s,called begin", __func__); + bool lossless = true; + uint64_t value = defaultValue; + if (napi_get_value_bigint_uint64(env, param, &value, &lossless) == napi_ok) { + HILOG_INFO("%{public}s,called value: %{public}" PRIu64 ".", __func__, defaultValue); + return value; + } else { + HILOG_INFO("%{public}s,called end with faild.", __func__); + return defaultValue; + } +} + +bool UnwrapBigIntUint64FromJS2(napi_env env, napi_value param, uint64_t &defaultValue) +{ + HILOG_INFO("%{public}s,called begin", __func__); + bool lossless = true; + if (napi_get_value_bigint_uint64(env, param, &defaultValue, &lossless) == napi_ok) { + HILOG_INFO("%{public}s,called value: %{public}" PRIu64 ".", __func__, defaultValue); + return true; + } else { + HILOG_INFO("%{public}s,called end with faild.", __func__); + return false; + } +} + +bool UnwrapBigIntUint64ByPropertyName(napi_env env, napi_value param, const char *propertyName, uint64_t &value) +{ + HILOG_INFO("%{public}s,called begin", __func__); + napi_value jsValue = GetPropertyValueByPropertyName(env, param, propertyName, napi_bigint); + if (jsValue != nullptr) { + HILOG_INFO("%{public}s,called end.", __func__); + return UnwrapBigIntUint64FromJS2(env, jsValue, value); + } else { + HILOG_INFO("%{public}s,called faild.", __func__); + return false; + } +} + +napi_value WrapFileInfo(napi_env env, const FileInfo &fileInfo) +{ + HILOG_INFO("%{public}s,called begin", __func__); + HILOG_INFO("%{public}s,uri: %{public}s", __func__, fileInfo.uri.ToString().c_str()); + HILOG_INFO("%{public}s,fileName: %{public}s", __func__, fileInfo.fileName.c_str()); + HILOG_INFO("%{public}s,mode: %{public}s", __func__, fileInfo.mode.c_str()); + HILOG_INFO("%{public}s,size: %{public}" PRId64 "", __func__, fileInfo.size); + HILOG_INFO("%{public}s,mtime: %{public}" PRId64 "", __func__, fileInfo.mtime); + HILOG_INFO("%{public}s,mimiType: %{public}s", __func__, fileInfo.mimiType.c_str()); + napi_value jsObject = nullptr; + napi_value jsValue = nullptr; + + NAPI_CALL(env, napi_create_object(env, &jsObject)); + + jsValue = nullptr; + jsValue = OHOS::AppExecFwk::WrapStringToJS(env, fileInfo.uri.ToString()); + SetPropertyValueByPropertyName(env, jsObject, "uri", jsValue); + + jsValue = nullptr; + jsValue = OHOS::AppExecFwk::WrapStringToJS(env, fileInfo.fileName); + SetPropertyValueByPropertyName(env, jsObject, "fileName", jsValue); + + jsValue = nullptr; + jsValue = OHOS::AppExecFwk::WrapStringToJS(env, fileInfo.mode); + SetPropertyValueByPropertyName(env, jsObject, "mode", jsValue); + + jsValue = nullptr; + jsValue = OHOS::AppExecFwk::WrapInt64ToJS(env, fileInfo.size); + SetPropertyValueByPropertyName(env, jsObject, "size", jsValue); + + jsValue = nullptr; + jsValue = OHOS::AppExecFwk::WrapInt64ToJS(env, fileInfo.mtime); + SetPropertyValueByPropertyName(env, jsObject, "mtime", jsValue); + + jsValue = nullptr; + jsValue = OHOS::AppExecFwk::WrapStringToJS(env, fileInfo.mimiType); + SetPropertyValueByPropertyName(env, jsObject, "mimiType", jsValue); + + HILOG_INFO("%{public}s,called end", __func__); + return jsObject; +} + +bool UnwrapFileInfo(napi_env env, napi_value param, FileInfo &fileInfo) +{ + HILOG_INFO("%{public}s,called begin", __func__); + if (!IsTypeForNapiValue(env, param, napi_object)) { + HILOG_INFO("%{public}s called. Params is invalid.", __func__); + return false; + } + + std::string natValueString(""); + if (OHOS::AppExecFwk::UnwrapStringByPropertyName(env, param, "uri", natValueString)) { + fileInfo.uri = Uri(natValueString); + } + + natValueString = ""; + if (OHOS::AppExecFwk::UnwrapStringByPropertyName(env, param, "fileName", natValueString)) { + fileInfo.fileName = natValueString; + } + + natValueString = ""; + if (OHOS::AppExecFwk::UnwrapStringByPropertyName(env, param, "mode", natValueString)) { + fileInfo.mode = natValueString; + } + + int64_t natValueInt64 = 0; + if (UnwrapInt64ByPropertyName(env, param, "size", natValueInt64)) { + fileInfo.size = natValueInt64; + } + + natValueInt64 = 0; + if (UnwrapInt64ByPropertyName(env, param, "mtime", natValueInt64)) { + fileInfo.mtime = natValueInt64; + } + + natValueString = ""; + if (OHOS::AppExecFwk::UnwrapStringByPropertyName(env, param, "mimiType", natValueString)) { + fileInfo.mimiType = natValueString; + } + + HILOG_INFO("%{public}s,uri: %{public}s", __func__, fileInfo.uri.ToString().c_str()); + HILOG_INFO("%{public}s,fileName: %{public}s", __func__, fileInfo.fileName.c_str()); + HILOG_INFO("%{public}s,mode: %{public}s", __func__, fileInfo.mode.c_str()); + HILOG_INFO("%{public}s,size: %{public}" PRId64 "", __func__, fileInfo.size); + HILOG_INFO("%{public}s,mtime: %{public}" PRId64 "", __func__, fileInfo.mtime); + HILOG_INFO("%{public}s,mimiType: %{public}s", __func__, fileInfo.mimiType.c_str()); + HILOG_INFO("%{public}s,end", __func__); + return true; +} + +napi_value WrapArrayFileInfoToJS(napi_env env, const std::vector &fileInfoVec) +{ + napi_value jsArray = nullptr; + napi_value jsValue = nullptr; + uint32_t index = 0; + + NAPI_CALL(env, napi_create_array(env, &jsArray)); + for (uint32_t i = 0; i < fileInfoVec.size(); i++) { + jsValue = WrapFileInfo(env, fileInfoVec[i]); + if (napi_set_element(env, jsArray, index, jsValue) == napi_ok) { + index++; + } + } + return jsArray; +} + +bool UnwrapArrayFileInfoFromJS(napi_env env, napi_value param, std::vector &fileInfoVec) +{ + uint32_t arraySize = 0; + napi_value jsValue = nullptr; + + if (!IsArrayForNapiValue(env, param, arraySize)) { + return false; + } + + fileInfoVec.clear(); + for (uint32_t i = 0; i < arraySize; i++) { + jsValue = nullptr; + FileInfo fileInfo; + if (napi_get_element(env, param, i, &jsValue) != napi_ok) { + return false; + } + + if (!UnwrapFileInfo(env, jsValue, fileInfo)) { + return false; + } + + fileInfoVec.push_back(fileInfo); + } + return true; +} + +napi_value WrapDeviceInfo(napi_env env, const DeviceInfo &deviceInfo) +{ + HILOG_INFO("%{public}s,called begin", __func__); + HILOG_INFO("%{public}s,uri: %{public}s", __func__, deviceInfo.uri.ToString().c_str()); + HILOG_INFO("%{public}s,displayName: %{public}s", __func__, deviceInfo.displayName.c_str()); + HILOG_INFO("%{public}s,deviceId: %{public}s", __func__, deviceInfo.deviceId.c_str()); + HILOG_INFO("%{public}s,flags: %{public}u", __func__, deviceInfo.flags); + napi_value jsObject = nullptr; + napi_value jsValue = nullptr; + + NAPI_CALL(env, napi_create_object(env, &jsObject)); + + jsValue = nullptr; + jsValue = OHOS::AppExecFwk::WrapStringToJS(env, deviceInfo.uri.ToString()); + SetPropertyValueByPropertyName(env, jsObject, "uri", jsValue); + + jsValue = nullptr; + jsValue = OHOS::AppExecFwk::WrapStringToJS(env, deviceInfo.displayName); + SetPropertyValueByPropertyName(env, jsObject, "displayName", jsValue); + + jsValue = nullptr; + jsValue = OHOS::AppExecFwk::WrapStringToJS(env, deviceInfo.deviceId); + SetPropertyValueByPropertyName(env, jsObject, "deviceId", jsValue); + + jsValue = nullptr; + jsValue = WrapUint32ToJS(env, deviceInfo.flags); + SetPropertyValueByPropertyName(env, jsObject, "flags", jsValue); + + HILOG_INFO("%{public}s,called end", __func__); + return jsObject; +} + +bool UnwrapDeviceInfo(napi_env env, napi_value param, DeviceInfo &deviceInfo) +{ + HILOG_INFO("%{public}s,called begin", __func__); + if (!IsTypeForNapiValue(env, param, napi_object)) { + HILOG_INFO("%{public}s called. Params is invalid.", __func__); + return false; + } + + std::string natValueString(""); + if (OHOS::AppExecFwk::UnwrapStringByPropertyName(env, param, "uri", natValueString)) { + deviceInfo.uri = Uri(natValueString); + } + + natValueString = ""; + if (OHOS::AppExecFwk::UnwrapStringByPropertyName(env, param, "displayName", natValueString)) { + deviceInfo.displayName = natValueString; + } + + natValueString = ""; + if (OHOS::AppExecFwk::UnwrapStringByPropertyName(env, param, "deviceId", natValueString)) { + deviceInfo.deviceId = natValueString; + } + + uint32_t natValueUint32 = 0; + if (UnwrapUint32ByPropertyName(env, param, "flags", natValueUint32)) { + HILOG_INFO("%{public}s,flags: %{public}u", __func__, natValueUint32); + deviceInfo.flags = natValueUint32; + } + HILOG_INFO("%{public}s,uri: %{public}s", __func__, deviceInfo.uri.ToString().c_str()); + HILOG_INFO("%{public}s,displayName: %{public}s", __func__, deviceInfo.displayName.c_str()); + HILOG_INFO("%{public}s,deviceId: %{public}s", __func__, deviceInfo.deviceId.c_str()); + HILOG_INFO("%{public}s,flags: %{public}u", __func__, deviceInfo.flags); + HILOG_INFO("%{public}s,end", __func__); + return true; +} + +napi_value WrapArrayDeviceInfoToJS(napi_env env, const std::vector &deviceInfoVec) +{ + napi_value jsArray = nullptr; + napi_value jsValue = nullptr; + uint32_t index = 0; + + NAPI_CALL(env, napi_create_array(env, &jsArray)); + for (uint32_t i = 0; i < deviceInfoVec.size(); i++) { + jsValue = WrapDeviceInfo(env, deviceInfoVec[i]); + if (napi_set_element(env, jsArray, index, jsValue) == napi_ok) { + index++; + } + } + return jsArray; +} + +bool UnwrapArrayDeviceInfoFromJS(napi_env env, napi_value param, std::vector &deviceInfoVec) +{ + uint32_t arraySize = 0; + napi_value jsValue = nullptr; + + if (!IsArrayForNapiValue(env, param, arraySize)) { + return false; + } + + deviceInfoVec.clear(); + for (uint32_t i = 0; i < arraySize; i++) { + jsValue = nullptr; + DeviceInfo deviceInfo; + if (napi_get_element(env, param, i, &jsValue) != napi_ok) { + return false; + } + + if (!UnwrapDeviceInfo(env, jsValue, deviceInfo)) { + return false; + } + + deviceInfoVec.push_back(deviceInfo); + } + return true; +} +} // namespace FileAccessFwk +} // namespace OHOS diff --git a/utils/hilog_wrapper.h b/utils/hilog_wrapper.h new file mode 100644 index 00000000..6df10f62 --- /dev/null +++ b/utils/hilog_wrapper.h @@ -0,0 +1,81 @@ +/* + * 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 HILOG_WRAPPER_H +#define HILOG_WRAPPER_H + +#define CONFIG_HILOG +#ifdef CONFIG_HILOG +#include "hilog/log.h" + +#ifdef HILOG_FATAL +#undef HILOG_FATAL +#endif + +#ifdef HILOG_ERROR +#undef HILOG_ERROR +#endif + +#ifdef HILOG_WARN +#undef HILOG_WARN +#endif + +#ifdef HILOG_INFO +#undef HILOG_INFO +#endif + +#ifdef HILOG_DEBUG +#undef HILOG_DEBUG +#endif + +#ifndef FAF_LOG_DOMAIN +#define FAF_LOG_DOMAIN 0xD00430A +#endif + +#ifndef FAF_LOG_TAG +#define FAF_LOG_TAG "FileAccessFwk" +#endif + +#ifdef LOG_LABEL +#undef LOG_LABEL +#endif + +static constexpr OHOS::HiviewDFX::HiLogLabel LOG_LABEL = {LOG_CORE, FAF_LOG_DOMAIN, FAF_LOG_TAG}; + +#define HILOG_FATAL(fmt, ...) \ + (void)OHOS::HiviewDFX::HiLog::Fatal( \ + LOG_LABEL, "[(%{public}s:%{public}d)]" fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define HILOG_ERROR(fmt, ...) \ + (void)OHOS::HiviewDFX::HiLog::Error( \ + LOG_LABEL, "[(%{public}s:%{public}d)]" fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define HILOG_WARN(fmt, ...) \ + (void)OHOS::HiviewDFX::HiLog::Warn( \ + LOG_LABEL, "[(%{public}s:%{public}d)]" fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define HILOG_INFO(fmt, ...) \ + (void)OHOS::HiviewDFX::HiLog::Info( \ + LOG_LABEL, "[(%{public}s:%{public}d)]" fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define HILOG_DEBUG(fmt, ...) \ + (void)OHOS::HiviewDFX::HiLog::Debug( \ + LOG_LABEL, "[(%{public}s:%{public}d)]" fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__) +#else + +#define HILOG_FATAL(...) +#define HILOG_ERROR(...) +#define HILOG_WARN(...) +#define HILOG_INFO(...) +#define HILOG_DEBUG(...) +#endif // CONFIG_HILOG + +#endif // HILOG_WRAPPER_H \ No newline at end of file -- Gitee From 5f2d86727f43525fd38e645c8a8ff854b2c907bb Mon Sep 17 00:00:00 2001 From: wangjianqiang Date: Wed, 22 Jun 2022 11:07:15 +0800 Subject: [PATCH 2/4] add napi and hap Signed-off-by: wangjianqiang --- bundle.json | 5 +- .../napi/common/file_extension_info_napi.cpp | 127 ++ .../napi/common/file_extension_info_napi.h | 27 + .../kits/napi/file_access_module/BUILD.gn | 50 + .../file_access_module/file_access_common.h | 112 ++ .../napi_fileaccess_helper.cpp | 1665 +++++++++++++++++ .../napi_fileaccess_helper.h | 114 ++ .../native_fileaccess_module.cpp | 65 + .../kits/napi/file_ext_ability/BUILD.gn | 50 + .../napi/file_ext_ability/file_ext_ability.js | 62 + .../file_ext_ability_module.cpp | 57 + .../napi/file_extension_info_module/BUILD.gn | 42 + .../module_export_napi.cpp | 37 + .../module_export_napi.h | 22 + services/BUILD.gn | 37 + services/file_extension_hap/AppScope/app.json | 11 + .../resources/base/element/string.json | 8 + .../resources/base/media/app_icon.png | Bin 0 -> 6790 bytes .../file_extension_hap/build-profile.json5 | 40 + .../entry/build-profile.json5 | 24 + .../file_extension_hap/entry/hvigorfile.js | 2 + .../src/main/ets/Application/AbilityStage.ts | 20 + .../FileExtensionAbility.ts | 271 +++ .../ets/FileExtensionAbility/Subcriber.ts | 32 + .../ets/FileExtensionAbility/VolumeManager.ts | 74 + .../entry/src/main/module.json | 25 + .../main/resources/base/element/string.json | 12 + .../src/main/resources/base/media/icon.png | Bin 0 -> 6790 bytes .../resources/base/profile/main_pages.json | 3 + services/file_extension_hap/hvigorfile.js | 2 + services/signature/fileextension.p7b | Bin 0 -> 3466 bytes 31 files changed, 2995 insertions(+), 1 deletion(-) create mode 100644 interfaces/kits/napi/common/file_extension_info_napi.cpp create mode 100644 interfaces/kits/napi/common/file_extension_info_napi.h create mode 100644 interfaces/kits/napi/file_access_module/BUILD.gn create mode 100644 interfaces/kits/napi/file_access_module/file_access_common.h create mode 100644 interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp create mode 100644 interfaces/kits/napi/file_access_module/napi_fileaccess_helper.h create mode 100644 interfaces/kits/napi/file_access_module/native_fileaccess_module.cpp create mode 100644 interfaces/kits/napi/file_ext_ability/BUILD.gn create mode 100644 interfaces/kits/napi/file_ext_ability/file_ext_ability.js create mode 100644 interfaces/kits/napi/file_ext_ability/file_ext_ability_module.cpp create mode 100644 interfaces/kits/napi/file_extension_info_module/BUILD.gn create mode 100644 interfaces/kits/napi/file_extension_info_module/module_export_napi.cpp create mode 100644 interfaces/kits/napi/file_extension_info_module/module_export_napi.h create mode 100644 services/file_extension_hap/AppScope/app.json create mode 100644 services/file_extension_hap/AppScope/resources/base/element/string.json create mode 100644 services/file_extension_hap/AppScope/resources/base/media/app_icon.png create mode 100644 services/file_extension_hap/build-profile.json5 create mode 100644 services/file_extension_hap/entry/build-profile.json5 create mode 100644 services/file_extension_hap/entry/hvigorfile.js create mode 100644 services/file_extension_hap/entry/src/main/ets/Application/AbilityStage.ts create mode 100644 services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/FileExtensionAbility.ts create mode 100644 services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/Subcriber.ts create mode 100644 services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/VolumeManager.ts create mode 100644 services/file_extension_hap/entry/src/main/module.json create mode 100644 services/file_extension_hap/entry/src/main/resources/base/element/string.json create mode 100644 services/file_extension_hap/entry/src/main/resources/base/media/icon.png create mode 100644 services/file_extension_hap/entry/src/main/resources/base/profile/main_pages.json create mode 100644 services/file_extension_hap/hvigorfile.js create mode 100644 services/signature/fileextension.p7b diff --git a/bundle.json b/bundle.json index b73e9a8b..e16b5324 100644 --- a/bundle.json +++ b/bundle.json @@ -37,7 +37,10 @@ "//foundation/filemanagement/user_file_service/services:fms", "//foundation/filemanagement/user_file_service/services/sa_profile:filemanager_service_sa_profile", "//foundation/filemanagement/user_file_service/interfaces/kits/js:filemanager", - "//foundation/filemanagement/user_file_service/frameworks/innerkits:frameworks_innerkits" + "//foundation/filemanagement/user_file_service/frameworks/innerkits:frameworks_innerkits", + "//foundation/filemanagement/user_file_service/interfaces/kits/napi/file_access_module:fileaccess", + "//foundation/filemanagement/user_file_service/interfaces/kits/napi/file_ext_ability:fileextensionability_napi", + "//foundation/filemanagement/user_file_service/interfaces/kits/napi/file_extension_info_module:fileextensioninfo" ], "test": [ "//foundation/filemanagement/user_file_service/services/test:user_file_manager_test" diff --git a/interfaces/kits/napi/common/file_extension_info_napi.cpp b/interfaces/kits/napi/common/file_extension_info_napi.cpp new file mode 100644 index 00000000..e693b54f --- /dev/null +++ b/interfaces/kits/napi/common/file_extension_info_napi.cpp @@ -0,0 +1,127 @@ +/* + * 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. + */ +#include "file_extension_info_napi.h" + +#include + +#include "file_extension_info.h" + +namespace OHOS { +namespace FileAccessFwk { +napi_value CreateStringUtf8(napi_env env, const std::string &str) +{ + napi_value value = nullptr; + if (napi_create_string_utf8(env, str.c_str(), str.length(), &value) != napi_ok) { + return nullptr; + } + return value; +} + +napi_value CreateUint32(napi_env env, uint32_t val) +{ + napi_value value = nullptr; + if (napi_create_uint32(env, val, &value) != napi_ok) { + return nullptr; + } + return value; +} + +napi_value FileInfoConstructor(napi_env env, napi_callback_info info) +{ + size_t argc = 0; + napi_value args[1] = {0}; + napi_value res = nullptr; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &res, &data); + if (status != napi_ok) { + return nullptr; + } + + return res; +} + +napi_value DeviceInfoConstructor(napi_env env, napi_callback_info info) +{ + size_t argc = 0; + napi_value args[1] = {0}; + napi_value res = nullptr; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &res, &data); + if (status != napi_ok) { + return nullptr; + } + + return res; +} + +void InitFlag(napi_env env, napi_value exports) +{ + char propertyName[] = "FLAG"; + napi_property_descriptor desc[] = { + DECLARE_NAPI_STATIC_PROPERTY("SUPPORTS_THUMBNAIL", + CreateUint32(env, FLAG_SUPPORTS_THUMBNAIL)), + DECLARE_NAPI_STATIC_PROPERTY("SUPPORTS_WRITE", + CreateUint32(env, FLAG_SUPPORTS_WRITE)), + DECLARE_NAPI_STATIC_PROPERTY("SUPPORTS_READ", + CreateUint32(env, FLAG_SUPPORTS_READ)), + DECLARE_NAPI_STATIC_PROPERTY("SUPPORTS_DELETE", + CreateUint32(env, FLAG_SUPPORTS_DELETE)), + DECLARE_NAPI_STATIC_PROPERTY("SUPPORTS_RENAME", + CreateUint32(env, FLAG_SUPPORTS_RENAME)), + DECLARE_NAPI_STATIC_PROPERTY("SUPPORTS_MOVE", + CreateUint32(env, FLAG_SUPPORTS_MOVE)) + }; + napi_value obj = nullptr; + napi_create_object(env, &obj); + napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc); + napi_set_named_property(env, exports, propertyName, obj); +} + +void InitFileInfo(napi_env env, napi_value exports) +{ + char className[] = "FileInfo"; + napi_property_descriptor desc[] = { + { "uri", nullptr, nullptr, nullptr, nullptr, CreateStringUtf8(env, "uri"), napi_writable, nullptr }, + { "fileName", nullptr, nullptr, nullptr, nullptr, CreateStringUtf8(env, "fileName"), napi_writable, nullptr }, + { "mode", nullptr, nullptr, nullptr, nullptr, CreateStringUtf8(env, "mode"), napi_writable, nullptr }, + { "size", nullptr, nullptr, nullptr, nullptr, CreateStringUtf8(env, "size"), napi_writable, nullptr }, + { "mtime", nullptr, nullptr, nullptr, nullptr, CreateStringUtf8(env, "mtime"), napi_writable, nullptr }, + { "mimiType", nullptr, nullptr, nullptr, nullptr, CreateStringUtf8(env, "mimiType"), napi_writable, nullptr } + }; + napi_value obj = nullptr; + napi_define_class(env, className, NAPI_AUTO_LENGTH, FileInfoConstructor, nullptr, + sizeof(desc) / sizeof(*desc), desc, &obj); + napi_set_named_property(env, exports, className, obj); +} + +void InitDeviceInfo(napi_env env, napi_value exports) +{ + char className[] = "DeviceInfo"; + napi_property_descriptor desc[] = { + { "uri", nullptr, nullptr, nullptr, nullptr, CreateStringUtf8(env, "uri"), napi_writable, nullptr }, + { "displayName", nullptr, nullptr, nullptr, nullptr, + CreateStringUtf8(env, "displayName"), napi_writable, nullptr }, + { "deviceId", nullptr, nullptr, nullptr, nullptr, CreateStringUtf8(env, "deviceId"), napi_writable, nullptr }, + { "flags", nullptr, nullptr, nullptr, nullptr, CreateStringUtf8(env, "flags"), napi_writable, nullptr } + }; + napi_value obj = nullptr; + napi_define_class(env, className, NAPI_AUTO_LENGTH, DeviceInfoConstructor, nullptr, + sizeof(desc) / sizeof(*desc), desc, &obj); + napi_set_named_property(env, exports, className, obj); +} +} // namespace FileAccessFwk +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/kits/napi/common/file_extension_info_napi.h b/interfaces/kits/napi/common/file_extension_info_napi.h new file mode 100644 index 00000000..3b974f68 --- /dev/null +++ b/interfaces/kits/napi/common/file_extension_info_napi.h @@ -0,0 +1,27 @@ +/* + * 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 FILE_EXTENSION_INFO_NAPI_H +#define FILE_EXTENSION_INFO_NAPI_H +#include "napi/native_api.h" +#include "napi/native_node_api.h" +namespace OHOS { +namespace FileAccessFwk { +void InitFlag(napi_env env, napi_value exports); +void InitFileInfo(napi_env env, napi_value exports); +void InitDeviceInfo(napi_env env, napi_value exports); +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_EXTENSION_INFO_NAPI_H \ No newline at end of file diff --git a/interfaces/kits/napi/file_access_module/BUILD.gn b/interfaces/kits/napi/file_access_module/BUILD.gn new file mode 100644 index 00000000..0bada650 --- /dev/null +++ b/interfaces/kits/napi/file_access_module/BUILD.gn @@ -0,0 +1,50 @@ +# 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") +BASE_DIR = "//foundation/filemanagement/user_file_service" + +ohos_shared_library("fileaccess") { + subsystem_name = "filemanagement" + part_name = "user_file_service" + + relative_install_dir = "module/data" + + include_dirs = [ + "./", + "${BASE_DIR}/utils", + "${BASE_DIR}/interfaces/kits/napi/common", + ] + + sources = [ + "napi_fileaccess_helper.cpp", + "native_fileaccess_module.cpp", + "${BASE_DIR}/interfaces/kits/napi/common/file_extension_info_napi.cpp", + ] + + deps = [ + "${BASE_DIR}/frameworks/innerkits/file_access:file_extension_ability_kit", + "//foundation/ability/ability_runtime/frameworks/js/napi/aafwk/inner/napi_common:napi_common", + ] + + external_deps = [ + "ability_base:base", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:abilitykit_native", + "ability_runtime:napi_base_context", + "hiviewdfx_hilog_native:libhilog", + "napi:ace_napi", + "utils_base:utils", + ] +} \ No newline at end of file diff --git a/interfaces/kits/napi/file_access_module/file_access_common.h b/interfaces/kits/napi/file_access_module/file_access_common.h new file mode 100644 index 00000000..4bc188b4 --- /dev/null +++ b/interfaces/kits/napi/file_access_module/file_access_common.h @@ -0,0 +1,112 @@ +/* + * 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 FILE_ACCESS_COMMON_H +#define FILE_ACCESS_COMMON_H + +#include "ability.h" +#include "file_access_helper.h" +#include "napi/native_api.h" +#include "napi/native_common.h" +#include "napi/native_node_api.h" +#include "napi_common.h" +#include "napi_common_util.h" + +namespace OHOS { +namespace FileAccessFwk { +struct CBBase { + AppExecFwk::CallbackInfo cbInfo; + napi_async_work asyncWork; + napi_deferred deferred; + Ability *ability = nullptr; + AppExecFwk::AbilityType abilityType = AppExecFwk::AbilityType::UNKNOWN; + int errCode = ERR_OK; +}; + +struct FileAccessHelperCB { + CBBase cbBase; + napi_ref uri = nullptr; + napi_value result = nullptr; +}; + +struct FileAccessHelperOpenFileCB { + CBBase cbBase; + FileAccessHelper *fileAccessHelper = nullptr; + std::string uri; + int flags; + int result = ERR_OK; + int execResult; +}; + +struct FileAccessHelperCreateFileCB { + CBBase cbBase; + FileAccessHelper *fileAccessHelper = nullptr; + std::string parentUri; + std::string name; + std::string result; + int execResult; +}; + +struct FileAccessHelperMkdirCB { + CBBase cbBase; + FileAccessHelper *fileAccessHelper = nullptr; + std::string parentUri; + std::string name; + std::string result; + int execResult; +}; + +struct FileAccessHelperDeleteCB { + CBBase cbBase; + FileAccessHelper *fileAccessHelper = nullptr; + std::string selectFileUri; + int result = ERR_OK; + int execResult; +}; + +struct FileAccessHelperMoveCB { + CBBase cbBase; + FileAccessHelper *fileAccessHelper = nullptr; + std::string sourceFileUri; + std::string targetParentUri; + std::string result; + int execResult; +}; + +struct FileAccessHelperRenameCB { + CBBase cbBase; + FileAccessHelper *fileAccessHelper = nullptr; + std::string sourceFileUri; + std::string displayName; + std::string result; + int execResult; +}; + +struct FileAccessHelperListFileCB { + CBBase cbBase; + FileAccessHelper *fileAccessHelper = nullptr; + std::string sourceFileUri; + std::vector result; + int execResult; +}; + +struct FileAccessHelperGetRootsCB { + CBBase cbBase; + FileAccessHelper *fileAccessHelper = nullptr; + std::vector result; + int execResult; +}; +} +} +#endif \ No newline at end of file diff --git a/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp b/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp new file mode 100644 index 00000000..190b386b --- /dev/null +++ b/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp @@ -0,0 +1,1665 @@ +/* + * 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 "napi_fileaccess_helper.h" + +#include +#include + +#include "uri.h" + +#include "hilog_wrapper.h" +#include "napi_base_context.h" +#include "securec.h" +#include "napi_common_fileaccess.h" + +using namespace OHOS::AAFwk; +using namespace OHOS::AppExecFwk; + +namespace OHOS { +namespace FileAccessFwk { +namespace { +const std::string FILEACCESS_CLASS_NAME = "FileAccessHelper"; + +std::string NapiValueToStringUtf8(napi_env env, napi_value value) +{ + HILOG_INFO("%{public}s,called", __func__); + std::string result = ""; + return UnwrapStringFromJS(env, value, result); +} + +int NapiValueToInt32Utf8(napi_env env, napi_value value) +{ + HILOG_INFO("%{public}s,called", __func__); + int result = 0; + return UnwrapInt32FromJS(env, value, result); +} +} + +std::list> g_fileAccessHelperList; +static napi_ref g_constructorRef = nullptr; + +napi_value AcquireFileAccessHelperWrap(napi_env env, napi_callback_info info, FileAccessHelperCB *fileAccessHelperCB) +{ + HILOG_INFO("%{public}s,called", __func__); + if (fileAccessHelperCB == nullptr) { + HILOG_ERROR("%{public}s,fileAccessHelperCB == nullptr", __func__); + return nullptr; + } + + size_t requireArgc = ARGS_THREE; + size_t argc = ARGS_THREE; + napi_value args[ARGS_THREE] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr)); + if (argc > requireArgc) { + HILOG_ERROR("%{public}s, Wrong argument count%{public}zu.", __func__, argc); + return nullptr; + } + + napi_value result = nullptr; + napi_value cons = nullptr; + if (napi_get_reference_value(env, g_constructorRef, &cons) != napi_ok) { + return nullptr; + } + NAPI_CALL(env, napi_new_instance(env, cons, ARGS_THREE, args, &result)); + + if (!IsTypeForNapiValue(env, result, napi_object)) { + HILOG_ERROR("%{public}s, IsTypeForNapiValue isn`t object", __func__); + return nullptr; + } + + if (IsTypeForNapiValue(env, result, napi_null)) { + HILOG_ERROR("%{public}s, IsTypeForNapiValue is null", __func__); + return nullptr; + } + + if (IsTypeForNapiValue(env, result, napi_undefined)) { + HILOG_ERROR("%{public}s, IsTypeForNapiValue is undefined", __func__); + return nullptr; + } + + delete fileAccessHelperCB; + fileAccessHelperCB = nullptr; + HILOG_INFO("%{public}s,end", __func__); + return result; +} + +napi_value NAPI_AcquireFileAccessHelperCommon(napi_env env, napi_callback_info info, AbilityType abilityType) +{ + HILOG_INFO("%{public}s,called", __func__); + FileAccessHelperCB *fileAccessHelperCB = new (std::nothrow) FileAccessHelperCB; + if (fileAccessHelperCB == nullptr) { + HILOG_ERROR("%{public}s, FileAccessHelperCB == nullptr", __func__); + return WrapVoidToJS(env); + } + + fileAccessHelperCB->cbBase.cbInfo.env = env; + fileAccessHelperCB->cbBase.errCode = NAPI_ERR_NO_ERROR; + fileAccessHelperCB->cbBase.abilityType = abilityType; + napi_value ret = AcquireFileAccessHelperWrap(env, info, fileAccessHelperCB); + if (ret == nullptr) { + HILOG_ERROR("%{public}s, ret == nullptr", __func__); + if (fileAccessHelperCB != nullptr) { + delete fileAccessHelperCB; + fileAccessHelperCB = nullptr; + } + ret = WrapVoidToJS(env); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value NAPI_CreateFileAccessHelper(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, called", __func__); + return NAPI_AcquireFileAccessHelperCommon(env, info, AbilityType::EXTENSION); +} + +napi_value FileAccessHelperInit(napi_env env, napi_value exports) +{ + HILOG_INFO("%{public}s,called start ", __func__); + napi_property_descriptor properties[] = { + DECLARE_NAPI_FUNCTION("openFile", NAPI_OpenFile), + DECLARE_NAPI_FUNCTION("mkdir", NAPI_Mkdir), + DECLARE_NAPI_FUNCTION("createFile", NAPI_CreateFile), + DECLARE_NAPI_FUNCTION("delete", NAPI_Delete), + DECLARE_NAPI_FUNCTION("move", NAPI_Move), + DECLARE_NAPI_FUNCTION("rename", NAPI_Rename), + DECLARE_NAPI_FUNCTION("listFile", NAPI_ListFile), + DECLARE_NAPI_FUNCTION("getRoots", NAPI_GetRoots), + }; + napi_value cons = nullptr; + NAPI_CALL(env, + napi_define_class(env, + FILEACCESS_CLASS_NAME.c_str(), + NAPI_AUTO_LENGTH, + FileAccessHelperConstructor, + nullptr, + sizeof(properties) / sizeof(*properties), + properties, + &cons)); + g_fileAccessHelperList.clear(); + NAPI_CALL(env, napi_create_reference(env, cons, 1, &g_constructorRef)); + NAPI_CALL(env, napi_set_named_property(env, exports, FILEACCESS_CLASS_NAME.c_str(), cons)); + + napi_property_descriptor export_properties[] = { + DECLARE_NAPI_FUNCTION("createFileAccessHelper", NAPI_CreateFileAccessHelper), + }; + NAPI_CALL(env, napi_define_properties(env, exports, sizeof(export_properties) / sizeof(export_properties[0]), + export_properties)); + return exports; +} + +napi_value FileAccessHelperConstructor(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, called start", __func__); + size_t argc = ARGS_TWO; + napi_value argv[ARGS_TWO] = {nullptr}; + napi_value thisVar = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr)); + NAPI_ASSERT(env, argc > 0, "Wrong number of arguments"); + AAFwk::Want want; + OHOS::AppExecFwk::UnwrapWant(env, argv[PARAM1], want); + std::shared_ptr fileAccessHelper = nullptr; + bool isStageMode = false; + napi_status status = AbilityRuntime::IsStageContext(env, argv[PARAM0], isStageMode); + if (status != napi_ok || !isStageMode) { + HILOG_INFO(" FA Model"); + return nullptr; + } else { + auto context = OHOS::AbilityRuntime::GetStageModeContext(env, argv[PARAM0]); + NAPI_ASSERT(env, context != nullptr, " FileAccessHelperConstructor: failed to get native context"); + HILOG_INFO(" Stage Model"); + fileAccessHelper = FileAccessHelper::Creator(context, want); + HILOG_INFO(" fileAccessHelper = %{public}p.", fileAccessHelper.get()); + } + NAPI_ASSERT(env, fileAccessHelper != nullptr, " FileAccessHelperConstructor: fileAccessHelper is nullptr"); + g_fileAccessHelperList.emplace_back(fileAccessHelper); + + napi_wrap(env, thisVar, fileAccessHelper.get(), [](napi_env env, void *data, void *hint) { + FileAccessHelper *objectInfo = static_cast(data); + g_fileAccessHelperList.remove_if([objectInfo](const std::shared_ptr &fileAccessHelper) { + return objectInfo == fileAccessHelper.get(); + }); + }, nullptr, nullptr); + HILOG_INFO("%{public}s,called end", __func__); + return thisVar; +} + +napi_value NAPI_OpenFile(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s,called start", __func__); + FileAccessHelperOpenFileCB *openFileCB = new (std::nothrow) FileAccessHelperOpenFileCB; + if (openFileCB == nullptr) { + HILOG_ERROR("%{public}s, openFileCB == nullptr.", __func__); + return WrapVoidToJS(env); + } + openFileCB->cbBase.cbInfo.env = env; + openFileCB->cbBase.asyncWork = nullptr; + openFileCB->cbBase.deferred = nullptr; + openFileCB->cbBase.ability = nullptr; + + napi_value ret = OpenFileWrap(env, info, openFileCB); + if (ret == nullptr) { + HILOG_ERROR("%{public}s,ret == nullptr", __func__); + if (openFileCB != nullptr) { + delete openFileCB; + openFileCB = nullptr; + } + ret = WrapVoidToJS(env); + } + HILOG_INFO("%{public}s,called end", __func__); + return ret; +} + +napi_value OpenFileWrap(napi_env env, napi_callback_info info, FileAccessHelperOpenFileCB *openFileCB) +{ + HILOG_INFO("%{public}s,called start", __func__); + size_t argcAsync = ARGS_THREE; + const size_t argcPromise = ARGS_TWO; + const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT; + napi_value args[ARGS_MAX_COUNT] = {nullptr}; + napi_value ret = 0; + napi_value thisVar = nullptr; + + NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); + if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { + HILOG_ERROR("%{public}s, Wrong argument count.", __func__); + return nullptr; + } + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valuetype)); + if (valuetype == napi_string) { + openFileCB->uri = NapiValueToStringUtf8(env, args[PARAM0]); + HILOG_INFO("%{public}s,uri= %{public}s", __func__, openFileCB->uri.c_str()); + } + + NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valuetype)); + if (valuetype == napi_number) { + openFileCB->flags = NapiValueToInt32Utf8(env, args[PARAM1]); + HILOG_INFO("%{public}s,flags=%d", __func__, openFileCB->flags); + } + + FileAccessHelper *objectInfo = nullptr; + napi_unwrap(env, thisVar, (void **)&objectInfo); + HILOG_INFO("%{public}s,FileAccessHelper objectInfo", __func__); + openFileCB->fileAccessHelper = objectInfo; + + if (argcAsync > argcPromise) { + ret = OpenFileAsync(env, args, ARGS_TWO, openFileCB); + } else { + ret = OpenFilePromise(env, openFileCB); + } + HILOG_INFO("%{public}s,called end", __func__); + return ret; +} + +napi_value OpenFileAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperOpenFileCB *openFileCB) +{ + HILOG_INFO("%{public}s, asyncCallback start.", __func__); + if (args == nullptr || openFileCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName = 0; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype)); + if (valuetype == napi_function) { + NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &openFileCB->cbBase.cbInfo.callback)); + } + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + OpenFileExecuteCB, + OpenFileAsyncCompleteCB, + (void *)openFileCB, + &openFileCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, openFileCB->cbBase.asyncWork)); + napi_value result = 0; + NAPI_CALL(env, napi_get_null(env, &result)); + HILOG_INFO("%{public}s, asyncCallback end.", __func__); + return result; +} + +napi_value OpenFilePromise(napi_env env, FileAccessHelperOpenFileCB *openFileCB) +{ + HILOG_INFO("%{public}s, promise start.", __func__); + if (openFileCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + napi_deferred deferred; + napi_value promise = 0; + NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); + openFileCB->cbBase.deferred = deferred; + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + OpenFileExecuteCB, + OpenFilePromiseCompleteCB, + (void *)openFileCB, + &openFileCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, openFileCB->cbBase.asyncWork)); + HILOG_INFO("%{public}s, promise end.", __func__); + return promise; +} + +void OpenFileExecuteCB(napi_env env, void *data) +{ + HILOG_INFO(" NAPI_OpenFile, worker pool thread execute start."); + FileAccessHelperOpenFileCB *openFileCB = static_cast(data); + if (openFileCB->fileAccessHelper != nullptr) { + openFileCB->execResult = -1; + if (!openFileCB->uri.empty()) { + OHOS::Uri uri(openFileCB->uri); + openFileCB->result = openFileCB->fileAccessHelper->OpenFile(uri, openFileCB->flags); + openFileCB->execResult = ERR_OK; + } else { + HILOG_ERROR(" NAPI_OpenFile, fileAccessHelper uri is empty"); + } + } else { + HILOG_ERROR(" NAPI_OpenFile, fileAccessHelper == nullptr"); + } + HILOG_INFO(" NAPI_OpenFile, worker pool thread execute end."); +} + +void OpenFileAsyncCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO("NAPI_OpenFile, %{public}s start.", __func__); + FileAccessHelperOpenFileCB *openFileCB = static_cast(data); + napi_value callback = nullptr; + napi_value undefined = nullptr; + napi_value result[ARGS_TWO] = {nullptr}; + napi_value callResult = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined)); + NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, openFileCB->cbBase.cbInfo.callback, &callback)); + + result[PARAM0] = GetCallbackErrorValue(env, openFileCB->execResult); + napi_create_int32(env, openFileCB->result, &result[PARAM1]); + NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult)); + + if (openFileCB->cbBase.cbInfo.callback != nullptr) { + NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, openFileCB->cbBase.cbInfo.callback)); + } + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, openFileCB->cbBase.asyncWork)); + delete openFileCB; + openFileCB = nullptr; + HILOG_INFO("NAPI_OpenFile, %{public}s end.", __func__); +} + +void OpenFilePromiseCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO("NAPI_OpenFile, %{public}s start.", __func__); + FileAccessHelperOpenFileCB *openFileCB = static_cast(data); + napi_value result = nullptr; + napi_create_int32(env, openFileCB->result, &result); + NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, openFileCB->cbBase.deferred, result)); + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, openFileCB->cbBase.asyncWork)); + delete openFileCB; + openFileCB = nullptr; + HILOG_INFO("NAPI_OpenFile, %{public}s end.", __func__); +} + +napi_value NAPI_CreateFile(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s,called", __func__); + FileAccessHelperCreateFileCB *createFileCB = new (std::nothrow) FileAccessHelperCreateFileCB; + if (createFileCB == nullptr) { + HILOG_ERROR("%{public}s, createFileCB == nullptr.", __func__); + return WrapVoidToJS(env); + } + createFileCB->cbBase.cbInfo.env = env; + createFileCB->cbBase.asyncWork = nullptr; + createFileCB->cbBase.deferred = nullptr; + createFileCB->cbBase.ability = nullptr; + + napi_value ret = CreateFileWrap(env, info, createFileCB); + if (ret == nullptr) { + HILOG_ERROR("%{public}s,ret == nullptr", __func__); + if (createFileCB != nullptr) { + delete createFileCB; + createFileCB = nullptr; + } + ret = WrapVoidToJS(env); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value CreateFileWrap(napi_env env, napi_callback_info info, FileAccessHelperCreateFileCB *createFileCB) +{ + HILOG_INFO("%{public}s,called", __func__); + size_t argcAsync = ARGS_THREE; + const size_t argcPromise = ARGS_TWO; + const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT; + napi_value args[ARGS_MAX_COUNT] = {nullptr}; + napi_value ret = 0; + napi_value thisVar = nullptr; + + NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); + if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { + HILOG_ERROR("%{public}s, Wrong argument count.", __func__); + return nullptr; + } + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valuetype)); + if (valuetype == napi_string) { + createFileCB->parentUri = NapiValueToStringUtf8(env, args[PARAM0]); + HILOG_INFO("%{public}s,parentUri=%{public}s", __func__, createFileCB->parentUri.c_str()); + } + + NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valuetype)); + if (valuetype == napi_string) { + createFileCB->name = NapiValueToStringUtf8(env, args[PARAM1]); + HILOG_INFO("%{public}s,name=%{public}s", __func__, createFileCB->name.c_str()); + } + + FileAccessHelper *objectInfo = nullptr; + napi_unwrap(env, thisVar, (void **)&objectInfo); + HILOG_INFO("%{public}s,FileAccessHelper objectInfo", __func__); + createFileCB->fileAccessHelper = objectInfo; + + if (argcAsync > argcPromise) { + ret = CreateFileAsync(env, args, ARGS_TWO, createFileCB); + } else { + ret = CreateFilePromise(env, createFileCB); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value CreateFileAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperCreateFileCB *createFileCB) +{ + HILOG_INFO("%{public}s, asyncCallback.", __func__); + if (args == nullptr || createFileCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName = 0; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype)); + if (valuetype == napi_function) { + NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &createFileCB->cbBase.cbInfo.callback)); + } + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + CreateFileExecuteCB, + CreateFileAsyncCompleteCB, + (void *)createFileCB, + &createFileCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, createFileCB->cbBase.asyncWork)); + napi_value result = 0; + NAPI_CALL(env, napi_get_null(env, &result)); + HILOG_INFO("%{public}s, asyncCallback end.", __func__); + return result; +} + +napi_value CreateFilePromise(napi_env env, FileAccessHelperCreateFileCB *createFileCB) +{ + HILOG_INFO("%{public}s, promise.", __func__); + if (createFileCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + napi_deferred deferred; + napi_value promise = 0; + NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); + createFileCB->cbBase.deferred = deferred; + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + CreateFileExecuteCB, + CreateFilePromiseCompleteCB, + (void *)createFileCB, + &createFileCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, createFileCB->cbBase.asyncWork)); + HILOG_INFO("%{public}s, promise end.", __func__); + return promise; +} + +void CreateFileExecuteCB(napi_env env, void *data) +{ + HILOG_INFO(" NAPI_CreateFile, worker pool thread execute."); + FileAccessHelperCreateFileCB *createFileCB = static_cast(data); + if (createFileCB->fileAccessHelper != nullptr) { + createFileCB->execResult = -1; + if (!createFileCB->parentUri.empty()) { + OHOS::Uri parentUri(createFileCB->parentUri); + std::string newFile = ""; + OHOS::Uri newFileUri(newFile); + int err = createFileCB->fileAccessHelper->CreateFile(parentUri, createFileCB->name, newFileUri); + createFileCB->result = newFileUri.ToString(); + createFileCB->execResult = err; + } else { + HILOG_ERROR("NAPI_CreateFile, fileAccessHelper uri is empty"); + } + } else { + HILOG_ERROR("NAPI_CreateFile, fileAccessHelper == nullptr"); + } + HILOG_INFO("NAPI_CreateFile, worker pool thread execute end."); +} + +void CreateFileAsyncCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO("NAPI_CreateFile, main event thread complete."); + FileAccessHelperCreateFileCB *createFileCB = static_cast(data); + napi_value callback = nullptr; + napi_value undefined = nullptr; + napi_value result[ARGS_TWO] = {nullptr}; + napi_value callResult = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined)); + NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, createFileCB->cbBase.cbInfo.callback, &callback)); + + result[PARAM0] = GetCallbackErrorValue(env, createFileCB->execResult); + NAPI_CALL_RETURN_VOID( + env, napi_create_string_utf8(env, createFileCB->result.c_str(), NAPI_AUTO_LENGTH, &result[PARAM1])); + NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult)); + + if (createFileCB->cbBase.cbInfo.callback != nullptr) { + NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, createFileCB->cbBase.cbInfo.callback)); + } + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, createFileCB->cbBase.asyncWork)); + delete createFileCB; + createFileCB = nullptr; + HILOG_INFO("NAPI_CreateFile, main event thread complete end."); +} + +void CreateFilePromiseCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO("NAPI_CreateFile, main event thread complete."); + FileAccessHelperCreateFileCB *createFileCB = static_cast(data); + napi_value result = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, createFileCB->result.c_str(), NAPI_AUTO_LENGTH, &result)); + NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, createFileCB->cbBase.deferred, result)); + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, createFileCB->cbBase.asyncWork)); + delete createFileCB; + createFileCB = nullptr; + HILOG_INFO("NAPI_CreateFile, main event thread complete end."); +} + +napi_value NAPI_Mkdir(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s,called", __func__); + FileAccessHelperMkdirCB *mkdirCB = new (std::nothrow) FileAccessHelperMkdirCB; + if (mkdirCB == nullptr) { + HILOG_ERROR("%{public}s, mkdirCB == nullptr.", __func__); + return WrapVoidToJS(env); + } + mkdirCB->cbBase.cbInfo.env = env; + mkdirCB->cbBase.asyncWork = nullptr; + mkdirCB->cbBase.deferred = nullptr; + mkdirCB->cbBase.ability = nullptr; + + napi_value ret = MkdirWrap(env, info, mkdirCB); + if (ret == nullptr) { + HILOG_ERROR("%{public}s,ret == nullptr", __func__); + if (mkdirCB != nullptr) { + delete mkdirCB; + mkdirCB = nullptr; + } + ret = WrapVoidToJS(env); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value MkdirWrap(napi_env env, napi_callback_info info, FileAccessHelperMkdirCB *mkdirCB) +{ + HILOG_INFO("%{public}s,called", __func__); + size_t argcAsync = ARGS_THREE; + const size_t argcPromise = ARGS_TWO; + const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT; + napi_value args[ARGS_MAX_COUNT] = {nullptr}; + napi_value ret = 0; + napi_value thisVar = nullptr; + + NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); + if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { + HILOG_ERROR("%{public}s, Wrong argument count.", __func__); + return nullptr; + } + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valuetype)); + if (valuetype == napi_string) { + mkdirCB->parentUri = NapiValueToStringUtf8(env, args[PARAM0]); + HILOG_INFO("%{public}s,parentUri= %{public}s", __func__, mkdirCB->parentUri.c_str()); + } + + NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valuetype)); + if (valuetype == napi_string) { + mkdirCB->name = NapiValueToStringUtf8(env, args[PARAM1]); + HILOG_INFO("%{public}s,name= %{public}s", __func__, mkdirCB->name.c_str()); + } + + FileAccessHelper *objectInfo = nullptr; + napi_unwrap(env, thisVar, (void **)&objectInfo); + HILOG_INFO("%{public}s,FileAccessHelper objectInfo", __func__); + mkdirCB->fileAccessHelper = objectInfo; + + if (argcAsync > argcPromise) { + ret = MkdirAsync(env, args, ARGS_TWO, mkdirCB); + } else { + ret = MkdirPromise(env, mkdirCB); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value MkdirAsync(napi_env env, napi_value *args, const size_t argCallback, FileAccessHelperMkdirCB *mkdirCB) +{ + HILOG_INFO("%{public}s, asyncCallback.", __func__); + if (args == nullptr || mkdirCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName = 0; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype)); + if (valuetype == napi_function) { + NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &mkdirCB->cbBase.cbInfo.callback)); + } + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + MkdirExecuteCB, + MkdirAsyncCompleteCB, + (void *)mkdirCB, + &mkdirCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, mkdirCB->cbBase.asyncWork)); + napi_value result = 0; + NAPI_CALL(env, napi_get_null(env, &result)); + HILOG_INFO("%{public}s, asyncCallback end.", __func__); + return result; +} + +napi_value MkdirPromise(napi_env env, FileAccessHelperMkdirCB *mkdirCB) +{ + HILOG_INFO("%{public}s, promise.", __func__); + if (mkdirCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + napi_deferred deferred; + napi_value promise = 0; + NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); + mkdirCB->cbBase.deferred = deferred; + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + MkdirExecuteCB, + MkdirPromiseCompleteCB, + (void *)mkdirCB, + &mkdirCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, mkdirCB->cbBase.asyncWork)); + HILOG_INFO("%{public}s, promise end.", __func__); + return promise; +} + +void MkdirExecuteCB(napi_env env, void *data) +{ + HILOG_INFO("NAPI_Mkdir, worker pool thread execute."); + FileAccessHelperMkdirCB *mkdirCB = static_cast(data); + if (mkdirCB->fileAccessHelper != nullptr) { + mkdirCB->execResult = -1; + if (!mkdirCB->parentUri.empty()) { + OHOS::Uri parentUri(mkdirCB->parentUri); + std::string newDir = ""; + OHOS::Uri newDirUri(newDir); + int err = mkdirCB->fileAccessHelper->Mkdir(parentUri, mkdirCB->name, newDirUri); + mkdirCB->result = newDirUri.ToString(); + mkdirCB->execResult = err; + } else { + HILOG_ERROR("NAPI_Mkdir, fileAccessHelper parentUri is empty"); + } + } else { + HILOG_ERROR("NAPI_Mkdir, fileAccessHelper == nullptr"); + } + HILOG_INFO("NAPI_Mkdir, worker pool thread execute end."); +} + +void MkdirAsyncCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO("NAPI_Mkdir, %{public}s start.", __func__); + FileAccessHelperMkdirCB *mkdirCB = static_cast(data); + napi_value callback = nullptr; + napi_value undefined = nullptr; + napi_value result[ARGS_TWO] = {nullptr}; + napi_value callResult = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined)); + NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, mkdirCB->cbBase.cbInfo.callback, &callback)); + + result[PARAM0] = GetCallbackErrorValue(env, mkdirCB->execResult); + NAPI_CALL_RETURN_VOID( + env, napi_create_string_utf8(env, mkdirCB->result.c_str(), NAPI_AUTO_LENGTH, &result[PARAM1])); + NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult)); + + if (mkdirCB->cbBase.cbInfo.callback != nullptr) { + NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, mkdirCB->cbBase.cbInfo.callback)); + } + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, mkdirCB->cbBase.asyncWork)); + delete mkdirCB; + mkdirCB = nullptr; + HILOG_INFO("NAPI_Mkdir, %{public}s end.", __func__); +} + +void MkdirPromiseCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO("NAPI_Mkdir, %{public}s start.", __func__); + FileAccessHelperMkdirCB *mkdirCB = static_cast(data); + napi_value result = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, mkdirCB->result.c_str(), NAPI_AUTO_LENGTH, &result)); + NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, mkdirCB->cbBase.deferred, result)); + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, mkdirCB->cbBase.asyncWork)); + delete mkdirCB; + mkdirCB = nullptr; + HILOG_INFO("NAPI_Mkdir, %{public}s end.", __func__); +} + +napi_value NAPI_Delete(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s,called", __func__); + FileAccessHelperDeleteCB *deleteCB = new (std::nothrow) FileAccessHelperDeleteCB; + if (deleteCB == nullptr) { + HILOG_ERROR("%{public}s, deleteCB == nullptr.", __func__); + return WrapVoidToJS(env); + } + deleteCB->cbBase.cbInfo.env = env; + deleteCB->cbBase.asyncWork = nullptr; + deleteCB->cbBase.deferred = nullptr; + deleteCB->cbBase.ability = nullptr; + + napi_value ret = DeleteWrap(env, info, deleteCB); + if (ret == nullptr) { + HILOG_ERROR("%{public}s,ret == nullptr", __func__); + if (deleteCB != nullptr) { + delete deleteCB; + deleteCB = nullptr; + } + ret = WrapVoidToJS(env); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value DeleteWrap(napi_env env, napi_callback_info info, FileAccessHelperDeleteCB *deleteCB) +{ + HILOG_INFO("%{public}s,called", __func__); + size_t argcAsync = ARGS_TWO; + const size_t argcPromise = ARGS_ONE; + const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT; + napi_value args[ARGS_MAX_COUNT] = {nullptr}; + napi_value ret = 0; + napi_value thisVar = nullptr; + + NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); + if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { + HILOG_ERROR("%{public}s, Wrong argument count.", __func__); + return nullptr; + } + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valuetype)); + if (valuetype == napi_string) { + deleteCB->selectFileUri = NapiValueToStringUtf8(env, args[PARAM0]); + } + + FileAccessHelper *objectInfo = nullptr; + napi_unwrap(env, thisVar, (void **)&objectInfo); + HILOG_INFO("%{public}s,FileAccessHelper objectInfo", __func__); + deleteCB->fileAccessHelper = objectInfo; + + if (argcAsync > argcPromise) { + ret = DeleteAsync(env, args, ARGS_ONE, deleteCB); + } else { + ret = DeletePromise(env, deleteCB); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value DeleteAsync(napi_env env, napi_value *args, const size_t argCallback, FileAccessHelperDeleteCB *deleteCB) +{ + HILOG_INFO("%{public}s, asyncCallback.", __func__); + if (args == nullptr || deleteCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName = 0; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype)); + if (valuetype == napi_function) { + NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &deleteCB->cbBase.cbInfo.callback)); + } + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + DeleteExecuteCB, + DeleteAsyncCompleteCB, + (void *)deleteCB, + &deleteCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, deleteCB->cbBase.asyncWork)); + napi_value result = 0; + NAPI_CALL(env, napi_get_null(env, &result)); + HILOG_INFO("%{public}s, asyncCallback end.", __func__); + return result; +} + +napi_value DeletePromise(napi_env env, FileAccessHelperDeleteCB *deleteCB) +{ + HILOG_INFO("%{public}s, promise.", __func__); + if (deleteCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + napi_deferred deferred; + napi_value promise = 0; + NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); + deleteCB->cbBase.deferred = deferred; + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + DeleteExecuteCB, + DeletePromiseCompleteCB, + (void *)deleteCB, + &deleteCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, deleteCB->cbBase.asyncWork)); + HILOG_INFO("%{public}s, promise end.", __func__); + return promise; +} + +void DeleteExecuteCB(napi_env env, void *data) +{ + HILOG_INFO(" NAPI_Delete, worker pool thread execute."); + FileAccessHelperDeleteCB *deleteCB = static_cast(data); + if (deleteCB->fileAccessHelper != nullptr) { + deleteCB->execResult = -1; + if (!deleteCB->selectFileUri.empty()) { + OHOS::Uri selectFileUri(deleteCB->selectFileUri); + deleteCB->result = deleteCB->fileAccessHelper->Delete(selectFileUri); + deleteCB->execResult = ERR_OK; + } else { + HILOG_ERROR("NAPI_Delete, fileAccessHelper selectFileUri is empty"); + } + } else { + HILOG_ERROR("NAPI_Delete, fileAccessHelper == nullptr"); + } + HILOG_INFO("NAPI_Delete, worker pool thread execute end."); +} + +void DeleteAsyncCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO("NAPI_Delete, %{public}s start.", __func__); + FileAccessHelperDeleteCB *deleteCB = static_cast(data); + napi_value callback = nullptr; + napi_value undefined = nullptr; + napi_value result[ARGS_TWO] = {nullptr}; + napi_value callResult = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined)); + NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, deleteCB->cbBase.cbInfo.callback, &callback)); + + result[PARAM0] = GetCallbackErrorValue(env, deleteCB->execResult); + napi_create_int32(env, deleteCB->result, &result[PARAM1]); + NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult)); + + if (deleteCB->cbBase.cbInfo.callback != nullptr) { + NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, deleteCB->cbBase.cbInfo.callback)); + } + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, deleteCB->cbBase.asyncWork)); + delete deleteCB; + deleteCB = nullptr; + HILOG_INFO("NAPI_Delete, %{public}s end.", __func__); +} + +void DeletePromiseCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO("NAPI_Delete, %{public}s start.", __func__); + FileAccessHelperDeleteCB *deleteCB = static_cast(data); + napi_value result = nullptr; + napi_create_int32(env, deleteCB->result, &result); + NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, deleteCB->cbBase.deferred, result)); + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, deleteCB->cbBase.asyncWork)); + delete deleteCB; + deleteCB = nullptr; + HILOG_INFO("NAPI_Delete, %{public}s end.", __func__); +} + +napi_value NAPI_Move(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s,called", __func__); + FileAccessHelperMoveCB *moveCB = new (std::nothrow) FileAccessHelperMoveCB; + if (moveCB == nullptr) { + HILOG_ERROR("%{public}s, moveCB == nullptr.", __func__); + return WrapVoidToJS(env); + } + moveCB->cbBase.cbInfo.env = env; + moveCB->cbBase.asyncWork = nullptr; + moveCB->cbBase.deferred = nullptr; + moveCB->cbBase.ability = nullptr; + + napi_value ret = MoveWrap(env, info, moveCB); + if (ret == nullptr) { + HILOG_ERROR("%{public}s,ret == nullptr", __func__); + if (moveCB != nullptr) { + delete moveCB; + moveCB = nullptr; + } + ret = WrapVoidToJS(env); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value MoveWrap(napi_env env, napi_callback_info info, FileAccessHelperMoveCB *moveCB) +{ + HILOG_INFO("%{public}s,called", __func__); + size_t argcAsync = ARGS_THREE; + const size_t argcPromise = ARGS_TWO; + const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT; + napi_value args[ARGS_MAX_COUNT] = {nullptr}; + napi_value ret = 0; + napi_value thisVar = nullptr; + + NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); + if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { + HILOG_ERROR("%{public}s, Wrong argument count.", __func__); + return nullptr; + } + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valuetype)); + if (valuetype == napi_string) { + moveCB->sourceFileUri = NapiValueToStringUtf8(env, args[PARAM0]); + HILOG_INFO("%{public}s,sourceFileUri=%{public}s", __func__, moveCB->sourceFileUri.c_str()); + } + + NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valuetype)); + if (valuetype == napi_string) { + moveCB->targetParentUri = NapiValueToStringUtf8(env, args[PARAM1]); + HILOG_INFO("%{public}s,targetParentUri=%{public}s", __func__, moveCB->targetParentUri.c_str()); + } + + FileAccessHelper *objectInfo = nullptr; + napi_unwrap(env, thisVar, (void **)&objectInfo); + HILOG_INFO("%{public}s,FileAccessHelper objectInfo", __func__); + moveCB->fileAccessHelper = objectInfo; + + if (argcAsync > argcPromise) { + ret = MoveAsync(env, args, ARGS_TWO, moveCB); + } else { + ret = MovePromise(env, moveCB); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value MoveAsync(napi_env env, napi_value *args, const size_t argCallback, FileAccessHelperMoveCB *moveCB) +{ + HILOG_INFO("%{public}s, asyncCallback.", __func__); + if (args == nullptr || moveCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName = 0; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype)); + if (valuetype == napi_function) { + NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &moveCB->cbBase.cbInfo.callback)); + } + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + MoveExecuteCB, + MoveAsyncCompleteCB, + (void *)moveCB, + &moveCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, moveCB->cbBase.asyncWork)); + napi_value result = 0; + NAPI_CALL(env, napi_get_null(env, &result)); + HILOG_INFO("%{public}s, asyncCallback end.", __func__); + return result; +} + +napi_value MovePromise(napi_env env, FileAccessHelperMoveCB *moveCB) +{ + HILOG_INFO("%{public}s, promise.", __func__); + if (moveCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + napi_deferred deferred; + napi_value promise = 0; + NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); + moveCB->cbBase.deferred = deferred; + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + MoveExecuteCB, + MovePromiseCompleteCB, + (void *)moveCB, + &moveCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, moveCB->cbBase.asyncWork)); + HILOG_INFO("%{public}s, promise end.", __func__); + return promise; +} + +void MoveExecuteCB(napi_env env, void *data) +{ + HILOG_INFO("NAPI_Move, worker pool thread execute."); + FileAccessHelperMoveCB *moveCB = static_cast(data); + if (moveCB->fileAccessHelper != nullptr) { + moveCB->execResult = -1; + if (!moveCB->sourceFileUri.empty()) { + OHOS::Uri sourceFileUri(moveCB->sourceFileUri); + OHOS::Uri targetParentUri(moveCB->targetParentUri); + std::string newFile = ""; + OHOS::Uri newFileUri(newFile); + int err = moveCB->fileAccessHelper->Move(sourceFileUri, targetParentUri, newFileUri); + moveCB->result = newFileUri.ToString(); + moveCB->execResult = err; + } else { + HILOG_ERROR("NAPI_Move, fileAccessHelper sourceFileUri is empty"); + } + } else { + HILOG_ERROR("NAPI_Move, fileAccessHelper == nullptr"); + } + HILOG_INFO("NAPI_Move, worker pool thread execute end."); +} + +void MoveAsyncCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO("NAPI_Move, main event thread complete."); + FileAccessHelperMoveCB *moveCB = static_cast(data); + if (moveCB == nullptr) { + return ; + } + napi_value callback = nullptr; + napi_value undefined = nullptr; + napi_value result[ARGS_TWO] = {nullptr}; + napi_value callResult = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined)); + NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, moveCB->cbBase.cbInfo.callback, &callback)); + + result[PARAM0] = GetCallbackErrorValue(env, moveCB->execResult); + NAPI_CALL_RETURN_VOID( + env, napi_create_string_utf8(env, moveCB->result.c_str(), NAPI_AUTO_LENGTH, &result[PARAM1])); + NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult)); + + if (moveCB->cbBase.cbInfo.callback != nullptr) { + NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, moveCB->cbBase.cbInfo.callback)); + } + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, moveCB->cbBase.asyncWork)); + delete moveCB; + moveCB = nullptr; + HILOG_INFO("NAPI_Move, main event thread complete end."); +} + +void MovePromiseCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO("NAPI_Move, main event thread complete."); + FileAccessHelperMoveCB *moveCB = static_cast(data); + napi_value result = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, moveCB->result.c_str(), NAPI_AUTO_LENGTH, &result)); + NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, moveCB->cbBase.deferred, result)); + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, moveCB->cbBase.asyncWork)); + delete moveCB; + moveCB = nullptr; + HILOG_INFO("NAPI_Move, main event thread complete end."); +} + +napi_value NAPI_Rename(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s,called", __func__); + FileAccessHelperRenameCB *renameCB = new (std::nothrow) FileAccessHelperRenameCB; + if (renameCB == nullptr) { + HILOG_ERROR("%{public}s, renameCB == nullptr.", __func__); + return WrapVoidToJS(env); + } + renameCB->cbBase.cbInfo.env = env; + renameCB->cbBase.asyncWork = nullptr; + renameCB->cbBase.deferred = nullptr; + renameCB->cbBase.ability = nullptr; + + napi_value ret = RenameWrap(env, info, renameCB); + if (ret == nullptr) { + HILOG_ERROR("%{public}s,ret == nullptr", __func__); + if (renameCB != nullptr) { + delete renameCB; + renameCB = nullptr; + } + ret = WrapVoidToJS(env); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value RenameWrap(napi_env env, napi_callback_info info, FileAccessHelperRenameCB *renameCB) +{ + HILOG_INFO("%{public}s,called", __func__); + size_t argcAsync = ARGS_THREE; + const size_t argcPromise = ARGS_TWO; + const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT; + napi_value args[ARGS_MAX_COUNT] = {nullptr}; + napi_value ret = 0; + napi_value thisVar = nullptr; + + NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); + if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { + HILOG_ERROR("%{public}s, Wrong argument count.", __func__); + return nullptr; + } + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valuetype)); + if (valuetype == napi_string) { + renameCB->sourceFileUri = NapiValueToStringUtf8(env, args[PARAM0]); + HILOG_INFO("%{public}s,sourceFileUri= %{public}s", __func__, renameCB->sourceFileUri.c_str()); + } + + NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valuetype)); + if (valuetype == napi_string) { + renameCB->displayName = NapiValueToStringUtf8(env, args[PARAM1]); + HILOG_INFO("%{public}s,displayName= %{public}s", __func__, renameCB->displayName.c_str()); + } + + FileAccessHelper *objectInfo = nullptr; + napi_unwrap(env, thisVar, (void **)&objectInfo); + HILOG_INFO("%{public}s,FileAccessHelper objectInfo", __func__); + renameCB->fileAccessHelper = objectInfo; + + if (argcAsync > argcPromise) { + ret = RenameAsync(env, args, ARGS_TWO, renameCB); + } else { + ret = RenamePromise(env, renameCB); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value RenameAsync(napi_env env, napi_value *args, const size_t argCallback, FileAccessHelperRenameCB *renameCB) +{ + HILOG_INFO("%{public}s, asyncCallback.", __func__); + if (args == nullptr || renameCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName = 0; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype)); + if (valuetype == napi_function) { + NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &renameCB->cbBase.cbInfo.callback)); + } + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + RenameExecuteCB, + RenameAsyncCompleteCB, + (void *)renameCB, + &renameCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, renameCB->cbBase.asyncWork)); + napi_value result = 0; + NAPI_CALL(env, napi_get_null(env, &result)); + HILOG_INFO("%{public}s, asyncCallback end.", __func__); + return result; +} + +napi_value RenamePromise(napi_env env, FileAccessHelperRenameCB *renameCB) +{ + HILOG_INFO("%{public}s, promise.", __func__); + if (renameCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + napi_deferred deferred; + napi_value promise = 0; + NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); + renameCB->cbBase.deferred = deferred; + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + RenameExecuteCB, + RenamePromiseCompleteCB, + (void *)renameCB, + &renameCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, renameCB->cbBase.asyncWork)); + HILOG_INFO("%{public}s, promise end.", __func__); + return promise; +} + +void RenameExecuteCB(napi_env env, void *data) +{ + HILOG_INFO(" NAPI_Rename, worker pool thread execute."); + FileAccessHelperRenameCB *renameCB = static_cast(data); + if (renameCB->fileAccessHelper != nullptr) { + renameCB->execResult = -1; + if (!renameCB->sourceFileUri.empty()) { + OHOS::Uri sourceFileUri(renameCB->sourceFileUri); + std::string newFile = ""; + OHOS::Uri newFileUri(newFile); + int err = renameCB->fileAccessHelper->Rename(sourceFileUri, renameCB->displayName, newFileUri); + renameCB->result = newFileUri.ToString(); + renameCB->execResult = err; + } else { + HILOG_ERROR("NAPI_Rename, fileAccessHelper sourceFileUri is empty"); + } + } else { + HILOG_ERROR("NAPI_Rename, fileAccessHelper == nullptr"); + } + HILOG_INFO("NAPI_Rename, worker pool thread execute end."); +} + +void RenameAsyncCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO("NAPI_Rename, %{public}s start.", __func__); + FileAccessHelperRenameCB *renameCB = static_cast(data); + napi_value callback = nullptr; + napi_value undefined = nullptr; + napi_value result[ARGS_TWO] = {nullptr}; + napi_value callResult = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined)); + NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, renameCB->cbBase.cbInfo.callback, &callback)); + + result[PARAM0] = GetCallbackErrorValue(env, renameCB->execResult); + NAPI_CALL_RETURN_VOID( + env, napi_create_string_utf8(env, renameCB->result.c_str(), NAPI_AUTO_LENGTH, &result[PARAM1])); + NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult)); + + if (renameCB->cbBase.cbInfo.callback != nullptr) { + NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, renameCB->cbBase.cbInfo.callback)); + } + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, renameCB->cbBase.asyncWork)); + delete renameCB; + renameCB = nullptr; + HILOG_INFO("NAPI_Rename, %{public}s end.", __func__); +} + +void RenamePromiseCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO("NAPI_Rename, %{public}s start.", __func__); + FileAccessHelperRenameCB *renameCB = static_cast(data); + napi_value result = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, renameCB->result.c_str(), NAPI_AUTO_LENGTH, &result)); + NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, renameCB->cbBase.deferred, result)); + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, renameCB->cbBase.asyncWork)); + delete renameCB; + renameCB = nullptr; + HILOG_INFO("NAPI_Rename, %{public}s end.", __func__); +} + +napi_value NAPI_ListFile(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s,called", __func__); + FileAccessHelperListFileCB *listFileCB = new (std::nothrow) FileAccessHelperListFileCB; + if (listFileCB == nullptr) { + HILOG_ERROR("%{public}s, listFileCB == nullptr.", __func__); + return WrapVoidToJS(env); + } + listFileCB->cbBase.cbInfo.env = env; + listFileCB->cbBase.asyncWork = nullptr; + listFileCB->cbBase.deferred = nullptr; + listFileCB->cbBase.ability = nullptr; + + napi_value ret = ListFileWrap(env, info, listFileCB); + if (ret == nullptr) { + HILOG_ERROR("%{public}s,ret == nullptr", __func__); + if (listFileCB != nullptr) { + delete listFileCB; + listFileCB = nullptr; + } + ret = WrapVoidToJS(env); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value ListFileWrap(napi_env env, napi_callback_info info, FileAccessHelperListFileCB *listFileCB) +{ + HILOG_INFO("%{public}s,called", __func__); + size_t argcAsync = ARGS_TWO; + const size_t argcPromise = ARGS_ONE; + const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT; + napi_value args[ARGS_MAX_COUNT] = {nullptr}; + napi_value ret = 0; + napi_value thisVar = nullptr; + + NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); + if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { + HILOG_ERROR("%{public}s, Wrong argument count.", __func__); + return nullptr; + } + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valuetype)); + if (valuetype == napi_string) { + listFileCB->sourceFileUri = NapiValueToStringUtf8(env, args[PARAM0]); + HILOG_INFO("%{public}s,sourceFileUri=%{public}s", __func__, listFileCB->sourceFileUri.c_str()); + } + + FileAccessHelper *objectInfo = nullptr; + napi_unwrap(env, thisVar, (void **)&objectInfo); + HILOG_INFO("%{public}s,FileAccessHelper objectInfo", __func__); + listFileCB->fileAccessHelper = objectInfo; + + if (argcAsync > argcPromise) { + ret = ListFileAsync(env, args, ARGS_ONE, listFileCB); + } else { + ret = ListFilePromise(env, listFileCB); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value ListFileAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperListFileCB *listFileCB) +{ + HILOG_INFO("%{public}s, asyncCallback.", __func__); + if (args == nullptr || listFileCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName = 0; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype)); + if (valuetype == napi_function) { + NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &listFileCB->cbBase.cbInfo.callback)); + } + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + ListFileExecuteCB, + ListFileAsyncCompleteCB, + (void *)listFileCB, + &listFileCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, listFileCB->cbBase.asyncWork)); + napi_value result = 0; + NAPI_CALL(env, napi_get_null(env, &result)); + HILOG_INFO("%{public}s, asyncCallback end.", __func__); + return result; +} + +napi_value ListFilePromise(napi_env env, FileAccessHelperListFileCB *listFileCB) +{ + HILOG_INFO("%{public}s, promise.", __func__); + if (listFileCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + napi_deferred deferred; + napi_value promise = 0; + NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); + listFileCB->cbBase.deferred = deferred; + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + ListFileExecuteCB, + ListFilePromiseCompleteCB, + (void *)listFileCB, + &listFileCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, listFileCB->cbBase.asyncWork)); + HILOG_INFO("%{public}s, promise end.", __func__); + return promise; +} + +void ListFileExecuteCB(napi_env env, void *data) +{ + HILOG_INFO(" NAPI_ListFile, worker pool thread execute."); + FileAccessHelperListFileCB *listFileCB = static_cast(data); + if (listFileCB->fileAccessHelper != nullptr) { + listFileCB->execResult = -1; + if (!listFileCB->sourceFileUri.empty()) { + OHOS::Uri sourceFileUri(listFileCB->sourceFileUri); + listFileCB->result = listFileCB->fileAccessHelper->ListFile(sourceFileUri); + listFileCB->execResult = ERR_OK; + } else { + HILOG_ERROR(" NAPI_ListFile, fileAccessHelper sourceFileUri is empty"); + } + } else { + HILOG_ERROR(" NAPI_ListFile, fileAccessHelper == nullptr"); + } + HILOG_INFO(" NAPI_ListFile, worker pool thread execute end."); +} + +void ListFileAsyncCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO(" NAPI_ListFile, main event thread complete."); + FileAccessHelperListFileCB *listFileCB = static_cast(data); + napi_value callback = nullptr; + napi_value undefined = nullptr; + napi_value result[ARGS_TWO] = {nullptr}; + napi_value callResult = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined)); + NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, listFileCB->cbBase.cbInfo.callback, &callback)); + + result[PARAM0] = GetCallbackErrorValue(env, listFileCB->execResult); + result[PARAM1] = WrapArrayFileInfoToJS(env, listFileCB->result); + NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult)); + + if (listFileCB->cbBase.cbInfo.callback != nullptr) { + NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, listFileCB->cbBase.cbInfo.callback)); + } + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, listFileCB->cbBase.asyncWork)); + delete listFileCB; + listFileCB = nullptr; + HILOG_INFO(" NAPI_Query, main event thread complete end."); +} + +void ListFilePromiseCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO(" NAPI_Query, main event thread complete."); + FileAccessHelperListFileCB *listFileCB = static_cast(data); + napi_value result = nullptr; + result = WrapArrayFileInfoToJS(env, listFileCB->result); + NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, listFileCB->cbBase.deferred, result)); + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, listFileCB->cbBase.asyncWork)); + delete listFileCB; + listFileCB = nullptr; + HILOG_INFO(" NAPI_Query, main event thread complete end."); +} + +napi_value NAPI_GetRoots(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s,called", __func__); + FileAccessHelperGetRootsCB *getRootsCB = new (std::nothrow) FileAccessHelperGetRootsCB; + if (getRootsCB == nullptr) { + HILOG_ERROR("%{public}s, getRootsCB == nullptr.", __func__); + return WrapVoidToJS(env); + } + getRootsCB->cbBase.cbInfo.env = env; + getRootsCB->cbBase.asyncWork = nullptr; + getRootsCB->cbBase.deferred = nullptr; + getRootsCB->cbBase.ability = nullptr; + + napi_value ret = GetRootsWrap(env, info, getRootsCB); + if (ret == nullptr) { + HILOG_ERROR("%{public}s,ret == nullptr", __func__); + if (getRootsCB != nullptr) { + delete getRootsCB; + getRootsCB = nullptr; + } + ret = WrapVoidToJS(env); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value GetRootsWrap(napi_env env, napi_callback_info info, FileAccessHelperGetRootsCB *getRootsCB) +{ + HILOG_INFO("%{public}s,called", __func__); + size_t argcAsync = ARGS_ONE; + const size_t argcPromise = ARGS_ZERO; + const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT; + napi_value args[ARGS_MAX_COUNT] = {nullptr}; + napi_value ret = 0; + napi_value thisVar = nullptr; + + NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); + if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { + HILOG_ERROR("%{public}s, Wrong argument count.", __func__); + return nullptr; + } + + FileAccessHelper *objectInfo = nullptr; + napi_unwrap(env, thisVar, (void **)&objectInfo); + HILOG_INFO("%{public}s,FileAccessHelper objectInfo", __func__); + getRootsCB->fileAccessHelper = objectInfo; + + if (argcAsync > argcPromise) { + ret = GetRootsAsync(env, args, ARGS_ZERO, getRootsCB); + } else { + ret = GetRootsPromise(env, getRootsCB); + } + HILOG_INFO("%{public}s,end", __func__); + return ret; +} + +napi_value GetRootsAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperGetRootsCB *getRootsCB) +{ + HILOG_INFO("%{public}s, asyncCallback.", __func__); + if (args == nullptr || getRootsCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName = 0; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + + napi_valuetype valuetype = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype)); + if (valuetype == napi_function) { + NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &getRootsCB->cbBase.cbInfo.callback)); + } + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + GetRootsExecuteCB, + GetRootsAsyncCompleteCB, + (void *)getRootsCB, + &getRootsCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, getRootsCB->cbBase.asyncWork)); + napi_value result = 0; + NAPI_CALL(env, napi_get_null(env, &result)); + HILOG_INFO("%{public}s, asyncCallback end.", __func__); + return result; +} + +napi_value GetRootsPromise(napi_env env, FileAccessHelperGetRootsCB *getRootsCB) +{ + HILOG_INFO("%{public}s, promise.", __func__); + if (getRootsCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; + } + napi_value resourceName; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + napi_deferred deferred; + napi_value promise = 0; + NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); + getRootsCB->cbBase.deferred = deferred; + + NAPI_CALL(env, + napi_create_async_work(env, + nullptr, + resourceName, + GetRootsExecuteCB, + GetRootsPromiseCompleteCB, + (void *)getRootsCB, + &getRootsCB->cbBase.asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, getRootsCB->cbBase.asyncWork)); + HILOG_INFO("%{public}s, promise end.", __func__); + return promise; +} + +void GetRootsExecuteCB(napi_env env, void *data) +{ + HILOG_INFO(" NAPI_GetRoots, worker pool thread execute."); + FileAccessHelperGetRootsCB *getRootsCB = static_cast(data); + if (getRootsCB->fileAccessHelper != nullptr) { + getRootsCB->result = getRootsCB->fileAccessHelper->GetRoots(); + getRootsCB->execResult = ERR_OK; + } else { + HILOG_ERROR(" NAPI_GetRoots, fileAccessHelper == nullptr"); + } + HILOG_INFO(" NAPI_GetRoots, worker pool thread execute end."); +} + +void GetRootsAsyncCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO(" NAPI_GetRoots, main event thread complete."); + FileAccessHelperGetRootsCB *getRootsCB = static_cast(data); + napi_value callback = nullptr; + napi_value undefined = nullptr; + napi_value result[ARGS_TWO] = {nullptr}; + napi_value callResult = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined)); + NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, getRootsCB->cbBase.cbInfo.callback, &callback)); + + result[PARAM0] = GetCallbackErrorValue(env, getRootsCB->execResult); + result[PARAM1] = WrapArrayDeviceInfoToJS(env, getRootsCB->result); + NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult)); + + if (getRootsCB->cbBase.cbInfo.callback != nullptr) { + NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, getRootsCB->cbBase.cbInfo.callback)); + } + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, getRootsCB->cbBase.asyncWork)); + delete getRootsCB; + getRootsCB = nullptr; + HILOG_INFO(" NAPI_GetRoots, main event thread complete end."); +} + +void GetRootsPromiseCompleteCB(napi_env env, napi_status status, void *data) +{ + HILOG_INFO(" NAPI_GetRoots, main event thread complete."); + FileAccessHelperGetRootsCB *getRootsCB = static_cast(data); + napi_value result = nullptr; + result = WrapArrayDeviceInfoToJS(env, getRootsCB->result); + NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, getRootsCB->cbBase.deferred, result)); + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, getRootsCB->cbBase.asyncWork)); + delete getRootsCB; + getRootsCB = nullptr; + HILOG_INFO(" NAPI_GetRoots, main event thread complete end."); +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.h b/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.h new file mode 100644 index 00000000..0f4fb297 --- /dev/null +++ b/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.h @@ -0,0 +1,114 @@ +/* + * 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 NAPI_FILEACCESS_HELPER_H +#define NAPI_FILEACCESS_HELPER_H + +#include "file_access_common.h" + +namespace OHOS { +namespace FileAccessFwk { + napi_value FileAccessHelperInit(napi_env env, napi_value exports); + napi_value FileAccessHelperConstructor(napi_env env, napi_callback_info info); + napi_value NAPI_OpenFile(napi_env env, napi_callback_info info); + napi_value OpenFileWrap(napi_env env, napi_callback_info info, FileAccessHelperOpenFileCB *openFileCB); + napi_value OpenFileAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperOpenFileCB *openFileCB); + napi_value OpenFilePromise(napi_env env, FileAccessHelperOpenFileCB *openFileCB); + void OpenFileExecuteCB(napi_env env, void *data); + void OpenFileAsyncCompleteCB(napi_env env, napi_status status, void *data); + void OpenFilePromiseCompleteCB(napi_env env, napi_status status, void *data); + + napi_value NAPI_CreateFile(napi_env env, napi_callback_info info); + napi_value CreateFileWrap(napi_env env, napi_callback_info info, FileAccessHelperCreateFileCB *createFileCB); + napi_value CreateFileAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperCreateFileCB *createFileCB); + napi_value CreateFilePromise(napi_env env, FileAccessHelperCreateFileCB *createFileCB); + void CreateFileExecuteCB(napi_env env, void *data); + void CreateFileAsyncCompleteCB(napi_env env, napi_status status, void *data); + void CreateFilePromiseCompleteCB(napi_env env, napi_status status, void *data); + + napi_value NAPI_Mkdir(napi_env env, napi_callback_info info); + napi_value MkdirWrap(napi_env env, napi_callback_info info, FileAccessHelperMkdirCB *mkdirCB); + napi_value MkdirAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperMkdirCB *mkdirCB); + napi_value MkdirPromise(napi_env env, FileAccessHelperMkdirCB *mkdirCB); + void MkdirExecuteCB(napi_env env, void *data); + void MkdirAsyncCompleteCB(napi_env env, napi_status status, void *data); + void MkdirPromiseCompleteCB(napi_env env, napi_status status, void *data); + + napi_value NAPI_Delete(napi_env env, napi_callback_info info); + napi_value DeleteWrap(napi_env env, napi_callback_info info, FileAccessHelperDeleteCB *deleteCB); + napi_value DeleteAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperDeleteCB *deleteCB); + napi_value DeletePromise(napi_env env, FileAccessHelperDeleteCB *deleteCB); + void DeleteExecuteCB(napi_env env, void *data); + void DeleteAsyncCompleteCB(napi_env env, napi_status status, void *data); + void DeletePromiseCompleteCB(napi_env env, napi_status status, void *data); + + napi_value NAPI_Move(napi_env env, napi_callback_info info); + napi_value MoveWrap(napi_env env, napi_callback_info info, FileAccessHelperMoveCB *moveCB); + napi_value MoveAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperMoveCB *moveCB); + napi_value MovePromise(napi_env env, FileAccessHelperMoveCB *moveCB); + void MoveExecuteCB(napi_env env, void *data); + void MoveAsyncCompleteCB(napi_env env, napi_status status, void *data); + void MovePromiseCompleteCB(napi_env env, napi_status status, void *data); + + napi_value NAPI_Rename(napi_env env, napi_callback_info info); + napi_value RenameWrap(napi_env env, napi_callback_info info, FileAccessHelperRenameCB *renameCB); + napi_value RenameAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperRenameCB *renameCB); + napi_value RenamePromise(napi_env env, FileAccessHelperRenameCB *renameCB); + void RenameExecuteCB(napi_env env, void *data); + void RenameAsyncCompleteCB(napi_env env, napi_status status, void *data); + void RenamePromiseCompleteCB(napi_env env, napi_status status, void *data); + + napi_value NAPI_ListFile(napi_env env, napi_callback_info info); + napi_value ListFileWrap(napi_env env, napi_callback_info info, FileAccessHelperListFileCB *listFileCB); + napi_value ListFileAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperListFileCB *listFileCB); + napi_value ListFilePromise(napi_env env, FileAccessHelperListFileCB *listFileCB); + void ListFileExecuteCB(napi_env env, void *data); + void ListFileAsyncCompleteCB(napi_env env, napi_status status, void *data); + void ListFilePromiseCompleteCB(napi_env env, napi_status status, void *data); + + napi_value NAPI_GetRoots(napi_env env, napi_callback_info info); + napi_value GetRootsWrap(napi_env env, napi_callback_info info, FileAccessHelperGetRootsCB *getRootsCB); + napi_value GetRootsAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperGetRootsCB *getRootsCB); + napi_value GetRootsPromise(napi_env env, FileAccessHelperGetRootsCB *getRootsCB); + void GetRootsExecuteCB(napi_env env, void *data); + void GetRootsAsyncCompleteCB(napi_env env, napi_status status, void *data); + void GetRootsPromiseCompleteCB(napi_env env, napi_status status, void *data); +} +} // namespace FileAccessFwk +#endif // FILE_ACCESS_NAPI_H \ No newline at end of file diff --git a/interfaces/kits/napi/file_access_module/native_fileaccess_module.cpp b/interfaces/kits/napi/file_access_module/native_fileaccess_module.cpp new file mode 100644 index 00000000..fb78160c --- /dev/null +++ b/interfaces/kits/napi/file_access_module/native_fileaccess_module.cpp @@ -0,0 +1,65 @@ +/* + * 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 +#include + +#include "napi_fileaccess_helper.h" +#include "napi/native_api.h" +#include "napi/native_node_api.h" +#include "hilog_wrapper.h" +#include "file_extension_info_napi.h" +using namespace std; + +namespace OHOS { +namespace FileAccessFwk { +EXTERN_C_START +/* + * The module initialization. + */ +static napi_value Init(napi_env env, napi_value exports) +{ + HILOG_INFO("tag dsa %{public}s,called", __func__); + FileAccessHelperInit(env, exports); + InitFlag(env, exports); + InitFileInfo(env, exports); + InitDeviceInfo(env, exports); + return exports; +} +EXTERN_C_END + +/* + * The module definition. + */ +static napi_module _module = { + .nm_version = 1, + .nm_flags = 0, + .nm_filename = nullptr, + .nm_register_func = Init, + .nm_modname = "data.fileAccess", + .nm_priv = ((void *)0), + .reserved = {0} +}; + +/* + * The module registration. + */ +extern "C" __attribute__((constructor)) void RegisterModule(void) +{ + HILOG_INFO("tag dsa %{public}s,called", __func__); + napi_module_register(&_module); +} +} // namespace FileAccessFwk +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/kits/napi/file_ext_ability/BUILD.gn b/interfaces/kits/napi/file_ext_ability/BUILD.gn new file mode 100644 index 00000000..b0e794e8 --- /dev/null +++ b/interfaces/kits/napi/file_ext_ability/BUILD.gn @@ -0,0 +1,50 @@ +# 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("//ark/ts2abc/ts2panda/ts2abc_config.gni") +import("//build/ohos.gni") + +ts2abc_gen_abc("gen_file_ext_ability_abc") { + src_js = rebase_path("file_ext_ability.js") + dst_file = rebase_path(target_out_dir + "/file_ext_ability.abc") + in_puts = [ "file_ext_ability.js" ] + out_puts = [ target_out_dir + "/file_ext_ability.abc" ] + extra_args = [ "--module" ] +} + +gen_js_obj("file_ext_ability_js") { + input = "file_ext_ability.js" + output = target_out_dir + "/file_ext_ability.o" +} + +gen_js_obj("file_ext_ability_abc") { + input = get_label_info(":gen_file_ext_ability_abc", "target_out_dir") + + "/file_ext_ability.abc" + output = target_out_dir + "/file_ext_ability_abc.o" + dep = ":gen_file_ext_ability_abc" +} + +ohos_shared_library("fileextensionability_napi") { + sources = [ "file_ext_ability_module.cpp" ] + + deps = [ + ":file_ext_ability_abc", + ":file_ext_ability_js", + ] + + external_deps = [ "napi:ace_napi" ] + + relative_install_dir = "module/application" + subsystem_name = "filemanagement" + part_name = "user_file_service" +} diff --git a/interfaces/kits/napi/file_ext_ability/file_ext_ability.js b/interfaces/kits/napi/file_ext_ability/file_ext_ability.js new file mode 100644 index 00000000..af76fcf3 --- /dev/null +++ b/interfaces/kits/napi/file_ext_ability/file_ext_ability.js @@ -0,0 +1,62 @@ +/* + * 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. + */ + +class FileExtensionAbility { + onCreate(want) { + console.log('js c++ tag dsa onCreate, want:' + want.abilityName); + } + + openFile(uri, mode) { + console.log('js c++ tag dsa openFile, uri:' + uri + ',flags: ' + flags); + return 0; + } + + createFile(parentUri, displayName) { + console.log('js c++ tag dsa CreateFile, parentUri:' + parentUri + ',displayName:' + displayName ); + return "filetest://fileext.share/temp/test/CreateFile000.txt"; + } + + mkdir(parentUri, displayName) { + console.log('js c++ tag dsa mkdir, parentUri:' + parentUri + ',displayName:' + displayName); + return "filetest://fileext.share/temp/test/Mkdir000"; + } + + delete(sourceFileUri) { + console.log('js c++ tag dsa delete, sourceFileUri:' + sourceFileUri); + return 0; + } + + move(sourceFileUri, targetParentUri) { + console.log('js c++ tag dsa move, sourceFileUri:' + sourceFileUri + ',targetParentUri:' + targetParentUri); + return "filetest://fileext.share/temp/test/move000.xl"; + } + + rename(sourceFileUri, displayName) { + console.log('js c++ tag dsa rename, sourceFileUri:' + sourceFileUri + ',displayName:' + displayName); + return "filetest://fileext.share/temp/test/rename000.ttt"; + } + + listFile(sourceFileUri) { + let infos = []; + return infos; + } + + getRoots() { + let roots = []; + return roots; + } +} + +export default FileExtensionAbility \ No newline at end of file diff --git a/interfaces/kits/napi/file_ext_ability/file_ext_ability_module.cpp b/interfaces/kits/napi/file_ext_ability/file_ext_ability_module.cpp new file mode 100644 index 00000000..6dca96b5 --- /dev/null +++ b/interfaces/kits/napi/file_ext_ability/file_ext_ability_module.cpp @@ -0,0 +1,57 @@ +/* + * 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 "native_engine/native_engine.h" + +extern const char _binary_file_ext_ability_js_start[]; +extern const char _binary_file_ext_ability_js_end[]; +extern const char _binary_file_ext_ability_abc_start[]; +extern const char _binary_file_ext_ability_abc_end[]; + +extern "C" __attribute__((constructor)) +void NAPI_application_FileExtensionAbility_AutoRegister() +{ + auto moduleManager = NativeModuleManager::GetInstance(); + NativeModule newModuleInfo = { + .name = "application.FileExtensionAbility", + .fileName = "application/libfileextensionability_napi.so/FileExtensionAbility.js", + }; + + moduleManager->Register(&newModuleInfo); +} + +extern "C" __attribute__((visibility("default"))) +void NAPI_application_FileExtensionAbility_GetJSCode(const char **buf, int *bufLen) +{ + if (buf != nullptr) { + *buf = _binary_file_ext_ability_js_start; + } + + if (bufLen != nullptr) { + *bufLen = _binary_file_ext_ability_js_end - _binary_file_ext_ability_js_start; + } +} + +// file extension ability JS register +extern "C" __attribute__((visibility("default"))) +void NAPI_application_FileExtensionAbility_GetABCCode(const char **buf, int *buflen) +{ + if (buf != nullptr) { + *buf = _binary_file_ext_ability_abc_start; + } + if (buflen != nullptr) { + *buflen = _binary_file_ext_ability_abc_end - _binary_file_ext_ability_abc_start; + } +} \ No newline at end of file diff --git a/interfaces/kits/napi/file_extension_info_module/BUILD.gn b/interfaces/kits/napi/file_extension_info_module/BUILD.gn new file mode 100644 index 00000000..ac54d7d6 --- /dev/null +++ b/interfaces/kits/napi/file_extension_info_module/BUILD.gn @@ -0,0 +1,42 @@ +# 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. + +import("//build/ohos.gni") + +UFS_BASE_PATH = "//foundation/filemanagement/user_file_service" +FRAMEWORK_PATH = "${UFS_BASE_PATH}/frameworks" + +ohos_shared_library("fileextensioninfo") { + subsystem_name = "filemanagement" + part_name = "user_file_service" + relative_install_dir = "module" + + include_dirs = [ + ".", + "${UFS_BASE_PATH}/interfaces/kits/napi/common", + "${FRAMEWORK_PATH}/innerkits/file_access/include", + ] + + sources = [ + "${UFS_BASE_PATH}/interfaces/kits/napi/common/file_extension_info_napi.cpp", + "module_export_napi.cpp", + ] + + deps = [ "//foundation/arkui/napi:ace_napi" ] + + external_deps = [ + "hiviewdfx_hilog_native:libhilog", + "ability_base:zuri", + "utils_base:utils", + ] +} \ No newline at end of file diff --git a/interfaces/kits/napi/file_extension_info_module/module_export_napi.cpp b/interfaces/kits/napi/file_extension_info_module/module_export_napi.cpp new file mode 100644 index 00000000..543a32cf --- /dev/null +++ b/interfaces/kits/napi/file_extension_info_module/module_export_napi.cpp @@ -0,0 +1,37 @@ +/* + * 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. + */ + +#include "module_export_napi.h" + +#include + +#include "file_extension_info_napi.h" +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace OHOS { +namespace FileAccessFwk { +napi_value FileExtensionInfoExport(napi_env env, napi_value exports) +{ + InitFlag(env, exports); + InitFileInfo(env, exports); + InitDeviceInfo(env, exports); + + return exports; +} + +NAPI_MODULE(fileExtensionInfo, FileExtensionInfoExport) +} // namespace FileAccessFwk +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/kits/napi/file_extension_info_module/module_export_napi.h b/interfaces/kits/napi/file_extension_info_module/module_export_napi.h new file mode 100644 index 00000000..c49f3b0a --- /dev/null +++ b/interfaces/kits/napi/file_extension_info_module/module_export_napi.h @@ -0,0 +1,22 @@ +/* + * 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 MODULE_EXPORT_NAPI_H +#define MODULE_EXPORT_NAPI_H +namespace OHOS { +namespace FileAccessFwk { +} // namespace FileAccessFwk +} // namespace OHOS +#endif // MODULE_EXPORT_NAPI_H \ No newline at end of file diff --git a/services/BUILD.gn b/services/BUILD.gn index aa10b398..2fefab42 100644 --- a/services/BUILD.gn +++ b/services/BUILD.gn @@ -19,6 +19,7 @@ group("fms") { deps = [ ":fms_server", ":fms_service.cfg", + ":external_file_manager_hap", ] } @@ -91,3 +92,39 @@ ohos_shared_library("fms_server") { "samgr_standard:samgr_proxy", ] } + +### external file manager hap +ohos_hap("external_file_manager_hap") { + hap_profile = "file_extension_hap/entry/src/main/module.json" + deps = [ + ":external_file_manager_js_assets", + ":external_file_manager_resources", + ] + certificate_profile = "signature/fileextension.p7b" + hap_name = "external_file_manager" + subsystem_name = "filemanagement" + part_name = "user_file_service" + module_install_dir = "app/com.ohos.UserFile.ExternalFileManager" +} + +ohos_js_assets("external_file_manager_js_assets") { + hap_profile = "file_extension_hap/entry/src/main/module.json" + ets2abc = true + source_dir = "file_extension_hap/entry/src/main/ets" +} + +ohos_app_scope("external_file_manager_app_profile") { + app_profile = "file_extension_hap/AppScope/app.json" + sources = [ "file_extension_hap/AppScope/resources" ] +} + +ohos_resources("external_file_manager_resources") { + sources = [ + "file_extension_hap/entry/src/main/resources", + ] + deps = [ + ":external_file_manager_app_profile", + ] + hap_profile = "file_extension_hap/entry/src/main/module.json" +} +### external file manager hap \ No newline at end of file diff --git a/services/file_extension_hap/AppScope/app.json b/services/file_extension_hap/AppScope/app.json new file mode 100644 index 00000000..9ed7e1ac --- /dev/null +++ b/services/file_extension_hap/AppScope/app.json @@ -0,0 +1,11 @@ +{ + "app": { + "bundleName": "com.ohos.UserFile.ExternalFileManager", + "versionCode": 100, + "versionName": "1.0.0", + "minAPIVersion": 9, + "targetAPIVersion": 9, + "icon": "$media:app_icon", + "label": "$string:app_name" + } +} diff --git a/services/file_extension_hap/AppScope/resources/base/element/string.json b/services/file_extension_hap/AppScope/resources/base/element/string.json new file mode 100644 index 00000000..bdb9ac36 --- /dev/null +++ b/services/file_extension_hap/AppScope/resources/base/element/string.json @@ -0,0 +1,8 @@ +{ + "string": [ + { + "name": "app_name", + "value": "ExternalFileManager" + } + ] +} diff --git a/services/file_extension_hap/AppScope/resources/base/media/app_icon.png b/services/file_extension_hap/AppScope/resources/base/media/app_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..ce307a8827bd75456441ceb57d530e4c8d45d36c GIT binary patch literal 6790 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 { + let flag = FLAG.SUPPORTS_WRITE | FLAG.SUPPORTS_DELETE | FLAG.SUPPORTS_RENAME | FLAG.SUPPORTS_COPY + | FLAG.SUPPORTS_MOVE | FLAG.SUPPORTS_REMOVE | FLAG.DIR_SUPPORTS_CREATE | FLAG.DIR_PREFERS_LAST_MODIFIED; + for (let i = 0; i < volumes.length; i++) { + let volume = volumes[i]; + let volumeInfo = { + 'volumeId': volume.id, + 'fsUuid': volume.uuid, + 'path': volume.path, + 'uri': path2uri(volume.id, volume.path), + 'displayName': volume.id, + 'deviceId': '', + 'flags': flag, + 'type': 'SD' + } + globalThis.volumeInfoList.push(volumeInfo); + } + }); + + } catch (err) { + hilog.debug(0x0001, 'jsserver', "err============>" + err); + } +} + +function addVolumeInfo(volumeInfo) { + globalThis.volumeInfoList.push(volumeInfo); +} + +function path2uri(id, path) { + return `fileAccess://${id}/${path}`; +} + +function delVolumeInfo(volumeId) { + globalThis.volumeInfoList = globalThis.volumeInfoList.filter((volume) => volume.volumeId !== volumeId); +} + +function getVolumeInfo(volumeId) { + let volumeInfo = globalThis.volumeInfoList.filter((volume) => volume.volumeId === volumeId); + return volumeInfo; +} + +function getVolumeInfoList() { + return globalThis.volumeInfoList; +} + +function notifyChange() { + +} +export { init, addVolumeInfo, delVolumeInfo, getVolumeInfoList, path2uri } \ No newline at end of file diff --git a/services/file_extension_hap/entry/src/main/module.json b/services/file_extension_hap/entry/src/main/module.json new file mode 100644 index 00000000..20916b6a --- /dev/null +++ b/services/file_extension_hap/entry/src/main/module.json @@ -0,0 +1,25 @@ +{ + "module": { + "name": "entry", + "type": "entry", + "srcEntrance": "./ets/Application/AbilityStage.ts", + "mainElement": "FileExtensionAbility", + "deviceTypes": [ + "phone", + "tablet" + ], + "deliveryWithInstall": true, + "installationFree": false, + "pages": "$profile:main_pages", + "uiSyntax": "ets", + "abilities": [], + "extensionAbilities": [ + { + "srcEntrance": "./ets/FileExtensionAbility/FileExtensionAbility.ts", + "name": "FileExtensionAbility", + "type": "fileAccess", + "visible": true + } + ] + } +} \ No newline at end of file diff --git a/services/file_extension_hap/entry/src/main/resources/base/element/string.json b/services/file_extension_hap/entry/src/main/resources/base/element/string.json new file mode 100644 index 00000000..c4e8611b --- /dev/null +++ b/services/file_extension_hap/entry/src/main/resources/base/element/string.json @@ -0,0 +1,12 @@ +{ + "string": [ + { + "name": "entry_desc", + "value": "description" + }, + { + "name": "description_serviceability", + "value": "description_serviceability" + } + ] +} \ No newline at end of file diff --git a/services/file_extension_hap/entry/src/main/resources/base/media/icon.png b/services/file_extension_hap/entry/src/main/resources/base/media/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..ce307a8827bd75456441ceb57d530e4c8d45d36c GIT binary patch literal 6790 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 Date: Wed, 22 Jun 2022 11:10:46 +0800 Subject: [PATCH 3/4] clean codecheck Signed-off-by: wangjianqiang --- frameworks/innerkits/file_access/src/file_ext_stub.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/frameworks/innerkits/file_access/src/file_ext_stub.cpp b/frameworks/innerkits/file_access/src/file_ext_stub.cpp index 1dfa9adc..660be1b4 100644 --- a/frameworks/innerkits/file_access/src/file_ext_stub.cpp +++ b/frameworks/innerkits/file_access/src/file_ext_stub.cpp @@ -222,7 +222,8 @@ ErrCode FileExtStub::CmdMove(MessageParcel &data, MessageParcel &reply) return ERR_INVALID_VALUE; } - HILOG_INFO("tag dsa %{public}s end. ret:%d, newFileUri = %{public}s", __func__, ret, fileUriNew->ToString().c_str()); + HILOG_INFO("tag dsa %{public}s end. ret:%d, newFileUri = %{public}s", __func__, + ret, fileUriNew->ToString().c_str()); return NO_ERROR; } -- Gitee From 4a13bb530b2b71ea794e574e948ddd1eef3119ca Mon Sep 17 00:00:00 2001 From: wangjianqiang Date: Wed, 22 Jun 2022 11:40:51 +0800 Subject: [PATCH 4/4] add delete funtion Signed-off-by: wangjianqiang --- .../FileExtensionAbility.ts | 30 ++++++++++++------- 1 file changed, 20 insertions(+), 10 deletions(-) diff --git a/services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/FileExtensionAbility.ts b/services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/FileExtensionAbility.ts index 741e2906..79678aff 100644 --- a/services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/FileExtensionAbility.ts +++ b/services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/FileExtensionAbility.ts @@ -13,7 +13,6 @@ * limitations under the License. */ import Extension from '@ohos.application.FileExtensionAbility' -import uriClass from '@ohos.uri' import fileio from '@ohos.fileio' import hilog from '@ohos.hilog' import { init, addVolumeInfo, delVolumeInfo, path2uri, getVolumeInfoList } from './VolumeManager' @@ -48,8 +47,15 @@ export default class FileExtAbility extends Extension { } getPath(uri) { - let uriObj = new uriClass.URI(uri); - let path = uriObj.path; + let sep = '://'; + let arr = uri.split(sep); + if (arr.length < 2) { + return uri; + } + let path = uri.replace(arr[0] + sep, ''); + if (arr[1].indexOf('/') > 0) { + path = path.replace(arr[1].split('/')[0], ''); + } return path; } @@ -108,15 +114,15 @@ export default class FileExtAbility extends Extension { } catch (e) { hilog.debug(0x0001, 'jsserver', 'listDir dir.readSync catch' + e); hasNextFile = false; - cb(path); + cb(path, true); } } } else { - cb(path); + cb(path, false); } } catch (e) { hilog.debug(0x0001, 'jsserver', 'listDir catch ' + e + ' ' + path); - cb(path); + cb(path, true); } } @@ -150,7 +156,7 @@ export default class FileExtAbility extends Extension { fileio.openSync(path, 0o100, 0o666); return newFileUri; } catch (e) { - hilog.info(0x0001, 'jsserver', 'createFile catch' + e); + hilog.debug(0x0001, 'jsserver', 'createFile catch' + e); return ''; } } @@ -170,9 +176,13 @@ export default class FileExtAbility extends Extension { delete(selectFileUri) { let path = this.getPath(selectFileUri); let code = 0; - this.listDir(path, function (filePath) { + this.listDir(path, function (filePath, isDirectory) { try { - fileio.unlinkSync(filePath); + if (isDirectory) { + fileio.rmdirSync(filePath); + } else { + fileio.unlinkSync(filePath); + } } catch (e) { hilog.debug(0x0001, 'jsserver', 'delete catch' + e); code = -1; @@ -192,7 +202,7 @@ export default class FileExtAbility extends Extension { return newFileUri; } catch (e) { hilog.debug(0x0001, 'jsserver', 'rename catch' + e); - return 'abc'; + return ''; } } -- Gitee