From 4df5dff6ff86ae691427bf72fcea1eaf324bb1d3 Mon Sep 17 00:00:00 2001 From: wangxu43 Date: Tue, 15 Feb 2022 15:24:16 +0800 Subject: [PATCH] Add api6 of user auth Signed-off-by: wangxu43 --- bundle.json | 21 +++- interfaces/innerkits/napi/BUILD.gn | 40 +++++++ .../innerkits/napi/include/auth_common.h | 12 ++ .../innerkits/napi/include/authapi_callback.h | 3 + .../innerkits/napi/include/user_auth_helper.h | 2 + .../innerkits/napi/include/user_auth_impl.h | 4 + .../innerkits/napi/src/auth_native_module.cpp | 4 + .../innerkits/napi/src/authapi_callback.cpp | 69 ++++++++++++ .../innerkits/napi/src/user_auth_helper.cpp | 14 +++ .../innerkits/napi/src/user_auth_impl.cpp | 103 ++++++++++++++++++ 10 files changed, 270 insertions(+), 2 deletions(-) diff --git a/bundle.json b/bundle.json index c096012..9127848 100644 --- a/bundle.json +++ b/bundle.json @@ -41,7 +41,7 @@ "//base/user_iam/user_auth/interfaces/kits/napi:userauthnorth" ], "inner_kits": [ - { + { "type": "so", "name": "//base/user_iam/user_auth/interfaces/innerkits/native:userauth_framework", "header": { @@ -57,7 +57,7 @@ "header_base": "//base/user_iam/user_auth/interfaces/innerkits/native/include" } }, - { + { "type": "so", "name": "//base/user_iam/user_auth/interfaces/innerkits/napi:userauth", "header": { @@ -73,6 +73,23 @@ ], "header_base": "//base/user_iam/user_auth/interfaces/innerkits/napi/include" } + }, + { + "type": "so", + "name": "//base/user_iam/user_auth/interfaces/innerkits/napi:userauth_napi", + "header": { + "header_files": [ + "auth_build.h", + "auth_common.h", + "auth_hilog_wrapper.h", + "auth_object.h", + "authapi_callback.h", + "result_convert.h", + "user_auth_helper.h", + "user_auth_impl.h" + ], + "header_base": "//base/user_iam/user_auth/interfaces/innerkits/napi/include" + } } ], "test": [ diff --git a/interfaces/innerkits/napi/BUILD.gn b/interfaces/innerkits/napi/BUILD.gn index 66db8e7..a9a5e15 100755 --- a/interfaces/innerkits/napi/BUILD.gn +++ b/interfaces/innerkits/napi/BUILD.gn @@ -58,3 +58,43 @@ ohos_shared_library("userauth") { part_name = "user_auth" subsystem_name = "user_iam" } + +ohos_shared_library("userauth_napi") { + cflags = [ + "-fPIC", + "-g3", + ] + + defines = [ "USER_AUTH_FOR_API6" ] + + sources = [ + "src/auth_build.cpp", + "src/auth_native_module.cpp", + "src/authapi_callback.cpp", + "src/result_convert.cpp", + "src/user_auth_helper.cpp", + "src/user_auth_impl.cpp", + ] + + deps = [ + "${userauth_innerkits_path}/native:userauth_framework", + "//foundation/ace/napi:ace_napi", + "//utils/native/base:utils", + ] + + configs = [ "${userauth_utils_path}:utils_config" ] + + public_configs = [ ":userauth_public_config" ] + + external_deps = [ + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr_standard:samgr_proxy", + ] + + relative_install_dir = "module/useriam" + + part_name = "user_auth" + subsystem_name = "user_iam" +} diff --git a/interfaces/innerkits/napi/include/auth_common.h b/interfaces/innerkits/napi/include/auth_common.h index dcecddd..7ea7226 100755 --- a/interfaces/innerkits/napi/include/auth_common.h +++ b/interfaces/innerkits/napi/include/auth_common.h @@ -15,6 +15,7 @@ #ifndef OHOS_USERAUTH_COMMON_H #define OHOS_USERAUTH_COMMON_H +#include #include #include "napi/native_api.h" @@ -80,6 +81,17 @@ struct SetPropertyInfo { int32_t setResult; }; +struct ExecuteInfo { + bool isPromise; + napi_env env; + std::string type; + std::string level; + napi_ref callbackRef; + napi_deferred deferred; + napi_value promise; + int32_t result; +}; + struct AuthInfo { AuthInfo() : asyncWork(nullptr) {}; CallBackInfo callBackInfo; diff --git a/interfaces/innerkits/napi/include/authapi_callback.h b/interfaces/innerkits/napi/include/authapi_callback.h index d1b5713..8582069 100755 --- a/interfaces/innerkits/napi/include/authapi_callback.h +++ b/interfaces/innerkits/napi/include/authapi_callback.h @@ -39,6 +39,7 @@ class AuthApiCallback : public UserAuthCallback { public: AuthApiCallback(AuthInfo *authInfo); AuthApiCallback(AuthUserInfo *userInfo); + AuthApiCallback(ExecuteInfo *executeInfo); virtual ~AuthApiCallback(); void onAcquireInfo(const int32_t module, const uint32_t acquireInfo, const int32_t extraInfo) override; void onResult(const int32_t result, const AuthResult extraInfo) override; @@ -51,9 +52,11 @@ private: void OnAuthAcquireInfo(AcquireInfoInner *acquireInfoInner); void OnUserAuthResult(const int32_t result, const AuthResult extraInfo); void OnAuthResult(const int32_t result, const AuthResult extraInfo); + void OnExecuteResult(const int32_t result); AuthInfo *authInfo_; AuthUserInfo *userInfo_; + ExecuteInfo *executeInfo_; }; class GetPropApiCallback : public GetPropCallback { diff --git a/interfaces/innerkits/napi/include/user_auth_helper.h b/interfaces/innerkits/napi/include/user_auth_helper.h index a75856c..c00744c 100755 --- a/interfaces/innerkits/napi/include/user_auth_helper.h +++ b/interfaces/innerkits/napi/include/user_auth_helper.h @@ -100,6 +100,8 @@ napi_value SetProperty(napi_env env, napi_callback_info info); */ napi_value Auth(napi_env env, napi_callback_info info); +napi_value Execute(napi_env env, napi_callback_info info); + /** * @brief user authentication * diff --git a/interfaces/innerkits/napi/include/user_auth_impl.h b/interfaces/innerkits/napi/include/user_auth_impl.h index 877dece..da9c40b 100755 --- a/interfaces/innerkits/napi/include/user_auth_impl.h +++ b/interfaces/innerkits/napi/include/user_auth_impl.h @@ -39,6 +39,7 @@ public: napi_value GetProperty(napi_env env, napi_callback_info info); napi_value SetProperty(napi_env env, napi_callback_info info); napi_value Auth(napi_env env, napi_callback_info info); + napi_value Execute(napi_env env, napi_callback_info info); napi_value AuthUser(napi_env env, napi_callback_info info); napi_value CancelAuth(napi_env env, napi_callback_info info); @@ -56,6 +57,9 @@ private: napi_value AuthUserWrap(napi_env env, AuthUserInfo *userInfo); napi_value BuildAuthUserInfo(napi_env env, AuthUserInfo *userInfo); + bool GetExecuteInfo(napi_env env, napi_value* argv, ExecuteInfo* executeInfo); + napi_value DoExecute(ExecuteInfo* executeInfo); + static void SetPropertyExecute(napi_env env, void *data); static void SetPropertyPromiseExecuteDone(napi_env env, napi_status status, void *data); static void SetPropertyAsyncExecuteDone(napi_env env, napi_status status, void *data); diff --git a/interfaces/innerkits/napi/src/auth_native_module.cpp b/interfaces/innerkits/napi/src/auth_native_module.cpp index d6277d4..4b9b1ab 100755 --- a/interfaces/innerkits/napi/src/auth_native_module.cpp +++ b/interfaces/innerkits/napi/src/auth_native_module.cpp @@ -31,7 +31,11 @@ extern "C" __attribute__((constructor)) void RegisterModule(void) .nm_flags = 0, // normal .nm_filename = nullptr, .nm_register_func = ModuleInit, +#ifdef USER_AUTH_FOR_API6 + .nm_modname = "userIAM.userAuth", +#else .nm_modname = "UserAuth", +#endif .nm_priv = nullptr, .reserved = {}}; napi_module_register(&module); diff --git a/interfaces/innerkits/napi/src/authapi_callback.cpp b/interfaces/innerkits/napi/src/authapi_callback.cpp index 876decb..80bd445 100755 --- a/interfaces/innerkits/napi/src/authapi_callback.cpp +++ b/interfaces/innerkits/napi/src/authapi_callback.cpp @@ -27,12 +27,21 @@ AuthApiCallback::AuthApiCallback(AuthInfo *authInfo) { authInfo_ = authInfo; userInfo_ = nullptr; + executeInfo_ = nullptr; } AuthApiCallback::AuthApiCallback(AuthUserInfo *userInfo) { authInfo_ = nullptr; userInfo_ = userInfo; + executeInfo_ = nullptr; +} + +AuthApiCallback::AuthApiCallback(ExecuteInfo *executeInfo) +{ + authInfo_ = nullptr; + userInfo_ = nullptr; + executeInfo_ = executeInfo; } AuthApiCallback::~AuthApiCallback() @@ -269,6 +278,61 @@ void AuthApiCallback::OnAuthResult(const int32_t result, const AuthResult extraI uv_queue_work(loop, work, [] (uv_work_t *work) {}, OnAuthResultWork); } +static void OnExecuteResultWork(uv_work_t *work, int status) +{ + HILOG_INFO("Do OnExecuteResultWork"); + ExecuteInfo *executeInfo = reinterpret_cast(work->data); + if (executeInfo == nullptr) { + HILOG_ERROR("executeInfo is null"); + delete work; + return; + } + napi_env env = executeInfo->env; + napi_value result; + if (napi_create_int32(env, executeInfo->result, &result) != napi_ok) { + HILOG_ERROR("napi_create_int32 faild"); + delete work; + delete executeInfo; + return; + } + napi_value undefined; + napi_get_undefined(env, &undefined); + if (executeInfo->isPromise) { + HILOG_INFO("do promise %{public}d", napi_resolve_deferred(env, executeInfo->deferred, result)); + } else { + napi_value callback; + napi_get_reference_value(env, executeInfo->callbackRef, &callback); + napi_value callResult = nullptr; + HILOG_INFO("do callback %{public}d", napi_call_function(env, undefined, callback, 1, &result, &callResult)); + } + delete executeInfo; + delete work; +} + +void AuthApiCallback::OnExecuteResult(const int32_t result) +{ + HILOG_INFO("AuthApiCallback OnExecuteResult start"); + uv_loop_s *loop(nullptr); + napi_get_uv_event_loop(executeInfo_->env, &loop); + if (loop == nullptr) { + HILOG_ERROR("loop is null"); + delete executeInfo_; + executeInfo_ = nullptr; + return; + } + uv_work_t *work = new (std::nothrow) uv_work_t; + if (work == nullptr) { + HILOG_ERROR("work is null"); + delete executeInfo_; + executeInfo_ = nullptr; + return; + } + executeInfo_->result = result; + work->data = reinterpret_cast(executeInfo_); + executeInfo_ = nullptr; + uv_queue_work(loop, work, [] (uv_work_t *work) {}, OnExecuteResultWork); +} + void AuthApiCallback::onResult(const int32_t result, const AuthResult extraInfo) { HILOG_INFO("AuthApiCallback onResult start result = %{public}d", result); @@ -285,6 +349,11 @@ void AuthApiCallback::onResult(const int32_t result, const AuthResult extraInfo) } else { HILOG_ERROR("AuthApiCallback onResult authInfo_ is nullptr "); } + if (executeInfo_ != nullptr) { + OnExecuteResult(result); + } else { + HILOG_ERROR("AuthApiCallback onResult executeInfo_ is nullptr "); + } HILOG_INFO("AuthApiCallback onResult end"); } diff --git a/interfaces/innerkits/napi/src/user_auth_helper.cpp b/interfaces/innerkits/napi/src/user_auth_helper.cpp index e5982a1..4e6ffc2 100755 --- a/interfaces/innerkits/napi/src/user_auth_helper.cpp +++ b/interfaces/innerkits/napi/src/user_auth_helper.cpp @@ -144,6 +144,18 @@ napi_value Auth(napi_env env, napi_callback_info info) return userAuthImpl->Auth(env, info); } +napi_value Execute(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + size_t argcAsync = 0; + napi_value args[ARGS_MAX_COUNT] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); + UserAuthImpl *userAuthImpl = nullptr; + NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&userAuthImpl)); + HILOG_INFO("UserAuthHelper, Execute"); + return userAuthImpl->Execute(env, info); +} + /** * @brief user authentication * @@ -194,6 +206,7 @@ void Init(napi_env env, napi_value exports) napi_status status; napi_property_descriptor exportFuncs[] = { DECLARE_NAPI_FUNCTION("constructor", UserAuth::Constructor), + DECLARE_NAPI_FUNCTION("getAuthenticator", UserAuth::Constructor), }; status = napi_define_properties(env, exports, sizeof(exportFuncs) / sizeof(*exportFuncs), exportFuncs); if (status != napi_ok) { @@ -221,6 +234,7 @@ napi_value GetCtor(napi_env env) DECLARE_NAPI_FUNCTION("auth", UserAuth::Auth), DECLARE_NAPI_FUNCTION("authUser", UserAuth::AuthUser), DECLARE_NAPI_FUNCTION("cancelAuth", UserAuth::CancelAuth), + DECLARE_NAPI_FUNCTION("execute", UserAuth::Execute), }; NAPI_CALL(env, napi_define_class(env, "UserAuth", NAPI_AUTO_LENGTH, UserAuthServiceConstructor, nullptr, sizeof(clzDes) / sizeof(napi_property_descriptor), clzDes, &cons)); diff --git a/interfaces/innerkits/napi/src/user_auth_impl.cpp b/interfaces/innerkits/napi/src/user_auth_impl.cpp index d1f54dc..f77011c 100755 --- a/interfaces/innerkits/napi/src/user_auth_impl.cpp +++ b/interfaces/innerkits/napi/src/user_auth_impl.cpp @@ -15,6 +15,8 @@ #include "user_auth_impl.h" +#include + #include "user_auth.h" #include "userauth_callback.h" #include "userauth_info.h" @@ -384,6 +386,107 @@ napi_value UserAuthImpl::BuildAuthInfo(napi_env env, AuthInfo *authInfo) return result; } +napi_value UserAuthImpl::DoExecute(ExecuteInfo* executeInfo) +{ + AuthApiCallback *object = new (std::nothrow) AuthApiCallback(executeInfo); + if (object == nullptr) { + delete executeInfo; + return nullptr; + } + std::shared_ptr callback; + callback.reset(object); + std::map convertAuthTurstLevel = { + { "S1", ATL1 }, + { "S2", ATL2 }, + { "S3", ATL3 }, + { "S4", ATL4 }, + }; + if (convertAuthTurstLevel.count(executeInfo->level) == 0) { + HILOG_ERROR("execute convertAuthTurstLevel is 0"); + delete executeInfo; + return nullptr; + } + UserAuth::GetInstance().Auth(0, FACE, convertAuthTurstLevel[executeInfo->level], callback); + if (executeInfo->isPromise) { + return executeInfo->promise; + } else { + napi_value result = nullptr; + NAPI_CALL(executeInfo->env, napi_get_null(executeInfo->env, &result)); + return result; + } +} + +napi_value UserAuthImpl::Execute(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, start", __func__); + ExecuteInfo *executeInfo = new (std::nothrow) ExecuteInfo(); + if (executeInfo == nullptr) { + HILOG_ERROR("%{public}s executeInfo nullptr", __func__); + return nullptr; + } + executeInfo->env = env; + size_t argc = ARGS_MAX_COUNT; + size_t callbackIndex = 0; + napi_value argv[ARGS_MAX_COUNT] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + if (argc < PARAM2) { + HILOG_ERROR("%{public}s argc check fail", __func__); + delete executeInfo; + return nullptr; + } + if (!GetExecuteInfo(env, argv, executeInfo)) { + HILOG_ERROR("%{public}s GetExecuteInfo fail", __func__); + delete executeInfo; + return nullptr; + } + callbackIndex = argc - 1; + napi_valuetype valuetype; + NAPI_CALL(env, napi_typeof(env, argv[callbackIndex], &valuetype)); + if (valuetype == napi_function) { + executeInfo->isPromise = false; + NAPI_CALL(env, napi_create_reference(env, argv[callbackIndex], 1, &executeInfo->callbackRef)); + } else { + executeInfo->isPromise = true; + NAPI_CALL(env, napi_create_promise(env, &executeInfo->deferred, &executeInfo->promise)); + } + return DoExecute(executeInfo); +} + +bool UserAuthImpl::GetExecuteInfo(napi_env env, napi_value* argv, ExecuteInfo* executeInfo) +{ + HILOG_INFO("%{public}s, start.", __func__); + napi_valuetype valuetype; + napi_typeof(env, argv[PARAM0], &valuetype); + if (valuetype != napi_string) { + return false; + } + char *str = nullptr; + size_t len = 0; + napi_get_value_string_utf8(env, argv[PARAM0], nullptr, 0, &len); + if (len > 0) { + str = new char[len + 1](); + napi_get_value_string_utf8(env, argv[PARAM0], str, len + 1, &len); + executeInfo->type = str; + delete[] str; + } + napi_typeof(env, argv[PARAM1], &valuetype); + if (valuetype != napi_string) { + return false; + } + napi_get_value_string_utf8(env, argv[PARAM1], nullptr, 0, &len); + if (len > 0) { + str = new char[len + 1](); + napi_get_value_string_utf8(env, argv[PARAM1], str, len + 1, &len); + executeInfo->level = str; + delete[] str; + } + if (executeInfo->type.compare("FACE_ONLY") != 0) { + HILOG_ERROR("%{public}s check type fail.", __func__); + return false; + } + return true; +} + napi_value UserAuthImpl::Auth(napi_env env, napi_callback_info info) { HILOG_INFO("%{public}s, start", __func__);