From ae7c04e1cde31a738afe8e8cd513ecdd7facd75c Mon Sep 17 00:00:00 2001 From: wangxu43 Date: Tue, 25 Jan 2022 20:09:29 +0800 Subject: [PATCH] Async bug fix Signed-off-by: wangxu43 --- .../innerkits/napi/include/auth_common.h | 3 +- .../innerkits/napi/include/user_auth_impl.h | 20 +- .../innerkits/napi/src/authapi_callback.cpp | 5 +- .../innerkits/napi/src/user_auth_impl.cpp | 263 +++++++++++------- services/include/userauth_async_proxy.h | 4 +- services/src/userauth_async_proxy.cpp | 53 +--- services/src/userauth_excallback_impl.cpp | 2 +- 7 files changed, 195 insertions(+), 155 deletions(-) diff --git a/interfaces/innerkits/napi/include/auth_common.h b/interfaces/innerkits/napi/include/auth_common.h index e32a51174..dcecddd60 100755 --- a/interfaces/innerkits/napi/include/auth_common.h +++ b/interfaces/innerkits/napi/include/auth_common.h @@ -58,9 +58,8 @@ struct CallBackInfo { }; struct GetPropertyInfo { - GetPropertyInfo() : asyncWork(nullptr), result(nullptr) {}; + GetPropertyInfo() : result(nullptr) {}; CallBackInfo callBackInfo; - napi_async_work asyncWork; napi_value result; int32_t authType; std::vector keys; diff --git a/interfaces/innerkits/napi/include/user_auth_impl.h b/interfaces/innerkits/napi/include/user_auth_impl.h index 80b469cd2..877dececd 100755 --- a/interfaces/innerkits/napi/include/user_auth_impl.h +++ b/interfaces/innerkits/napi/include/user_auth_impl.h @@ -23,6 +23,12 @@ namespace OHOS { namespace UserIAM { namespace UserAuth { +typedef struct AsyncHolder { + AsyncHolder() : data(nullptr), asyncWork(nullptr) {}; + void *data; + napi_async_work asyncWork; +} AsyncHolder; + class UserAuthImpl { public: UserAuthImpl(); @@ -37,16 +43,18 @@ public: napi_value CancelAuth(napi_env env, napi_callback_info info); private: - napi_value GetPropertyWrap(napi_env env, napi_callback_info info, GetPropertyInfo *getPropertyInfo); - napi_value GetPropertyAsync(napi_env env, GetPropertyInfo *getPropertyInfo); - napi_value GetPropertyPromise(napi_env env, GetPropertyInfo *getPropertyInfo); + napi_value GetPropertyWrap(napi_env env, napi_callback_info info, AsyncHolder *asyncHolder); + napi_value GetPropertyAsync(napi_env env, AsyncHolder *asyncHolder); + napi_value GetPropertyPromise(napi_env env, AsyncHolder *asyncHolder); - napi_value SetPropertyWrap(napi_env env, napi_callback_info info, SetPropertyInfo *setPropertyInfo); - napi_value SetPropertyAsync(napi_env env, SetPropertyInfo *setPropertyInfo); - napi_value SetPropertyPromise(napi_env env, SetPropertyInfo *setPropertyInfo); + napi_value SetPropertyWrap(napi_env env, napi_callback_info info, AsyncHolder *asyncHolder); + napi_value SetPropertyAsync(napi_env env, AsyncHolder *asyncHolder); + napi_value SetPropertyPromise(napi_env env, AsyncHolder *asyncHolder); napi_value AuthWrap(napi_env env, AuthInfo *authInfo); + napi_value BuildAuthInfo(napi_env env, AuthInfo *authInfo); napi_value AuthUserWrap(napi_env env, AuthUserInfo *userInfo); + napi_value BuildAuthUserInfo(napi_env env, AuthUserInfo *userInfo); static void SetPropertyExecute(napi_env env, void *data); static void SetPropertyPromiseExecuteDone(napi_env env, napi_status status, void *data); diff --git a/interfaces/innerkits/napi/src/authapi_callback.cpp b/interfaces/innerkits/napi/src/authapi_callback.cpp index 620c60d6a..7abfba6b2 100755 --- a/interfaces/innerkits/napi/src/authapi_callback.cpp +++ b/interfaces/innerkits/napi/src/authapi_callback.cpp @@ -49,8 +49,9 @@ napi_value AuthApiCallback::BuildExecutorProperty( NAPI_CALL(env, napi_create_uint32(env, freezingTime, &freezingTimeValue)); NAPI_CALL(env, napi_set_named_property(env, jsObject, "freezingTime", freezingTimeValue)); - napi_value jsType = Uint64ToNapi(env, authSubType); - NAPI_CALL(env, napi_set_named_property(env, jsObject, "authSubType", jsType)); + napi_value authSubTypeValue = nullptr; + NAPI_CALL(env, napi_create_uint32(env, static_cast(authSubType), &authSubTypeValue)); + NAPI_CALL(env, napi_set_named_property(env, jsObject, "authSubType", authSubTypeValue)); return jsObject; } diff --git a/interfaces/innerkits/napi/src/user_auth_impl.cpp b/interfaces/innerkits/napi/src/user_auth_impl.cpp index ceeb649a9..50bbc87a7 100755 --- a/interfaces/innerkits/napi/src/user_auth_impl.cpp +++ b/interfaces/innerkits/napi/src/user_auth_impl.cpp @@ -72,14 +72,35 @@ napi_value UserAuthImpl::GetAvailabeStatus(napi_env env, napi_callback_info info napi_value UserAuthImpl::GetProperty(napi_env env, napi_callback_info info) { + AsyncHolder *asyncHolder = new (std::nothrow) AsyncHolder(); + if (asyncHolder == nullptr) { + HILOG_ERROR("%{public}s asyncHolder nullptr", __func__); + return nullptr; + } GetPropertyInfo *getPropertyInfo = new (std::nothrow) GetPropertyInfo(); + if (getPropertyInfo == nullptr) { + delete asyncHolder; + HILOG_ERROR("%{public}s getPropertyInfo nullptr", __func__); + return nullptr; + } getPropertyInfo->callBackInfo.env = env; - return GetPropertyWrap(env, info, getPropertyInfo); + asyncHolder->data = getPropertyInfo; + napi_value ret = GetPropertyWrap(env, info, asyncHolder); + if (ret == nullptr) { + HILOG_ERROR("%{public}s GetPropertyWrap fail", __func__); + delete getPropertyInfo; + delete asyncHolder; + if (asyncHolder->asyncWork != nullptr) { + napi_delete_async_work(env, asyncHolder->asyncWork); + } + } + return ret; } -napi_value UserAuthImpl::GetPropertyWrap(napi_env env, napi_callback_info info, GetPropertyInfo *getPropertyInfo) +napi_value UserAuthImpl::GetPropertyWrap(napi_env env, napi_callback_info info, AsyncHolder *asyncHolder) { HILOG_INFO("%{public}s, called", __func__); + GetPropertyInfo *getPropertyInfo = reinterpret_cast(asyncHolder->data); size_t argcAsync = ARGS_TWO; const size_t argcPromise = ARGS_ONE; const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT; @@ -96,18 +117,16 @@ napi_value UserAuthImpl::GetPropertyWrap(napi_env env, napi_callback_info info, NAPI_CALL(env, napi_create_reference(env, args[PARAM1], 1, &(getPropertyInfo->callBackInfo.callBack))); } } - if (authBuild.NapiTypeObject(env, args[PARAM0])) { Napi_GetPropertyRequest request = authBuild.GetPropertyRequestBuild(env, args[0]); getPropertyInfo->authType = request.authType_; getPropertyInfo->keys = request.keys_; } - - napi_value ret = 0; + napi_value ret = nullptr; if (argcAsync > argcPromise) { - ret = GetPropertyAsync(env, getPropertyInfo); + ret = GetPropertyAsync(env, asyncHolder); } else { - ret = GetPropertyPromise(env, getPropertyInfo); + ret = GetPropertyPromise(env, asyncHolder); } HILOG_INFO("%{public}s,end.", __func__); return ret; @@ -116,66 +135,66 @@ napi_value UserAuthImpl::GetPropertyWrap(napi_env env, napi_callback_info info, void UserAuthImpl::GetPropertyExecute(napi_env env, void *data) { HILOG_INFO("GetPropertyExecute, worker pool thread execute."); - GetPropertyInfo *getPropertyInfo = static_cast(data); - if (getPropertyInfo != nullptr) { - AuthType authTypeGet = AuthType(getPropertyInfo->authType); - - GetPropertyRequest request; - request.authType = authTypeGet; - request.keys = getPropertyInfo->keys; - HILOG_INFO("GetPropertyExecute start 1"); - AuthApiCallback *object = new AuthApiCallback(); - object->getPropertyInfo_ = getPropertyInfo; - std::shared_ptr callback; - callback.reset(object); - UserAuth::GetInstance().GetProperty(request, callback); - } else { - HILOG_ERROR("GetPropertyExecute, asynccallBackInfo == nullptr"); + AsyncHolder *asyncHolder = reinterpret_cast(data); + if (asyncHolder == nullptr) { + HILOG_ERROR("GetPropertyExecute, asyncHolder == nullptr"); + return; + } + GetPropertyInfo *getPropertyInfo = reinterpret_cast(asyncHolder->data); + if (getPropertyInfo == nullptr) { + HILOG_ERROR("GetPropertyExecute, getPropertyInfo == nullptr"); + return; } + AuthType authTypeGet = AuthType(getPropertyInfo->authType); + + GetPropertyRequest request; + request.authType = authTypeGet; + request.keys = getPropertyInfo->keys; + HILOG_INFO("GetPropertyExecute start 1"); + AuthApiCallback *object = new AuthApiCallback(); + object->getPropertyInfo_ = getPropertyInfo; + std::shared_ptr callback; + callback.reset(object); + UserAuth::GetInstance().GetProperty(request, callback); HILOG_INFO("GetPropertyExecute, worker pool thread execute end."); } void UserAuthImpl::GetPropertyPromiseExecuteDone(napi_env env, napi_status status, void *data) { HILOG_INFO("GetPropertyPromiseExecuteDone, start"); - GetPropertyInfo *getPropertyInfo = static_cast(data); - napi_delete_async_work(env, getPropertyInfo->asyncWork); + AsyncHolder *asyncHolder = reinterpret_cast(data); + napi_delete_async_work(env, asyncHolder->asyncWork); + delete asyncHolder; HILOG_INFO("GetPropertyPromiseExecuteDone, end"); } void UserAuthImpl::GetPropertyAsyncExecuteDone(napi_env env, napi_status status, void *data) { HILOG_INFO("GetPropertyAsyncExecuteDone, start"); - GetPropertyInfo *getPropertyInfo = static_cast(data); - napi_delete_async_work(env, getPropertyInfo->asyncWork); + AsyncHolder *asyncHolder = reinterpret_cast(data); + napi_delete_async_work(env, asyncHolder->asyncWork); + delete asyncHolder; HILOG_INFO("GetPropertyAsyncExecuteDone, end"); } -napi_value UserAuthImpl::GetPropertyAsync(napi_env env, GetPropertyInfo *getPropertyInfo) +napi_value UserAuthImpl::GetPropertyAsync(napi_env env, AsyncHolder *asyncHolder) { HILOG_INFO("%{public}s, asyncCallback.", __func__); - if (getPropertyInfo == nullptr) { - HILOG_ERROR("%{public}s, param == nullptr.", __func__); - return nullptr; - } - napi_value resourceName = 0; + napi_value result = nullptr; + NAPI_CALL(env, napi_get_null(env, &result)); + napi_value resourceName = nullptr; NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, GetPropertyExecute, GetPropertyAsyncExecuteDone, - (void *)getPropertyInfo, &getPropertyInfo->asyncWork)); - NAPI_CALL(env, napi_queue_async_work(env, getPropertyInfo->asyncWork)); - napi_value result = 0; - NAPI_CALL(env, napi_get_null(env, &result)); + (void *)asyncHolder, &asyncHolder->asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, asyncHolder->asyncWork)); HILOG_INFO("%{public}s, asyncCallback end.", __func__); return result; } -napi_value UserAuthImpl::GetPropertyPromise(napi_env env, GetPropertyInfo *getPropertyInfo) +napi_value UserAuthImpl::GetPropertyPromise(napi_env env, AsyncHolder *asyncHolder) { HILOG_INFO("%{public}s, promise.", __func__); - if (getPropertyInfo == nullptr) { - HILOG_ERROR("%{public}s, param == nullptr.", __func__); - return nullptr; - } + GetPropertyInfo *getPropertyInfo = reinterpret_cast(asyncHolder->data); napi_value resourceName = 0; NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); napi_deferred deferred; @@ -183,24 +202,44 @@ napi_value UserAuthImpl::GetPropertyPromise(napi_env env, GetPropertyInfo *getPr NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); getPropertyInfo->callBackInfo.callBack = nullptr; getPropertyInfo->callBackInfo.deferred = deferred; - NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, GetPropertyExecute, GetPropertyPromiseExecuteDone, - (void *)getPropertyInfo, &getPropertyInfo->asyncWork)); - NAPI_CALL(env, napi_queue_async_work(env, getPropertyInfo->asyncWork)); + (void *)asyncHolder, &asyncHolder->asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, asyncHolder->asyncWork)); HILOG_INFO("%{public}s, promise end.", __func__); return promise; } napi_value UserAuthImpl::SetProperty(napi_env env, napi_callback_info info) { + AsyncHolder *asyncHolder = new (std::nothrow) AsyncHolder(); + if (asyncHolder == nullptr) { + HILOG_ERROR("%{public}s asyncHolder nullptr", __func__); + return nullptr; + } SetPropertyInfo *setPropertyInfo = new (std::nothrow) SetPropertyInfo(); + if (setPropertyInfo == nullptr) { + delete asyncHolder; + HILOG_ERROR("%{public}s setPropertyInfo nullptr", __func__); + return nullptr; + } setPropertyInfo->callBackInfo.env = env; - return SetPropertyWrap(env, info, setPropertyInfo); + asyncHolder->data = setPropertyInfo; + napi_value ret = SetPropertyWrap(env, info, asyncHolder); + if (ret == nullptr) { + HILOG_ERROR("%{public}s SetPropertyWrap fail", __func__); + delete setPropertyInfo; + delete asyncHolder; + if (asyncHolder->asyncWork != nullptr) { + napi_delete_async_work(env, asyncHolder->asyncWork); + } + } + return ret; } -napi_value UserAuthImpl::SetPropertyWrap(napi_env env, napi_callback_info info, SetPropertyInfo *setPropertyInfo) +napi_value UserAuthImpl::SetPropertyWrap(napi_env env, napi_callback_info info, AsyncHolder *asyncHolder) { HILOG_INFO("%{public}s, called", __func__); + SetPropertyInfo *setPropertyInfo = reinterpret_cast(asyncHolder->data); size_t argcAsync = ARGS_TWO; const size_t argcPromise = ARGS_ONE; const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT; @@ -227,9 +266,9 @@ napi_value UserAuthImpl::SetPropertyWrap(napi_env env, napi_callback_info info, napi_value ret = 0; if (argcAsync > argcPromise) { - ret = SetPropertyAsync(env, setPropertyInfo); + ret = SetPropertyAsync(env, asyncHolder); } else { - ret = SetPropertyPromise(env, setPropertyInfo); + ret = SetPropertyPromise(env, asyncHolder); } HILOG_INFO("%{public}s,end.", __func__); return ret; @@ -238,86 +277,83 @@ napi_value UserAuthImpl::SetPropertyWrap(napi_env env, napi_callback_info info, void UserAuthImpl::SetPropertyExecute(napi_env env, void *data) { HILOG_INFO("setPropertyExecute, worker pool thread execute."); - SetPropertyInfo *setPropertyInfo = static_cast(data); - if (setPropertyInfo != nullptr) { - AuthType authTypeGet = AuthType(setPropertyInfo->authType); - - SetPropertyRequest request; - request.authType = authTypeGet; - request.key = SetPropertyType(setPropertyInfo->key); - request.setInfo = setPropertyInfo->setInfo; - AuthApiCallback *object = new AuthApiCallback(); - object->setPropertyInfo_ = setPropertyInfo; - std::shared_ptr callback; - callback.reset(object); - UserAuth::GetInstance().SetProperty(request, callback); - } else { - HILOG_ERROR("setPropertyExecute, asynccallBackInfo == nullptr"); + AsyncHolder *asyncHolder = reinterpret_cast(data); + if (asyncHolder == nullptr) { + HILOG_ERROR("SetPropertyExecute, asyncHolder == nullptr"); + return; + } + SetPropertyInfo *setPropertyInfo = reinterpret_cast(asyncHolder->data); + if (setPropertyInfo == nullptr) { + HILOG_ERROR("SetPropertyExecute, setPropertyInfo == nullptr"); + return; } + AuthType authTypeGet = AuthType(setPropertyInfo->authType); + SetPropertyRequest request; + request.authType = authTypeGet; + request.key = SetPropertyType(setPropertyInfo->key); + request.setInfo = setPropertyInfo->setInfo; + AuthApiCallback *object = new AuthApiCallback(); + object->setPropertyInfo_ = setPropertyInfo; + std::shared_ptr callback; + callback.reset(object); + UserAuth::GetInstance().SetProperty(request, callback); HILOG_INFO("setPropertyExecute, worker pool thread execute end."); } void UserAuthImpl::SetPropertyPromiseExecuteDone(napi_env env, napi_status status, void *data) { HILOG_INFO("SetPropertyPromiseExecuteDone, start"); - SetPropertyInfo *setPropertyInfo = static_cast(data); - napi_delete_async_work(env, setPropertyInfo->asyncWork); + AsyncHolder *asyncHolder = reinterpret_cast(data); + napi_delete_async_work(env, asyncHolder->asyncWork); + delete asyncHolder; HILOG_INFO("SetPropertyPromiseExecuteDone, end"); } void UserAuthImpl::SetPropertyAsyncExecuteDone(napi_env env, napi_status status, void *data) { HILOG_INFO("SetPropertyAsyncExecuteDone, start"); - SetPropertyInfo *setPropertyInfo = static_cast(data); - napi_delete_async_work(env, setPropertyInfo->asyncWork); + AsyncHolder *asyncHolder = reinterpret_cast(data); + napi_delete_async_work(env, asyncHolder->asyncWork); + delete asyncHolder; HILOG_INFO("SetPropertyAsyncExecuteDone, end"); } -napi_value UserAuthImpl::SetPropertyAsync(napi_env env, SetPropertyInfo *setPropertyInfo) +napi_value UserAuthImpl::SetPropertyAsync(napi_env env, AsyncHolder *asyncHolder) { HILOG_INFO("%{public}s, asyncCallback.", __func__); - if (setPropertyInfo == nullptr) { - HILOG_ERROR("%{public}s, param == nullptr.", __func__); - return nullptr; - } - napi_value resourceName = 0; + napi_value result = nullptr; + NAPI_CALL(env, napi_get_null(env, &result)); + napi_value resourceName = nullptr; NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, SetPropertyExecute, SetPropertyAsyncExecuteDone, - (void *)setPropertyInfo, &setPropertyInfo->asyncWork)); - NAPI_CALL(env, napi_queue_async_work(env, setPropertyInfo->asyncWork)); - napi_value result = 0; - NAPI_CALL(env, napi_get_null(env, &result)); + (void *)asyncHolder, &asyncHolder->asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, asyncHolder->asyncWork)); HILOG_INFO("%{public}s, asyncCallback end.", __func__); return result; } -napi_value UserAuthImpl::SetPropertyPromise(napi_env env, SetPropertyInfo *setPropertyInfo) +napi_value UserAuthImpl::SetPropertyPromise(napi_env env, AsyncHolder *asyncHolder) { HILOG_INFO("%{public}s, promise.", __func__); - if (setPropertyInfo == nullptr) { - HILOG_ERROR("%{public}s, param == nullptr.", __func__); - return nullptr; - } + SetPropertyInfo *setPropertyInfo = reinterpret_cast(asyncHolder->data); napi_value resourceName = 0; NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); napi_deferred deferred; - napi_value promise = 0; + napi_value promise = nullptr; NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); setPropertyInfo->callBackInfo.callBack = nullptr; setPropertyInfo->callBackInfo.deferred = deferred; - - NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, SetPropertyExecute, SetPropertyPromiseExecuteDone, - (void *)setPropertyInfo, &setPropertyInfo->asyncWork)); - NAPI_CALL(env, napi_queue_async_work(env, setPropertyInfo->asyncWork)); + NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, + SetPropertyExecute, SetPropertyPromiseExecuteDone, (void *)asyncHolder, &asyncHolder->asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, asyncHolder->asyncWork)); HILOG_INFO("%{public}s, promise end.", __func__); return promise; } -napi_value UserAuthImpl::Auth(napi_env env, napi_callback_info info) +napi_value UserAuthImpl::BuildAuthInfo(napi_env env, AuthInfo *authInfo) { - HILOG_INFO("%{public}s, start", __func__); - AuthInfo *authInfo = new (std::nothrow) AuthInfo(); - authInfo->info = info; + napi_value result = nullptr; + NAPI_CALL(env, napi_get_null(env, &result)); authInfo->callBackInfo.env = env; size_t argc = ARGS_MAX_COUNT; napi_value argv[ARGS_MAX_COUNT] = {nullptr}; @@ -347,16 +383,30 @@ napi_value UserAuthImpl::Auth(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_get_named_property(env, argv[PARAM3], "onAcquireInfo", &authInfo->onAcquireInfoCallBack)); NAPI_CALL(env, napi_create_reference(env, authInfo->onAcquireInfoCallBack, PARAM1, &authInfo->onAcquireInfo)); } - return AuthWrap(env, authInfo); + return result; } -napi_value UserAuthImpl::AuthWrap(napi_env env, AuthInfo *authInfo) +napi_value UserAuthImpl::Auth(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start.", __func__); + HILOG_INFO("%{public}s, start", __func__); + AuthInfo *authInfo = new (std::nothrow) AuthInfo(); if (authInfo == nullptr) { - HILOG_ERROR("%{public}s, param == nullptr.", __func__); + HILOG_INFO("%{public}s authInfo nullptr", __func__); return nullptr; } + authInfo->info = info; + napi_value ret = BuildAuthInfo(env, authInfo); + if (ret == nullptr) { + HILOG_INFO("%{public}s BuildAuthInfo fail", __func__); + delete authInfo; + return ret; + } + return AuthWrap(env, authInfo); +} + +napi_value UserAuthImpl::AuthWrap(napi_env env, AuthInfo *authInfo) +{ + HILOG_INFO("%{public}s, start.", __func__); AuthApiCallback *object = new AuthApiCallback(); object->authInfo_ = authInfo; object->userInfo_ = nullptr; @@ -374,8 +424,25 @@ napi_value UserAuthImpl::AuthUser(napi_env env, napi_callback_info info) { HILOG_INFO("%{public}s, start.", __func__); AuthUserInfo *userInfo = new (std::nothrow) AuthUserInfo(); + if (userInfo == nullptr) { + HILOG_INFO("%{public}s userInfo nullptr", __func__); + return nullptr; + } userInfo->callBackInfo.env = env; userInfo->info = info; + napi_value ret = BuildAuthUserInfo(env, userInfo); + if (ret == nullptr) { + HILOG_INFO("%{public}s BuildAuthUserInfo fail", __func__); + delete userInfo; + return ret; + } + return AuthUserWrap(env, userInfo); +} + +napi_value UserAuthImpl::BuildAuthUserInfo(napi_env env, AuthUserInfo *userInfo) +{ + napi_value result = nullptr; + NAPI_CALL(env, napi_get_null(env, &result)); size_t argc = ARGS_MAX_COUNT; napi_value argv[ARGS_MAX_COUNT] = {nullptr}; NAPI_CALL(env, napi_get_cb_info(env, userInfo->info, &argc, argv, nullptr, nullptr)); @@ -407,16 +474,12 @@ napi_value UserAuthImpl::AuthUser(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_get_named_property(env, argv[PARAM4], "onAcquireInfo", &userInfo->onAcquireInfoCallBack)); NAPI_CALL(env, napi_create_reference(env, userInfo->onAcquireInfoCallBack, PARAM1, &userInfo->onAcquireInfo)); } - return AuthUserWrap(env, userInfo); + return result; } napi_value UserAuthImpl::AuthUserWrap(napi_env env, AuthUserInfo *userInfo) { HILOG_INFO("%{public}s, start.", __func__); - if (userInfo == nullptr) { - HILOG_ERROR("%{public}s, param == nullptr.", __func__); - return nullptr; - } AuthApiCallback *object = new AuthApiCallback(); object->authInfo_ = nullptr; object->userInfo_ = userInfo; diff --git a/services/include/userauth_async_proxy.h b/services/include/userauth_async_proxy.h index e3b3f2738..f34f67f50 100755 --- a/services/include/userauth_async_proxy.h +++ b/services/include/userauth_async_proxy.h @@ -37,8 +37,6 @@ public: private: bool SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply); - void WriteFailResult(const ExecutorProperty &result, ExecutorProperty &resultFail, - MessageParcel &data); private: static inline BrokerDelegator delegator_; @@ -46,4 +44,4 @@ private: } // namespace UserAuth } // namespace UserIAM } // namespace OHOS -#endif // USERAUTH_ASYNC_PROXY_H \ No newline at end of file +#endif // USERAUTH_ASYNC_PROXY_H diff --git a/services/src/userauth_async_proxy.cpp b/services/src/userauth_async_proxy.cpp index da472454d..d12862b1d 100755 --- a/services/src/userauth_async_proxy.cpp +++ b/services/src/userauth_async_proxy.cpp @@ -90,61 +90,32 @@ void UserAuthAsyncProxy::onExecutorPropertyInfo(const ExecutorProperty result) USERAUTH_HILOGD(MODULE_SERVICE, "userauthAsyncProxy onExecutorPropertyInfo enter"); MessageParcel data; MessageParcel reply; - ExecutorProperty resultFail; if (!data.WriteInterfaceToken(UserAuthAsyncProxy::GetDescriptor())) { USERAUTH_HILOGI(MODULE_SERVICE, "userauth write descriptor failed!"); return ; } - if (result.result != SUCCESS) { - WriteFailResult(result, resultFail, data); - } else { - if (!data.WriteInt32(result.result)) { - USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteInt32(result.result)."); - return; - } - if (!data.WriteUint64(result.authSubType)) { - USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteUint64(result.authSubType)."); - return; - } - if (!data.WriteUint32(result.remainTimes)) { - USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteUint32(result.remainTimes)."); - return; - } - if (!data.WriteUint32(result.freezingTime)) { - USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteUint32(result.freezingTime)."); - return; - } - } - bool ret = SendRequest(IUserAuth::USER_AUTH_GETEXPORP, data, reply); - if (ret) { - int32_t result = reply.ReadInt32(); - USERAUTH_HILOGE(MODULE_SERVICE, "userauth result = %{public}d", result); - } - return; -} - -void UserAuthAsyncProxy::WriteFailResult(const ExecutorProperty &result, ExecutorProperty &resultFail, - MessageParcel &data) -{ - resultFail.authSubType = PIN_SIX; - resultFail.freezingTime = 0; - resultFail.remainTimes = 0; if (!data.WriteInt32(result.result)) { USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteInt32(result.result)."); return; } - if (!data.WriteUint64(resultFail.authSubType)) { - USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteUint64(resultFail.authSubType)."); + if (!data.WriteUint64(result.authSubType)) { + USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteUint64(result.authSubType)."); return; } - if (!data.WriteUint32(resultFail.remainTimes)) { - USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteUint32(resultFail.remainTimes)."); + if (!data.WriteUint32(result.remainTimes)) { + USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteUint32(result.remainTimes)."); return; } - if (!data.WriteUint32(resultFail.freezingTime)) { - USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteUint32(resultFail.freezingTime)."); + if (!data.WriteUint32(result.freezingTime)) { + USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteUint32(result.freezingTime)."); return; } + bool ret = SendRequest(IUserAuth::USER_AUTH_GETEXPORP, data, reply); + if (ret) { + int32_t result = reply.ReadInt32(); + USERAUTH_HILOGE(MODULE_SERVICE, "userauth result = %{public}d", result); + } + return; } void UserAuthAsyncProxy::onSetExecutorProperty(const int32_t result) diff --git a/services/src/userauth_excallback_impl.cpp b/services/src/userauth_excallback_impl.cpp index 6f15a822c..695f81c01 100644 --- a/services/src/userauth_excallback_impl.cpp +++ b/services/src/userauth_excallback_impl.cpp @@ -278,7 +278,7 @@ UserAuthCallbackImplIDMGetPorp::UserAuthCallbackImplIDMGetPorp(const sptr& info) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthCallbackImplIDMGetPorp OnGetInfo enter"); - ExecutorProperty executorProperty; + ExecutorProperty executorProperty = {}; if (info.size() == 0) { executorProperty.result = GENERAL_ERROR; callback_->onExecutorPropertyInfo(executorProperty); -- Gitee