diff --git a/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp b/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp index 3097ee4a4706ebd4fcf417733cb1eaa3eca8695c..e86cc1894823679ba11103a2e1c5a027429ee037 100644 --- a/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp +++ b/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp @@ -42,11 +42,13 @@ using namespace OHOS::FileManagement::LibN; namespace OHOS { namespace FileAccessFwk { namespace { - const std::string FILEACCESS_CLASS_NAME = "FileAccessHelper"; - static napi_ref g_constructorRef = nullptr; - constexpr uint32_t INITIAL_REFCOUNT = 1; - constexpr int COPY_EXCEPTION = -1; -} +const std::string FILEACCESS_CLASS_NAME = "FileAccessHelper"; +static napi_ref g_constructorRef = nullptr; +constexpr uint32_t INITIAL_REFCOUNT = 1; +constexpr int COPY_EXCEPTION = -1; +using CallbackExec = std::function; +using CallbackComplete = std::function; +} // namespace std::list> g_fileAccessHelperList; @@ -59,7 +61,7 @@ static napi_value FileAccessHelperConstructor(napi_env env, napi_callback_info i } napi_value thisVar = funcArg.GetThisVar(); - std::pair, int> createResult{nullptr, ERR_OK}; + std::pair, int> createResult { nullptr, ERR_OK }; bool isStageMode = false; napi_status status = AbilityRuntime::IsStageContext(env, funcArg.GetArg(PARAM0), isStageMode); if (status != napi_ok || !isStageMode) { @@ -94,13 +96,13 @@ static napi_value FileAccessHelperConstructor(napi_env env, napi_callback_info i } g_fileAccessHelperList.emplace_back(createResult.first); - auto finalize = [](napi_env env, void *data, void *hint) { - FileAccessHelper *objectInfo = static_cast(data); + auto finalize = [](napi_env env, void* data, void* hint) { + FileAccessHelper* objectInfo = static_cast(data); if (objectInfo != nullptr) { objectInfo->Release(); - g_fileAccessHelperList.remove_if([objectInfo](const std::shared_ptr &fileAccessHelper) { - return objectInfo == fileAccessHelper.get(); - }); + g_fileAccessHelperList.remove_if([objectInfo](const std::shared_ptr& fileAccessHelper) { + return objectInfo == fileAccessHelper.get(); + }); objectInfo = nullptr; } }; @@ -125,7 +127,7 @@ napi_value AcquireFileAccessHelperWrap(napi_env env, napi_callback_info info) if (funcArg.GetArgc() == NARG_CNT::ONE) { size_t requireArgc = ARGS_ONE; size_t argc = ARGS_ONE; - napi_value args[ARGS_ONE] = {nullptr}; + napi_value args[ARGS_ONE] = { nullptr }; if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) { return nullptr; } @@ -141,7 +143,7 @@ napi_value AcquireFileAccessHelperWrap(napi_env env, napi_callback_info info) } else if (funcArg.GetArgc() == NARG_CNT::TWO) { size_t requireArgc = ARGS_TWO; size_t argc = ARGS_TWO; - napi_value args[ARGS_TWO] = {nullptr}; + napi_value args[ARGS_TWO] = { nullptr }; if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) { return nullptr; } @@ -161,8 +163,8 @@ napi_value AcquireFileAccessHelperWrap(napi_env env, napi_callback_info info) return nullptr; } - FileAccessHelper *fileAccessHelper = nullptr; - if (napi_unwrap(env, result, (void **)&fileAccessHelper) != napi_ok) { + FileAccessHelper* fileAccessHelper = nullptr; + if (napi_unwrap(env, result, (void**)&fileAccessHelper) != napi_ok) { HILOG_ERROR("Faild to get fileAccessHelper"); return nullptr; } @@ -207,7 +209,7 @@ napi_value NAPI_GetFileAccessAbilityInfo(napi_env env, napi_callback_info info) return { env, err.GetNapiErr(env) }; } napi_value jsArray = WrapArrayWantToJS(env, *result); - return {env, jsArray}; + return { env, jsArray }; }; const std::string procedureName = "getFileAccessAbilityInfo"; NVal thisVar(env, funcArg.GetThisVar()); @@ -224,33 +226,19 @@ napi_value NAPI_GetFileAccessAbilityInfo(napi_env env, napi_callback_info info) napi_value FileAccessHelperInit(napi_env env, napi_value exports) { - 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("query", NAPI_Query), - DECLARE_NAPI_FUNCTION("copy", NAPI_Copy), - DECLARE_NAPI_FUNCTION("rename", NAPI_Rename), - DECLARE_NAPI_FUNCTION("getRoots", NAPI_GetRoots), + 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("query", NAPI_Query), DECLARE_NAPI_FUNCTION("copy", NAPI_Copy), + DECLARE_NAPI_FUNCTION("rename", NAPI_Rename), DECLARE_NAPI_FUNCTION("getRoots", NAPI_GetRoots), DECLARE_NAPI_FUNCTION("access", NAPI_Access), DECLARE_NAPI_FUNCTION("getFileInfoFromUri", NAPI_GetFileInfoFromUri), DECLARE_NAPI_FUNCTION("getFileInfoFromRelativePath", NAPI_GetFileInfoFromRelativePath), - DECLARE_NAPI_FUNCTION("getThumbnail", NAPI_GetThumbnail), - DECLARE_NAPI_FUNCTION("on", NAPI_RegisterObserver), - DECLARE_NAPI_FUNCTION("off", NAPI_UnregisterObserver) - }; + DECLARE_NAPI_FUNCTION("getThumbnail", NAPI_GetThumbnail), DECLARE_NAPI_FUNCTION("on", NAPI_RegisterObserver), + DECLARE_NAPI_FUNCTION("off", NAPI_UnregisterObserver) }; 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)); + 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, INITIAL_REFCOUNT, &g_constructorRef)); NAPI_CALL(env, napi_set_named_property(env, exports, FILEACCESS_CLASS_NAME.c_str(), cons)); @@ -259,20 +247,20 @@ napi_value FileAccessHelperInit(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("createFileAccessHelper", NAPI_CreateFileAccessHelper), DECLARE_NAPI_FUNCTION("getFileAccessAbilityInfo", NAPI_GetFileAccessAbilityInfo), }; - NAPI_CALL(env, napi_define_properties(env, exports, sizeof(export_properties) / sizeof(export_properties[0]), - export_properties)); + NAPI_CALL(env, napi_define_properties( + env, exports, sizeof(export_properties) / sizeof(export_properties[0]), export_properties)); return exports; } -static FileAccessHelper *GetFileAccessHelper(napi_env env, napi_value thisVar) +static FileAccessHelper* GetFileAccessHelper(napi_env env, napi_value thisVar) { if (thisVar == nullptr) { NError(EINVAL).ThrowErr(env); return nullptr; } - FileAccessHelper *fileAccessHelper = nullptr; - if (napi_unwrap(env, thisVar, (void **)&fileAccessHelper) != napi_ok) { + FileAccessHelper* fileAccessHelper = nullptr; + if (napi_unwrap(env, thisVar, (void**)&fileAccessHelper) != napi_ok) { NError(E_GETRESULT).ThrowErr(env); return nullptr; } @@ -284,9 +272,8 @@ static FileAccessHelper *GetFileAccessHelper(napi_env env, napi_value thisVar) return fileAccessHelper; } -static std::tuple, std::unique_ptr> GetReadArg(napi_env env, - napi_value sourceFile, - napi_value targetParent) +static std::tuple, std::unique_ptr> GetReadArg( + napi_env env, napi_value sourceFile, napi_value targetParent) { bool succ = false; std::unique_ptr uri = nullptr; @@ -329,7 +316,7 @@ napi_value NAPI_OpenFile(napi_env env, napi_callback_info info) return nullptr; } - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { return nullptr; } @@ -383,7 +370,7 @@ napi_value NAPI_CreateFile(napi_env env, napi_callback_info info) return nullptr; } - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { return nullptr; } @@ -440,7 +427,7 @@ napi_value NAPI_Mkdir(napi_env env, napi_callback_info info) return nullptr; } - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { return nullptr; } @@ -497,7 +484,7 @@ napi_value NAPI_Delete(napi_env env, napi_callback_info info) return nullptr; } - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { return nullptr; } @@ -551,7 +538,7 @@ napi_value NAPI_Move(napi_env env, napi_callback_info info) return nullptr; } - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { return nullptr; } @@ -610,7 +597,7 @@ napi_value NAPI_Query(napi_env env, napi_callback_info info) return nullptr; } - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { return nullptr; } @@ -657,7 +644,7 @@ static napi_value CreateObjectArray(napi_env env, std::vector result } for (size_t i = 0; i < result.size(); i++) { - CopyResult &tmpResult = result.at(i); + CopyResult& tmpResult = result.at(i); napi_value resultVal; status |= napi_create_object(env, &resultVal); napi_value tmpVal; @@ -678,7 +665,7 @@ static napi_value CreateObjectArray(napi_env env, std::vector result return copyResultArray; } -std::tuple GetCopyArguments(napi_env env, NFuncArg &funcArg) +static std::tuple GetCopyArguments(napi_env env, NFuncArg& funcArg) { bool retStatus = false; std::unique_ptr srcPath; @@ -688,8 +675,8 @@ std::tuple GetCopyArguments(napi_env env, HILOG_ERROR("Get first or second argument error"); return std::make_tuple(false, "", "", false); } - std::string srcPathStr (srcPath.get()); - std::string destPathStr (destPath.get()); + std::string srcPathStr(srcPath.get()); + std::string destPathStr(destPath.get()); bool force = false; if (funcArg.GetArgc() == NARG_CNT::THREE) { @@ -717,6 +704,35 @@ std::tuple GetCopyArguments(napi_env env, return std::make_tuple(true, srcPathStr, destPathStr, force); } +static napi_value AddNAsyncWork(napi_env env, NFuncArg& funcArg, CallbackExec cbExec, CallbackComplete cbComplete) +{ + const std::string procedureName = "copy"; + NVal thisVar(env, funcArg.GetThisVar()); + + if (funcArg.GetArgc() == NARG_CNT::TWO) { + return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_; + } + + if (funcArg.GetArgc() == NARG_CNT::THREE) { + NVal thirdArg(env, funcArg[NARG_POS::THIRD]); + if (thirdArg.TypeIs(napi_boolean) || thirdArg.TypeIs(napi_undefined)) { + return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_; + } + if (thirdArg.TypeIs(napi_function)) { + return NAsyncWorkCallback(env, thisVar, thirdArg).Schedule(procedureName, cbExec, cbComplete).val_; + } + NError(EINVAL).ThrowErr(env); + return nullptr; + } + + NVal cb(env, funcArg[NARG_POS::FOURTH]); + if (!cb.TypeIs(napi_function)) { + NError(EINVAL).ThrowErr(env); + return nullptr; + } + return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_; +} + napi_value NAPI_Copy(napi_env env, napi_callback_info info) { NFuncArg funcArg(env, info); @@ -735,7 +751,7 @@ napi_value NAPI_Copy(napi_env env, napi_callback_info info) return nullptr; } - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { return nullptr; } @@ -745,7 +761,6 @@ napi_value NAPI_Copy(napi_env env, napi_callback_info info) NError(E_GETRESULT).ThrowErr(env); return nullptr; } - int ret = ERR_OK; auto cbExec = [srcPathStr, destPathStr, force, result, &ret, fileAccessHelper]() -> NError { OHOS::Uri srcUri(srcPathStr); @@ -763,31 +778,7 @@ napi_value NAPI_Copy(napi_env env, napi_callback_info info) return { env, CreateObjectArray(env, *result) }; }; - const std::string procedureName = "copy"; - NVal thisVar(env, funcArg.GetThisVar()); - - if (funcArg.GetArgc() == NARG_CNT::TWO) { - return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_; - } - - if (funcArg.GetArgc() == NARG_CNT::THREE) { - NVal thirdArg(env, funcArg[NARG_POS::THIRD]); - if (thirdArg.TypeIs(napi_boolean) || thirdArg.TypeIs(napi_undefined)) { - return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_; - } - if (thirdArg.TypeIs(napi_function)) { - return NAsyncWorkCallback(env, thisVar, thirdArg).Schedule(procedureName, cbExec, cbComplete).val_; - } - NError(EINVAL).ThrowErr(env); - return nullptr; - } - - NVal cb(env, funcArg[NARG_POS::FOURTH]); - if (!cb.TypeIs(napi_function)) { - NError(EINVAL).ThrowErr(env); - return nullptr; - } - return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_; + return AddNAsyncWork(env, funcArg, cbExec, cbComplete); } napi_value NAPI_Rename(napi_env env, napi_callback_info info) @@ -806,7 +797,7 @@ napi_value NAPI_Rename(napi_env env, napi_callback_info info) return nullptr; } - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { return nullptr; } @@ -847,7 +838,7 @@ napi_value NAPI_Rename(napi_env env, napi_callback_info info) return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_; } -static int MakeGetRootsResult(napi_env &env, FileAccessHelper *helper, std::vector &rootInfoVec, NVal &nVal) +static int MakeGetRootsResult(napi_env& env, FileAccessHelper* helper, std::vector& rootInfoVec, NVal& nVal) { auto objRootIterator = NClass::InstantiateClass(env, NapiRootIteratorExporter::className_, {}); if (objRootIterator == nullptr) { @@ -878,7 +869,7 @@ napi_value NAPI_GetRoots(napi_env env, napi_callback_info info) return nullptr; } - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { NError(E_GETRESULT).ThrowErr(env); return nullptr; @@ -903,8 +894,8 @@ napi_value NAPI_GetRoots(napi_env env, napi_callback_info info) int ret = MakeGetRootsResult(env, fileAccessHelper, *result, nVal); if (ret != ERR_OK) { return { env, NError([ret]() -> std::tuple { - return { ret, "Make GetRoots Result fail" }; - }).GetNapiErr(env) }; + return { ret, "Make GetRoots Result fail" }; + }).GetNapiErr(env) }; } return nVal; @@ -940,7 +931,7 @@ napi_value NAPI_Access(napi_env env, napi_callback_info info) return nullptr; } - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { return nullptr; } @@ -974,7 +965,7 @@ napi_value NAPI_Access(napi_env env, napi_callback_info info) return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_; } -static int MakeFileInfoResult(napi_env &env, FileAccessHelper *helper, FileInfo &fileinfo, NVal &nVal) +static int MakeFileInfoResult(napi_env& env, FileAccessHelper* helper, FileInfo& fileinfo, NVal& nVal) { auto objFileInfo = NClass::InstantiateClass(env, NapiFileInfoExporter::className_, {}); if (objFileInfo == nullptr) { @@ -1010,7 +1001,7 @@ napi_value NAPI_GetFileInfoFromUri(napi_env env, napi_callback_info info) return nullptr; } - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { return nullptr; } @@ -1036,8 +1027,8 @@ napi_value NAPI_GetFileInfoFromUri(napi_env env, napi_callback_info info) int ret = MakeFileInfoResult(env, fileAccessHelper, *result, nVal); if (ret != ERR_OK) { return { env, NError([ret]() -> std::tuple { - return { ret, "Make FileInfo Result fail" }; - }).GetNapiErr(env) }; + return { ret, "Make FileInfo Result fail" }; + }).GetNapiErr(env) }; } return nVal; @@ -1072,7 +1063,7 @@ napi_value NAPI_GetFileInfoFromRelativePath(napi_env env, napi_callback_info inf return nullptr; } - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { return nullptr; } @@ -1098,8 +1089,8 @@ napi_value NAPI_GetFileInfoFromRelativePath(napi_env env, napi_callback_info inf int ret = MakeFileInfoResult(env, fileAccessHelper, *result, nVal); if (ret != ERR_OK) { return { env, NError([ret]() -> std::tuple { - return { ret, "Make FileInfo Result fail" }; - }).GetNapiErr(env) }; + return { ret, "Make FileInfo Result fail" }; + }).GetNapiErr(env) }; } return nVal; @@ -1118,7 +1109,7 @@ napi_value NAPI_GetFileInfoFromRelativePath(napi_env env, napi_callback_info inf return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_; } -static bool parseGetThumbnailArgs(napi_env env, NFuncArg &nArg, std::string &uri, ThumbnailSize &thumbnailSize) +static bool parseGetThumbnailArgs(napi_env env, NFuncArg& nArg, std::string& uri, ThumbnailSize& thumbnailSize) { bool succ = false; std::unique_ptr uriPtr; @@ -1165,7 +1156,7 @@ napi_value NAPI_GetThumbnail(napi_env env, napi_callback_info info) return nullptr; } - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { NError(EINVAL).ThrowErr(env); return nullptr; @@ -1206,7 +1197,7 @@ struct FileObserverCallbackWrapper { sptr callback; }; -static bool parseRegisterObserverArgs(napi_env env, NFuncArg &funcArg, std::string &uri, bool ¬ifyForDescendants) +static bool parseRegisterObserverArgs(napi_env env, NFuncArg& funcArg, std::string& uri, bool& notifyForDescendants) { bool succ = false; std::unique_ptr uriPtr; @@ -1252,8 +1243,8 @@ napi_value NAPI_RegisterObserver(napi_env env, napi_callback_info info) return nullptr; } - auto finalize = [](napi_env env, void *data, void *hint) { - FileObserverCallbackWrapper *observerWrapper = static_cast(data); + auto finalize = [](napi_env env, void* data, void* hint) { + FileObserverCallbackWrapper* observerWrapper = static_cast(data); if (observerWrapper != nullptr) { delete observerWrapper; } @@ -1267,7 +1258,7 @@ napi_value NAPI_RegisterObserver(napi_env env, napi_callback_info info) } observerWrapper.release(); - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { return nullptr; } @@ -1304,7 +1295,7 @@ napi_value NAPI_UnregisterObserver(napi_env env, napi_callback_info info) } std::unique_ptr observerWrapper; - if (napi_unwrap(env, napiCallback, (void **)&(observerWrapper)) != napi_ok) { + if (napi_unwrap(env, napiCallback, (void**)&(observerWrapper)) != napi_ok) { NError(EINVAL).ThrowErr(env); return nullptr; } @@ -1314,7 +1305,7 @@ napi_value NAPI_UnregisterObserver(napi_env env, napi_callback_info info) } auto wrapper = observerWrapper.release(); - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + FileAccessHelper* fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { return nullptr; } diff --git a/interfaces/inner_api/file_access/include/file_access_helper.h b/interfaces/inner_api/file_access/include/file_access_helper.h index 80fe58d6e9313ae73faeed0fa64205aa6109288c..e08c07b4138a752ebcd7a4a54e17c76e56bb9dfc 100644 --- a/interfaces/inner_api/file_access/include/file_access_helper.h +++ b/interfaces/inner_api/file_access/include/file_access_helper.h @@ -105,6 +105,12 @@ private: std::shared_ptr GetConnectInfo(const std::string &bundleName); int CopyInsideService(Uri &sourceUri, Uri &destUri, std::vector ©Result, bool force = false); + int GetCopyResult(const std::string &sourceUri, const std::string &destUri, int errCode, const std::string &errMsg, + std::vector ©Result); + int TranslateCopyResult(int errCode, CopyResult ©Result); + int IsDirectory(Uri &uri, bool &isDir); + bool IsExternalUri(Uri &uri); + bool IsMediaUri(Uri &uri); sptr token_ = nullptr; std::unordered_map> cMap_; diff --git a/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h b/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h index 79e0eb1e40bdac2a16c507b1763a1d8db8af20be..fdedf002f2dc260390d6364650c50f1339485b3f 100644 --- a/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h +++ b/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h @@ -65,6 +65,7 @@ public: int Mkdir(const Uri &parent, const std::string &displayName, Uri &newFile) override; int Delete(const Uri &sourceFile) override; int Move(const Uri &sourceFile, const Uri &targetParent, Uri &newFile) override; + int Copy(const Uri &sourceUri, const Uri &destUri, std::vector ©Result, bool force = false) override; int Rename(const Uri &sourceFile, const std::string &displayName, Uri &newFile) override; int ListFile(const FileInfo &fileInfo, const int64_t offset, const int64_t maxCount, const FileFilter &filter, std::vector &fileInfoVec) override; diff --git a/interfaces/inner_api/file_access/src/file_access_ext_proxy.cpp b/interfaces/inner_api/file_access/src/file_access_ext_proxy.cpp index 130b4ab3469d0f722dc31f5d0f9240876e996561..87708f0db1000225209c672a68f0d52b0a3bab65 100644 --- a/interfaces/inner_api/file_access/src/file_access_ext_proxy.cpp +++ b/interfaces/inner_api/file_access/src/file_access_ext_proxy.cpp @@ -318,17 +318,9 @@ int FileAccessExtProxy::Move(const Uri &sourceFile, const Uri &targetParent, Uri return ERR_OK; } -int FileAccessExtProxy::Copy(const Uri &sourceUri, const Uri &destUri, std::vector ©Result, - bool force) +static int WriteCopyFuncArguments(OHOS::MessageParcel &data, const Uri &sourceUri, const Uri &destUri, bool force) { - StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Copy"); - MessageParcel data; - if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) { - HILOG_ERROR("WriteInterfaceToken failed"); - FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return E_IPCS; - } - + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "WriteCopyFuncArguments"); std::string insideInputSourceUri = sourceUri.ToString(); if (!data.WriteString(insideInputSourceUri)) { HILOG_ERROR("fail to WriteParcelable insideInputSourceUri"); @@ -348,16 +340,13 @@ int FileAccessExtProxy::Copy(const Uri &sourceUri, const Uri &destUri, std::vect FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return E_IPCS; } + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} - MessageParcel reply; - MessageOption option; - int err = Remote()->SendRequest(CMD_COPY, data, reply, option); - if (err != ERR_OK) { - HILOG_ERROR("fail to SendRequest. err: %{public}d", err); - FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return err; - } - +static int ReadCopyFuncResults(OHOS::MessageParcel &reply, std::vector ©Result) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "ReadCopyFuncResults"); int ret = E_IPCS; if (!reply.ReadInt32(ret)) { HILOG_ERROR("fail to ReadInt32 ret"); @@ -367,7 +356,7 @@ int FileAccessExtProxy::Copy(const Uri &sourceUri, const Uri &destUri, std::vect if (ret == ERR_OK) { HILOG_ERROR("Copy operation success"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return ERR_OK; + return ret; } uint32_t count = 0; @@ -392,6 +381,43 @@ int FileAccessExtProxy::Copy(const Uri &sourceUri, const Uri &destUri, std::vect copyResult.push_back(*copyResultPtr); } } + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; +} + +int FileAccessExtProxy::Copy(const Uri &sourceUri, const Uri &destUri, std::vector ©Result, + bool force) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Copy"); + MessageParcel data; + if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) { + HILOG_ERROR("WriteInterfaceToken failed"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + int ret = WriteCopyFuncArguments(data, sourceUri, destUri, force); + if (ret != ERR_OK) { + HILOG_ERROR("Write copy function arguments error, code: %{public}d", ret); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; + } + + MessageParcel reply; + MessageOption option; + int err = Remote()->SendRequest(CMD_COPY, data, reply, option); + if (err != ERR_OK) { + HILOG_ERROR("fail to SendRequest, err: %{public}d", err); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return err; + } + + ret = ReadCopyFuncResults(reply, copyResult); + if (ret != ERR_OK) { + HILOG_ERROR("Read copy function result error, code: %{public}d", ret); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; + } FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ret; diff --git a/interfaces/inner_api/file_access/src/file_access_helper.cpp b/interfaces/inner_api/file_access/src/file_access_helper.cpp index df45fb58f25f88bcbd84a871c604c26afcf02477..5ca6efd5f4c07dfa9cee22e177d1b60416143da4 100644 --- a/interfaces/inner_api/file_access/src/file_access_helper.cpp +++ b/interfaces/inner_api/file_access/src/file_access_helper.cpp @@ -646,7 +646,7 @@ int FileAccessHelper::Move(Uri &sourceFile, Uri &targetParent, Uri &newFile) return ERR_OK; } -static bool IsMediaUri(Uri &uri) +bool FileAccessHelper::IsMediaUri(Uri &uri) { string scheme = uri.GetScheme(); if (scheme == FILE_SCHEME_NAME) { @@ -655,7 +655,34 @@ static bool IsMediaUri(Uri &uri) return false; } -static int ThrowExceptionByErrorCode(int errCode, CopyResult ©Result) +bool FileAccessHelper::IsExternalUri(Uri &uri) +{ + string scheme = uri.GetScheme(); + if (scheme == FILE_SCHEME_NAME) { + return uri.GetAuthority() == EXTERNAL_BNUDLE_NAME; + } + return false; +} + +int FileAccessHelper::IsDirectory(Uri &uri, bool &isDir) +{ + sptr proxy = FileAccessHelper::GetProxyByUri(uri); + if (proxy == nullptr) { + HILOG_ERROR("failed with invalid fileAccessExtProxy"); + return E_IPCS; + } + + FileInfo fileInfo; + int ret = proxy->GetFileInfoFromUri(uri, fileInfo); + if (ret != ERR_OK) { + HILOG_ERROR("get FileInfo from uri error, code:%{public}d", ret); + return ret; + } + isDir = (fileInfo.mode & DOCUMENT_FLAG_REPRESENTS_DIR) != 0; + return ret; +} + +int FileAccessHelper::TranslateCopyResult(int errCode, CopyResult &result) { if (errCode == COPY_EXCEPTION || errCode == ERR_OK) { return errCode; @@ -666,6 +693,7 @@ static int ThrowExceptionByErrorCode(int errCode, CopyResult ©Result) case E_IPCS: case E_URIS: case ERR_NOMEM: + case E_PERMISSION_SYS: case ERR_PERM: { HILOG_ERROR("Copy exception, terminate copy"); ret = COPY_EXCEPTION; @@ -679,12 +707,22 @@ static int ThrowExceptionByErrorCode(int errCode, CopyResult ©Result) } if (OHOS::FileManagement::LibN::errCodeTable.find(errCode) != OHOS::FileManagement::LibN::errCodeTable.end()) { - copyResult.errCode = OHOS::FileManagement::LibN::errCodeTable.at(errCode).first; - copyResult.errMsg = OHOS::FileManagement::LibN::errCodeTable.at(errCode).second; + result.errCode = OHOS::FileManagement::LibN::errCodeTable.at(errCode).first; + result.errMsg = OHOS::FileManagement::LibN::errCodeTable.at(errCode).second; } return ret; } +int FileAccessHelper::GetCopyResult(const std::string &sourceUri, const std::string &destUri, int errCode, + const std::string &errMsg, std::vector ©Result) +{ + CopyResult result { sourceUri, destUri, errCode, errMsg }; + int ret = TranslateCopyResult(errCode, result); + copyResult.clear(); + copyResult.push_back(result); + return ret; +} + int FileAccessHelper::CopyInsideService(Uri &sourceUri, Uri &destUri, std::vector ©Result, bool force) { StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CopyInsideService"); @@ -694,23 +732,24 @@ int FileAccessHelper::CopyInsideService(Uri &sourceUri, Uri &destUri, std::vecto HILOG_ERROR("Failed with invalid fileAccessExtProxy"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); CopyResult result; - ret = ThrowExceptionByErrorCode(E_IPCS, result); + ret = TranslateCopyResult(E_IPCS, result); copyResult.push_back(result); return ret; } ret = proxy->Copy(sourceUri, destUri, copyResult, force); if (ret != ERR_OK) { - HILOG_ERROR("Copy error, code:%{public}d", ret); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); if ((ret == COPY_EXCEPTION) || (ret == COPY_NOEXCEPTION)) { HILOG_ERROR("Copy exception, code:%{public}d", ret); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ret; } - CopyResult result { "", "", ret, ""}; + HILOG_ERROR("Copy error, code:%{public}d", ret); + CopyResult result { "", "", ret, "" }; + ret = TranslateCopyResult(ret, result); copyResult.push_back(result); - return COPY_EXCEPTION; + return ret; } FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ret; @@ -720,29 +759,38 @@ int FileAccessHelper::Copy(Uri &sourceUri, Uri &destUri, std::vector { StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Copy"); if (!IsSystemApp()) { - HILOG_ERROR("FileAccessHelper::Copy check IsSystemAppByFullTokenID failed"); + HILOG_ERROR("Copy check IsSystemAppByFullTokenID failed"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - CopyResult result { sourceUri.ToString(), destUri.ToString(), E_PERMISSION_SYS, "" }; - copyResult.push_back(result); - return COPY_EXCEPTION; + return GetCopyResult("", "", E_PERMISSION_SYS, "", copyResult); } if (!CheckUri(sourceUri) || !CheckUri(destUri)) { HILOG_ERROR("Uri format check error"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - CopyResult result { sourceUri.ToString(), destUri.ToString(), E_URIS, "" }; - copyResult.push_back(result); + return GetCopyResult("", "", E_URIS, "", copyResult); + } + + bool isDir = false; + int ret = IsDirectory(destUri, isDir); + if (ret != ERR_OK) { + HILOG_ERROR("Get uri type error"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + GetCopyResult("", "", ret, "", copyResult); return COPY_EXCEPTION; } + if (!isDir) { + HILOG_ERROR("Destination uri is not directory"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return GetCopyResult("", "", E_URIS, "", copyResult); + } - int ret = COPY_EXCEPTION; - if (IsMediaUri(sourceUri) && IsMediaUri(destUri)) { + ret = COPY_EXCEPTION; + if ((IsMediaUri(sourceUri) && IsMediaUri(destUri)) + || (IsExternalUri(sourceUri) && IsExternalUri(destUri))) { ret = CopyInsideService(sourceUri, destUri, copyResult, force); } else { - HILOG_ERROR("External storage copy is not supported."); - CopyResult result { sourceUri.ToString(), destUri.ToString(), EPERM, "" }; - copyResult.push_back(result); - return COPY_NOEXCEPTION; + HILOG_ERROR("Unsupported copy service, invalid uri"); + return GetCopyResult("", "", E_URIS, "", copyResult); } FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ret; diff --git a/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp b/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp index 694d86b05e2248520aee5a06cecde5e523fa0342..42614a05e6ad36c71f5d11b1d29f06cac48b68fe 100644 --- a/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp +++ b/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp @@ -32,6 +32,7 @@ #include "napi_common_util.h" #include "napi_common_want.h" #include "napi_remote_object.h" +#include "n_error.h" namespace OHOS { namespace FileAccessFwk { @@ -42,10 +43,13 @@ namespace { constexpr size_t ARGC_THREE = 3; constexpr size_t ARGC_FOUR = 4; constexpr size_t MAX_ARG_COUNT = 5; + constexpr int COPY_EXCEPTION = -1; + constexpr int COPY_NOEXCEPTION = -2; } using namespace OHOS::AppExecFwk; using namespace OHOS::AbilityRuntime; +using namespace OHOS::FileManagement::LibN; using OHOS::Security::AccessToken::AccessTokenKit; struct FilterParam { @@ -590,6 +594,121 @@ int JsFileAccessExtAbility::Move(const Uri &sourceFile, const Uri &targetParent, return ERR_OK; } +static void TranslateCopyResult(CopyResult ©Result) +{ + if (errCodeTable.find(copyResult.errCode) != errCodeTable.end()) { + copyResult.errCode = errCodeTable.at(copyResult.errCode).first; + if (copyResult.errMsg.empty()) { + copyResult.errMsg = errCodeTable.at(copyResult.errCode).second; + } + } +} + +static bool ParserGetJsCopyResult(NativeEngine &engine, NativeValue *nativeValue, + std::vector ©Result, int ©Ret) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "ParserGetJsCopyResult"); + NativeObject *obj = ConvertNativeValueTo(nativeValue); + if (obj == nullptr) { + HILOG_ERROR("Convert js object fail."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return false; + } + + bool ret = ConvertFromJsValue(engine, obj->GetProperty("code"), copyRet); + if (!ret) { + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + HILOG_ERROR("Convert js value fail."); + return false; + } + if (copyRet == ERR_OK) { + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + HILOG_ERROR("copyRet == ERR_OK"); + return true; + } + + NativeArray *nativeArray = ConvertNativeValueTo(obj->GetProperty("results")); + if (nativeArray == nullptr) { + HILOG_ERROR("nativeArray is nullptr"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return false; + } + + for (uint32_t i = 0; i < nativeArray->GetLength(); i++) { + NativeValue *nativeCopyResult = nativeArray->GetElement(i); + if (nativeCopyResult == nullptr) { + HILOG_ERROR("get native FileInfo fail."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return false; + } + obj = ConvertNativeValueTo(nativeCopyResult); + if (obj == nullptr) { + HILOG_ERROR("Convert js object fail."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return false; + } + + CopyResult result; + if (copyRet == COPY_NOEXCEPTION) { + ret = ret && ConvertFromJsValue(engine, obj->GetProperty("sourceUri"), result.sourceUri); + ret = ret && ConvertFromJsValue(engine, obj->GetProperty("destUri"), result.destUri); + } + if ((copyRet == COPY_NOEXCEPTION) || (copyRet == COPY_EXCEPTION)) { + ret = ret && ConvertFromJsValue(engine, obj->GetProperty("errCode"), result.errCode); + } + if (!ret) { + HILOG_ERROR("Convert js value fail."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; + } + + TranslateCopyResult(result); + copyResult.push_back(result); + } + + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return true; +} + +int JsFileAccessExtAbility::Copy(const Uri &sourceUri, const Uri &destUri, std::vector ©Result, + bool force) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Copy"); + auto argParser = [sourceUri, destUri, force](NativeEngine &engine, NativeValue* argv[], size_t &argc) -> bool { + NativeValue *srcNativeUri = engine.CreateString(sourceUri.ToString().c_str(), + sourceUri.ToString().length()); + NativeValue *dstNativeUri = engine.CreateString(destUri.ToString().c_str(), destUri.ToString().length()); + NativeValue *forceCopy = engine.CreateBoolean(force); + if (srcNativeUri == nullptr || dstNativeUri == nullptr || forceCopy == nullptr) { + HILOG_ERROR("create arguments native js value fail."); + return false; + } + argv[ARGC_ZERO] = srcNativeUri; + argv[ARGC_ONE] = dstNativeUri; + argv[ARGC_TWO] = forceCopy; + argc = ARGC_THREE; + return true; + }; + + int copyRet = COPY_EXCEPTION; + auto retParser = [©Result, ©Ret](NativeEngine &engine, NativeValue *result) -> bool { + return ParserGetJsCopyResult(engine, result, copyResult, copyRet); + }; + + auto errCode = CallJsMethod("copy", jsRuntime_, jsObj_.get(), argParser, retParser); + if (errCode != ERR_OK) { + HILOG_ERROR("CallJsMethod error, code:%{public}d.", errCode); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + CopyResult result { "", "", errCode, ""}; + TranslateCopyResult(result); + copyResult.push_back(result); + return COPY_EXCEPTION; + } + + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return copyRet; +} + int JsFileAccessExtAbility::Rename(const Uri &sourceFile, const std::string &displayName, Uri &newFile) { StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Rename"); 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 b4cb8deaa1eae4ce6873d349483759cbd272864d..5feccbbac36277453bb8e38d51da70fb6a7199dc 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 @@ -29,9 +29,13 @@ const FILE_PREFIX_NAME = 'file://'; const TAG = 'ExternalFileManager'; const ERR_OK = 0; const ERR_ERROR = -1; -const E_EXIST = 13900015; -const ERR_PERM = 13900001; +const COPY_EXCEPTION = -1; +const COPY_NOEXCEPTION = -2; +const E_PERM = 13900001; const E_NOEXIST = 13900002; +const E_FAULT = 13900013; +const E_EXIST = 13900015; +const E_INVAL = 13900020; const E_URIS = 14300002; const E_GETRESULT = 14300004; const CREATE_EVENT_CODE = 0x00000100; @@ -379,7 +383,7 @@ export default class FileExtAbility extends Extension { //Cross device move not currently supported return { uri: '', - code: ERR_PERM, + code: E_PERM, }; } catch (e) { hilog.error(DOMAIN_CODE, TAG, 'move error ' + e.message); @@ -424,6 +428,179 @@ export default class FileExtAbility extends Extension { } } + getCopyReturnValue(sourceUri, destUri, errCode, errMsg, ret): {[], number} { + let copyResult = [ + { + sourceUri: sourceUri, + destUri: destUri, + errCode: errCode, + errMsg: errMsg, + }, + ]; + return { + results: copyResult, + code: ret, + }; + } + + processCopyReturnValue(ret, copyRet) + { + if (ret.code == COPY_EXCEPTION) { + copyRet = ret; + } + if (ret.code == COPY_NOEXCEPTION) { + for (let index in ret.results) { + copyRet.results.push(ret.results[index]); + } + copyRet.code = ret.code; + } + } + + checkCopyArguments(sourceFileUri, targetParentUri): {[], number} { + if (!this.checkUri(sourceFileUri) || !this.checkUri(targetParentUri)) { + hilog.error(DOMAIN_CODE, TAG, 'check arguments error, invalid arguments'); + return this.getCopyReturnValue('', '', E_URIS, '', COPY_EXCEPTION); + } + + let displayName = this.getFileName(sourceFileUri); + let newFileOrDirUri = this.genNewFileUri(targetParentUri, displayName); + let oldPath = getPath(sourceFileUri); + let newPath = getPath(newFileOrDirUri); + if (oldPath === newPath) { + hilog.error(DOMAIN_CODE, TAG, 'the source and target files are the same file'); + return this.getCopyReturnValue(sourceFileUri, targetParentUri, E_INVAL, '', COPY_NOEXCEPTION); + } else if (newPath.indexOf(oldPath) === 0 && newPath[oldPath.length] === '/')) { + hilog.error(DOMAIN_CODE, TAG, 'copy to a subdirectory of the source directory'); + return this.getCopyReturnValue('', '', E_FAULT, '', COPY_EXCEPTION); + } + + try { + let isExist = fs.accessSync(oldPath); + if (!isExist) { + hilog.error(DOMAIN_CODE, TAG, 'source uri is not exist, invalid arguments'); + return this.getCopyReturnValue(sourceFileUri, '', E_INVAL, '', COPY_NOEXCEPTION); + } + + let stat = fs.statSync(getPath(targetParentUri)); + if (!stat || !stat.isDirectory()) { + hilog.error(DOMAIN_CODE, TAG, 'target is not directory, invalid arguments'); + return this.getCopyReturnValue('', targetParentUri, E_INVAL, '', COPY_NOEXCEPTION); + } + } catch (e) { + hilog.error(DOMAIN_CODE, TAG, 'copy error ' + e.message); + return this.getCopyReturnValue('', '', e.code, '', COPY_EXCEPTION); + } + return { + results: [], + code: ERR_OK, + } + } + + doCopyProcess(copyContext, isDirectory): {[], number} { + let sourcePath = copyContext.sourcePath; + let destPath = sourcePath.replace(copyContext.oldPath, copyContext.newPath); + if (isDirectory) { + try { + let isExist = fs.accessSync(destPath); + if (!isExist) { + fs.mkdirSync(destPath); + } + } catch (e) { + hilog.error(DOMAIN_CODE, TAG, 'copy directory error ' + e.message); + return this.getCopyReturnValue('', '', e.code, '', COPY_EXCEPTION); + } + } else { + try { + let isExist = fs.accessSync(destPath); + if (!isExist || copyContext.force) { + try { + let srcFile = fs.openSync(sourcePath, fs.OpenMode.READ_ONLY); + let newFile = fs.openSync(destPath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); + fs.copyFileSync(srcFile.fd, newFile.fd); + fs.closeSync(srcFile); + fs.closeSync(newFile); + } catch (e) { + fs.closeSync(srcFile); + fs.closeSync(newFIle); + return this.getCopyReturnValue(sourceFileUri, '', e.code, e.message, COPY_EXCEPTION); + } + } else { + let sourceFileUri = FILE_PREFIX_NAME + BUNDLE_NAME + sourcePath; + let destFileUri = FILE_PREFIX_NAME + BUNDLE_NAME + destPath; + return this.getCopyReturnValue(sourceFileUri, destFileUri, E_EXIST, '', COPY_NOEXCEPTION); + } + } catch (e) { + hilog.error(DOMAIN_CODE, TAG, 'copy file error ' + e.message); + return this.getCopyReturnValue('', '', e.code, '', COPY_EXCEPTION); + } + } + return this.getCopyReturnValue('', '', ERR_OK, '', ERR_OK); + } + + copyOperation(copyContext): {[], number} { + let copyRet = { + results: [], + code: ERR_OK, + }; + + try { + let stat = fs.statSync(copyContext.sourcePath); + if (stat.isDirectory()) { + let ret = this.doCopyProcess(copyContext, true); + this.processCopyReturnValue(ret, copyRet); + if (copyRet.code === COPY_EXCEPTION) { + return copyRet; + } + + let fileNames = fs.listFileSync(copyContext.sourcePath); + for (let i = 0; i < fileNames.length; i++) { + let ret = this.copyOperation({ + sourcePath: copyContext.sourcePath + '/' + fileNames[i], + force: copyContext.force, + oldPath: copyContext.oldPath, + newPath: copyContext.newPath, + }); + this.processCopyReturnValue(ret, copyRet); + if (copyRet.code === COPY_EXCEPTION) { + return copyRet; + } + } + } else { + let ret = this.doCopyProcess(copyContext, false); + this.processCopyReturnValue(ret, copyRet); + if (copyRet.code === COPY_EXCEPTION) { + return copyRet; + } + } + } catch (e) { + hilog.error(DOMAIN_CODE, TAG, 'copyOperation error ' + e.message); + return this.getCopyReturnValue('', '', e.code, '', COPY_EXCEPTION); + } + return copyRet; + } + + copy(sourceFileUri, targetParentUri, force): {[], number} { + let checkRet= this.checkCopyArguments(sourceFileUri, targetParentUri); + if (checkRet.code != ERR_OK) { + return checkRet; + } + + let displayName = this.getFileName(sourceFileUri); + let newFileOrDirUri = this.genNewFileUri(targetParentUri, displayName); + let oldPath = getPath(sourceFileUri); + let newPath = getPath(newFileOrDirUri); + let sourcePath = oldPath; + let copyContext = { + sourcePath: sourcePath, + force: force, + oldPath: oldPath, + newPath: newPath, + }; + + let copyRet = this.copyOperation(copyContext); + return copyRet; + } + access(sourceFileUri): {boolean, number} { sourceFileUri = this.decode(sourceFileUri); if (sourceFileUri === '') { @@ -732,4 +909,4 @@ export default class FileExtAbility extends Extension { } return ERR_OK; } -}; \ No newline at end of file +}; diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index abea929a5b10b92b91e86deca923d64da02354ca..8deeb4fb1a9c9c12d2744c8df10b06371fd0fdc9 100755 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -94,6 +94,8 @@ ohos_unittest("external_file_access_test") { "ipc_js:rpc", "samgr:samgr_proxy", ] + resource_config_file = + "${user_file_service_path}/test/unittest/resources/ohos_test.xml" } ohos_unittest("abnormal_file_access_test") { diff --git a/test/unittest/external_file_access_test.cpp b/test/unittest/external_file_access_test.cpp index 43b1ef943d053548ff6f7cfefde96168fc71dbb5..ba87f1b7fcf3ab96962d5eb66d3ee98f1130c014 100644 --- a/test/unittest/external_file_access_test.cpp +++ b/test/unittest/external_file_access_test.cpp @@ -14,11 +14,10 @@ */ #include -#include -#include - #include #include +#include +#include #include "accesstoken_kit.h" #include "context_impl.h" @@ -48,7 +47,7 @@ shared_ptr g_context = nullptr; void SetNativeToken() { uint64_t tokenId; - const char **perms = new const char *[1]; + const char** perms = new const char*[1]; perms[0] = "ohos.permission.FILE_ACCESS_MANAGER"; NativeTokenInfoParams infoInstance = { .dcapsNum = 0, @@ -95,7 +94,7 @@ public: } } EXPECT_TRUE(sus); - vector wants{want}; + vector wants { want }; g_fah = FileAccessHelper::Creator(remoteObj, wants); if (g_fah == nullptr) { GTEST_LOG_(ERROR) << "external_file_access_test g_fah is nullptr"; @@ -108,10 +107,10 @@ public: g_fah->Release(); g_fah = nullptr; }; - void SetUp(){}; - void TearDown(){}; + void SetUp() {}; + void TearDown() {}; }; - +#if 1 /** * @tc.number: user_file_service_external_file_access_OpenFile_0000 * @tc.name: external_file_access_OpenFile_0000 @@ -427,7 +426,7 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0008, testing::e GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0008"; } -static bool ReplaceBundleNameFromPath(std::string &path, const std::string &newName) +static bool ReplaceBundleNameFromPath(std::string& path, const std::string& newName) { Uri uri(path); std::string scheme = uri.GetScheme(); @@ -1689,7 +1688,7 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0009, testing::ext:: result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); Uri testUri(""); - size_t fileNumbers = 2000; + size_t fileNumbers = 2; for (size_t j = 0; j < fileNumbers; j++) { string fileName = "test" + ToString(j) + ".txt"; result = g_fah->CreateFile(newDirUriTest1, fileName, testUri); @@ -2025,7 +2024,530 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0016, testing::ext:: } GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0016"; } +#endif + +#if 1 +/** + * @tc.number: user_file_service_external_file_access_Copy_0000 + * @tc.name: external_file_access_Copy_0000 + * @tc.desc: Test function of Copy interface, copy a file and argument of force is false + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: TODO: 换成Issue编号 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0000"; + try { + vector info; + int result = g_fah->GetRoots(info); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + for (size_t i = 0; i < info.size(); i++) { + Uri parentUri(info[i].uri); + Uri srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0000_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri srcFile(""); + result = g_fah->CreateFile(srcDir, "a.txt", srcFile); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + int fd; + result = g_fah->OpenFile(srcFile, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + char buff[] = "Copy test content for a.txt"; + ssize_t srcFileSize = write(fd, buff, sizeof(buff)); + EXPECT_EQ(srcFileSize, sizeof(buff)); + close(fd); + + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0000_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcFile, destDir, copyResult, false); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 0); + + Uri destFileUri(destDir.ToString() + "/" + "a.txt"); + GTEST_LOG_(ERROR) << "-------------------- destFileUri : " << destFileUri.ToString(); + result = g_fah->OpenFile(destFileUri, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + ssize_t destFileSize = read(fd, buff, sizeof(buff)); + EXPECT_EQ(srcFileSize, destFileSize); + close(fd); + + // result = g_fah->Delete(srcDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + // result = g_fah->Delete(destDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0000 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0000"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0001 + * @tc.name: external_file_access_Copy_0001 + * @tc.desc: Test function of Copy interface, copy a directory and argument of force is false + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0001"; + try { + vector info; + int result = g_fah->GetRoots(info); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + GTEST_LOG_(ERROR) << "-------------------- RootInfo.size(): " << info.size(); + for (size_t i = 0; i < info.size(); i++) { + GTEST_LOG_(ERROR) << "-------------------- RootInfo uri: " << info[i].uri; + Uri parentUri(info[i].uri); + Uri srcDir(""); + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0001_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri aUri(""); + result = g_fah->CreateFile(srcDir, "a.txt", aUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + int fd = -1; + result = g_fah->OpenFile(aUri, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + char buff[] = "Copy test content for a.txt"; + ssize_t aFileSize = write(fd, buff, sizeof(buff)); + EXPECT_EQ(aFileSize, sizeof(buff)); + close(fd); + Uri bUri(""); + result = g_fah->CreateFile(srcDir, "b.txt", bUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + result = g_fah->Mkdir(parentUri, "Copy_0001_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcDir, destDir, copyResult, false); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 0); + + // result = g_fah->Delete(srcDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + // result = g_fah->Delete(destDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0001 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0001"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0002 + * @tc.name: external_file_access_Copy_0002 + * @tc.desc: Test function of Copy interface, copy a empty directory + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0002, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0002"; + try { + vector info; + int result = g_fah->GetRoots(info); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + for (size_t i = 0; i < info.size(); i++) { + Uri parentUri(info[i].uri); + Uri srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0002_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0002_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcDir, destDir, copyResult, false); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 0); + + // result = g_fah->Delete(srcDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + // result = g_fah->Delete(destDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0002 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0002"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0003 + * @tc.name: external_file_access_Copy_0003 + * @tc.desc: Test function of Copy interface, copy a file with the same name and argument of force is true + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0003, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0003"; + try { + vector info; + int result = g_fah->GetRoots(info); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + for (size_t i = 0; i < info.size(); i++) { + Uri parentUri(info[i].uri); + Uri srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0003_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri srcFile(""); + result = g_fah->CreateFile(srcDir, "a.txt", srcFile); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + int fd; + result = g_fah->OpenFile(srcFile, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + char buff[] = "Copy test content for a.txt"; + ssize_t srcFileSize = write(fd, buff, sizeof(buff)); + EXPECT_EQ(srcFileSize, sizeof(buff)); + close(fd); + + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0003_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri existFile(""); + result = g_fah->CreateFile(destDir, "a.txt", existFile); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcFile, destDir, copyResult, true); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 0); + + result = g_fah->OpenFile(existFile, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + ssize_t destFileSize = read(fd, buff, sizeof(buff)); + EXPECT_EQ(srcFileSize, destFileSize); + close(fd); + + // result = g_fah->Delete(srcDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + // result = g_fah->Delete(destDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0003 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0003"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0004 + * @tc.name: external_file_access_Copy_0004 + * @tc.desc: Test function of Copy interface, copy a file with the same name and argument of force is false + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0004, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0004"; + try { + vector info; + int result = g_fah->GetRoots(info); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + for (size_t i = 0; i < info.size(); i++) { + Uri parentUri(info[i].uri); + Uri srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0004_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri srcFile(""); + result = g_fah->CreateFile(srcDir, "a.txt", srcFile); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + int fd; + result = g_fah->OpenFile(srcFile, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + char buff[] = "Copy test content for a.txt"; + ssize_t srcFileSize = write(fd, buff, sizeof(buff)); + EXPECT_EQ(srcFileSize, sizeof(buff)); + close(fd); + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0004_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri existFile(""); + result = g_fah->CreateFile(destDir, "a.txt", existFile); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcFile, destDir, copyResult, false); + EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 1); + + result = g_fah->OpenFile(existFile, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + ssize_t destFileSize = read(fd, buff, sizeof(buff)); + EXPECT_EQ(destFileSize, 0); + close(fd); + + // result = g_fah->Delete(srcDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + // result = g_fah->Delete(destDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0004 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0004"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0005 + * @tc.name: external_file_access_Copy_0005 + * @tc.desc: Test function of Copy interface, copy a file with the same name and no force argument + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0005, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0005"; + try { + vector info; + int result = g_fah->GetRoots(info); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + for (size_t i = 0; i < info.size(); i++) { + Uri parentUri(info[i].uri); + Uri srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0005_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri srcFile(""); + result = g_fah->CreateFile(srcDir, "a.txt", srcFile); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + int fd; + result = g_fah->OpenFile(srcFile, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + char buff[] = "Copy test content for a.txt"; + ssize_t srcFileSize = write(fd, buff, sizeof(buff)); + EXPECT_EQ(srcFileSize, sizeof(buff)); + close(fd); + + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0005_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri existFile(""); + result = g_fah->CreateFile(destDir, "a.txt", existFile); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcFile, destDir, copyResult); + EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_GT(copyResult.size(), 0); + + result = g_fah->OpenFile(existFile, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + ssize_t destFileSize = read(fd, buff, sizeof(buff)); + EXPECT_EQ(destFileSize, 0); + close(fd); + + // result = g_fah->Delete(srcDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + // result = g_fah->Delete(destDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0005 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0005"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0006 + * @tc.name: external_file_access_Copy_0006 + * @tc.desc: Test function of Copy interface, copy a directory with the same name and argument of force is true + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0006, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0006"; + try { + vector info; + int result = g_fah->GetRoots(info); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + for (size_t i = 0; i < info.size(); i++) { + Uri parentUri(info[i].uri); + Uri srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0006_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri aUri(""); + result = g_fah->CreateFile(srcDir, "a.txt", aUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri bUri(""); + result = g_fah->CreateFile(srcDir, "b.txt", bUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + int fd; + result = g_fah->OpenFile(bUri, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + char buff[] = "Copy test content for b.txt"; + ssize_t srcFileSize = write(fd, buff, sizeof(buff)); + EXPECT_EQ(srcFileSize, sizeof(buff)); + close(fd); + + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0006_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri destSrcDir(""); + result = g_fah->Mkdir(destDir, "Copy_0006_src", destSrcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + result = g_fah->CreateFile(destSrcDir, "b.txt", bUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcDir, destDir, copyResult, true); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 0); + + result = g_fah->OpenFile(bUri, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + ssize_t destFileSize = read(fd, buff, sizeof(buff)); + EXPECT_EQ(destFileSize, srcFileSize); + close(fd); + + // result = g_fah->Delete(srcDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + // result = g_fah->Delete(destDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0006 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0006"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0007 + * @tc.name: external_file_access_Copy_0007 + * @tc.desc: Test function of Copy interface, copy a directory with the same name and argument of force is false + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0007, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0007"; + try { + vector info; + int result = g_fah->GetRoots(info); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + for (size_t i = 0; i < info.size(); i++) { + Uri parentUri(info[i].uri); + Uri srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0007_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri aUri(""); + result = g_fah->CreateFile(srcDir, "a.txt", aUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri bUri(""); + result = g_fah->CreateFile(srcDir, "b.txt", bUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + int fd; + result = g_fah->OpenFile(bUri, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + char buff[] = "Copy test content for b.txt"; + ssize_t bFileSize = write(fd, buff, sizeof(buff)); + EXPECT_EQ(bFileSize, sizeof(buff)); + close(fd); + + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0007_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri destSrcDir(""); + result = g_fah->Mkdir(destDir, "Copy_0007_src", destSrcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + result = g_fah->CreateFile(destSrcDir, "b.txt", bUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcDir, destDir, copyResult, false); + EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 1); + + // result = g_fah->Delete(srcDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + // result = g_fah->Delete(destDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0007 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0007"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0008 + * @tc.name: external_file_access_Copy_0008 + * @tc.desc: Test function of Copy interface, copy a directory with the same name and no force argument + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0008, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0008"; + try { + vector info; + int result = g_fah->GetRoots(info); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + for (size_t i = 0; i < info.size(); i++) { + Uri parentUri(info[i].uri); + Uri srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0008_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri aUri(""); + result = g_fah->CreateFile(srcDir, "a.txt", aUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri bUri(""); + result = g_fah->CreateFile(srcDir, "b.txt", bUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0008_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri destSrcDir(""); + result = g_fah->Mkdir(destDir, "Copy_0008_src", destSrcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + result = g_fah->CreateFile(destSrcDir, "b.txt", bUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcDir, destDir, copyResult); + EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 1); + + // result = g_fah->Delete(srcDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + // result = g_fah->Delete(destDir); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0008 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0008"; +} +#endif +#if 1 /** * @tc.number: user_file_service_external_file_access_Rename_0000 * @tc.name: external_file_access_Rename_0000 @@ -2538,8 +3060,8 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0003, testing::e GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0003"; } -static void ListFileTdd(FileInfo fileInfo, int offset, int maxCount, FileFilter filter, - std::vector fileInfoVec) +static void ListFileTdd( + FileInfo fileInfo, int offset, int maxCount, FileFilter filter, std::vector fileInfoVec) { GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFileTdd"; int ret = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); @@ -3221,7 +3743,7 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0001, testing::ex } } EXPECT_TRUE(sus); - vector wants{want}; + vector wants { want }; std::pair, int> helper = FileAccessHelper::Creator(g_context, wants); setuid(UID_DEFAULT); ASSERT_TRUE(helper.first != nullptr); @@ -3319,7 +3841,7 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0005, testing::ex try { AAFwk::Want want; want.SetElementName("NotExistBundleName", "NotExistAbilityName"); - std::vector wants{want}; + std::vector wants { want }; std::pair, int> helper = FileAccessHelper::Creator(g_context, wants); ASSERT_TRUE(helper.first == nullptr); } catch (...) { @@ -3391,7 +3913,7 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0008, testing::ex try { AAFwk::Want want; want.SetElementName("NotExistBundleName", "NotExistAbilityName"); - std::vector wants{want}; + std::vector wants { want }; shared_ptr helper = FileAccessHelper::Creator(g_context->GetToken(), wants); ASSERT_TRUE(helper == nullptr); } catch (...) { @@ -3537,16 +4059,8 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0000, testing::ext: fileSize = write(fd, buff.c_str(), buff.size()); close(fd); EXPECT_EQ(fileSize, buff.size()); - json testJson = { - {RELATIVE_PATH, " "}, - {DISPLAY_NAME, " "}, - {FILE_SIZE, " "}, - {DATE_MODIFIED, " "}, - {DATE_ADDED, " "}, - {HEIGHT, " "}, - {WIDTH, " "}, - {DURATION, " "} - }; + json testJson = { { RELATIVE_PATH, " " }, { DISPLAY_NAME, " " }, { FILE_SIZE, " " }, { DATE_MODIFIED, " " }, + { DATE_ADDED, " " }, { HEIGHT, " " }, { WIDTH, " " }, { DURATION, " " } }; auto testJsonString = testJson.dump(); result = g_fah->Query(newDirUriTest1, testJsonString); EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); @@ -3598,16 +4112,8 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0001, testing::ext: ssize_t fileSize = write(fd, buff.c_str(), buff.size()); close(fd); EXPECT_EQ(fileSize, buff.size()); - json testJson = { - {RELATIVE_PATH, " "}, - {DISPLAY_NAME, " "}, - {FILE_SIZE, " "}, - {DATE_MODIFIED, " "}, - {DATE_ADDED, " "}, - {HEIGHT, " "}, - {WIDTH, " "}, - {DURATION, " "} - }; + json testJson = { { RELATIVE_PATH, " " }, { DISPLAY_NAME, " " }, { FILE_SIZE, " " }, { DATE_MODIFIED, " " }, + { DATE_ADDED, " " }, { HEIGHT, " " }, { WIDTH, " " }, { DURATION, " " } }; auto testJsonString = testJson.dump(); result = g_fah->Query(newFileUri, testJsonString); EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); @@ -3669,9 +4175,7 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0002, testing::ext: fileSize = write(fd, buff.c_str(), buff.size()); close(fd); EXPECT_EQ(fileSize, buff.size()); - json testJson = { - {FILE_SIZE, " "} - }; + json testJson = { { FILE_SIZE, " " } }; auto testJsonString = testJson.dump(); result = g_fah->Query(newDirUriTest1, testJsonString); EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); @@ -3700,10 +4204,7 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0003, testing::ext: GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0003"; try { Uri testUri("&*()*/?"); - json testJson = { - {RELATIVE_PATH, " "}, - {DISPLAY_NAME, " "} - }; + json testJson = { { RELATIVE_PATH, " " }, { DISPLAY_NAME, " " } }; auto testJsonString = testJson.dump(); int result = g_fah->Query(testUri, testJsonString); EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); @@ -3735,12 +4236,7 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0004, testing::ext: Uri newDirUriTest(""); result = g_fah->Mkdir(parentUri, "QueryTest6", newDirUriTest); EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - json testJson = { - {"001", " "}, - {"#", " "}, - {"test", " "}, - {"target", " "} - }; + json testJson = { { "001", " " }, { "#", " " }, { "test", " " }, { "target", " " } }; auto testJsonString = testJson.dump(); result = g_fah->Query(newDirUriTest, testJsonString); EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); @@ -3774,11 +4270,7 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0005, testing::ext: Uri newDirUriTest(""); result = g_fah->Mkdir(parentUri, "QueryTest7", newDirUriTest); EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - json testJson = { - {RELATIVE_PATH, " "}, - {DISPLAY_NAME, " "}, - {"test", " "} - }; + json testJson = { { RELATIVE_PATH, " " }, { DISPLAY_NAME, " " }, { "test", " " } }; auto testJsonString = testJson.dump(); result = g_fah->Query(newDirUriTest, testJsonString); EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); @@ -3874,16 +4366,8 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0007, testing::ext: fileSize = write(fd, buff.c_str(), buff.size()); close(fd); EXPECT_EQ(fileSize, buff.size()); - json testJson = { - {RELATIVE_PATH, " "}, - {DISPLAY_NAME, " "}, - {FILE_SIZE, " "}, - {DATE_MODIFIED, " "}, - {DATE_ADDED, " "}, - {HEIGHT, " "}, - {WIDTH, " "}, - {DURATION, " "} - }; + json testJson = { { RELATIVE_PATH, " " }, { DISPLAY_NAME, " " }, { FILE_SIZE, " " }, { DATE_MODIFIED, " " }, + { DATE_ADDED, " " }, { HEIGHT, " " }, { WIDTH, " " }, { DURATION, " " } }; auto testJsonString = testJson.dump(); result = g_fah->Query(newDirUriTest1, testJsonString); EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); @@ -3901,4 +4385,5 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0007, testing::ext: } GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0007"; } -} // namespace \ No newline at end of file +#endif +} // namespace diff --git a/test/unittest/resources/ohos_test.xml b/test/unittest/resources/ohos_test.xml index ba2271adff50c7cbff6e6e9281c241d490b3f7aa..9f60bc56f56897f5838e967ac35d7617338b5ae7 100644 --- a/test/unittest/resources/ohos_test.xml +++ b/test/unittest/resources/ohos_test.xml @@ -34,4 +34,11 @@