From 8bb3c47dec1202d3cc235f41843a4f95b984ad6d Mon Sep 17 00:00:00 2001 From: wangjianqiang Date: Mon, 27 Jun 2022 20:50:25 +0800 Subject: [PATCH 1/3] =?UTF-8?q?=E6=B7=BB=E5=8A=A0napi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wangjianqiang --- .../napi_fileaccess_helper.cpp | 524 ++++++++++++++++++ 1 file changed, 524 insertions(+) create mode 100644 interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp 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..6a09d304 --- /dev/null +++ b/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp @@ -0,0 +1,524 @@ +napi_value NAPI_Rename(napi_env env, napi_callback_info info) +{ + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) { + HILOG_ERROR("%{public}s, Number of arguments unmatched.", __func__); + UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched"); + return nullptr; + } + if (funcArg.GetArgc() == NARG_CNT::THREE && !NVal(env, funcArg[NARG_POS::THIRD]).TypeIs(napi_function)) { + UniError(EINVAL).ThrowErr(env, "Type of arguments unmatched"); + return nullptr; + } + 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); + } + return ret; +} + +napi_value RenameWrap(napi_env env, napi_callback_info info, FileAccessHelperRenameCB *renameCB) +{ + 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) { + UniError(EINVAL).ThrowErr(env, "Type of arguments unmatched"); + return nullptr; + } + renameCB->sourceFileUri = NapiValueToStringUtf8(env, args[PARAM0]); + + NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valueType)); + if (valueType != napi_string) { + UniError(EINVAL).ThrowErr(env, "Type of arguments unmatched"); + return nullptr; + } + renameCB->displayName = NapiValueToStringUtf8(env, args[PARAM1]); + + FileAccessHelper *objectInfo = nullptr; + napi_unwrap(env, thisVar, (void **)&objectInfo); + renameCB->fileAccessHelper = objectInfo; + + if (argcAsync > argcPromise) { + ret = RenameAsync(env, args, ARGS_TWO, renameCB); + } else { + ret = RenamePromise(env, renameCB); + } + return ret; +} + +napi_value RenameAsync(napi_env env, napi_value *args, const size_t argCallback, FileAccessHelperRenameCB *renameCB) +{ + 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)); + return result; +} + +napi_value RenamePromise(napi_env env, FileAccessHelperRenameCB *renameCB) +{ + 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)); + return promise; +} + +void RenameExecuteCB(napi_env env, void *data) +{ + FileAccessHelperRenameCB *renameCB = static_cast(data); + renameCB->execResult = ERR_ERROR; + if (renameCB->fileAccessHelper == nullptr) { + HILOG_ERROR("NAPI_Rename, fileAccessHelper == nullptr"); + return ; + } + if (renameCB->sourceFileUri.empty()) { + HILOG_ERROR("NAPI_Rename, fileAccessHelper sourceFileUri is empty"); + return ; + } + 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; +} + +void RenameAsyncCompleteCB(napi_env env, napi_status status, void *data) +{ + 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; +} + +void RenamePromiseCompleteCB(napi_env env, napi_status status, void *data) +{ + 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; +} + +napi_value NAPI_ListFile(napi_env env, napi_callback_info info) +{ + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) { + HILOG_ERROR("%{public}s, Number of arguments unmatched.", __func__); + UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched"); + return nullptr; + } + if (funcArg.GetArgc() == NARG_CNT::TWO && !NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_function)) { + UniError(EINVAL).ThrowErr(env, "Type of arguments unmatched"); + return nullptr; + } + + 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); + } + return ret; +} + +napi_value ListFileWrap(napi_env env, napi_callback_info info, FileAccessHelperListFileCB *listFileCB) +{ + 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) { + UniError(EINVAL).ThrowErr(env, "Type of arguments unmatched"); + return nullptr; + } + listFileCB->sourceFileUri = NapiValueToStringUtf8(env, args[PARAM0]); + + FileAccessHelper *objectInfo = nullptr; + napi_unwrap(env, thisVar, (void **)&objectInfo); + listFileCB->fileAccessHelper = objectInfo; + + if (argcAsync > argcPromise) { + ret = ListFileAsync(env, args, ARGS_ONE, listFileCB); + } else { + ret = ListFilePromise(env, listFileCB); + } + return ret; +} + +napi_value ListFileAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperListFileCB *listFileCB) +{ + 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)); + return result; +} + +napi_value ListFilePromise(napi_env env, FileAccessHelperListFileCB *listFileCB) +{ + 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)); + return promise; +} + +void ListFileExecuteCB(napi_env env, void *data) +{ + FileAccessHelperListFileCB *listFileCB = static_cast(data); + listFileCB->execResult = ERR_ERROR; + if (listFileCB->fileAccessHelper == nullptr) { + HILOG_ERROR(" NAPI_ListFile, fileAccessHelper == nullptr"); + return ; + } + if (listFileCB->sourceFileUri.empty()) { + HILOG_ERROR(" NAPI_ListFile, fileAccessHelper sourceFileUri is empty"); + return ; + } + OHOS::Uri sourceFileUri(listFileCB->sourceFileUri); + listFileCB->result = listFileCB->fileAccessHelper->ListFile(sourceFileUri); + listFileCB->execResult = 0; +} + +void ListFileAsyncCompleteCB(napi_env env, napi_status status, void *data) +{ + 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; +} + +void ListFilePromiseCompleteCB(napi_env env, napi_status status, void *data) +{ + 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; +} + +napi_value NAPI_GetRoots(napi_env env, napi_callback_info info) +{ + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::ZERO, NARG_CNT::ONE)) { + HILOG_ERROR("%{public}s, Number of arguments unmatched.", __func__); + UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched"); + return nullptr; + } + if (funcArg.GetArgc() == NARG_CNT::ONE && !NVal(env, funcArg[NARG_POS::FIRST]).TypeIs(napi_function)) { + UniError(EINVAL).ThrowErr(env, "Type of arguments unmatched"); + return nullptr; + } + + 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); + } + return ret; +} + +napi_value GetRootsWrap(napi_env env, napi_callback_info info, FileAccessHelperGetRootsCB *getRootsCB) +{ + 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); + getRootsCB->fileAccessHelper = objectInfo; + + if (argcAsync > argcPromise) { + ret = GetRootsAsync(env, args, ARGS_ZERO, getRootsCB); + } else { + ret = GetRootsPromise(env, getRootsCB); + } + return ret; +} + +napi_value GetRootsAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperGetRootsCB *getRootsCB) +{ + 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)); + return result; +} + +napi_value GetRootsPromise(napi_env env, FileAccessHelperGetRootsCB *getRootsCB) +{ + 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)); + return promise; +} + +void GetRootsExecuteCB(napi_env env, void *data) +{ + FileAccessHelperGetRootsCB *getRootsCB = static_cast(data); + getRootsCB->execResult = ERR_ERROR; + if (getRootsCB->fileAccessHelper == nullptr) { + HILOG_ERROR(" NAPI_GetRoots, fileAccessHelper == nullptr"); + return ; + } + getRootsCB->result = getRootsCB->fileAccessHelper->GetRoots(); + getRootsCB->execResult = ERR_OK; +} + +void GetRootsAsyncCompleteCB(napi_env env, napi_status status, void *data) +{ + 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; +} + +void GetRootsPromiseCompleteCB(napi_env env, napi_status status, void *data) +{ + 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; +} \ No newline at end of file -- Gitee From f7f008310925f21f4dde21018ede47e9c28143d0 Mon Sep 17 00:00:00 2001 From: wangjianqiang Date: Tue, 28 Jun 2022 23:10:43 +0800 Subject: [PATCH 2/3] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E7=9B=91=E8=A7=86?= =?UTF-8?q?=E6=84=8F=E8=A7=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wangjianqiang --- .../napi_fileaccess_helper.cpp | 671 +++++++++--------- 1 file changed, 340 insertions(+), 331 deletions(-) diff --git a/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp b/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp index 6a09d304..4aff7ee0 100644 --- a/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp +++ b/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp @@ -1,44 +1,121 @@ -napi_value NAPI_Rename(napi_env env, napi_callback_info info) +static void RenamePromiseCompleteCB(napi_env env, napi_status status, void *data) { - NFuncArg funcArg(env, info); - if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) { - HILOG_ERROR("%{public}s, Number of arguments unmatched.", __func__); - UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched"); - return nullptr; + 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; +} + +static void RenameAsyncCompleteCB(napi_env env, napi_status status, void *data) +{ + 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)); } - if (funcArg.GetArgc() == NARG_CNT::THREE && !NVal(env, funcArg[NARG_POS::THIRD]).TypeIs(napi_function)) { - UniError(EINVAL).ThrowErr(env, "Type of arguments unmatched"); - return nullptr; + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, renameCB->cbBase.asyncWork)); + delete renameCB; + renameCB = nullptr; +} + +static void RenameExecuteCB(napi_env env, void *data) +{ + FileAccessHelperRenameCB *renameCB = static_cast(data); + renameCB->execResult = ERR_ERROR; + if (renameCB->fileAccessHelper == nullptr) { + HILOG_ERROR("NAPI_Rename, fileAccessHelper == nullptr"); + return ; } - FileAccessHelperRenameCB *renameCB = new (std::nothrow) FileAccessHelperRenameCB; + + if (renameCB->sourceFileUri.empty()) { + HILOG_ERROR("NAPI_Rename, fileAccessHelper sourceFileUri is empty"); + return ; + } + 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; +} + +static napi_value RenamePromise(napi_env env, FileAccessHelperRenameCB *renameCB) +{ if (renameCB == nullptr) { - HILOG_ERROR("%{public}s, renameCB == nullptr.", __func__); - return WrapVoidToJS(env); + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; } - renameCB->cbBase.cbInfo.env = env; - renameCB->cbBase.asyncWork = nullptr; - renameCB->cbBase.deferred = nullptr; - renameCB->cbBase.ability = nullptr; + napi_value resourceName = nullptr; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + napi_deferred deferred; + napi_value promise = nullptr; + NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); + renameCB->cbBase.deferred = deferred; - 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); + 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)); + return promise; +} + +static napi_value RenameAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperRenameCB *renameCB) +{ + if (args == nullptr || renameCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; } - return ret; + napi_value resourceName = nullptr; + 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], initial_refcount, &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 = nullptr; + NAPI_CALL(env, napi_get_null(env, &result)); + return result; } -napi_value RenameWrap(napi_env env, napi_callback_info info, FileAccessHelperRenameCB *renameCB) +static napi_value RenameWrap(napi_env env, napi_callback_info info, FileAccessHelperRenameCB *renameCB) { 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)); @@ -65,7 +142,8 @@ napi_value RenameWrap(napi_env env, napi_callback_info info, FileAccessHelperRen FileAccessHelper *objectInfo = nullptr; napi_unwrap(env, thisVar, (void **)&objectInfo); renameCB->fileAccessHelper = objectInfo; - + + napi_value ret = nullptr; if (argcAsync > argcPromise) { ret = RenameAsync(env, args, ARGS_TWO, renameCB); } else { @@ -74,156 +152,156 @@ napi_value RenameWrap(napi_env env, napi_callback_info info, FileAccessHelperRen return ret; } -napi_value RenameAsync(napi_env env, napi_value *args, const size_t argCallback, FileAccessHelperRenameCB *renameCB) +napi_value NAPI_Rename(napi_env env, napi_callback_info info) { - if (args == nullptr || renameCB == nullptr) { - HILOG_ERROR("%{public}s, param == nullptr.", __func__); + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) { + HILOG_ERROR("Number of arguments unmatched."); + UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched"); 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)); + if (funcArg.GetArgc() == NARG_CNT::THREE && !NVal(env, funcArg[NARG_POS::THIRD]).TypeIs(napi_function)) { + UniError(EINVAL).ThrowErr(env, "Type of arguments unmatched"); + return nullptr; } - 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)); - return result; -} - -napi_value RenamePromise(napi_env env, FileAccessHelperRenameCB *renameCB) -{ + FileAccessHelperRenameCB *renameCB = new (std::nothrow) FileAccessHelperRenameCB; if (renameCB == nullptr) { - HILOG_ERROR("%{public}s, param == nullptr.", __func__); - return nullptr; + HILOG_ERROR("%{public}s, renameCB == nullptr.", __func__); + return WrapVoidToJS(env); } - 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; + renameCB->cbBase.cbInfo.env = env; + renameCB->cbBase.asyncWork = nullptr; + renameCB->cbBase.deferred = nullptr; + renameCB->cbBase.ability = nullptr; - 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)); - return promise; + 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); + } + return ret; } -void RenameExecuteCB(napi_env env, void *data) +static void ListFilePromiseCompleteCB(napi_env env, napi_status status, void *data) { - FileAccessHelperRenameCB *renameCB = static_cast(data); - renameCB->execResult = ERR_ERROR; - if (renameCB->fileAccessHelper == nullptr) { - HILOG_ERROR("NAPI_Rename, fileAccessHelper == nullptr"); - return ; - } - if (renameCB->sourceFileUri.empty()) { - HILOG_ERROR("NAPI_Rename, fileAccessHelper sourceFileUri is empty"); - return ; - } - 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; + 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; } -void RenameAsyncCompleteCB(napi_env env, napi_status status, void *data) +static void ListFileAsyncCompleteCB(napi_env env, napi_status status, void *data) { - FileAccessHelperRenameCB *renameCB = static_cast(data); + 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, renameCB->cbBase.cbInfo.callback, &callback)); + NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, listFileCB->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])); + 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 (renameCB->cbBase.cbInfo.callback != nullptr) { - NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, renameCB->cbBase.cbInfo.callback)); + 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, renameCB->cbBase.asyncWork)); - delete renameCB; - renameCB = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, listFileCB->cbBase.asyncWork)); + delete listFileCB; + listFileCB = nullptr; } -void RenamePromiseCompleteCB(napi_env env, napi_status status, void *data) +static void ListFileExecuteCB(napi_env env, void *data) { - 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; + FileAccessHelperListFileCB *listFileCB = static_cast(data); + listFileCB->execResult = ERR_ERROR; + if (listFileCB->fileAccessHelper == nullptr) { + HILOG_ERROR(" NAPI_ListFile, fileAccessHelper == nullptr"); + return ; + } + + if (listFileCB->sourceFileUri.empty()) { + HILOG_ERROR(" NAPI_ListFile, fileAccessHelper sourceFileUri is empty"); + return ; + } + OHOS::Uri sourceFileUri(listFileCB->sourceFileUri); + listFileCB->result = listFileCB->fileAccessHelper->ListFile(sourceFileUri); + listFileCB->execResult = ERR_OK; } -napi_value NAPI_ListFile(napi_env env, napi_callback_info info) +static napi_value ListFilePromise(napi_env env, FileAccessHelperListFileCB *listFileCB) { - NFuncArg funcArg(env, info); - if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) { - HILOG_ERROR("%{public}s, Number of arguments unmatched.", __func__); - UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched"); - return nullptr; - } - if (funcArg.GetArgc() == NARG_CNT::TWO && !NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_function)) { - UniError(EINVAL).ThrowErr(env, "Type of arguments unmatched"); + if (listFileCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); return nullptr; } - - FileAccessHelperListFileCB *listFileCB = new (std::nothrow) FileAccessHelperListFileCB; - if (listFileCB == nullptr) { - HILOG_ERROR("%{public}s, listFileCB == nullptr.", __func__); - return WrapVoidToJS(env); + napi_value resourceName = nullptr; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + napi_deferred deferred; + napi_value promise = nullptr; + 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)); + return promise; +} + +static napi_value ListFileAsync(napi_env env, + napi_value *args, + const size_t argCallback, + FileAccessHelperListFileCB *listFileCB) +{ + if (args == nullptr || listFileCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); + return nullptr; } - listFileCB->cbBase.cbInfo.env = env; - listFileCB->cbBase.asyncWork = nullptr; - listFileCB->cbBase.deferred = nullptr; - listFileCB->cbBase.ability = nullptr; + napi_value resourceName = nullptr; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); - 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); + 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], initial_refcount, &listFileCB->cbBase.cbInfo.callback)); } - return ret; + + 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 = nullptr; + NAPI_CALL(env, napi_get_null(env, &result)); + return result; } -napi_value ListFileWrap(napi_env env, napi_callback_info info, FileAccessHelperListFileCB *listFileCB) +static napi_value ListFileWrap(napi_env env, napi_callback_info info, FileAccessHelperListFileCB *listFileCB) { 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)); @@ -243,7 +321,8 @@ napi_value ListFileWrap(napi_env env, napi_callback_info info, FileAccessHelperL FileAccessHelper *objectInfo = nullptr; napi_unwrap(env, thisVar, (void **)&objectInfo); listFileCB->fileAccessHelper = objectInfo; - + + napi_value ret = nullptr; if (argcAsync > argcPromise) { ret = ListFileAsync(env, args, ARGS_ONE, listFileCB); } else { @@ -252,176 +331,113 @@ napi_value ListFileWrap(napi_env env, napi_callback_info info, FileAccessHelperL return ret; } -napi_value ListFileAsync(napi_env env, - napi_value *args, - const size_t argCallback, - FileAccessHelperListFileCB *listFileCB) +napi_value NAPI_ListFile(napi_env env, napi_callback_info info) { - if (args == nullptr || listFileCB == nullptr) { - HILOG_ERROR("%{public}s, param == nullptr.", __func__); + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) { + HILOG_ERROR("%{public}s, Number of arguments unmatched.", __func__); + UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched"); 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)); + if (funcArg.GetArgc() == NARG_CNT::TWO && !NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_function)) { + UniError(EINVAL).ThrowErr(env, "Type of arguments unmatched"); + return nullptr; } - - 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)); - return result; -} - -napi_value ListFilePromise(napi_env env, FileAccessHelperListFileCB *listFileCB) -{ + + FileAccessHelperListFileCB *listFileCB = new (std::nothrow) FileAccessHelperListFileCB; if (listFileCB == nullptr) { - HILOG_ERROR("%{public}s, param == nullptr.", __func__); - return nullptr; + HILOG_ERROR("%{public}s, listFileCB == nullptr.", __func__); + return WrapVoidToJS(env); } - 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; + listFileCB->cbBase.cbInfo.env = env; + listFileCB->cbBase.asyncWork = nullptr; + listFileCB->cbBase.deferred = nullptr; + listFileCB->cbBase.ability = nullptr; - 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)); - return promise; + 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); + } + return ret; } -void ListFileExecuteCB(napi_env env, void *data) +static void GetRootsPromiseCompleteCB(napi_env env, napi_status status, void *data) { - FileAccessHelperListFileCB *listFileCB = static_cast(data); - listFileCB->execResult = ERR_ERROR; - if (listFileCB->fileAccessHelper == nullptr) { - HILOG_ERROR(" NAPI_ListFile, fileAccessHelper == nullptr"); - return ; - } - if (listFileCB->sourceFileUri.empty()) { - HILOG_ERROR(" NAPI_ListFile, fileAccessHelper sourceFileUri is empty"); - return ; - } - OHOS::Uri sourceFileUri(listFileCB->sourceFileUri); - listFileCB->result = listFileCB->fileAccessHelper->ListFile(sourceFileUri); - listFileCB->execResult = 0; + 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; } -void ListFileAsyncCompleteCB(napi_env env, napi_status status, void *data) +static void GetRootsAsyncCompleteCB(napi_env env, napi_status status, void *data) { - FileAccessHelperListFileCB *listFileCB = static_cast(data); + 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, listFileCB->cbBase.cbInfo.callback, &callback)); + NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, getRootsCB->cbBase.cbInfo.callback, &callback)); - result[PARAM0] = GetCallbackErrorValue(env, listFileCB->execResult); - result[PARAM1] = WrapArrayFileInfoToJS(env, listFileCB->result); + 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 (listFileCB->cbBase.cbInfo.callback != nullptr) { - NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, listFileCB->cbBase.cbInfo.callback)); + 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, listFileCB->cbBase.asyncWork)); - delete listFileCB; - listFileCB = nullptr; -} - -void ListFilePromiseCompleteCB(napi_env env, napi_status status, void *data) -{ - 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; + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, getRootsCB->cbBase.asyncWork)); + delete getRootsCB; + getRootsCB = nullptr; } -napi_value NAPI_GetRoots(napi_env env, napi_callback_info info) +static void GetRootsExecuteCB(napi_env env, void *data) { - NFuncArg funcArg(env, info); - if (!funcArg.InitArgs(NARG_CNT::ZERO, NARG_CNT::ONE)) { - HILOG_ERROR("%{public}s, Number of arguments unmatched.", __func__); - UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched"); - return nullptr; - } - if (funcArg.GetArgc() == NARG_CNT::ONE && !NVal(env, funcArg[NARG_POS::FIRST]).TypeIs(napi_function)) { - UniError(EINVAL).ThrowErr(env, "Type of arguments unmatched"); - return nullptr; - } - - 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); + FileAccessHelperGetRootsCB *getRootsCB = static_cast(data); + getRootsCB->execResult = ERR_ERROR; + if (getRootsCB->fileAccessHelper == nullptr) { + HILOG_ERROR(" NAPI_GetRoots, fileAccessHelper == nullptr"); + return ; } - return ret; + getRootsCB->result = getRootsCB->fileAccessHelper->GetRoots(); + getRootsCB->execResult = ERR_OK; } -napi_value GetRootsWrap(napi_env env, napi_callback_info info, FileAccessHelperGetRootsCB *getRootsCB) +static napi_value GetRootsPromise(napi_env env, FileAccessHelperGetRootsCB *getRootsCB) { - 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__); + if (getRootsCB == nullptr) { + HILOG_ERROR("%{public}s, param == nullptr.", __func__); return nullptr; } + napi_value resourceName = nullptr; + NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); + napi_deferred deferred; + napi_value promise = nullptr; + NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); + getRootsCB->cbBase.deferred = deferred; - FileAccessHelper *objectInfo = nullptr; - napi_unwrap(env, thisVar, (void **)&objectInfo); - getRootsCB->fileAccessHelper = objectInfo; - - if (argcAsync > argcPromise) { - ret = GetRootsAsync(env, args, ARGS_ZERO, getRootsCB); - } else { - ret = GetRootsPromise(env, getRootsCB); - } - return ret; + 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)); + return promise; } -napi_value GetRootsAsync(napi_env env, +static napi_value GetRootsAsync(napi_env env, napi_value *args, const size_t argCallback, FileAccessHelperGetRootsCB *getRootsCB) @@ -430,13 +446,13 @@ napi_value GetRootsAsync(napi_env env, HILOG_ERROR("%{public}s, param == nullptr.", __func__); return nullptr; } - napi_value resourceName = 0; + napi_value resourceName = nullptr; 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_reference(env, args[argCallback], initial_refcount, &getRootsCB->cbBase.cbInfo.callback)); } NAPI_CALL(env, @@ -448,77 +464,70 @@ napi_value GetRootsAsync(napi_env env, (void *)getRootsCB, &getRootsCB->cbBase.asyncWork)); NAPI_CALL(env, napi_queue_async_work(env, getRootsCB->cbBase.asyncWork)); - napi_value result = 0; + napi_value result = nullptr; NAPI_CALL(env, napi_get_null(env, &result)); return result; } -napi_value GetRootsPromise(napi_env env, FileAccessHelperGetRootsCB *getRootsCB) +static napi_value GetRootsWrap(napi_env env, napi_callback_info info, FileAccessHelperGetRootsCB *getRootsCB) { - if (getRootsCB == nullptr) { - HILOG_ERROR("%{public}s, param == nullptr.", __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 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_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)); - return promise; -} -void GetRootsExecuteCB(napi_env env, void *data) -{ - FileAccessHelperGetRootsCB *getRootsCB = static_cast(data); - getRootsCB->execResult = ERR_ERROR; - if (getRootsCB->fileAccessHelper == nullptr) { - HILOG_ERROR(" NAPI_GetRoots, fileAccessHelper == nullptr"); - return ; + FileAccessHelper *objectInfo = nullptr; + napi_unwrap(env, thisVar, (void **)&objectInfo); + getRootsCB->fileAccessHelper = objectInfo; + + napi_value ret = nullptr; + if (argcAsync > argcPromise) { + ret = GetRootsAsync(env, args, ARGS_ZERO, getRootsCB); + } else { + ret = GetRootsPromise(env, getRootsCB); } - getRootsCB->result = getRootsCB->fileAccessHelper->GetRoots(); - getRootsCB->execResult = ERR_OK; + return ret; } -void GetRootsAsyncCompleteCB(napi_env env, napi_status status, void *data) +napi_value NAPI_GetRoots(napi_env env, napi_callback_info info) { - 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)); + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::ZERO, NARG_CNT::ONE)) { + HILOG_ERROR("%{public}s, Number of arguments unmatched.", __func__); + UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched"); + return nullptr; + } - 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 (funcArg.GetArgc() == NARG_CNT::ONE && !NVal(env, funcArg[NARG_POS::FIRST]).TypeIs(napi_function)) { + UniError(EINVAL).ThrowErr(env, "Type of arguments unmatched"); + return nullptr; + } - if (getRootsCB->cbBase.cbInfo.callback != nullptr) { - NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, getRootsCB->cbBase.cbInfo.callback)); + FileAccessHelperGetRootsCB *getRootsCB = new (std::nothrow) FileAccessHelperGetRootsCB; + if (getRootsCB == nullptr) { + HILOG_ERROR("%{public}s, getRootsCB == nullptr.", __func__); + return WrapVoidToJS(env); } - NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, getRootsCB->cbBase.asyncWork)); - delete getRootsCB; - getRootsCB = nullptr; -} + getRootsCB->cbBase.cbInfo.env = env; + getRootsCB->cbBase.asyncWork = nullptr; + getRootsCB->cbBase.deferred = nullptr; + getRootsCB->cbBase.ability = nullptr; -void GetRootsPromiseCompleteCB(napi_env env, napi_status status, void *data) -{ - 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; + 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); + } + return ret; } \ No newline at end of file -- Gitee From 7833fe785a469c377a87206affb0bb1376411fd9 Mon Sep 17 00:00:00 2001 From: wangjianqiang Date: Wed, 29 Jun 2022 18:55:28 +0800 Subject: [PATCH 3/3] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=A3=80=E8=A7=86?= =?UTF-8?q?=E6=84=8F=E8=A7=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wangjianqiang --- .../napi_fileaccess_helper.cpp | 27 ++++++++++++------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp b/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp index 4aff7ee0..e62fa096 100644 --- a/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp +++ b/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp @@ -93,7 +93,10 @@ static napi_value RenameAsync(napi_env env, 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], initial_refcount, &renameCB->cbBase.cbInfo.callback)); + NAPI_CALL(env, napi_create_reference(env, + args[argCallback], + INITIAL_REFCOUNT, + &renameCB->cbBase.cbInfo.callback)); } NAPI_CALL(env, @@ -265,9 +268,9 @@ static napi_value ListFilePromise(napi_env env, FileAccessHelperListFileCB *list } static napi_value ListFileAsync(napi_env env, - napi_value *args, - const size_t argCallback, - FileAccessHelperListFileCB *listFileCB) + napi_value *args, + const size_t argCallback, + FileAccessHelperListFileCB *listFileCB) { if (args == nullptr || listFileCB == nullptr) { HILOG_ERROR("%{public}s, param == nullptr.", __func__); @@ -279,7 +282,10 @@ static napi_value ListFileAsync(napi_env env, 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], initial_refcount, &listFileCB->cbBase.cbInfo.callback)); + NAPI_CALL(env, napi_create_reference(env, + args[argCallback], + INITIAL_REFCOUNT, + &listFileCB->cbBase.cbInfo.callback)); } NAPI_CALL(env, @@ -438,9 +444,9 @@ static napi_value GetRootsPromise(napi_env env, FileAccessHelperGetRootsCB *getR } static napi_value GetRootsAsync(napi_env env, - napi_value *args, - const size_t argCallback, - FileAccessHelperGetRootsCB *getRootsCB) + napi_value *args, + const size_t argCallback, + FileAccessHelperGetRootsCB *getRootsCB) { if (args == nullptr || getRootsCB == nullptr) { HILOG_ERROR("%{public}s, param == nullptr.", __func__); @@ -452,7 +458,10 @@ static napi_value GetRootsAsync(napi_env env, 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], initial_refcount, &getRootsCB->cbBase.cbInfo.callback)); + NAPI_CALL(env, napi_create_reference(env, + args[argCallback], + INITIAL_REFCOUNT, + &getRootsCB->cbBase.cbInfo.callback)); } NAPI_CALL(env, -- Gitee