From 9db82716952f7968fc891a321915ceaaeab52b6e Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Fri, 28 Jan 2022 14:31:49 +0800 Subject: [PATCH 01/19] [user_auth]code update 1 add C++ aip7 IF 2 fix setProperty for faceauth 3 code update for review Signed-off-by: yanfang.gu --- .../kitsimpl/src/iuserauth_api7_callback.cpp | 121 ++++++++++++++ frameworks/kitsimpl/src/userauth_api7.cpp | 148 +++++++++++++++++ .../kitsimpl/src/userauth_api7_datamgr.cpp | 55 +++++++ .../kitsimpl/src/userauth_async_stub.cpp | 26 +-- interfaces/innerkits/native/BUILD.gn | 3 + .../native/include/iuserauth_api7_callback.h | 43 +++++ .../innerkits/native/include/user_auth.h | 6 +- .../innerkits/native/include/userauth_api7.h | 41 +++++ .../native/include/userauth_api7_callback.h | 32 ++++ .../native/include/userauth_api7_datamgr.h | 41 +++++ .../include/userauth_api7_hilog_wrapper.h | 72 +++++++++ .../native/include/userauth_api7_info.h | 150 ++++++++++++++++++ .../innerkits/native/include/userauth_info.h | 44 ++--- services/include/userauth_adapter.h | 6 +- services/include/userauth_datamgr.h | 2 +- services/include/userauth_excallback_impl.h | 2 +- services/src/userauth_adapter.cpp | 82 +++++++--- services/src/userauth_async_proxy.cpp | 2 +- services/src/userauth_excallback_impl.cpp | 55 ++++--- services/src/userauth_service.cpp | 43 +++-- services/src/userauth_stub.cpp | 8 +- test/unittest/include/userauth_test.h | 5 + test/unittest/src/userauth_test.cpp | 48 ++++++ 23 files changed, 927 insertions(+), 108 deletions(-) create mode 100644 frameworks/kitsimpl/src/iuserauth_api7_callback.cpp create mode 100644 frameworks/kitsimpl/src/userauth_api7.cpp create mode 100644 frameworks/kitsimpl/src/userauth_api7_datamgr.cpp create mode 100755 interfaces/innerkits/native/include/iuserauth_api7_callback.h create mode 100755 interfaces/innerkits/native/include/userauth_api7.h create mode 100755 interfaces/innerkits/native/include/userauth_api7_callback.h create mode 100755 interfaces/innerkits/native/include/userauth_api7_datamgr.h create mode 100755 interfaces/innerkits/native/include/userauth_api7_hilog_wrapper.h create mode 100755 interfaces/innerkits/native/include/userauth_api7_info.h diff --git a/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp b/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp new file mode 100644 index 000000000..7b15f3226 --- /dev/null +++ b/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include + +#include "userauth_api7_hilog_wrapper.h" +#include "userauth_api7_datamgr.h" +#include "userauth_api7_info.h" +#include "iuserauth_api7_callback.h" +namespace OHOS { +namespace UserIAM { +namespace API7UserAuth { +std::map g_convertResult = { +{UserAuth::SUCCESS, API7UserAuth::SUCCESS}, +{UserAuth::FAIL, API7UserAuth::GENERAL_ERROR}, +{UserAuth::GENERAL_ERROR, API7UserAuth::GENERAL_ERROR}, +{UserAuth::CANCELED, API7UserAuth::CANCELED}, +{UserAuth::TIMEOUT, API7UserAuth::TIMEOUT}, +{UserAuth::TYPE_NOT_SUPPORT, API7UserAuth::NO_SUPPORT}, +{UserAuth::TRUST_LEVEL_NOT_SUPPORT, API7UserAuth::NO_SUPPORT}, +{UserAuth::BUSY, API7UserAuth::BUSY}, +{UserAuth::INVALID_PARAMETERS, API7UserAuth::INVALID_PARAMETERS}, +{UserAuth::LOCKED, API7UserAuth::LOCKED}, +{UserAuth::NOT_ENROLLED, API7UserAuth::NOT_ENROLLED}, +{UserAuth::IPC_ERROR, API7UserAuth::GENERAL_ERROR}, +{UserAuth::INVALID_CONTEXTID, API7UserAuth::GENERAL_ERROR}, +{UserAuth::E_WRITE_PARCEL_ERROR, API7UserAuth::GENERAL_ERROR}, +{UserAuth::E_READ_PARCEL_ERROR, API7UserAuth::GENERAL_ERROR}, +{UserAuth::E_GET_POWER_SERVICE_FAILED, API7UserAuth::GENERAL_ERROR}, +{UserAuth::E_RET_UNDONE, API7UserAuth::GENERAL_ERROR}, +{UserAuth::E_RET_NOSERVER, API7UserAuth::GENERAL_ERROR}, +}; + +std::map g_convertTipInfo = { +{ FACE_AUTH_TIP_TOO_BRIGHT, "the obtained facial image is too bright due to high illumination" }, +{ FACE_AUTH_TIP_TOO_DARK, "the obtained facial image is too dark due to low illumination" }, +{ FACE_AUTH_TIP_TOO_CLOSE, "the face is too close to the device" }, +{ FACE_AUTH_TIP_TOO_FAR, "the face is too far away from the device" }, +{ FACE_AUTH_TIP_TOO_HIGH, "the device is too high, and that only the upper part of the face is captured" }, +{ FACE_AUTH_TIP_TOO_LOW, "the device is too low, and that only the lower part of the face is captured" }, +{ FACE_AUTH_TIP_TOO_RIGHT, + "the device is deviated to the right, and that only the right part of the face is captured" }, +{ FACE_AUTH_TIP_TOO_LEFT, "the device is deviated to the left, and that only the left part of the face is captured" }, +{ FACE_AUTH_TIP_TOO_MUCH_MOTION, "the face moves too fast during facial information collection" }, +{ FACE_AUTH_TIP_POOR_GAZE, "the face is not facing the device" }, +{ FACE_AUTH_TIP_NOT_DETECTED, "no face is detected" }, +}; + +IUserAuthAPI7Callback::IUserAuthAPI7Callback(std::shared_ptr& impl) +{ + callback_ = impl; +} + +void IUserAuthAPI7Callback::onAcquireInfo(const int32_t module, const uint32_t acquireInfo, const int32_t extraInfo) +{ + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 onAcquireInfo is start"); + std::string sTipInfo = ""; + if (UserAuthAPI7Datamgr::GetInstance().GetAPI7Tip()) { + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 GetAPI7Tip is on"); + API7UserAuth::Tip sTip; + sTip.errorCode = API7UserAuth::SUCCESS; + sTip.tipEvent = API7UserAuth::ACQUIRE; + sTip.tipCode = acquireInfo; + if (g_convertTipInfo.count(static_cast(acquireInfo)) == 0) { + USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 g_convertTipInfo is 0"); + sTipInfo = "other error"; + } else { + sTipInfo = g_convertTipInfo[static_cast(acquireInfo)]; + } + callback_->TipCallback(sTip); + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 GetAPI7Tip is end"); + } + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 onAcquireInfo is end"); +} + +void IUserAuthAPI7Callback::onResult(const int32_t result, const UserAuth::AuthResult extraInfo) +{ + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 onResult is start"); + AuthenticationResult iResult; + UserAuthAPI7Datamgr::GetInstance().API7DeleteContextID(); + callback_->API7OnResult(result); + if (UserAuthAPI7Datamgr::GetInstance().GetAPI7Tip()) { + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 GetAPI7Tip is on"); + API7UserAuth::Tip sTip; + if (result != UserAuth::SUCCESS) { + USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 result is failed"); + sTip.errorCode = API7UserAuth::FAILED; + sTip.tipInfo = "FAILED"; + } else { + sTip.errorCode = API7UserAuth::SUCCESSED; + sTip.tipInfo = "SUCCESSED"; + } + sTip.tipEvent = API7UserAuth::RESULT; + if (g_convertResult.count(static_cast(result)) == 0) { + USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 g_convertResult is 0"); + iResult = static_cast(result); + } else { + iResult = g_convertResult[static_cast(result)]; + } + sTip.tipCode = iResult; + callback_->TipCallback(sTip); + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 GetAPI7Tip is end"); + } + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 onResult is end"); +} +void IUserAuthAPI7Callback::onExecutorPropertyInfo(const UserAuth::ExecutorProperty result) {} +void IUserAuthAPI7Callback::onSetExecutorProperty(const int32_t result) {} +} +} +} \ No newline at end of file diff --git a/frameworks/kitsimpl/src/userauth_api7.cpp b/frameworks/kitsimpl/src/userauth_api7.cpp new file mode 100644 index 000000000..4375deeb4 --- /dev/null +++ b/frameworks/kitsimpl/src/userauth_api7.cpp @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include + +#include "userauth_info.h" +#include "user_auth.h" +#include "userauth_hilog_wrapper.h" +#include "userauth_api7_hilog_wrapper.h" +#include "userauth_api7_datamgr.h" +#include "iuserauth_api7_callback.h" +#include "userauth_api7.h" + +namespace OHOS { +namespace UserIAM { +namespace API7UserAuth { +std::map g_convertAuthType = { +{ "FACE_ONLY", UserAuth::FACE }, +}; +std::map g_convertAuthTurstLevel = { +{ "S1", UserAuth::ATL1 }, +{ "S2", UserAuth::ATL2 }, +{ "S3", UserAuth::ATL3 }, +{ "S4", UserAuth::ATL4 }, +}; + +UserAuthAPI7 &UserAuthAPI7::GetAuthenticator() +{ + static UserAuthAPI7 instance; + return instance; +} + +void UserAuthAPI7::Execute(std::string authtype, std::string trustLevel, std::shared_ptr callback) +{ + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 execute is start"); + UserAuth::AuthType uAuthType; + UserAuth::AuthTurstLevel uAuthTurstLevel; + uint64_t contextID = 0; + + if (callback == nullptr) { + USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 execute callback is Null"); + return; + } + + if (g_convertAuthType.count(authtype) == 0) { + USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 execute g_convertAuthType is 0"); + callback->API7OnResult(NO_SUPPORT); + return; + } else { + uAuthType = g_convertAuthType[authtype]; + } + + if (g_convertAuthTurstLevel.count(trustLevel) == 0) { + USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 execute g_convertAuthTurstLevel is 0"); + callback->API7OnResult(NO_SUPPORT); + return; + } else { + uAuthTurstLevel = g_convertAuthTurstLevel[trustLevel]; + } + + std::shared_ptr asyncStub = std::make_shared(callback); + contextID = UserAuth::UserAuth::GetInstance().Auth(CHALLENGE_INIT, uAuthType, uAuthTurstLevel, asyncStub); + if (contextID != CONTEXTID_INIT) { + UserAuthAPI7Datamgr::GetInstance().API7AddContextID(contextID); + } + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 execute is end"); +} + +int32_t UserAuthAPI7::Cancel() +{ + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 cancel is start"); + uint64_t contextID = 0; + int32_t ret = API7UserAuth::GENERAL_ERROR; + + UserAuthAPI7Datamgr::GetInstance().API7GetContextID(contextID); + if (contextID != CONTEXTID_INIT) { + ret = UserAuth::UserAuth::GetInstance().CancelAuth(contextID); + if (ret != API7UserAuth::SUCCESS) { + USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 cancel is error"); + } + UserAuthAPI7Datamgr::GetInstance().API7DeleteContextID(); + } + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 cancel is end"); + return ret; +} + +int32_t UserAuthAPI7::CheckAvailability(std::string authtype, std::string trustLevel) +{ + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 checkAvailability is start"); + UserAuth::AuthType uAuthType; + UserAuth::AuthTurstLevel uAuthTurstLevel; + + if (g_convertAuthType.count(authtype) == 0) { + USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 checkAvailability g_convertAuthType is 0"); + return AUTH_TYPE_NOT_SUPPORT; + } else { + uAuthType = g_convertAuthType[authtype]; + } + + if (g_convertAuthTurstLevel.count(trustLevel) == 0) { + USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 checkAvailability g_convertAuthTurstLevel is 0"); + return SECURE_LEVEL_NOT_SUPPORT; + } else { + uAuthTurstLevel = g_convertAuthTurstLevel[trustLevel]; + } + + int32_t ret = UserAuth::UserAuth::GetInstance().GetAvailableStatus(uAuthType, uAuthTurstLevel); + if (ret != UserAuth::SUCCESS) { + USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 checkAvailability is error "); + } + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 checkAvailability is end"); + return ret; +} + +void UserAuthAPI7::On(std::string tip, std::shared_ptr tipCallback) +{ + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 On is start"); + std::string sTip = "tip"; + + if (!sTip.compare(tip)) { + USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 On is not tip"); + UserAuthAPI7Datamgr::GetInstance().SetAPI7Tip(false); + return; + } + UserAuthAPI7Datamgr::GetInstance().SetAPI7Tip(true); + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 On is end"); +} + +void UserAuthAPI7::Off(std::string tip, std::shared_ptr tipCallback) +{ + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 Off is start"); + UserAuthAPI7Datamgr::GetInstance().SetAPI7Tip(false); + USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 Off is end"); +} +} // namespace userAuth +} // namespace UserIam +} // namespace OHOS diff --git a/frameworks/kitsimpl/src/userauth_api7_datamgr.cpp b/frameworks/kitsimpl/src/userauth_api7_datamgr.cpp new file mode 100644 index 000000000..7a31984a0 --- /dev/null +++ b/frameworks/kitsimpl/src/userauth_api7_datamgr.cpp @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "userauth_info.h" +#include "userauth_hilog_wrapper.h" +#include "userauth_api7_info.h" +#include "userauth_api7_datamgr.h" + +namespace OHOS { +namespace UserIAM { +namespace API7UserAuth { +UserAuthAPI7Datamgr &UserAuthAPI7Datamgr::GetInstance() +{ + static UserAuthAPI7Datamgr instance; + return instance; +} + +void UserAuthAPI7Datamgr::API7AddContextID(uint64_t contextID) +{ + contextID_ = contextID; +} + +void UserAuthAPI7Datamgr::API7GetContextID(uint64_t &contextID) +{ + contextID = contextID_; +} + +void UserAuthAPI7Datamgr::API7DeleteContextID() +{ + contextID_= CONTEXTID_INIT; +} + +void UserAuthAPI7Datamgr::SetAPI7Tip(bool isTipOn) +{ + isTipOn_ = isTipOn; +} +bool UserAuthAPI7Datamgr::GetAPI7Tip() +{ + return isTipOn_; +} +} // namespace UserAuth +} // namespace UserIam +} // namespace OHOS diff --git a/frameworks/kitsimpl/src/userauth_async_stub.cpp b/frameworks/kitsimpl/src/userauth_async_stub.cpp index 3e2fbaf65..e3608e808 100644 --- a/frameworks/kitsimpl/src/userauth_async_stub.cpp +++ b/frameworks/kitsimpl/src/userauth_async_stub.cpp @@ -189,28 +189,30 @@ int32_t UserAuthAsyncStub::onSetExecutorPropertyStub(MessageParcel& data, Messag void UserAuthAsyncStub::onAcquireInfo(const int32_t module, const uint32_t acquireInfo, const int32_t extraInfo) { - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub onAcquireInfo enter"); - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub module:%{public}d", module); - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub acquireInfo:%{public}d", acquireInfo); - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub extraInfo:%{public}d", extraInfo); + USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthAsyncStub onAcquireInfo enter"); + if (callback_ == nullptr) { USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAsyncStub onAcquireInfo callback_ is Null"); return ; } + + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub module:%{public}d, acquireInfo:%{public}d", + module, acquireInfo); + callback_->onAcquireInfo(module, acquireInfo, extraInfo); } void UserAuthAsyncStub::onResult(const int32_t result, const AuthResult extraInfot) { - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub onResult enter"); - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub result:%{public}d", result); - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub remainTimes:%{public}d", extraInfot.remainTimes); - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub freezingTime:%{public}d", extraInfot.freezingTime); + USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthAsyncStub onResult enter"); if (callback_ == nullptr) { USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAsyncStub onResult callback_ is Null"); return ; } + + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub result:%{public}d, reTimes:%{public}d, freTime:%{public}d", + result, extraInfot.remainTimes, extraInfot.freezingTime); callback_->onResult(result, extraInfot); } @@ -222,10 +224,10 @@ void UserAuthAsyncStub::onExecutorPropertyInfo(const ExecutorProperty result) USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub onExecutorPropertyInfo callback_ is Null"); return ; } - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub result:%{public}d", result.result); - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub authSubType:%{public}llu", result.authSubType); - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub remainTimes:%{public}d", result.freezingTime); - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub freezingTime:%{public}d", result.freezingTime); + + USERAUTH_HILOGD(MODULE_INNERKIT, + "userauthAsyncStub result:%{public}d, SubTyp:%{public}llu, reTimes:%{public}d, freTime:%{public}d", + result.result, result.authSubType, result.freezingTime, result.freezingTime); callback_->onExecutorPropertyInfo(result); } diff --git a/interfaces/innerkits/native/BUILD.gn b/interfaces/innerkits/native/BUILD.gn index e07ff2c54..de98274ee 100755 --- a/interfaces/innerkits/native/BUILD.gn +++ b/interfaces/innerkits/native/BUILD.gn @@ -29,6 +29,9 @@ ohos_shared_library("userauth_framework") { "../../../frameworks/kitsimpl/src/userauth.cpp", "../../../frameworks/kitsimpl/src/userauth_async_stub.cpp", "../../../frameworks/kitsimpl/src/userauth_proxy.cpp", + "../../../frameworks/kitsimpl/src/userauth_api7.cpp", + "../../../frameworks/kitsimpl/src/userauth_api7_datamgr.cpp", + "../../../frameworks/kitsimpl/src/iuserauth_api7_callback.cpp", ] configs = [ diff --git a/interfaces/innerkits/native/include/iuserauth_api7_callback.h b/interfaces/innerkits/native/include/iuserauth_api7_callback.h new file mode 100755 index 000000000..6bfecf375 --- /dev/null +++ b/interfaces/innerkits/native/include/iuserauth_api7_callback.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef IUSERAUTH_API7_CALLBACK_H +#define IUSERAUTH_API7_CALLBACK_H + +#include +#include "userauth_info.h" +#include "userauth_callback.h" +#include "userauth_api7_callback.h" + + +namespace OHOS { +namespace UserIAM { +namespace API7UserAuth { +class IUserAuthAPI7Callback : public UserAuth::UserAuthCallback { +public: + explicit IUserAuthAPI7Callback(std::shared_ptr& impl); + virtual ~IUserAuthAPI7Callback() = default; + + void onAcquireInfo(const int32_t module, const uint32_t acquireInfo, const int32_t extraInfo) override; + void onResult(const int32_t result, const UserAuth::AuthResult extraInfo) override; + void onExecutorPropertyInfo(const UserAuth::ExecutorProperty result) override; + void onSetExecutorProperty(const int32_t result) override; +private: + std::shared_ptr callback_ {nullptr}; +}; +} // namespace API7UserAuth +} // namespace UserIAM +} // namespace OHOS +#endif // IUSERAUTH_API7_CALLBACK_H \ No newline at end of file diff --git a/interfaces/innerkits/native/include/user_auth.h b/interfaces/innerkits/native/include/user_auth.h index be7198471..4c875e446 100755 --- a/interfaces/innerkits/native/include/user_auth.h +++ b/interfaces/innerkits/native/include/user_auth.h @@ -44,9 +44,9 @@ public: private: class UserAuthDeathRecipient : public IRemoteObject::DeathRecipient { public: - UserAuthDeathRecipient() = default; - ~UserAuthDeathRecipient() = default; - void OnRemoteDied(const wptr& remote) override; + UserAuthDeathRecipient() = default; + ~UserAuthDeathRecipient() = default; + void OnRemoteDied(const wptr& remote) override; private: DISALLOW_COPY_AND_MOVE(UserAuthDeathRecipient); diff --git a/interfaces/innerkits/native/include/userauth_api7.h b/interfaces/innerkits/native/include/userauth_api7.h new file mode 100755 index 000000000..070fce2e8 --- /dev/null +++ b/interfaces/innerkits/native/include/userauth_api7.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef USERAUTH_API7_H +#define USERAUTH_API7_H + +#include + +#include "userauth_api7_info.h" +#include "userauth_api7_callback.h" + +namespace OHOS { +namespace UserIAM { +namespace API7UserAuth { +class UserAuthAPI7 { +public: + UserAuthAPI7() = default; + ~UserAuthAPI7() = default; + static UserAuthAPI7 &GetAuthenticator(); + void Execute(std::string authtype, std::string trustLevel, std::shared_ptr callback); + int32_t Cancel(); + int32_t CheckAvailability(std::string authtype, std::string trustLevel); + void On(std::string tip, std::shared_ptr tipCallback); + void Off(std::string tip, std::shared_ptr tipCallback); +}; +} // namespace API7UserAuth +} // namespace UserIAM +} // namespace OHOS +#endif // USERAUTH_API7_H \ No newline at end of file diff --git a/interfaces/innerkits/native/include/userauth_api7_callback.h b/interfaces/innerkits/native/include/userauth_api7_callback.h new file mode 100755 index 000000000..c9d3dcb7a --- /dev/null +++ b/interfaces/innerkits/native/include/userauth_api7_callback.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef USERAUTH_API7_CALLBACK_H +#define USERAUTH_API7_CALLBACK_H + +#include "userauth_api7_info.h" + +namespace OHOS { +namespace UserIAM { +namespace API7UserAuth { +class UserAuthAPI7Callback { +public: + virtual void API7OnResult(const int32_t result) = 0; + virtual void TipCallback(const Tip result) = 0; +}; +} // namespace API7UserAuth +} // namespace UserIAM +} // namespace OHOS +#endif // USERAUTH_API7_CALLBACK_H \ No newline at end of file diff --git a/interfaces/innerkits/native/include/userauth_api7_datamgr.h b/interfaces/innerkits/native/include/userauth_api7_datamgr.h new file mode 100755 index 000000000..40d52c116 --- /dev/null +++ b/interfaces/innerkits/native/include/userauth_api7_datamgr.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef USERAUTH_API7_DATAMGR_H +#define USERAUTH_API7_DATAMGR_H + +#include "userauth_api7_info.h" + +namespace OHOS { +namespace UserIAM { +namespace API7UserAuth { +class UserAuthAPI7Datamgr { +public: + static UserAuthAPI7Datamgr &GetInstance(); + void API7AddContextID(uint64_t contextID); + void API7GetContextID(uint64_t &contextID); + void API7DeleteContextID(); + void SetAPI7Tip(bool isTipOn); + bool GetAPI7Tip(); +private: + UserAuthAPI7Datamgr() = default; + ~UserAuthAPI7Datamgr() = default; + uint64_t contextID_ = CONTEXTID_INIT; + bool isTipOn_ = false; +}; +} // namespace API7UserAuth +} // namespace UserIAM +} // namespace OHOS +#endif // USERAUTH_API7_DATAMGR_H \ No newline at end of file diff --git a/interfaces/innerkits/native/include/userauth_api7_hilog_wrapper.h b/interfaces/innerkits/native/include/userauth_api7_hilog_wrapper.h new file mode 100755 index 000000000..517032c96 --- /dev/null +++ b/interfaces/innerkits/native/include/userauth_api7_hilog_wrapper.h @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef USERAUTH_API7_HILOG_WRAPPER_H +#define USERAUTH_API7_HILOG_WRAPPER_H + +#define CONFIG_HILOG +#ifdef CONFIG_HILOG + +#include "hilog/log.h" + +namespace OHOS { +namespace UserIAM { +namespace API7UserAuth { +#define filename__ (__builtin_strrchr(__FILE__, '/') ? __builtin_strrchr(__FILE__, '/') + 1 : __FILE__) +#define formated__(fmt, ...) "[%{public}s] %{public}s# " fmt, filename__, __FUNCTION__, ##__VA_ARGS__ + + +#ifdef USERAUTH_API7_HILOGE +#undef USERAUTH_API7_HILOGE +#endif + +#ifdef USERAUTH_API7_HILOGD +#undef USERAUTH_API7_HILOGD +#endif + +// param of log interface, such as USERAUTH_API7_HILOGF. +enum UserAuthAPI7SubModule { + MODULE_API7 = 0, + USERAUTHAPI7_MODULE_BUTT, +}; + +// 0xD002900: subsystem:distributeddatamgr module:distributedgallery, 8 bits reserved. +static constexpr unsigned int BASE_USERAUTH_API7_DOMAIN_ID = 0xD002910; + +enum UserAuthAPI7DomainId { + USERAUTH_API7_DOMAIN = BASE_USERAUTH_API7_DOMAIN_ID + MODULE_API7, + USERAUTH_API7_BUTT, +}; + +static constexpr OHOS::HiviewDFX::HiLogLabel L_LABEL[USERAUTHAPI7_MODULE_BUTT] = { + {LOG_CORE, USERAUTH_API7_DOMAIN, "UserAUTH_API7"}, +}; + +// In order to improve performance, do not check the module range. +// Besides, make sure module is less than USERAUTH_API7_MODULE_BUTT. +#define USERAUTH_API7_HILOGE(module, ...) (void)OHOS::HiviewDFX::HiLog::Error(L_LABEL[module], formated__(__VA_ARGS__)) +#define USERAUTH_API7_HILOGD(module, ...) (void)OHOS::HiviewDFX::HiLog::Debug(L_LABEL[module], formated__(__VA_ARGS__)) +} // namespace UserAUTH_API7 +} // namespace UserIAM +} // namespace OHOS + +#else + +#define USERAUTH_API7_HILOGE(...) +#define USERAUTH_API7_HILOGD(...) + +#endif // CONFIG_HILOG + +#endif // USERAUTH_API7_HILOG_WRAPPER_H diff --git a/interfaces/innerkits/native/include/userauth_api7_info.h b/interfaces/innerkits/native/include/userauth_api7_info.h new file mode 100755 index 000000000..445ce9bdb --- /dev/null +++ b/interfaces/innerkits/native/include/userauth_api7_info.h @@ -0,0 +1,150 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef USERAUTH_API7_INFO_H +#define USERAUTH_API7_INFO_H + +#include + +#define CONTEXTID_INIT 0 +#define CHALLENGE_INIT 0 + +namespace OHOS { +namespace UserIAM { +namespace API7UserAuth { +// Authentication Result +enum AuthenticationResult { + /** + * The device does not support the current authentication method. + */ + NO_SUPPORT = -1, + /** + * Authentication succeeded. + */ + SUCCESS = 0, + /** + * Alignment failed. + */ + COMPARE_FAILURE = 1, + /** + * User deauthentication. + */ + CANCELED = 2, + /** + * Authentication timed out. + */ + TIMEOUT = 3, + /** + * Failed to turn on camera. + */ + CAMERA_FAIL = 4, + /** + * The authentication service is busy, please try again later. + */ + BUSY = 5, + /** + * Authentication parameters are invalid. + */ + INVALID_PARAMETERS = 6, + /** + * Too many authentication failures, locked. + */ + LOCKED = 7, + /** + * Authentication credentials not entered. + */ + NOT_ENROLLED = 78, + /** + * other errors. + */ + GENERAL_ERROR = 100, +}; +// Device Certification Capability +enum CheckAvailabilityResult { + // The device supports the specified authentication type and authentication security level + SUPPORTED = 0, + // The device does not support the specified authentication type + AUTH_TYPE_NOT_SUPPORT = 1, + // The device does not support the specified authentication security level + SECURE_LEVEL_NOT_SUPPORT = 2, + // The device does not support distributed authentication + DISTRIBUTED_AUTH_NOT_SUPPORT = 3, + // Authentication credentials are not entered in the device + NO_ENROLLED = 4, + // wrong number of parameters + PARAM_NUM_ERROR = 5, +}; +// Prompt events during authentication +enum TipEvent { + // Entry or Certification Results + RESULT = 1, + // Entry or Certification Cancellation + CANCEL = 2, + // Prompt during entry or authentication + ACQUIRE = 3, + // Entry or authentication functions are occupied + ISBUSY = 4, + // Not enough storage + OUT_OF_MEM = 5, + // Face authentication credential index number + FACE_ID = 6, +}; +// Result +enum Result { + // SUCCESSED + SUCCESSED = 0, + // FAILED + FAILED = 1, +}; +// Prompt code during authentication +enum TipCode { + // The light is too strong, the acquired image is too bright + FACE_AUTH_TIP_TOO_BRIGHT = 1, + // The light is too dim, the acquired image is too dark + FACE_AUTH_TIP_TOO_DARK = 2, + // The face is too close to the device + FACE_AUTH_TIP_TOO_CLOSE = 3, + // The face is too far from the device + FACE_AUTH_TIP_TOO_FAR = 4, + // The device is too high, only the face obtained + FACE_AUTH_TIP_TOO_HIGH = 5, + // The device is too low, only the lower part of the face is obtained + FACE_AUTH_TIP_TOO_LOW = 6, + // The device is too far to the right, only the right part of the face is obtained + FACE_AUTH_TIP_TOO_RIGHT = 7, + // The device is too far to the left, only the left part of the face is obtained + FACE_AUTH_TIP_TOO_LEFT = 8, + // During image acquisition, the user's face moves too fast + FACE_AUTH_TIP_TOO_MUCH_MOTION = 9, + // no facing camera + FACE_AUTH_TIP_POOR_GAZE = 10, + // No face information detected + FACE_AUTH_TIP_NOT_DETECTED = 11, +}; +// Prompt information during the authentication process +struct Tip { + // Whether the prompt information was successfully obtained + int32_t errorCode; + // Authentication prompt event + int32_t tipEvent; + // Authentication prompt event + int32_t tipCode; + // Description of the event prompt code of the authentication prompt + std::string tipInfo; +}; +} // namespace API7UserAuth +} // namespace UserIam +} // namespace OHOS +#endif // USERAUTH_API7_INFO_H diff --git a/interfaces/innerkits/native/include/userauth_info.h b/interfaces/innerkits/native/include/userauth_info.h index 4284e9b69..7a60d349d 100755 --- a/interfaces/innerkits/native/include/userauth_info.h +++ b/interfaces/innerkits/native/include/userauth_info.h @@ -23,12 +23,12 @@ namespace OHOS { namespace UserIAM { namespace UserAuth { -// 认证的类型(口令,人脸) +// Type of authentication (password, face) enum AuthType: uint32_t { PIN = 1, FACE = 2, }; -// 认证子类型(2D人脸,3D人脸...) +// Authentication subtype (2D face, 3D face...) enum AuthSubType: uint64_t { /** * Authentication sub type six number pin. @@ -51,7 +51,7 @@ enum AuthSubType: uint64_t { */ FACE_3D = 20001 }; -// 认证结果可信等级 +// Certification result confidence level enum AuthTurstLevel: uint32_t { // level 1-4 ATL1 = 10000, @@ -59,48 +59,50 @@ enum AuthTurstLevel: uint32_t { ATL3 = 30000, ATL4 = 40000 }; -// 执行器属性列表 +// Actuator get property list enum GetPropertyType: uint32_t { - // 认证子类型(此时认证类型已确认) + // Authentication subtype (at this point the authentication type has been confirmed) AUTH_SUB_TYPE = 1, - // 剩余认证次数 + // Remaining authentication times REMAIN_TIMES = 2, - // 冻结时间 + // Freeze time FREEZING_TIME = 3, }; -// 获得属性请求 +// get attribute request struct GetPropertyRequest { AuthType authType; // GetPropertyType std::vector keys; }; -// 执行器属性 +// Actuator properties struct ExecutorProperty { int32_t result; AuthSubType authSubType; uint32_t remainTimes; uint32_t freezingTime; }; -// 执行器属性列表 +// Actuator property mode list enum AuthPropertyMode: uint32_t { - PROPERMODE_DELETE = 0, - PROPERMODE_GET = 1, - PROPERMODE_SET = 2, - PROPERMODE_FREEZE = 3, - PROPERMODE_UNFREEZE = 4, + PROPERMODE_DELETE = 0, + PROPERMODE_GET = 1, + PROPERMODE_SET = 2, + PROPERMODE_FREEZE = 3, + PROPERMODE_UNFREEZE = 4, + PROPERMODE_INIT_ALGORITHM = 5, + PROPERMODE_RELEASE_ALGORITHM = 6, }; -// 执行器属性列表 +// Actuator property list enum SetPropertyType: uint32_t { - INIT_ALGORITHM = 1, - FREEZE_TEMPLATE = 2, - THAW_TEMPLATE = 3, + INIT_ALGORITHM = 1, + FREEZE_TEMPLATE = 2, + THAW_TEMPLATE = 3, }; struct SetPropertyRequest { AuthType authType; SetPropertyType key; std::vector setInfo; }; -// 认证结果 +// Authentication Result struct AuthResult { std::vector token; uint32_t remainTimes; @@ -121,7 +123,7 @@ struct FreezInfo { AuthType authType; }; -// 结果码 +// Result Code enum ResultCode: int32_t { /** * Indicates that authentication is success or ability is supported. diff --git a/services/include/userauth_adapter.h b/services/include/userauth_adapter.h index 3f2b5a61f..7ad3d7ecf 100644 --- a/services/include/userauth_adapter.h +++ b/services/include/userauth_adapter.h @@ -45,20 +45,24 @@ public: void CoauthSetPropAuthInfo(int32_t resultCode, uint64_t callerUID, std::string pkgName, UserAuthToken authToken, SetPropertyRequest requset, sptr& callback); - /* Set the executor authentication properties */ + /* Set the executor authentication properties for freez or unfreez */ void SetPropAuthInfo(uint64_t callerUID, std::string pkgName, int32_t resultCode, UserAuthToken authToken, SetPropertyRequest requset, std::vector templateIds, sptr& callback); + /* get the executor authentication properties for Coauth */ void GetPropAuthInfoCoauth(uint64_t callerUID, std::string pkgName, int32_t resultCode, UserAuthToken authToken, GetPropertyRequest requset, sptr& callback); + /* get userID */ int32_t GetUserID(int32_t &userID); int32_t GenerateSolution(AuthSolution param, std::vector &sessionIds); int32_t RequestAuthResult(uint64_t contextId, std::vector scheduleToken, UserAuthToken &authToken, std::vector &sessionIds); int32_t CancelContext(uint64_t contextId, std::vector &sessionIds); int32_t Cancel(uint64_t sessionId); + /* get the executor authentication properties */ int32_t GetExecutorProp(uint64_t callerUID, std::string pkgName, uint64_t templateId, GetPropertyRequest requset, ExecutorProperty &result); + /* Set the executor authentication properties */ int32_t SetExecutorProp(uint64_t callerUID, std::string pkgName, SetPropertyRequest requset, sptr& callback); int32_t GetVersion(); diff --git a/services/include/userauth_datamgr.h b/services/include/userauth_datamgr.h index 73e60ae37..6c6094ff9 100755 --- a/services/include/userauth_datamgr.h +++ b/services/include/userauth_datamgr.h @@ -26,7 +26,7 @@ namespace OHOS { namespace UserIAM { namespace UserAuth { -class UserAuthDataMgr : public Singleton { +class UserAuthDataMgr { public: static UserAuthDataMgr &GetInstance(); int32_t AddContextID(uint64_t contextID); diff --git a/services/include/userauth_excallback_impl.h b/services/include/userauth_excallback_impl.h index 65a2a9c44..e20ad8d66 100644 --- a/services/include/userauth_excallback_impl.h +++ b/services/include/userauth_excallback_impl.h @@ -47,7 +47,7 @@ private: uint64_t callbackContextID_ = 0; std::string pkgName_ = ""; uint64_t callerUid_ = 0; - bool callbackResultFlag_ = false; + bool isResultDoneFlag_ = false; sptr callback_ { nullptr }; AuthType authType_; std::mutex mutex_; diff --git a/services/src/userauth_adapter.cpp b/services/src/userauth_adapter.cpp index 4dff5c26e..89fd00ce6 100644 --- a/services/src/userauth_adapter.cpp +++ b/services/src/userauth_adapter.cpp @@ -26,8 +26,7 @@ namespace OHOS { namespace UserIAM { namespace UserAuth { -const int32_t cUserId = 0; - +const int USERID_BUFF_SIZE = 10; UserAuthAdapter &UserAuthAdapter::GetInstance() { static UserAuthAdapter instance; @@ -49,10 +48,10 @@ void UserAuthAdapter::GetPropAuthInfo(uint64_t callerUID, std::string pkgName, G sptr& callback) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth GetPropAuthInfo is start!"); - - std::shared_ptr getInfoCallback = + using namespace UserIDM; + std::shared_ptr getInfoCallback = std::make_shared(callback, requset, callerUID, pkgName); - int32_t ret = UserIDM::UserIDMClient::GetInstance().GetAuthInfo(static_cast(requset.authType), + int32_t ret = UserIDMClient::GetInstance().GetAuthInfo(static_cast(requset.authType), getInfoCallback); if (ret != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth GetPropAuthInfo ERROR!"); @@ -66,14 +65,16 @@ void UserAuthAdapter::SetPropAuthInfo(uint64_t callerUID, std::string pkgName, i sptr& callback) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth SetPropAuthInfo is start!"); + using namespace AuthResPool; FreezInfo freezInfo; freezInfo.callerID = callerUID; freezInfo.authType = requset.authType; freezInfo.pkgName = pkgName; freezInfo.resultCode = resultCode; + std::shared_ptr setPropCallback = std::make_shared(callback, templateIds, authToken, freezInfo); - OHOS::UserIAM::AuthResPool::AuthAttributes authAttributes; + AuthAttributes authAttributes; int32_t ret = SetProPropAuthInfo(authAttributes, callerUID, pkgName, requset, templateIds, setPropCallback); if (ret != SUCCESS) { return; @@ -94,7 +95,7 @@ int32_t UserAuthAdapter::SetProPropAuthInfo(OHOS::UserIAM::AuthResPool::AuthAttr setPropCallback->OnResult(ret, extraInfo); return ret; } - value = requset.key ==SetPropertyType::FREEZE_TEMPLATE ? + value = requset.key == SetPropertyType::FREEZE_TEMPLATE ? static_cast(AuthPropertyMode::PROPERMODE_FREEZE) : static_cast(AuthPropertyMode::PROPERMODE_UNFREEZE); ret = authAttributes.SetUint32Value(AUTH_PROPERTY_MODE, value); @@ -139,11 +140,11 @@ void UserAuthAdapter::GetPropAuthInfoCoauth(uint64_t callerUID, std::string pkgN sptr& callback) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth GetPropAuthInfoCoauth is start!"); - - std::shared_ptr getInfoCallback = + using namespace UserIDM; + std::shared_ptr getInfoCallback = std::make_shared(callback, callerUID, pkgName, resultCode, authToken, requset); - int32_t ret = UserIDM::UserIDMClient::GetInstance().GetAuthInfo(static_cast(requset.authType), + int32_t ret = UserIDMClient::GetInstance().GetAuthInfo(static_cast(requset.authType), getInfoCallback); if (ret != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth GetPropAuthInfoCoauth ERROR!"); @@ -156,10 +157,11 @@ void UserAuthAdapter::CoauthSetPropAuthInfo(int32_t resultCode, uint64_t callerU sptr& callback) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth CoauthSetPropAuthInfo is start!"); - std::shared_ptr setPropCallback = + using namespace UserIDM; + std::shared_ptr setPropCallback = std::make_shared(callback, callerUID, pkgName, resultCode, authToken, requset); - int32_t ret = UserIDM::UserIDMClient::GetInstance().GetAuthInfo(static_cast(requset.authType), + int32_t ret = UserIDMClient::GetInstance().GetAuthInfo(static_cast(requset.authType), setPropCallback); if (ret != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth CoauthSetPropAuthInfo ERROR!"); @@ -170,8 +172,35 @@ void UserAuthAdapter::CoauthSetPropAuthInfo(int32_t resultCode, uint64_t callerU int32_t UserAuthAdapter::GetUserID(int32_t &userID) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth GetUserID is start!"); - // 打桩 IAMTA - userID = cUserId; + + bool once = true; + int32_t ret = SUCCESS; + uint8_t buff[USERID_BUFF_SIZE]; + FILE* fp = fopen("/data/useriam/userId", "rb"); + if (fp == nullptr) { + USERAUTH_HILOGE(MODULE_SERVICE, "## fopen failed!"); + once = false; + return FAIL; + } + + if (once) { + ret = fread(buff, 1, USERID_BUFF_SIZE, fp); + if (ret > 0) { + USERAUTH_HILOGD(MODULE_SERVICE, "## reading success: %{public}s", buff); + } else { + USERAUTH_HILOGE(MODULE_SERVICE, "## reading failed: %{public}d", ret); + fclose(fp); + return FAIL; + } + } + userID = atoi((char*)buff); + USERAUTH_HILOGD(MODULE_SERVICE, "## test userId: %{public}d", userID); + + ret = fclose(fp); + if (ret != SUCCESS) { + USERAUTH_HILOGE(MODULE_SERVICE, "## fclose failed: %{public}d", ret); + } + return SUCCESS; } @@ -228,10 +257,11 @@ int32_t UserAuthAdapter::GetExecutorProp(uint64_t callerUID, std::string pkgName GetPropertyRequest requset, ExecutorProperty &result) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth GetExecutorProp is start!"); + using namespace AuthResPool; uint32_t value; - auto pAuthAttributes (std::make_shared()); - OHOS::UserIAM::AuthResPool::AuthAttributes cAuthAttributes; + auto pAuthAttributes (std::make_shared()); + AuthAttributes cAuthAttributes; int32_t ret = cAuthAttributes.SetUint32Value(AUTH_TYPE, requset.authType); if (ret != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth SetUint32Value AUTH_TYPE ERROR!"); @@ -286,8 +316,8 @@ int32_t UserAuthAdapter::GetEachExecutorProp(GetPropertyRequest &requset, Execut result.freezingTime = 0; result.remainTimes = 0; result.authSubType = UserAuth::PIN_SIX; - for (std::vector::const_iterator iter = requset.keys.begin(); iter != requset.keys.end(); ++iter) { - switch (*iter) { + for (auto const & item : requset.keys) { + switch (item) { case AUTH_SUB_TYPE: ret = pAuthAttributes->GetUint64Value(AUTH_SUBTYPE, tmpValue); if (ret != SUCCESS) { @@ -328,10 +358,15 @@ int32_t UserAuthAdapter::SetExecutorProp(uint64_t callerUID, std::string pkgName sptr& callback) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth SetExecutorProp is start!"); + using namespace AuthResPool; + uint32_t value; std::shared_ptr setPropCallback = std::make_shared(callback); - OHOS::UserIAM::AuthResPool::AuthAttributes pAuthAttributes; - int32_t ret = pAuthAttributes.SetUint32Value(AUTH_PROPERTY_MODE, PROPERMODE_SET); + AuthAttributes pAuthAttributes; + value = requset.key == SetPropertyType::INIT_ALGORITHM ? + static_cast(AuthPropertyMode::PROPERMODE_INIT_ALGORITHM) + : static_cast(AuthPropertyMode::PROPERMODE_RELEASE_ALGORITHM); + int32_t ret = pAuthAttributes.SetUint32Value(AUTH_PROPERTY_MODE, value); if (ret != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth SetUint32Value SET_AUTH_PROPERTY_MODE ERROR!"); return ret; @@ -355,7 +390,7 @@ int32_t UserAuthAdapter::SetExecutorProp(uint64_t callerUID, std::string pkgName USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth SetUint32Value AUTH_TYPE ERROR!"); return ret; } - ret = pAuthAttributes.SetUint8ArrayValue(AUTH_SIGNATURE, requset.setInfo); + ret = pAuthAttributes.SetUint8ArrayValue(ALGORITHM_INFO, requset.setInfo); if (ret != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth SetUint8ArrayValue init ERROR!"); return ret; @@ -386,9 +421,8 @@ int32_t UserAuthAdapter::coAuth(CoAuthInfo coAuthInfo, sptr& USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth SaveCoauthCallback ERROR!"); return ret; } - for (std::vector::iterator iter = coAuthInfo.sessionIds.begin(); - iter != coAuthInfo.sessionIds.end(); ++iter) { - CoAuth::CoAuth::GetInstance().coAuth(*iter, authInfo, coAuthCallback); + for (auto const & item : coAuthInfo.sessionIds) { + CoAuth::CoAuth::GetInstance().coAuth(item, authInfo, coAuthCallback); } return SUCCESS; diff --git a/services/src/userauth_async_proxy.cpp b/services/src/userauth_async_proxy.cpp index d12862b1d..ab5dec89e 100755 --- a/services/src/userauth_async_proxy.cpp +++ b/services/src/userauth_async_proxy.cpp @@ -59,7 +59,7 @@ void UserAuthAsyncProxy::onResult(const int32_t result, const AuthResult extraIn MessageParcel reply; if (!data.WriteInterfaceToken(UserAuthAsyncProxy::GetDescriptor())) { USERAUTH_HILOGI(MODULE_SERVICE, "userauth write descriptor failed!"); - return ; + return; } if (!data.WriteInt32(result)) { USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteInt32(result)."); diff --git a/services/src/userauth_excallback_impl.cpp b/services/src/userauth_excallback_impl.cpp index 695f81c01..125dba752 100644 --- a/services/src/userauth_excallback_impl.cpp +++ b/services/src/userauth_excallback_impl.cpp @@ -51,6 +51,10 @@ UserAuthCallbackImplSetPropFreez::UserAuthCallbackImplSetPropFreez(const sptr templateIds, UserAuthToken authToken, FreezInfo freezInfo) { + if (impl == nullptr) { + USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthCallbackImplSetPropFreez impl callback is Null"); + return ; + } callback_ = impl; templateIds_.clear(); templateIds_.assign(templateIds.begin(), templateIds.end()); @@ -112,7 +116,7 @@ UserAuthCallbackImplCoAuth::UserAuthCallbackImplCoAuth(const sptr &scheduleToken) @@ -121,12 +125,13 @@ void UserAuthCallbackImplCoAuth::OnFinish(uint32_t resultCode, std::vector scheduleToken_; scheduleToken_.assign(scheduleToken.begin(), scheduleToken.end()); - auto task = std::bind(&UserAuthCallbackImplCoAuth::OnFinishHandle, this, resultCode, scheduleToken_); - bool ret = ContextThreadPool::GetInstance().AddTask(callbackContextID_, task); + bool ret = ContextThreadPool::GetInstance().AddTask(callbackContextID_, [&](){ + OnFinishHandle(resultCode, scheduleToken_); + }); if (!ret) { USERAUTH_HILOGE(MODULE_SERVICE, "OnFinish ContextThreadPool is BUSY"); callback_->onResult(BUSY, authResult); - callbackResultFlag_ = true; + isResultDoneFlag_ = true; return; } } @@ -134,11 +139,12 @@ void UserAuthCallbackImplCoAuth::OnAcquireInfo(uint32_t acquire) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthCallbackImplCoAuth OnAcquireInfo enter"); - auto task = std::bind(&UserAuthCallbackImplCoAuth::OnAcquireInfoHandle, this, acquire); - bool ret = ContextThreadPool::GetInstance().AddTask(callbackContextID_, task); + bool ret = ContextThreadPool::GetInstance().AddTask(callbackContextID_, [&](){ + OnAcquireInfoHandle(acquire); + }); if (!ret) { USERAUTH_HILOGE(MODULE_SERVICE, "OnAcquireInfoHandle ContextThreadPool is BUSY"); - callbackResultFlag_ = true; + isResultDoneFlag_ = true; return; } } @@ -173,22 +179,23 @@ void UserAuthCallbackImplCoAuth::OnFinishHandle(uint32_t resultCode, std::vector USERAUTH_HILOGD(MODULE_SERVICE, "OnFinishHandle scheduleTokensize:%{public}d, resultCode:%{public}d", scheduleToken.size(), resultCode); callbackNowCount_++; - if (callbackResultFlag_) { + if (isResultDoneFlag_) { return; } int32_t ret = UserAuthAdapter::GetInstance().RequestAuthResult(callbackContextID_, scheduleToken, authToken, sessionIds); + if (ret == E_RET_UNDONE) { + if (callbackNowCount_ == callbackCount_) { + USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthCallbackImplCoAuth E_RET_UNDONE"); + UserAuthDataMgr::GetInstance().DeleteContextID(callbackContextID_); + UserAuthCallbackImplCoAuth::DeleteCoauthCallback(callbackContextID_); + callback_->onResult(GENERAL_ERROR, authResult); + isResultDoneFlag_ = true; + } + return; + } if (resultCode != LOCKED) { - if (ret == E_RET_UNDONE) { - if (callbackNowCount_ == callbackCount_) { - USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthCallbackImplCoAuth E_RET_UNDONE"); - UserAuthDataMgr::GetInstance().DeleteContextID(callbackContextID_); - UserAuthCallbackImplCoAuth::DeleteCoauthCallback(callbackContextID_); - callback_->onResult(GENERAL_ERROR, authResult); - callbackResultFlag_ = true; - } - return ; - } else if (ret == SUCCESS) { + if (ret == SUCCESS) { OnFinishHandleExtend(setPropertyRequest, authResult, ret, authToken); } else { USERAUTH_HILOGD(MODULE_SERVICE, "RequestAuthResult NOT SUCCESS"); @@ -206,20 +213,20 @@ void UserAuthCallbackImplCoAuth::OnFinishHandle(uint32_t resultCode, std::vector callback_); } if (sessionIds.size() != 0) { - for (std::vector::iterator iter = sessionIds.begin(); iter != sessionIds.end(); iter++) { - UserAuthAdapter::GetInstance().Cancel(*iter); + for (auto const & item : sessionIds) { + UserAuthAdapter::GetInstance().Cancel(item); } } UserAuthDataMgr::GetInstance().DeleteContextID(callbackContextID_); UserAuthCallbackImplCoAuth::DeleteCoauthCallback(callbackContextID_); - callbackResultFlag_ = true; + isResultDoneFlag_ = true; } void UserAuthCallbackImplCoAuth::OnAcquireInfoHandle(uint32_t acquire) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthCallbackImplCoAuth OnAcquireInfoHandle"); std::lock_guard lock(mutex_); - if (callbackResultFlag_) { + if (isResultDoneFlag_) { return; } int32_t module = static_cast(authType_); @@ -324,8 +331,8 @@ void UserAuthCallbackImplIDMCothGetPorpFreez::OnGetInfo(std::vector::const_iterator iter = info.begin(); iter != info.end(); ++iter) { - templateIds.push_back((*iter).templateId); + for (auto const & item : info) { + templateIds.push_back(item.templateId); } UserAuthAdapter::GetInstance().SetPropAuthInfo(callerUid_, pkgName_, resultCode_, authToken_, requset_, templateIds, callback_); diff --git a/services/src/userauth_service.cpp b/services/src/userauth_service.cpp index 4f827b150..3e93ef3c7 100644 --- a/services/src/userauth_service.cpp +++ b/services/src/userauth_service.cpp @@ -77,6 +77,7 @@ int32_t UserAuthService::GetAvailableStatus(const AuthType authType, const AuthT USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthService GetAvailableStatus GetUserID is ERROR!"); return result; } + ret = userauthController_.GetAuthTrustLevel(userID, authType, authTurstLevelFromSys); if (ret == SUCCESS) { USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthService iAuthTurstLevel_:%{public}d", authTurstLevelFromSys); @@ -100,14 +101,14 @@ void UserAuthService::GetProperty(const GetPropertyRequest request, sptrGetCallingUid(); - callerName = std::to_string(callerID); - sptr dr = new UserAuthServiceCallbackDeathRecipient(callback); if ((!callback->AsObject()->AddDeathRecipient(dr))) { USERAUTH_HILOGE(MODULE_SERVICE, "Failed to add death recipient UserAuthServiceCallbackDeathRecipient"); } + callerID = this->GetCallingUid(); + callerName = std::to_string(callerID); + userauthController_.GetPropAuthInfo(callerName, callerID, request, callback); } @@ -122,13 +123,14 @@ void UserAuthService::SetProperty(const SetPropertyRequest request, sptrGetCallingUid(); - callerName = std::to_string(callerID); - sptr dr = new UserAuthServiceCallbackDeathRecipient(callback); if ((!callback->AsObject()->AddDeathRecipient(dr))) { USERAUTH_HILOGE(MODULE_SERVICE, "Failed to add death recipient UserAuthServiceCallbackDeathRecipient"); } + + callerID = this->GetCallingUid(); + callerName = std::to_string(callerID); + ret = userauthController_.SetExecutorProp(callerID, callerName, request, callback); if (ret != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthService SetExecutorProp getUserID is ERROR!"); @@ -151,15 +153,23 @@ uint64_t UserAuthService::Auth(const uint64_t challenge, const AuthType authType AuthSolution authSolutionParam; CoAuthInfo coAuthInfo; AuthResult extraInfo; + + sptr dr = new UserAuthServiceCallbackDeathRecipient(callback); + if ((!callback->AsObject()->AddDeathRecipient(dr))) { + USERAUTH_HILOGE(MODULE_SERVICE, "Failed to add death recipient UserAuthServiceCallbackDeathRecipient"); + } + if (GetControllerData(callback, extraInfo, authTurstLevel, callerID, callerName, contextID) == FAIL) { return ret; } + result = userauthController_.GetUserID(userID); if (result != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthService Auth GetUserID is ERROR!"); callback->onResult(FAIL, extraInfo); return ret; } + authSolutionParam.contextId = contextID; authSolutionParam.userId = userID; authSolutionParam.authTrustLevel = authTurstLevel; @@ -171,14 +181,11 @@ uint64_t UserAuthService::Auth(const uint64_t challenge, const AuthType authType callback->onResult(result, extraInfo); return ret; } + coAuthInfo.authType = authType; coAuthInfo.callerID = callerID; coAuthInfo.contextID = contextID; coAuthInfo.pkgName = callerName; - sptr dr = new UserAuthServiceCallbackDeathRecipient(callback); - if ((!callback->AsObject()->AddDeathRecipient(dr))) { - USERAUTH_HILOGE(MODULE_SERVICE, "Failed to add death recipient UserAuthServiceCallbackDeathRecipient"); - } result = userauthController_.coAuth(coAuthInfo, callback); if (result != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthService Auth coAuth is ERROR!"); @@ -201,9 +208,16 @@ uint64_t UserAuthService::AuthUser(const int32_t userId, const uint64_t challeng AuthSolution authSolutionParam; CoAuthInfo coAuthInfo; AuthResult extraInfo; + + sptr dr = new UserAuthServiceCallbackDeathRecipient(callback); + if ((!callback->AsObject()->AddDeathRecipient(dr))) { + USERAUTH_HILOGE(MODULE_SERVICE, "Failed to add death recipient UserAuthServiceCallbackDeathRecipient"); + } + if (GetControllerData(callback, extraInfo, authTurstLevel, callerID, callerName, contextID) == FAIL) { return ret; } + authSolutionParam.contextId = contextID; authSolutionParam.userId = userId; authSolutionParam.authTrustLevel = authTurstLevel; @@ -216,14 +230,11 @@ uint64_t UserAuthService::AuthUser(const int32_t userId, const uint64_t challeng callback->onResult(result, extraInfo); return ret; } + coAuthInfo.authType = authType; coAuthInfo.callerID = callerID; coAuthInfo.contextID = contextID; coAuthInfo.pkgName = callerName; - sptr dr = new UserAuthServiceCallbackDeathRecipient(callback); - if ((!callback->AsObject()->AddDeathRecipient(dr))) { - USERAUTH_HILOGE(MODULE_SERVICE, "Failed to add death recipient UserAuthServiceCallbackDeathRecipient"); - } result = userauthController_.coAuth(coAuthInfo, callback); if (result != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthService AuthUser coAuth is ERROR!"); @@ -287,8 +298,8 @@ int32_t UserAuthService::CancelAuth(const uint64_t contextId) result = userauthController_.CancelContext(contextId, sessionIds); if (result == SUCCESS) { - for (std::vector::iterator iter = sessionIds.begin(); iter != sessionIds.end(); iter++) { - result = userauthController_.Cancel(*iter); + for (auto const & item : sessionIds) { + result = userauthController_.Cancel(item); if (result != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthService CancelAuth Cancel is ERROR!"); return result; diff --git a/services/src/userauth_stub.cpp b/services/src/userauth_stub.cpp index ee2345a3a..f5f9253d2 100644 --- a/services/src/userauth_stub.cpp +++ b/services/src/userauth_stub.cpp @@ -103,7 +103,7 @@ int32_t UserAuthStub::GetPropertyStub(MessageParcel& data, MessageParcel& reply) sptr callback = iface_cast(obj); if (callback == nullptr) { - return E_READ_PARCEL_ERROR; + return FAIL; } GetProperty(getPropertyRequest, callback); @@ -142,7 +142,7 @@ int32_t UserAuthStub::SetPropertyStub(MessageParcel& data, MessageParcel& reply) sptr callback = iface_cast(obj); if (callback == nullptr) { - return E_READ_PARCEL_ERROR; + return FAIL; } SetProperty(setPropertyRequest, callback); @@ -177,7 +177,7 @@ int32_t UserAuthStub::AuthStub(MessageParcel& data, MessageParcel& reply) sptr callback = iface_cast(obj); if (callback == nullptr) { - return E_READ_PARCEL_ERROR; + return FAIL; } ret = Auth(challenge, static_cast(authType), static_cast(authTurstLevel), callback); @@ -221,7 +221,7 @@ int32_t UserAuthStub::AuthUserStub(MessageParcel& data, MessageParcel& reply) sptr callback = iface_cast(obj); if (callback == nullptr) { - return E_READ_PARCEL_ERROR; + return FAIL; } ret = AuthUser(userID, challenge, static_cast(authType), diff --git a/test/unittest/include/userauth_test.h b/test/unittest/include/userauth_test.h index eb0908a70..e020c97aa 100644 --- a/test/unittest/include/userauth_test.h +++ b/test/unittest/include/userauth_test.h @@ -25,6 +25,11 @@ void UseriamUtTest_003(); void UseriamUtTest_004(); void UseriamUtTest_005(); void UseriamUtTest_006(); +void UseriamUtTest_007(); +void UseriamUtTest_008(); +void UseriamUtTest_009(); +void UseriamUtTest_010(); +void UseriamUtTest_011(); } } } diff --git a/test/unittest/src/userauth_test.cpp b/test/unittest/src/userauth_test.cpp index 980deb608..f567339bb 100644 --- a/test/unittest/src/userauth_test.cpp +++ b/test/unittest/src/userauth_test.cpp @@ -17,6 +17,7 @@ #include #include #include "user_auth.h" +#include "userauth_api7.h" #include "userauth_callback.h" #include "userauth_info.h" #include "userauth_test.h" @@ -79,6 +80,25 @@ void TestUserAuthCallback::onSetExecutorProperty(const int32_t result) std::cout << "onSetExecutorProperty callback" << std::endl; } +class TestUserAuthAPI7Callback : public UserAuthAPI7Callback { +public: + TestUserAuthAPI7Callback() = default; + virtual ~TestUserAuthAPI7Callback() = default; + + void API7OnResult(const int32_t result) override; + void TipCallback(const Tip result) override; +} + +void TestUserAuthAPI7Callback::API7OnResult(const int32_t result) +{ + std::cout << "API7OnResult callback" << std::endl; +} + +void TestUserAuthAPI7Callback::TipCallback(const Tip result) +{ + std::cout << "TipCallback callback" << std::endl; +} + HWTEST_F(UseriamUtTest, UseriamUtTest_001, TestSize.Level1) { AuthType authType = FACE; @@ -131,6 +151,34 @@ HWTEST_F(UseriamUtTest, UseriamUtTest_006, TestSize.Level1) uint64_t contextId = 123; EXPECT_EQ(0, UserAuth::GetInstance().CancelAuth(contextId)); } + +HWTEST_F(UseriamUtTest, UseriamUtTest_007, TestSize.Level1) +{ + std::shared_ptr callback = std::make_shared(); + UserAuthAPI7::GetAuthenticator().Execute("FACE_ONLY", "S1", callback); +} + +HWTEST_F(UseriamUtTest, UseriamUtTest_008, TestSize.Level1) +{ + EXPECT_EQ(0, UserAuthAPI7::GetAuthenticator().Cancel()); +} + +HWTEST_F(UseriamUtTest, UseriamUtTest_009, TestSize.Level1) +{ + EXPECT_EQ(0, UserAuthAPI7::GetAuthenticator().CheckAvailability("FACE_ONLY", "S1")); +} + +HWTEST_F(UseriamUtTest, UseriamUtTest_010, TestSize.Level1) +{ + std::shared_ptr callback = std::make_shared(); + UserAuthAPI7::GetAuthenticator().On("tip", callback); +} + +HWTEST_F(UseriamUtTest, UseriamUtTest_011, TestSize.Level1) +{ + std::shared_ptr callback = std::make_shared(); + UserAuthAPI7::GetAuthenticator().Off("tip", callback); +} } } } \ No newline at end of file -- Gitee From f7dc28582a03f82017457fb2f720b134e6a3511c Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Fri, 28 Jan 2022 17:19:29 +0800 Subject: [PATCH 02/19] [user_auth]code change 1 add api7 dts 2 code update for review Signed-off-by: yanfang.gu --- .../kitsimpl/src/iuserauth_api7_callback.cpp | 98 ++--- frameworks/kitsimpl/src/userauth_api7.cpp | 34 +- .../kitsimpl/src/userauth_async_stub.cpp | 10 +- .../js/ohos.UserIAM.userAuth_API7.d.ts | 336 ++++++++++++++++++ services/src/userauth_excallback_impl.cpp | 4 +- 5 files changed, 409 insertions(+), 73 deletions(-) create mode 100644 interfaces/innerkits/js/ohos.UserIAM.userAuth_API7.d.ts diff --git a/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp b/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp index 7b15f3226..fc3fa9777 100644 --- a/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp +++ b/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp @@ -22,39 +22,39 @@ namespace OHOS { namespace UserIAM { namespace API7UserAuth { std::map g_convertResult = { -{UserAuth::SUCCESS, API7UserAuth::SUCCESS}, -{UserAuth::FAIL, API7UserAuth::GENERAL_ERROR}, -{UserAuth::GENERAL_ERROR, API7UserAuth::GENERAL_ERROR}, -{UserAuth::CANCELED, API7UserAuth::CANCELED}, -{UserAuth::TIMEOUT, API7UserAuth::TIMEOUT}, -{UserAuth::TYPE_NOT_SUPPORT, API7UserAuth::NO_SUPPORT}, -{UserAuth::TRUST_LEVEL_NOT_SUPPORT, API7UserAuth::NO_SUPPORT}, -{UserAuth::BUSY, API7UserAuth::BUSY}, -{UserAuth::INVALID_PARAMETERS, API7UserAuth::INVALID_PARAMETERS}, -{UserAuth::LOCKED, API7UserAuth::LOCKED}, -{UserAuth::NOT_ENROLLED, API7UserAuth::NOT_ENROLLED}, -{UserAuth::IPC_ERROR, API7UserAuth::GENERAL_ERROR}, -{UserAuth::INVALID_CONTEXTID, API7UserAuth::GENERAL_ERROR}, -{UserAuth::E_WRITE_PARCEL_ERROR, API7UserAuth::GENERAL_ERROR}, -{UserAuth::E_READ_PARCEL_ERROR, API7UserAuth::GENERAL_ERROR}, -{UserAuth::E_GET_POWER_SERVICE_FAILED, API7UserAuth::GENERAL_ERROR}, -{UserAuth::E_RET_UNDONE, API7UserAuth::GENERAL_ERROR}, -{UserAuth::E_RET_NOSERVER, API7UserAuth::GENERAL_ERROR}, + {UserAuth::SUCCESS, API7UserAuth::SUCCESS}, + {UserAuth::FAIL, API7UserAuth::GENERAL_ERROR}, + {UserAuth::GENERAL_ERROR, API7UserAuth::GENERAL_ERROR}, + {UserAuth::CANCELED, API7UserAuth::CANCELED}, + {UserAuth::TIMEOUT, API7UserAuth::TIMEOUT}, + {UserAuth::TYPE_NOT_SUPPORT, API7UserAuth::NO_SUPPORT}, + {UserAuth::TRUST_LEVEL_NOT_SUPPORT, API7UserAuth::NO_SUPPORT}, + {UserAuth::BUSY, API7UserAuth::BUSY}, + {UserAuth::INVALID_PARAMETERS, API7UserAuth::INVALID_PARAMETERS}, + {UserAuth::LOCKED, API7UserAuth::LOCKED}, + {UserAuth::NOT_ENROLLED, API7UserAuth::NOT_ENROLLED}, + {UserAuth::IPC_ERROR, API7UserAuth::GENERAL_ERROR}, + {UserAuth::INVALID_CONTEXTID, API7UserAuth::GENERAL_ERROR}, + {UserAuth::E_WRITE_PARCEL_ERROR, API7UserAuth::GENERAL_ERROR}, + {UserAuth::E_READ_PARCEL_ERROR, API7UserAuth::GENERAL_ERROR}, + {UserAuth::E_GET_POWER_SERVICE_FAILED, API7UserAuth::GENERAL_ERROR}, + {UserAuth::E_RET_UNDONE, API7UserAuth::GENERAL_ERROR}, + {UserAuth::E_RET_NOSERVER, API7UserAuth::GENERAL_ERROR}, }; std::map g_convertTipInfo = { -{ FACE_AUTH_TIP_TOO_BRIGHT, "the obtained facial image is too bright due to high illumination" }, -{ FACE_AUTH_TIP_TOO_DARK, "the obtained facial image is too dark due to low illumination" }, -{ FACE_AUTH_TIP_TOO_CLOSE, "the face is too close to the device" }, -{ FACE_AUTH_TIP_TOO_FAR, "the face is too far away from the device" }, -{ FACE_AUTH_TIP_TOO_HIGH, "the device is too high, and that only the upper part of the face is captured" }, -{ FACE_AUTH_TIP_TOO_LOW, "the device is too low, and that only the lower part of the face is captured" }, -{ FACE_AUTH_TIP_TOO_RIGHT, - "the device is deviated to the right, and that only the right part of the face is captured" }, -{ FACE_AUTH_TIP_TOO_LEFT, "the device is deviated to the left, and that only the left part of the face is captured" }, -{ FACE_AUTH_TIP_TOO_MUCH_MOTION, "the face moves too fast during facial information collection" }, -{ FACE_AUTH_TIP_POOR_GAZE, "the face is not facing the device" }, -{ FACE_AUTH_TIP_NOT_DETECTED, "no face is detected" }, + { FACE_AUTH_TIP_TOO_BRIGHT, "the obtained facial image is too bright due to high illumination" }, + { FACE_AUTH_TIP_TOO_DARK, "the obtained facial image is too dark due to low illumination" }, + { FACE_AUTH_TIP_TOO_CLOSE, "the face is too close to the device" }, + { FACE_AUTH_TIP_TOO_FAR, "the face is too far away from the device" }, + { FACE_AUTH_TIP_TOO_HIGH, "the device is too high, and that only the upper part of the face is captured" }, + { FACE_AUTH_TIP_TOO_LOW, "the device is too low, and that only the lower part of the face is captured" }, + { FACE_AUTH_TIP_TOO_RIGHT, + "the device is deviated to the right, and that only the right part of the face is captured" }, + { FACE_AUTH_TIP_TOO_LEFT, "the device is deviated to the left, and that only the left part of the face is captured" }, + { FACE_AUTH_TIP_TOO_MUCH_MOTION, "the face moves too fast during facial information collection" }, + { FACE_AUTH_TIP_POOR_GAZE, "the face is not facing the device" }, + { FACE_AUTH_TIP_NOT_DETECTED, "no face is detected" }, }; IUserAuthAPI7Callback::IUserAuthAPI7Callback(std::shared_ptr& impl) @@ -65,20 +65,20 @@ IUserAuthAPI7Callback::IUserAuthAPI7Callback(std::shared_ptr(acquireInfo)) == 0) { USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 g_convertTipInfo is 0"); - sTipInfo = "other error"; + tipOfInfo = "other error"; } else { - sTipInfo = g_convertTipInfo[static_cast(acquireInfo)]; + tipOfInfo = g_convertTipInfo[static_cast(acquireInfo)]; } - callback_->TipCallback(sTip); + callback_->TipCallback(tipInfo); USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 GetAPI7Tip is end"); } USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 onAcquireInfo is end"); @@ -87,29 +87,29 @@ void IUserAuthAPI7Callback::onAcquireInfo(const int32_t module, const uint32_t a void IUserAuthAPI7Callback::onResult(const int32_t result, const UserAuth::AuthResult extraInfo) { USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 onResult is start"); - AuthenticationResult iResult; + AuthenticationResult authResult; UserAuthAPI7Datamgr::GetInstance().API7DeleteContextID(); callback_->API7OnResult(result); if (UserAuthAPI7Datamgr::GetInstance().GetAPI7Tip()) { USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 GetAPI7Tip is on"); - API7UserAuth::Tip sTip; + API7UserAuth::Tip tipInfo; if (result != UserAuth::SUCCESS) { USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 result is failed"); - sTip.errorCode = API7UserAuth::FAILED; - sTip.tipInfo = "FAILED"; + tipInfo.errorCode = API7UserAuth::FAILED; + tipInfo.tipInfo = "FAILED"; } else { - sTip.errorCode = API7UserAuth::SUCCESSED; - sTip.tipInfo = "SUCCESSED"; + tipInfo.errorCode = API7UserAuth::SUCCESSED; + tipInfo.tipInfo = "SUCCESSED"; } - sTip.tipEvent = API7UserAuth::RESULT; + tipInfo.tipEvent = API7UserAuth::RESULT; if (g_convertResult.count(static_cast(result)) == 0) { USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 g_convertResult is 0"); - iResult = static_cast(result); + authResult = static_cast(result); } else { - iResult = g_convertResult[static_cast(result)]; + authResult = g_convertResult[static_cast(result)]; } - sTip.tipCode = iResult; - callback_->TipCallback(sTip); + tipInfo.tipCode = authResult; + callback_->TipCallback(tipInfo); USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 GetAPI7Tip is end"); } USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 onResult is end"); diff --git a/frameworks/kitsimpl/src/userauth_api7.cpp b/frameworks/kitsimpl/src/userauth_api7.cpp index 4375deeb4..cbab1aedf 100644 --- a/frameworks/kitsimpl/src/userauth_api7.cpp +++ b/frameworks/kitsimpl/src/userauth_api7.cpp @@ -26,13 +26,13 @@ namespace OHOS { namespace UserIAM { namespace API7UserAuth { std::map g_convertAuthType = { -{ "FACE_ONLY", UserAuth::FACE }, + { "FACE_ONLY", UserAuth::FACE }, }; std::map g_convertAuthTurstLevel = { -{ "S1", UserAuth::ATL1 }, -{ "S2", UserAuth::ATL2 }, -{ "S3", UserAuth::ATL3 }, -{ "S4", UserAuth::ATL4 }, + { "S1", UserAuth::ATL1 }, + { "S2", UserAuth::ATL2 }, + { "S3", UserAuth::ATL3 }, + { "S4", UserAuth::ATL4 }, }; UserAuthAPI7 &UserAuthAPI7::GetAuthenticator() @@ -44,8 +44,8 @@ UserAuthAPI7 &UserAuthAPI7::GetAuthenticator() void UserAuthAPI7::Execute(std::string authtype, std::string trustLevel, std::shared_ptr callback) { USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 execute is start"); - UserAuth::AuthType uAuthType; - UserAuth::AuthTurstLevel uAuthTurstLevel; + UserAuth::AuthType exeAuthType; + UserAuth::AuthTurstLevel authTurstLevel; uint64_t contextID = 0; if (callback == nullptr) { @@ -58,7 +58,7 @@ void UserAuthAPI7::Execute(std::string authtype, std::string trustLevel, std::sh callback->API7OnResult(NO_SUPPORT); return; } else { - uAuthType = g_convertAuthType[authtype]; + exeAuthType = g_convertAuthType[authtype]; } if (g_convertAuthTurstLevel.count(trustLevel) == 0) { @@ -66,11 +66,11 @@ void UserAuthAPI7::Execute(std::string authtype, std::string trustLevel, std::sh callback->API7OnResult(NO_SUPPORT); return; } else { - uAuthTurstLevel = g_convertAuthTurstLevel[trustLevel]; + authTurstLevel = g_convertAuthTurstLevel[trustLevel]; } std::shared_ptr asyncStub = std::make_shared(callback); - contextID = UserAuth::UserAuth::GetInstance().Auth(CHALLENGE_INIT, uAuthType, uAuthTurstLevel, asyncStub); + contextID = UserAuth::UserAuth::GetInstance().Auth(CHALLENGE_INIT, exeAuthType, authTurstLevel, asyncStub); if (contextID != CONTEXTID_INIT) { UserAuthAPI7Datamgr::GetInstance().API7AddContextID(contextID); } @@ -98,24 +98,24 @@ int32_t UserAuthAPI7::Cancel() int32_t UserAuthAPI7::CheckAvailability(std::string authtype, std::string trustLevel) { USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 checkAvailability is start"); - UserAuth::AuthType uAuthType; - UserAuth::AuthTurstLevel uAuthTurstLevel; + UserAuth::AuthType checkAuthType; + UserAuth::AuthTurstLevel authTurstLevel; if (g_convertAuthType.count(authtype) == 0) { USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 checkAvailability g_convertAuthType is 0"); return AUTH_TYPE_NOT_SUPPORT; } else { - uAuthType = g_convertAuthType[authtype]; + checkAuthType = g_convertAuthType[authtype]; } if (g_convertAuthTurstLevel.count(trustLevel) == 0) { USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 checkAvailability g_convertAuthTurstLevel is 0"); return SECURE_LEVEL_NOT_SUPPORT; } else { - uAuthTurstLevel = g_convertAuthTurstLevel[trustLevel]; + authTurstLevel = g_convertAuthTurstLevel[trustLevel]; } - int32_t ret = UserAuth::UserAuth::GetInstance().GetAvailableStatus(uAuthType, uAuthTurstLevel); + int32_t ret = UserAuth::UserAuth::GetInstance().GetAvailableStatus(checkAuthType, authTurstLevel); if (ret != UserAuth::SUCCESS) { USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 checkAvailability is error "); } @@ -126,9 +126,9 @@ int32_t UserAuthAPI7::CheckAvailability(std::string authtype, std::string trustL void UserAuthAPI7::On(std::string tip, std::shared_ptr tipCallback) { USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 On is start"); - std::string sTip = "tip"; + std::string tipInfo = "tip"; - if (!sTip.compare(tip)) { + if (!tipInfo.compare(tip)) { USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 On is not tip"); UserAuthAPI7Datamgr::GetInstance().SetAPI7Tip(false); return; diff --git a/frameworks/kitsimpl/src/userauth_async_stub.cpp b/frameworks/kitsimpl/src/userauth_async_stub.cpp index e3608e808..eebd36438 100644 --- a/frameworks/kitsimpl/src/userauth_async_stub.cpp +++ b/frameworks/kitsimpl/src/userauth_async_stub.cpp @@ -192,11 +192,11 @@ void UserAuthAsyncStub::onAcquireInfo(const int32_t module, const uint32_t acqui USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthAsyncStub onAcquireInfo enter"); if (callback_ == nullptr) { - USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAsyncStub onAcquireInfo callback_ is Null"); + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAsyncStub onAcquireInfo callback_ is Null"); return ; } - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub module:%{public}d, acquireInfo:%{public}d", + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub module:%{public}d, acquireInfo:%{public}d", module, acquireInfo); callback_->onAcquireInfo(module, acquireInfo, extraInfo); @@ -207,11 +207,11 @@ void UserAuthAsyncStub::onResult(const int32_t result, const AuthResult extraInf USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthAsyncStub onResult enter"); if (callback_ == nullptr) { - USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAsyncStub onResult callback_ is Null"); + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAsyncStub onResult callback_ is Null"); return ; } - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub result:%{public}d, reTimes:%{public}d, freTime:%{public}d", + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub result:%{public}d, reTimes:%{public}d, freTime:%{public}d", result, extraInfot.remainTimes, extraInfot.freezingTime); callback_->onResult(result, extraInfot); } @@ -239,7 +239,7 @@ void UserAuthAsyncStub::onSetExecutorProperty(const int32_t result) USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub onSetExecutorProperty callback_ is Null"); return ; } - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub result:%{public}d", result); + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub result:%{public}d", result); callback_->onSetExecutorProperty(result); } } // namespace UserAuth diff --git a/interfaces/innerkits/js/ohos.UserIAM.userAuth_API7.d.ts b/interfaces/innerkits/js/ohos.UserIAM.userAuth_API7.d.ts new file mode 100644 index 000000000..5eca79f7b --- /dev/null +++ b/interfaces/innerkits/js/ohos.UserIAM.userAuth_API7.d.ts @@ -0,0 +1,336 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import{AsyncCallback} from './basic'; + +/** + * User authentication + * @since 8 + * @sysCap SystemCapability.UserIAM.UserAuth.BiometricAuth + * @devices phone, tablet + * @permission ohos.permission.ACCESS_BIOMETRIC + */ +declare namespace userIAM +{ + class Authenticator + { + /** + * Execute authentication. + * @since 8 + * @SysCap SystemCapability.UserIAM.UserAuth.BiometricAuth + * @param type Indicates the authentication type. + * @param level Indicates the security level. + * @return Returns authentication result, which is specified by AuthenticationResult. + */ + execute(type: string, level: string, callback: AsyncCallback): void; + execute(type:string, level:string): Promise; + + /** + * Cancels the current authentication. + * @since 8 + * @SysCap SystemCapability.UserIAM.UserAuth.BiometricAuth + * @return Returns a cancel result, which is specified by Result. + */ + cancel(): number; + + /** + * Checks whether the device supports the specified authentication type and security level. + * @since 8 + * @SysCap SystemCapability.UserIAM.UserAuth.BiometricAuth + * @param type Indicates the authentication type. + * @param level Indicates the security level. + * @return Returns a check result, which is specified by CheckAvailabilityResult. + */ + checkAvailability(type: AuthType, level: SecureLevel): number + + /** + * Registers an event callback. + * @since 8 + * @SysCap SystemCapability.UserIAM.UserAuth.BiometricAuth + * @param type Indicates the event type. + * @param callback Indicates the authentication tip callback to register. + */ + on(type: "tip", callback: Callback) : void; + + /** + * Unregisters an event callback. + * @since 8 + * @SysCap SystemCapability.UserIAM.UserAuth.BiometricAuth + * @param type Indicates the event type. + * @param callback Indicates the authentication tip callback to unregister. + */ + off(type: "tip", callback?: Callback) : void; + } + + /** + * Get Authenticator instance. + * @SysCap SystemCapability.UserIAM.UserAuth.BiometricAuth + * @return Returns an Authenticator. + */ + function getAuthenticator(): Authenticator; + + /** + * Auth types + */ + type AuthType = "ALL" | "FACE_ONLY"; + + /** + * Secure levels + */ + type SecureLevel = "S1" | "S2" | "S3" | "S4"; + + interface Tip { + /** + * Indicates whether authentication tip is obtained, defined in Result. + * @since 8 + */ + errorCode: number; + + /** + * Indicates an authentication tip event, defined in TipEvent. + * @since 8 + */ + tipEvent: number; + + /** + * Indicates the return code of an authentication tip, defined in TipCode. + * @since 8 + */ + tipCode: number; + + /** + * Indicates the description of an authentication tip code. + * @since 8 + */ + tipInfo: string; + } + + export enum AuthenticationResult { + /** + * Indicates that the device does not support authentication. + */ + NO_SUPPORT = -1, + + /** + * Indicates that authentication is success. + */ + SUCCESS = 0, + + /** + * Indicates the authenticator fails to identify user. + */ + COMPARE_FAILURE = 1, + + /** + * Indicates that authentication has been canceled. + */ + CANCELED = 2, + + /** + * Indicates that authentication has timed out. + */ + TIMEOUT = 3, + + /** + * Indicates a failure to open the camera. + */ + CAMERA_FAIL = 4, + + /** + * Indicates that the authentication task is busy. Wait for a few seconds and try again. + */ + BUSY = 5, + + /** + * Indicates incorrect parameters. + */ + INVALID_PARAMETERS = 6, + + /** + * Indicates that the authenticator is locked. + */ + LOCKED = 7, + + /** + * Indicates that the user has not enrolled the authenticator. + */ + NOT_ENROLLED = 8, + + /** + * Indicates other errors. + */ + GENERAL_ERROR = 100, + } + + export enum Result { + /** + * Indicates that execute is success. + * @since 8 + */ + SUCCESS = 0, + + /** + * Indicates that execute is failed. + * @since 8 + */ + FAILED = 1, + } + + export enum CheckAvailabilityResult { + /** + * Indicates that the device supports the specified authentication type and security level. + * @since 8 + */ + SUPPORTED = 0, + + /** + * Indicates that the device does not support the specified authentication type. + * @since 8 + */ + AUTH_TYPE_NOT_SUPPORT = 1, + + /** + * Indicates that the device does not support the specified authentication security level. + * @since 8 + */ + SECURE_LEVEL_NOT_SUPPORT = 2, + + /** + * Indicates that the device does not support distributed authentication. + * @since 8 + */ + DISTRIBUTED_AUTH_NOT_SUPPORT = 3, + + /** + * Indicates that the device does not have the authentication credential. + * @since 8 + */ + NOT_ENROLLED = 4, + + /** + * Indicates that the number of parameters is incorrect. + * @since 8 + */ + PARAM_NUM_ERROR = 5, + } + + export enum TipEvent { + /** + * Enroll or authenticate result. + * @since 8 + */ + RESULT = 1, + + /** + * Cancel result. + * @since 8 + */ + CANCEL = 2, + + /** + * Prompt for user enroll and authentication. + * @since 8 + */ + ACQUIRE = 3, + + /** + * Busy. + * @since 8 + */ + BUSY = 4, + + /** + * Out of memory. + * @since 8 + */ + OUT_OF_MEM = 5, + + /** + * Index of a face authentication credential. + * @since 8 + */ + FACE_ID = 6, + } + + export enum TipCode { + /** + * Indicates that the obtained facial image is too bright due to high illumination. + * @since 8 + */ + FACE_AUTH_TIP_TOO_BRIGHT = 1, + + /** + * Indicates that the obtained facial image is too dark due to low illumination. + * @since 8 + */ + FACE_AUTH_TIP_TOO_DARK = 2, + + /** + * Indicates that the face is too close to the device. + * @since 8 + */ + FACE_AUTH_TIP_TOO_CLOSE = 3, + + /** + * Indicates that the face is too far away from the device. + * @since 8 + */ + FACE_AUTH_TIP_TOO_FAR = 4, + + /** + * Indicates that the device is too high, and that only the upper part of the face is captured. + * @since 8 + */ + FACE_AUTH_TIP_TOO_HIGH = 5, + + /** + * Indicates that the device is too low, and that only the lower part of the face is captured. + * @since 8 + */ + FACE_AUTH_TIP_TOO_LOW = 6, + + /** + * Indicates that the device is deviated to the right, and that only the right part of the face is captured. + * @since 8 + */ + FACE_AUTH_TIP_TOO_RIGHT = 7, + + /** + * Indicates that the device is deviated to the left, and that only the left part of the face is captured. + * @since 8 + */ + FACE_AUTH_TIP_TOO_LEFT = 8, + + /** + * Indicates that the face moves too fast during facial information collection. + * @since 8 + */ + FACE_AUTH_TIP_TOO_MUCH_MOTION = 9, + + /** + * Indicates that the face is not facing the device. + * @since 8 + */ + FACE_AUTH_TIP_POOR_GAZE = 10, + + /** + * Indicates that no face is detected. + * @since 8 + */ + FACE_AUTH_TIP_NOT_DETECTED = 11, + } +} + +export default userIAM; \ No newline at end of file diff --git a/services/src/userauth_excallback_impl.cpp b/services/src/userauth_excallback_impl.cpp index 125dba752..1263009ae 100644 --- a/services/src/userauth_excallback_impl.cpp +++ b/services/src/userauth_excallback_impl.cpp @@ -125,7 +125,7 @@ void UserAuthCallbackImplCoAuth::OnFinish(uint32_t resultCode, std::vector scheduleToken_; scheduleToken_.assign(scheduleToken.begin(), scheduleToken.end()); - bool ret = ContextThreadPool::GetInstance().AddTask(callbackContextID_, [&](){ + bool ret = ContextThreadPool::GetInstance().AddTask(callbackContextID_, [&]() { OnFinishHandle(resultCode, scheduleToken_); }); if (!ret) { @@ -139,7 +139,7 @@ void UserAuthCallbackImplCoAuth::OnAcquireInfo(uint32_t acquire) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthCallbackImplCoAuth OnAcquireInfo enter"); - bool ret = ContextThreadPool::GetInstance().AddTask(callbackContextID_, [&](){ + bool ret = ContextThreadPool::GetInstance().AddTask(callbackContextID_, [&]() { OnAcquireInfoHandle(acquire); }); if (!ret) { -- Gitee From d3f3a0232b94659e73fb8f9c724948d0e5fc99ed Mon Sep 17 00:00:00 2001 From: wangxu43 Date: Mon, 7 Feb 2022 10:54:38 +0800 Subject: [PATCH 03/19] fix --- bundle.json | 2 +- frameworks/kitsimpl/src/userauth_async_stub.cpp | 14 +++++++------- services/src/userauth_adapter.cpp | 4 ++-- services/src/userauth_excallback_impl.cpp | 8 ++++---- services/src/userauth_service.cpp | 2 +- 5 files changed, 15 insertions(+), 15 deletions(-) diff --git a/bundle.json b/bundle.json index 9112a9ba8..c09601202 100644 --- a/bundle.json +++ b/bundle.json @@ -18,7 +18,7 @@ "adapted_system_type": [ "standard" ], "syscap": ["SystemCapability.UserIAM.UserAuth"], "features": [], - "rom": "200KB", + "rom": "2400KB", "ram": "1500KB", "deps": { "components": [ diff --git a/frameworks/kitsimpl/src/userauth_async_stub.cpp b/frameworks/kitsimpl/src/userauth_async_stub.cpp index eebd36438..bb6d33fc7 100644 --- a/frameworks/kitsimpl/src/userauth_async_stub.cpp +++ b/frameworks/kitsimpl/src/userauth_async_stub.cpp @@ -196,13 +196,13 @@ void UserAuthAsyncStub::onAcquireInfo(const int32_t module, const uint32_t acqui return ; } - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub module:%{public}d, acquireInfo:%{public}d", + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub module:%{public}d, acquireInfo:%{public}u", module, acquireInfo); callback_->onAcquireInfo(module, acquireInfo, extraInfo); } -void UserAuthAsyncStub::onResult(const int32_t result, const AuthResult extraInfot) +void UserAuthAsyncStub::onResult(const int32_t result, const AuthResult extraInfo) { USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthAsyncStub onResult enter"); @@ -211,9 +211,9 @@ void UserAuthAsyncStub::onResult(const int32_t result, const AuthResult extraInf return ; } - USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub result:%{public}d, reTimes:%{public}d, freTime:%{public}d", - result, extraInfot.remainTimes, extraInfot.freezingTime); - callback_->onResult(result, extraInfot); + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub result:%{public}d, remain:%{public}u, freeze:%{public}u", + result, extraInfo.remainTimes, extraInfo.freezingTime); + callback_->onResult(result, extraInfo); } void UserAuthAsyncStub::onExecutorPropertyInfo(const ExecutorProperty result) @@ -226,8 +226,8 @@ void UserAuthAsyncStub::onExecutorPropertyInfo(const ExecutorProperty result) } USERAUTH_HILOGD(MODULE_INNERKIT, - "userauthAsyncStub result:%{public}d, SubTyp:%{public}llu, reTimes:%{public}d, freTime:%{public}d", - result.result, result.authSubType, result.freezingTime, result.freezingTime); + "userauthAsyncStub result:%{public}d, sub:%{public}llu, remain:%{public}u, freeze:%{public}u", + result.result, result.authSubType, result.remainTimes, result.freezingTime); callback_->onExecutorPropertyInfo(result); } diff --git a/services/src/userauth_adapter.cpp b/services/src/userauth_adapter.cpp index 89fd00ce6..7b2ab55fc 100644 --- a/services/src/userauth_adapter.cpp +++ b/services/src/userauth_adapter.cpp @@ -316,7 +316,7 @@ int32_t UserAuthAdapter::GetEachExecutorProp(GetPropertyRequest &requset, Execut result.freezingTime = 0; result.remainTimes = 0; result.authSubType = UserAuth::PIN_SIX; - for (auto const & item : requset.keys) { + for (auto const &item : requset.keys) { switch (item) { case AUTH_SUB_TYPE: ret = pAuthAttributes->GetUint64Value(AUTH_SUBTYPE, tmpValue); @@ -421,7 +421,7 @@ int32_t UserAuthAdapter::coAuth(CoAuthInfo coAuthInfo, sptr& USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth SaveCoauthCallback ERROR!"); return ret; } - for (auto const & item : coAuthInfo.sessionIds) { + for (auto const &item : coAuthInfo.sessionIds) { CoAuth::CoAuth::GetInstance().coAuth(item, authInfo, coAuthCallback); } diff --git a/services/src/userauth_excallback_impl.cpp b/services/src/userauth_excallback_impl.cpp index 1263009ae..838598b86 100644 --- a/services/src/userauth_excallback_impl.cpp +++ b/services/src/userauth_excallback_impl.cpp @@ -126,7 +126,7 @@ void UserAuthCallbackImplCoAuth::OnFinish(uint32_t resultCode, std::vector scheduleToken_; scheduleToken_.assign(scheduleToken.begin(), scheduleToken.end()); bool ret = ContextThreadPool::GetInstance().AddTask(callbackContextID_, [&]() { - OnFinishHandle(resultCode, scheduleToken_); + OnFinishHandle(resultCode, scheduleToken_); }); if (!ret) { USERAUTH_HILOGE(MODULE_SERVICE, "OnFinish ContextThreadPool is BUSY"); @@ -140,7 +140,7 @@ void UserAuthCallbackImplCoAuth::OnAcquireInfo(uint32_t acquire) USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthCallbackImplCoAuth OnAcquireInfo enter"); bool ret = ContextThreadPool::GetInstance().AddTask(callbackContextID_, [&]() { - OnAcquireInfoHandle(acquire); + OnAcquireInfoHandle(acquire); }); if (!ret) { USERAUTH_HILOGE(MODULE_SERVICE, "OnAcquireInfoHandle ContextThreadPool is BUSY"); @@ -213,7 +213,7 @@ void UserAuthCallbackImplCoAuth::OnFinishHandle(uint32_t resultCode, std::vector callback_); } if (sessionIds.size() != 0) { - for (auto const & item : sessionIds) { + for (auto const &item : sessionIds) { UserAuthAdapter::GetInstance().Cancel(item); } } @@ -331,7 +331,7 @@ void UserAuthCallbackImplIDMCothGetPorpFreez::OnGetInfo(std::vector Date: Tue, 8 Feb 2022 16:10:31 +0800 Subject: [PATCH 04/19] Innerkit update --- frameworks/kitsimpl/src/userauth.cpp | 45 ++-- .../kitsimpl/src/userauth_async_stub.cpp | 34 ++- .../innerkits/napi/include/authapi_callback.h | 38 ++- .../innerkits/napi/src/authapi_callback.cpp | 255 +++++++++--------- .../innerkits/napi/src/user_auth_impl.cpp | 18 +- .../innerkits/native/include/user_auth.h | 6 +- .../native/include/userauth_async_stub.h | 8 +- .../native/include/userauth_callback.h | 13 +- test/unittest/src/userauth_test.cpp | 32 ++- 9 files changed, 252 insertions(+), 197 deletions(-) diff --git a/frameworks/kitsimpl/src/userauth.cpp b/frameworks/kitsimpl/src/userauth.cpp index 9715e7090..796592ab0 100644 --- a/frameworks/kitsimpl/src/userauth.cpp +++ b/frameworks/kitsimpl/src/userauth.cpp @@ -95,35 +95,35 @@ int32_t UserAuth::GetAvailableStatus(const AuthType authType, const AuthTurstLev return ret; } -void UserAuth::GetProperty(const GetPropertyRequest request, std::shared_ptr callback) +void UserAuth::GetProperty(const GetPropertyRequest request, std::shared_ptr callback) { USERAUTH_HILOGD(MODULE_INNERKIT, "userauth GetProperty is start"); + if (callback == nullptr) { + USERAUTH_HILOGE(MODULE_INNERKIT, "userauth GetProperty callback is Null"); + return; + } auto proxy = GetProxy(); if (proxy == nullptr) { - callback->onSetExecutorProperty(E_RET_NOSERVER); + ExecutorProperty result = {}; + result.result = E_RET_NOSERVER; + callback->onGetProperty(result); return ; } - if (callback == nullptr) { - USERAUTH_HILOGE(MODULE_INNERKIT, "userauth GetProperty callback is Null"); - } - sptr asyncStub = new UserAuthAsyncStub(callback); proxy_->GetProperty(request, asyncStub); } -void UserAuth::SetProperty(const SetPropertyRequest request, std::shared_ptr callback) +void UserAuth::SetProperty(const SetPropertyRequest request, std::shared_ptr callback) { USERAUTH_HILOGD(MODULE_INNERKIT, "userauth SetProperty is start"); + if (callback == nullptr) { + USERAUTH_HILOGE(MODULE_INNERKIT, "userauth SetProperty callback is Null"); + return; + } auto proxy = GetProxy(); if (proxy == nullptr) { - ExecutorProperty result; - result.result = E_RET_NOSERVER; - callback->onExecutorPropertyInfo(result); + callback->onSetProperty(E_RET_NOSERVER); return ; } - if (callback == nullptr) { - USERAUTH_HILOGE(MODULE_INNERKIT, "userauth SetProperty callback is Null"); - } - sptr asyncStub = new UserAuthAsyncStub(callback); proxy_->SetProperty(request, asyncStub); } @@ -131,14 +131,14 @@ uint64_t UserAuth::Auth(const uint64_t challenge, const AuthType authType, const std::shared_ptr callback) { USERAUTH_HILOGD(MODULE_INNERKIT, "userauth Auth is start"); - auto proxy = GetProxy(); - if (proxy == nullptr) { - return E_RET_NOSERVER; - } if (callback == nullptr) { USERAUTH_HILOGE(MODULE_INNERKIT, "userauth Auth callback is Null"); return INVALID_PARAMETERS; } + auto proxy = GetProxy(); + if (proxy == nullptr) { + return E_RET_NOSERVER; + } sptr asyncStub = new UserAuthAsyncStub(callback); uint64_t ret = proxy_->Auth(challenge, authType, authTurstLevel, asyncStub); return ret; @@ -147,15 +147,14 @@ uint64_t UserAuth::AuthUser(const int32_t userId, const uint64_t challenge, cons const AuthTurstLevel authTurstLevel, std::shared_ptr callback) { USERAUTH_HILOGD(MODULE_INNERKIT, "userauth AuthUser is start"); - auto proxy = GetProxy(); - if (proxy == nullptr) { - return E_RET_NOSERVER; - } if (callback == nullptr) { USERAUTH_HILOGE(MODULE_INNERKIT, "userauth AuthUser callback is Null"); return INVALID_PARAMETERS; } - + auto proxy = GetProxy(); + if (proxy == nullptr) { + return E_RET_NOSERVER; + } sptr asyncStub = new UserAuthAsyncStub(callback); uint64_t ret = proxy_->AuthUser(userId, challenge, authType, authTurstLevel, asyncStub); return ret; diff --git a/frameworks/kitsimpl/src/userauth_async_stub.cpp b/frameworks/kitsimpl/src/userauth_async_stub.cpp index bb6d33fc7..4a7ee0545 100644 --- a/frameworks/kitsimpl/src/userauth_async_stub.cpp +++ b/frameworks/kitsimpl/src/userauth_async_stub.cpp @@ -24,7 +24,15 @@ namespace UserIAM { namespace UserAuth { UserAuthAsyncStub::UserAuthAsyncStub(std::shared_ptr& impl) { - callback_ = impl; + authCallback_ = impl; +} +UserAuthAsyncStub::UserAuthAsyncStub(std::shared_ptr& impl) +{ + getPropCallback_ = impl; +} +UserAuthAsyncStub::UserAuthAsyncStub(std::shared_ptr& impl) +{ + setPropCallback_ = impl; } int32_t UserAuthAsyncStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) @@ -191,56 +199,56 @@ void UserAuthAsyncStub::onAcquireInfo(const int32_t module, const uint32_t acqui { USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthAsyncStub onAcquireInfo enter"); - if (callback_ == nullptr) { - USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAsyncStub onAcquireInfo callback_ is Null"); + if (authCallback_ == nullptr) { + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAsyncStub onAcquireInfo callback is Null"); return ; } USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub module:%{public}d, acquireInfo:%{public}u", module, acquireInfo); - callback_->onAcquireInfo(module, acquireInfo, extraInfo); + authCallback_->onAcquireInfo(module, acquireInfo, extraInfo); } void UserAuthAsyncStub::onResult(const int32_t result, const AuthResult extraInfo) { USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthAsyncStub onResult enter"); - if (callback_ == nullptr) { - USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAsyncStub onResult callback_ is Null"); + if (authCallback_ == nullptr) { + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAsyncStub onResult callback is Null"); return ; } USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub result:%{public}d, remain:%{public}u, freeze:%{public}u", result, extraInfo.remainTimes, extraInfo.freezingTime); - callback_->onResult(result, extraInfo); + authCallback_->onResult(result, extraInfo); } void UserAuthAsyncStub::onExecutorPropertyInfo(const ExecutorProperty result) { USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthAsyncStub onExecutorPropertyInfo enter"); - if (callback_ == nullptr) { - USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub onExecutorPropertyInfo callback_ is Null"); + if (getPropCallback_ == nullptr) { + USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub onExecutorPropertyInfo callback is Null"); return ; } USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub result:%{public}d, sub:%{public}llu, remain:%{public}u, freeze:%{public}u", result.result, result.authSubType, result.remainTimes, result.freezingTime); - callback_->onExecutorPropertyInfo(result); + getPropCallback_->onGetProperty(result); } void UserAuthAsyncStub::onSetExecutorProperty(const int32_t result) { USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthAsyncStub onSetExecutorProperty enter"); - if (callback_ == nullptr) { - USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub onSetExecutorProperty callback_ is Null"); + if (setPropCallback_ == nullptr) { + USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub onSetExecutorProperty callback is Null"); return ; } USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub result:%{public}d", result); - callback_->onSetExecutorProperty(result); + setPropCallback_->onSetProperty(result); } } // namespace UserAuth } // namespace UserIAM diff --git a/interfaces/innerkits/napi/include/authapi_callback.h b/interfaces/innerkits/napi/include/authapi_callback.h index 87fbf6de1..d1b5713cd 100755 --- a/interfaces/innerkits/napi/include/authapi_callback.h +++ b/interfaces/innerkits/napi/include/authapi_callback.h @@ -37,20 +37,12 @@ typedef struct AcquireInfoInner { } AcquireInfoInner; class AuthApiCallback : public UserAuthCallback { public: - AuthApiCallback(); + AuthApiCallback(AuthInfo *authInfo); + AuthApiCallback(AuthUserInfo *userInfo); virtual ~AuthApiCallback(); - GetPropertyInfo *getPropertyInfo_; - SetPropertyInfo *setPropertyInfo_; - AuthInfo *authInfo_; - AuthUserInfo *userInfo_; - void onExecutorPropertyInfo(const ExecutorProperty result) override; 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; - void onSetExecutorProperty(const int32_t result) override; - static napi_value BuildExecutorProperty( - napi_env env, int32_t result, uint32_t remainTimes, uint32_t freezingTime, uint64_t authSubType); - static napi_value Uint64ToNapi(napi_env env, uint64_t value); static napi_value BuildOnResult( napi_env env, uint32_t remainTimes, uint32_t freezingTime, std::vector token); static napi_value Uint8ArrayToNapi(napi_env env, std::vector value); @@ -59,6 +51,32 @@ private: void OnAuthAcquireInfo(AcquireInfoInner *acquireInfoInner); void OnUserAuthResult(const int32_t result, const AuthResult extraInfo); void OnAuthResult(const int32_t result, const AuthResult extraInfo); + + AuthInfo *authInfo_; + AuthUserInfo *userInfo_; +}; + +class GetPropApiCallback : public GetPropCallback { +public: + GetPropApiCallback(GetPropertyInfo *getPropertyInfo); + virtual ~GetPropApiCallback(); + void onGetProperty(const ExecutorProperty result) override; + + static napi_value BuildExecutorProperty( + napi_env env, int32_t result, uint32_t remainTimes, uint32_t freezingTime, uint64_t authSubType); + +private: + GetPropertyInfo *getPropertyInfo_; +}; + +class SetPropApiCallback : public SetPropCallback { +public: + SetPropApiCallback(SetPropertyInfo *setPropertyInfo); + virtual ~SetPropApiCallback(); + void onSetProperty(const int32_t result) override; + +private: + SetPropertyInfo *setPropertyInfo_; }; } // namespace UserAuth } // namespace UserIAM diff --git a/interfaces/innerkits/napi/src/authapi_callback.cpp b/interfaces/innerkits/napi/src/authapi_callback.cpp index 7abfba6b2..876decb9e 100755 --- a/interfaces/innerkits/napi/src/authapi_callback.cpp +++ b/interfaces/innerkits/napi/src/authapi_callback.cpp @@ -23,49 +23,20 @@ namespace OHOS { namespace UserIAM { namespace UserAuth { -AuthApiCallback::AuthApiCallback() +AuthApiCallback::AuthApiCallback(AuthInfo *authInfo) { + authInfo_ = authInfo; + userInfo_ = nullptr; } -AuthApiCallback::~AuthApiCallback() +AuthApiCallback::AuthApiCallback(AuthUserInfo *userInfo) { + authInfo_ = nullptr; + userInfo_ = userInfo; } -napi_value AuthApiCallback::BuildExecutorProperty( - napi_env env, int32_t result, uint32_t remainTimes, uint32_t freezingTime, uint64_t authSubType) +AuthApiCallback::~AuthApiCallback() { - napi_value jsObject = nullptr; - NAPI_CALL(env, napi_create_object(env, &jsObject)); - - napi_value resultValue = 0; - NAPI_CALL(env, napi_create_int32(env, result, &resultValue)); - NAPI_CALL(env, napi_set_named_property(env, jsObject, "result", resultValue)); - - napi_value remainTimesValue = 0; - NAPI_CALL(env, napi_create_uint32(env, remainTimes, &remainTimesValue)); - NAPI_CALL(env, napi_set_named_property(env, jsObject, "remainTimes", remainTimesValue)); - - napi_value freezingTimeValue = 0; - NAPI_CALL(env, napi_create_uint32(env, freezingTime, &freezingTimeValue)); - NAPI_CALL(env, napi_set_named_property(env, jsObject, "freezingTime", freezingTimeValue)); - - 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; -} - -napi_value AuthApiCallback::Uint64ToNapi(napi_env env, uint64_t value) -{ - size_t length = sizeof(value); - napi_value out = nullptr; - void *data = nullptr; - napi_value arrayBuffer = nullptr; - size_t bufferSize = length; - NAPI_CALL(env, napi_create_arraybuffer(env, bufferSize, &data, &arrayBuffer)); - memcpy_s(data, bufferSize, reinterpret_cast(&value), bufferSize); - NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, bufferSize, arrayBuffer, 0, &out)); - return out; } napi_value AuthApiCallback::Uint8ArrayToNapi(napi_env env, std::vector value) @@ -102,89 +73,6 @@ napi_value AuthApiCallback::BuildOnResult( return jsObject; } -static void GetPropertyInfoCallback(uv_work_t* work, int status) -{ - HILOG_INFO("Do OnAuthAcquireInfo work"); - GetPropertyInfo *getPropertyInfo = reinterpret_cast(work->data); - if (getPropertyInfo == nullptr) { - HILOG_ERROR("getPropertyInfo is null"); - delete work; - return; - } - napi_env env = getPropertyInfo->callBackInfo.env; - napi_value resultData[PARAM1]; - resultData[PARAM0] = AuthApiCallback::BuildExecutorProperty(env, getPropertyInfo->getResult, - getPropertyInfo->remainTimes, getPropertyInfo->freezingTime, getPropertyInfo->authSubType); - if (getPropertyInfo->callBackInfo.callBack != nullptr) { - HILOG_INFO("onExecutorPropertyInfo async"); - napi_value global = nullptr; - napi_status napiStatus = napi_get_global(env, &global); - if (napiStatus != napi_ok) { - HILOG_INFO("napi_get_global faild "); - goto EXIT; - } - napi_value resultValue = nullptr; - napi_value callBack = nullptr; - napiStatus = napi_get_reference_value(env, getPropertyInfo->callBackInfo.callBack, &callBack); - if (napiStatus != napi_ok) { - HILOG_INFO("napi_get_reference_value faild "); - goto EXIT; - } - napiStatus = napi_call_function(env, global, callBack, PARAM1, resultData, &resultValue); - if (napiStatus != napi_ok) { - HILOG_INFO("napi_call_function faild "); - goto EXIT; - } - } else { - HILOG_INFO("onExecutorPropertyInfo promise"); - napi_value resultValue = resultData[PARAM0]; - napi_deferred deferred = getPropertyInfo->callBackInfo.deferred; - napi_status napiStatus = napi_resolve_deferred(env, deferred, resultValue); - if (napiStatus != napi_ok) { - HILOG_INFO("napi_resolve_deferred faild "); - goto EXIT; - } - } -EXIT: - delete getPropertyInfo; - delete work; -} - -void AuthApiCallback::onExecutorPropertyInfo(const ExecutorProperty result) -{ - HILOG_INFO("AuthApiCallback onExecutorPropertyInfo 1 = %{public}d", result.result); - HILOG_INFO("AuthApiCallback onExecutorPropertyInfo 2 = %{public}llu", result.authSubType); - HILOG_INFO("AuthApiCallback onExecutorPropertyInfo 3 = %{public}u", result.remainTimes); - HILOG_INFO("AuthApiCallback onExecutorPropertyInfo 4 = %{public}u", result.freezingTime); - if (getPropertyInfo_ == nullptr) { - HILOG_ERROR("AuthApiCallback onExecutorPropertyInfo getPropertyInfo_ is nullptr"); - return; - } - uv_loop_s *loop(nullptr); - napi_get_uv_event_loop(getPropertyInfo_->callBackInfo.env, &loop); - if (loop == nullptr) { - HILOG_ERROR("loop is null"); - delete getPropertyInfo_; - getPropertyInfo_ = nullptr; - return; - } - uv_work_t *work = new (std::nothrow) uv_work_t; - if (work == nullptr) { - HILOG_ERROR("work is null"); - delete getPropertyInfo_; - getPropertyInfo_ = nullptr; - return; - } - getPropertyInfo_->getResult = result.result; - getPropertyInfo_->authSubType = static_cast(result.authSubType); - getPropertyInfo_->remainTimes = result.remainTimes; - getPropertyInfo_->freezingTime = result.freezingTime; - work->data = reinterpret_cast(getPropertyInfo_); - getPropertyInfo_ = nullptr; - HILOG_INFO("Before GetPropertyInfoCallback"); - uv_queue_work(loop, work, [] (uv_work_t *work) {}, GetPropertyInfoCallback); -} - void AuthApiCallback::OnAuthAcquireInfo(AcquireInfoInner *acquireInfoInner) { HILOG_INFO("AuthApiCallback OnAuthAcquireInfo start"); @@ -400,6 +288,131 @@ void AuthApiCallback::onResult(const int32_t result, const AuthResult extraInfo) HILOG_INFO("AuthApiCallback onResult end"); } +GetPropApiCallback::GetPropApiCallback(GetPropertyInfo *getPropertyInfo) +{ + getPropertyInfo_ = getPropertyInfo; +} + +GetPropApiCallback::~GetPropApiCallback() +{ +} + +static void GetPropertyInfoCallback(uv_work_t* work, int status) +{ + HILOG_INFO("Do OnAuthAcquireInfo work"); + GetPropertyInfo *getPropertyInfo = reinterpret_cast(work->data); + if (getPropertyInfo == nullptr) { + HILOG_ERROR("getPropertyInfo is null"); + delete work; + return; + } + napi_env env = getPropertyInfo->callBackInfo.env; + napi_value resultData[PARAM1]; + resultData[PARAM0] = GetPropApiCallback::BuildExecutorProperty(env, getPropertyInfo->getResult, + getPropertyInfo->remainTimes, getPropertyInfo->freezingTime, getPropertyInfo->authSubType); + if (getPropertyInfo->callBackInfo.callBack != nullptr) { + HILOG_INFO("onExecutorPropertyInfo async"); + napi_value global = nullptr; + napi_status napiStatus = napi_get_global(env, &global); + if (napiStatus != napi_ok) { + HILOG_INFO("napi_get_global faild "); + goto EXIT; + } + napi_value resultValue = nullptr; + napi_value callBack = nullptr; + napiStatus = napi_get_reference_value(env, getPropertyInfo->callBackInfo.callBack, &callBack); + if (napiStatus != napi_ok) { + HILOG_INFO("napi_get_reference_value faild "); + goto EXIT; + } + napiStatus = napi_call_function(env, global, callBack, PARAM1, resultData, &resultValue); + if (napiStatus != napi_ok) { + HILOG_INFO("napi_call_function faild "); + goto EXIT; + } + } else { + HILOG_INFO("onExecutorPropertyInfo promise"); + napi_value resultValue = resultData[PARAM0]; + napi_deferred deferred = getPropertyInfo->callBackInfo.deferred; + napi_status napiStatus = napi_resolve_deferred(env, deferred, resultValue); + if (napiStatus != napi_ok) { + HILOG_INFO("napi_resolve_deferred faild "); + goto EXIT; + } + } +EXIT: + delete getPropertyInfo; + delete work; +} + +napi_value GetPropApiCallback::BuildExecutorProperty( + napi_env env, int32_t result, uint32_t remainTimes, uint32_t freezingTime, uint64_t authSubType) +{ + napi_value jsObject = nullptr; + NAPI_CALL(env, napi_create_object(env, &jsObject)); + + napi_value resultValue = 0; + NAPI_CALL(env, napi_create_int32(env, result, &resultValue)); + NAPI_CALL(env, napi_set_named_property(env, jsObject, "result", resultValue)); + + napi_value remainTimesValue = 0; + NAPI_CALL(env, napi_create_uint32(env, remainTimes, &remainTimesValue)); + NAPI_CALL(env, napi_set_named_property(env, jsObject, "remainTimes", remainTimesValue)); + + napi_value freezingTimeValue = 0; + NAPI_CALL(env, napi_create_uint32(env, freezingTime, &freezingTimeValue)); + NAPI_CALL(env, napi_set_named_property(env, jsObject, "freezingTime", freezingTimeValue)); + + 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; +} + +void GetPropApiCallback::onGetProperty(const ExecutorProperty result) +{ + HILOG_INFO("GetPropApiCallback onGetProperty 1 = %{public}d", result.result); + HILOG_INFO("GetPropApiCallback onGetProperty 2 = %{public}llu", result.authSubType); + HILOG_INFO("GetPropApiCallback onGetProperty 3 = %{public}u", result.remainTimes); + HILOG_INFO("GetPropApiCallback onGetProperty 4 = %{public}u", result.freezingTime); + if (getPropertyInfo_ == nullptr) { + HILOG_ERROR("GetPropApiCallback onGetProperty getPropertyInfo_ is nullptr"); + return; + } + uv_loop_s *loop(nullptr); + napi_get_uv_event_loop(getPropertyInfo_->callBackInfo.env, &loop); + if (loop == nullptr) { + HILOG_ERROR("loop is null"); + delete getPropertyInfo_; + getPropertyInfo_ = nullptr; + return; + } + uv_work_t *work = new (std::nothrow) uv_work_t; + if (work == nullptr) { + HILOG_ERROR("work is null"); + delete getPropertyInfo_; + getPropertyInfo_ = nullptr; + return; + } + getPropertyInfo_->getResult = result.result; + getPropertyInfo_->authSubType = static_cast(result.authSubType); + getPropertyInfo_->remainTimes = result.remainTimes; + getPropertyInfo_->freezingTime = result.freezingTime; + work->data = reinterpret_cast(getPropertyInfo_); + getPropertyInfo_ = nullptr; + HILOG_INFO("Before GetPropertyInfoCallback"); + uv_queue_work(loop, work, [] (uv_work_t *work) {}, GetPropertyInfoCallback); +} + +SetPropApiCallback::SetPropApiCallback(SetPropertyInfo *setPropertyInfo) +{ + setPropertyInfo_ = setPropertyInfo; +} + +SetPropApiCallback::~SetPropApiCallback() +{ +} + static void SetExecutorPropertyCallback(uv_work_t *work, int status) { HILOG_INFO("Do SetExecutorPropertyCallback work"); @@ -451,9 +464,9 @@ EXIT: delete work; } -void AuthApiCallback::onSetExecutorProperty(const int32_t result) +void SetPropApiCallback::onSetProperty(const int32_t result) { - HILOG_INFO("onSetExecutorProperty start = %{public}d", result); + HILOG_INFO("onSetProperty start = %{public}d", result); if (setPropertyInfo_ != nullptr) { HILOG_ERROR("setPropertyInfo is null"); return; diff --git a/interfaces/innerkits/napi/src/user_auth_impl.cpp b/interfaces/innerkits/napi/src/user_auth_impl.cpp index 50bbc87a7..d1f54dcf7 100755 --- a/interfaces/innerkits/napi/src/user_auth_impl.cpp +++ b/interfaces/innerkits/napi/src/user_auth_impl.cpp @@ -151,9 +151,8 @@ void UserAuthImpl::GetPropertyExecute(napi_env env, void *data) request.authType = authTypeGet; request.keys = getPropertyInfo->keys; HILOG_INFO("GetPropertyExecute start 1"); - AuthApiCallback *object = new AuthApiCallback(); - object->getPropertyInfo_ = getPropertyInfo; - std::shared_ptr callback; + GetPropApiCallback *object = new GetPropApiCallback(getPropertyInfo); + std::shared_ptr callback; callback.reset(object); UserAuth::GetInstance().GetProperty(request, callback); HILOG_INFO("GetPropertyExecute, worker pool thread execute end."); @@ -292,9 +291,8 @@ void UserAuthImpl::SetPropertyExecute(napi_env env, void *data) request.authType = authTypeGet; request.key = SetPropertyType(setPropertyInfo->key); request.setInfo = setPropertyInfo->setInfo; - AuthApiCallback *object = new AuthApiCallback(); - object->setPropertyInfo_ = setPropertyInfo; - std::shared_ptr callback; + SetPropApiCallback *object = new SetPropApiCallback(setPropertyInfo); + std::shared_ptr callback; callback.reset(object); UserAuth::GetInstance().SetProperty(request, callback); HILOG_INFO("setPropertyExecute, worker pool thread execute end."); @@ -407,9 +405,7 @@ napi_value UserAuthImpl::Auth(napi_env env, napi_callback_info info) 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; + AuthApiCallback *object = new AuthApiCallback(authInfo); std::shared_ptr callback; callback.reset(object); uint64_t result = UserAuth::GetInstance().Auth( @@ -480,9 +476,7 @@ napi_value UserAuthImpl::BuildAuthUserInfo(napi_env env, AuthUserInfo *userInfo) napi_value UserAuthImpl::AuthUserWrap(napi_env env, AuthUserInfo *userInfo) { HILOG_INFO("%{public}s, start.", __func__); - AuthApiCallback *object = new AuthApiCallback(); - object->authInfo_ = nullptr; - object->userInfo_ = userInfo; + AuthApiCallback *object = new AuthApiCallback(userInfo); std::shared_ptr callback; callback.reset(object); uint64_t result = UserAuth::GetInstance().AuthUser(userInfo->userId, userInfo->challenge, diff --git a/interfaces/innerkits/native/include/user_auth.h b/interfaces/innerkits/native/include/user_auth.h index 4c875e446..49348c4e1 100755 --- a/interfaces/innerkits/native/include/user_auth.h +++ b/interfaces/innerkits/native/include/user_auth.h @@ -32,8 +32,8 @@ public: DISALLOW_COPY_AND_MOVE(UserAuth); int32_t GetAvailableStatus(const AuthType authType, const AuthTurstLevel authTurstLevel); - void GetProperty(const GetPropertyRequest request, std::shared_ptr callback); - void SetProperty(const SetPropertyRequest request, std::shared_ptr callback); + void GetProperty(const GetPropertyRequest request, std::shared_ptr callback); + void SetProperty(const SetPropertyRequest request, std::shared_ptr callback); uint64_t Auth(const uint64_t challenge, const AuthType authType, const AuthTurstLevel authTurstLevel, std::shared_ptr callback); uint64_t AuthUser(const int32_t userId, const uint64_t challenge, const AuthType authType, @@ -61,4 +61,4 @@ private: } // namespace UserAuth } // namespace UserIam } // namespace OHOS -#endif // USERAUTH_CLIENT_H \ No newline at end of file +#endif // USERAUTH_CLIENT_H diff --git a/interfaces/innerkits/native/include/userauth_async_stub.h b/interfaces/innerkits/native/include/userauth_async_stub.h index 27ea1b6cc..980b29b38 100755 --- a/interfaces/innerkits/native/include/userauth_async_stub.h +++ b/interfaces/innerkits/native/include/userauth_async_stub.h @@ -26,6 +26,8 @@ namespace UserAuth { class UserAuthAsyncStub : public IRemoteStub { public: explicit UserAuthAsyncStub(std::shared_ptr& impl); + explicit UserAuthAsyncStub(std::shared_ptr& impl); + explicit UserAuthAsyncStub(std::shared_ptr& impl); ~UserAuthAsyncStub() = default; int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override; @@ -39,10 +41,12 @@ private: int32_t onResultStub(MessageParcel& data, MessageParcel& reply); int32_t onExecutorPropertyInfoStub(MessageParcel& data, MessageParcel& reply); int32_t onSetExecutorPropertyStub(MessageParcel& data, MessageParcel& reply); - std::shared_ptr callback_ {nullptr}; + std::shared_ptr authCallback_ {nullptr}; + std::shared_ptr setPropCallback_ {nullptr}; + std::shared_ptr getPropCallback_ {nullptr}; }; } // namespace UserAuth } // namespace UserIAM } // namespace OHOS -#endif // USERAUTH_ASYNC_STUB_H \ No newline at end of file +#endif // USERAUTH_ASYNC_STUB_H diff --git a/interfaces/innerkits/native/include/userauth_callback.h b/interfaces/innerkits/native/include/userauth_callback.h index 9982c24cb..c451c1b87 100755 --- a/interfaces/innerkits/native/include/userauth_callback.h +++ b/interfaces/innerkits/native/include/userauth_callback.h @@ -23,13 +23,18 @@ namespace UserIAM { namespace UserAuth { class UserAuthCallback { public: - virtual void onAcquireInfo(const int32_t module, const uint32_t acquireInfo, const int32_t extraInfo) = 0; virtual void onResult(const int32_t result, const AuthResult extraInfo) = 0; - virtual void onExecutorPropertyInfo(const ExecutorProperty result) = 0; - virtual void onSetExecutorProperty(const int32_t result) = 0; +}; +class GetPropCallback { +public: + virtual void onGetProperty(const ExecutorProperty result) = 0; +}; +class SetPropCallback { +public: + virtual void onSetProperty(const int32_t result) = 0; }; } // namespace UserAuth } // namespace UserIam } // namespace OHOS -#endif // IUSERAUTH_CALLBACK_H \ No newline at end of file +#endif // IUSERAUTH_CALLBACK_H diff --git a/test/unittest/src/userauth_test.cpp b/test/unittest/src/userauth_test.cpp index f567339bb..5e98b7ebb 100644 --- a/test/unittest/src/userauth_test.cpp +++ b/test/unittest/src/userauth_test.cpp @@ -59,8 +59,22 @@ public: 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; - void onExecutorPropertyInfo(const ExecutorProperty result) override; - void onSetExecutorProperty(const int32_t result) override; +}; + +class TestGetPropCallback : public GetPropCallback { +public: + TestGetPropCallback() = default; + virtual ~TestGetPropCallback() = default; + + void onGetProperty(const ExecutorProperty result) override; +}; + +class TestSetPropCallback : public SetPropCallback { +public: + TestSetPropCallback() = default; + virtual ~TestSetPropCallback() = default; + + void onSetProperty(const int32_t result) override; }; void TestUserAuthCallback::onAcquireInfo(const int32_t module, const uint32_t acquireInfo, const int32_t extraInfo) @@ -71,13 +85,13 @@ void TestUserAuthCallback::onResult(const int32_t result, const AuthResult extra { std::cout << "onResult callback" << std::endl; } -void TestUserAuthCallback::onExecutorPropertyInfo(const ExecutorProperty result) +void TestGetPropCallback::onGetProperty(const ExecutorProperty result) { - std::cout << "onExecutorPropertyInfo callback" << std::endl; + std::cout << "onGetProperty callback" << std::endl; } -void TestUserAuthCallback::onSetExecutorProperty(const int32_t result) +void TestSetPropCallback::onSetProperty(const int32_t result) { - std::cout << "onSetExecutorProperty callback" << std::endl; + std::cout << "onSetProperty callback" << std::endl; } class TestUserAuthAPI7Callback : public UserAuthAPI7Callback { @@ -112,7 +126,7 @@ HWTEST_F(UseriamUtTest, UseriamUtTest_002, TestSize.Level1) request.authType = FACE; request.keys.push_back(1); request.keys.push_back(3); - std::shared_ptr callback = std::make_shared(); + std::shared_ptr callback = std::make_shared(); UserAuth::GetInstance().GetProperty(request, callback); } @@ -123,7 +137,7 @@ HWTEST_F(UseriamUtTest, UseriamUtTest_003, TestSize.Level1) request.key = INIT_ALGORITHM; uint8_t i = 123; request.setInfo.push_back(i); - std::shared_ptr callback = std::make_shared(); + std::shared_ptr callback = std::make_shared(); UserAuth::GetInstance().SetProperty(request, callback); } @@ -181,4 +195,4 @@ HWTEST_F(UseriamUtTest, UseriamUtTest_011, TestSize.Level1) } } } -} \ No newline at end of file +} -- Gitee From fc9c8c4f1bb276f9718d4c3232d89446cecedf29 Mon Sep 17 00:00:00 2001 From: wangxu43 Date: Tue, 8 Feb 2022 16:47:53 +0800 Subject: [PATCH 05/19] bug fix --- services/src/userauth_excallback_impl.cpp | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/services/src/userauth_excallback_impl.cpp b/services/src/userauth_excallback_impl.cpp index 838598b86..cb449e97e 100644 --- a/services/src/userauth_excallback_impl.cpp +++ b/services/src/userauth_excallback_impl.cpp @@ -53,7 +53,7 @@ UserAuthCallbackImplSetPropFreez::UserAuthCallbackImplSetPropFreez(const sptr scheduleToken_; scheduleToken_.assign(scheduleToken.begin(), scheduleToken.end()); - bool ret = ContextThreadPool::GetInstance().AddTask(callbackContextID_, [&]() { - OnFinishHandle(resultCode, scheduleToken_); - }); + auto task = std::bind(&UserAuthCallbackImplCoAuth::OnFinishHandle, this, resultCode, scheduleToken_); + bool ret = ContextThreadPool::GetInstance().AddTask(callbackContextID_, task); if (!ret) { USERAUTH_HILOGE(MODULE_SERVICE, "OnFinish ContextThreadPool is BUSY"); callback_->onResult(BUSY, authResult); @@ -139,9 +138,8 @@ void UserAuthCallbackImplCoAuth::OnAcquireInfo(uint32_t acquire) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthCallbackImplCoAuth OnAcquireInfo enter"); - bool ret = ContextThreadPool::GetInstance().AddTask(callbackContextID_, [&]() { - OnAcquireInfoHandle(acquire); - }); + auto task = std::bind(&UserAuthCallbackImplCoAuth::OnAcquireInfoHandle, this, acquire); + bool ret = ContextThreadPool::GetInstance().AddTask(callbackContextID_, task); if (!ret) { USERAUTH_HILOGE(MODULE_SERVICE, "OnAcquireInfoHandle ContextThreadPool is BUSY"); isResultDoneFlag_ = true; -- Gitee From fa092fd00daead705f64c9b2bb94f20bd1aa89d7 Mon Sep 17 00:00:00 2001 From: wangxu43 Date: Wed, 9 Feb 2022 17:14:43 +0800 Subject: [PATCH 06/19] Code update --- .../innerkits/native/include/userauth_info.h | 1 + services/BUILD.gn | 2 + services/include/userauth_adapter.h | 12 ++-- services/include/userauth_controller.h | 3 +- services/include/userauth_excallback_impl.h | 3 +- services/include/userauth_service.h | 1 + services/src/userauth_adapter.cpp | 56 ++++--------------- services/src/userauth_controller.cpp | 8 +-- services/src/userauth_excallback_impl.cpp | 15 ++--- services/src/userauth_service.cpp | 39 +++++++++++-- 10 files changed, 67 insertions(+), 73 deletions(-) diff --git a/interfaces/innerkits/native/include/userauth_info.h b/interfaces/innerkits/native/include/userauth_info.h index 7a60d349d..e826536d7 100755 --- a/interfaces/innerkits/native/include/userauth_info.h +++ b/interfaces/innerkits/native/include/userauth_info.h @@ -112,6 +112,7 @@ struct CoAuthInfo { AuthType authType; uint64_t callerID; uint64_t contextID; + int32_t userID; std::string pkgName; std::vector sessionIds; }; diff --git a/services/BUILD.gn b/services/BUILD.gn index db18f921d..dae1c3a0f 100755 --- a/services/BUILD.gn +++ b/services/BUILD.gn @@ -18,6 +18,7 @@ config("userauth_private_config") { "include", "//base/user_iam/auth_executor_mgr/common/interface", "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + "//base/security/access_token/interfaces/innerkits/accesstoken/include", ] } @@ -40,6 +41,7 @@ ohos_shared_library("userauthservice") { deps = [ "${userauth_innerkits_path}/native:userauth_framework", + "//base/security/access_token/interfaces/innerkits/accesstoken:libaccesstoken_sdk", "//base/startup/syspara_lite/interfaces/innerkits/native/syspara:syspara", "//base/user_iam/auth_executor_mgr/common:useriam_common_lib", "//base/user_iam/auth_executor_mgr/interfaces/innerkits:coauth_framework", diff --git a/services/include/userauth_adapter.h b/services/include/userauth_adapter.h index 7ad3d7ecf..d445d59c9 100644 --- a/services/include/userauth_adapter.h +++ b/services/include/userauth_adapter.h @@ -35,25 +35,23 @@ public: int32_t GetAuthTrustLevel(int32_t userId, uint32_t authType, uint32_t &authTrustLevel); /* Get the executor authentication properties */ - void GetPropAuthInfo(uint64_t callerUID, std::string pkgName, GetPropertyRequest requset, + void GetPropAuthInfo(int32_t userID, uint64_t callerUID, std::string pkgName, GetPropertyRequest requset, sptr& callback); /** This method is called to set the executor properties * after the callback of the coAuth is called to obtain the scheduling token * and the authentication result is successful. * */ - void CoauthSetPropAuthInfo(int32_t resultCode, uint64_t callerUID, std::string pkgName, UserAuthToken authToken, - SetPropertyRequest requset, sptr& callback); + void CoauthSetPropAuthInfo(int32_t userID, int32_t resultCode, uint64_t callerUID, std::string pkgName, + UserAuthToken authToken, SetPropertyRequest requset, sptr& callback); /* Set the executor authentication properties for freez or unfreez */ void SetPropAuthInfo(uint64_t callerUID, std::string pkgName, int32_t resultCode, UserAuthToken authToken, SetPropertyRequest requset, std::vector templateIds, sptr& callback); /* get the executor authentication properties for Coauth */ - void GetPropAuthInfoCoauth(uint64_t callerUID, std::string pkgName, int32_t resultCode, UserAuthToken authToken, - GetPropertyRequest requset, sptr& callback); - /* get userID */ - int32_t GetUserID(int32_t &userID); + void GetPropAuthInfoCoauth(int32_t userID, uint64_t callerUID, std::string pkgName, int32_t resultCode, + UserAuthToken authToken, GetPropertyRequest requset, sptr& callback); int32_t GenerateSolution(AuthSolution param, std::vector &sessionIds); int32_t RequestAuthResult(uint64_t contextId, std::vector scheduleToken, UserAuthToken &authToken, std::vector &sessionIds); diff --git a/services/include/userauth_controller.h b/services/include/userauth_controller.h index 079c765d7..b25893332 100644 --- a/services/include/userauth_controller.h +++ b/services/include/userauth_controller.h @@ -27,11 +27,10 @@ namespace UserAuth { class UserAuthController { public: int32_t GetAuthTrustLevel(int32_t userId, uint32_t authType, uint32_t &authTrustLevel); - void GetPropAuthInfo(std::string pkgName, uint64_t callerUID, GetPropertyRequest getPropertyRequest, + void GetPropAuthInfo(int32_t userID, std::string pkgName, uint64_t callerUID, GetPropertyRequest getPropertyRequest, sptr& callback); int32_t SetExecutorProp(uint64_t callerUID, std::string pkgName, SetPropertyRequest setPropertyrequest, sptr& callback); - int32_t GetUserID(int32_t &userID); int32_t AddContextID(uint64_t contextID); int32_t IsContextIDExist(uint64_t contextID); int32_t GenerateContextID(uint64_t &contextID); diff --git a/services/include/userauth_excallback_impl.h b/services/include/userauth_excallback_impl.h index e20ad8d66..fa9a7c024 100644 --- a/services/include/userauth_excallback_impl.h +++ b/services/include/userauth_excallback_impl.h @@ -46,6 +46,7 @@ private: int32_t callbackNowCount_ = 0; uint64_t callbackContextID_ = 0; std::string pkgName_ = ""; + int32_t userID_ = 0; uint64_t callerUid_ = 0; bool isResultDoneFlag_ = false; sptr callback_ { nullptr }; @@ -53,7 +54,7 @@ private: std::mutex mutex_; static std::mutex coauthCallbackmutex_; static std::map> saveCoauthCallback_; - void OnFinishHandleExtend(SetPropertyRequest setPropertyRequest, AuthResult authResult, int32_t ret, + void OnFinishHandleExtend(int32_t userID, SetPropertyRequest setPropertyRequest, AuthResult authResult, int32_t ret, UserAuthToken authToken); }; diff --git a/services/include/userauth_service.h b/services/include/userauth_service.h index 03e22009a..1311866f2 100644 --- a/services/include/userauth_service.h +++ b/services/include/userauth_service.h @@ -45,6 +45,7 @@ public: int32_t GetVersion() override; private: + int32_t GetCallingUserID(int32_t &userID); int32_t GetControllerData(sptr& callback, AuthResult &extraInfo, const AuthTurstLevel authTurstLevel, uint64_t &callerID, std::string &callerName, uint64_t &contextID); diff --git a/services/src/userauth_adapter.cpp b/services/src/userauth_adapter.cpp index 7b2ab55fc..5cacdaad2 100644 --- a/services/src/userauth_adapter.cpp +++ b/services/src/userauth_adapter.cpp @@ -26,7 +26,6 @@ namespace OHOS { namespace UserIAM { namespace UserAuth { -const int USERID_BUFF_SIZE = 10; UserAuthAdapter &UserAuthAdapter::GetInstance() { static UserAuthAdapter instance; @@ -44,15 +43,15 @@ int32_t UserAuthAdapter::GetAuthTrustLevel(int32_t userId, uint32_t authType, ui return ret; } -void UserAuthAdapter::GetPropAuthInfo(uint64_t callerUID, std::string pkgName, GetPropertyRequest requset, - sptr& callback) +void UserAuthAdapter::GetPropAuthInfo(int32_t userID, uint64_t callerUID, std::string pkgName, + GetPropertyRequest requset, sptr& callback) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth GetPropAuthInfo is start!"); using namespace UserIDM; std::shared_ptr getInfoCallback = std::make_shared(callback, requset, callerUID, pkgName); - int32_t ret = UserIDMClient::GetInstance().GetAuthInfo(static_cast(requset.authType), - getInfoCallback); + int32_t ret = UserIDMClient::GetInstance().GetAuthInfo(userID, + static_cast(requset.authType), getInfoCallback); if (ret != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth GetPropAuthInfo ERROR!"); } @@ -135,7 +134,7 @@ int32_t UserAuthAdapter::SetProPropAuthInfo(OHOS::UserIAM::AuthResPool::AuthAttr } return ret; } -void UserAuthAdapter::GetPropAuthInfoCoauth(uint64_t callerUID, std::string pkgName, int32_t resultCode, +void UserAuthAdapter::GetPropAuthInfoCoauth(int32_t userID, uint64_t callerUID, std::string pkgName, int32_t resultCode, UserAuthToken authToken, GetPropertyRequest requset, sptr& callback) { @@ -144,15 +143,15 @@ void UserAuthAdapter::GetPropAuthInfoCoauth(uint64_t callerUID, std::string pkgN std::shared_ptr getInfoCallback = std::make_shared(callback, callerUID, pkgName, resultCode, authToken, requset); - int32_t ret = UserIDMClient::GetInstance().GetAuthInfo(static_cast(requset.authType), - getInfoCallback); + int32_t ret = UserIDMClient::GetInstance().GetAuthInfo(userID, + static_cast(requset.authType), getInfoCallback); if (ret != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth GetPropAuthInfoCoauth ERROR!"); } USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth GetPropAuthInfoCoauth is end!"); } -void UserAuthAdapter::CoauthSetPropAuthInfo(int32_t resultCode, uint64_t callerUID, std::string pkgName, +void UserAuthAdapter::CoauthSetPropAuthInfo(int32_t userID, int32_t resultCode, uint64_t callerUID, std::string pkgName, UserAuthToken authToken, SetPropertyRequest requset, sptr& callback) { @@ -161,49 +160,14 @@ void UserAuthAdapter::CoauthSetPropAuthInfo(int32_t resultCode, uint64_t callerU std::shared_ptr setPropCallback = std::make_shared(callback, callerUID, pkgName, resultCode, authToken, requset); - int32_t ret = UserIDMClient::GetInstance().GetAuthInfo(static_cast(requset.authType), - setPropCallback); + int32_t ret = UserIDMClient::GetInstance().GetAuthInfo(userID, + static_cast(requset.authType), setPropCallback); if (ret != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth CoauthSetPropAuthInfo ERROR!"); } USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth CoauthSetPropAuthInfo is end!"); } -int32_t UserAuthAdapter::GetUserID(int32_t &userID) -{ - USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth GetUserID is start!"); - - bool once = true; - int32_t ret = SUCCESS; - uint8_t buff[USERID_BUFF_SIZE]; - FILE* fp = fopen("/data/useriam/userId", "rb"); - if (fp == nullptr) { - USERAUTH_HILOGE(MODULE_SERVICE, "## fopen failed!"); - once = false; - return FAIL; - } - - if (once) { - ret = fread(buff, 1, USERID_BUFF_SIZE, fp); - if (ret > 0) { - USERAUTH_HILOGD(MODULE_SERVICE, "## reading success: %{public}s", buff); - } else { - USERAUTH_HILOGE(MODULE_SERVICE, "## reading failed: %{public}d", ret); - fclose(fp); - return FAIL; - } - } - userID = atoi((char*)buff); - USERAUTH_HILOGD(MODULE_SERVICE, "## test userId: %{public}d", userID); - - ret = fclose(fp); - if (ret != SUCCESS) { - USERAUTH_HILOGE(MODULE_SERVICE, "## fclose failed: %{public}d", ret); - } - - return SUCCESS; -} - int32_t UserAuthAdapter::GenerateSolution(AuthSolution param, std::vector &sessionIds) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth GenerateSolution is start!"); diff --git a/services/src/userauth_controller.cpp b/services/src/userauth_controller.cpp index 2beb1145f..8a28a8ea3 100644 --- a/services/src/userauth_controller.cpp +++ b/services/src/userauth_controller.cpp @@ -29,15 +29,11 @@ int32_t UserAuthController::SetExecutorProp(uint64_t callerUID, std::string pkgN { return UserAuthAdapter::GetInstance().SetExecutorProp(callerUID, pkgName, setPropertyrequest, callback); } -void UserAuthController::GetPropAuthInfo(std::string pkgName, uint64_t callerUID, +void UserAuthController::GetPropAuthInfo(int32_t userID, std::string pkgName, uint64_t callerUID, GetPropertyRequest getPropertyRequest, sptr& callback) { - UserAuthAdapter::GetInstance().GetPropAuthInfo(callerUID, pkgName, getPropertyRequest, callback); -} -int32_t UserAuthController::GetUserID(int32_t &userID) -{ - return UserAuthAdapter::GetInstance().GetUserID(userID); + UserAuthAdapter::GetInstance().GetPropAuthInfo(userID, callerUID, pkgName, getPropertyRequest, callback); } int32_t UserAuthController::GenerateSolution(AuthSolution param, std::vector &sessionIds) { diff --git a/services/src/userauth_excallback_impl.cpp b/services/src/userauth_excallback_impl.cpp index cb449e97e..b5e8cbf4d 100644 --- a/services/src/userauth_excallback_impl.cpp +++ b/services/src/userauth_excallback_impl.cpp @@ -118,6 +118,7 @@ UserAuthCallbackImplCoAuth::UserAuthCallbackImplCoAuth(const sptr &scheduleToken) { @@ -146,14 +147,14 @@ void UserAuthCallbackImplCoAuth::OnAcquireInfo(uint32_t acquire) return; } } -void UserAuthCallbackImplCoAuth::OnFinishHandleExtend(SetPropertyRequest setPropertyRequest, AuthResult authResult, - int32_t ret, UserAuthToken authToken) +void UserAuthCallbackImplCoAuth::OnFinishHandleExtend(int32_t userID, SetPropertyRequest setPropertyRequest, + AuthResult authResult, int32_t ret, UserAuthToken authToken) { if (authType_ == UserAuth::PIN) { USERAUTH_HILOGD(MODULE_SERVICE, "RequestAuthResult SUCCESS"); setPropertyRequest.authType = authType_; setPropertyRequest.key = SetPropertyType::THAW_TEMPLATE; - UserAuthAdapter::GetInstance().CoauthSetPropAuthInfo(ret, callerUid_, pkgName_, + UserAuthAdapter::GetInstance().CoauthSetPropAuthInfo(userID, ret, callerUid_, pkgName_, authToken, setPropertyRequest, callback_); } else { USERAUTH_HILOGD(MODULE_SERVICE, "RequestAuthResult SUCCESS NOT INFO"); @@ -194,21 +195,21 @@ void UserAuthCallbackImplCoAuth::OnFinishHandle(uint32_t resultCode, std::vector } if (resultCode != LOCKED) { if (ret == SUCCESS) { - OnFinishHandleExtend(setPropertyRequest, authResult, ret, authToken); + OnFinishHandleExtend(userID_, setPropertyRequest, authResult, ret, authToken); } else { USERAUTH_HILOGD(MODULE_SERVICE, "RequestAuthResult NOT SUCCESS"); getPropertyRequest.authType = authType_; getPropertyRequest.keys.push_back(UserAuth::REMAIN_TIMES); getPropertyRequest.keys.push_back(UserAuth::FREEZING_TIME); - UserAuthAdapter::GetInstance().GetPropAuthInfoCoauth(callerUid_, pkgName_, ret, + UserAuthAdapter::GetInstance().GetPropAuthInfoCoauth(userID_, callerUid_, pkgName_, ret, authToken, getPropertyRequest, callback_); } } else { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthCallbackImplCoAuth resultCode == LOCKED"); setPropertyRequest.authType = authType_; setPropertyRequest.key = SetPropertyType::FREEZE_TEMPLATE; - UserAuthAdapter::GetInstance().CoauthSetPropAuthInfo(ret, callerUid_, pkgName_, authToken, setPropertyRequest, - callback_); + UserAuthAdapter::GetInstance().CoauthSetPropAuthInfo(userID_, ret, callerUid_, pkgName_, authToken, + setPropertyRequest, callback_); } if (sessionIds.size() != 0) { for (auto const &item : sessionIds) { diff --git a/services/src/userauth_service.cpp b/services/src/userauth_service.cpp index c62701c68..205757fcd 100644 --- a/services/src/userauth_service.cpp +++ b/services/src/userauth_service.cpp @@ -17,6 +17,7 @@ #include #include "userauth_hilog_wrapper.h" #include "useriam_common.h" +#include "accesstoken_kit.h" #include "userauth_service.h" namespace OHOS { @@ -72,7 +73,7 @@ int32_t UserAuthService::GetAvailableStatus(const AuthType authType, const AuthT return result; } - ret = userauthController_.GetUserID(userID); + ret = this->GetCallingUserID(userID); if (ret != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthService GetAvailableStatus GetUserID is ERROR!"); return result; @@ -100,6 +101,14 @@ void UserAuthService::GetProperty(const GetPropertyRequest request, sptrGetCallingUserID(userID); + if (ret != SUCCESS) { + AuthResult extraInfo; + callback->onResult(ret, extraInfo); + return; + } sptr dr = new UserAuthServiceCallbackDeathRecipient(callback); if ((!callback->AsObject()->AddDeathRecipient(dr))) { @@ -109,7 +118,7 @@ void UserAuthService::GetProperty(const GetPropertyRequest request, sptrGetCallingUid(); callerName = std::to_string(callerID); - userauthController_.GetPropAuthInfo(callerName, callerID, request, callback); + userauthController_.GetPropAuthInfo(userID, callerName, callerID, request, callback); } void UserAuthService::SetProperty(const SetPropertyRequest request, sptr& callback) @@ -139,6 +148,28 @@ void UserAuthService::SetProperty(const SetPropertyRequest request, sptrGetFirstTokenID(); + if (tokenID == 0) { + tokenID = this->GetCallingTokenID(); + } + Security::AccessToken::ATokenTypeEnum callingType = Security::AccessToken::AccessTokenKit::GetTokenType(tokenID); + if (callingType != Security::AccessToken::TOKEN_HAP) { + USERAUTH_HILOGE(MODULE_SERVICE, "CallingType is not hap."); + return TYPE_NOT_SUPPORT; + } + Security::AccessToken::HapTokenInfo hapTokenInfo; + int result = Security::AccessToken::AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfo); + if (result != SUCCESS) { + USERAUTH_HILOGE(MODULE_SERVICE, "Get hap token info failed."); + return TYPE_NOT_SUPPORT; + } + userID = (int32_t)hapTokenInfo.userID; + USERAUTH_HILOGE(MODULE_SERVICE, "GetCallingUserID is %{public}d", userID); + return SUCCESS; +} + uint64_t UserAuthService::Auth(const uint64_t challenge, const AuthType authType, const AuthTurstLevel authTurstLevel, sptr& callback) @@ -162,8 +193,7 @@ uint64_t UserAuthService::Auth(const uint64_t challenge, const AuthType authType if (GetControllerData(callback, extraInfo, authTurstLevel, callerID, callerName, contextID) == FAIL) { return ret; } - - result = userauthController_.GetUserID(userID); + result = this->GetCallingUserID(userID); if (result != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthService Auth GetUserID is ERROR!"); callback->onResult(FAIL, extraInfo); @@ -186,6 +216,7 @@ uint64_t UserAuthService::Auth(const uint64_t challenge, const AuthType authType coAuthInfo.callerID = callerID; coAuthInfo.contextID = contextID; coAuthInfo.pkgName = callerName; + coAuthInfo.userID = userID; result = userauthController_.coAuth(coAuthInfo, callback); if (result != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthService Auth coAuth is ERROR!"); -- Gitee From 866b2f154116a41bc88aec003ed332b8c9d6e4b0 Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Thu, 10 Feb 2022 10:51:39 +0800 Subject: [PATCH 07/19] [user_auth]code update for review 1.printf llu changed to PRIu64 2.Judging whether the object is empty after new 3.code change for review Signed-off-by: yanfang.gu --- .../kitsimpl/src/iuserauth_api7_callback.cpp | 2 -- frameworks/kitsimpl/src/userauth.cpp | 18 ++++++++++- frameworks/kitsimpl/src/userauth_api7.cpp | 4 +++ .../kitsimpl/src/userauth_async_stub.cpp | 5 +-- frameworks/kitsimpl/src/userauth_proxy.cpp | 29 ++++++++--------- .../native/include/iuserauth_api7_callback.h | 2 -- services/src/userauth_adapter.cpp | 18 +++-------- services/src/userauth_excallback_impl.cpp | 13 ++++---- services/src/userauth_service.cpp | 11 +++---- test/unittest/src/userauth_test.cpp | 31 ++++++++++--------- 10 files changed, 73 insertions(+), 60 deletions(-) diff --git a/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp b/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp index fc3fa9777..d39f7b723 100644 --- a/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp +++ b/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp @@ -114,8 +114,6 @@ void IUserAuthAPI7Callback::onResult(const int32_t result, const UserAuth::AuthR } USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 onResult is end"); } -void IUserAuthAPI7Callback::onExecutorPropertyInfo(const UserAuth::ExecutorProperty result) {} -void IUserAuthAPI7Callback::onSetExecutorProperty(const int32_t result) {} } } } \ No newline at end of file diff --git a/frameworks/kitsimpl/src/userauth.cpp b/frameworks/kitsimpl/src/userauth.cpp index 796592ab0..3e5940df5 100644 --- a/frameworks/kitsimpl/src/userauth.cpp +++ b/frameworks/kitsimpl/src/userauth.cpp @@ -107,9 +107,13 @@ void UserAuth::GetProperty(const GetPropertyRequest request, std::shared_ptronGetProperty(result); - return ; + return; } sptr asyncStub = new UserAuthAsyncStub(callback); + if (asyncStub == nullptr) { + USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub failed, GetProperty IUserAuthCallback is nullptr"); + return; + } proxy_->GetProperty(request, asyncStub); } void UserAuth::SetProperty(const SetPropertyRequest request, std::shared_ptr callback) @@ -125,6 +129,10 @@ void UserAuth::SetProperty(const SetPropertyRequest request, std::shared_ptr asyncStub = new UserAuthAsyncStub(callback); + if (asyncStub == nullptr) { + USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub failed, SetProperty IUserAuthCallback is nullptr"); + return; + } proxy_->SetProperty(request, asyncStub); } uint64_t UserAuth::Auth(const uint64_t challenge, const AuthType authType, const AuthTurstLevel authTurstLevel, @@ -140,6 +148,10 @@ uint64_t UserAuth::Auth(const uint64_t challenge, const AuthType authType, const return E_RET_NOSERVER; } sptr asyncStub = new UserAuthAsyncStub(callback); + if (asyncStub == nullptr) { + USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub failed, Auth IUserAuthCallback is nullptr"); + return GENERAL_ERROR; + } uint64_t ret = proxy_->Auth(challenge, authType, authTurstLevel, asyncStub); return ret; } @@ -156,6 +168,10 @@ uint64_t UserAuth::AuthUser(const int32_t userId, const uint64_t challenge, cons return E_RET_NOSERVER; } sptr asyncStub = new UserAuthAsyncStub(callback); + if (asyncStub == nullptr) { + USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub failed, AuthUser IUserAuthCallback is nullptr"); + return GENERAL_ERROR; + } uint64_t ret = proxy_->AuthUser(userId, challenge, authType, authTurstLevel, asyncStub); return ret; } diff --git a/frameworks/kitsimpl/src/userauth_api7.cpp b/frameworks/kitsimpl/src/userauth_api7.cpp index cbab1aedf..89c44cd24 100644 --- a/frameworks/kitsimpl/src/userauth_api7.cpp +++ b/frameworks/kitsimpl/src/userauth_api7.cpp @@ -70,6 +70,10 @@ void UserAuthAPI7::Execute(std::string authtype, std::string trustLevel, std::sh } std::shared_ptr asyncStub = std::make_shared(callback); + if (asyncStub == nullptr) { + USERAUTH_API7_HILOGE(MODULE_API7, "UserAuthCallback failed, IUserAuthAPI7Callback is nullptr"); + return; + } contextID = UserAuth::UserAuth::GetInstance().Auth(CHALLENGE_INIT, exeAuthType, authTurstLevel, asyncStub); if (contextID != CONTEXTID_INIT) { UserAuthAPI7Datamgr::GetInstance().API7AddContextID(contextID); diff --git a/frameworks/kitsimpl/src/userauth_async_stub.cpp b/frameworks/kitsimpl/src/userauth_async_stub.cpp index 4a7ee0545..9274b64e3 100644 --- a/frameworks/kitsimpl/src/userauth_async_stub.cpp +++ b/frameworks/kitsimpl/src/userauth_async_stub.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include #include #include "userauth_hilog_wrapper.h" @@ -201,7 +202,7 @@ void UserAuthAsyncStub::onAcquireInfo(const int32_t module, const uint32_t acqui if (authCallback_ == nullptr) { USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAsyncStub onAcquireInfo callback is Null"); - return ; + return; } USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub module:%{public}d, acquireInfo:%{public}u", @@ -234,7 +235,7 @@ void UserAuthAsyncStub::onExecutorPropertyInfo(const ExecutorProperty result) } USERAUTH_HILOGD(MODULE_INNERKIT, - "userauthAsyncStub result:%{public}d, sub:%{public}llu, remain:%{public}u, freeze:%{public}u", + "userauthAsyncStub result:%{public}d, sub:%{public}" PRIu64 ", remain:%{public}u, freeze:%{public}u", result.result, result.authSubType, result.remainTimes, result.freezingTime); getPropCallback_->onGetProperty(result); } diff --git a/frameworks/kitsimpl/src/userauth_proxy.cpp b/frameworks/kitsimpl/src/userauth_proxy.cpp index 65c9093ac..f8e82f4a6 100644 --- a/frameworks/kitsimpl/src/userauth_proxy.cpp +++ b/frameworks/kitsimpl/src/userauth_proxy.cpp @@ -12,6 +12,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include #include #include #include "userauth_hilog_wrapper.h" @@ -44,7 +45,7 @@ int32_t UserAuthProxy::GetAvailableStatus(const AuthType authType, const AuthTur } bool ret = SendRequest(static_cast(IUserAuth::USER_AUTH_GET_AVAILABLE_STATUS), data, reply, option); if (!ret) { - USERAUTH_HILOGE(MODULE_INNERKIT, "userauth SendRequest is failed, error code: %d", ret); + USERAUTH_HILOGE(MODULE_INNERKIT, "userauth SendRequest is failed, error code: %{public}d", ret); return IPC_ERROR; } if (!reply.ReadInt32(result)) { @@ -63,7 +64,7 @@ void UserAuthProxy::GetProperty(const GetPropertyRequest request, sptr(request.authType))) { USERAUTH_HILOGE(MODULE_INNERKIT, "failed to WriteUint32(static_cast(request.authType))."); @@ -82,8 +83,8 @@ void UserAuthProxy::GetProperty(const GetPropertyRequest request, sptronExecutorPropertyInfo(result); - USERAUTH_HILOGE(MODULE_INNERKIT, "userauth SendRequest is failed, error code: %d", ret); - return ; + USERAUTH_HILOGE(MODULE_INNERKIT, "userauth SendRequest is failed, error code: %{public}d", ret); + return; } } void UserAuthProxy::SetProperty(const SetPropertyRequest request, sptr& callback) @@ -95,7 +96,7 @@ void UserAuthProxy::SetProperty(const SetPropertyRequest request, sptr(request.authType))) { USERAUTH_HILOGE(MODULE_INNERKIT, "failed to WriteUint32(static_cast(request.authType))."); @@ -117,8 +118,8 @@ void UserAuthProxy::SetProperty(const SetPropertyRequest request, sptronSetExecutorProperty(result); - USERAUTH_HILOGE(MODULE_INNERKIT, "userauth SendRequest is failed, error code: %d", ret); - return ; + USERAUTH_HILOGE(MODULE_INNERKIT, "userauth SendRequest is failed, error code: %{public}d", ret); + return; } } @@ -129,13 +130,13 @@ uint64_t UserAuthProxy::Auth(const uint64_t challenge, const AuthType authType, u_int64_t result = SUCCESS; MessageParcel data; MessageParcel reply; - MessageOption option; + MessageOption option(MessageOption::TF_ASYNC); if (!data.WriteInterfaceToken(UserAuthProxy::GetDescriptor())) { USERAUTH_HILOGE(MODULE_INNERKIT, "userauth write descriptor failed!"); return result; } - USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthProxy::Auth challenge = %{public}llu", challenge); + USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthProxy::Auth challenge = %{public}" PRIu64 "", challenge); if (!data.WriteUint64(challenge)) { USERAUTH_HILOGE(MODULE_INNERKIT, "failed to WriteUint64(challenge)."); return E_READ_PARCEL_ERROR; @@ -154,7 +155,7 @@ uint64_t UserAuthProxy::Auth(const uint64_t challenge, const AuthType authType, } bool ret = SendRequest(IUserAuth::USER_AUTH_AUTH, data, reply, option); if (!ret) { - USERAUTH_HILOGE(MODULE_INNERKIT, "userauth SendRequest is failed, error code: %d", ret); + USERAUTH_HILOGE(MODULE_INNERKIT, "userauth SendRequest is failed, error code: %{public}d", ret); return result; } if (!reply.ReadUint64(result)) { @@ -172,7 +173,7 @@ uint64_t UserAuthProxy::AuthUser(const int32_t userId, const uint64_t challenge, u_int64_t result = SUCCESS; MessageParcel data; MessageParcel reply; - MessageOption option; + MessageOption option(MessageOption::TF_ASYNC); if (!data.WriteInterfaceToken(UserAuthProxy::GetDescriptor())) { USERAUTH_HILOGE(MODULE_INNERKIT, "write descriptor failed!"); @@ -200,7 +201,7 @@ uint64_t UserAuthProxy::AuthUser(const int32_t userId, const uint64_t challenge, } bool ret = SendRequest(IUserAuth::USER_AUTH_AUTH_USER, data, reply, option); if (!ret) { - USERAUTH_HILOGE(MODULE_INNERKIT, "SendRequest is failed, error code: %d", ret); + USERAUTH_HILOGE(MODULE_INNERKIT, "SendRequest is failed, error code: %{public}d", ret); return result; } if (!reply.ReadUint64(result)) { @@ -229,7 +230,7 @@ int32_t UserAuthProxy::CancelAuth(const uint64_t contextId) } bool ret = SendRequest(IUserAuth::USER_AUTH_CANCEL_AUTH, data, reply, option); if (!ret) { - USERAUTH_HILOGE(MODULE_INNERKIT, "SendRequest is failed, error code: %d", ret); + USERAUTH_HILOGE(MODULE_INNERKIT, "SendRequest is failed, error code: %{public}d", ret); return IPC_ERROR; } if (!reply.ReadInt32(result)) { @@ -254,7 +255,7 @@ int32_t UserAuthProxy::GetVersion() bool ret = SendRequest(IUserAuth::USER_AUTH_GET_VERSION, data, reply, option); if (!ret) { - USERAUTH_HILOGE(MODULE_INNERKIT, "SendRequest is failed, error code: %d", ret); + USERAUTH_HILOGE(MODULE_INNERKIT, "SendRequest is failed, error code: %{public}d", ret); return IPC_ERROR; } if (!reply.ReadInt32(result)) { diff --git a/interfaces/innerkits/native/include/iuserauth_api7_callback.h b/interfaces/innerkits/native/include/iuserauth_api7_callback.h index 6bfecf375..2c5f1c4b4 100755 --- a/interfaces/innerkits/native/include/iuserauth_api7_callback.h +++ b/interfaces/innerkits/native/include/iuserauth_api7_callback.h @@ -32,8 +32,6 @@ public: void onAcquireInfo(const int32_t module, const uint32_t acquireInfo, const int32_t extraInfo) override; void onResult(const int32_t result, const UserAuth::AuthResult extraInfo) override; - void onExecutorPropertyInfo(const UserAuth::ExecutorProperty result) override; - void onSetExecutorProperty(const int32_t result) override; private: std::shared_ptr callback_ {nullptr}; }; diff --git a/services/src/userauth_adapter.cpp b/services/src/userauth_adapter.cpp index 5cacdaad2..6cb4aeef5 100644 --- a/services/src/userauth_adapter.cpp +++ b/services/src/userauth_adapter.cpp @@ -12,6 +12,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include #include "userauth_adapter.h" #include "userauth_hilog_wrapper.h" @@ -26,6 +27,7 @@ namespace OHOS { namespace UserIAM { namespace UserAuth { +const int USERAUTH_VERSION = 1235; UserAuthAdapter &UserAuthAdapter::GetInstance() { static UserAuthAdapter instance; @@ -122,9 +124,6 @@ int32_t UserAuthAdapter::SetProPropAuthInfo(OHOS::UserIAM::AuthResPool::AuthAttr setPropCallback->OnResult(ret, extraInfo); return ret; } - if (ret != SUCCESS) { - return ret; - } ret = authAttributes.SetUint64ArrayValue(AUTH_TEMPLATE_ID_LIST, templateIds); if (ret != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth SetUint64ArrayValue AUTH_TEMPLATE_ID_LIST ERROR!"); @@ -212,7 +211,7 @@ int32_t UserAuthAdapter::Cancel(uint64_t sessionId) int32_t UserAuthAdapter::GetVersion() { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth GetVersion is start!"); - int32_t version = 1235; + int32_t version = USERAUTH_VERSION; return version; } @@ -313,7 +312,7 @@ int32_t UserAuthAdapter::GetEachExecutorProp(GetPropertyRequest &requset, Execut return INVALID_PARAMETERS; } } - USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthAdapter::GetEachExecutorProp %{public}llu:%{public}u:%{public}u", + USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthAdapter::GetEachExecutorProp %{public}" PRIu64 ":%{public}u:%{public}u", result.authSubType, result.remainTimes, result.freezingTime); return ret; } @@ -371,15 +370,8 @@ int32_t UserAuthAdapter::coAuth(CoAuthInfo coAuthInfo, sptr& std::make_shared(callback, coAuthInfo, false); OHOS::UserIAM::CoAuth::AuthInfo authInfo; int32_t ret = authInfo.SetPkgName(coAuthInfo.pkgName); - if (ret != SUCCESS) { - USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth pAuthInfo_ SetPkgName ERROR!"); - return ret; - } ret = authInfo.SetCallerUid(coAuthInfo.callerID); - if (ret != SUCCESS) { - USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth pAuthInfo_ SetCallerUid ERROR!"); - return ret; - } + ret = UserAuthCallbackImplCoAuth::SaveCoauthCallback(coAuthInfo.contextID, coAuthCallback); if (ret != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth SaveCoauthCallback ERROR!"); diff --git a/services/src/userauth_excallback_impl.cpp b/services/src/userauth_excallback_impl.cpp index b5e8cbf4d..ebcf143a8 100644 --- a/services/src/userauth_excallback_impl.cpp +++ b/services/src/userauth_excallback_impl.cpp @@ -20,6 +20,7 @@ #include "userauth_async_proxy.h" #include "securec.h" +#include #include #include @@ -32,7 +33,7 @@ UserAuthCallbackImplSetProp::UserAuthCallbackImplSetProp(const sptr ATL4 || authTurstLevel < ATL1) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthService GetAvailableStatus AuthTurstLevel is NOT SUPPORT!"); return result; @@ -81,8 +82,8 @@ int32_t UserAuthService::GetAvailableStatus(const AuthType authType, const AuthT ret = userauthController_.GetAuthTrustLevel(userID, authType, authTurstLevelFromSys); if (ret == SUCCESS) { - USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthService iAuthTurstLevel_:%{public}d", authTurstLevelFromSys); - USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthService authTurstLevel:%{public}d", authTurstLevel); + USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthService iAuthTurstLevel_:%{public}d", authTurstLevelFromSys); + USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthService authTurstLevel:%{public}d", authTurstLevel); if (authTurstLevelFromSys < authTurstLevel) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthService authTurstLevel is ERROR!"); return result; @@ -144,7 +145,7 @@ void UserAuthService::SetProperty(const SetPropertyRequest request, sptronSetExecutorProperty(ret); - return ; + return; } } @@ -284,7 +285,6 @@ int32_t UserAuthService::GetControllerData(sptr& callback, Au int result = SUCCESS; if (callback == nullptr) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthService AuthUser IUserAuthCallback is NULL!"); - callback->onResult(INVALID_PARAMETERS, extraInfo); ret = FAIL; return ret; } @@ -333,7 +333,6 @@ int32_t UserAuthService::CancelAuth(const uint64_t contextId) result = userauthController_.Cancel(item); if (result != SUCCESS) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthService CancelAuth Cancel is ERROR!"); - return result; } } userauthController_.DeleteContextID(contextId); diff --git a/test/unittest/src/userauth_test.cpp b/test/unittest/src/userauth_test.cpp index 5e98b7ebb..6f41f3e08 100644 --- a/test/unittest/src/userauth_test.cpp +++ b/test/unittest/src/userauth_test.cpp @@ -94,21 +94,21 @@ void TestSetPropCallback::onSetProperty(const int32_t result) std::cout << "onSetProperty callback" << std::endl; } -class TestUserAuthAPI7Callback : public UserAuthAPI7Callback { +class TestUserAuthAPI7Callback : public API7UserAuth::UserAuthAPI7Callback { public: TestUserAuthAPI7Callback() = default; virtual ~TestUserAuthAPI7Callback() = default; void API7OnResult(const int32_t result) override; - void TipCallback(const Tip result) override; -} + void TipCallback(const API7UserAuth::Tip result) override; +}; void TestUserAuthAPI7Callback::API7OnResult(const int32_t result) { std::cout << "API7OnResult callback" << std::endl; } -void TestUserAuthAPI7Callback::TipCallback(const Tip result) +void TestUserAuthAPI7Callback::TipCallback(const API7UserAuth::Tip result) { std::cout << "TipCallback callback" << std::endl; } @@ -126,7 +126,7 @@ HWTEST_F(UseriamUtTest, UseriamUtTest_002, TestSize.Level1) request.authType = FACE; request.keys.push_back(1); request.keys.push_back(3); - std::shared_ptr callback = std::make_shared(); + std::shared_ptr callback = std::make_shared(); UserAuth::GetInstance().GetProperty(request, callback); } @@ -137,7 +137,7 @@ HWTEST_F(UseriamUtTest, UseriamUtTest_003, TestSize.Level1) request.key = INIT_ALGORITHM; uint8_t i = 123; request.setInfo.push_back(i); - std::shared_ptr callback = std::make_shared(); + std::shared_ptr callback = std::make_shared(); UserAuth::GetInstance().SetProperty(request, callback); } @@ -168,30 +168,33 @@ HWTEST_F(UseriamUtTest, UseriamUtTest_006, TestSize.Level1) HWTEST_F(UseriamUtTest, UseriamUtTest_007, TestSize.Level1) { - std::shared_ptr callback = std::make_shared(); - UserAuthAPI7::GetAuthenticator().Execute("FACE_ONLY", "S1", callback); + std::shared_ptr callback = + std::make_shared(); + API7UserAuth::UserAuthAPI7::GetAuthenticator().Execute("FACE_ONLY", "S1", callback); } HWTEST_F(UseriamUtTest, UseriamUtTest_008, TestSize.Level1) { - EXPECT_EQ(0, UserAuthAPI7::GetAuthenticator().Cancel()); + EXPECT_EQ(0, API7UserAuth::UserAuthAPI7::GetAuthenticator().Cancel()); } HWTEST_F(UseriamUtTest, UseriamUtTest_009, TestSize.Level1) { - EXPECT_EQ(0, UserAuthAPI7::GetAuthenticator().CheckAvailability("FACE_ONLY", "S1")); + EXPECT_EQ(0, API7UserAuth::UserAuthAPI7::GetAuthenticator().CheckAvailability("FACE_ONLY", "S1")); } HWTEST_F(UseriamUtTest, UseriamUtTest_010, TestSize.Level1) { - std::shared_ptr callback = std::make_shared(); - UserAuthAPI7::GetAuthenticator().On("tip", callback); + std::shared_ptr callback = + std::make_shared(); + API7UserAuth::UserAuthAPI7::GetAuthenticator().On("tip", callback); } HWTEST_F(UseriamUtTest, UseriamUtTest_011, TestSize.Level1) { - std::shared_ptr callback = std::make_shared(); - UserAuthAPI7::GetAuthenticator().Off("tip", callback); + std::shared_ptr callback = + std::make_shared(); + API7UserAuth::UserAuthAPI7::GetAuthenticator().Off("tip", callback); } } } -- Gitee From 8ee8bb30e8afd11f96403be40d41f3f21327cc30 Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Thu, 10 Feb 2022 15:05:12 +0800 Subject: [PATCH 08/19] [user_auth]code update for review-2 1.code change for review Signed-off-by: yanfang.gu --- frameworks/kitsimpl/src/userauth.cpp | 18 ++++++++++-------- frameworks/kitsimpl/src/userauth_proxy.cpp | 4 ++-- services/src/userauth_service.cpp | 4 ++-- test/unittest/src/userauth_test.cpp | 4 ++-- 4 files changed, 16 insertions(+), 14 deletions(-) diff --git a/frameworks/kitsimpl/src/userauth.cpp b/frameworks/kitsimpl/src/userauth.cpp index 3e5940df5..388caf35a 100644 --- a/frameworks/kitsimpl/src/userauth.cpp +++ b/frameworks/kitsimpl/src/userauth.cpp @@ -12,6 +12,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include + #include #include #include @@ -109,8 +111,8 @@ void UserAuth::GetProperty(const GetPropertyRequest request, std::shared_ptronGetProperty(result); return; } - sptr asyncStub = new UserAuthAsyncStub(callback); - if (asyncStub == nullptr) { + sptr asyncStub = new (std::nothrow) UserAuthAsyncStub(callback); + if (asyncStub == nullptr) { USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub failed, GetProperty IUserAuthCallback is nullptr"); return; } @@ -128,8 +130,8 @@ void UserAuth::SetProperty(const SetPropertyRequest request, std::shared_ptronSetProperty(E_RET_NOSERVER); return ; } - sptr asyncStub = new UserAuthAsyncStub(callback); - if (asyncStub == nullptr) { + sptr asyncStub = new (std::nothrow) UserAuthAsyncStub(callback); + if (asyncStub == nullptr) { USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub failed, SetProperty IUserAuthCallback is nullptr"); return; } @@ -147,8 +149,8 @@ uint64_t UserAuth::Auth(const uint64_t challenge, const AuthType authType, const if (proxy == nullptr) { return E_RET_NOSERVER; } - sptr asyncStub = new UserAuthAsyncStub(callback); - if (asyncStub == nullptr) { + sptr asyncStub = new (std::nothrow) UserAuthAsyncStub(callback); + if (asyncStub == nullptr) { USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub failed, Auth IUserAuthCallback is nullptr"); return GENERAL_ERROR; } @@ -167,8 +169,8 @@ uint64_t UserAuth::AuthUser(const int32_t userId, const uint64_t challenge, cons if (proxy == nullptr) { return E_RET_NOSERVER; } - sptr asyncStub = new UserAuthAsyncStub(callback); - if (asyncStub == nullptr) { + sptr asyncStub = new (std::nothrow) UserAuthAsyncStub(callback); + if (asyncStub == nullptr) { USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub failed, AuthUser IUserAuthCallback is nullptr"); return GENERAL_ERROR; } diff --git a/frameworks/kitsimpl/src/userauth_proxy.cpp b/frameworks/kitsimpl/src/userauth_proxy.cpp index f8e82f4a6..6cab23523 100644 --- a/frameworks/kitsimpl/src/userauth_proxy.cpp +++ b/frameworks/kitsimpl/src/userauth_proxy.cpp @@ -130,7 +130,7 @@ uint64_t UserAuthProxy::Auth(const uint64_t challenge, const AuthType authType, u_int64_t result = SUCCESS; MessageParcel data; MessageParcel reply; - MessageOption option(MessageOption::TF_ASYNC); + MessageOption option(MessageOption::TF_SYNC); if (!data.WriteInterfaceToken(UserAuthProxy::GetDescriptor())) { USERAUTH_HILOGE(MODULE_INNERKIT, "userauth write descriptor failed!"); @@ -173,7 +173,7 @@ uint64_t UserAuthProxy::AuthUser(const int32_t userId, const uint64_t challenge, u_int64_t result = SUCCESS; MessageParcel data; MessageParcel reply; - MessageOption option(MessageOption::TF_ASYNC); + MessageOption option(MessageOption::TF_SYNC); if (!data.WriteInterfaceToken(UserAuthProxy::GetDescriptor())) { USERAUTH_HILOGE(MODULE_INNERKIT, "write descriptor failed!"); diff --git a/services/src/userauth_service.cpp b/services/src/userauth_service.cpp index 45c2236ee..b220724e6 100644 --- a/services/src/userauth_service.cpp +++ b/services/src/userauth_service.cpp @@ -82,8 +82,8 @@ int32_t UserAuthService::GetAvailableStatus(const AuthType authType, const AuthT ret = userauthController_.GetAuthTrustLevel(userID, authType, authTurstLevelFromSys); if (ret == SUCCESS) { - USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthService iAuthTurstLevel_:%{public}d", authTurstLevelFromSys); - USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthService authTurstLevel:%{public}d", authTurstLevel); + USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthService iAuthTurstLevel_:%{public}u", authTurstLevelFromSys); + USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthService authTurstLevel:%{public}u", authTurstLevel); if (authTurstLevelFromSys < authTurstLevel) { USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthService authTurstLevel is ERROR!"); return result; diff --git a/test/unittest/src/userauth_test.cpp b/test/unittest/src/userauth_test.cpp index 6f41f3e08..127f97cea 100644 --- a/test/unittest/src/userauth_test.cpp +++ b/test/unittest/src/userauth_test.cpp @@ -126,7 +126,7 @@ HWTEST_F(UseriamUtTest, UseriamUtTest_002, TestSize.Level1) request.authType = FACE; request.keys.push_back(1); request.keys.push_back(3); - std::shared_ptr callback = std::make_shared(); + std::shared_ptr callback = std::make_shared(); UserAuth::GetInstance().GetProperty(request, callback); } @@ -137,7 +137,7 @@ HWTEST_F(UseriamUtTest, UseriamUtTest_003, TestSize.Level1) request.key = INIT_ALGORITHM; uint8_t i = 123; request.setInfo.push_back(i); - std::shared_ptr callback = std::make_shared(); + std::shared_ptr callback = std::make_shared(); UserAuth::GetInstance().SetProperty(request, callback); } -- Gitee From 3c540ec3f5e663e38282eb78d5bada273d597dba Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Thu, 10 Feb 2022 15:48:56 +0800 Subject: [PATCH 09/19] [user_auth]code update for review-3 Signed-off-by: yanfang.gu --- services/src/userauth_adapter.cpp | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/services/src/userauth_adapter.cpp b/services/src/userauth_adapter.cpp index 6cb4aeef5..280f3a95b 100644 --- a/services/src/userauth_adapter.cpp +++ b/services/src/userauth_adapter.cpp @@ -364,13 +364,21 @@ int32_t UserAuthAdapter::SetExecutorProp(uint64_t callerUID, std::string pkgName int32_t UserAuthAdapter::coAuth(CoAuthInfo coAuthInfo, sptr& callback) { - USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth coAuthHandle is start!"); + USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth coAuth is start!"); std::shared_ptr coAuthCallback = std::make_shared(callback, coAuthInfo, false); OHOS::UserIAM::CoAuth::AuthInfo authInfo; int32_t ret = authInfo.SetPkgName(coAuthInfo.pkgName); + if (ret != SUCCESS) { + USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth authInfo SetPkgName ERROR!"); + return ret; + } ret = authInfo.SetCallerUid(coAuthInfo.callerID); + if (ret != SUCCESS) { + USERAUTH_HILOGE(MODULE_SERVICE, "UserAuth authInfo SetCallerUid ERROR!"); + return ret; + } ret = UserAuthCallbackImplCoAuth::SaveCoauthCallback(coAuthInfo.contextID, coAuthCallback); if (ret != SUCCESS) { -- Gitee From bc86833330bc346b28926100718ad969133bd8fd Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Thu, 10 Feb 2022 16:12:38 +0800 Subject: [PATCH 10/19] [user_auth]code update for fix log Signed-off-by: yanfang.gu --- services/src/userauth_excallback_impl.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/services/src/userauth_excallback_impl.cpp b/services/src/userauth_excallback_impl.cpp index ebcf143a8..d15f513ee 100644 --- a/services/src/userauth_excallback_impl.cpp +++ b/services/src/userauth_excallback_impl.cpp @@ -176,7 +176,7 @@ void UserAuthCallbackImplCoAuth::OnFinishHandle(uint32_t resultCode, std::vector GetPropertyRequest getPropertyRequest; AuthResult authResult; std::lock_guard lock(mutex_); - USERAUTH_HILOGD(MODULE_SERVICE, "OnFinishHandle scheduleTokensize:%{public}d, resultCode:%{public}d", + USERAUTH_HILOGD(MODULE_SERVICE, "OnFinishHandle scheduleTokensize:%{public}d, resultCode:%{public}u", scheduleToken.size(), resultCode); callbackNowCount_++; if (isResultDoneFlag_) { @@ -259,7 +259,7 @@ int32_t UserAuthCallbackImplCoAuth::DeleteCoauthCallback(uint64_t contextId) if (iter != saveCoauthCallback_.end()) { saveCoauthCallback_.erase(iter); resultCode = SUCCESS; - USERAUTH_HILOGD(MODULE_SERVICE, "contextId XXXX%{public}04" PRIu64 " is deleted", contextId); + USERAUTH_HILOGD(MODULE_SERVICE, "contextId XXXX%{public}04" PRIx64 " is deleted", contextId); } else { resultCode = FAIL; USERAUTH_HILOGE(MODULE_SERVICE, "contextId is not found and do not delete callback"); -- Gitee From 6d7bcecde08fd94d02bf314f0dd0a220ea12262c Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Fri, 11 Feb 2022 10:08:36 +0800 Subject: [PATCH 11/19] [user_auth]code update for napi 1.add napi code for api7 Signed-off-by: yanfang.gu --- .../innerkits/napi/include/auth_common.h | 283 ++-- .../innerkits/napi/include/auth_object.h | 108 +- .../innerkits/napi/include/authapi_callback.h | 187 +-- .../innerkits/napi/include/user_auth_helper.h | 317 +++-- .../innerkits/napi/include/user_auth_impl.h | 154 +- .../innerkits/napi/src/authapi_callback.cpp | 1155 ++++++++------- .../innerkits/napi/src/result_convert.cpp | 450 +++--- .../innerkits/napi/src/user_auth_helper.cpp | 581 +++++--- .../innerkits/napi/src/user_auth_impl.cpp | 1255 ++++++++++------- .../napi/include/user_auth_helper_north.h | 1 + 10 files changed, 2571 insertions(+), 1920 deletions(-) diff --git a/interfaces/innerkits/napi/include/auth_common.h b/interfaces/innerkits/napi/include/auth_common.h index dcecddd60..7586cdad7 100755 --- a/interfaces/innerkits/napi/include/auth_common.h +++ b/interfaces/innerkits/napi/include/auth_common.h @@ -1,128 +1,155 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef OHOS_USERAUTH_COMMON_H -#define OHOS_USERAUTH_COMMON_H - -#include - -#include "napi/native_api.h" -#include "napi/native_common.h" - -namespace OHOS { -namespace UserIAM { -namespace UserAuth { -#define ARGS_MAX_COUNT 10 -#define ARGS_ASYNC_COUNT 1 -#define GET_VALUE_ERROR (-1) -#define NAPI_GET_STRING_SIZE 128 - -#define ARGS_ONE 1 -#define ARGS_TWO 2 -#define ARGS_THREE 3 -#define ARGS_FOUR 4 -#define ARGS_FIVE 5 -#define ARGS_SIX 6 -#define ARGS_SEVEN 7 -#define ARGS_EIGHT 8 -#define ARGS_NINE 9 -#define ARGS_TEN 10 - -#define PARAM0 0 -#define PARAM1 1 -#define PARAM2 2 -#define PARAM3 3 -#define PARAM4 4 -#define PARAM5 5 -#define PARAM6 6 -#define PARAM7 7 -#define PARAM8 8 -#define PARAM9 9 -#define PARAM10 10 - -struct CallBackInfo { - napi_env env; - napi_ref callBack = 0; - napi_deferred deferred; -}; - -struct GetPropertyInfo { - GetPropertyInfo() : result(nullptr) {}; - CallBackInfo callBackInfo; - napi_value result; - int32_t authType; - std::vector keys; - int32_t getResult; - uint64_t authSubType; - uint32_t remainTimes; - uint32_t freezingTime; -}; - -struct SetPropertyInfo { - SetPropertyInfo() : asyncWork(nullptr), result(nullptr) {}; - CallBackInfo callBackInfo; - napi_async_work asyncWork; - napi_value result; - int32_t authType; - int32_t key; - std::vector setInfo; - int32_t setResult; -}; - -struct AuthInfo { - AuthInfo() : asyncWork(nullptr) {}; - CallBackInfo callBackInfo; - napi_callback_info info; - napi_async_work asyncWork; - napi_value jsFunction; - napi_value onResultCallBack; - napi_value onAcquireInfoCallBack; - napi_ref onResult; - napi_ref onAcquireInfo; - napi_value onResultData[ARGS_TWO]; - napi_value onAcquireInfoData[ARGS_THREE]; - uint64_t challenge; - int32_t authType; - int32_t authTrustLevel; - int32_t result; - std::vector token; - uint32_t remainTimes; - uint32_t freezingTime; -}; - -struct AuthUserInfo { - AuthUserInfo() : asyncWork(nullptr) {}; - CallBackInfo callBackInfo; - napi_callback_info info; - napi_async_work asyncWork; - napi_value jsFunction; - napi_ref onResult; - napi_ref onAcquireInfo; - napi_value onResultCallBack; - napi_value onAcquireInfoCallBack; - napi_value onResultData[ARGS_TWO]; - napi_value onAcquireInfoData[ARGS_THREE]; - int32_t userId; - uint64_t challenge; - int32_t authType; - int32_t authTrustLevel; - int32_t result; - std::vector token; - uint32_t remainTimes; - uint32_t freezingTime; -}; -} // namespace UserAuth -} // namespace UserIAM -} // namespace OHOS -#endif /* OHOS_USERAUTH_COMMON_H */ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef OHOS_USERAUTH_COMMON_H +#define OHOS_USERAUTH_COMMON_H + +#include +#include + +#include "napi/native_api.h" +#include "napi/native_common.h" +#include "napi/native_node_api.h" + +namespace OHOS { +namespace UserIAM { +namespace UserAuth { +#define RESULTVAR 0 +#define ARGS_MAX_COUNT 10 +#define ARGS_ASYNC_COUNT 1 +#define GET_VALUE_ERROR (-1) +#define NAPI_GET_STRING_SIZE 128 + +#define ARGS_ONE 1 +#define ARGS_TWO 2 +#define ARGS_THREE 3 +#define ARGS_FOUR 4 +#define ARGS_FIVE 5 +#define ARGS_SIX 6 +#define ARGS_SEVEN 7 +#define ARGS_EIGHT 8 +#define ARGS_NINE 9 +#define ARGS_TEN 10 + +#define PARAM0 0 +#define PARAM1 1 +#define PARAM2 2 +#define PARAM3 3 +#define PARAM4 4 +#define PARAM5 5 +#define PARAM6 6 +#define PARAM7 7 +#define PARAM8 8 +#define PARAM9 9 +#define PARAM10 10 + +struct CallBackInfo { + napi_env env; + napi_ref callBack = 0; + napi_deferred deferred; +}; + +struct GetPropertyInfo { + GetPropertyInfo() : result(nullptr) {}; + CallBackInfo callBackInfo; + napi_value result; + int32_t authType; + std::vector keys; + int32_t getResult; + uint64_t authSubType; + uint32_t remainTimes; + uint32_t freezingTime; +}; + +struct SetPropertyInfo { + SetPropertyInfo() : asyncWork(nullptr), result(nullptr) {}; + CallBackInfo callBackInfo; + napi_async_work asyncWork; + napi_value result; + int32_t authType; + uint32_t key; + std::vector setInfo; + int32_t setResult; +}; + +struct AuthInfo { + AuthInfo() : asyncWork(nullptr) {}; + CallBackInfo callBackInfo; + napi_callback_info info; + napi_async_work asyncWork; + napi_value jsFunction; + napi_value onResultCallBack; + napi_value onAcquireInfoCallBack; + napi_ref onResult; + napi_ref onAcquireInfo; + napi_value onResultData[ARGS_TWO]; + napi_value onAcquireInfoData[ARGS_THREE]; + uint64_t challenge; + int32_t authType; + int32_t authTrustLevel; + int32_t result; + std::vector token; + uint32_t remainTimes; + uint32_t freezingTime; +}; + +struct AuthUserInfo { + AuthUserInfo() : asyncWork(nullptr) {}; + CallBackInfo callBackInfo; + napi_callback_info info; + napi_async_work asyncWork; + napi_value jsFunction; + napi_ref onResult; + napi_ref onAcquireInfo; + napi_value onResultCallBack; + napi_value onAcquireInfoCallBack; + napi_value onResultData[ARGS_TWO]; + napi_value onAcquireInfoData[ARGS_THREE]; + int32_t userId; + uint64_t challenge; + int32_t authType; + int32_t authTrustLevel; + int32_t result; + std::vector token; + uint32_t remainTimes; + uint32_t freezingTime; +}; +struct ExecuteInfo { + ExecuteInfo() : asyncWork(nullptr){}; + napi_env env; + std::string type; + std::string level; + napi_async_work asyncWork; + napi_ref callbackRef; + napi_deferred deferred; + napi_value promise; + napi_value result; +}; + +struct CheckAvailabilityInfo { + napi_env env; + std::string type; + std::string level; +}; + +struct FunctionOnAndOffInfo { + napi_env env; + std::string tip; + napi_ref callbackRef; + napi_value param[PARAM1] = {0}; +}; +} // namespace UserAuth +} // namespace UserIAM +} // namespace OHOS +#endif /* OHOS_USERAUTH_COMMON_H */ diff --git a/interfaces/innerkits/napi/include/auth_object.h b/interfaces/innerkits/napi/include/auth_object.h index c1fbf65c9..985c80b5d 100755 --- a/interfaces/innerkits/napi/include/auth_object.h +++ b/interfaces/innerkits/napi/include/auth_object.h @@ -1,54 +1,54 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef AUTH_OBJECT_H -#define AUTH_OBJECT_H - -#include - -namespace OHOS { -namespace UserIAM { -namespace UserAuth { -class Napi_ExecutorProperty { -public: - int32_t result_ = 0; - uint64_t authSubType_ = 0; - uint32_t remainTimes_ = 0; - uint32_t freezingTime_ = 0; -}; - -class Napi_SetPropertyRequest { -public: - int32_t authType_ = 0; - int32_t key_ = 0; - std::vector setInfo_; -}; - -class Napi_GetPropertyRequest { -public: - int32_t authType_ = 0; - std::vector keys_; -}; - -class Napi_AuthResult { -public: - std::vector token_; - uint32_t remainTimes_; - uint32_t freezingTime_; -}; -} // namespace UserAuth -} // namespace UserIAM -} // namespace OHOS -#endif // AUTH_OBJECT_H +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUTH_OBJECT_H +#define AUTH_OBJECT_H + +#include + +namespace OHOS { +namespace UserIAM { +namespace UserAuth { +class Napi_ExecutorProperty { +public: + int32_t result_ = 0; + uint64_t authSubType_ = 0; + uint32_t remainTimes_ = 0; + uint32_t freezingTime_ = 0; +}; + +class Napi_SetPropertyRequest { +public: + int32_t authType_ = 0; + uint32_t key_ = 0; + std::vector setInfo_; +}; + +class Napi_GetPropertyRequest { +public: + int32_t authType_ = 0; + std::vector keys_; +}; + +class Napi_AuthResult { +public: + std::vector token_; + uint32_t remainTimes_; + uint32_t freezingTime_; +}; +} // namespace UserAuth +} // namespace UserIAM +} // namespace OHOS +#endif // AUTH_OBJECT_H diff --git a/interfaces/innerkits/napi/include/authapi_callback.h b/interfaces/innerkits/napi/include/authapi_callback.h index d1b5713cd..03a7a531d 100755 --- a/interfaces/innerkits/napi/include/authapi_callback.h +++ b/interfaces/innerkits/napi/include/authapi_callback.h @@ -1,84 +1,103 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef AUTHAPI_CALLBACK_H -#define AUTHAPI_CALLBACK_H - -#include "napi/native_api.h" -#include "napi/native_common.h" - -#include "userauth_callback.h" -#include "userauth_info.h" - -#include "auth_common.h" - -namespace OHOS { -namespace UserIAM { -namespace UserAuth { -typedef struct AcquireInfoInner { - napi_env env; - napi_ref onAcquireInfo; - napi_value jsFunction; - int32_t module; - uint32_t acquireInfo; - int32_t extraInfo; -} AcquireInfoInner; -class AuthApiCallback : public UserAuthCallback { -public: - AuthApiCallback(AuthInfo *authInfo); - AuthApiCallback(AuthUserInfo *userInfo); - 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; - - static napi_value BuildOnResult( - napi_env env, uint32_t remainTimes, uint32_t freezingTime, std::vector token); - static napi_value Uint8ArrayToNapi(napi_env env, std::vector value); - -private: - void OnAuthAcquireInfo(AcquireInfoInner *acquireInfoInner); - void OnUserAuthResult(const int32_t result, const AuthResult extraInfo); - void OnAuthResult(const int32_t result, const AuthResult extraInfo); - - AuthInfo *authInfo_; - AuthUserInfo *userInfo_; -}; - -class GetPropApiCallback : public GetPropCallback { -public: - GetPropApiCallback(GetPropertyInfo *getPropertyInfo); - virtual ~GetPropApiCallback(); - void onGetProperty(const ExecutorProperty result) override; - - static napi_value BuildExecutorProperty( - napi_env env, int32_t result, uint32_t remainTimes, uint32_t freezingTime, uint64_t authSubType); - -private: - GetPropertyInfo *getPropertyInfo_; -}; - -class SetPropApiCallback : public SetPropCallback { -public: - SetPropApiCallback(SetPropertyInfo *setPropertyInfo); - virtual ~SetPropApiCallback(); - void onSetProperty(const int32_t result) override; - -private: - SetPropertyInfo *setPropertyInfo_; -}; -} // namespace UserAuth -} // namespace UserIAM -} // namespace OHOS -#endif // AUTHAPI_CALLBACK_H +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUTHAPI_CALLBACK_H +#define AUTHAPI_CALLBACK_H + +#include +#include "napi/native_api.h" +#include "napi/native_common.h" + +#include "userauth_callback.h" +#include "userauth_info.h" + +#include "userauth_api7_info.h" +#include "userauth_api7_callback.h" +#include "auth_common.h" + +namespace OHOS { +namespace UserIAM { +namespace UserAuth { +typedef struct AcquireInfoInner { + napi_env env; + napi_ref onAcquireInfo; + napi_value jsFunction; + int32_t module; + uint32_t acquireInfo; + int32_t extraInfo; +} AcquireInfoInner; +class AuthApiCallback : public UserAuthCallback { +public: + AuthApiCallback(AuthInfo *authInfo); + AuthApiCallback(AuthUserInfo *userInfo); + 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; + + static napi_value BuildOnResult( + napi_env env, uint32_t remainTimes, uint32_t freezingTime, std::vector token); + static napi_value Uint8ArrayToNapi(napi_env env, std::vector value); + +private: + void OnAuthAcquireInfo(AcquireInfoInner *acquireInfoInner); + void OnUserAuthResult(const int32_t result, const AuthResult extraInfo); + void OnAuthResult(const int32_t result, const AuthResult extraInfo); + + AuthInfo *authInfo_; + AuthUserInfo *userInfo_; +}; + +class GetPropApiCallback : public GetPropCallback { +public: + GetPropApiCallback(GetPropertyInfo *getPropertyInfo); + virtual ~GetPropApiCallback(); + void onGetProperty(const ExecutorProperty result) override; + + static napi_value BuildExecutorProperty( + napi_env env, int32_t result, uint32_t remainTimes, uint32_t freezingTime, uint64_t authSubType); + +private: + GetPropertyInfo *getPropertyInfo_; +}; + +class SetPropApiCallback : public SetPropCallback { +public: + SetPropApiCallback(SetPropertyInfo *setPropertyInfo); + virtual ~SetPropApiCallback(); + void onSetProperty(const int32_t result) override; + +private: + SetPropertyInfo *setPropertyInfo_; +}; + +class API7callback : public API7UserAuth::UserAuthAPI7Callback { +public: + explicit API7callback(ExecuteInfo* executeInfo); + explicit API7callback(FunctionOnAndOffInfo* functionOnAndOffInfo); + virtual ~API7callback() = default; + ExecuteInfo* executeInfo_; + FunctionOnAndOffInfo* functionOnAndOffInfo_; + void API7OnResult(const int32_t result) override; + void TipCallback(const API7UserAuth::Tip result) override; +private: + napi_value ResultTips(napi_env env, const API7UserAuth::Tip result); + void API7OnResultWrap(uv_loop_s *loop, uv_work_t *work); + void TipCallbackWrap(uv_loop_s *loop, uv_work_t *work); + std::mutex mutex_; +}; +} // namespace UserAuth +} // namespace UserIAM +} // namespace OHOS +#endif // AUTHAPI_CALLBACK_H diff --git a/interfaces/innerkits/napi/include/user_auth_helper.h b/interfaces/innerkits/napi/include/user_auth_helper.h index a75856cbf..6d2efcf36 100755 --- a/interfaces/innerkits/napi/include/user_auth_helper.h +++ b/interfaces/innerkits/napi/include/user_auth_helper.h @@ -1,124 +1,193 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef FACERECOGNITION_PIN_AUTH_HELPER_H -#define FACERECOGNITION_PIN_AUTH_HELPER_H - -#include "napi/native_api.h" -#include "napi/native_common.h" - -namespace OHOS { -namespace UserIAM { -namespace UserAuth { -/** - * @brief Napi initialization - * - * @param env - * @param exports - */ -void Init(napi_env env, napi_value exports); - -/** - * @brief Get the Ctor object - * - * @param env - * @return napi_value UserAuth Instance - */ -napi_value GetCtor(napi_env env); -/** - * @brief Construction method - * - * @param env - * @param info - * @return napi_value UserAuth Instance - */ -napi_value Constructor(napi_env env, napi_callback_info info); - -/** - * @brief Instance passed to context - * - * @param env - * @param info - * @return napi_value Instance - */ -napi_value UserAuthServiceConstructor(napi_env env, napi_callback_info info); - -/** - * @brief Get the Version object - * - * @param env - * @param info - * @return napi_value Specific version number results - */ -napi_value GetVersion(napi_env env, napi_callback_info info); - -/** - * @brief Get the Availabe Status object - * - * @param env - * @param info - * @return napi_value Verify that the certification capability is available - */ -napi_value GetAvailabeStatus(napi_env env, napi_callback_info info); - -/** - * @brief Get the Property object - * - * @param env - * @param info - * @return napi_value It supports querying subclasses / remaining authentication times / freezing time - */ -napi_value GetProperty(napi_env env, napi_callback_info info); - -/** - * @brief Set the Property object - * - * @param env - * @param info - * @return napi_value Set properties: can be used to initialize algorithms - */ -napi_value SetProperty(napi_env env, napi_callback_info info); - -/** - * @brief user authentication - * - * @param env - * @param info - * @return napi_value Enter the challenge value, authentication method, trust level and callback, and return the result - * and acquireinfo through the callback - */ -napi_value Auth(napi_env env, napi_callback_info info); - -/** - * @brief user authentication - * - * @param env - * @param info - * @return napi_value Pass in the user ID, challenge value, authentication method, trust level and callback, and return - * the result acquireinfo through the callback - */ -napi_value AuthUser(napi_env env, napi_callback_info info); - -/** - * @brief Cancel authentication - * - * @param env - * @param info - * @return napi_value success or fail - */ -napi_value CancelAuth(napi_env env, napi_callback_info info); -} // namespace UserAuth -} // namespace UserIAM -} // namespace OHOS -#endif // FACERECOGNITION_PIN_AUTH_HELPER_H +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef FACERECOGNITION_PIN_AUTH_HELPER_H +#define FACERECOGNITION_PIN_AUTH_HELPER_H + +#include "napi/native_api.h" +#include "napi/native_common.h" +#include "napi/native_node_api.h" + +namespace OHOS { +namespace UserIAM { +namespace UserAuth { +/** + * @brief Napi initialization + * + * @param env + * @param exports + */ +void Init(napi_env env, napi_value exports); + +/** + * @brief Get the Ctor object + * + * @param env + * @return napi_value UserAuth Instance + */ +napi_value GetCtor(napi_env env); + +/** + * @brief Get the Ctor object + * + * @param env + * @return napi_value AuthenticatorImpl Instance + */ +napi_value GetCtor_API(napi_env env); + +/** + * @brief Construction method + * + * @param env + * @param info + * @return napi_value UserAuth Instance + */ +napi_value Constructor(napi_env env, napi_callback_info info); + +/** + * @brief Get the Ctor object + * + * @param env + * @return napi_value AuthenticatorImpl Instance + */ +napi_value GetAuthenticator(napi_env, napi_callback_info info); + +/** + * @brief Instance passed to context + * + * @param env + * @param info + * @return napi_value UserAuth Instance + */ +napi_value UserAuthServiceConstructor(napi_env env, napi_callback_info info); + +/** + * @brief Instance passed to context + * + * @param env + * @param info + * @return napi_value AuthenticatorImpl Instance + */ +napi_value AuthenticatorServiceConstructor(napi_env env, napi_callback_info info); + +/** + * @brief Get the Version object + * + * @param env + * @param info + * @return napi_value Specific version number results + */ +napi_value GetVersion(napi_env env, napi_callback_info info); + +/** + * @brief Get the Availabe Status object + * + * @param env + * @param info + * @return napi_value Verify that the certification capability is available + */ +napi_value GetAvailabeStatus(napi_env env, napi_callback_info info); + +/** + * @brief Get the Property object + * + * @param env + * @param info + * @return napi_value It supports querying subclasses / remaining authentication times / freezing time + */ +napi_value GetProperty(napi_env env, napi_callback_info info); + +/** + * @brief Set the Property object + * + * @param env + * @param info + * @return napi_value Set properties: can be used to initialize algorithms + */ +napi_value SetProperty(napi_env env, napi_callback_info info); + +/** + * @brief user authentication + * + * @param env + * @param info + * @return napi_value Enter the challenge value, authentication method, trust level and callback, and return the result + * and acquireinfo through the callback + */ +napi_value Auth(napi_env env, napi_callback_info info); + +/** + * @brief user authentication + * + * @param env + * @param info + * @return napi_value Pass in the user ID, challenge value, authentication method, trust level and callback, and return + * the result acquireinfo through the callback + */ +napi_value AuthUser(napi_env env, napi_callback_info info); + +/** + * @brief Cancel authentication + * + * @param env + * @param info + * @return napi_value success or fail + */ +napi_value CancelAuth(napi_env env, napi_callback_info info); + +/** + * @brief Perform user authentication + * + * @param env + * @return Returns the result of successful authentication + */ +napi_value Execute(napi_env, napi_callback_info info); + +/** + * @brief Cancel the current authentication process + * + * @param env + * @return Results of canceling the current authentication process + */ +napi_value Cancel(napi_env, napi_callback_info info); + +/** + * @brief Check whether the current equipment + * supports the corresponding authentication capability + * according to the specified authentication type and security level. + * + * @param env + * @return Returns whether the current device supports the corresponding authentication capability. + */ +napi_value CheckAvailability(napi_env, napi_callback_info info); + +/** + * @brief Subscribe to events of the specified type + * + * @param env + * @return nullptr + */ +napi_value On(napi_env, napi_callback_info info); + +/** + * @brief Unsubscribe from events of the specified type + * + * @param env + * @return nullptr + */ +napi_value Off(napi_env, napi_callback_info info); +} // namespace UserAuth +} // namespace UserIAM +} // namespace OHOS +#endif // FACERECOGNITION_PIN_AUTH_HELPER_H diff --git a/interfaces/innerkits/napi/include/user_auth_impl.h b/interfaces/innerkits/napi/include/user_auth_impl.h index 877dececd..7f3affb87 100755 --- a/interfaces/innerkits/napi/include/user_auth_impl.h +++ b/interfaces/innerkits/napi/include/user_auth_impl.h @@ -1,69 +1,85 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef FACERECOGNITION_USER_AUTH_H -#define FACERECOGNITION_USER_AUTH_H - -#include "napi/native_common.h" - -#include "auth_build.h" -#include "auth_common.h" - -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(); - ~UserAuthImpl(); - AuthBuild authBuild; - napi_value GetVersion(napi_env env, napi_callback_info info); - napi_value GetAvailabeStatus(napi_env env, napi_callback_info info); - 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 AuthUser(napi_env env, napi_callback_info info); - napi_value CancelAuth(napi_env env, napi_callback_info info); - -private: - 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, 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); - static void SetPropertyAsyncExecuteDone(napi_env env, napi_status status, void *data); - static void GetPropertyExecute(napi_env env, void *data); - static void GetPropertyPromiseExecuteDone(napi_env env, napi_status status, void *data); - static void GetPropertyAsyncExecuteDone(napi_env env, napi_status status, void *data); -}; -} // namespace UserAuth -} // namespace UserIAM -} // namespace OHOS -#endif // FACERECOGNITION_USER_AUTH_H +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef FACERECOGNITION_USER_AUTH_H +#define FACERECOGNITION_USER_AUTH_H + +#include "napi/native_common.h" + +#include "auth_build.h" +#include "auth_common.h" +#include "userauth_api7.h" +#include "userauth_api7_callback.h" + +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(); + ~UserAuthImpl(); + AuthBuild authBuild; + napi_value GetVersion(napi_env env, napi_callback_info info); + napi_value GetAvailabeStatus(napi_env env, napi_callback_info info); + 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 AuthUser(napi_env env, napi_callback_info info); + napi_value CancelAuth(napi_env env, napi_callback_info info); + +private: + 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, 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); + static void SetPropertyAsyncExecuteDone(napi_env env, napi_status status, void *data); + static void GetPropertyExecute(napi_env env, void *data); + static void GetPropertyPromiseExecuteDone(napi_env env, napi_status status, void *data); + static void GetPropertyAsyncExecuteDone(napi_env env, napi_status status, void *data); +}; +class AuthenticatorImpl { +public: + AuthenticatorImpl(); + ~AuthenticatorImpl(); + napi_value Execute(napi_env env, napi_callback_info info); + napi_value Cancel(napi_env env, napi_callback_info info); + napi_value CheckAvailability(napi_env env, napi_callback_info info); + napi_value On(napi_env env, napi_callback_info info); + napi_value Off(napi_env env, napi_callback_info info); +private: + napi_value ExecuteWrap(napi_env, napi_callback_info info, ExecuteInfo* executeInfo); + napi_value ExecuteAsyncallback(napi_env, napi_value* argv, ExecuteInfo* executeInfo); + napi_value ExecutePromise(napi_env, napi_value* argv, ExecuteInfo* executeInfo); +}; +} // namespace UserAuth +} // namespace UserIAM +} // namespace OHOS +#endif // FACERECOGNITION_USER_AUTH_H diff --git a/interfaces/innerkits/napi/src/authapi_callback.cpp b/interfaces/innerkits/napi/src/authapi_callback.cpp index 876decb9e..18d422438 100755 --- a/interfaces/innerkits/napi/src/authapi_callback.cpp +++ b/interfaces/innerkits/napi/src/authapi_callback.cpp @@ -1,496 +1,659 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "authapi_callback.h" - -#include -#include "securec.h" - -#include "auth_hilog_wrapper.h" - -namespace OHOS { -namespace UserIAM { -namespace UserAuth { -AuthApiCallback::AuthApiCallback(AuthInfo *authInfo) -{ - authInfo_ = authInfo; - userInfo_ = nullptr; -} - -AuthApiCallback::AuthApiCallback(AuthUserInfo *userInfo) -{ - authInfo_ = nullptr; - userInfo_ = userInfo; -} - -AuthApiCallback::~AuthApiCallback() -{ -} - -napi_value AuthApiCallback::Uint8ArrayToNapi(napi_env env, std::vector value) -{ - int size = value.size(); - HILOG_INFO("Uint8ArrayToNapi size = %{public}d", size); - napi_value out = nullptr; - void *data = nullptr; - napi_value buffer = nullptr; - NAPI_CALL(env, napi_create_arraybuffer(env, value.size(), &data, &buffer)); - if (memcpy_s(data, value.size(), value.data(), value.size()) != 0) { - HILOG_ERROR("AuthApiCallback Uint8ArrayToNapi error"); - } - NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, value.size(), buffer, 0, &out)); - return out; -} - -napi_value AuthApiCallback::BuildOnResult( - napi_env env, uint32_t remainTimes, uint32_t freezingTime, std::vector token) -{ - napi_value jsObject = nullptr; - NAPI_CALL(env, napi_create_object(env, &jsObject)); - - napi_value remainTimesValue = 0; - NAPI_CALL(env, napi_create_uint32(env, remainTimes, &remainTimesValue)); - NAPI_CALL(env, napi_set_named_property(env, jsObject, "remainTimes", remainTimesValue)); - - napi_value freezingTimeValue = 0; - NAPI_CALL(env, napi_create_uint32(env, freezingTime, &freezingTimeValue)); - NAPI_CALL(env, napi_set_named_property(env, jsObject, "freezingTime", freezingTimeValue)); - - napi_value jsToken = Uint8ArrayToNapi(env, token); - NAPI_CALL(env, napi_set_named_property(env, jsObject, "token", jsToken)); - return jsObject; -} - -void AuthApiCallback::OnAuthAcquireInfo(AcquireInfoInner *acquireInfoInner) -{ - HILOG_INFO("AuthApiCallback OnAuthAcquireInfo start"); - uv_loop_s *loop(nullptr); - napi_get_uv_event_loop(authInfo_->callBackInfo.env, &loop); - if (loop == nullptr) { - HILOG_ERROR("loop is null"); - delete acquireInfoInner; - return; - } - uv_work_t *work = new (std::nothrow) uv_work_t; - if (work == nullptr) { - HILOG_ERROR("work is null"); - delete acquireInfoInner; - return; - } - work->data = reinterpret_cast(acquireInfoInner); - uv_queue_work(loop, work, [] (uv_work_t *work) {}, [] (uv_work_t *work, int status) { - HILOG_INFO("Do OnAuthAcquireInfo work"); - AcquireInfoInner *acquireInfoInner = reinterpret_cast(work->data); - if (acquireInfoInner == nullptr) { - HILOG_ERROR("authInfo is null"); - delete work; - return; - } - napi_env env = acquireInfoInner->env; - napi_value returnOnAcquire = nullptr; - napi_value callback; - napi_status napiStatus = napi_get_reference_value(env, acquireInfoInner->onAcquireInfo, &callback); - if (napiStatus != napi_ok) { - HILOG_INFO("napi_get_reference_value faild "); - delete acquireInfoInner; - delete work; - return; - } - napi_value params[PARAM3]; - napi_create_int32(env, acquireInfoInner->module, ¶ms[PARAM0]); - napi_create_uint32(env, acquireInfoInner->acquireInfo, ¶ms[PARAM1]); - napi_create_int32(env, acquireInfoInner->extraInfo, ¶ms[PARAM2]); - napiStatus = napi_call_function(env, acquireInfoInner->jsFunction, callback, PARAM3, params, &returnOnAcquire); - if (napiStatus != napi_ok) { - HILOG_ERROR("napi_call_function faild"); - } - delete acquireInfoInner; - delete work; - }); -} - -void AuthApiCallback::onAcquireInfo(const int32_t module, const uint32_t acquireInfo, const int32_t extraInfo) -{ - if (userInfo_ != nullptr) { - AcquireInfoInner *acquireInfoInner = new (std::nothrow) AcquireInfoInner(); - if (acquireInfoInner == nullptr) { - HILOG_ERROR("acquireInfoInner is null"); - return; - } - acquireInfoInner->env = userInfo_->callBackInfo.env; - acquireInfoInner->onAcquireInfo = userInfo_->onAcquireInfo; - acquireInfoInner->jsFunction = userInfo_->jsFunction; - acquireInfoInner->module = module; - acquireInfoInner->acquireInfo = acquireInfo; - acquireInfoInner->extraInfo = extraInfo; - OnAuthAcquireInfo(acquireInfoInner); - } else { - HILOG_INFO("AuthApiCallback onAcquireInfo userInfo_ is nullptr "); - } - - if (authInfo_ != nullptr) { - AcquireInfoInner *acquireInfoInner = new (std::nothrow) AcquireInfoInner(); - if (acquireInfoInner == nullptr) { - HILOG_ERROR("acquireInfoInner is null"); - return; - } - acquireInfoInner->env = authInfo_->callBackInfo.env; - acquireInfoInner->onAcquireInfo = authInfo_->onAcquireInfo; - acquireInfoInner->jsFunction = authInfo_->jsFunction; - acquireInfoInner->module = module; - acquireInfoInner->acquireInfo = acquireInfo; - acquireInfoInner->extraInfo = extraInfo; - OnAuthAcquireInfo(acquireInfoInner); - } else { - HILOG_INFO("AuthApiCallback onAcquireInfo authInfo_ is nullptr "); - } - HILOG_INFO("AuthApiCallback onAcquireInfo end"); -} - -static void OnUserAuthResultWork(uv_work_t *work, int status) -{ - HILOG_INFO("Do OnUserAuthResult work"); - AuthUserInfo *userInfo = reinterpret_cast(work->data); - if (userInfo == nullptr) { - HILOG_ERROR("authInfo is null"); - delete work; - return; - } - napi_env env = userInfo->callBackInfo.env; - napi_value callback; - napi_status napiStatus = napi_get_reference_value(env, userInfo->onResult, &callback); - if (napiStatus != napi_ok) { - HILOG_INFO("napi_get_reference_value faild "); - delete userInfo; - delete work; - return; - } - napi_value params[PARAM2]; - napi_create_int32(env, userInfo->result, ¶ms[PARAM0]); - params[PARAM1] = AuthApiCallback::BuildOnResult( - env, userInfo->remainTimes, userInfo->freezingTime, userInfo->token); - napi_value return_val = nullptr; - napi_call_function(env, userInfo->jsFunction, callback, PARAM2, params, &return_val); - delete userInfo; - delete work; -} - -void AuthApiCallback::OnUserAuthResult(const int32_t result, const AuthResult extraInfo) -{ - HILOG_INFO("AuthApiCallback OnUserAuthResult start"); - uv_loop_s *loop(nullptr); - napi_get_uv_event_loop(userInfo_->callBackInfo.env, &loop); - if (loop == nullptr) { - HILOG_ERROR("loop is null"); - delete userInfo_; - userInfo_ = nullptr; - return; - } - uv_work_t *work = new (std::nothrow) uv_work_t; - if (work == nullptr) { - HILOG_ERROR("work is null"); - delete userInfo_; - userInfo_ = nullptr; - return; - } - userInfo_->result = result; - userInfo_->token = extraInfo.token; - userInfo_->freezingTime = extraInfo.freezingTime; - userInfo_->remainTimes = extraInfo.remainTimes; - work->data = reinterpret_cast(userInfo_); - userInfo_ = nullptr; - uv_queue_work(loop, work, [] (uv_work_t *work) {}, OnUserAuthResultWork); -} - -static void OnAuthResultWork(uv_work_t *work, int status) -{ - HILOG_INFO("Do OnAuthResult work"); - AuthInfo *authInfo = reinterpret_cast(work->data); - if (authInfo == nullptr) { - HILOG_ERROR("authInfo is null"); - delete work; - return; - } - napi_env env = authInfo->callBackInfo.env; - napi_value callback; - napi_status napiStatus = napi_get_reference_value(env, authInfo->onResult, &callback); - if (napiStatus != napi_ok) { - HILOG_INFO("napi_get_reference_value faild "); - delete authInfo; - delete work; - return; - } - napi_value params[PARAM2]; - napi_create_int32(env, authInfo->result, ¶ms[PARAM0]); - params[PARAM1] = AuthApiCallback::BuildOnResult( - env, authInfo->remainTimes, authInfo->freezingTime, authInfo->token); - napi_value return_val = nullptr; - napi_call_function(env, authInfo->jsFunction, callback, PARAM2, params, &return_val); - delete authInfo; - delete work; -} - -void AuthApiCallback::OnAuthResult(const int32_t result, const AuthResult extraInfo) -{ - HILOG_INFO("AuthApiCallback OnAuthResult start"); - uv_loop_s *loop(nullptr); - napi_get_uv_event_loop(authInfo_->callBackInfo.env, &loop); - if (loop == nullptr) { - HILOG_ERROR("loop is null"); - delete authInfo_; - authInfo_ = nullptr; - return; - } - uv_work_t *work = new (std::nothrow) uv_work_t; - if (work == nullptr) { - HILOG_ERROR("work is null"); - delete authInfo_; - authInfo_ = nullptr; - return; - } - authInfo_->result = result; - authInfo_->token = extraInfo.token; - authInfo_->freezingTime = extraInfo.freezingTime; - authInfo_->remainTimes = extraInfo.remainTimes; - work->data = reinterpret_cast(authInfo_); - authInfo_ = nullptr; - uv_queue_work(loop, work, [] (uv_work_t *work) {}, OnAuthResultWork); -} - -void AuthApiCallback::onResult(const int32_t result, const AuthResult extraInfo) -{ - HILOG_INFO("AuthApiCallback onResult start result = %{public}d", result); - HILOG_INFO("AuthApiCallback onResult start token.length = %{public}d", extraInfo.token.size()); - HILOG_INFO("AuthApiCallback onResult start extraInfo.remainTimes = %{public}u", extraInfo.remainTimes); - HILOG_INFO("AuthApiCallback onResult start extraInfo.freezingTime = %{public}u", extraInfo.freezingTime); - if (userInfo_ != nullptr) { - OnUserAuthResult(result, extraInfo); - } else { - HILOG_ERROR("AuthApiCallback onResult userInfo_ is nullptr "); - } - if (authInfo_ != nullptr) { - OnAuthResult(result, extraInfo); - } else { - HILOG_ERROR("AuthApiCallback onResult authInfo_ is nullptr "); - } - HILOG_INFO("AuthApiCallback onResult end"); -} - -GetPropApiCallback::GetPropApiCallback(GetPropertyInfo *getPropertyInfo) -{ - getPropertyInfo_ = getPropertyInfo; -} - -GetPropApiCallback::~GetPropApiCallback() -{ -} - -static void GetPropertyInfoCallback(uv_work_t* work, int status) -{ - HILOG_INFO("Do OnAuthAcquireInfo work"); - GetPropertyInfo *getPropertyInfo = reinterpret_cast(work->data); - if (getPropertyInfo == nullptr) { - HILOG_ERROR("getPropertyInfo is null"); - delete work; - return; - } - napi_env env = getPropertyInfo->callBackInfo.env; - napi_value resultData[PARAM1]; - resultData[PARAM0] = GetPropApiCallback::BuildExecutorProperty(env, getPropertyInfo->getResult, - getPropertyInfo->remainTimes, getPropertyInfo->freezingTime, getPropertyInfo->authSubType); - if (getPropertyInfo->callBackInfo.callBack != nullptr) { - HILOG_INFO("onExecutorPropertyInfo async"); - napi_value global = nullptr; - napi_status napiStatus = napi_get_global(env, &global); - if (napiStatus != napi_ok) { - HILOG_INFO("napi_get_global faild "); - goto EXIT; - } - napi_value resultValue = nullptr; - napi_value callBack = nullptr; - napiStatus = napi_get_reference_value(env, getPropertyInfo->callBackInfo.callBack, &callBack); - if (napiStatus != napi_ok) { - HILOG_INFO("napi_get_reference_value faild "); - goto EXIT; - } - napiStatus = napi_call_function(env, global, callBack, PARAM1, resultData, &resultValue); - if (napiStatus != napi_ok) { - HILOG_INFO("napi_call_function faild "); - goto EXIT; - } - } else { - HILOG_INFO("onExecutorPropertyInfo promise"); - napi_value resultValue = resultData[PARAM0]; - napi_deferred deferred = getPropertyInfo->callBackInfo.deferred; - napi_status napiStatus = napi_resolve_deferred(env, deferred, resultValue); - if (napiStatus != napi_ok) { - HILOG_INFO("napi_resolve_deferred faild "); - goto EXIT; - } - } -EXIT: - delete getPropertyInfo; - delete work; -} - -napi_value GetPropApiCallback::BuildExecutorProperty( - napi_env env, int32_t result, uint32_t remainTimes, uint32_t freezingTime, uint64_t authSubType) -{ - napi_value jsObject = nullptr; - NAPI_CALL(env, napi_create_object(env, &jsObject)); - - napi_value resultValue = 0; - NAPI_CALL(env, napi_create_int32(env, result, &resultValue)); - NAPI_CALL(env, napi_set_named_property(env, jsObject, "result", resultValue)); - - napi_value remainTimesValue = 0; - NAPI_CALL(env, napi_create_uint32(env, remainTimes, &remainTimesValue)); - NAPI_CALL(env, napi_set_named_property(env, jsObject, "remainTimes", remainTimesValue)); - - napi_value freezingTimeValue = 0; - NAPI_CALL(env, napi_create_uint32(env, freezingTime, &freezingTimeValue)); - NAPI_CALL(env, napi_set_named_property(env, jsObject, "freezingTime", freezingTimeValue)); - - 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; -} - -void GetPropApiCallback::onGetProperty(const ExecutorProperty result) -{ - HILOG_INFO("GetPropApiCallback onGetProperty 1 = %{public}d", result.result); - HILOG_INFO("GetPropApiCallback onGetProperty 2 = %{public}llu", result.authSubType); - HILOG_INFO("GetPropApiCallback onGetProperty 3 = %{public}u", result.remainTimes); - HILOG_INFO("GetPropApiCallback onGetProperty 4 = %{public}u", result.freezingTime); - if (getPropertyInfo_ == nullptr) { - HILOG_ERROR("GetPropApiCallback onGetProperty getPropertyInfo_ is nullptr"); - return; - } - uv_loop_s *loop(nullptr); - napi_get_uv_event_loop(getPropertyInfo_->callBackInfo.env, &loop); - if (loop == nullptr) { - HILOG_ERROR("loop is null"); - delete getPropertyInfo_; - getPropertyInfo_ = nullptr; - return; - } - uv_work_t *work = new (std::nothrow) uv_work_t; - if (work == nullptr) { - HILOG_ERROR("work is null"); - delete getPropertyInfo_; - getPropertyInfo_ = nullptr; - return; - } - getPropertyInfo_->getResult = result.result; - getPropertyInfo_->authSubType = static_cast(result.authSubType); - getPropertyInfo_->remainTimes = result.remainTimes; - getPropertyInfo_->freezingTime = result.freezingTime; - work->data = reinterpret_cast(getPropertyInfo_); - getPropertyInfo_ = nullptr; - HILOG_INFO("Before GetPropertyInfoCallback"); - uv_queue_work(loop, work, [] (uv_work_t *work) {}, GetPropertyInfoCallback); -} - -SetPropApiCallback::SetPropApiCallback(SetPropertyInfo *setPropertyInfo) -{ - setPropertyInfo_ = setPropertyInfo; -} - -SetPropApiCallback::~SetPropApiCallback() -{ -} - -static void SetExecutorPropertyCallback(uv_work_t *work, int status) -{ - HILOG_INFO("Do SetExecutorPropertyCallback work"); - SetPropertyInfo *setPropertyInfo = reinterpret_cast(work->data); - if (setPropertyInfo == nullptr) { - HILOG_ERROR("authInfo is null"); - delete work; - return; - } - napi_env env = setPropertyInfo->callBackInfo.env; - napi_status napiStatus = napi_create_int32(env, setPropertyInfo->setResult, &setPropertyInfo->result); - if (napiStatus != napi_ok) { - HILOG_ERROR("napi_create_int32 faild"); - goto EXIT; - } - if (setPropertyInfo->callBackInfo.callBack != nullptr) { - napi_value global = nullptr; - napiStatus = napi_get_global(env, &global); - if (napiStatus != napi_ok) { - HILOG_ERROR("napi_get_global faild"); - goto EXIT; - } - napi_value resultData[PARAM1]; - resultData[PARAM0] = setPropertyInfo->result; - setPropertyInfo->result = nullptr; - napi_value result = nullptr; - napi_value callBack = nullptr; - napiStatus = napi_get_reference_value(env, setPropertyInfo->callBackInfo.callBack, &callBack); - if (napiStatus != napi_ok) { - HILOG_ERROR("napi_get_reference_value faild"); - goto EXIT; - } - napiStatus = napi_call_function(env, global, callBack, PARAM1, resultData, &result); - if (napiStatus != napi_ok) { - HILOG_ERROR("napi_call_function faild"); - goto EXIT; - } - } else { - napi_value result = setPropertyInfo->result; - napi_deferred deferred = setPropertyInfo->callBackInfo.deferred; - napiStatus = napi_resolve_deferred(env, deferred, result); - if (napiStatus != napi_ok) { - HILOG_ERROR("napi_call_function faild"); - goto EXIT; - } - } -EXIT: - delete setPropertyInfo; - delete work; -} - -void SetPropApiCallback::onSetProperty(const int32_t result) -{ - HILOG_INFO("onSetProperty start = %{public}d", result); - if (setPropertyInfo_ != nullptr) { - HILOG_ERROR("setPropertyInfo is null"); - return; - } - uv_loop_s *loop(nullptr); - napi_get_uv_event_loop(setPropertyInfo_->callBackInfo.env, &loop); - if (loop == nullptr) { - HILOG_ERROR("loop is null"); - delete setPropertyInfo_; - setPropertyInfo_ = nullptr; - return; - } - uv_work_t *work = new (std::nothrow) uv_work_t; - if (work == nullptr) { - HILOG_ERROR("work is null"); - delete setPropertyInfo_; - setPropertyInfo_ = nullptr; - return; - } - setPropertyInfo_->setResult = result; - work->data = reinterpret_cast(setPropertyInfo_); - setPropertyInfo_ = nullptr; - uv_queue_work(loop, work, [] (uv_work_t *work) {}, SetExecutorPropertyCallback); -} -} // namespace UserAuth -} // namespace UserIAM -} // namespace OHOS +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "authapi_callback.h" + +#include +#include "securec.h" + +#include "auth_hilog_wrapper.h" + +namespace OHOS { +namespace UserIAM { +namespace UserAuth { +AuthApiCallback::AuthApiCallback(AuthInfo *authInfo) +{ + authInfo_ = authInfo; + userInfo_ = nullptr; +} + +AuthApiCallback::AuthApiCallback(AuthUserInfo *userInfo) +{ + authInfo_ = nullptr; + userInfo_ = userInfo; +} + +AuthApiCallback::~AuthApiCallback() +{ +} + + +API7callback::API7callback(ExecuteInfo* executeInfo) +{ + executeInfo_ = executeInfo; +} + +API7callback::API7callback(FunctionOnAndOffInfo* functionOnAndOffInfo) +{ + functionOnAndOffInfo_ = functionOnAndOffInfo; +} + +void API7callback::API7OnResultWrap(uv_loop_s *loop, uv_work_t *work) +{ + HILOG_INFO("authFace : %{public}s, start.", __func__); + uv_queue_work(loop, work, [] (uv_work_t *work) { }, [] (uv_work_t *work, int status) { + ExecuteInfo *executeInfo = reinterpret_cast(work->data); + if (executeInfo == nullptr) { + delete work; + work = nullptr; + return; + } + napi_env env = executeInfo->env; + napi_value undefined; + napi_get_undefined(env, &undefined); + if (executeInfo->callbackRef == nullptr && executeInfo->deferred != nullptr) { + napi_resolve_deferred(env, executeInfo->deferred, executeInfo->result); + delete executeInfo; + executeInfo = nullptr; + delete work; + work = nullptr; + return; + } + napi_value callback; + napi_value resultData[PARAM1]; + resultData[PARAM0] = executeInfo->result; + napi_get_reference_value(env, executeInfo->callbackRef, &callback); + napi_value callResult = nullptr; + napi_call_function(env, undefined, callback, 1, resultData, &callResult); + delete executeInfo; + executeInfo = nullptr; + delete work; + work = nullptr; + }); +} + +void API7callback::API7OnResult(const int32_t result) +{ + HILOG_INFO("authFace : %{public}s, start.", __func__); + if (executeInfo_ != nullptr) { + napi_env env = executeInfo_->env; + napi_status status = napi_create_int32(env, result, &executeInfo_->result); + if (status != napi_ok) { + HILOG_INFO("napi_create_int32 faild"); + } + uv_loop_s *loop(nullptr); + status = napi_get_uv_event_loop(env, &loop); + if (status != napi_ok) { + HILOG_INFO("napi_get_uv_event_loop faild"); + } + if (loop == nullptr) { + return; + } + uv_work_t *work = new(std::nothrow) uv_work_t; + if (work == nullptr) { + return; + } + ExecuteInfo *executeInfo = new (std::nothrow) ExecuteInfo(); + executeInfo = executeInfo_; + if (executeInfo == nullptr) { + delete work; + work = nullptr; + return; + } + work->data = reinterpret_cast(executeInfo); + API7OnResultWrap(loop, work); + } else { + HILOG_ERROR("asyncCallbackContext_ is nullptr"); + } +} + +void API7callback::TipCallbackWrap(uv_loop_s *loop, uv_work_t *work) +{ + HILOG_INFO("authFace : %{public}s, start.", __func__); + uv_queue_work(loop, work, [] (uv_work_t *work) { }, [] (uv_work_t *work, int status) { + FunctionOnAndOffInfo *functionOnAndOffInfo = reinterpret_cast(work->data); + if (functionOnAndOffInfo == nullptr) { + delete work; + work = nullptr; + return; + } + napi_env env = functionOnAndOffInfo->env; + napi_value undefined; + napi_get_undefined(env, &undefined); + if (functionOnAndOffInfo->callbackRef == nullptr) { + delete work; + work = nullptr; + return; + } + napi_value callback; + napi_get_reference_value(env, functionOnAndOffInfo->callbackRef, &callback); + napi_value callResult = nullptr; + napi_call_function(env, undefined, callback, 1, functionOnAndOffInfo->param, &callResult); + delete functionOnAndOffInfo; + functionOnAndOffInfo = nullptr; + delete work; + work = nullptr; + }); +} + +void API7callback::TipCallback(const API7UserAuth::Tip result) +{ + HILOG_INFO("authFace : %{public}s, start.", __func__); + if (functionOnAndOffInfo_ != nullptr) { + napi_env env = functionOnAndOffInfo_->env; + functionOnAndOffInfo_->param[PARAM0] = ResultTips(env,result); + uv_loop_s *loop(nullptr); + napi_status status = napi_get_uv_event_loop(env, &loop); + if (status != napi_ok) { + HILOG_INFO("napi_get_uv_event_loop faild"); + } + if (loop == nullptr) { + return; + } + uv_work_t *work = new(std::nothrow) uv_work_t; + if (work == nullptr) { + return; + } + FunctionOnAndOffInfo *functionOnAndOffInfo = new (std::nothrow) FunctionOnAndOffInfo(); + functionOnAndOffInfo = functionOnAndOffInfo_; + if (functionOnAndOffInfo == nullptr) { + delete work; + work = nullptr; + return; + } + work->data = reinterpret_cast(functionOnAndOffInfo); + TipCallbackWrap(loop, work); + } else { + HILOG_ERROR("asyncCallbackContext_ is nullptr"); + } + HILOG_ERROR("TipCallback is end"); +} + +napi_value API7callback::ResultTips(napi_env env, const API7UserAuth::Tip result) +{ + HILOG_INFO("authFace : %{public}s, start.", __func__); + napi_value obj; + napi_value errorCode; + napi_value tipCode; + napi_value tipInfo; + napi_value tipEvent; + const char* tipInfo_ = result.tipInfo.c_str(); + NAPI_CALL(env, napi_create_object(env, &obj)); + NAPI_CALL(env, napi_create_int32(env, result.errorCode, &errorCode)); + NAPI_CALL(env, napi_create_int32(env, result.tipCode, &tipCode)); + NAPI_CALL(env, napi_create_int32(env, static_cast(result.tipEvent), &tipEvent)); + NAPI_CALL(env, napi_create_string_utf8(env, tipInfo_, NAPI_AUTO_LENGTH, &tipInfo)); + NAPI_CALL(env, napi_set_named_property(env, obj, "errorCode", errorCode)); + NAPI_CALL(env, napi_set_named_property(env, obj, "tipCode", tipCode)); + NAPI_CALL(env, napi_set_named_property(env, obj, "tipInfo", tipInfo)); + NAPI_CALL(env, napi_set_named_property(env, obj, "tipEvent", tipEvent)); + return obj; +} + +napi_value AuthApiCallback::Uint8ArrayToNapi(napi_env env, std::vector value) +{ + int size = value.size(); + HILOG_INFO("Uint8ArrayToNapi size = %{public}d", size); + napi_value out = nullptr; + void *data = nullptr; + napi_value buffer = nullptr; + NAPI_CALL(env, napi_create_arraybuffer(env, value.size(), &data, &buffer)); + if (memcpy_s(data, value.size(), value.data(), value.size()) != 0) { + HILOG_ERROR("AuthApiCallback Uint8ArrayToNapi error"); + } + NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, value.size(), buffer, 0, &out)); + return out; +} + +napi_value AuthApiCallback::BuildOnResult( + napi_env env, uint32_t remainTimes, uint32_t freezingTime, std::vector token) +{ + napi_value jsObject = nullptr; + NAPI_CALL(env, napi_create_object(env, &jsObject)); + + napi_value remainTimesValue = 0; + NAPI_CALL(env, napi_create_uint32(env, remainTimes, &remainTimesValue)); + NAPI_CALL(env, napi_set_named_property(env, jsObject, "remainTimes", remainTimesValue)); + + napi_value freezingTimeValue = 0; + NAPI_CALL(env, napi_create_uint32(env, freezingTime, &freezingTimeValue)); + NAPI_CALL(env, napi_set_named_property(env, jsObject, "freezingTime", freezingTimeValue)); + + napi_value jsToken = Uint8ArrayToNapi(env, token); + NAPI_CALL(env, napi_set_named_property(env, jsObject, "token", jsToken)); + return jsObject; +} + +void AuthApiCallback::OnAuthAcquireInfo(AcquireInfoInner *acquireInfoInner) +{ + HILOG_INFO("AuthApiCallback OnAuthAcquireInfo start"); + uv_loop_s *loop(nullptr); + napi_get_uv_event_loop(authInfo_->callBackInfo.env, &loop); + if (loop == nullptr) { + HILOG_ERROR("loop is null"); + delete acquireInfoInner; + return; + } + uv_work_t *work = new (std::nothrow) uv_work_t; + if (work == nullptr) { + HILOG_ERROR("work is null"); + delete acquireInfoInner; + return; + } + work->data = reinterpret_cast(acquireInfoInner); + uv_queue_work(loop, work, [] (uv_work_t *work) {}, [] (uv_work_t *work, int status) { + HILOG_INFO("Do OnAuthAcquireInfo work"); + AcquireInfoInner *acquireInfoInner = reinterpret_cast(work->data); + if (acquireInfoInner == nullptr) { + HILOG_ERROR("authInfo is null"); + delete work; + return; + } + napi_env env = acquireInfoInner->env; + napi_value returnOnAcquire = nullptr; + napi_value callback; + napi_status napiStatus = napi_get_reference_value(env, acquireInfoInner->onAcquireInfo, &callback); + if (napiStatus != napi_ok) { + HILOG_INFO("napi_get_reference_value faild "); + delete acquireInfoInner; + delete work; + return; + } + napi_value params[PARAM3]; + napi_create_int32(env, acquireInfoInner->module, ¶ms[PARAM0]); + napi_create_uint32(env, acquireInfoInner->acquireInfo, ¶ms[PARAM1]); + napi_create_int32(env, acquireInfoInner->extraInfo, ¶ms[PARAM2]); + napiStatus = napi_call_function(env, acquireInfoInner->jsFunction, callback, PARAM3, params, &returnOnAcquire); + if (napiStatus != napi_ok) { + HILOG_ERROR("napi_call_function faild"); + } + delete acquireInfoInner; + delete work; + }); +} + +void AuthApiCallback::onAcquireInfo(const int32_t module, const uint32_t acquireInfo, const int32_t extraInfo) +{ + if (userInfo_ != nullptr) { + AcquireInfoInner *acquireInfoInner = new (std::nothrow) AcquireInfoInner(); + if (acquireInfoInner == nullptr) { + HILOG_ERROR("acquireInfoInner is null"); + return; + } + acquireInfoInner->env = userInfo_->callBackInfo.env; + acquireInfoInner->onAcquireInfo = userInfo_->onAcquireInfo; + acquireInfoInner->jsFunction = userInfo_->jsFunction; + acquireInfoInner->module = module; + acquireInfoInner->acquireInfo = acquireInfo; + acquireInfoInner->extraInfo = extraInfo; + OnAuthAcquireInfo(acquireInfoInner); + } else { + HILOG_INFO("AuthApiCallback onAcquireInfo userInfo_ is nullptr "); + } + + if (authInfo_ != nullptr) { + AcquireInfoInner *acquireInfoInner = new (std::nothrow) AcquireInfoInner(); + if (acquireInfoInner == nullptr) { + HILOG_ERROR("acquireInfoInner is null"); + return; + } + acquireInfoInner->env = authInfo_->callBackInfo.env; + acquireInfoInner->onAcquireInfo = authInfo_->onAcquireInfo; + acquireInfoInner->jsFunction = authInfo_->jsFunction; + acquireInfoInner->module = module; + acquireInfoInner->acquireInfo = acquireInfo; + acquireInfoInner->extraInfo = extraInfo; + OnAuthAcquireInfo(acquireInfoInner); + } else { + HILOG_INFO("AuthApiCallback onAcquireInfo authInfo_ is nullptr "); + } + HILOG_INFO("AuthApiCallback onAcquireInfo end"); +} + +static void OnUserAuthResultWork(uv_work_t *work, int status) +{ + HILOG_INFO("Do OnUserAuthResult work"); + AuthUserInfo *userInfo = reinterpret_cast(work->data); + if (userInfo == nullptr) { + HILOG_ERROR("authInfo is null"); + delete work; + return; + } + napi_env env = userInfo->callBackInfo.env; + napi_value callback; + napi_status napiStatus = napi_get_reference_value(env, userInfo->onResult, &callback); + if (napiStatus != napi_ok) { + HILOG_INFO("napi_get_reference_value faild "); + delete userInfo; + delete work; + return; + } + napi_value params[PARAM2]; + napi_create_int32(env, userInfo->result, ¶ms[PARAM0]); + params[PARAM1] = AuthApiCallback::BuildOnResult( + env, userInfo->remainTimes, userInfo->freezingTime, userInfo->token); + napi_value return_val = nullptr; + napi_call_function(env, userInfo->jsFunction, callback, PARAM2, params, &return_val); + delete userInfo; + delete work; +} + +void AuthApiCallback::OnUserAuthResult(const int32_t result, const AuthResult extraInfo) +{ + HILOG_INFO("AuthApiCallback OnUserAuthResult start"); + uv_loop_s *loop(nullptr); + napi_get_uv_event_loop(userInfo_->callBackInfo.env, &loop); + if (loop == nullptr) { + HILOG_ERROR("loop is null"); + delete userInfo_; + userInfo_ = nullptr; + return; + } + uv_work_t *work = new (std::nothrow) uv_work_t; + if (work == nullptr) { + HILOG_ERROR("work is null"); + delete userInfo_; + userInfo_ = nullptr; + return; + } + userInfo_->result = result; + userInfo_->token = extraInfo.token; + userInfo_->freezingTime = extraInfo.freezingTime; + userInfo_->remainTimes = extraInfo.remainTimes; + work->data = reinterpret_cast(userInfo_); + userInfo_ = nullptr; + uv_queue_work(loop, work, [] (uv_work_t *work) {}, OnUserAuthResultWork); +} + +static void OnAuthResultWork(uv_work_t *work, int status) +{ + HILOG_INFO("Do OnAuthResult work"); + AuthInfo *authInfo = reinterpret_cast(work->data); + if (authInfo == nullptr) { + HILOG_ERROR("authInfo is null"); + delete work; + return; + } + napi_env env = authInfo->callBackInfo.env; + napi_value callback; + napi_status napiStatus = napi_get_reference_value(env, authInfo->onResult, &callback); + if (napiStatus != napi_ok) { + HILOG_INFO("napi_get_reference_value faild "); + delete authInfo; + delete work; + return; + } + napi_value params[PARAM2]; + napi_create_int32(env, authInfo->result, ¶ms[PARAM0]); + params[PARAM1] = AuthApiCallback::BuildOnResult( + env, authInfo->remainTimes, authInfo->freezingTime, authInfo->token); + napi_value return_val = nullptr; + napi_call_function(env, authInfo->jsFunction, callback, PARAM2, params, &return_val); + delete authInfo; + delete work; +} + +void AuthApiCallback::OnAuthResult(const int32_t result, const AuthResult extraInfo) +{ + HILOG_INFO("AuthApiCallback OnAuthResult start"); + uv_loop_s *loop(nullptr); + napi_get_uv_event_loop(authInfo_->callBackInfo.env, &loop); + if (loop == nullptr) { + HILOG_ERROR("loop is null"); + delete authInfo_; + authInfo_ = nullptr; + return; + } + uv_work_t *work = new (std::nothrow) uv_work_t; + if (work == nullptr) { + HILOG_ERROR("work is null"); + delete authInfo_; + authInfo_ = nullptr; + return; + } + authInfo_->result = result; + authInfo_->token = extraInfo.token; + authInfo_->freezingTime = extraInfo.freezingTime; + authInfo_->remainTimes = extraInfo.remainTimes; + work->data = reinterpret_cast(authInfo_); + authInfo_ = nullptr; + uv_queue_work(loop, work, [] (uv_work_t *work) {}, OnAuthResultWork); +} + +void AuthApiCallback::onResult(const int32_t result, const AuthResult extraInfo) +{ + HILOG_INFO("AuthApiCallback onResult start result = %{public}d", result); + HILOG_INFO("AuthApiCallback onResult start token.length = %{public}d", extraInfo.token.size()); + HILOG_INFO("AuthApiCallback onResult start extraInfo.remainTimes = %{public}u", extraInfo.remainTimes); + HILOG_INFO("AuthApiCallback onResult start extraInfo.freezingTime = %{public}u", extraInfo.freezingTime); + if (userInfo_ != nullptr) { + OnUserAuthResult(result, extraInfo); + } else { + HILOG_ERROR("AuthApiCallback onResult userInfo_ is nullptr "); + } + if (authInfo_ != nullptr) { + OnAuthResult(result, extraInfo); + } else { + HILOG_ERROR("AuthApiCallback onResult authInfo_ is nullptr "); + } + HILOG_INFO("AuthApiCallback onResult end"); +} + +GetPropApiCallback::GetPropApiCallback(GetPropertyInfo *getPropertyInfo) +{ + getPropertyInfo_ = getPropertyInfo; +} + +GetPropApiCallback::~GetPropApiCallback() +{ +} + +static void GetPropertyInfoCallback(uv_work_t* work, int status) +{ + HILOG_INFO("Do OnAuthAcquireInfo work"); + GetPropertyInfo *getPropertyInfo = reinterpret_cast(work->data); + if (getPropertyInfo == nullptr) { + HILOG_ERROR("getPropertyInfo is null"); + delete work; + return; + } + napi_env env = getPropertyInfo->callBackInfo.env; + napi_value resultData[PARAM1]; + resultData[PARAM0] = GetPropApiCallback::BuildExecutorProperty(env, getPropertyInfo->getResult, + getPropertyInfo->remainTimes, getPropertyInfo->freezingTime, getPropertyInfo->authSubType); + if (getPropertyInfo->callBackInfo.callBack != nullptr) { + HILOG_INFO("onExecutorPropertyInfo async"); + napi_value global = nullptr; + napi_status napiStatus = napi_get_global(env, &global); + if (napiStatus != napi_ok) { + HILOG_INFO("napi_get_global faild "); + goto EXIT; + } + napi_value resultValue = nullptr; + napi_value callBack = nullptr; + napiStatus = napi_get_reference_value(env, getPropertyInfo->callBackInfo.callBack, &callBack); + if (napiStatus != napi_ok) { + HILOG_INFO("napi_get_reference_value faild "); + goto EXIT; + } + napiStatus = napi_call_function(env, global, callBack, PARAM1, resultData, &resultValue); + if (napiStatus != napi_ok) { + HILOG_INFO("napi_call_function faild "); + goto EXIT; + } + } else { + HILOG_INFO("onExecutorPropertyInfo promise"); + napi_value resultValue = resultData[PARAM0]; + napi_deferred deferred = getPropertyInfo->callBackInfo.deferred; + napi_status napiStatus = napi_resolve_deferred(env, deferred, resultValue); + if (napiStatus != napi_ok) { + HILOG_INFO("napi_resolve_deferred faild "); + goto EXIT; + } + } +EXIT: + delete getPropertyInfo; + delete work; +} + +napi_value GetPropApiCallback::BuildExecutorProperty( + napi_env env, int32_t result, uint32_t remainTimes, uint32_t freezingTime, uint64_t authSubType) +{ + napi_value jsObject = nullptr; + NAPI_CALL(env, napi_create_object(env, &jsObject)); + + napi_value resultValue = 0; + NAPI_CALL(env, napi_create_int32(env, result, &resultValue)); + NAPI_CALL(env, napi_set_named_property(env, jsObject, "result", resultValue)); + + napi_value remainTimesValue = 0; + NAPI_CALL(env, napi_create_uint32(env, remainTimes, &remainTimesValue)); + NAPI_CALL(env, napi_set_named_property(env, jsObject, "remainTimes", remainTimesValue)); + + napi_value freezingTimeValue = 0; + NAPI_CALL(env, napi_create_uint32(env, freezingTime, &freezingTimeValue)); + NAPI_CALL(env, napi_set_named_property(env, jsObject, "freezingTime", freezingTimeValue)); + + 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; +} + +void GetPropApiCallback::onGetProperty(const ExecutorProperty result) +{ + HILOG_INFO("GetPropApiCallback onGetProperty 1 = %{public}d", result.result); + HILOG_INFO("GetPropApiCallback onGetProperty 2 = %{public}llu", result.authSubType); + HILOG_INFO("GetPropApiCallback onGetProperty 3 = %{public}u", result.remainTimes); + HILOG_INFO("GetPropApiCallback onGetProperty 4 = %{public}u", result.freezingTime); + if (getPropertyInfo_ == nullptr) { + HILOG_ERROR("GetPropApiCallback onGetProperty getPropertyInfo_ is nullptr"); + return; + } + uv_loop_s *loop(nullptr); + napi_get_uv_event_loop(getPropertyInfo_->callBackInfo.env, &loop); + if (loop == nullptr) { + HILOG_ERROR("loop is null"); + delete getPropertyInfo_; + getPropertyInfo_ = nullptr; + return; + } + uv_work_t *work = new (std::nothrow) uv_work_t; + if (work == nullptr) { + HILOG_ERROR("work is null"); + delete getPropertyInfo_; + getPropertyInfo_ = nullptr; + return; + } + getPropertyInfo_->getResult = result.result; + getPropertyInfo_->authSubType = static_cast(result.authSubType); + getPropertyInfo_->remainTimes = result.remainTimes; + getPropertyInfo_->freezingTime = result.freezingTime; + work->data = reinterpret_cast(getPropertyInfo_); + getPropertyInfo_ = nullptr; + HILOG_INFO("Before GetPropertyInfoCallback"); + uv_queue_work(loop, work, [] (uv_work_t *work) {}, GetPropertyInfoCallback); +} + +SetPropApiCallback::SetPropApiCallback(SetPropertyInfo *setPropertyInfo) +{ + setPropertyInfo_ = setPropertyInfo; +} + +SetPropApiCallback::~SetPropApiCallback() +{ +} + +static void SetExecutorPropertyCallback(uv_work_t *work, int status) +{ + HILOG_INFO("Do SetExecutorPropertyCallback work"); + SetPropertyInfo *setPropertyInfo = reinterpret_cast(work->data); + if (setPropertyInfo == nullptr) { + HILOG_ERROR("authInfo is null"); + delete work; + return; + } + napi_env env = setPropertyInfo->callBackInfo.env; + napi_status napiStatus = napi_create_int32(env, setPropertyInfo->setResult, &setPropertyInfo->result); + if (napiStatus != napi_ok) { + HILOG_ERROR("napi_create_int32 faild"); + goto EXIT; + } + if (setPropertyInfo->callBackInfo.callBack != nullptr) { + napi_value global = nullptr; + napiStatus = napi_get_global(env, &global); + if (napiStatus != napi_ok) { + HILOG_ERROR("napi_get_global faild"); + goto EXIT; + } + napi_value resultData[PARAM1]; + resultData[PARAM0] = setPropertyInfo->result; + setPropertyInfo->result = nullptr; + napi_value result = nullptr; + napi_value callBack = nullptr; + napiStatus = napi_get_reference_value(env, setPropertyInfo->callBackInfo.callBack, &callBack); + if (napiStatus != napi_ok) { + HILOG_ERROR("napi_get_reference_value faild"); + goto EXIT; + } + napiStatus = napi_call_function(env, global, callBack, PARAM1, resultData, &result); + if (napiStatus != napi_ok) { + HILOG_ERROR("napi_call_function faild"); + goto EXIT; + } + } else { + napi_value result = setPropertyInfo->result; + napi_deferred deferred = setPropertyInfo->callBackInfo.deferred; + napiStatus = napi_resolve_deferred(env, deferred, result); + if (napiStatus != napi_ok) { + HILOG_ERROR("napi_call_function faild"); + goto EXIT; + } + } +EXIT: + delete setPropertyInfo; + delete work; +} + +void SetPropApiCallback::onSetProperty(const int32_t result) +{ + HILOG_INFO("onSetProperty start = %{public}d", result); + if (setPropertyInfo_ != nullptr) { + HILOG_ERROR("setPropertyInfo is null"); + return; + } + uv_loop_s *loop(nullptr); + napi_get_uv_event_loop(setPropertyInfo_->callBackInfo.env, &loop); + if (loop == nullptr) { + HILOG_ERROR("loop is null"); + delete setPropertyInfo_; + setPropertyInfo_ = nullptr; + return; + } + uv_work_t *work = new (std::nothrow) uv_work_t; + if (work == nullptr) { + HILOG_ERROR("work is null"); + delete setPropertyInfo_; + setPropertyInfo_ = nullptr; + return; + } + setPropertyInfo_->setResult = result; + work->data = reinterpret_cast(setPropertyInfo_); + setPropertyInfo_ = nullptr; + uv_queue_work(loop, work, [] (uv_work_t *work) {}, SetExecutorPropertyCallback); +} +} // namespace UserAuth +} // namespace UserIAM +} // namespace OHOS diff --git a/interfaces/innerkits/napi/src/result_convert.cpp b/interfaces/innerkits/napi/src/result_convert.cpp index 77abb2f6d..a43548c92 100644 --- a/interfaces/innerkits/napi/src/result_convert.cpp +++ b/interfaces/innerkits/napi/src/result_convert.cpp @@ -1,225 +1,225 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "result_convert.h" - -#include "securec.h" - -#include "auth_hilog_wrapper.h" - -namespace OHOS { -namespace UserIAM { -namespace UserAuth { -ResultConvert::ResultConvert(void) -{ -} - -ResultConvert::~ResultConvert() -{ -} - -napi_value ResultConvert::Uint64ToUint8Napi(napi_env env, uint64_t value) -{ - HILOG_INFO("ResultConvert Uint64ToUint8Napi uint64_t %{public}llu", value); - size_t length = sizeof(value); - void *data = nullptr; - napi_value arrayBuffer = nullptr; - size_t bufferSize = length; - NAPI_CALL(env, napi_create_arraybuffer(env, bufferSize, &data, &arrayBuffer)); - memcpy_s(data, bufferSize, reinterpret_cast(&value), bufferSize); - napi_value result = nullptr; - NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, bufferSize, arrayBuffer, 0, &result)); - return result; -} - -std::vector ResultConvert::NapiGetValueUint8Array(napi_env env, napi_value jsObject, std::string key) -{ - napi_value jsValue = GetNapiValue(env, key.c_str(), jsObject); - std::vector RetNull; - if (jsValue == nullptr) { - return RetNull; - } - napi_typedarray_type arraytype; - size_t length = 0; - napi_value buffer = nullptr; - size_t offset = 0; - uint8_t *data = nullptr; - bool isTypedArray = false; - napi_is_typedarray(env, jsValue, &isTypedArray); - if (!isTypedArray) { - HILOG_ERROR("NapiGetValueUint8Array jsValue is not typedarray"); - return RetNull; - } - napi_get_typedarray_info(env, jsValue, &arraytype, &length, reinterpret_cast(&data), &buffer, &offset); - if (arraytype != napi_uint8_array) { - HILOG_ERROR("NapiGetValueUint8Array js jsValue is not uint8Array"); - return RetNull; - } - if (offset != 0) { - HILOG_ERROR("offset is %{public}d", offset); - return RetNull; - } - std::vector result(data, data + length); - return result; -} - -napi_valuetype ResultConvert::GetType(napi_env env, napi_value value) -{ - napi_status status; - if (value == nullptr) { - return napi_null; - } - napi_valuetype type; - status = napi_typeof(env, value, &type); - if (status != napi_ok) { - HILOG_ERROR("napi_typeof faild"); - } - return type; -} - -std::string ResultConvert::GetStringValueByKey(napi_env env, napi_value jsObject, std::string key) -{ - napi_value value = GetNapiValue(env, key.c_str(), jsObject); - std::string result = NapiGetValueString(env, value); - return result; -} - -int32_t ResultConvert::GetInt32ValueByKey(napi_env env, napi_value jsObject, std::string key) -{ - napi_value value = GetNapiValue(env, key.c_str(), jsObject); - return NapiGetValueInt32(env, value); -} - -std::vector ResultConvert::GetCppArrayUint32(napi_env env, napi_value value) -{ - napi_status status; - uint32_t arrayLength = 0; - napi_get_array_length(env, value, &arrayLength); - if (arrayLength <= 0) { - HILOG_ERROR("%{public}s The array is empty.", __func__); - return std::vector(); - } - std::vector paramArrays; - for (size_t i = 0; i < arrayLength; i++) { - napi_value napiElement = nullptr; - napi_get_element(env, value, i, &napiElement); - napi_valuetype napiValueType = napi_undefined; - napi_typeof(env, napiElement, &napiValueType); - if (napiValueType != napi_number) { - HILOG_ERROR("%{public}s Wrong argument type. Numbers expected.", __func__); - return std::vector(); - } - uint32_t napiValue = 0; - status = napi_get_value_uint32(env, napiElement, &napiValue); - if (status != napi_ok) { - return std::vector(); - } - paramArrays.push_back(napiValue); - } - return paramArrays; -} - -std::vector ResultConvert::GetInt32ArrayValueByKey(napi_env env, napi_value jsObject, std::string key) -{ - napi_status status; - napi_value array = GetNapiValue(env, key.c_str(), jsObject); - if (array == nullptr) { - return std::vector(); - } - bool isArray = false; - status = napi_is_array(env, array, &isArray); - if (status != napi_ok) { - HILOG_INFO("napi_is_array is failed"); - return std::vector(); - } - if (isArray) { - HILOG_INFO("args[PIN_PARAMS_ONE] is a array"); - } else { - HILOG_INFO("args[PIN_PARAMS_ONE] is not a array"); - return std::vector(); - } - return GetCppArrayUint32(env, array); -} - -std::string ResultConvert::NapiGetValueString(napi_env env, napi_value value) -{ - napi_status status; - if (value == nullptr) { - HILOG_ERROR("AuthBuild NapiGetValueString value is nullptr"); - return ""; - } - std::string resultValue = ""; - char valueString[NAPI_GET_STRING_SIZE]; - size_t valueSize = NAPI_GET_STRING_SIZE; - size_t resultSize = 0; - status = napi_get_value_string_utf8(env, value, valueString, valueSize, &resultSize); - if (status != napi_ok) { - HILOG_ERROR("napi_get_value_string_utf8 faild"); - } - resultValue = valueString; - if (resultValue == "") { - HILOG_ERROR("ContactsBuild NapiGetValueString Data error"); - return ""; - } - return resultValue; -} - -int32_t ResultConvert::NapiGetValueInt32(napi_env env, napi_value value) -{ - if (value == nullptr) { - return GET_VALUE_ERROR; - } - int32_t result; - napi_status status = napi_get_value_int32(env, value, &result); - if (status != napi_ok) { - return GET_VALUE_ERROR; - } - return result; -} - -int ResultConvert::NapiGetValueInt(napi_env env, napi_value value) -{ - if (value == nullptr) { - return GET_VALUE_ERROR; - } - int32_t result; - napi_status status = napi_get_value_int32(env, value, &result); - if (status != napi_ok) { - return GET_VALUE_ERROR; - } - int ret = result; - return ret; -} - -napi_value ResultConvert::GetNapiValue(napi_env env, const std::string keyChar, napi_value object) -{ - if (object == nullptr) { - HILOG_ERROR("ResultConvert::GetNapiValue object is nullptr"); - return nullptr; - } - napi_value key = nullptr; - NAPI_CALL(env, napi_create_string_utf8(env, keyChar.c_str(), NAPI_AUTO_LENGTH, &key)); - bool result = false; - NAPI_CALL(env, napi_has_property(env, object, key, &result)); - if (result) { - napi_value value = nullptr; - NAPI_CALL(env, napi_get_property(env, object, key, &value)); - return value; - } - return nullptr; -} -} // namespace UserAuth -} // namespace UserIAM -} // namespace OHOS +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "result_convert.h" + +#include "securec.h" + +#include "auth_hilog_wrapper.h" + +namespace OHOS { +namespace UserIAM { +namespace UserAuth { +ResultConvert::ResultConvert(void) +{ +} + +ResultConvert::~ResultConvert() +{ +} + +napi_value ResultConvert::Uint64ToUint8Napi(napi_env env, uint64_t value) +{ + HILOG_INFO("ResultConvert Uint64ToUint8Napi uint64_t %{public}llu", value); + size_t length = sizeof(value); + void *data = nullptr; + napi_value arrayBuffer = nullptr; + size_t bufferSize = length; + NAPI_CALL(env, napi_create_arraybuffer(env, bufferSize, &data, &arrayBuffer)); + memcpy_s(data, bufferSize, reinterpret_cast(&value), bufferSize); + napi_value result = nullptr; + NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, bufferSize, arrayBuffer, 0, &result)); + return result; +} + +std::vector ResultConvert::NapiGetValueUint8Array(napi_env env, napi_value jsObject, std::string key) +{ + napi_value jsValue = GetNapiValue(env, key.c_str(), jsObject); + std::vector RetNull; + if (jsValue == nullptr) { + return RetNull; + } + napi_typedarray_type arraytype; + size_t length = 0; + napi_value buffer = nullptr; + size_t offset = 0; + uint8_t *data = nullptr; + bool isTypedArray = false; + napi_is_typedarray(env, jsValue, &isTypedArray); + if (!isTypedArray) { + HILOG_ERROR("NapiGetValueUint8Array jsValue is not typedarray"); + return RetNull; + } + napi_get_typedarray_info(env, jsValue, &arraytype, &length, reinterpret_cast(&data), &buffer, &offset); + if (arraytype != napi_uint8_array) { + HILOG_ERROR("NapiGetValueUint8Array js jsValue is not uint8Array"); + return RetNull; + } + if (offset != 0) { + HILOG_ERROR("offset is %{public}d", offset); + return RetNull; + } + std::vector result(data, data + length); + return result; +} + +napi_valuetype ResultConvert::GetType(napi_env env, napi_value value) +{ + napi_status status; + if (value == nullptr) { + return napi_null; + } + napi_valuetype type; + status = napi_typeof(env, value, &type); + if (status != napi_ok) { + HILOG_ERROR("napi_typeof faild"); + } + return type; +} + +std::string ResultConvert::GetStringValueByKey(napi_env env, napi_value jsObject, std::string key) +{ + napi_value value = GetNapiValue(env, key.c_str(), jsObject); + std::string result = NapiGetValueString(env, value); + return result; +} + +int32_t ResultConvert::GetInt32ValueByKey(napi_env env, napi_value jsObject, std::string key) +{ + napi_value value = GetNapiValue(env, key.c_str(), jsObject); + return NapiGetValueInt32(env, value); +} + +std::vector ResultConvert::GetCppArrayUint32(napi_env env, napi_value value) +{ + napi_status status; + uint32_t arrayLength = 0; + napi_get_array_length(env, value, &arrayLength); + if (arrayLength <= 0) { + HILOG_ERROR("%{public}s The array is empty.", __func__); + return std::vector(); + } + std::vector paramArrays; + for (size_t i = 0; i < arrayLength; i++) { + napi_value napiElement = nullptr; + napi_get_element(env, value, i, &napiElement); + napi_valuetype napiValueType = napi_undefined; + napi_typeof(env, napiElement, &napiValueType); + if (napiValueType != napi_number) { + HILOG_ERROR("%{public}s Wrong argument type. Numbers expected.", __func__); + return std::vector(); + } + uint32_t napiValue = 0; + status = napi_get_value_uint32(env, napiElement, &napiValue); + if (status != napi_ok) { + return std::vector(); + } + paramArrays.push_back(napiValue); + } + return paramArrays; +} + +std::vector ResultConvert::GetInt32ArrayValueByKey(napi_env env, napi_value jsObject, std::string key) +{ + napi_status status; + napi_value array = GetNapiValue(env, key.c_str(), jsObject); + if (array == nullptr) { + return std::vector(); + } + bool isArray = false; + status = napi_is_array(env, array, &isArray); + if (status != napi_ok) { + HILOG_INFO("napi_is_array is failed"); + return std::vector(); + } + if (isArray) { + HILOG_INFO("args[PIN_PARAMS_ONE] is a array"); + } else { + HILOG_INFO("args[PIN_PARAMS_ONE] is not a array"); + return std::vector(); + } + return GetCppArrayUint32(env, array); +} + +std::string ResultConvert::NapiGetValueString(napi_env env, napi_value value) +{ + napi_status status; + if (value == nullptr) { + HILOG_ERROR("AuthBuild NapiGetValueString value is nullptr"); + return ""; + } + std::string resultValue = ""; + char valueString[NAPI_GET_STRING_SIZE]; + size_t valueSize = NAPI_GET_STRING_SIZE; + size_t resultSize = 0; + status = napi_get_value_string_utf8(env, value, valueString, valueSize, &resultSize); + if (status != napi_ok) { + HILOG_ERROR("napi_get_value_string_utf8 faild"); + } + resultValue = valueString; + if (resultValue == "") { + HILOG_ERROR("ContactsBuild NapiGetValueString Data error"); + return ""; + } + return resultValue; +} + +int32_t ResultConvert::NapiGetValueInt32(napi_env env, napi_value value) +{ + if (value == nullptr) { + return GET_VALUE_ERROR; + } + uint32_t result; + napi_status status = napi_get_value_uint32(env, value, &result); + if (status != napi_ok) { + return GET_VALUE_ERROR; + } + return result; +} + +int ResultConvert::NapiGetValueInt(napi_env env, napi_value value) +{ + if (value == nullptr) { + return GET_VALUE_ERROR; + } + int32_t result; + napi_status status = napi_get_value_int32(env, value, &result); + if (status != napi_ok) { + return GET_VALUE_ERROR; + } + int ret = result; + return ret; +} + +napi_value ResultConvert::GetNapiValue(napi_env env, const std::string keyChar, napi_value object) +{ + if (object == nullptr) { + HILOG_ERROR("ResultConvert::GetNapiValue object is nullptr"); + return nullptr; + } + napi_value key = nullptr; + NAPI_CALL(env, napi_create_string_utf8(env, keyChar.c_str(), NAPI_AUTO_LENGTH, &key)); + bool result = false; + NAPI_CALL(env, napi_has_property(env, object, key, &result)); + if (result) { + napi_value value = nullptr; + NAPI_CALL(env, napi_get_property(env, object, key, &value)); + return value; + } + return nullptr; +} +} // namespace UserAuth +} // namespace UserIAM +} // namespace OHOS diff --git a/interfaces/innerkits/napi/src/user_auth_helper.cpp b/interfaces/innerkits/napi/src/user_auth_helper.cpp index e5982a1be..83188d8c6 100755 --- a/interfaces/innerkits/napi/src/user_auth_helper.cpp +++ b/interfaces/innerkits/napi/src/user_auth_helper.cpp @@ -1,231 +1,350 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "user_auth_helper.h" - -#include "auth_hilog_wrapper.h" -#include "user_auth_impl.h" - -namespace OHOS { -namespace UserIAM { -namespace UserAuth { -/** - * @brief Instance passed to context - * - * @param env - * @param info - * @return napi_value Instance - */ -napi_value UserAuthServiceConstructor(napi_env env, napi_callback_info info) -{ - std::shared_ptr userAuthImpl; - userAuthImpl.reset(new UserAuthImpl()); - napi_value thisVar = nullptr; - size_t argc = ARGS_ONE; - napi_value argv[ARGS_ONE] = {nullptr}; - NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr)); - NAPI_CALL(env, napi_wrap(env, thisVar, userAuthImpl.get(), - [](napi_env env, void *data, void *hint) { - UserAuthImpl *userAuthImpl = static_cast(data); - if (userAuthImpl != nullptr) { - delete userAuthImpl; - } - }, - nullptr, nullptr)); - // Pull up the face service process - return thisVar; -} - -/** - * @brief Get the Version object - * - * @param env - * @param info - * @return napi_value Specific version number results - */ -napi_value GetVersion(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, GetVersion"); - return userAuthImpl->GetVersion(env, info); -} - -/** - * @brief Get the Availabe Status object - * - * @param env - * @param info - * @return napi_value Verify that the certification capability is available - */ -napi_value GetAvailabeStatus(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, getAvailabeStatus"); - return userAuthImpl->GetAvailabeStatus(env, info); -} - -/** - * @brief Get the Property object - * - * @param env - * @param info - * @return napi_value It supports querying subclasses / remaining authentication times / freezing time - */ -napi_value GetProperty(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, GetProperty"); - return userAuthImpl->GetProperty(env, info); -} - -/** - * @brief Set the Property object - * - * @param env - * @param info - * @return napi_value Set properties: can be used to initialize algorithms - */ -napi_value SetProperty(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, SetProperty"); - return userAuthImpl->SetProperty(env, info); -} - -/** - * @brief user authentication - * - * @param env - * @param info - * @return napi_value Enter the challenge value, authentication method, trust level and callback, and return the result - * and acquireinfo through the callback - */ -napi_value Auth(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, Auth"); - return userAuthImpl->Auth(env, info); -} - -/** - * @brief user authentication - * - * @param env - * @param info - * @return napi_value Pass in the user ID, challenge value, authentication method, trust level and callback, and return - * the result acquireinfo through the callback - */ -napi_value AuthUser(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, AuthUser"); - return userAuthImpl->AuthUser(env, info); -} - -/** - * @brief Cancel authentication - * - * @param env - * @param info - * @return napi_value success or fail - */ -napi_value CancelAuth(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, CancelAuth"); - return userAuthImpl->CancelAuth(env, info); -} - -/** - * @brief Napi initialization - * - * @param env - * @param exports - */ -void Init(napi_env env, napi_value exports) -{ - napi_status status; - napi_property_descriptor exportFuncs[] = { - DECLARE_NAPI_FUNCTION("constructor", UserAuth::Constructor), - }; - status = napi_define_properties(env, exports, sizeof(exportFuncs) / sizeof(*exportFuncs), exportFuncs); - if (status != napi_ok) { - HILOG_ERROR("napi_define_properties faild"); - } -} - -napi_value Constructor(napi_env env, napi_callback_info info) -{ - napi_value thisVar = nullptr; - napi_value userAuth = nullptr; - NAPI_CALL(env, napi_new_instance(env, GetCtor(env), 0, nullptr, &userAuth)); - NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); - return userAuth; -} - -napi_value GetCtor(napi_env env) -{ - napi_value cons = nullptr; - napi_property_descriptor clzDes[] = { - DECLARE_NAPI_FUNCTION("getVersion", UserAuth::GetVersion), - DECLARE_NAPI_FUNCTION("getAvailabeStatus", UserAuth::GetAvailabeStatus), - DECLARE_NAPI_FUNCTION("getProperty", UserAuth::GetProperty), - DECLARE_NAPI_FUNCTION("setProperty", UserAuth::SetProperty), - DECLARE_NAPI_FUNCTION("auth", UserAuth::Auth), - DECLARE_NAPI_FUNCTION("authUser", UserAuth::AuthUser), - DECLARE_NAPI_FUNCTION("cancelAuth", UserAuth::CancelAuth), - }; - NAPI_CALL(env, napi_define_class(env, "UserAuth", NAPI_AUTO_LENGTH, UserAuthServiceConstructor, nullptr, - sizeof(clzDes) / sizeof(napi_property_descriptor), clzDes, &cons)); - return cons; -} -} // namespace UserAuth -} // namespace UserIAM -} // namespace OHOS +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "user_auth_helper.h" + +#include "auth_hilog_wrapper.h" +#include "user_auth_impl.h" + +namespace OHOS { +namespace UserIAM { +namespace UserAuth { +/** + * @brief Instance passed to context + * + * @param env + * @param info + * @return napi_value Instance + */ +napi_value UserAuthServiceConstructor(napi_env env, napi_callback_info info) +{ + std::shared_ptr userAuthImpl; + userAuthImpl.reset(new UserAuthImpl()); + napi_value thisVar = nullptr; + size_t argc = ARGS_ONE; + napi_value argv[ARGS_ONE] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr)); + NAPI_CALL(env, napi_wrap(env, thisVar, userAuthImpl.get(), + [](napi_env env, void *data, void *hint) { + UserAuthImpl *userAuthImpl = static_cast(data); + if (userAuthImpl != nullptr) { + delete userAuthImpl; + } + }, + nullptr, nullptr)); + // Pull up the face service process + return thisVar; +} + +/** + * @brief Instance passed to context + * + * @param env + * @param info + * @return napi_value Instance + */ +napi_value AuthenticatorServiceConstructor(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, start.", __func__); + std::shared_ptr authenticatorImpl; + authenticatorImpl.reset(new AuthenticatorImpl()); + napi_value thisVar = nullptr; + size_t argc = ARGS_ONE; + napi_value argv[ARGS_ONE] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr)); + NAPI_CALL(env, napi_wrap( + env, thisVar, authenticatorImpl.get(), + [](napi_env env, void *data, void *hint) { + AuthenticatorImpl *authenticatorImpl = static_cast(data); + if (authenticatorImpl != nullptr) { + delete authenticatorImpl; + } + }, + nullptr, nullptr)); + // Pull up the face service process + return thisVar; +} + +/** + * @brief Get the Version object + * + * @param env + * @param info + * @return napi_value Specific version number results + */ +napi_value GetVersion(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, GetVersion"); + return userAuthImpl->GetVersion(env, info); +} + +/** + * @brief Get the Availabe Status object + * + * @param env + * @param info + * @return napi_value Verify that the certification capability is available + */ +napi_value GetAvailabeStatus(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, getAvailabeStatus"); + return userAuthImpl->GetAvailabeStatus(env, info); +} + +/** + * @brief Get the Property object + * + * @param env + * @param info + * @return napi_value It supports querying subclasses / remaining authentication times / freezing time + */ +napi_value GetProperty(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, GetProperty"); + return userAuthImpl->GetProperty(env, info); +} + +/** + * @brief Set the Property object + * + * @param env + * @param info + * @return napi_value Set properties: can be used to initialize algorithms + */ +napi_value SetProperty(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, SetProperty"); + return userAuthImpl->SetProperty(env, info); +} + +/** + * @brief user authentication + * + * @param env + * @param info + * @return napi_value Enter the challenge value, authentication method, trust level and callback, and return the result + * and acquireinfo through the callback + */ +napi_value Auth(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, Auth"); + return userAuthImpl->Auth(env, info); +} + +/** + * @brief user authentication + * + * @param env + * @param info + * @return napi_value Pass in the user ID, challenge value, authentication method, trust level and callback, and return + * the result acquireinfo through the callback + */ +napi_value AuthUser(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, AuthUser"); + return userAuthImpl->AuthUser(env, info); +} + +/** + * @brief Cancel authentication + * + * @param env + * @param info + * @return napi_value success or fail + */ +napi_value CancelAuth(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, CancelAuth"); + return userAuthImpl->CancelAuth(env, info); +} + +napi_value Execute(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, start.", __func__); + napi_value thisVar = nullptr; + size_t argcAsync = ARGS_THREE; + napi_value args[ARGS_MAX_COUNT] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); + AuthenticatorImpl *authenticatorImpl = nullptr; + NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); + HILOG_INFO("UserAuthHelper, CancelAuth"); + return authenticatorImpl->Execute(env, info); +} + +napi_value Cancel(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, start.", __func__); + 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)); + AuthenticatorImpl *authenticatorImpl = nullptr; + NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); + HILOG_INFO("UserAuthHelper, CancelAuth"); + return authenticatorImpl->Cancel(env, info); +} + +napi_value CheckAvailability(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, start.", __func__); + 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)); + AuthenticatorImpl *authenticatorImpl = nullptr; + NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); + HILOG_INFO("UserAuthHelper, CancelAuth"); + return authenticatorImpl->CheckAvailability(env, info); +} + +napi_value On(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, start.", __func__); + 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)); + AuthenticatorImpl *authenticatorImpl = nullptr; + NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); + HILOG_INFO("UserAuthHelper, CancelAuth"); + return authenticatorImpl->On(env, info); +} + +napi_value Off(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, start.", __func__); + 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)); + AuthenticatorImpl *authenticatorImpl = nullptr; + NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); + HILOG_INFO("UserAuthHelper, CancelAuth"); + return authenticatorImpl->Off(env, info); +} +/** + * @brief Napi initialization + * + * @param env + * @param exports + */ +void Init(napi_env env, napi_value exports) +{ + napi_status status; + napi_property_descriptor exportFuncs[] = { + DECLARE_NAPI_FUNCTION("constructor", UserAuth::Constructor), + }; + status = napi_define_properties(env, exports, sizeof(exportFuncs) / sizeof(*exportFuncs), exportFuncs); + if (status != napi_ok) { + HILOG_ERROR("napi_define_properties faild"); + } +} + +napi_value Constructor(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + napi_value userAuth = nullptr; + NAPI_CALL(env, napi_new_instance(env, GetCtor(env), 0, nullptr, &userAuth)); + NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); + return userAuth; +} + +napi_value GetAuthenticator(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, start.", __func__); + napi_value thisVar = nullptr; + napi_value authenticator = nullptr; + NAPI_CALL(env, napi_new_instance(env, GetCtor_API(env), 0, nullptr, &authenticator)); + NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); + return authenticator; +} + +napi_value GetCtor(napi_env env) +{ + napi_value cons = nullptr; + napi_property_descriptor clzDes[] = { + DECLARE_NAPI_FUNCTION("getVersion", UserAuth::GetVersion), + DECLARE_NAPI_FUNCTION("getAvailabeStatus", UserAuth::GetAvailabeStatus), + DECLARE_NAPI_FUNCTION("getProperty", UserAuth::GetProperty), + DECLARE_NAPI_FUNCTION("setProperty", UserAuth::SetProperty), + DECLARE_NAPI_FUNCTION("auth", UserAuth::Auth), + DECLARE_NAPI_FUNCTION("authUser", UserAuth::AuthUser), + DECLARE_NAPI_FUNCTION("cancelAuth", UserAuth::CancelAuth), + }; + NAPI_CALL(env, napi_define_class(env, "UserAuth", NAPI_AUTO_LENGTH, UserAuthServiceConstructor, nullptr, + sizeof(clzDes) / sizeof(napi_property_descriptor), clzDes, &cons)); + return cons; +} + +napi_value GetCtor_API(napi_env env) +{ + HILOG_INFO("%{public}s, start.", __func__); + napi_value cons = nullptr; + napi_property_descriptor clzDes[] = { + DECLARE_NAPI_FUNCTION("execute", UserAuth::Execute), + DECLARE_NAPI_FUNCTION("cancel", UserAuth::Cancel), + DECLARE_NAPI_FUNCTION("checkAvailability", UserAuth::CheckAvailability), + DECLARE_NAPI_FUNCTION("on", UserAuth::On), + DECLARE_NAPI_FUNCTION("off", UserAuth::Off), + }; + NAPI_CALL(env, napi_define_class(env, "Authenticator", NAPI_AUTO_LENGTH, AuthenticatorServiceConstructor, nullptr, + sizeof(clzDes) / sizeof(napi_property_descriptor), clzDes, &cons)); + return cons; +} +} // namespace UserAuth +} // namespace UserIAM +} // namespace OHOS diff --git a/interfaces/innerkits/napi/src/user_auth_impl.cpp b/interfaces/innerkits/napi/src/user_auth_impl.cpp index d1f54dcf7..92592fd57 100755 --- a/interfaces/innerkits/napi/src/user_auth_impl.cpp +++ b/interfaces/innerkits/napi/src/user_auth_impl.cpp @@ -1,509 +1,746 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "user_auth_impl.h" - -#include "user_auth.h" -#include "userauth_callback.h" -#include "userauth_info.h" - -#include "auth_hilog_wrapper.h" -#include "authapi_callback.h" - -namespace OHOS { -namespace UserIAM { -namespace UserAuth { -UserAuthImpl::UserAuthImpl() -{ -} - -UserAuthImpl::~UserAuthImpl() -{ -} - -napi_value UserAuthImpl::GetVersion(napi_env env, napi_callback_info info) -{ - int32_t result = UserAuth::GetInstance().GetVersion(); - HILOG_INFO("GetVersion result = %{public}d ", result); - napi_value version = 0; - NAPI_CALL(env, napi_create_int32(env, result, &version)); - return version; -} - -napi_value UserAuthImpl::GetAvailabeStatus(napi_env env, napi_callback_info info) -{ - napi_value argv[ARGS_MAX_COUNT] = {nullptr}; - size_t argc = ARGS_MAX_COUNT; - NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); - if (argc != ARGS_TWO) { - HILOG_ERROR("%{public}s, parms error.", __func__); - return nullptr; - } - int type = authBuild.NapiGetValueInt(env, argv[PARAM0]); - if (type == GET_VALUE_ERROR) { - HILOG_ERROR("%{public}s, argv[PARAM0] error.", __func__); - return nullptr; - } - int level = authBuild.NapiGetValueInt(env, argv[PARAM1]); - if (level == GET_VALUE_ERROR) { - HILOG_ERROR("%{public}s, argv[PARAM1] error.", __func__); - return nullptr; - } - AuthType authType = AuthType(type); - AuthTurstLevel authTurstLevel = AuthTurstLevel(level); - int32_t result = UserAuth::GetInstance().GetAvailableStatus(authType, authTurstLevel); - HILOG_INFO("GetAvailabeStatus result = %{public}d", result); - napi_value ret = 0; - NAPI_CALL(env, napi_create_int32(env, result, &ret)); - return ret; -} - -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; - 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, 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; - napi_value args[ARGS_MAX_COUNT] = {nullptr}; - NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr)); - if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { - HILOG_ERROR("%{public}s, Wrong argument count.", __func__); - return nullptr; - } - if (argcAsync > PARAM1) { - napi_valuetype valuetype = napi_undefined; - napi_typeof(env, args[PARAM1], &valuetype); - if (valuetype == napi_function) { - 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 = nullptr; - if (argcAsync > argcPromise) { - ret = GetPropertyAsync(env, asyncHolder); - } else { - ret = GetPropertyPromise(env, asyncHolder); - } - HILOG_INFO("%{public}s,end.", __func__); - return ret; -} - -void UserAuthImpl::GetPropertyExecute(napi_env env, void *data) -{ - HILOG_INFO("GetPropertyExecute, worker pool thread execute."); - 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"); - GetPropApiCallback *object = new GetPropApiCallback(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"); - 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"); - 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, AsyncHolder *asyncHolder) -{ - HILOG_INFO("%{public}s, asyncCallback.", __func__); - 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 *)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, AsyncHolder *asyncHolder) -{ - HILOG_INFO("%{public}s, promise.", __func__); - 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; - napi_value promise = nullptr; - 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 *)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; - 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, 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; - napi_value args[ARGS_MAX_COUNT] = {nullptr}; - NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr)); - if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { - HILOG_ERROR("%{public}s, Wrong argument count.", __func__); - return nullptr; - } - if (argcAsync > PARAM1) { - napi_valuetype valuetype = napi_undefined; - napi_typeof(env, args[PARAM1], &valuetype); - if (valuetype == napi_function) { - NAPI_CALL(env, napi_create_reference(env, args[PARAM1], 1, &(setPropertyInfo->callBackInfo.callBack))); - } - } - - if (authBuild.NapiTypeObject(env, args[PARAM0])) { - Napi_SetPropertyRequest request = authBuild.SetPropertyRequestBuild(env, args[0]); - setPropertyInfo->authType = request.authType_; - setPropertyInfo->key = request.key_; - setPropertyInfo->setInfo = request.setInfo_; - } - - napi_value ret = 0; - if (argcAsync > argcPromise) { - ret = SetPropertyAsync(env, asyncHolder); - } else { - ret = SetPropertyPromise(env, asyncHolder); - } - HILOG_INFO("%{public}s,end.", __func__); - return ret; -} - -void UserAuthImpl::SetPropertyExecute(napi_env env, void *data) -{ - HILOG_INFO("setPropertyExecute, worker pool thread execute."); - 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; - SetPropApiCallback *object = new SetPropApiCallback(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"); - 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"); - 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, AsyncHolder *asyncHolder) -{ - HILOG_INFO("%{public}s, asyncCallback.", __func__); - 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 *)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, AsyncHolder *asyncHolder) -{ - HILOG_INFO("%{public}s, promise.", __func__); - 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 = 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 *)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::BuildAuthInfo(napi_env env, AuthInfo *authInfo) -{ - 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}; - NAPI_CALL(env, napi_get_cb_info(env, authInfo->info, &argc, argv, nullptr, nullptr)); - if (argc != ARGS_FOUR) { - HILOG_ERROR("%{public}s, parms error.", __func__); - return nullptr; - } - authInfo->challenge = authBuild.GetUint8ArrayTo64(env, argv[0]); - - if (authBuild.NapiTypeNumber(env, argv[PARAM1])) { - int64_t type; - NAPI_CALL(env, napi_get_value_int64(env, argv[PARAM1], &type)); - authInfo->authType = type; - } - - if (authBuild.NapiTypeNumber(env, argv[PARAM2])) { - int64_t level; - NAPI_CALL(env, napi_get_value_int64(env, argv[PARAM2], &level)); - authInfo->authTrustLevel = level; - } - - if (authBuild.NapiTypeObject(env, argv[PARAM3])) { - authInfo->jsFunction = argv[PARAM3]; - NAPI_CALL(env, napi_get_named_property(env, argv[PARAM3], "onResult", &authInfo->onResultCallBack)); - NAPI_CALL(env, napi_create_reference(env, authInfo->onResultCallBack, PARAM1, &authInfo->onResult)); - 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 result; -} - -napi_value UserAuthImpl::Auth(napi_env env, napi_callback_info info) -{ - HILOG_INFO("%{public}s, start", __func__); - AuthInfo *authInfo = new (std::nothrow) AuthInfo(); - if (authInfo == nullptr) { - 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(authInfo); - std::shared_ptr callback; - callback.reset(object); - uint64_t result = UserAuth::GetInstance().Auth( - authInfo->challenge, AuthType(authInfo->authType), AuthTurstLevel(authInfo->authTrustLevel), callback); - HILOG_INFO("UserAuth::GetInstance().Auth.result = %{public}llu", result); - napi_value key = authBuild.Uint64ToUint8Array(env, result); - HILOG_INFO("%{public}s, end.", __func__); - return key; -} - -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)); - if (argc != ARGS_FIVE) { - HILOG_ERROR("%{public}s, parms error.", __func__); - return nullptr; - } - if (authBuild.NapiTypeNumber(env, argv[PARAM0])) { - int32_t id = 0; - NAPI_CALL(env, napi_get_value_int32(env, argv[PARAM0], &id)); - userInfo->userId = id; - } - userInfo->challenge = authBuild.GetUint8ArrayTo64(env, argv[PARAM1]); - if (authBuild.NapiTypeNumber(env, argv[PARAM2])) { - int32_t type = 0; - napi_get_value_int32(env, argv[PARAM2], &type); - userInfo->authType = type; - } - if (authBuild.NapiTypeNumber(env, argv[PARAM3])) { - int32_t level = 0; - NAPI_CALL(env, napi_get_value_int32(env, argv[PARAM3], &level)); - userInfo->authTrustLevel = level; - } - if (authBuild.NapiTypeObject(env, argv[PARAM4])) { - HILOG_INFO("AuthUser is Object"); - userInfo->jsFunction = argv[PARAM4]; - NAPI_CALL(env, napi_get_named_property(env, argv[PARAM4], "onResult", &userInfo->onResultCallBack)); - NAPI_CALL(env, napi_create_reference(env, userInfo->onResultCallBack, PARAM1, &userInfo->onResult)); - 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 result; -} - -napi_value UserAuthImpl::AuthUserWrap(napi_env env, AuthUserInfo *userInfo) -{ - HILOG_INFO("%{public}s, start.", __func__); - AuthApiCallback *object = new AuthApiCallback(userInfo); - std::shared_ptr callback; - callback.reset(object); - uint64_t result = UserAuth::GetInstance().AuthUser(userInfo->userId, userInfo->challenge, - AuthType(userInfo->authType), AuthTurstLevel(userInfo->authTrustLevel), callback); - HILOG_INFO("UserAuth::GetInstance().AuthUser. result = %{public}llu", result); - napi_value key = authBuild.Uint64ToUint8Array(env, result); - HILOG_INFO("%{public}s, end.", __func__); - return key; -} - -napi_value UserAuthImpl::CancelAuth(napi_env env, napi_callback_info info) -{ - size_t argc = ARGS_MAX_COUNT; - napi_value argv[ARGS_MAX_COUNT] = {nullptr}; - NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); - - uint64_t contextId = authBuild.GetUint8ArrayTo64(env, argv[0]); - HILOG_INFO("CancelAuth contextId = %{public}llu", contextId); - if (contextId == 0) { - return nullptr; - } - int32_t result = UserAuth::GetInstance().CancelAuth(contextId); - HILOG_INFO("CancelAuth result = %{public}d", result); - napi_value key = 0; - NAPI_CALL(env, napi_create_int32(env, result, &key)); - return key; -} -} // namespace UserAuth -} // namespace UserIAM -} // namespace OHOS +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "user_auth_impl.h" + +#include "user_auth.h" +#include "userauth_callback.h" +#include "userauth_info.h" + +#include "auth_hilog_wrapper.h" +#include "authapi_callback.h" + +namespace OHOS { +namespace UserIAM { +namespace UserAuth { +UserAuthImpl::UserAuthImpl() +{ +} + +UserAuthImpl::~UserAuthImpl() +{ +} + +AuthenticatorImpl::AuthenticatorImpl() +{ +} + +AuthenticatorImpl::~AuthenticatorImpl() +{ +} + +napi_value UserAuthImpl::GetVersion(napi_env env, napi_callback_info info) +{ + int32_t result = UserAuth::GetInstance().GetVersion(); + HILOG_INFO("GetVersion result = %{public}d ", result); + napi_value version = 0; + NAPI_CALL(env, napi_create_int32(env, result, &version)); + return version; +} + +napi_value UserAuthImpl::GetAvailabeStatus(napi_env env, napi_callback_info info) +{ + napi_value argv[ARGS_MAX_COUNT] = {nullptr}; + size_t argc = ARGS_MAX_COUNT; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + if (argc != ARGS_TWO) { + HILOG_ERROR("%{public}s, parms error.", __func__); + return nullptr; + } + int type = authBuild.NapiGetValueInt(env, argv[PARAM0]); + if (type == GET_VALUE_ERROR) { + HILOG_ERROR("%{public}s, argv[PARAM0] error.", __func__); + return nullptr; + } + int level = authBuild.NapiGetValueInt(env, argv[PARAM1]); + if (level == GET_VALUE_ERROR) { + HILOG_ERROR("%{public}s, argv[PARAM1] error.", __func__); + return nullptr; + } + AuthType authType = AuthType(type); + AuthTurstLevel authTurstLevel = AuthTurstLevel(level); + int32_t result = UserAuth::GetInstance().GetAvailableStatus(authType, authTurstLevel); + HILOG_INFO("GetAvailabeStatus result = %{public}d", result); + napi_value ret = 0; + NAPI_CALL(env, napi_create_int32(env, result, &ret)); + return ret; +} + +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; + 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, 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; + napi_value args[ARGS_MAX_COUNT] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr)); + if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { + HILOG_ERROR("%{public}s, Wrong argument count.", __func__); + return nullptr; + } + if (argcAsync > PARAM1) { + napi_valuetype valuetype = napi_undefined; + napi_typeof(env, args[PARAM1], &valuetype); + if (valuetype == napi_function) { + 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 = nullptr; + if (argcAsync > argcPromise) { + ret = GetPropertyAsync(env, asyncHolder); + } else { + ret = GetPropertyPromise(env, asyncHolder); + } + HILOG_INFO("%{public}s,end.", __func__); + return ret; +} + +void UserAuthImpl::GetPropertyExecute(napi_env env, void *data) +{ + HILOG_INFO("GetPropertyExecute, worker pool thread execute."); + 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"); + GetPropApiCallback *object = new GetPropApiCallback(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"); + 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"); + 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, AsyncHolder *asyncHolder) +{ + HILOG_INFO("%{public}s, asyncCallback.", __func__); + 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 *)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, AsyncHolder *asyncHolder) +{ + HILOG_INFO("%{public}s, promise.", __func__); + 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; + napi_value promise = nullptr; + 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 *)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; + 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, 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; + napi_value args[ARGS_MAX_COUNT] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr)); + if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { + HILOG_ERROR("%{public}s, Wrong argument count.", __func__); + return nullptr; + } + if (argcAsync > PARAM1) { + napi_valuetype valuetype = napi_undefined; + napi_typeof(env, args[PARAM1], &valuetype); + if (valuetype == napi_function) { + NAPI_CALL(env, napi_create_reference(env, args[PARAM1], 1, &(setPropertyInfo->callBackInfo.callBack))); + } + } + + if (authBuild.NapiTypeObject(env, args[PARAM0])) { + Napi_SetPropertyRequest request = authBuild.SetPropertyRequestBuild(env, args[0]); + setPropertyInfo->authType = request.authType_; + setPropertyInfo->key = request.key_; + setPropertyInfo->setInfo = request.setInfo_; + } + + napi_value ret = 0; + if (argcAsync > argcPromise) { + ret = SetPropertyAsync(env, asyncHolder); + } else { + ret = SetPropertyPromise(env, asyncHolder); + } + HILOG_INFO("%{public}s,end.", __func__); + return ret; +} + +void UserAuthImpl::SetPropertyExecute(napi_env env, void *data) +{ + HILOG_INFO("setPropertyExecute, worker pool thread execute."); + 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; + SetPropApiCallback *object = new SetPropApiCallback(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"); + 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"); + 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, AsyncHolder *asyncHolder) +{ + HILOG_INFO("%{public}s, asyncCallback.", __func__); + 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 *)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, AsyncHolder *asyncHolder) +{ + HILOG_INFO("%{public}s, promise.", __func__); + 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 = 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 *)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::BuildAuthInfo(napi_env env, AuthInfo *authInfo) +{ + 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}; + NAPI_CALL(env, napi_get_cb_info(env, authInfo->info, &argc, argv, nullptr, nullptr)); + if (argc != ARGS_FOUR) { + HILOG_ERROR("%{public}s, parms error.", __func__); + return nullptr; + } + authInfo->challenge = authBuild.GetUint8ArrayTo64(env, argv[0]); + + if (authBuild.NapiTypeNumber(env, argv[PARAM1])) { + int64_t type; + NAPI_CALL(env, napi_get_value_int64(env, argv[PARAM1], &type)); + authInfo->authType = type; + } + + if (authBuild.NapiTypeNumber(env, argv[PARAM2])) { + int64_t level; + NAPI_CALL(env, napi_get_value_int64(env, argv[PARAM2], &level)); + authInfo->authTrustLevel = level; + } + + if (authBuild.NapiTypeObject(env, argv[PARAM3])) { + authInfo->jsFunction = argv[PARAM3]; + NAPI_CALL(env, napi_get_named_property(env, argv[PARAM3], "onResult", &authInfo->onResultCallBack)); + NAPI_CALL(env, napi_create_reference(env, authInfo->onResultCallBack, PARAM1, &authInfo->onResult)); + 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 result; +} + +napi_value UserAuthImpl::Auth(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, start", __func__); + AuthInfo *authInfo = new (std::nothrow) AuthInfo(); + if (authInfo == nullptr) { + 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(authInfo); + std::shared_ptr callback; + callback.reset(object); + uint64_t result = UserAuth::GetInstance().Auth( + authInfo->challenge, AuthType(authInfo->authType), AuthTurstLevel(authInfo->authTrustLevel), callback); + HILOG_INFO("UserAuth::GetInstance().Auth.result = %{public}llu", result); + napi_value key = authBuild.Uint64ToUint8Array(env, result); + HILOG_INFO("%{public}s, end.", __func__); + return key; +} + +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)); + if (argc != ARGS_FIVE) { + HILOG_ERROR("%{public}s, parms error.", __func__); + return nullptr; + } + if (authBuild.NapiTypeNumber(env, argv[PARAM0])) { + int32_t id = 0; + NAPI_CALL(env, napi_get_value_int32(env, argv[PARAM0], &id)); + userInfo->userId = id; + } + userInfo->challenge = authBuild.GetUint8ArrayTo64(env, argv[PARAM1]); + if (authBuild.NapiTypeNumber(env, argv[PARAM2])) { + int32_t type = 0; + napi_get_value_int32(env, argv[PARAM2], &type); + userInfo->authType = type; + } + if (authBuild.NapiTypeNumber(env, argv[PARAM3])) { + int32_t level = 0; + NAPI_CALL(env, napi_get_value_int32(env, argv[PARAM3], &level)); + userInfo->authTrustLevel = level; + } + if (authBuild.NapiTypeObject(env, argv[PARAM4])) { + HILOG_INFO("AuthUser is Object"); + userInfo->jsFunction = argv[PARAM4]; + NAPI_CALL(env, napi_get_named_property(env, argv[PARAM4], "onResult", &userInfo->onResultCallBack)); + NAPI_CALL(env, napi_create_reference(env, userInfo->onResultCallBack, PARAM1, &userInfo->onResult)); + 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 result; +} + +napi_value UserAuthImpl::AuthUserWrap(napi_env env, AuthUserInfo *userInfo) +{ + HILOG_INFO("%{public}s, start.", __func__); + AuthApiCallback *object = new AuthApiCallback(userInfo); + std::shared_ptr callback; + callback.reset(object); + uint64_t result = UserAuth::GetInstance().AuthUser(userInfo->userId, userInfo->challenge, + AuthType(userInfo->authType), AuthTurstLevel(userInfo->authTrustLevel), callback); + HILOG_INFO("UserAuth::GetInstance().AuthUser. result = %{public}llu", result); + napi_value key = authBuild.Uint64ToUint8Array(env, result); + HILOG_INFO("%{public}s, end.", __func__); + return key; +} + +napi_value UserAuthImpl::CancelAuth(napi_env env, napi_callback_info info) +{ + size_t argc = ARGS_MAX_COUNT; + napi_value argv[ARGS_MAX_COUNT] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + uint64_t contextId = authBuild.GetUint8ArrayTo64(env, argv[0]); + HILOG_INFO("CancelAuth contextId = %{public}llu", contextId); + if (contextId == 0) { + return nullptr; + } + int32_t result = UserAuth::GetInstance().CancelAuth(contextId); + HILOG_INFO("CancelAuth result = %{public}d", result); + napi_value key = 0; + NAPI_CALL(env, napi_create_int32(env, result, &key)); + return key; +} + +napi_value AuthenticatorImpl::Execute(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, start.", __func__); + ExecuteInfo *executeInfo = new (std::nothrow) ExecuteInfo(); + executeInfo->env = env; + return ExecuteWrap(env, info, executeInfo); +} + +napi_value AuthenticatorImpl::ExecuteWrap(napi_env env, napi_callback_info info, ExecuteInfo* executeInfo) +{ + HILOG_INFO("%{public}s, start.", __func__); + 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)); + callbackIndex = argc - 1; + napi_valuetype valuetype; + NAPI_CALL(env, napi_typeof(env, argv[callbackIndex], &valuetype)); + if (valuetype == napi_function) { + NAPI_CALL(env, napi_create_reference(env, argv[callbackIndex], 1, &executeInfo->callbackRef)); + return ExecuteAsyncallback(env, argv, executeInfo); + } else { + NAPI_CALL(env,napi_create_promise(env, &executeInfo->deferred, &executeInfo->promise)); + return ExecutePromise(env, argv, executeInfo); + } +} + +napi_value AuthenticatorImpl::ExecuteAsyncallback(napi_env env, napi_value* argv, ExecuteInfo* executeInfo) +{ + HILOG_INFO("%{public}s, start.", __func__); + napi_valuetype valuetype; + NAPI_CALL(env, napi_typeof(env, argv[0], &valuetype)); + if (valuetype == napi_string) { + char *type = nullptr; + size_t typelen = 0; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], nullptr, 0, &typelen)); + if (typelen > 0) { + type = new char[typelen + 1]; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], type, typelen + 1, &typelen)); + executeInfo->type = type; + delete[] type; + } + } + NAPI_CALL(env, napi_typeof(env, argv[1], &valuetype)); + if (valuetype == napi_string) { + char *type1 = nullptr; + size_t typelen1 = 0; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[1], nullptr, 0, &typelen1)); + if (typelen1 > 0) { + type1 = new char[typelen1 + 1]; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[1], type1, typelen1 + 1, &typelen1)); + executeInfo->level = type1; + delete[] type1; + } + } + 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, + [](napi_env env, void *data) { + ExecuteInfo *executeInfo = (ExecuteInfo *)data; + std::shared_ptr userauthAPI7callback = std::make_shared(executeInfo); + API7UserAuth::UserAuthAPI7::GetAuthenticator().Execute(executeInfo->type, executeInfo->level, userauthAPI7callback); + }, + [](napi_env env, napi_status status, void *data) { + ExecuteInfo *executeInfo = (ExecuteInfo *)data; + napi_delete_async_work(env, executeInfo->asyncWork); + }, + (void *)executeInfo, &executeInfo->asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, executeInfo->asyncWork)); + napi_value result = RESULTVAR; + NAPI_CALL(env, napi_get_null(env, &result)); + return result; +} + +napi_value AuthenticatorImpl::ExecutePromise(napi_env env, napi_value* argv, ExecuteInfo* executeInfo) +{ + HILOG_INFO("%{public}s, start.", __func__); + napi_valuetype valuetype; + NAPI_CALL(env, napi_typeof(env, argv[0], &valuetype)); + if (valuetype == napi_string) { + char *type = nullptr; + size_t typelen = 0; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], nullptr, 0, &typelen)); + if (typelen > 0) { + type = new char[typelen + 1]; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], type, typelen + 1, &typelen)); + executeInfo->type = type; + delete[] type; + } + } + NAPI_CALL(env, napi_typeof(env, argv[1], &valuetype)); + if (valuetype == napi_string) { + char *type1 = nullptr; + size_t typelen1 = 0; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[1], nullptr, 0, &typelen1)); + if (typelen1 > 0) { + type1 = new char[typelen1 + 1]; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[1], type1, typelen1 + 1, &typelen1)); + executeInfo->level = type1; + delete[] type1; + } + } + 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, + [](napi_env env, void *data) { + ExecuteInfo *executeInfo = (ExecuteInfo *)data; + std::shared_ptr userauthAPI7callback = std::make_shared(executeInfo); + API7UserAuth::UserAuthAPI7::GetAuthenticator().Execute(executeInfo->type, executeInfo->level, userauthAPI7callback); + }, + [](napi_env env, napi_status status, void *data) { + ExecuteInfo *executeInfo = (ExecuteInfo *)data; + napi_delete_async_work(env, executeInfo->asyncWork); + }, + (void *)executeInfo, &executeInfo->asyncWork)); + NAPI_CALL(env, napi_queue_async_work(env, executeInfo->asyncWork)); + return executeInfo->promise; +} + +napi_value AuthenticatorImpl::Cancel(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, start.", __func__); + napi_value ret; + int32_t result = API7UserAuth::UserAuthAPI7::GetAuthenticator().Cancel(); + NAPI_CALL(env,napi_create_int32(env, result, &ret)); + return ret; +} + +napi_value AuthenticatorImpl::CheckAvailability(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, start.", __func__); + napi_value ret; + int32_t result = 0; + size_t argc = PARAM2; + napi_value argv[PARAM2] = {0}; + CheckAvailabilityInfo *checkAvailabilityInfo = new (std::nothrow) CheckAvailabilityInfo(); + checkAvailabilityInfo->env = env; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + napi_valuetype valuetype; + NAPI_CALL(env, napi_typeof(env, argv[0], &valuetype)); + if (valuetype == napi_string) { + char *type = nullptr; + size_t typelen = 0; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], nullptr, 0, &typelen)); + if (typelen > 0) { + type = new char[typelen + 1]; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], type, typelen + 1, &typelen)); + checkAvailabilityInfo->type = type; + delete[] type; + } + } + NAPI_CALL(env, napi_typeof(env, argv[1], &valuetype)); + if (valuetype == napi_string) { + char *type1 = nullptr; + size_t typelen1 = 0; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[1], nullptr, 0, &typelen1)); + if (typelen1 > 0) { + type1 = new char[typelen1 + 1]; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[1], type1, typelen1 + 1, &typelen1)); + checkAvailabilityInfo->level = type1; + delete[] type1; + } + } + result = API7UserAuth::UserAuthAPI7::GetAuthenticator().CheckAvailability(checkAvailabilityInfo->type, checkAvailabilityInfo->level); + NAPI_CALL(env,napi_create_int32(env, result, &ret)); + return ret; + +} + +napi_value AuthenticatorImpl::On(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, start.", __func__); + size_t argc = PARAM2; + napi_value argv[PARAM2] = {0}; + FunctionOnAndOffInfo* functionOnAndOffInfo = new (std::nothrow) FunctionOnAndOffInfo(); + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + napi_valuetype valuetype; + NAPI_CALL(env, napi_typeof(env, argv[0], &valuetype)); + if (valuetype == napi_string) { + char *type = nullptr; + size_t typelen = 0; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], nullptr, 0, &typelen)); + if (typelen > 0) { + type = new char[typelen + 1]; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], type, typelen + 1, &typelen)); + functionOnAndOffInfo->tip = type; + delete[] type; + } + } + NAPI_CALL(env, napi_typeof(env, argv[1], &valuetype)); + if (valuetype == napi_function) { + NAPI_CALL(env, napi_create_reference(env, argv[1], 1, &functionOnAndOffInfo->callbackRef)); + } + std::shared_ptr userauthAPI7callback = std::make_shared(functionOnAndOffInfo); + API7UserAuth::UserAuthAPI7::GetAuthenticator().On(functionOnAndOffInfo->tip, userauthAPI7callback); + napi_value result = RESULTVAR; + NAPI_CALL(env, napi_get_null(env, &result)); + return result; +} + +napi_value AuthenticatorImpl::Off(napi_env env, napi_callback_info info) +{ + HILOG_INFO("%{public}s, start.", __func__); + size_t argc = PARAM2; + napi_value argv[PARAM2] = {0}; + FunctionOnAndOffInfo* functionOnAndOffInfo = new (std::nothrow) FunctionOnAndOffInfo(); + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + napi_valuetype valuetype; + NAPI_CALL(env, napi_typeof(env, argv[0], &valuetype)); + if (valuetype == napi_string) { + char *type = nullptr; + size_t typelen = 0; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], nullptr, 0, &typelen)); + if (typelen > 0) { + type = new char[typelen + 1]; + NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], type, typelen + 1, &typelen)); + functionOnAndOffInfo->tip = type; + delete[] type; + } + } + std::shared_ptr userauthAPI7callback = std::make_shared(functionOnAndOffInfo); + API7UserAuth::UserAuthAPI7::GetAuthenticator().Off(functionOnAndOffInfo->tip, userauthAPI7callback); + napi_value result = RESULTVAR; + NAPI_CALL(env, napi_get_null(env, &result)); + return result; +} +} // namespace UserAuth +} // namespace UserIAM +} // namespace OHOS diff --git a/interfaces/kits/napi/include/user_auth_helper_north.h b/interfaces/kits/napi/include/user_auth_helper_north.h index c6434c206..4f203d767 100755 --- a/interfaces/kits/napi/include/user_auth_helper_north.h +++ b/interfaces/kits/napi/include/user_auth_helper_north.h @@ -17,6 +17,7 @@ #include "napi/native_api.h" #include "napi/native_common.h" +#include "napi/native_node_api.h" namespace OHOS { namespace UserAuthNorth { -- Gitee From 5d12fba62ee2d98a90dc078edc4e4deee1228c21 Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Fri, 11 Feb 2022 18:49:00 +0800 Subject: [PATCH 12/19] [user_auth]fix code for napi constructor Signed-off-by: yanfang.gu --- interfaces/innerkits/napi/src/user_auth_helper.cpp | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/interfaces/innerkits/napi/src/user_auth_helper.cpp b/interfaces/innerkits/napi/src/user_auth_helper.cpp index 83188d8c6..5420550ea 100755 --- a/interfaces/innerkits/napi/src/user_auth_helper.cpp +++ b/interfaces/innerkits/napi/src/user_auth_helper.cpp @@ -287,11 +287,20 @@ 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::GetAuthenticator), }; status = napi_define_properties(env, exports, sizeof(exportFuncs) / sizeof(*exportFuncs), exportFuncs); if (status != napi_ok) { HILOG_ERROR("napi_define_properties faild"); } + status = napi_set_named_property(env, exports, "UserAuth", GetCtor(env)); + if (status != napi_ok) { + HILOG_ERROR("napi_set_named_property faild"); + } + status = napi_set_named_property(env, exports, "Authenticator", GetCtor_API(env)); + if (status != napi_ok) { + HILOG_ERROR("napi_set_named_property faild"); + } } napi_value Constructor(napi_env env, napi_callback_info info) -- Gitee From e968f54daf2ddac8bff17ab5dd758ddecf71772f Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Mon, 14 Feb 2022 15:16:27 +0800 Subject: [PATCH 13/19] [user_auth]code update for white-box 1.code update for napi review 2.code update for log out 3.code update for white-box 4.code update for review Signed-off-by: yanfang.gu --- bundle.json | 170 ++++++------ .../kitsimpl/src/iuserauth_api7_callback.cpp | 26 +- frameworks/kitsimpl/src/userauth.cpp | 2 +- frameworks/kitsimpl/src/userauth_api7.cpp | 62 +++-- .../kitsimpl/src/userauth_api7_datamgr.cpp | 1 - .../kitsimpl/src/userauth_async_stub.cpp | 6 +- frameworks/kitsimpl/src/userauth_proxy.cpp | 2 - interfaces/innerkits/napi/BUILD.gn | 1 - .../napi/include/auth_hilog_wrapper.h | 61 ----- .../innerkits/napi/include/user_auth_helper.h | 2 +- .../innerkits/napi/include/user_auth_impl.h | 9 +- interfaces/innerkits/napi/src/auth_build.cpp | 256 +++++++++--------- .../innerkits/napi/src/auth_native_module.cpp | 41 --- .../innerkits/napi/src/authapi_callback.cpp | 144 +++++----- .../innerkits/napi/src/result_convert.cpp | 30 +- .../innerkits/napi/src/user_auth_helper.cpp | 53 ++-- .../innerkits/napi/src/user_auth_impl.cpp | 223 +++++++-------- .../include/userauth_api7_hilog_wrapper.h | 72 ----- interfaces/kits/napi/BUILD.gn | 4 +- .../kits/napi/src/auth_native_module.cpp | 41 --- .../kits/napi/src/user_auth_helper_north.cpp | 27 +- services/src/userauth_adapter.cpp | 4 +- services/src/userauth_async_proxy.cpp | 6 +- services/src/userauth_excallback_impl.cpp | 6 +- services/src/userauth_service.cpp | 4 +- 25 files changed, 526 insertions(+), 727 deletions(-) delete mode 100755 interfaces/innerkits/napi/include/auth_hilog_wrapper.h delete mode 100755 interfaces/innerkits/napi/src/auth_native_module.cpp delete mode 100755 interfaces/innerkits/native/include/userauth_api7_hilog_wrapper.h delete mode 100755 interfaces/kits/napi/src/auth_native_module.cpp diff --git a/bundle.json b/bundle.json index c09601202..dc9f363e1 100644 --- a/bundle.json +++ b/bundle.json @@ -1,83 +1,87 @@ -{ - "name": "@openharmony/user_auth", - "version": "3.1.0", - "description": "User Authentication capability", - "homePage": "https://gitee.com/openharmony", - "author": {}, - "repository": "", - "license": "Apache License 2.0", - "publishAs": "code-segment", - "segment": { - "destPath" : "base/user_iam/user_auth" - }, - "dirs": {}, - "scripts": {}, - "component": { - "name": "user_auth", - "subsystem": "useriam", - "adapted_system_type": [ "standard" ], - "syscap": ["SystemCapability.UserIAM.UserAuth"], - "features": [], - "rom": "2400KB", - "ram": "1500KB", - "deps": { - "components": [ - "hiviewdfx_hilog_native", - "ipc", - "safwk", - "samgr_standard", - "hilog", - "auth_executor_mgr" - ], - "third_party": [ - "openssl", - "googletest" - ] - }, - "build": { - "sub_component": [ - "//base/user_iam/user_auth/sa_profile:userauth_sa_profile", - "//base/user_iam/user_auth/services:userauthservice", - "//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": { - "header_files": [ - "iuser_auth.h", - "iuserauth_callback.h", - "user_auth.h", - "userauth_async_stub.h", - "userauth_callback.h", - "userauth_info.h", - "userauth_proxy.h" - ], - "header_base": "//base/user_iam/user_auth/interfaces/innerkits/native/include" - } - }, - { - "type": "so", - "name": "//base/user_iam/user_auth/interfaces/innerkits/napi:userauth", - "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": [ - "//base/user_iam/user_auth/test:userauth_native_test" - ] - } - } - } +{ + "name": "@openharmony/user_auth", + "version": "3.1.0", + "description": "User Authentication capability", + "homePage": "https://gitee.com/openharmony", + "author": {}, + "repository": "", + "license": "Apache License 2.0", + "publishAs": "code-segment", + "segment": { + "destPath" : "base/user_iam/user_auth" + }, + "dirs": {}, + "scripts": {}, + "component": { + "name": "user_auth", + "subsystem": "useriam", + "adapted_system_type": [ "standard" ], + "syscap": ["SystemCapability.UserIAM.UserAuth"], + "features": [], + "rom": "2400KB", + "ram": "1500KB", + "deps": { + "components": [ + "hiviewdfx_hilog_native", + "ipc", + "safwk", + "samgr_standard", + "hilog", + "auth_executor_mgr" + ], + "third_party": [ + "openssl", + "googletest" + ] + }, + "build": { + "sub_component": [ + "//base/user_iam/user_auth/sa_profile:userauth_sa_profile", + "//base/user_iam/user_auth/services:userauthservice", + "//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": { + "header_files": [ + "iuser_auth.h", + "iuserauth_api7_callback.h", + "iuserauth_callback.h", + "user_auth.h", + "userauth_api7_callback.h", + "userauth_api7_datamgr.h", + "userauth_api7_info.h", + "userauth_api7.h", + "userauth_async_stub.h", + "userauth_callback.h", + "userauth_info.h", + "userauth_proxy.h" + ], + "header_base": "//base/user_iam/user_auth/interfaces/innerkits/native/include" + } + }, + { + "type": "so", + "name": "//base/user_iam/user_auth/interfaces/innerkits/napi:userauth", + "header": { + "header_files": [ + "auth_build.h", + "auth_common.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": [ + "//base/user_iam/user_auth/test:userauth_native_test" + ] + } + } + } diff --git a/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp b/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp index d39f7b723..250b604bd 100644 --- a/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp +++ b/frameworks/kitsimpl/src/iuserauth_api7_callback.cpp @@ -14,7 +14,7 @@ */ #include -#include "userauth_api7_hilog_wrapper.h" +#include "userauth_hilog_wrapper.h" #include "userauth_api7_datamgr.h" #include "userauth_api7_info.h" #include "iuserauth_api7_callback.h" @@ -64,37 +64,39 @@ IUserAuthAPI7Callback::IUserAuthAPI7Callback(std::shared_ptr(acquireInfo)) == 0) { - USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 g_convertTipInfo is 0"); + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAPI7 g_convertTipInfo is 0"); tipOfInfo = "other error"; } else { tipOfInfo = g_convertTipInfo[static_cast(acquireInfo)]; } callback_->TipCallback(tipInfo); - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 GetAPI7Tip is end"); + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 GetAPI7Tip is end"); } - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 onAcquireInfo is end"); + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 onAcquireInfo is end"); } void IUserAuthAPI7Callback::onResult(const int32_t result, const UserAuth::AuthResult extraInfo) { - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 onResult is start"); + using namespace UserAuth; + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 onResult is start"); AuthenticationResult authResult; UserAuthAPI7Datamgr::GetInstance().API7DeleteContextID(); callback_->API7OnResult(result); if (UserAuthAPI7Datamgr::GetInstance().GetAPI7Tip()) { - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 GetAPI7Tip is on"); + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 GetAPI7Tip is on"); API7UserAuth::Tip tipInfo; if (result != UserAuth::SUCCESS) { - USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 result is failed"); + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAPI7 result is failed"); tipInfo.errorCode = API7UserAuth::FAILED; tipInfo.tipInfo = "FAILED"; } else { @@ -103,16 +105,16 @@ void IUserAuthAPI7Callback::onResult(const int32_t result, const UserAuth::AuthR } tipInfo.tipEvent = API7UserAuth::RESULT; if (g_convertResult.count(static_cast(result)) == 0) { - USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 g_convertResult is 0"); + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAPI7 g_convertResult is 0"); authResult = static_cast(result); } else { authResult = g_convertResult[static_cast(result)]; } tipInfo.tipCode = authResult; callback_->TipCallback(tipInfo); - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 GetAPI7Tip is end"); + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 GetAPI7Tip is end"); } - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 onResult is end"); + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 onResult is end"); } } } diff --git a/frameworks/kitsimpl/src/userauth.cpp b/frameworks/kitsimpl/src/userauth.cpp index 388caf35a..88ad3c87b 100644 --- a/frameworks/kitsimpl/src/userauth.cpp +++ b/frameworks/kitsimpl/src/userauth.cpp @@ -128,7 +128,7 @@ void UserAuth::SetProperty(const SetPropertyRequest request, std::shared_ptronSetProperty(E_RET_NOSERVER); - return ; + return; } sptr asyncStub = new (std::nothrow) UserAuthAsyncStub(callback); if (asyncStub == nullptr) { diff --git a/frameworks/kitsimpl/src/userauth_api7.cpp b/frameworks/kitsimpl/src/userauth_api7.cpp index 89c44cd24..4744d64bc 100644 --- a/frameworks/kitsimpl/src/userauth_api7.cpp +++ b/frameworks/kitsimpl/src/userauth_api7.cpp @@ -17,7 +17,6 @@ #include "userauth_info.h" #include "user_auth.h" #include "userauth_hilog_wrapper.h" -#include "userauth_api7_hilog_wrapper.h" #include "userauth_api7_datamgr.h" #include "iuserauth_api7_callback.h" #include "userauth_api7.h" @@ -43,18 +42,19 @@ UserAuthAPI7 &UserAuthAPI7::GetAuthenticator() void UserAuthAPI7::Execute(std::string authtype, std::string trustLevel, std::shared_ptr callback) { - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 execute is start"); - UserAuth::AuthType exeAuthType; - UserAuth::AuthTurstLevel authTurstLevel; + using namespace UserAuth; + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 execute is start"); + AuthType exeAuthType; + AuthTurstLevel authTurstLevel; uint64_t contextID = 0; if (callback == nullptr) { - USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 execute callback is Null"); + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAPI7 execute callback is Null"); return; } if (g_convertAuthType.count(authtype) == 0) { - USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 execute g_convertAuthType is 0"); + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAPI7 execute g_convertAuthType is 0"); callback->API7OnResult(NO_SUPPORT); return; } else { @@ -62,90 +62,94 @@ void UserAuthAPI7::Execute(std::string authtype, std::string trustLevel, std::sh } if (g_convertAuthTurstLevel.count(trustLevel) == 0) { - USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 execute g_convertAuthTurstLevel is 0"); + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAPI7 execute g_convertAuthTurstLevel is 0"); callback->API7OnResult(NO_SUPPORT); return; } else { authTurstLevel = g_convertAuthTurstLevel[trustLevel]; } - std::shared_ptr asyncStub = std::make_shared(callback); + std::shared_ptr asyncStub = std::make_shared(callback); if (asyncStub == nullptr) { - USERAUTH_API7_HILOGE(MODULE_API7, "UserAuthCallback failed, IUserAuthAPI7Callback is nullptr"); + USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthCallback failed, IUserAuthAPI7Callback is nullptr"); return; } - contextID = UserAuth::UserAuth::GetInstance().Auth(CHALLENGE_INIT, exeAuthType, authTurstLevel, asyncStub); + contextID = UserIAM::UserAuth::UserAuth::GetInstance().Auth(CHALLENGE_INIT, exeAuthType, authTurstLevel, asyncStub); if (contextID != CONTEXTID_INIT) { UserAuthAPI7Datamgr::GetInstance().API7AddContextID(contextID); } - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 execute is end"); + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 execute is end"); } int32_t UserAuthAPI7::Cancel() { - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 cancel is start"); + using namespace UserAuth; + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 cancel is start"); uint64_t contextID = 0; int32_t ret = API7UserAuth::GENERAL_ERROR; UserAuthAPI7Datamgr::GetInstance().API7GetContextID(contextID); if (contextID != CONTEXTID_INIT) { - ret = UserAuth::UserAuth::GetInstance().CancelAuth(contextID); + ret = UserIAM::UserAuth::UserAuth::GetInstance().CancelAuth(contextID); if (ret != API7UserAuth::SUCCESS) { - USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 cancel is error"); + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAPI7 cancel is error"); } UserAuthAPI7Datamgr::GetInstance().API7DeleteContextID(); } - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 cancel is end"); + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 cancel is end"); return ret; } int32_t UserAuthAPI7::CheckAvailability(std::string authtype, std::string trustLevel) { - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 checkAvailability is start"); - UserAuth::AuthType checkAuthType; - UserAuth::AuthTurstLevel authTurstLevel; + using namespace UserAuth; + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 checkAvailability is start"); + AuthType checkAuthType; + AuthTurstLevel authTurstLevel; if (g_convertAuthType.count(authtype) == 0) { - USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 checkAvailability g_convertAuthType is 0"); + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAPI7 checkAvailability g_convertAuthType is 0"); return AUTH_TYPE_NOT_SUPPORT; } else { checkAuthType = g_convertAuthType[authtype]; } if (g_convertAuthTurstLevel.count(trustLevel) == 0) { - USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 checkAvailability g_convertAuthTurstLevel is 0"); + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAPI7 checkAvailability g_convertAuthTurstLevel is 0"); return SECURE_LEVEL_NOT_SUPPORT; } else { authTurstLevel = g_convertAuthTurstLevel[trustLevel]; } - int32_t ret = UserAuth::UserAuth::GetInstance().GetAvailableStatus(checkAuthType, authTurstLevel); - if (ret != UserAuth::SUCCESS) { - USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 checkAvailability is error "); + int32_t ret = UserIAM::UserAuth::UserAuth::GetInstance().GetAvailableStatus(checkAuthType, authTurstLevel); + if (ret != SUCCESS) { + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAPI7 checkAvailability is error "); } - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 checkAvailability is end"); + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 checkAvailability is end"); return ret; } void UserAuthAPI7::On(std::string tip, std::shared_ptr tipCallback) { - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 On is start"); + using namespace UserAuth; + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 On is start"); std::string tipInfo = "tip"; if (!tipInfo.compare(tip)) { - USERAUTH_API7_HILOGE(MODULE_API7, "userauthAPI7 On is not tip"); + USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAPI7 On is not tip"); UserAuthAPI7Datamgr::GetInstance().SetAPI7Tip(false); return; } UserAuthAPI7Datamgr::GetInstance().SetAPI7Tip(true); - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 On is end"); + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 On is end"); } void UserAuthAPI7::Off(std::string tip, std::shared_ptr tipCallback) { - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 Off is start"); + using namespace UserAuth; + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 Off is start"); UserAuthAPI7Datamgr::GetInstance().SetAPI7Tip(false); - USERAUTH_API7_HILOGD(MODULE_API7, "userauthAPI7 Off is end"); + USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 Off is end"); } } // namespace userAuth } // namespace UserIam diff --git a/frameworks/kitsimpl/src/userauth_api7_datamgr.cpp b/frameworks/kitsimpl/src/userauth_api7_datamgr.cpp index 7a31984a0..ea3dbcf88 100644 --- a/frameworks/kitsimpl/src/userauth_api7_datamgr.cpp +++ b/frameworks/kitsimpl/src/userauth_api7_datamgr.cpp @@ -14,7 +14,6 @@ */ #include "userauth_info.h" -#include "userauth_hilog_wrapper.h" #include "userauth_api7_info.h" #include "userauth_api7_datamgr.h" diff --git a/frameworks/kitsimpl/src/userauth_async_stub.cpp b/frameworks/kitsimpl/src/userauth_async_stub.cpp index 9274b64e3..6d1832fa5 100644 --- a/frameworks/kitsimpl/src/userauth_async_stub.cpp +++ b/frameworks/kitsimpl/src/userauth_async_stub.cpp @@ -217,7 +217,7 @@ void UserAuthAsyncStub::onResult(const int32_t result, const AuthResult extraInf if (authCallback_ == nullptr) { USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAsyncStub onResult callback is Null"); - return ; + return; } USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub result:%{public}d, remain:%{public}u, freeze:%{public}u", @@ -231,7 +231,7 @@ void UserAuthAsyncStub::onExecutorPropertyInfo(const ExecutorProperty result) if (getPropCallback_ == nullptr) { USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub onExecutorPropertyInfo callback is Null"); - return ; + return; } USERAUTH_HILOGD(MODULE_INNERKIT, @@ -246,7 +246,7 @@ void UserAuthAsyncStub::onSetExecutorProperty(const int32_t result) if (setPropCallback_ == nullptr) { USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthAsyncStub onSetExecutorProperty callback is Null"); - return ; + return; } USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAsyncStub result:%{public}d", result); setPropCallback_->onSetProperty(result); diff --git a/frameworks/kitsimpl/src/userauth_proxy.cpp b/frameworks/kitsimpl/src/userauth_proxy.cpp index 6cab23523..cbab77709 100644 --- a/frameworks/kitsimpl/src/userauth_proxy.cpp +++ b/frameworks/kitsimpl/src/userauth_proxy.cpp @@ -160,7 +160,6 @@ uint64_t UserAuthProxy::Auth(const uint64_t challenge, const AuthType authType, } if (!reply.ReadUint64(result)) { USERAUTH_HILOGE(MODULE_INNERKIT, "userauth Readback fail!"); - return result; } return result; @@ -206,7 +205,6 @@ uint64_t UserAuthProxy::AuthUser(const int32_t userId, const uint64_t challenge, } if (!reply.ReadUint64(result)) { USERAUTH_HILOGE(MODULE_INNERKIT, "userauth Readback fail!"); - return result; } return result; diff --git a/interfaces/innerkits/napi/BUILD.gn b/interfaces/innerkits/napi/BUILD.gn index 66db8e7cc..0626ef7ae 100755 --- a/interfaces/innerkits/napi/BUILD.gn +++ b/interfaces/innerkits/napi/BUILD.gn @@ -29,7 +29,6 @@ ohos_shared_library("userauth") { sources = [ "src/auth_build.cpp", - "src/auth_native_module.cpp", "src/authapi_callback.cpp", "src/result_convert.cpp", "src/user_auth_helper.cpp", diff --git a/interfaces/innerkits/napi/include/auth_hilog_wrapper.h b/interfaces/innerkits/napi/include/auth_hilog_wrapper.h deleted file mode 100755 index f8e944e1c..000000000 --- a/interfaces/innerkits/napi/include/auth_hilog_wrapper.h +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright (C) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef HILOG_WRAPPER_H -#define HILOG_WRAPPER_H - -#define CONFIG_HILOG -#ifdef CONFIG_HILOG - -#include "hilog/log.h" - -#ifdef HILOG_FATAL -#undef HILOG_FATAL -#endif - -#ifdef HILOG_ERROR -#undef HILOG_ERROR -#endif - -#ifdef HILOG_WARN -#undef HILOG_WARN -#endif - -#ifdef HILOG_INFO -#undef HILOG_INFO -#endif - -#ifdef HILOG_DEBUG -#undef HILOG_DEBUG -#endif - -static constexpr OHOS::HiviewDFX::HiLogLabel LOG_LABEL = {LOG_CORE, 0, "UserAuthNapi===>"}; - -#define HILOG_FATAL(...) (void)OHOS::HiviewDFX::HiLog::Fatal(LOG_LABEL, __VA_ARGS__) -#define HILOG_ERROR(...) (void)OHOS::HiviewDFX::HiLog::Error(LOG_LABEL, __VA_ARGS__) -#define HILOG_WARN(...) (void)OHOS::HiviewDFX::HiLog::Warn(LOG_LABEL, __VA_ARGS__) -#define HILOG_INFO(...) (void)OHOS::HiviewDFX::HiLog::Info(LOG_LABEL, __VA_ARGS__) -#define HILOG_DEBUG(...) (void)OHOS::HiviewDFX::HiLog::Debug(LOG_LABEL, __VA_ARGS__) -#else - -#define HILOG_FATAL(...) -#define HILOG_ERROR(...) -#define HILOG_WARN(...) -#define HILOG_INFO(...) -#define HILOG_DEBUG(...) - -#endif // CONFIG_HILOG - -#endif // HILOG_WRAPPER_H \ No newline at end of file diff --git a/interfaces/innerkits/napi/include/user_auth_helper.h b/interfaces/innerkits/napi/include/user_auth_helper.h index 6d2efcf36..76efacc2f 100755 --- a/interfaces/innerkits/napi/include/user_auth_helper.h +++ b/interfaces/innerkits/napi/include/user_auth_helper.h @@ -44,7 +44,7 @@ napi_value GetCtor(napi_env env); * @param env * @return napi_value AuthenticatorImpl Instance */ -napi_value GetCtor_API(napi_env env); +napi_value GetCtorAPI7(napi_env env); /** * @brief Construction method diff --git a/interfaces/innerkits/napi/include/user_auth_impl.h b/interfaces/innerkits/napi/include/user_auth_impl.h index 7f3affb87..f65133a9e 100755 --- a/interfaces/innerkits/napi/include/user_auth_impl.h +++ b/interfaces/innerkits/napi/include/user_auth_impl.h @@ -16,6 +16,8 @@ #define FACERECOGNITION_USER_AUTH_H #include "napi/native_common.h" +#include +#include "user_auth_helper.h" #include "auth_build.h" #include "auth_common.h" @@ -75,9 +77,10 @@ public: napi_value On(napi_env env, napi_callback_info info); napi_value Off(napi_env env, napi_callback_info info); private: - napi_value ExecuteWrap(napi_env, napi_callback_info info, ExecuteInfo* executeInfo); - napi_value ExecuteAsyncallback(napi_env, napi_value* argv, ExecuteInfo* executeInfo); - napi_value ExecutePromise(napi_env, napi_value* argv, ExecuteInfo* executeInfo); + napi_value ExecuteWrap(napi_env env, napi_callback_info info, ExecuteInfo* executeInfo); + napi_value ExecuteAsyncallback(napi_env env, napi_value* argv, ExecuteInfo* executeInfo); + napi_value ExecutePromise(napi_env env, napi_value* argv, ExecuteInfo* executeInfo); + void JudgeString(napi_env env, napi_value* argv, ExecuteInfo* executeInfo); }; } // namespace UserAuth } // namespace UserIAM diff --git a/interfaces/innerkits/napi/src/auth_build.cpp b/interfaces/innerkits/napi/src/auth_build.cpp index cd5c85bda..0ca4e572a 100755 --- a/interfaces/innerkits/napi/src/auth_build.cpp +++ b/interfaces/innerkits/napi/src/auth_build.cpp @@ -1,128 +1,128 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "auth_build.h" - -#include "auth_common.h" -#include "auth_hilog_wrapper.h" -#include "auth_object.h" - -namespace OHOS { -namespace UserIAM { -namespace UserAuth { -AuthBuild::AuthBuild(void) -{ -} -AuthBuild::~AuthBuild() -{ -} - -Napi_SetPropertyRequest AuthBuild::SetPropertyRequestBuild(napi_env env, napi_value object) -{ - Napi_SetPropertyRequest request; - if (object == nullptr) { - HILOG_ERROR("SetPropertyRequestBuild object is null "); - return request; - } - request.authType_ = convert.GetInt32ValueByKey(env, object, "authType"); - request.key_ = convert.GetInt32ValueByKey(env, object, "key"); - request.setInfo_ = convert.NapiGetValueUint8Array(env, object, "setInfo"); - HILOG_INFO(" AuthBuild::SetPropertyRequestBuild authType = %{public}d", request.authType_); - HILOG_INFO(" AuthBuild::SetPropertyRequestBuild key = %{public}d", request.key_); - return request; -} - -Napi_GetPropertyRequest AuthBuild::GetPropertyRequestBuild(napi_env env, napi_value object) -{ - Napi_GetPropertyRequest request; - if (object == nullptr) { - HILOG_ERROR("GetPropertyRequestBuild object is null "); - return request; - } - request.authType_ = convert.GetInt32ValueByKey(env, object, "authType"); - request.keys_ = convert.GetInt32ArrayValueByKey(env, object, "keys"); - HILOG_INFO(" AuthBuild::GetPropertyRequestBuild authType = %{public}d", request.authType_); - return request; -} - -bool AuthBuild::NapiTypeObject(napi_env env, napi_value value) -{ - if (value == nullptr) { - return false; - } - napi_valuetype isObject = convert.GetType(env, value); - if (isObject == napi_object) { - return true; - } - return false; -} - -bool AuthBuild::NapiTypeNumber(napi_env env, napi_value value) -{ - if (value == nullptr) { - return false; - } - napi_valuetype isNumber = convert.GetType(env, value); - if (isNumber == napi_number) { - return true; - } - return false; -} - -uint64_t AuthBuild::GetUint8ArrayTo64(napi_env env, napi_value value) -{ - napi_typedarray_type arraytype; - size_t length = 0; - napi_value buffer = nullptr; - size_t offset = 0; - uint8_t *data = nullptr; - bool isTypedArray = false; - napi_is_typedarray(env, value, &isTypedArray); - if (!isTypedArray) { - HILOG_ERROR("GetUint8ArrayTo64 value is not typedarray"); - return 0; - } - napi_get_typedarray_info(env, value, &arraytype, &length, reinterpret_cast(&data), &buffer, &offset); - if (arraytype != napi_uint8_array) { - HILOG_ERROR("GetUint8ArrayTo64 js value is not uint8Array"); - return 0; - } - if (offset != 0) { - HILOG_ERROR("offset is %{public}d", offset); - return 0; - } - std::vector result(data, data + length); - uint8_t tmp[sizeof(uint64_t)]; - for (uint32_t i = 0; i < sizeof(uint64_t); i++) { - tmp[i] = result[i]; - HILOG_INFO("GetUint8ArrayTo64 result is %{public}d", (unsigned)result[i]); - } - uint64_t *re = static_cast(static_cast(tmp)); - HILOG_INFO("GetUint8ArrayTo64 resultUint64 is %{public}llu", *re); - return *re; -} - -int AuthBuild::NapiGetValueInt(napi_env env, napi_value value) -{ - return convert.NapiGetValueInt(env, value); -} - -napi_value AuthBuild::Uint64ToUint8Array(napi_env env, uint64_t value) -{ - return convert.Uint64ToUint8Napi(env, value); -} -} // namespace UserAuth -} // namespace UserIAM -} // namespace OHOS +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "auth_build.h" + +#include "auth_common.h" +#include "userauth_hilog_wrapper.h" +#include "auth_object.h" + +namespace OHOS { +namespace UserIAM { +namespace UserAuth { +AuthBuild::AuthBuild(void) +{ +} +AuthBuild::~AuthBuild() +{ +} + +Napi_SetPropertyRequest AuthBuild::SetPropertyRequestBuild(napi_env env, napi_value object) +{ + Napi_SetPropertyRequest request; + if (object == nullptr) { + USERAUTH_HILOGE(MODULE_JS_NAPI,"SetPropertyRequestBuild object is null "); + return request; + } + request.authType_ = convert.GetInt32ValueByKey(env, object, "authType"); + request.key_ = convert.GetInt32ValueByKey(env, object, "key"); + request.setInfo_ = convert.NapiGetValueUint8Array(env, object, "setInfo"); + USERAUTH_HILOGI(MODULE_JS_NAPI," AuthBuild::SetPropertyRequestBuild authType = %{public}d", request.authType_); + USERAUTH_HILOGI(MODULE_JS_NAPI," AuthBuild::SetPropertyRequestBuild key = %{public}d", request.key_); + return request; +} + +Napi_GetPropertyRequest AuthBuild::GetPropertyRequestBuild(napi_env env, napi_value object) +{ + Napi_GetPropertyRequest request; + if (object == nullptr) { + USERAUTH_HILOGE(MODULE_JS_NAPI,"GetPropertyRequestBuild object is null "); + return request; + } + request.authType_ = convert.GetInt32ValueByKey(env, object, "authType"); + request.keys_ = convert.GetInt32ArrayValueByKey(env, object, "keys"); + USERAUTH_HILOGI(MODULE_JS_NAPI," AuthBuild::GetPropertyRequestBuild authType = %{public}d", request.authType_); + return request; +} + +bool AuthBuild::NapiTypeObject(napi_env env, napi_value value) +{ + if (value == nullptr) { + return false; + } + napi_valuetype isObject = convert.GetType(env, value); + if (isObject == napi_object) { + return true; + } + return false; +} + +bool AuthBuild::NapiTypeNumber(napi_env env, napi_value value) +{ + if (value == nullptr) { + return false; + } + napi_valuetype isNumber = convert.GetType(env, value); + if (isNumber == napi_number) { + return true; + } + return false; +} + +uint64_t AuthBuild::GetUint8ArrayTo64(napi_env env, napi_value value) +{ + napi_typedarray_type arraytype; + size_t length = 0; + napi_value buffer = nullptr; + size_t offset = 0; + uint8_t *data = nullptr; + bool isTypedArray = false; + napi_is_typedarray(env, value, &isTypedArray); + if (!isTypedArray) { + USERAUTH_HILOGE(MODULE_JS_NAPI,"GetUint8ArrayTo64 value is not typedarray"); + return 0; + } + napi_get_typedarray_info(env, value, &arraytype, &length, reinterpret_cast(&data), &buffer, &offset); + if (arraytype != napi_uint8_array) { + USERAUTH_HILOGE(MODULE_JS_NAPI,"GetUint8ArrayTo64 js value is not uint8Array"); + return 0; + } + if (offset != 0) { + USERAUTH_HILOGE(MODULE_JS_NAPI,"offset is %{public}d", offset); + return 0; + } + std::vector result(data, data + length); + uint8_t tmp[sizeof(uint64_t)]; + for (uint32_t i = 0; i < sizeof(uint64_t); i++) { + tmp[i] = result[i]; + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetUint8ArrayTo64 result is %{public}d", (unsigned)result[i]); + } + uint64_t *re = static_cast(static_cast(tmp)); + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetUint8ArrayTo64 resultUint64 is %{public}llu", *re); + return *re; +} + +int AuthBuild::NapiGetValueInt(napi_env env, napi_value value) +{ + return convert.NapiGetValueInt(env, value); +} + +napi_value AuthBuild::Uint64ToUint8Array(napi_env env, uint64_t value) +{ + return convert.Uint64ToUint8Napi(env, value); +} +} // namespace UserAuth +} // namespace UserIAM +} // namespace OHOS diff --git a/interfaces/innerkits/napi/src/auth_native_module.cpp b/interfaces/innerkits/napi/src/auth_native_module.cpp deleted file mode 100755 index d6277d4a0..000000000 --- a/interfaces/innerkits/napi/src/auth_native_module.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include - -#include "user_auth_helper.h" - -namespace OHOS { -namespace UserIAM { -namespace UserAuth { -static napi_value ModuleInit(napi_env env, napi_value exports) -{ - OHOS::UserIAM::UserAuth::Init(env, exports); - return exports; -} -extern "C" __attribute__((constructor)) void RegisterModule(void) -{ - napi_module module = {.nm_version = 1, // NAPI v1 - .nm_flags = 0, // normal - .nm_filename = nullptr, - .nm_register_func = ModuleInit, - .nm_modname = "UserAuth", - .nm_priv = nullptr, - .reserved = {}}; - napi_module_register(&module); -} -} // namespace UserAuth -} // namespace UserIAM -} // namespace OHOS diff --git a/interfaces/innerkits/napi/src/authapi_callback.cpp b/interfaces/innerkits/napi/src/authapi_callback.cpp index 18d422438..44ee9455b 100755 --- a/interfaces/innerkits/napi/src/authapi_callback.cpp +++ b/interfaces/innerkits/napi/src/authapi_callback.cpp @@ -18,7 +18,7 @@ #include #include "securec.h" -#include "auth_hilog_wrapper.h" +#include "userauth_hilog_wrapper.h" namespace OHOS { namespace UserIAM { @@ -52,7 +52,7 @@ API7callback::API7callback(FunctionOnAndOffInfo* functionOnAndOffInfo) void API7callback::API7OnResultWrap(uv_loop_s *loop, uv_work_t *work) { - HILOG_INFO("authFace : %{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"authFace : %{public}s, start.", __func__); uv_queue_work(loop, work, [] (uv_work_t *work) { }, [] (uv_work_t *work, int status) { ExecuteInfo *executeInfo = reinterpret_cast(work->data); if (executeInfo == nullptr) { @@ -86,17 +86,17 @@ void API7callback::API7OnResultWrap(uv_loop_s *loop, uv_work_t *work) void API7callback::API7OnResult(const int32_t result) { - HILOG_INFO("authFace : %{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"authFace : %{public}s, start.", __func__); if (executeInfo_ != nullptr) { napi_env env = executeInfo_->env; napi_status status = napi_create_int32(env, result, &executeInfo_->result); if (status != napi_ok) { - HILOG_INFO("napi_create_int32 faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_create_int32 faild"); } uv_loop_s *loop(nullptr); status = napi_get_uv_event_loop(env, &loop); if (status != napi_ok) { - HILOG_INFO("napi_get_uv_event_loop faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_uv_event_loop faild"); } if (loop == nullptr) { return; @@ -115,13 +115,13 @@ void API7callback::API7OnResult(const int32_t result) work->data = reinterpret_cast(executeInfo); API7OnResultWrap(loop, work); } else { - HILOG_ERROR("asyncCallbackContext_ is nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"asyncCallbackContext_ is nullptr"); } } void API7callback::TipCallbackWrap(uv_loop_s *loop, uv_work_t *work) { - HILOG_INFO("authFace : %{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"authFace : %{public}s, start.", __func__); uv_queue_work(loop, work, [] (uv_work_t *work) { }, [] (uv_work_t *work, int status) { FunctionOnAndOffInfo *functionOnAndOffInfo = reinterpret_cast(work->data); if (functionOnAndOffInfo == nullptr) { @@ -150,14 +150,14 @@ void API7callback::TipCallbackWrap(uv_loop_s *loop, uv_work_t *work) void API7callback::TipCallback(const API7UserAuth::Tip result) { - HILOG_INFO("authFace : %{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"authFace : %{public}s, start.", __func__); if (functionOnAndOffInfo_ != nullptr) { napi_env env = functionOnAndOffInfo_->env; functionOnAndOffInfo_->param[PARAM0] = ResultTips(env,result); uv_loop_s *loop(nullptr); napi_status status = napi_get_uv_event_loop(env, &loop); if (status != napi_ok) { - HILOG_INFO("napi_get_uv_event_loop faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_uv_event_loop faild"); } if (loop == nullptr) { return; @@ -176,14 +176,14 @@ void API7callback::TipCallback(const API7UserAuth::Tip result) work->data = reinterpret_cast(functionOnAndOffInfo); TipCallbackWrap(loop, work); } else { - HILOG_ERROR("asyncCallbackContext_ is nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"asyncCallbackContext_ is nullptr"); } - HILOG_ERROR("TipCallback is end"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"TipCallback is end"); } napi_value API7callback::ResultTips(napi_env env, const API7UserAuth::Tip result) { - HILOG_INFO("authFace : %{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"authFace : %{public}s, start.", __func__); napi_value obj; napi_value errorCode; napi_value tipCode; @@ -205,13 +205,13 @@ napi_value API7callback::ResultTips(napi_env env, const API7UserAuth::Tip result napi_value AuthApiCallback::Uint8ArrayToNapi(napi_env env, std::vector value) { int size = value.size(); - HILOG_INFO("Uint8ArrayToNapi size = %{public}d", size); + USERAUTH_HILOGI(MODULE_JS_NAPI,"Uint8ArrayToNapi size = %{public}d", size); napi_value out = nullptr; void *data = nullptr; napi_value buffer = nullptr; NAPI_CALL(env, napi_create_arraybuffer(env, value.size(), &data, &buffer)); if (memcpy_s(data, value.size(), value.data(), value.size()) != 0) { - HILOG_ERROR("AuthApiCallback Uint8ArrayToNapi error"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"AuthApiCallback Uint8ArrayToNapi error"); } NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, value.size(), buffer, 0, &out)); return out; @@ -238,26 +238,26 @@ napi_value AuthApiCallback::BuildOnResult( void AuthApiCallback::OnAuthAcquireInfo(AcquireInfoInner *acquireInfoInner) { - HILOG_INFO("AuthApiCallback OnAuthAcquireInfo start"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback OnAuthAcquireInfo start"); uv_loop_s *loop(nullptr); napi_get_uv_event_loop(authInfo_->callBackInfo.env, &loop); if (loop == nullptr) { - HILOG_ERROR("loop is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"loop is null"); delete acquireInfoInner; return; } uv_work_t *work = new (std::nothrow) uv_work_t; if (work == nullptr) { - HILOG_ERROR("work is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"work is null"); delete acquireInfoInner; return; } work->data = reinterpret_cast(acquireInfoInner); uv_queue_work(loop, work, [] (uv_work_t *work) {}, [] (uv_work_t *work, int status) { - HILOG_INFO("Do OnAuthAcquireInfo work"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"Do OnAuthAcquireInfo work"); AcquireInfoInner *acquireInfoInner = reinterpret_cast(work->data); if (acquireInfoInner == nullptr) { - HILOG_ERROR("authInfo is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"authInfo is null"); delete work; return; } @@ -266,7 +266,7 @@ void AuthApiCallback::OnAuthAcquireInfo(AcquireInfoInner *acquireInfoInner) napi_value callback; napi_status napiStatus = napi_get_reference_value(env, acquireInfoInner->onAcquireInfo, &callback); if (napiStatus != napi_ok) { - HILOG_INFO("napi_get_reference_value faild "); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_reference_value faild "); delete acquireInfoInner; delete work; return; @@ -277,7 +277,7 @@ void AuthApiCallback::OnAuthAcquireInfo(AcquireInfoInner *acquireInfoInner) napi_create_int32(env, acquireInfoInner->extraInfo, ¶ms[PARAM2]); napiStatus = napi_call_function(env, acquireInfoInner->jsFunction, callback, PARAM3, params, &returnOnAcquire); if (napiStatus != napi_ok) { - HILOG_ERROR("napi_call_function faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_call_function faild"); } delete acquireInfoInner; delete work; @@ -289,7 +289,7 @@ void AuthApiCallback::onAcquireInfo(const int32_t module, const uint32_t acquire if (userInfo_ != nullptr) { AcquireInfoInner *acquireInfoInner = new (std::nothrow) AcquireInfoInner(); if (acquireInfoInner == nullptr) { - HILOG_ERROR("acquireInfoInner is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"acquireInfoInner is null"); return; } acquireInfoInner->env = userInfo_->callBackInfo.env; @@ -300,13 +300,13 @@ void AuthApiCallback::onAcquireInfo(const int32_t module, const uint32_t acquire acquireInfoInner->extraInfo = extraInfo; OnAuthAcquireInfo(acquireInfoInner); } else { - HILOG_INFO("AuthApiCallback onAcquireInfo userInfo_ is nullptr "); + USERAUTH_HILOGE(MODULE_JS_NAPI,"AuthApiCallback onAcquireInfo userInfo_ is nullptr "); } if (authInfo_ != nullptr) { AcquireInfoInner *acquireInfoInner = new (std::nothrow) AcquireInfoInner(); if (acquireInfoInner == nullptr) { - HILOG_ERROR("acquireInfoInner is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"acquireInfoInner is null"); return; } acquireInfoInner->env = authInfo_->callBackInfo.env; @@ -317,17 +317,17 @@ void AuthApiCallback::onAcquireInfo(const int32_t module, const uint32_t acquire acquireInfoInner->extraInfo = extraInfo; OnAuthAcquireInfo(acquireInfoInner); } else { - HILOG_INFO("AuthApiCallback onAcquireInfo authInfo_ is nullptr "); + USERAUTH_HILOGE(MODULE_JS_NAPI,"AuthApiCallback onAcquireInfo authInfo_ is nullptr "); } - HILOG_INFO("AuthApiCallback onAcquireInfo end"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback onAcquireInfo end"); } static void OnUserAuthResultWork(uv_work_t *work, int status) { - HILOG_INFO("Do OnUserAuthResult work"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"Do OnUserAuthResult work"); AuthUserInfo *userInfo = reinterpret_cast(work->data); if (userInfo == nullptr) { - HILOG_ERROR("authInfo is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"authInfo is null"); delete work; return; } @@ -335,7 +335,7 @@ static void OnUserAuthResultWork(uv_work_t *work, int status) napi_value callback; napi_status napiStatus = napi_get_reference_value(env, userInfo->onResult, &callback); if (napiStatus != napi_ok) { - HILOG_INFO("napi_get_reference_value faild "); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_reference_value faild "); delete userInfo; delete work; return; @@ -352,18 +352,18 @@ static void OnUserAuthResultWork(uv_work_t *work, int status) void AuthApiCallback::OnUserAuthResult(const int32_t result, const AuthResult extraInfo) { - HILOG_INFO("AuthApiCallback OnUserAuthResult start"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback OnUserAuthResult start"); uv_loop_s *loop(nullptr); napi_get_uv_event_loop(userInfo_->callBackInfo.env, &loop); if (loop == nullptr) { - HILOG_ERROR("loop is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"loop is null"); delete userInfo_; userInfo_ = nullptr; return; } uv_work_t *work = new (std::nothrow) uv_work_t; if (work == nullptr) { - HILOG_ERROR("work is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"work is null"); delete userInfo_; userInfo_ = nullptr; return; @@ -379,10 +379,10 @@ void AuthApiCallback::OnUserAuthResult(const int32_t result, const AuthResult ex static void OnAuthResultWork(uv_work_t *work, int status) { - HILOG_INFO("Do OnAuthResult work"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"Do OnAuthResult work"); AuthInfo *authInfo = reinterpret_cast(work->data); if (authInfo == nullptr) { - HILOG_ERROR("authInfo is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"authInfo is null"); delete work; return; } @@ -390,7 +390,7 @@ static void OnAuthResultWork(uv_work_t *work, int status) napi_value callback; napi_status napiStatus = napi_get_reference_value(env, authInfo->onResult, &callback); if (napiStatus != napi_ok) { - HILOG_INFO("napi_get_reference_value faild "); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_reference_value faild "); delete authInfo; delete work; return; @@ -407,18 +407,18 @@ static void OnAuthResultWork(uv_work_t *work, int status) void AuthApiCallback::OnAuthResult(const int32_t result, const AuthResult extraInfo) { - HILOG_INFO("AuthApiCallback OnAuthResult start"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback OnAuthResult start"); uv_loop_s *loop(nullptr); napi_get_uv_event_loop(authInfo_->callBackInfo.env, &loop); if (loop == nullptr) { - HILOG_ERROR("loop is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"loop is null"); delete authInfo_; authInfo_ = nullptr; return; } uv_work_t *work = new (std::nothrow) uv_work_t; if (work == nullptr) { - HILOG_ERROR("work is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"work is null"); delete authInfo_; authInfo_ = nullptr; return; @@ -434,21 +434,21 @@ void AuthApiCallback::OnAuthResult(const int32_t result, const AuthResult extraI void AuthApiCallback::onResult(const int32_t result, const AuthResult extraInfo) { - HILOG_INFO("AuthApiCallback onResult start result = %{public}d", result); - HILOG_INFO("AuthApiCallback onResult start token.length = %{public}d", extraInfo.token.size()); - HILOG_INFO("AuthApiCallback onResult start extraInfo.remainTimes = %{public}u", extraInfo.remainTimes); - HILOG_INFO("AuthApiCallback onResult start extraInfo.freezingTime = %{public}u", extraInfo.freezingTime); + USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback onResult start result = %{public}d", result); + USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback onResult start token.length = %{public}d", extraInfo.token.size()); + USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback onResult start extraInfo.remainTimes = %{public}u", extraInfo.remainTimes); + USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback onResult start extraInfo.freezingTime = %{public}u", extraInfo.freezingTime); if (userInfo_ != nullptr) { OnUserAuthResult(result, extraInfo); } else { - HILOG_ERROR("AuthApiCallback onResult userInfo_ is nullptr "); + USERAUTH_HILOGE(MODULE_JS_NAPI,"AuthApiCallback onResult userInfo_ is nullptr "); } if (authInfo_ != nullptr) { OnAuthResult(result, extraInfo); } else { - HILOG_ERROR("AuthApiCallback onResult authInfo_ is nullptr "); + USERAUTH_HILOGE(MODULE_JS_NAPI,"AuthApiCallback onResult authInfo_ is nullptr "); } - HILOG_INFO("AuthApiCallback onResult end"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback onResult end"); } GetPropApiCallback::GetPropApiCallback(GetPropertyInfo *getPropertyInfo) @@ -462,10 +462,10 @@ GetPropApiCallback::~GetPropApiCallback() static void GetPropertyInfoCallback(uv_work_t* work, int status) { - HILOG_INFO("Do OnAuthAcquireInfo work"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"Do OnAuthAcquireInfo work"); GetPropertyInfo *getPropertyInfo = reinterpret_cast(work->data); if (getPropertyInfo == nullptr) { - HILOG_ERROR("getPropertyInfo is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"getPropertyInfo is null"); delete work; return; } @@ -474,32 +474,32 @@ static void GetPropertyInfoCallback(uv_work_t* work, int status) resultData[PARAM0] = GetPropApiCallback::BuildExecutorProperty(env, getPropertyInfo->getResult, getPropertyInfo->remainTimes, getPropertyInfo->freezingTime, getPropertyInfo->authSubType); if (getPropertyInfo->callBackInfo.callBack != nullptr) { - HILOG_INFO("onExecutorPropertyInfo async"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"onExecutorPropertyInfo async"); napi_value global = nullptr; napi_status napiStatus = napi_get_global(env, &global); if (napiStatus != napi_ok) { - HILOG_INFO("napi_get_global faild "); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_global faild "); goto EXIT; } napi_value resultValue = nullptr; napi_value callBack = nullptr; napiStatus = napi_get_reference_value(env, getPropertyInfo->callBackInfo.callBack, &callBack); if (napiStatus != napi_ok) { - HILOG_INFO("napi_get_reference_value faild "); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_reference_value faild "); goto EXIT; } napiStatus = napi_call_function(env, global, callBack, PARAM1, resultData, &resultValue); if (napiStatus != napi_ok) { - HILOG_INFO("napi_call_function faild "); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_call_function faild "); goto EXIT; } } else { - HILOG_INFO("onExecutorPropertyInfo promise"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"onExecutorPropertyInfo promise"); napi_value resultValue = resultData[PARAM0]; napi_deferred deferred = getPropertyInfo->callBackInfo.deferred; napi_status napiStatus = napi_resolve_deferred(env, deferred, resultValue); if (napiStatus != napi_ok) { - HILOG_INFO("napi_resolve_deferred faild "); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_resolve_deferred faild "); goto EXIT; } } @@ -534,25 +534,25 @@ napi_value GetPropApiCallback::BuildExecutorProperty( void GetPropApiCallback::onGetProperty(const ExecutorProperty result) { - HILOG_INFO("GetPropApiCallback onGetProperty 1 = %{public}d", result.result); - HILOG_INFO("GetPropApiCallback onGetProperty 2 = %{public}llu", result.authSubType); - HILOG_INFO("GetPropApiCallback onGetProperty 3 = %{public}u", result.remainTimes); - HILOG_INFO("GetPropApiCallback onGetProperty 4 = %{public}u", result.freezingTime); + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropApiCallback onGetProperty 1 = %{public}d", result.result); + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropApiCallback onGetProperty 2 = %{public}llu", result.authSubType); + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropApiCallback onGetProperty 3 = %{public}u", result.remainTimes); + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropApiCallback onGetProperty 4 = %{public}u", result.freezingTime); if (getPropertyInfo_ == nullptr) { - HILOG_ERROR("GetPropApiCallback onGetProperty getPropertyInfo_ is nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"GetPropApiCallback onGetProperty getPropertyInfo_ is nullptr"); return; } uv_loop_s *loop(nullptr); napi_get_uv_event_loop(getPropertyInfo_->callBackInfo.env, &loop); if (loop == nullptr) { - HILOG_ERROR("loop is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"loop is null"); delete getPropertyInfo_; getPropertyInfo_ = nullptr; return; } uv_work_t *work = new (std::nothrow) uv_work_t; if (work == nullptr) { - HILOG_ERROR("work is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"work is null"); delete getPropertyInfo_; getPropertyInfo_ = nullptr; return; @@ -563,7 +563,7 @@ void GetPropApiCallback::onGetProperty(const ExecutorProperty result) getPropertyInfo_->freezingTime = result.freezingTime; work->data = reinterpret_cast(getPropertyInfo_); getPropertyInfo_ = nullptr; - HILOG_INFO("Before GetPropertyInfoCallback"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"Before GetPropertyInfoCallback"); uv_queue_work(loop, work, [] (uv_work_t *work) {}, GetPropertyInfoCallback); } @@ -578,24 +578,24 @@ SetPropApiCallback::~SetPropApiCallback() static void SetExecutorPropertyCallback(uv_work_t *work, int status) { - HILOG_INFO("Do SetExecutorPropertyCallback work"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"Do SetExecutorPropertyCallback work"); SetPropertyInfo *setPropertyInfo = reinterpret_cast(work->data); if (setPropertyInfo == nullptr) { - HILOG_ERROR("authInfo is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"authInfo is null"); delete work; return; } napi_env env = setPropertyInfo->callBackInfo.env; napi_status napiStatus = napi_create_int32(env, setPropertyInfo->setResult, &setPropertyInfo->result); if (napiStatus != napi_ok) { - HILOG_ERROR("napi_create_int32 faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_create_int32 faild"); goto EXIT; } if (setPropertyInfo->callBackInfo.callBack != nullptr) { napi_value global = nullptr; napiStatus = napi_get_global(env, &global); if (napiStatus != napi_ok) { - HILOG_ERROR("napi_get_global faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_global faild"); goto EXIT; } napi_value resultData[PARAM1]; @@ -605,12 +605,12 @@ static void SetExecutorPropertyCallback(uv_work_t *work, int status) napi_value callBack = nullptr; napiStatus = napi_get_reference_value(env, setPropertyInfo->callBackInfo.callBack, &callBack); if (napiStatus != napi_ok) { - HILOG_ERROR("napi_get_reference_value faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_reference_value faild"); goto EXIT; } napiStatus = napi_call_function(env, global, callBack, PARAM1, resultData, &result); if (napiStatus != napi_ok) { - HILOG_ERROR("napi_call_function faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_call_function faild"); goto EXIT; } } else { @@ -618,7 +618,7 @@ static void SetExecutorPropertyCallback(uv_work_t *work, int status) napi_deferred deferred = setPropertyInfo->callBackInfo.deferred; napiStatus = napi_resolve_deferred(env, deferred, result); if (napiStatus != napi_ok) { - HILOG_ERROR("napi_call_function faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_call_function faild"); goto EXIT; } } @@ -629,22 +629,22 @@ EXIT: void SetPropApiCallback::onSetProperty(const int32_t result) { - HILOG_INFO("onSetProperty start = %{public}d", result); + USERAUTH_HILOGI(MODULE_JS_NAPI,"onSetProperty start = %{public}d", result); if (setPropertyInfo_ != nullptr) { - HILOG_ERROR("setPropertyInfo is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"setPropertyInfo is null"); return; } uv_loop_s *loop(nullptr); napi_get_uv_event_loop(setPropertyInfo_->callBackInfo.env, &loop); if (loop == nullptr) { - HILOG_ERROR("loop is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"loop is null"); delete setPropertyInfo_; setPropertyInfo_ = nullptr; return; } uv_work_t *work = new (std::nothrow) uv_work_t; if (work == nullptr) { - HILOG_ERROR("work is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"work is null"); delete setPropertyInfo_; setPropertyInfo_ = nullptr; return; diff --git a/interfaces/innerkits/napi/src/result_convert.cpp b/interfaces/innerkits/napi/src/result_convert.cpp index a43548c92..7f32751b9 100644 --- a/interfaces/innerkits/napi/src/result_convert.cpp +++ b/interfaces/innerkits/napi/src/result_convert.cpp @@ -17,7 +17,7 @@ #include "securec.h" -#include "auth_hilog_wrapper.h" +#include "userauth_hilog_wrapper.h" namespace OHOS { namespace UserIAM { @@ -32,7 +32,7 @@ ResultConvert::~ResultConvert() napi_value ResultConvert::Uint64ToUint8Napi(napi_env env, uint64_t value) { - HILOG_INFO("ResultConvert Uint64ToUint8Napi uint64_t %{public}llu", value); + USERAUTH_HILOGI(MODULE_JS_NAPI,"ResultConvert Uint64ToUint8Napi uint64_t %{public}llu", value); size_t length = sizeof(value); void *data = nullptr; napi_value arrayBuffer = nullptr; @@ -59,16 +59,16 @@ std::vector ResultConvert::NapiGetValueUint8Array(napi_env env, napi_va bool isTypedArray = false; napi_is_typedarray(env, jsValue, &isTypedArray); if (!isTypedArray) { - HILOG_ERROR("NapiGetValueUint8Array jsValue is not typedarray"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"NapiGetValueUint8Array jsValue is not typedarray"); return RetNull; } napi_get_typedarray_info(env, jsValue, &arraytype, &length, reinterpret_cast(&data), &buffer, &offset); if (arraytype != napi_uint8_array) { - HILOG_ERROR("NapiGetValueUint8Array js jsValue is not uint8Array"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"NapiGetValueUint8Array js jsValue is not uint8Array"); return RetNull; } if (offset != 0) { - HILOG_ERROR("offset is %{public}d", offset); + USERAUTH_HILOGE(MODULE_JS_NAPI,"offset is %{public}d", offset); return RetNull; } std::vector result(data, data + length); @@ -84,7 +84,7 @@ napi_valuetype ResultConvert::GetType(napi_env env, napi_value value) napi_valuetype type; status = napi_typeof(env, value, &type); if (status != napi_ok) { - HILOG_ERROR("napi_typeof faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_typeof faild"); } return type; } @@ -108,7 +108,7 @@ std::vector ResultConvert::GetCppArrayUint32(napi_env env, napi_value uint32_t arrayLength = 0; napi_get_array_length(env, value, &arrayLength); if (arrayLength <= 0) { - HILOG_ERROR("%{public}s The array is empty.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s The array is empty.", __func__); return std::vector(); } std::vector paramArrays; @@ -118,7 +118,7 @@ std::vector ResultConvert::GetCppArrayUint32(napi_env env, napi_value napi_valuetype napiValueType = napi_undefined; napi_typeof(env, napiElement, &napiValueType); if (napiValueType != napi_number) { - HILOG_ERROR("%{public}s Wrong argument type. Numbers expected.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s Wrong argument type. Numbers expected.", __func__); return std::vector(); } uint32_t napiValue = 0; @@ -141,13 +141,13 @@ std::vector ResultConvert::GetInt32ArrayValueByKey(napi_env env, napi_ bool isArray = false; status = napi_is_array(env, array, &isArray); if (status != napi_ok) { - HILOG_INFO("napi_is_array is failed"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"napi_is_array is failed"); return std::vector(); } if (isArray) { - HILOG_INFO("args[PIN_PARAMS_ONE] is a array"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"args[PIN_PARAMS_ONE] is a array"); } else { - HILOG_INFO("args[PIN_PARAMS_ONE] is not a array"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"args[PIN_PARAMS_ONE] is not a array"); return std::vector(); } return GetCppArrayUint32(env, array); @@ -157,7 +157,7 @@ std::string ResultConvert::NapiGetValueString(napi_env env, napi_value value) { napi_status status; if (value == nullptr) { - HILOG_ERROR("AuthBuild NapiGetValueString value is nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"AuthBuild NapiGetValueString value is nullptr"); return ""; } std::string resultValue = ""; @@ -166,11 +166,11 @@ std::string ResultConvert::NapiGetValueString(napi_env env, napi_value value) size_t resultSize = 0; status = napi_get_value_string_utf8(env, value, valueString, valueSize, &resultSize); if (status != napi_ok) { - HILOG_ERROR("napi_get_value_string_utf8 faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_value_string_utf8 faild"); } resultValue = valueString; if (resultValue == "") { - HILOG_ERROR("ContactsBuild NapiGetValueString Data error"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"ContactsBuild NapiGetValueString Data error"); return ""; } return resultValue; @@ -206,7 +206,7 @@ int ResultConvert::NapiGetValueInt(napi_env env, napi_value value) napi_value ResultConvert::GetNapiValue(napi_env env, const std::string keyChar, napi_value object) { if (object == nullptr) { - HILOG_ERROR("ResultConvert::GetNapiValue object is nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"ResultConvert::GetNapiValue object is nullptr"); return nullptr; } napi_value key = nullptr; diff --git a/interfaces/innerkits/napi/src/user_auth_helper.cpp b/interfaces/innerkits/napi/src/user_auth_helper.cpp index 5420550ea..d2152aa79 100755 --- a/interfaces/innerkits/napi/src/user_auth_helper.cpp +++ b/interfaces/innerkits/napi/src/user_auth_helper.cpp @@ -15,7 +15,7 @@ #include "user_auth_helper.h" -#include "auth_hilog_wrapper.h" +#include "userauth_hilog_wrapper.h" #include "user_auth_impl.h" namespace OHOS { @@ -30,6 +30,7 @@ namespace UserAuth { */ napi_value UserAuthServiceConstructor(napi_env env, napi_callback_info info) { + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); std::shared_ptr userAuthImpl; userAuthImpl.reset(new UserAuthImpl()); napi_value thisVar = nullptr; @@ -57,7 +58,7 @@ napi_value UserAuthServiceConstructor(napi_env env, napi_callback_info info) */ napi_value AuthenticatorServiceConstructor(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); std::shared_ptr authenticatorImpl; authenticatorImpl.reset(new AuthenticatorImpl()); napi_value thisVar = nullptr; @@ -92,7 +93,7 @@ napi_value GetVersion(napi_env env, napi_callback_info info) 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, GetVersion"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthHelper, GetVersion"); return userAuthImpl->GetVersion(env, info); } @@ -111,7 +112,7 @@ napi_value GetAvailabeStatus(napi_env env, napi_callback_info info) 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, getAvailabeStatus"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthHelper, getAvailabeStatus"); return userAuthImpl->GetAvailabeStatus(env, info); } @@ -130,7 +131,7 @@ napi_value GetProperty(napi_env env, napi_callback_info info) 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, GetProperty"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthHelper, GetProperty"); return userAuthImpl->GetProperty(env, info); } @@ -149,7 +150,7 @@ napi_value SetProperty(napi_env env, napi_callback_info info) 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, SetProperty"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthHelper, SetProperty"); return userAuthImpl->SetProperty(env, info); } @@ -169,7 +170,7 @@ napi_value Auth(napi_env env, napi_callback_info info) 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, Auth"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthHelper, Auth"); return userAuthImpl->Auth(env, info); } @@ -189,7 +190,7 @@ napi_value AuthUser(napi_env env, napi_callback_info info) 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, AuthUser"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthHelper, AuthUser"); return userAuthImpl->AuthUser(env, info); } @@ -208,72 +209,67 @@ napi_value CancelAuth(napi_env env, napi_callback_info info) 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, CancelAuth"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthHelper, CancelAuth"); return userAuthImpl->CancelAuth(env, info); } napi_value Execute(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start.", __func__); napi_value thisVar = nullptr; size_t argcAsync = ARGS_THREE; napi_value args[ARGS_MAX_COUNT] = {nullptr}; NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); AuthenticatorImpl *authenticatorImpl = nullptr; NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); - HILOG_INFO("UserAuthHelper, CancelAuth"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"authenticatorImpl, Execute"); return authenticatorImpl->Execute(env, info); } napi_value Cancel(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start.", __func__); 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)); AuthenticatorImpl *authenticatorImpl = nullptr; NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); - HILOG_INFO("UserAuthHelper, CancelAuth"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"authenticatorImpl, Cancel"); return authenticatorImpl->Cancel(env, info); } napi_value CheckAvailability(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start.", __func__); 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)); AuthenticatorImpl *authenticatorImpl = nullptr; NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); - HILOG_INFO("UserAuthHelper, CancelAuth"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"authenticatorImpl, CheckAvailability"); return authenticatorImpl->CheckAvailability(env, info); } napi_value On(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start.", __func__); 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)); AuthenticatorImpl *authenticatorImpl = nullptr; NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); - HILOG_INFO("UserAuthHelper, CancelAuth"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"authenticatorImpl, On"); return authenticatorImpl->On(env, info); } napi_value Off(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start.", __func__); 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)); AuthenticatorImpl *authenticatorImpl = nullptr; NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); - HILOG_INFO("UserAuthHelper, CancelAuth"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"authenticatorImpl, Off"); return authenticatorImpl->Off(env, info); } /** @@ -284,6 +280,7 @@ napi_value Off(napi_env env, napi_callback_info info) */ void Init(napi_env env, napi_value exports) { + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); napi_status status; napi_property_descriptor exportFuncs[] = { DECLARE_NAPI_FUNCTION("constructor", UserAuth::Constructor), @@ -291,20 +288,21 @@ void Init(napi_env env, napi_value exports) }; status = napi_define_properties(env, exports, sizeof(exportFuncs) / sizeof(*exportFuncs), exportFuncs); if (status != napi_ok) { - HILOG_ERROR("napi_define_properties faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_define_properties faild"); } status = napi_set_named_property(env, exports, "UserAuth", GetCtor(env)); if (status != napi_ok) { - HILOG_ERROR("napi_set_named_property faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_set_named_property faild"); } - status = napi_set_named_property(env, exports, "Authenticator", GetCtor_API(env)); + status = napi_set_named_property(env, exports, "Authenticator", GetCtorAPI7(env)); if (status != napi_ok) { - HILOG_ERROR("napi_set_named_property faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_set_named_property faild"); } } napi_value Constructor(napi_env env, napi_callback_info info) { + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); napi_value thisVar = nullptr; napi_value userAuth = nullptr; NAPI_CALL(env, napi_new_instance(env, GetCtor(env), 0, nullptr, &userAuth)); @@ -314,16 +312,17 @@ napi_value Constructor(napi_env env, napi_callback_info info) napi_value GetAuthenticator(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); napi_value thisVar = nullptr; napi_value authenticator = nullptr; - NAPI_CALL(env, napi_new_instance(env, GetCtor_API(env), 0, nullptr, &authenticator)); + NAPI_CALL(env, napi_new_instance(env, GetCtorAPI7(env), 0, nullptr, &authenticator)); NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); return authenticator; } napi_value GetCtor(napi_env env) { + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); napi_value cons = nullptr; napi_property_descriptor clzDes[] = { DECLARE_NAPI_FUNCTION("getVersion", UserAuth::GetVersion), @@ -339,9 +338,9 @@ napi_value GetCtor(napi_env env) return cons; } -napi_value GetCtor_API(napi_env env) +napi_value GetCtorAPI7(napi_env env) { - HILOG_INFO("%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); napi_value cons = nullptr; napi_property_descriptor clzDes[] = { DECLARE_NAPI_FUNCTION("execute", UserAuth::Execute), diff --git a/interfaces/innerkits/napi/src/user_auth_impl.cpp b/interfaces/innerkits/napi/src/user_auth_impl.cpp index 92592fd57..e5b94410d 100755 --- a/interfaces/innerkits/napi/src/user_auth_impl.cpp +++ b/interfaces/innerkits/napi/src/user_auth_impl.cpp @@ -19,7 +19,7 @@ #include "userauth_callback.h" #include "userauth_info.h" -#include "auth_hilog_wrapper.h" +#include "userauth_hilog_wrapper.h" #include "authapi_callback.h" namespace OHOS { @@ -44,7 +44,7 @@ AuthenticatorImpl::~AuthenticatorImpl() napi_value UserAuthImpl::GetVersion(napi_env env, napi_callback_info info) { int32_t result = UserAuth::GetInstance().GetVersion(); - HILOG_INFO("GetVersion result = %{public}d ", result); + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetVersion result = %{public}d ", result); napi_value version = 0; NAPI_CALL(env, napi_create_int32(env, result, &version)); return version; @@ -56,23 +56,23 @@ napi_value UserAuthImpl::GetAvailabeStatus(napi_env env, napi_callback_info info size_t argc = ARGS_MAX_COUNT; NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); if (argc != ARGS_TWO) { - HILOG_ERROR("%{public}s, parms error.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s, parms error.", __func__); return nullptr; } int type = authBuild.NapiGetValueInt(env, argv[PARAM0]); if (type == GET_VALUE_ERROR) { - HILOG_ERROR("%{public}s, argv[PARAM0] error.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s, argv[PARAM0] error.", __func__); return nullptr; } int level = authBuild.NapiGetValueInt(env, argv[PARAM1]); if (level == GET_VALUE_ERROR) { - HILOG_ERROR("%{public}s, argv[PARAM1] error.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s, argv[PARAM1] error.", __func__); return nullptr; } AuthType authType = AuthType(type); AuthTurstLevel authTurstLevel = AuthTurstLevel(level); int32_t result = UserAuth::GetInstance().GetAvailableStatus(authType, authTurstLevel); - HILOG_INFO("GetAvailabeStatus result = %{public}d", result); + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetAvailabeStatus result = %{public}d", result); napi_value ret = 0; NAPI_CALL(env, napi_create_int32(env, result, &ret)); return ret; @@ -82,20 +82,20 @@ 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__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{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__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s getPropertyInfo nullptr", __func__); return nullptr; } getPropertyInfo->callBackInfo.env = env; asyncHolder->data = getPropertyInfo; napi_value ret = GetPropertyWrap(env, info, asyncHolder); if (ret == nullptr) { - HILOG_ERROR("%{public}s GetPropertyWrap fail", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s GetPropertyWrap fail", __func__); delete getPropertyInfo; delete asyncHolder; if (asyncHolder->asyncWork != nullptr) { @@ -107,7 +107,7 @@ napi_value UserAuthImpl::GetProperty(napi_env env, napi_callback_info info) napi_value UserAuthImpl::GetPropertyWrap(napi_env env, napi_callback_info info, AsyncHolder *asyncHolder) { - HILOG_INFO("%{public}s, called", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, called", __func__); GetPropertyInfo *getPropertyInfo = reinterpret_cast(asyncHolder->data); size_t argcAsync = ARGS_TWO; const size_t argcPromise = ARGS_ONE; @@ -115,7 +115,7 @@ napi_value UserAuthImpl::GetPropertyWrap(napi_env env, napi_callback_info info, napi_value args[ARGS_MAX_COUNT] = {nullptr}; NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr)); if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { - HILOG_ERROR("%{public}s, Wrong argument count.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s, Wrong argument count.", __func__); return nullptr; } if (argcAsync > PARAM1) { @@ -136,21 +136,21 @@ napi_value UserAuthImpl::GetPropertyWrap(napi_env env, napi_callback_info info, } else { ret = GetPropertyPromise(env, asyncHolder); } - HILOG_INFO("%{public}s,end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s,end.", __func__); return ret; } void UserAuthImpl::GetPropertyExecute(napi_env env, void *data) { - HILOG_INFO("GetPropertyExecute, worker pool thread execute."); + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropertyExecute, worker pool thread execute."); AsyncHolder *asyncHolder = reinterpret_cast(data); if (asyncHolder == nullptr) { - HILOG_ERROR("GetPropertyExecute, asyncHolder == nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"GetPropertyExecute, asyncHolder == nullptr"); return; } GetPropertyInfo *getPropertyInfo = reinterpret_cast(asyncHolder->data); if (getPropertyInfo == nullptr) { - HILOG_ERROR("GetPropertyExecute, getPropertyInfo == nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"GetPropertyExecute, getPropertyInfo == nullptr"); return; } AuthType authTypeGet = AuthType(getPropertyInfo->authType); @@ -158,35 +158,35 @@ void UserAuthImpl::GetPropertyExecute(napi_env env, void *data) GetPropertyRequest request; request.authType = authTypeGet; request.keys = getPropertyInfo->keys; - HILOG_INFO("GetPropertyExecute start 1"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropertyExecute start 1"); GetPropApiCallback *object = new GetPropApiCallback(getPropertyInfo); std::shared_ptr callback; callback.reset(object); UserAuth::GetInstance().GetProperty(request, callback); - HILOG_INFO("GetPropertyExecute, worker pool thread execute end."); + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropertyExecute, worker pool thread execute end."); } void UserAuthImpl::GetPropertyPromiseExecuteDone(napi_env env, napi_status status, void *data) { - HILOG_INFO("GetPropertyPromiseExecuteDone, start"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropertyPromiseExecuteDone, start"); AsyncHolder *asyncHolder = reinterpret_cast(data); napi_delete_async_work(env, asyncHolder->asyncWork); delete asyncHolder; - HILOG_INFO("GetPropertyPromiseExecuteDone, end"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropertyPromiseExecuteDone, end"); } void UserAuthImpl::GetPropertyAsyncExecuteDone(napi_env env, napi_status status, void *data) { - HILOG_INFO("GetPropertyAsyncExecuteDone, start"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropertyAsyncExecuteDone, start"); AsyncHolder *asyncHolder = reinterpret_cast(data); napi_delete_async_work(env, asyncHolder->asyncWork); delete asyncHolder; - HILOG_INFO("GetPropertyAsyncExecuteDone, end"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropertyAsyncExecuteDone, end"); } napi_value UserAuthImpl::GetPropertyAsync(napi_env env, AsyncHolder *asyncHolder) { - HILOG_INFO("%{public}s, asyncCallback.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, asyncCallback.", __func__); napi_value result = nullptr; NAPI_CALL(env, napi_get_null(env, &result)); napi_value resourceName = nullptr; @@ -194,13 +194,13 @@ napi_value UserAuthImpl::GetPropertyAsync(napi_env env, AsyncHolder *asyncHolder NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, GetPropertyExecute, GetPropertyAsyncExecuteDone, (void *)asyncHolder, &asyncHolder->asyncWork)); NAPI_CALL(env, napi_queue_async_work(env, asyncHolder->asyncWork)); - HILOG_INFO("%{public}s, asyncCallback end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, asyncCallback end.", __func__); return result; } napi_value UserAuthImpl::GetPropertyPromise(napi_env env, AsyncHolder *asyncHolder) { - HILOG_INFO("%{public}s, promise.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, promise.", __func__); GetPropertyInfo *getPropertyInfo = reinterpret_cast(asyncHolder->data); napi_value resourceName = 0; NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); @@ -212,7 +212,7 @@ napi_value UserAuthImpl::GetPropertyPromise(napi_env env, AsyncHolder *asyncHold NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, GetPropertyExecute, GetPropertyPromiseExecuteDone, (void *)asyncHolder, &asyncHolder->asyncWork)); NAPI_CALL(env, napi_queue_async_work(env, asyncHolder->asyncWork)); - HILOG_INFO("%{public}s, promise end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, promise end.", __func__); return promise; } @@ -220,20 +220,20 @@ 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__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{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__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s setPropertyInfo nullptr", __func__); return nullptr; } setPropertyInfo->callBackInfo.env = env; asyncHolder->data = setPropertyInfo; napi_value ret = SetPropertyWrap(env, info, asyncHolder); if (ret == nullptr) { - HILOG_ERROR("%{public}s SetPropertyWrap fail", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s SetPropertyWrap fail", __func__); delete setPropertyInfo; delete asyncHolder; if (asyncHolder->asyncWork != nullptr) { @@ -245,7 +245,7 @@ napi_value UserAuthImpl::SetProperty(napi_env env, napi_callback_info info) napi_value UserAuthImpl::SetPropertyWrap(napi_env env, napi_callback_info info, AsyncHolder *asyncHolder) { - HILOG_INFO("%{public}s, called", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, called", __func__); SetPropertyInfo *setPropertyInfo = reinterpret_cast(asyncHolder->data); size_t argcAsync = ARGS_TWO; const size_t argcPromise = ARGS_ONE; @@ -253,7 +253,7 @@ napi_value UserAuthImpl::SetPropertyWrap(napi_env env, napi_callback_info info, napi_value args[ARGS_MAX_COUNT] = {nullptr}; NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr)); if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { - HILOG_ERROR("%{public}s, Wrong argument count.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s, Wrong argument count.", __func__); return nullptr; } if (argcAsync > PARAM1) { @@ -277,21 +277,21 @@ napi_value UserAuthImpl::SetPropertyWrap(napi_env env, napi_callback_info info, } else { ret = SetPropertyPromise(env, asyncHolder); } - HILOG_INFO("%{public}s,end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s,end.", __func__); return ret; } void UserAuthImpl::SetPropertyExecute(napi_env env, void *data) { - HILOG_INFO("setPropertyExecute, worker pool thread execute."); + USERAUTH_HILOGI(MODULE_JS_NAPI,"setPropertyExecute, worker pool thread execute."); AsyncHolder *asyncHolder = reinterpret_cast(data); if (asyncHolder == nullptr) { - HILOG_ERROR("SetPropertyExecute, asyncHolder == nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"SetPropertyExecute, asyncHolder == nullptr"); return; } SetPropertyInfo *setPropertyInfo = reinterpret_cast(asyncHolder->data); if (setPropertyInfo == nullptr) { - HILOG_ERROR("SetPropertyExecute, setPropertyInfo == nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"SetPropertyExecute, setPropertyInfo == nullptr"); return; } AuthType authTypeGet = AuthType(setPropertyInfo->authType); @@ -303,30 +303,30 @@ void UserAuthImpl::SetPropertyExecute(napi_env env, void *data) std::shared_ptr callback; callback.reset(object); UserAuth::GetInstance().SetProperty(request, callback); - HILOG_INFO("setPropertyExecute, worker pool thread execute end."); + USERAUTH_HILOGI(MODULE_JS_NAPI,"setPropertyExecute, worker pool thread execute end."); } void UserAuthImpl::SetPropertyPromiseExecuteDone(napi_env env, napi_status status, void *data) { - HILOG_INFO("SetPropertyPromiseExecuteDone, start"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"SetPropertyPromiseExecuteDone, start"); AsyncHolder *asyncHolder = reinterpret_cast(data); napi_delete_async_work(env, asyncHolder->asyncWork); delete asyncHolder; - HILOG_INFO("SetPropertyPromiseExecuteDone, end"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"SetPropertyPromiseExecuteDone, end"); } void UserAuthImpl::SetPropertyAsyncExecuteDone(napi_env env, napi_status status, void *data) { - HILOG_INFO("SetPropertyAsyncExecuteDone, start"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"SetPropertyAsyncExecuteDone, start"); AsyncHolder *asyncHolder = reinterpret_cast(data); napi_delete_async_work(env, asyncHolder->asyncWork); delete asyncHolder; - HILOG_INFO("SetPropertyAsyncExecuteDone, end"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"SetPropertyAsyncExecuteDone, end"); } napi_value UserAuthImpl::SetPropertyAsync(napi_env env, AsyncHolder *asyncHolder) { - HILOG_INFO("%{public}s, asyncCallback.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, asyncCallback.", __func__); napi_value result = nullptr; NAPI_CALL(env, napi_get_null(env, &result)); napi_value resourceName = nullptr; @@ -334,13 +334,13 @@ napi_value UserAuthImpl::SetPropertyAsync(napi_env env, AsyncHolder *asyncHolder NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, SetPropertyExecute, SetPropertyAsyncExecuteDone, (void *)asyncHolder, &asyncHolder->asyncWork)); NAPI_CALL(env, napi_queue_async_work(env, asyncHolder->asyncWork)); - HILOG_INFO("%{public}s, asyncCallback end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, asyncCallback end.", __func__); return result; } napi_value UserAuthImpl::SetPropertyPromise(napi_env env, AsyncHolder *asyncHolder) { - HILOG_INFO("%{public}s, promise.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, promise.", __func__); SetPropertyInfo *setPropertyInfo = reinterpret_cast(asyncHolder->data); napi_value resourceName = 0; NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); @@ -352,7 +352,7 @@ napi_value UserAuthImpl::SetPropertyPromise(napi_env env, AsyncHolder *asyncHold 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__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, promise end.", __func__); return promise; } @@ -365,7 +365,7 @@ napi_value UserAuthImpl::BuildAuthInfo(napi_env env, AuthInfo *authInfo) napi_value argv[ARGS_MAX_COUNT] = {nullptr}; NAPI_CALL(env, napi_get_cb_info(env, authInfo->info, &argc, argv, nullptr, nullptr)); if (argc != ARGS_FOUR) { - HILOG_ERROR("%{public}s, parms error.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s, parms error.", __func__); return nullptr; } authInfo->challenge = authBuild.GetUint8ArrayTo64(env, argv[0]); @@ -394,16 +394,16 @@ napi_value UserAuthImpl::BuildAuthInfo(napi_env env, AuthInfo *authInfo) napi_value UserAuthImpl::Auth(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start", __func__); AuthInfo *authInfo = new (std::nothrow) AuthInfo(); if (authInfo == nullptr) { - HILOG_INFO("%{public}s authInfo nullptr", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{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__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s BuildAuthInfo fail", __func__); delete authInfo; return ret; } @@ -412,31 +412,31 @@ napi_value UserAuthImpl::Auth(napi_env env, napi_callback_info info) napi_value UserAuthImpl::AuthWrap(napi_env env, AuthInfo *authInfo) { - HILOG_INFO("%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); AuthApiCallback *object = new AuthApiCallback(authInfo); std::shared_ptr callback; callback.reset(object); uint64_t result = UserAuth::GetInstance().Auth( authInfo->challenge, AuthType(authInfo->authType), AuthTurstLevel(authInfo->authTrustLevel), callback); - HILOG_INFO("UserAuth::GetInstance().Auth.result = %{public}llu", result); + USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuth::GetInstance().Auth.result = %{public}llu", result); napi_value key = authBuild.Uint64ToUint8Array(env, result); - HILOG_INFO("%{public}s, end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, end.", __func__); return key; } napi_value UserAuthImpl::AuthUser(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); AuthUserInfo *userInfo = new (std::nothrow) AuthUserInfo(); if (userInfo == nullptr) { - HILOG_INFO("%{public}s userInfo nullptr", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{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__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s BuildAuthUserInfo fail", __func__); delete userInfo; return ret; } @@ -451,7 +451,7 @@ napi_value UserAuthImpl::BuildAuthUserInfo(napi_env env, AuthUserInfo *userInfo) napi_value argv[ARGS_MAX_COUNT] = {nullptr}; NAPI_CALL(env, napi_get_cb_info(env, userInfo->info, &argc, argv, nullptr, nullptr)); if (argc != ARGS_FIVE) { - HILOG_ERROR("%{public}s, parms error.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s, parms error.", __func__); return nullptr; } if (authBuild.NapiTypeNumber(env, argv[PARAM0])) { @@ -471,7 +471,7 @@ napi_value UserAuthImpl::BuildAuthUserInfo(napi_env env, AuthUserInfo *userInfo) userInfo->authTrustLevel = level; } if (authBuild.NapiTypeObject(env, argv[PARAM4])) { - HILOG_INFO("AuthUser is Object"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthUser is Object"); userInfo->jsFunction = argv[PARAM4]; NAPI_CALL(env, napi_get_named_property(env, argv[PARAM4], "onResult", &userInfo->onResultCallBack)); NAPI_CALL(env, napi_create_reference(env, userInfo->onResultCallBack, PARAM1, &userInfo->onResult)); @@ -483,15 +483,15 @@ napi_value UserAuthImpl::BuildAuthUserInfo(napi_env env, AuthUserInfo *userInfo) napi_value UserAuthImpl::AuthUserWrap(napi_env env, AuthUserInfo *userInfo) { - HILOG_INFO("%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); AuthApiCallback *object = new AuthApiCallback(userInfo); std::shared_ptr callback; callback.reset(object); uint64_t result = UserAuth::GetInstance().AuthUser(userInfo->userId, userInfo->challenge, AuthType(userInfo->authType), AuthTurstLevel(userInfo->authTrustLevel), callback); - HILOG_INFO("UserAuth::GetInstance().AuthUser. result = %{public}llu", result); + USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuth::GetInstance().AuthUser. result = %{public}llu", result); napi_value key = authBuild.Uint64ToUint8Array(env, result); - HILOG_INFO("%{public}s, end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, end.", __func__); return key; } @@ -502,12 +502,12 @@ napi_value UserAuthImpl::CancelAuth(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); uint64_t contextId = authBuild.GetUint8ArrayTo64(env, argv[0]); - HILOG_INFO("CancelAuth contextId = %{public}llu", contextId); + USERAUTH_HILOGI(MODULE_JS_NAPI,"CancelAuth contextId = %{public}llu", contextId); if (contextId == 0) { return nullptr; } int32_t result = UserAuth::GetInstance().CancelAuth(contextId); - HILOG_INFO("CancelAuth result = %{public}d", result); + USERAUTH_HILOGI(MODULE_JS_NAPI,"CancelAuth result = %{public}d", result); napi_value key = 0; NAPI_CALL(env, napi_create_int32(env, result, &key)); return key; @@ -515,7 +515,7 @@ napi_value UserAuthImpl::CancelAuth(napi_env env, napi_callback_info info) napi_value AuthenticatorImpl::Execute(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); ExecuteInfo *executeInfo = new (std::nothrow) ExecuteInfo(); executeInfo->env = env; return ExecuteWrap(env, info, executeInfo); @@ -523,7 +523,7 @@ napi_value AuthenticatorImpl::Execute(napi_env env, napi_callback_info info) napi_value AuthenticatorImpl::ExecuteWrap(napi_env env, napi_callback_info info, ExecuteInfo* executeInfo) { - HILOG_INFO("%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); size_t argc = ARGS_MAX_COUNT; size_t callbackIndex = 0; napi_value argv[ARGS_MAX_COUNT] = {nullptr}; @@ -540,37 +540,37 @@ napi_value AuthenticatorImpl::ExecuteWrap(napi_env env, napi_callback_info info, } } -napi_value AuthenticatorImpl::ExecuteAsyncallback(napi_env env, napi_value* argv, ExecuteInfo* executeInfo) +void AuthenticatorImpl::JudgeString(napi_env env, napi_value* argv, ExecuteInfo* executeInfo) { - HILOG_INFO("%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); napi_valuetype valuetype; - NAPI_CALL(env, napi_typeof(env, argv[0], &valuetype)); + napi_typeof(env, argv[0], &valuetype); if (valuetype == napi_string) { char *type = nullptr; size_t typelen = 0; - NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], nullptr, 0, &typelen)); + napi_get_value_string_utf8(env, argv[0], nullptr, 0, &typelen); if (typelen > 0) { type = new char[typelen + 1]; - NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], type, typelen + 1, &typelen)); + napi_get_value_string_utf8(env, argv[0], type, typelen + 1, &typelen); executeInfo->type = type; delete[] type; } } - NAPI_CALL(env, napi_typeof(env, argv[1], &valuetype)); + napi_typeof(env, argv[1], &valuetype); if (valuetype == napi_string) { char *type1 = nullptr; size_t typelen1 = 0; - NAPI_CALL(env, napi_get_value_string_utf8(env, argv[1], nullptr, 0, &typelen1)); + napi_get_value_string_utf8(env, argv[1], nullptr, 0, &typelen1); if (typelen1 > 0) { type1 = new char[typelen1 + 1]; - NAPI_CALL(env, napi_get_value_string_utf8(env, argv[1], type1, typelen1 + 1, &typelen1)); + napi_get_value_string_utf8(env, argv[1], type1, typelen1 + 1, &typelen1); executeInfo->level = type1; delete[] type1; } } napi_value resourceName = nullptr; - NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); - NAPI_CALL(env, napi_create_async_work( + napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName); + napi_create_async_work( env, nullptr, resourceName, [](napi_env env, void *data) { ExecuteInfo *executeInfo = (ExecuteInfo *)data; @@ -581,8 +581,14 @@ napi_value AuthenticatorImpl::ExecuteAsyncallback(napi_env env, napi_value* argv ExecuteInfo *executeInfo = (ExecuteInfo *)data; napi_delete_async_work(env, executeInfo->asyncWork); }, - (void *)executeInfo, &executeInfo->asyncWork)); - NAPI_CALL(env, napi_queue_async_work(env, executeInfo->asyncWork)); + (void *)executeInfo, &executeInfo->asyncWork); + napi_queue_async_work(env, executeInfo->asyncWork); +} + +napi_value AuthenticatorImpl::ExecuteAsyncallback(napi_env env, napi_value* argv, ExecuteInfo* executeInfo) +{ + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + JudgeString(env,argv,executeInfo); napi_value result = RESULTVAR; NAPI_CALL(env, napi_get_null(env, &result)); return result; @@ -590,53 +596,14 @@ napi_value AuthenticatorImpl::ExecuteAsyncallback(napi_env env, napi_value* argv napi_value AuthenticatorImpl::ExecutePromise(napi_env env, napi_value* argv, ExecuteInfo* executeInfo) { - HILOG_INFO("%{public}s, start.", __func__); - napi_valuetype valuetype; - NAPI_CALL(env, napi_typeof(env, argv[0], &valuetype)); - if (valuetype == napi_string) { - char *type = nullptr; - size_t typelen = 0; - NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], nullptr, 0, &typelen)); - if (typelen > 0) { - type = new char[typelen + 1]; - NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], type, typelen + 1, &typelen)); - executeInfo->type = type; - delete[] type; - } - } - NAPI_CALL(env, napi_typeof(env, argv[1], &valuetype)); - if (valuetype == napi_string) { - char *type1 = nullptr; - size_t typelen1 = 0; - NAPI_CALL(env, napi_get_value_string_utf8(env, argv[1], nullptr, 0, &typelen1)); - if (typelen1 > 0) { - type1 = new char[typelen1 + 1]; - NAPI_CALL(env, napi_get_value_string_utf8(env, argv[1], type1, typelen1 + 1, &typelen1)); - executeInfo->level = type1; - delete[] type1; - } - } - 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, - [](napi_env env, void *data) { - ExecuteInfo *executeInfo = (ExecuteInfo *)data; - std::shared_ptr userauthAPI7callback = std::make_shared(executeInfo); - API7UserAuth::UserAuthAPI7::GetAuthenticator().Execute(executeInfo->type, executeInfo->level, userauthAPI7callback); - }, - [](napi_env env, napi_status status, void *data) { - ExecuteInfo *executeInfo = (ExecuteInfo *)data; - napi_delete_async_work(env, executeInfo->asyncWork); - }, - (void *)executeInfo, &executeInfo->asyncWork)); - NAPI_CALL(env, napi_queue_async_work(env, executeInfo->asyncWork)); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + JudgeString(env,argv,executeInfo); return executeInfo->promise; } napi_value AuthenticatorImpl::Cancel(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); napi_value ret; int32_t result = API7UserAuth::UserAuthAPI7::GetAuthenticator().Cancel(); NAPI_CALL(env,napi_create_int32(env, result, &ret)); @@ -645,7 +612,7 @@ napi_value AuthenticatorImpl::Cancel(napi_env env, napi_callback_info info) napi_value AuthenticatorImpl::CheckAvailability(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); napi_value ret; int32_t result = 0; size_t argc = PARAM2; @@ -686,7 +653,7 @@ napi_value AuthenticatorImpl::CheckAvailability(napi_env env, napi_callback_info napi_value AuthenticatorImpl::On(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); size_t argc = PARAM2; napi_value argv[PARAM2] = {0}; FunctionOnAndOffInfo* functionOnAndOffInfo = new (std::nothrow) FunctionOnAndOffInfo(); @@ -717,7 +684,7 @@ napi_value AuthenticatorImpl::On(napi_env env, napi_callback_info info) napi_value AuthenticatorImpl::Off(napi_env env, napi_callback_info info) { - HILOG_INFO("%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); size_t argc = PARAM2; napi_value argv[PARAM2] = {0}; FunctionOnAndOffInfo* functionOnAndOffInfo = new (std::nothrow) FunctionOnAndOffInfo(); @@ -741,6 +708,24 @@ napi_value AuthenticatorImpl::Off(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_get_null(env, &result)); return result; } + +static napi_value ModuleInit(napi_env env, napi_value exports) +{ + OHOS::UserIAM::UserAuth::Init(env, exports); + return exports; +} +extern "C" __attribute__((constructor)) void RegisterModule(void) +{ + napi_module module = {.nm_version = 1, // NAPI v1 + .nm_flags = 0, // normal + .nm_filename = nullptr, + .nm_register_func = ModuleInit, + .nm_modname = "UserAuth", + .nm_priv = nullptr, + .reserved = {}}; + napi_module_register(&module); +} + } // namespace UserAuth } // namespace UserIAM } // namespace OHOS diff --git a/interfaces/innerkits/native/include/userauth_api7_hilog_wrapper.h b/interfaces/innerkits/native/include/userauth_api7_hilog_wrapper.h deleted file mode 100755 index 517032c96..000000000 --- a/interfaces/innerkits/native/include/userauth_api7_hilog_wrapper.h +++ /dev/null @@ -1,72 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef USERAUTH_API7_HILOG_WRAPPER_H -#define USERAUTH_API7_HILOG_WRAPPER_H - -#define CONFIG_HILOG -#ifdef CONFIG_HILOG - -#include "hilog/log.h" - -namespace OHOS { -namespace UserIAM { -namespace API7UserAuth { -#define filename__ (__builtin_strrchr(__FILE__, '/') ? __builtin_strrchr(__FILE__, '/') + 1 : __FILE__) -#define formated__(fmt, ...) "[%{public}s] %{public}s# " fmt, filename__, __FUNCTION__, ##__VA_ARGS__ - - -#ifdef USERAUTH_API7_HILOGE -#undef USERAUTH_API7_HILOGE -#endif - -#ifdef USERAUTH_API7_HILOGD -#undef USERAUTH_API7_HILOGD -#endif - -// param of log interface, such as USERAUTH_API7_HILOGF. -enum UserAuthAPI7SubModule { - MODULE_API7 = 0, - USERAUTHAPI7_MODULE_BUTT, -}; - -// 0xD002900: subsystem:distributeddatamgr module:distributedgallery, 8 bits reserved. -static constexpr unsigned int BASE_USERAUTH_API7_DOMAIN_ID = 0xD002910; - -enum UserAuthAPI7DomainId { - USERAUTH_API7_DOMAIN = BASE_USERAUTH_API7_DOMAIN_ID + MODULE_API7, - USERAUTH_API7_BUTT, -}; - -static constexpr OHOS::HiviewDFX::HiLogLabel L_LABEL[USERAUTHAPI7_MODULE_BUTT] = { - {LOG_CORE, USERAUTH_API7_DOMAIN, "UserAUTH_API7"}, -}; - -// In order to improve performance, do not check the module range. -// Besides, make sure module is less than USERAUTH_API7_MODULE_BUTT. -#define USERAUTH_API7_HILOGE(module, ...) (void)OHOS::HiviewDFX::HiLog::Error(L_LABEL[module], formated__(__VA_ARGS__)) -#define USERAUTH_API7_HILOGD(module, ...) (void)OHOS::HiviewDFX::HiLog::Debug(L_LABEL[module], formated__(__VA_ARGS__)) -} // namespace UserAUTH_API7 -} // namespace UserIAM -} // namespace OHOS - -#else - -#define USERAUTH_API7_HILOGE(...) -#define USERAUTH_API7_HILOGD(...) - -#endif // CONFIG_HILOG - -#endif // USERAUTH_API7_HILOG_WRAPPER_H diff --git a/interfaces/kits/napi/BUILD.gn b/interfaces/kits/napi/BUILD.gn index a84551cd3..777be8efe 100755 --- a/interfaces/kits/napi/BUILD.gn +++ b/interfaces/kits/napi/BUILD.gn @@ -24,7 +24,6 @@ config("userauth_public_config") { ohos_shared_library("userauthnorth") { sources = [ - "src/auth_native_module.cpp", "src/user_auth_helper_north.cpp", ] @@ -36,6 +35,7 @@ ohos_shared_library("userauthnorth") { "//foundation/ace/napi:ace_napi", ] + configs = [ "${userauth_utils_path}:utils_config" ] public_configs = [ ":userauth_public_config" ] external_deps = [ "ipc:ipc_core" ] @@ -48,5 +48,5 @@ ohos_shared_library("userauthnorth") { public_deps = [] relative_install_dir = "module" part_name = "user_auth" - subsystem_name = "useriam" + subsystem_name = "user_iam" } diff --git a/interfaces/kits/napi/src/auth_native_module.cpp b/interfaces/kits/napi/src/auth_native_module.cpp deleted file mode 100755 index b826a2a11..000000000 --- a/interfaces/kits/napi/src/auth_native_module.cpp +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include - -#include "user_auth_helper_north.h" - -namespace OHOS { -namespace UserAuthNorth { -static napi_value ModuleInit(napi_env env, napi_value exports) -{ - OHOS::UserAuthNorth::Init(env, exports); - return exports; -} -extern "C" __attribute__((constructor)) void RegisterModule(void) -{ - napi_module module = { - .nm_version = 1, // NAPI v1 - .nm_flags = 0, // normal - .nm_filename = nullptr, - .nm_register_func = ModuleInit, - .nm_modname = "UserAuthNorth", - .nm_priv = nullptr, - .reserved = {} - }; - napi_module_register(&module); -} -} // namespace UserAuthNorth -} // namespace OHOS diff --git a/interfaces/kits/napi/src/user_auth_helper_north.cpp b/interfaces/kits/napi/src/user_auth_helper_north.cpp index 2b4f842ab..4f8443a44 100755 --- a/interfaces/kits/napi/src/user_auth_helper_north.cpp +++ b/interfaces/kits/napi/src/user_auth_helper_north.cpp @@ -15,10 +15,11 @@ #include "user_auth_helper_north.h" -#include "auth_hilog_wrapper.h" +#include "userauth_hilog_wrapper.h" #include "user_auth_impl.h" #include "user_auth_helper.h" +using namespace OHOS::UserIAM::UserAuth; namespace OHOS { namespace UserAuthNorth { napi_value Constructor(napi_env env, napi_callback_info info) @@ -27,7 +28,7 @@ napi_value Constructor(napi_env env, napi_callback_info info) napi_value userAuth = nullptr; NAPI_CALL(env, napi_new_instance(env, GetCtor(env), 0, nullptr, &userAuth)); NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); - HILOG_INFO("UserAuthNorth, Constructor start"); + USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthNorth, Constructor start"); return userAuth; } @@ -53,8 +54,28 @@ void Init(napi_env env, napi_value exports) }; status = napi_define_properties(env, exports, sizeof(exportFuncs) / sizeof(*exportFuncs), exportFuncs); if (status != napi_ok) { - HILOG_ERROR("napi_define_properties faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_define_properties faild"); } } + +static napi_value ModuleInit(napi_env env, napi_value exports) +{ + OHOS::UserAuthNorth::Init(env, exports); + return exports; +} +extern "C" __attribute__((constructor)) void RegisterModule(void) +{ + napi_module module = { + .nm_version = 1, // NAPI v1 + .nm_flags = 0, // normal + .nm_filename = nullptr, + .nm_register_func = ModuleInit, + .nm_modname = "UserAuthNorth", + .nm_priv = nullptr, + .reserved = {} + }; + napi_module_register(&module); +} + } // namespace UserAuthNorth } // namespace OHOS \ No newline at end of file diff --git a/services/src/userauth_adapter.cpp b/services/src/userauth_adapter.cpp index 280f3a95b..5c08655bb 100644 --- a/services/src/userauth_adapter.cpp +++ b/services/src/userauth_adapter.cpp @@ -27,7 +27,7 @@ namespace OHOS { namespace UserIAM { namespace UserAuth { -const int USERAUTH_VERSION = 1235; +const int g_userAuthVersion = 1235; UserAuthAdapter &UserAuthAdapter::GetInstance() { static UserAuthAdapter instance; @@ -211,7 +211,7 @@ int32_t UserAuthAdapter::Cancel(uint64_t sessionId) int32_t UserAuthAdapter::GetVersion() { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuth GetVersion is start!"); - int32_t version = USERAUTH_VERSION; + int32_t version = g_userAuthVersion; return version; } diff --git a/services/src/userauth_async_proxy.cpp b/services/src/userauth_async_proxy.cpp index ab5dec89e..30660bb26 100755 --- a/services/src/userauth_async_proxy.cpp +++ b/services/src/userauth_async_proxy.cpp @@ -29,7 +29,7 @@ void UserAuthAsyncProxy::onAcquireInfo(const int32_t module, const uint32_t acqu if (!data.WriteInterfaceToken(UserAuthAsyncProxy::GetDescriptor())) { USERAUTH_HILOGE(MODULE_SERVICE, "userauth write descriptor failed!"); - return ; + return; } if (!data.WriteInt32(module)) { USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteInt32(module)."); @@ -92,7 +92,7 @@ void UserAuthAsyncProxy::onExecutorPropertyInfo(const ExecutorProperty result) MessageParcel reply; if (!data.WriteInterfaceToken(UserAuthAsyncProxy::GetDescriptor())) { USERAUTH_HILOGI(MODULE_SERVICE, "userauth write descriptor failed!"); - return ; + return; } if (!data.WriteInt32(result.result)) { USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteInt32(result.result)."); @@ -126,7 +126,7 @@ void UserAuthAsyncProxy::onSetExecutorProperty(const int32_t result) MessageParcel reply; if (!data.WriteInterfaceToken(UserAuthAsyncProxy::GetDescriptor())) { USERAUTH_HILOGE(MODULE_SERVICE, "userauth write descriptor failed!"); - return ; + return; } if (!data.WriteInt32(result)) { USERAUTH_HILOGE(MODULE_SERVICE, "failed to WriteInt32(result)."); diff --git a/services/src/userauth_excallback_impl.cpp b/services/src/userauth_excallback_impl.cpp index d15f513ee..5b6b2a0d7 100644 --- a/services/src/userauth_excallback_impl.cpp +++ b/services/src/userauth_excallback_impl.cpp @@ -272,7 +272,7 @@ UserAuthCallbackImplIDMGetPorp::UserAuthCallbackImplIDMGetPorp(const sptr& info) { - USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthCallbackImplIDMGetPorp OnGetInfo enter"); + USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthCallbackImplIDMGetPorp OnGetInfo enter"); ExecutorProperty executorProperty = {}; if (info.size() == 0) { executorProperty.result = GENERAL_ERROR; @@ -316,7 +316,7 @@ UserAuthCallbackImplIDMCothGetPorpFreez::UserAuthCallbackImplIDMCothGetPorpFreez } void UserAuthCallbackImplIDMCothGetPorpFreez::OnGetInfo(std::vector& info) { - USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthCallbackImplIDMCothGetPorpFreez OnGetInfo enter"); + USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthCallbackImplIDMCothGetPorpFreez OnGetInfo enter"); std::vector templateIds; AuthResult authResult; if (info.size() == 0) { diff --git a/services/src/userauth_service.cpp b/services/src/userauth_service.cpp index b220724e6..c584614f4 100644 --- a/services/src/userauth_service.cpp +++ b/services/src/userauth_service.cpp @@ -100,7 +100,7 @@ void UserAuthService::GetProperty(const GetPropertyRequest request, sptr dr = new UserAuthServiceCallbackDeathRecipient(callback); -- Gitee From 1e2e1123c117eb1f6073867ec94b268e6d260218 Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Mon, 14 Feb 2022 19:16:33 +0800 Subject: [PATCH 14/19] [user_auth]code update for napi review-1 1.fix napi code for review 2.add requestauthresult log out 3.Delete useless errcode files Signed-off-by: yanfang.gu --- interfaces/innerkits/napi/src/auth_build.cpp | 22 +-- .../innerkits/napi/src/authapi_callback.cpp | 153 +++++++++--------- .../innerkits/napi/src/result_convert.cpp | 32 ++-- .../innerkits/napi/src/user_auth_helper.cpp | 49 +++--- .../innerkits/napi/src/user_auth_impl.cpp | 150 ++++++++--------- .../kits/napi/src/user_auth_helper_north.cpp | 13 +- services/src/userauth_adapter.cpp | 3 +- services/src/userauth_excallback_impl.cpp | 1 + utils/native/include/userauth_errors.h | 36 ----- 9 files changed, 212 insertions(+), 247 deletions(-) delete mode 100644 utils/native/include/userauth_errors.h diff --git a/interfaces/innerkits/napi/src/auth_build.cpp b/interfaces/innerkits/napi/src/auth_build.cpp index 0ca4e572a..381793b1c 100755 --- a/interfaces/innerkits/napi/src/auth_build.cpp +++ b/interfaces/innerkits/napi/src/auth_build.cpp @@ -12,9 +12,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include #include "auth_build.h" - #include "auth_common.h" #include "userauth_hilog_wrapper.h" #include "auth_object.h" @@ -33,14 +33,14 @@ Napi_SetPropertyRequest AuthBuild::SetPropertyRequestBuild(napi_env env, napi_va { Napi_SetPropertyRequest request; if (object == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"SetPropertyRequestBuild object is null "); + USERAUTH_HILOGE(MODULE_JS_NAPI, "SetPropertyRequestBuild object is null"); return request; } request.authType_ = convert.GetInt32ValueByKey(env, object, "authType"); request.key_ = convert.GetInt32ValueByKey(env, object, "key"); request.setInfo_ = convert.NapiGetValueUint8Array(env, object, "setInfo"); - USERAUTH_HILOGI(MODULE_JS_NAPI," AuthBuild::SetPropertyRequestBuild authType = %{public}d", request.authType_); - USERAUTH_HILOGI(MODULE_JS_NAPI," AuthBuild::SetPropertyRequestBuild key = %{public}d", request.key_); + USERAUTH_HILOGI(MODULE_JS_NAPI, "AuthBuild::SetPropertyRequestBuild authType = %{public}d, key = %{public}d", + request.authType_, request.key_); return request; } @@ -48,12 +48,12 @@ Napi_GetPropertyRequest AuthBuild::GetPropertyRequestBuild(napi_env env, napi_va { Napi_GetPropertyRequest request; if (object == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"GetPropertyRequestBuild object is null "); + USERAUTH_HILOGE(MODULE_JS_NAPI, "GetPropertyRequestBuild object is null"); return request; } request.authType_ = convert.GetInt32ValueByKey(env, object, "authType"); request.keys_ = convert.GetInt32ArrayValueByKey(env, object, "keys"); - USERAUTH_HILOGI(MODULE_JS_NAPI," AuthBuild::GetPropertyRequestBuild authType = %{public}d", request.authType_); + USERAUTH_HILOGI(MODULE_JS_NAPI, "AuthBuild::GetPropertyRequestBuild authType = %{public}d", request.authType_); return request; } @@ -91,26 +91,26 @@ uint64_t AuthBuild::GetUint8ArrayTo64(napi_env env, napi_value value) bool isTypedArray = false; napi_is_typedarray(env, value, &isTypedArray); if (!isTypedArray) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"GetUint8ArrayTo64 value is not typedarray"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "GetUint8ArrayTo64 value is not typedarray"); return 0; } napi_get_typedarray_info(env, value, &arraytype, &length, reinterpret_cast(&data), &buffer, &offset); if (arraytype != napi_uint8_array) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"GetUint8ArrayTo64 js value is not uint8Array"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "GetUint8ArrayTo64 js value is not uint8Array"); return 0; } if (offset != 0) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"offset is %{public}d", offset); + USERAUTH_HILOGE(MODULE_JS_NAPI, "offset is %{public}d", offset); return 0; } std::vector result(data, data + length); uint8_t tmp[sizeof(uint64_t)]; for (uint32_t i = 0; i < sizeof(uint64_t); i++) { tmp[i] = result[i]; - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetUint8ArrayTo64 result is %{public}d", (unsigned)result[i]); + USERAUTH_HILOGI(MODULE_JS_NAPI, "GetUint8ArrayTo64 result is %{public}d", (unsigned)result[i]); } uint64_t *re = static_cast(static_cast(tmp)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetUint8ArrayTo64 resultUint64 is %{public}llu", *re); + USERAUTH_HILOGI(MODULE_JS_NAPI, "GetUint8ArrayTo64 resultUint64 is %{public}" PRIu64 "", *re); return *re; } diff --git a/interfaces/innerkits/napi/src/authapi_callback.cpp b/interfaces/innerkits/napi/src/authapi_callback.cpp index 44ee9455b..9252cba74 100755 --- a/interfaces/innerkits/napi/src/authapi_callback.cpp +++ b/interfaces/innerkits/napi/src/authapi_callback.cpp @@ -13,11 +13,11 @@ * limitations under the License. */ -#include "authapi_callback.h" - +#include #include -#include "securec.h" +#include "authapi_callback.h" +#include "securec.h" #include "userauth_hilog_wrapper.h" namespace OHOS { @@ -52,7 +52,7 @@ API7callback::API7callback(FunctionOnAndOffInfo* functionOnAndOffInfo) void API7callback::API7OnResultWrap(uv_loop_s *loop, uv_work_t *work) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"authFace : %{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "authFace : %{public}s, start.", __func__); uv_queue_work(loop, work, [] (uv_work_t *work) { }, [] (uv_work_t *work, int status) { ExecuteInfo *executeInfo = reinterpret_cast(work->data); if (executeInfo == nullptr) { @@ -86,23 +86,29 @@ void API7callback::API7OnResultWrap(uv_loop_s *loop, uv_work_t *work) void API7callback::API7OnResult(const int32_t result) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"authFace : %{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "authFace : %{public}s, start.", __func__); if (executeInfo_ != nullptr) { napi_env env = executeInfo_->env; napi_status status = napi_create_int32(env, result, &executeInfo_->result); if (status != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_create_int32 faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_create_int32 faild"); } uv_loop_s *loop(nullptr); status = napi_get_uv_event_loop(env, &loop); if (status != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_uv_event_loop faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_get_uv_event_loop faild"); } if (loop == nullptr) { + USERAUTH_HILOGE(MODULE_JS_NAPI, "loop is null"); + delete executeInfo_; + executeInfo_ = nullptr; return; } uv_work_t *work = new(std::nothrow) uv_work_t; if (work == nullptr) { + USERAUTH_HILOGE(MODULE_JS_NAPI, "work is null"); + delete executeInfo_; + executeInfo_ = nullptr; return; } ExecuteInfo *executeInfo = new (std::nothrow) ExecuteInfo(); @@ -115,13 +121,13 @@ void API7callback::API7OnResult(const int32_t result) work->data = reinterpret_cast(executeInfo); API7OnResultWrap(loop, work); } else { - USERAUTH_HILOGE(MODULE_JS_NAPI,"asyncCallbackContext_ is nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "asyncCallbackContext_ is nullptr"); } } void API7callback::TipCallbackWrap(uv_loop_s *loop, uv_work_t *work) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"authFace : %{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "authFace : %{public}s, start.", __func__); uv_queue_work(loop, work, [] (uv_work_t *work) { }, [] (uv_work_t *work, int status) { FunctionOnAndOffInfo *functionOnAndOffInfo = reinterpret_cast(work->data); if (functionOnAndOffInfo == nullptr) { @@ -150,20 +156,26 @@ void API7callback::TipCallbackWrap(uv_loop_s *loop, uv_work_t *work) void API7callback::TipCallback(const API7UserAuth::Tip result) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"authFace : %{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "authFace : %{public}s, start.", __func__); if (functionOnAndOffInfo_ != nullptr) { napi_env env = functionOnAndOffInfo_->env; functionOnAndOffInfo_->param[PARAM0] = ResultTips(env,result); uv_loop_s *loop(nullptr); napi_status status = napi_get_uv_event_loop(env, &loop); if (status != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_uv_event_loop faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_get_uv_event_loop faild"); } if (loop == nullptr) { + USERAUTH_HILOGE(MODULE_JS_NAPI, "loop is null"); + delete functionOnAndOffInfo_; + functionOnAndOffInfo_ = nullptr; return; } uv_work_t *work = new(std::nothrow) uv_work_t; if (work == nullptr) { + USERAUTH_HILOGE(MODULE_JS_NAPI, "work is null"); + delete functionOnAndOffInfo_; + functionOnAndOffInfo_ = nullptr; return; } FunctionOnAndOffInfo *functionOnAndOffInfo = new (std::nothrow) FunctionOnAndOffInfo(); @@ -176,14 +188,14 @@ void API7callback::TipCallback(const API7UserAuth::Tip result) work->data = reinterpret_cast(functionOnAndOffInfo); TipCallbackWrap(loop, work); } else { - USERAUTH_HILOGE(MODULE_JS_NAPI,"asyncCallbackContext_ is nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "asyncCallbackContext_ is nullptr"); } - USERAUTH_HILOGI(MODULE_JS_NAPI,"TipCallback is end"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "TipCallback is end"); } napi_value API7callback::ResultTips(napi_env env, const API7UserAuth::Tip result) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"authFace : %{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "authFace : %{public}s, start.", __func__); napi_value obj; napi_value errorCode; napi_value tipCode; @@ -205,13 +217,13 @@ napi_value API7callback::ResultTips(napi_env env, const API7UserAuth::Tip result napi_value AuthApiCallback::Uint8ArrayToNapi(napi_env env, std::vector value) { int size = value.size(); - USERAUTH_HILOGI(MODULE_JS_NAPI,"Uint8ArrayToNapi size = %{public}d", size); + USERAUTH_HILOGI(MODULE_JS_NAPI, "Uint8ArrayToNapi size = %{public}d", size); napi_value out = nullptr; void *data = nullptr; napi_value buffer = nullptr; NAPI_CALL(env, napi_create_arraybuffer(env, value.size(), &data, &buffer)); if (memcpy_s(data, value.size(), value.data(), value.size()) != 0) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"AuthApiCallback Uint8ArrayToNapi error"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "AuthApiCallback Uint8ArrayToNapi error"); } NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, value.size(), buffer, 0, &out)); return out; @@ -238,26 +250,26 @@ napi_value AuthApiCallback::BuildOnResult( void AuthApiCallback::OnAuthAcquireInfo(AcquireInfoInner *acquireInfoInner) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback OnAuthAcquireInfo start"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "AuthApiCallback OnAuthAcquireInfo start"); uv_loop_s *loop(nullptr); napi_get_uv_event_loop(authInfo_->callBackInfo.env, &loop); if (loop == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"loop is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "loop is null"); delete acquireInfoInner; return; } uv_work_t *work = new (std::nothrow) uv_work_t; if (work == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"work is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "work is null"); delete acquireInfoInner; return; } work->data = reinterpret_cast(acquireInfoInner); uv_queue_work(loop, work, [] (uv_work_t *work) {}, [] (uv_work_t *work, int status) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"Do OnAuthAcquireInfo work"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "Do OnAuthAcquireInfo work"); AcquireInfoInner *acquireInfoInner = reinterpret_cast(work->data); if (acquireInfoInner == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"authInfo is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "authInfo is null"); delete work; return; } @@ -266,7 +278,7 @@ void AuthApiCallback::OnAuthAcquireInfo(AcquireInfoInner *acquireInfoInner) napi_value callback; napi_status napiStatus = napi_get_reference_value(env, acquireInfoInner->onAcquireInfo, &callback); if (napiStatus != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_reference_value faild "); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_get_reference_value faild"); delete acquireInfoInner; delete work; return; @@ -277,7 +289,7 @@ void AuthApiCallback::OnAuthAcquireInfo(AcquireInfoInner *acquireInfoInner) napi_create_int32(env, acquireInfoInner->extraInfo, ¶ms[PARAM2]); napiStatus = napi_call_function(env, acquireInfoInner->jsFunction, callback, PARAM3, params, &returnOnAcquire); if (napiStatus != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_call_function faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_call_function faild"); } delete acquireInfoInner; delete work; @@ -289,7 +301,7 @@ void AuthApiCallback::onAcquireInfo(const int32_t module, const uint32_t acquire if (userInfo_ != nullptr) { AcquireInfoInner *acquireInfoInner = new (std::nothrow) AcquireInfoInner(); if (acquireInfoInner == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"acquireInfoInner is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "acquireInfoInner is null"); return; } acquireInfoInner->env = userInfo_->callBackInfo.env; @@ -300,13 +312,13 @@ void AuthApiCallback::onAcquireInfo(const int32_t module, const uint32_t acquire acquireInfoInner->extraInfo = extraInfo; OnAuthAcquireInfo(acquireInfoInner); } else { - USERAUTH_HILOGE(MODULE_JS_NAPI,"AuthApiCallback onAcquireInfo userInfo_ is nullptr "); + USERAUTH_HILOGE(MODULE_JS_NAPI, "AuthApiCallback onAcquireInfo userInfo_ is nullptr"); } if (authInfo_ != nullptr) { AcquireInfoInner *acquireInfoInner = new (std::nothrow) AcquireInfoInner(); if (acquireInfoInner == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"acquireInfoInner is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "acquireInfoInner is null"); return; } acquireInfoInner->env = authInfo_->callBackInfo.env; @@ -317,17 +329,17 @@ void AuthApiCallback::onAcquireInfo(const int32_t module, const uint32_t acquire acquireInfoInner->extraInfo = extraInfo; OnAuthAcquireInfo(acquireInfoInner); } else { - USERAUTH_HILOGE(MODULE_JS_NAPI,"AuthApiCallback onAcquireInfo authInfo_ is nullptr "); + USERAUTH_HILOGE(MODULE_JS_NAPI, "AuthApiCallback onAcquireInfo authInfo_ is nullptr"); } - USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback onAcquireInfo end"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "AuthApiCallback onAcquireInfo end"); } static void OnUserAuthResultWork(uv_work_t *work, int status) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"Do OnUserAuthResult work"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "Do OnUserAuthResult work"); AuthUserInfo *userInfo = reinterpret_cast(work->data); if (userInfo == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"authInfo is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "authInfo is null"); delete work; return; } @@ -335,7 +347,7 @@ static void OnUserAuthResultWork(uv_work_t *work, int status) napi_value callback; napi_status napiStatus = napi_get_reference_value(env, userInfo->onResult, &callback); if (napiStatus != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_reference_value faild "); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_get_reference_value faild"); delete userInfo; delete work; return; @@ -352,18 +364,18 @@ static void OnUserAuthResultWork(uv_work_t *work, int status) void AuthApiCallback::OnUserAuthResult(const int32_t result, const AuthResult extraInfo) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback OnUserAuthResult start"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "AuthApiCallback OnUserAuthResult start"); uv_loop_s *loop(nullptr); napi_get_uv_event_loop(userInfo_->callBackInfo.env, &loop); if (loop == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"loop is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "loop is null"); delete userInfo_; userInfo_ = nullptr; return; } uv_work_t *work = new (std::nothrow) uv_work_t; if (work == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"work is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "work is null"); delete userInfo_; userInfo_ = nullptr; return; @@ -379,10 +391,10 @@ void AuthApiCallback::OnUserAuthResult(const int32_t result, const AuthResult ex static void OnAuthResultWork(uv_work_t *work, int status) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"Do OnAuthResult work"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "Do OnAuthResult work"); AuthInfo *authInfo = reinterpret_cast(work->data); if (authInfo == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"authInfo is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "authInfo is null"); delete work; return; } @@ -390,7 +402,7 @@ static void OnAuthResultWork(uv_work_t *work, int status) napi_value callback; napi_status napiStatus = napi_get_reference_value(env, authInfo->onResult, &callback); if (napiStatus != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_reference_value faild "); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_get_reference_value faild"); delete authInfo; delete work; return; @@ -407,18 +419,18 @@ static void OnAuthResultWork(uv_work_t *work, int status) void AuthApiCallback::OnAuthResult(const int32_t result, const AuthResult extraInfo) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback OnAuthResult start"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "AuthApiCallback OnAuthResult start"); uv_loop_s *loop(nullptr); napi_get_uv_event_loop(authInfo_->callBackInfo.env, &loop); if (loop == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"loop is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "loop is null"); delete authInfo_; authInfo_ = nullptr; return; } uv_work_t *work = new (std::nothrow) uv_work_t; if (work == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"work is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "work is null"); delete authInfo_; authInfo_ = nullptr; return; @@ -434,21 +446,18 @@ void AuthApiCallback::OnAuthResult(const int32_t result, const AuthResult extraI void AuthApiCallback::onResult(const int32_t result, const AuthResult extraInfo) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback onResult start result = %{public}d", result); - USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback onResult start token.length = %{public}d", extraInfo.token.size()); - USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback onResult start extraInfo.remainTimes = %{public}u", extraInfo.remainTimes); - USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback onResult start extraInfo.freezingTime = %{public}u", extraInfo.freezingTime); + USERAUTH_HILOGI(MODULE_JS_NAPI, "AuthApiCallback onResult start result = %{public}d", result); if (userInfo_ != nullptr) { OnUserAuthResult(result, extraInfo); } else { - USERAUTH_HILOGE(MODULE_JS_NAPI,"AuthApiCallback onResult userInfo_ is nullptr "); + USERAUTH_HILOGE(MODULE_JS_NAPI, "AuthApiCallback onResult userInfo_ is nullptr"); } if (authInfo_ != nullptr) { OnAuthResult(result, extraInfo); } else { - USERAUTH_HILOGE(MODULE_JS_NAPI,"AuthApiCallback onResult authInfo_ is nullptr "); + USERAUTH_HILOGE(MODULE_JS_NAPI, "AuthApiCallback onResult authInfo_ is nullptr"); } - USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthApiCallback onResult end"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "AuthApiCallback onResult end"); } GetPropApiCallback::GetPropApiCallback(GetPropertyInfo *getPropertyInfo) @@ -462,10 +471,10 @@ GetPropApiCallback::~GetPropApiCallback() static void GetPropertyInfoCallback(uv_work_t* work, int status) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"Do OnAuthAcquireInfo work"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "Do OnAuthAcquireInfo work"); GetPropertyInfo *getPropertyInfo = reinterpret_cast(work->data); if (getPropertyInfo == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"getPropertyInfo is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "getPropertyInfo is null"); delete work; return; } @@ -474,32 +483,32 @@ static void GetPropertyInfoCallback(uv_work_t* work, int status) resultData[PARAM0] = GetPropApiCallback::BuildExecutorProperty(env, getPropertyInfo->getResult, getPropertyInfo->remainTimes, getPropertyInfo->freezingTime, getPropertyInfo->authSubType); if (getPropertyInfo->callBackInfo.callBack != nullptr) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"onExecutorPropertyInfo async"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "onExecutorPropertyInfo async"); napi_value global = nullptr; napi_status napiStatus = napi_get_global(env, &global); if (napiStatus != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_global faild "); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_get_global faild"); goto EXIT; } napi_value resultValue = nullptr; napi_value callBack = nullptr; napiStatus = napi_get_reference_value(env, getPropertyInfo->callBackInfo.callBack, &callBack); if (napiStatus != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_reference_value faild "); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_get_reference_value faild"); goto EXIT; } napiStatus = napi_call_function(env, global, callBack, PARAM1, resultData, &resultValue); if (napiStatus != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_call_function faild "); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_call_function faild"); goto EXIT; } } else { - USERAUTH_HILOGI(MODULE_JS_NAPI,"onExecutorPropertyInfo promise"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "onExecutorPropertyInfo promise"); napi_value resultValue = resultData[PARAM0]; napi_deferred deferred = getPropertyInfo->callBackInfo.deferred; napi_status napiStatus = napi_resolve_deferred(env, deferred, resultValue); if (napiStatus != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_resolve_deferred faild "); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_resolve_deferred faild"); goto EXIT; } } @@ -534,25 +543,21 @@ napi_value GetPropApiCallback::BuildExecutorProperty( void GetPropApiCallback::onGetProperty(const ExecutorProperty result) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropApiCallback onGetProperty 1 = %{public}d", result.result); - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropApiCallback onGetProperty 2 = %{public}llu", result.authSubType); - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropApiCallback onGetProperty 3 = %{public}u", result.remainTimes); - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropApiCallback onGetProperty 4 = %{public}u", result.freezingTime); if (getPropertyInfo_ == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"GetPropApiCallback onGetProperty getPropertyInfo_ is nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "GetPropApiCallback onGetProperty getPropertyInfo_ is nullptr"); return; } uv_loop_s *loop(nullptr); napi_get_uv_event_loop(getPropertyInfo_->callBackInfo.env, &loop); if (loop == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"loop is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "loop is null"); delete getPropertyInfo_; getPropertyInfo_ = nullptr; return; } uv_work_t *work = new (std::nothrow) uv_work_t; if (work == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"work is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "work is null"); delete getPropertyInfo_; getPropertyInfo_ = nullptr; return; @@ -563,7 +568,7 @@ void GetPropApiCallback::onGetProperty(const ExecutorProperty result) getPropertyInfo_->freezingTime = result.freezingTime; work->data = reinterpret_cast(getPropertyInfo_); getPropertyInfo_ = nullptr; - USERAUTH_HILOGI(MODULE_JS_NAPI,"Before GetPropertyInfoCallback"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "Before GetPropertyInfoCallback"); uv_queue_work(loop, work, [] (uv_work_t *work) {}, GetPropertyInfoCallback); } @@ -578,24 +583,24 @@ SetPropApiCallback::~SetPropApiCallback() static void SetExecutorPropertyCallback(uv_work_t *work, int status) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"Do SetExecutorPropertyCallback work"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "Do SetExecutorPropertyCallback work"); SetPropertyInfo *setPropertyInfo = reinterpret_cast(work->data); if (setPropertyInfo == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"authInfo is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "authInfo is null"); delete work; return; } napi_env env = setPropertyInfo->callBackInfo.env; napi_status napiStatus = napi_create_int32(env, setPropertyInfo->setResult, &setPropertyInfo->result); if (napiStatus != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_create_int32 faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_create_int32 faild"); goto EXIT; } if (setPropertyInfo->callBackInfo.callBack != nullptr) { napi_value global = nullptr; napiStatus = napi_get_global(env, &global); if (napiStatus != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_global faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_get_global faild"); goto EXIT; } napi_value resultData[PARAM1]; @@ -605,12 +610,12 @@ static void SetExecutorPropertyCallback(uv_work_t *work, int status) napi_value callBack = nullptr; napiStatus = napi_get_reference_value(env, setPropertyInfo->callBackInfo.callBack, &callBack); if (napiStatus != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_reference_value faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_get_reference_value faild"); goto EXIT; } napiStatus = napi_call_function(env, global, callBack, PARAM1, resultData, &result); if (napiStatus != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_call_function faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_call_function faild"); goto EXIT; } } else { @@ -618,7 +623,7 @@ static void SetExecutorPropertyCallback(uv_work_t *work, int status) napi_deferred deferred = setPropertyInfo->callBackInfo.deferred; napiStatus = napi_resolve_deferred(env, deferred, result); if (napiStatus != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_call_function faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_call_function faild"); goto EXIT; } } @@ -629,22 +634,22 @@ EXIT: void SetPropApiCallback::onSetProperty(const int32_t result) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"onSetProperty start = %{public}d", result); + USERAUTH_HILOGI(MODULE_JS_NAPI, "onSetProperty start = %{public}d", result); if (setPropertyInfo_ != nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"setPropertyInfo is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "setPropertyInfo is null"); return; } uv_loop_s *loop(nullptr); napi_get_uv_event_loop(setPropertyInfo_->callBackInfo.env, &loop); if (loop == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"loop is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "loop is null"); delete setPropertyInfo_; setPropertyInfo_ = nullptr; return; } uv_work_t *work = new (std::nothrow) uv_work_t; if (work == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"work is null"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "work is null"); delete setPropertyInfo_; setPropertyInfo_ = nullptr; return; diff --git a/interfaces/innerkits/napi/src/result_convert.cpp b/interfaces/innerkits/napi/src/result_convert.cpp index 7f32751b9..063dcc730 100644 --- a/interfaces/innerkits/napi/src/result_convert.cpp +++ b/interfaces/innerkits/napi/src/result_convert.cpp @@ -13,10 +13,10 @@ * limitations under the License. */ -#include "result_convert.h" +#include +#include "result_convert.h" #include "securec.h" - #include "userauth_hilog_wrapper.h" namespace OHOS { @@ -32,7 +32,7 @@ ResultConvert::~ResultConvert() napi_value ResultConvert::Uint64ToUint8Napi(napi_env env, uint64_t value) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"ResultConvert Uint64ToUint8Napi uint64_t %{public}llu", value); + USERAUTH_HILOGI(MODULE_JS_NAPI, "ResultConvert Uint64ToUint8Napi uint64_t %{public}" PRIu64 "", value); size_t length = sizeof(value); void *data = nullptr; napi_value arrayBuffer = nullptr; @@ -59,16 +59,16 @@ std::vector ResultConvert::NapiGetValueUint8Array(napi_env env, napi_va bool isTypedArray = false; napi_is_typedarray(env, jsValue, &isTypedArray); if (!isTypedArray) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"NapiGetValueUint8Array jsValue is not typedarray"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "NapiGetValueUint8Array jsValue is not typedarray"); return RetNull; } napi_get_typedarray_info(env, jsValue, &arraytype, &length, reinterpret_cast(&data), &buffer, &offset); if (arraytype != napi_uint8_array) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"NapiGetValueUint8Array js jsValue is not uint8Array"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "NapiGetValueUint8Array js jsValue is not uint8Array"); return RetNull; } if (offset != 0) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"offset is %{public}d", offset); + USERAUTH_HILOGE(MODULE_JS_NAPI, "offset is %{public}d", offset); return RetNull; } std::vector result(data, data + length); @@ -84,7 +84,7 @@ napi_valuetype ResultConvert::GetType(napi_env env, napi_value value) napi_valuetype type; status = napi_typeof(env, value, &type); if (status != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_typeof faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_typeof faild"); } return type; } @@ -108,7 +108,7 @@ std::vector ResultConvert::GetCppArrayUint32(napi_env env, napi_value uint32_t arrayLength = 0; napi_get_array_length(env, value, &arrayLength); if (arrayLength <= 0) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s The array is empty.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s The array is empty.", __func__); return std::vector(); } std::vector paramArrays; @@ -118,7 +118,7 @@ std::vector ResultConvert::GetCppArrayUint32(napi_env env, napi_value napi_valuetype napiValueType = napi_undefined; napi_typeof(env, napiElement, &napiValueType); if (napiValueType != napi_number) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s Wrong argument type. Numbers expected.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s Wrong argument type. Numbers expected.", __func__); return std::vector(); } uint32_t napiValue = 0; @@ -141,13 +141,13 @@ std::vector ResultConvert::GetInt32ArrayValueByKey(napi_env env, napi_ bool isArray = false; status = napi_is_array(env, array, &isArray); if (status != napi_ok) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"napi_is_array is failed"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "napi_is_array is failed"); return std::vector(); } if (isArray) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"args[PIN_PARAMS_ONE] is a array"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "args[PIN_PARAMS_ONE] is a array"); } else { - USERAUTH_HILOGI(MODULE_JS_NAPI,"args[PIN_PARAMS_ONE] is not a array"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "args[PIN_PARAMS_ONE] is not a array"); return std::vector(); } return GetCppArrayUint32(env, array); @@ -157,7 +157,7 @@ std::string ResultConvert::NapiGetValueString(napi_env env, napi_value value) { napi_status status; if (value == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"AuthBuild NapiGetValueString value is nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "AuthBuild NapiGetValueString value is nullptr"); return ""; } std::string resultValue = ""; @@ -166,11 +166,11 @@ std::string ResultConvert::NapiGetValueString(napi_env env, napi_value value) size_t resultSize = 0; status = napi_get_value_string_utf8(env, value, valueString, valueSize, &resultSize); if (status != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_get_value_string_utf8 faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_get_value_string_utf8 faild"); } resultValue = valueString; if (resultValue == "") { - USERAUTH_HILOGE(MODULE_JS_NAPI,"ContactsBuild NapiGetValueString Data error"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "ContactsBuild NapiGetValueString Data error"); return ""; } return resultValue; @@ -206,7 +206,7 @@ int ResultConvert::NapiGetValueInt(napi_env env, napi_value value) napi_value ResultConvert::GetNapiValue(napi_env env, const std::string keyChar, napi_value object) { if (object == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"ResultConvert::GetNapiValue object is nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "ResultConvert::GetNapiValue object is nullptr"); return nullptr; } napi_value key = nullptr; diff --git a/interfaces/innerkits/napi/src/user_auth_helper.cpp b/interfaces/innerkits/napi/src/user_auth_helper.cpp index d2152aa79..cf999249f 100755 --- a/interfaces/innerkits/napi/src/user_auth_helper.cpp +++ b/interfaces/innerkits/napi/src/user_auth_helper.cpp @@ -12,9 +12,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include #include "user_auth_helper.h" - #include "userauth_hilog_wrapper.h" #include "user_auth_impl.h" @@ -30,7 +30,7 @@ namespace UserAuth { */ napi_value UserAuthServiceConstructor(napi_env env, napi_callback_info info) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); std::shared_ptr userAuthImpl; userAuthImpl.reset(new UserAuthImpl()); napi_value thisVar = nullptr; @@ -58,7 +58,7 @@ napi_value UserAuthServiceConstructor(napi_env env, napi_callback_info info) */ napi_value AuthenticatorServiceConstructor(napi_env env, napi_callback_info info) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); std::shared_ptr authenticatorImpl; authenticatorImpl.reset(new AuthenticatorImpl()); napi_value thisVar = nullptr; @@ -93,7 +93,7 @@ napi_value GetVersion(napi_env env, napi_callback_info info) 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)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthHelper, GetVersion"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "UserAuthHelper, GetVersion"); return userAuthImpl->GetVersion(env, info); } @@ -112,7 +112,7 @@ napi_value GetAvailabeStatus(napi_env env, napi_callback_info info) 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)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthHelper, getAvailabeStatus"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "UserAuthHelper, getAvailabeStatus"); return userAuthImpl->GetAvailabeStatus(env, info); } @@ -131,7 +131,7 @@ napi_value GetProperty(napi_env env, napi_callback_info info) 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)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthHelper, GetProperty"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "UserAuthHelper, GetProperty"); return userAuthImpl->GetProperty(env, info); } @@ -150,7 +150,7 @@ napi_value SetProperty(napi_env env, napi_callback_info info) 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)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthHelper, SetProperty"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "UserAuthHelper, SetProperty"); return userAuthImpl->SetProperty(env, info); } @@ -170,7 +170,7 @@ napi_value Auth(napi_env env, napi_callback_info info) 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)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthHelper, Auth"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "UserAuthHelper, Auth"); return userAuthImpl->Auth(env, info); } @@ -190,7 +190,7 @@ napi_value AuthUser(napi_env env, napi_callback_info info) 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)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthHelper, AuthUser"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "UserAuthHelper, AuthUser"); return userAuthImpl->AuthUser(env, info); } @@ -209,7 +209,7 @@ napi_value CancelAuth(napi_env env, napi_callback_info info) 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)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthHelper, CancelAuth"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "UserAuthHelper, CancelAuth"); return userAuthImpl->CancelAuth(env, info); } @@ -221,7 +221,7 @@ napi_value Execute(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); AuthenticatorImpl *authenticatorImpl = nullptr; NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"authenticatorImpl, Execute"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "authenticatorImpl, Execute"); return authenticatorImpl->Execute(env, info); } @@ -233,7 +233,7 @@ napi_value Cancel(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); AuthenticatorImpl *authenticatorImpl = nullptr; NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"authenticatorImpl, Cancel"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "authenticatorImpl, Cancel"); return authenticatorImpl->Cancel(env, info); } @@ -245,7 +245,7 @@ napi_value CheckAvailability(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); AuthenticatorImpl *authenticatorImpl = nullptr; NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"authenticatorImpl, CheckAvailability"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "authenticatorImpl, CheckAvailability"); return authenticatorImpl->CheckAvailability(env, info); } @@ -257,7 +257,7 @@ napi_value On(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); AuthenticatorImpl *authenticatorImpl = nullptr; NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"authenticatorImpl, On"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "authenticatorImpl, On"); return authenticatorImpl->On(env, info); } @@ -269,7 +269,7 @@ napi_value Off(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); AuthenticatorImpl *authenticatorImpl = nullptr; NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"authenticatorImpl, Off"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "authenticatorImpl, Off"); return authenticatorImpl->Off(env, info); } /** @@ -280,29 +280,24 @@ napi_value Off(napi_env env, napi_callback_info info) */ void Init(napi_env env, napi_value exports) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); napi_status status; napi_property_descriptor exportFuncs[] = { DECLARE_NAPI_FUNCTION("constructor", UserAuth::Constructor), - DECLARE_NAPI_FUNCTION("getAuthenticator", UserAuth::GetAuthenticator), }; status = napi_define_properties(env, exports, sizeof(exportFuncs) / sizeof(*exportFuncs), exportFuncs); if (status != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_define_properties faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_define_properties faild"); } status = napi_set_named_property(env, exports, "UserAuth", GetCtor(env)); if (status != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_set_named_property faild"); - } - status = napi_set_named_property(env, exports, "Authenticator", GetCtorAPI7(env)); - if (status != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_set_named_property faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_set_named_property faild"); } } napi_value Constructor(napi_env env, napi_callback_info info) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); napi_value thisVar = nullptr; napi_value userAuth = nullptr; NAPI_CALL(env, napi_new_instance(env, GetCtor(env), 0, nullptr, &userAuth)); @@ -312,7 +307,7 @@ napi_value Constructor(napi_env env, napi_callback_info info) napi_value GetAuthenticator(napi_env env, napi_callback_info info) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); napi_value thisVar = nullptr; napi_value authenticator = nullptr; NAPI_CALL(env, napi_new_instance(env, GetCtorAPI7(env), 0, nullptr, &authenticator)); @@ -322,7 +317,7 @@ napi_value GetAuthenticator(napi_env env, napi_callback_info info) napi_value GetCtor(napi_env env) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); napi_value cons = nullptr; napi_property_descriptor clzDes[] = { DECLARE_NAPI_FUNCTION("getVersion", UserAuth::GetVersion), @@ -340,7 +335,7 @@ napi_value GetCtor(napi_env env) napi_value GetCtorAPI7(napi_env env) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); napi_value cons = nullptr; napi_property_descriptor clzDes[] = { DECLARE_NAPI_FUNCTION("execute", UserAuth::Execute), diff --git a/interfaces/innerkits/napi/src/user_auth_impl.cpp b/interfaces/innerkits/napi/src/user_auth_impl.cpp index e5b94410d..3228189ab 100755 --- a/interfaces/innerkits/napi/src/user_auth_impl.cpp +++ b/interfaces/innerkits/napi/src/user_auth_impl.cpp @@ -13,12 +13,12 @@ * limitations under the License. */ -#include "user_auth_impl.h" +#include +#include "user_auth_impl.h" #include "user_auth.h" #include "userauth_callback.h" #include "userauth_info.h" - #include "userauth_hilog_wrapper.h" #include "authapi_callback.h" @@ -44,7 +44,7 @@ AuthenticatorImpl::~AuthenticatorImpl() napi_value UserAuthImpl::GetVersion(napi_env env, napi_callback_info info) { int32_t result = UserAuth::GetInstance().GetVersion(); - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetVersion result = %{public}d ", result); + USERAUTH_HILOGI(MODULE_JS_NAPI, "GetVersion result = %{public}d", result); napi_value version = 0; NAPI_CALL(env, napi_create_int32(env, result, &version)); return version; @@ -56,23 +56,23 @@ napi_value UserAuthImpl::GetAvailabeStatus(napi_env env, napi_callback_info info size_t argc = ARGS_MAX_COUNT; NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); if (argc != ARGS_TWO) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s, parms error.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s, parms error.", __func__); return nullptr; } int type = authBuild.NapiGetValueInt(env, argv[PARAM0]); if (type == GET_VALUE_ERROR) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s, argv[PARAM0] error.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s, argv[PARAM0] error.", __func__); return nullptr; } int level = authBuild.NapiGetValueInt(env, argv[PARAM1]); if (level == GET_VALUE_ERROR) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s, argv[PARAM1] error.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s, argv[PARAM1] error.", __func__); return nullptr; } AuthType authType = AuthType(type); AuthTurstLevel authTurstLevel = AuthTurstLevel(level); int32_t result = UserAuth::GetInstance().GetAvailableStatus(authType, authTurstLevel); - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetAvailabeStatus result = %{public}d", result); + USERAUTH_HILOGI(MODULE_JS_NAPI, "GetAvailabeStatus result = %{public}d", result); napi_value ret = 0; NAPI_CALL(env, napi_create_int32(env, result, &ret)); return ret; @@ -82,20 +82,20 @@ napi_value UserAuthImpl::GetProperty(napi_env env, napi_callback_info info) { AsyncHolder *asyncHolder = new (std::nothrow) AsyncHolder(); if (asyncHolder == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s asyncHolder nullptr", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s asyncHolder nullptr", __func__); return nullptr; } GetPropertyInfo *getPropertyInfo = new (std::nothrow) GetPropertyInfo(); if (getPropertyInfo == nullptr) { delete asyncHolder; - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s getPropertyInfo nullptr", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s getPropertyInfo nullptr", __func__); return nullptr; } getPropertyInfo->callBackInfo.env = env; asyncHolder->data = getPropertyInfo; napi_value ret = GetPropertyWrap(env, info, asyncHolder); if (ret == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s GetPropertyWrap fail", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s GetPropertyWrap fail", __func__); delete getPropertyInfo; delete asyncHolder; if (asyncHolder->asyncWork != nullptr) { @@ -107,7 +107,7 @@ napi_value UserAuthImpl::GetProperty(napi_env env, napi_callback_info info) napi_value UserAuthImpl::GetPropertyWrap(napi_env env, napi_callback_info info, AsyncHolder *asyncHolder) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, called", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, called", __func__); GetPropertyInfo *getPropertyInfo = reinterpret_cast(asyncHolder->data); size_t argcAsync = ARGS_TWO; const size_t argcPromise = ARGS_ONE; @@ -115,7 +115,7 @@ napi_value UserAuthImpl::GetPropertyWrap(napi_env env, napi_callback_info info, napi_value args[ARGS_MAX_COUNT] = {nullptr}; NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr)); if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s, Wrong argument count.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s, Wrong argument count.", __func__); return nullptr; } if (argcAsync > PARAM1) { @@ -136,21 +136,21 @@ napi_value UserAuthImpl::GetPropertyWrap(napi_env env, napi_callback_info info, } else { ret = GetPropertyPromise(env, asyncHolder); } - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s,end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s,end.", __func__); return ret; } void UserAuthImpl::GetPropertyExecute(napi_env env, void *data) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropertyExecute, worker pool thread execute."); + USERAUTH_HILOGI(MODULE_JS_NAPI, "GetPropertyExecute, worker pool thread execute."); AsyncHolder *asyncHolder = reinterpret_cast(data); if (asyncHolder == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"GetPropertyExecute, asyncHolder == nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "GetPropertyExecute, asyncHolder == nullptr"); return; } GetPropertyInfo *getPropertyInfo = reinterpret_cast(asyncHolder->data); if (getPropertyInfo == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"GetPropertyExecute, getPropertyInfo == nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "GetPropertyExecute, getPropertyInfo == nullptr"); return; } AuthType authTypeGet = AuthType(getPropertyInfo->authType); @@ -158,35 +158,35 @@ void UserAuthImpl::GetPropertyExecute(napi_env env, void *data) GetPropertyRequest request; request.authType = authTypeGet; request.keys = getPropertyInfo->keys; - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropertyExecute start 1"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "GetPropertyExecute start 1"); GetPropApiCallback *object = new GetPropApiCallback(getPropertyInfo); std::shared_ptr callback; callback.reset(object); UserAuth::GetInstance().GetProperty(request, callback); - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropertyExecute, worker pool thread execute end."); + USERAUTH_HILOGI(MODULE_JS_NAPI, "GetPropertyExecute, worker pool thread execute end."); } void UserAuthImpl::GetPropertyPromiseExecuteDone(napi_env env, napi_status status, void *data) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropertyPromiseExecuteDone, start"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "GetPropertyPromiseExecuteDone, start"); AsyncHolder *asyncHolder = reinterpret_cast(data); napi_delete_async_work(env, asyncHolder->asyncWork); delete asyncHolder; - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropertyPromiseExecuteDone, end"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "GetPropertyPromiseExecuteDone, end"); } void UserAuthImpl::GetPropertyAsyncExecuteDone(napi_env env, napi_status status, void *data) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropertyAsyncExecuteDone, start"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "GetPropertyAsyncExecuteDone, start"); AsyncHolder *asyncHolder = reinterpret_cast(data); napi_delete_async_work(env, asyncHolder->asyncWork); delete asyncHolder; - USERAUTH_HILOGI(MODULE_JS_NAPI,"GetPropertyAsyncExecuteDone, end"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "GetPropertyAsyncExecuteDone, end"); } napi_value UserAuthImpl::GetPropertyAsync(napi_env env, AsyncHolder *asyncHolder) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, asyncCallback.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, asyncCallback.", __func__); napi_value result = nullptr; NAPI_CALL(env, napi_get_null(env, &result)); napi_value resourceName = nullptr; @@ -194,13 +194,13 @@ napi_value UserAuthImpl::GetPropertyAsync(napi_env env, AsyncHolder *asyncHolder NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, GetPropertyExecute, GetPropertyAsyncExecuteDone, (void *)asyncHolder, &asyncHolder->asyncWork)); NAPI_CALL(env, napi_queue_async_work(env, asyncHolder->asyncWork)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, asyncCallback end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, asyncCallback end.", __func__); return result; } napi_value UserAuthImpl::GetPropertyPromise(napi_env env, AsyncHolder *asyncHolder) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, promise.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, promise.", __func__); GetPropertyInfo *getPropertyInfo = reinterpret_cast(asyncHolder->data); napi_value resourceName = 0; NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); @@ -212,7 +212,7 @@ napi_value UserAuthImpl::GetPropertyPromise(napi_env env, AsyncHolder *asyncHold NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, GetPropertyExecute, GetPropertyPromiseExecuteDone, (void *)asyncHolder, &asyncHolder->asyncWork)); NAPI_CALL(env, napi_queue_async_work(env, asyncHolder->asyncWork)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, promise end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, promise end.", __func__); return promise; } @@ -220,20 +220,20 @@ napi_value UserAuthImpl::SetProperty(napi_env env, napi_callback_info info) { AsyncHolder *asyncHolder = new (std::nothrow) AsyncHolder(); if (asyncHolder == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s asyncHolder nullptr", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s asyncHolder nullptr", __func__); return nullptr; } SetPropertyInfo *setPropertyInfo = new (std::nothrow) SetPropertyInfo(); if (setPropertyInfo == nullptr) { delete asyncHolder; - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s setPropertyInfo nullptr", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s setPropertyInfo nullptr", __func__); return nullptr; } setPropertyInfo->callBackInfo.env = env; asyncHolder->data = setPropertyInfo; napi_value ret = SetPropertyWrap(env, info, asyncHolder); if (ret == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s SetPropertyWrap fail", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s SetPropertyWrap fail", __func__); delete setPropertyInfo; delete asyncHolder; if (asyncHolder->asyncWork != nullptr) { @@ -245,7 +245,7 @@ napi_value UserAuthImpl::SetProperty(napi_env env, napi_callback_info info) napi_value UserAuthImpl::SetPropertyWrap(napi_env env, napi_callback_info info, AsyncHolder *asyncHolder) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, called", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, called", __func__); SetPropertyInfo *setPropertyInfo = reinterpret_cast(asyncHolder->data); size_t argcAsync = ARGS_TWO; const size_t argcPromise = ARGS_ONE; @@ -253,7 +253,7 @@ napi_value UserAuthImpl::SetPropertyWrap(napi_env env, napi_callback_info info, napi_value args[ARGS_MAX_COUNT] = {nullptr}; NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr)); if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s, Wrong argument count.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s, Wrong argument count.", __func__); return nullptr; } if (argcAsync > PARAM1) { @@ -277,21 +277,21 @@ napi_value UserAuthImpl::SetPropertyWrap(napi_env env, napi_callback_info info, } else { ret = SetPropertyPromise(env, asyncHolder); } - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s,end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s,end.", __func__); return ret; } void UserAuthImpl::SetPropertyExecute(napi_env env, void *data) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"setPropertyExecute, worker pool thread execute."); + USERAUTH_HILOGI(MODULE_JS_NAPI, "setPropertyExecute, worker pool thread execute."); AsyncHolder *asyncHolder = reinterpret_cast(data); if (asyncHolder == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"SetPropertyExecute, asyncHolder == nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "SetPropertyExecute, asyncHolder == nullptr"); return; } SetPropertyInfo *setPropertyInfo = reinterpret_cast(asyncHolder->data); if (setPropertyInfo == nullptr) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"SetPropertyExecute, setPropertyInfo == nullptr"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "SetPropertyExecute, setPropertyInfo == nullptr"); return; } AuthType authTypeGet = AuthType(setPropertyInfo->authType); @@ -303,30 +303,30 @@ void UserAuthImpl::SetPropertyExecute(napi_env env, void *data) std::shared_ptr callback; callback.reset(object); UserAuth::GetInstance().SetProperty(request, callback); - USERAUTH_HILOGI(MODULE_JS_NAPI,"setPropertyExecute, worker pool thread execute end."); + USERAUTH_HILOGI(MODULE_JS_NAPI, "setPropertyExecute, worker pool thread execute end."); } void UserAuthImpl::SetPropertyPromiseExecuteDone(napi_env env, napi_status status, void *data) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"SetPropertyPromiseExecuteDone, start"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "SetPropertyPromiseExecuteDone, start"); AsyncHolder *asyncHolder = reinterpret_cast(data); napi_delete_async_work(env, asyncHolder->asyncWork); delete asyncHolder; - USERAUTH_HILOGI(MODULE_JS_NAPI,"SetPropertyPromiseExecuteDone, end"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "SetPropertyPromiseExecuteDone, end"); } void UserAuthImpl::SetPropertyAsyncExecuteDone(napi_env env, napi_status status, void *data) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"SetPropertyAsyncExecuteDone, start"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "SetPropertyAsyncExecuteDone, start"); AsyncHolder *asyncHolder = reinterpret_cast(data); napi_delete_async_work(env, asyncHolder->asyncWork); delete asyncHolder; - USERAUTH_HILOGI(MODULE_JS_NAPI,"SetPropertyAsyncExecuteDone, end"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "SetPropertyAsyncExecuteDone, end"); } napi_value UserAuthImpl::SetPropertyAsync(napi_env env, AsyncHolder *asyncHolder) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, asyncCallback.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, asyncCallback.", __func__); napi_value result = nullptr; NAPI_CALL(env, napi_get_null(env, &result)); napi_value resourceName = nullptr; @@ -334,13 +334,13 @@ napi_value UserAuthImpl::SetPropertyAsync(napi_env env, AsyncHolder *asyncHolder NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, SetPropertyExecute, SetPropertyAsyncExecuteDone, (void *)asyncHolder, &asyncHolder->asyncWork)); NAPI_CALL(env, napi_queue_async_work(env, asyncHolder->asyncWork)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, asyncCallback end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, asyncCallback end.", __func__); return result; } napi_value UserAuthImpl::SetPropertyPromise(napi_env env, AsyncHolder *asyncHolder) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, promise.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, promise.", __func__); SetPropertyInfo *setPropertyInfo = reinterpret_cast(asyncHolder->data); napi_value resourceName = 0; NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName)); @@ -352,7 +352,7 @@ napi_value UserAuthImpl::SetPropertyPromise(napi_env env, AsyncHolder *asyncHold 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)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, promise end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, promise end.", __func__); return promise; } @@ -365,7 +365,7 @@ napi_value UserAuthImpl::BuildAuthInfo(napi_env env, AuthInfo *authInfo) napi_value argv[ARGS_MAX_COUNT] = {nullptr}; NAPI_CALL(env, napi_get_cb_info(env, authInfo->info, &argc, argv, nullptr, nullptr)); if (argc != ARGS_FOUR) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s, parms error.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s, parms error.", __func__); return nullptr; } authInfo->challenge = authBuild.GetUint8ArrayTo64(env, argv[0]); @@ -394,16 +394,16 @@ napi_value UserAuthImpl::BuildAuthInfo(napi_env env, AuthInfo *authInfo) napi_value UserAuthImpl::Auth(napi_env env, napi_callback_info info) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start", __func__); AuthInfo *authInfo = new (std::nothrow) AuthInfo(); if (authInfo == nullptr) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s authInfo nullptr", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s authInfo nullptr", __func__); return nullptr; } authInfo->info = info; napi_value ret = BuildAuthInfo(env, authInfo); if (ret == nullptr) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s BuildAuthInfo fail", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s BuildAuthInfo fail", __func__); delete authInfo; return ret; } @@ -412,31 +412,31 @@ napi_value UserAuthImpl::Auth(napi_env env, napi_callback_info info) napi_value UserAuthImpl::AuthWrap(napi_env env, AuthInfo *authInfo) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); AuthApiCallback *object = new AuthApiCallback(authInfo); std::shared_ptr callback; callback.reset(object); uint64_t result = UserAuth::GetInstance().Auth( authInfo->challenge, AuthType(authInfo->authType), AuthTurstLevel(authInfo->authTrustLevel), callback); - USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuth::GetInstance().Auth.result = %{public}llu", result); + USERAUTH_HILOGI(MODULE_JS_NAPI, "UserAuth::GetInstance().Auth.result = %{public}" PRIu64 "", result); napi_value key = authBuild.Uint64ToUint8Array(env, result); - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, end.", __func__); return key; } napi_value UserAuthImpl::AuthUser(napi_env env, napi_callback_info info) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); AuthUserInfo *userInfo = new (std::nothrow) AuthUserInfo(); if (userInfo == nullptr) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s userInfo nullptr", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s userInfo nullptr", __func__); return nullptr; } userInfo->callBackInfo.env = env; userInfo->info = info; napi_value ret = BuildAuthUserInfo(env, userInfo); if (ret == nullptr) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s BuildAuthUserInfo fail", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s BuildAuthUserInfo fail", __func__); delete userInfo; return ret; } @@ -451,7 +451,7 @@ napi_value UserAuthImpl::BuildAuthUserInfo(napi_env env, AuthUserInfo *userInfo) napi_value argv[ARGS_MAX_COUNT] = {nullptr}; NAPI_CALL(env, napi_get_cb_info(env, userInfo->info, &argc, argv, nullptr, nullptr)); if (argc != ARGS_FIVE) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"%{public}s, parms error.", __func__); + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s, parms error.", __func__); return nullptr; } if (authBuild.NapiTypeNumber(env, argv[PARAM0])) { @@ -471,7 +471,7 @@ napi_value UserAuthImpl::BuildAuthUserInfo(napi_env env, AuthUserInfo *userInfo) userInfo->authTrustLevel = level; } if (authBuild.NapiTypeObject(env, argv[PARAM4])) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"AuthUser is Object"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "AuthUser is Object"); userInfo->jsFunction = argv[PARAM4]; NAPI_CALL(env, napi_get_named_property(env, argv[PARAM4], "onResult", &userInfo->onResultCallBack)); NAPI_CALL(env, napi_create_reference(env, userInfo->onResultCallBack, PARAM1, &userInfo->onResult)); @@ -483,15 +483,15 @@ napi_value UserAuthImpl::BuildAuthUserInfo(napi_env env, AuthUserInfo *userInfo) napi_value UserAuthImpl::AuthUserWrap(napi_env env, AuthUserInfo *userInfo) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); AuthApiCallback *object = new AuthApiCallback(userInfo); std::shared_ptr callback; callback.reset(object); uint64_t result = UserAuth::GetInstance().AuthUser(userInfo->userId, userInfo->challenge, AuthType(userInfo->authType), AuthTurstLevel(userInfo->authTrustLevel), callback); - USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuth::GetInstance().AuthUser. result = %{public}llu", result); + USERAUTH_HILOGI(MODULE_JS_NAPI, "UserAuth::GetInstance().AuthUser. result = %{public}" PRIu64 "", result); napi_value key = authBuild.Uint64ToUint8Array(env, result); - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, end.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, end.", __func__); return key; } @@ -502,12 +502,12 @@ napi_value UserAuthImpl::CancelAuth(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); uint64_t contextId = authBuild.GetUint8ArrayTo64(env, argv[0]); - USERAUTH_HILOGI(MODULE_JS_NAPI,"CancelAuth contextId = %{public}llu", contextId); + USERAUTH_HILOGI(MODULE_JS_NAPI, "CancelAuth contextId = %{public}" PRIu64 "", contextId); if (contextId == 0) { return nullptr; } int32_t result = UserAuth::GetInstance().CancelAuth(contextId); - USERAUTH_HILOGI(MODULE_JS_NAPI,"CancelAuth result = %{public}d", result); + USERAUTH_HILOGI(MODULE_JS_NAPI, "CancelAuth result = %{public}d", result); napi_value key = 0; NAPI_CALL(env, napi_create_int32(env, result, &key)); return key; @@ -515,7 +515,7 @@ napi_value UserAuthImpl::CancelAuth(napi_env env, napi_callback_info info) napi_value AuthenticatorImpl::Execute(napi_env env, napi_callback_info info) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); ExecuteInfo *executeInfo = new (std::nothrow) ExecuteInfo(); executeInfo->env = env; return ExecuteWrap(env, info, executeInfo); @@ -523,7 +523,7 @@ napi_value AuthenticatorImpl::Execute(napi_env env, napi_callback_info info) napi_value AuthenticatorImpl::ExecuteWrap(napi_env env, napi_callback_info info, ExecuteInfo* executeInfo) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); size_t argc = ARGS_MAX_COUNT; size_t callbackIndex = 0; napi_value argv[ARGS_MAX_COUNT] = {nullptr}; @@ -542,7 +542,7 @@ napi_value AuthenticatorImpl::ExecuteWrap(napi_env env, napi_callback_info info, void AuthenticatorImpl::JudgeString(napi_env env, napi_value* argv, ExecuteInfo* executeInfo) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); napi_valuetype valuetype; napi_typeof(env, argv[0], &valuetype); if (valuetype == napi_string) { @@ -587,7 +587,7 @@ void AuthenticatorImpl::JudgeString(napi_env env, napi_value* argv, ExecuteInfo* napi_value AuthenticatorImpl::ExecuteAsyncallback(napi_env env, napi_value* argv, ExecuteInfo* executeInfo) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); JudgeString(env,argv,executeInfo); napi_value result = RESULTVAR; NAPI_CALL(env, napi_get_null(env, &result)); @@ -596,14 +596,14 @@ napi_value AuthenticatorImpl::ExecuteAsyncallback(napi_env env, napi_value* argv napi_value AuthenticatorImpl::ExecutePromise(napi_env env, napi_value* argv, ExecuteInfo* executeInfo) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); JudgeString(env,argv,executeInfo); return executeInfo->promise; } napi_value AuthenticatorImpl::Cancel(napi_env env, napi_callback_info info) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); napi_value ret; int32_t result = API7UserAuth::UserAuthAPI7::GetAuthenticator().Cancel(); NAPI_CALL(env,napi_create_int32(env, result, &ret)); @@ -612,7 +612,7 @@ napi_value AuthenticatorImpl::Cancel(napi_env env, napi_callback_info info) napi_value AuthenticatorImpl::CheckAvailability(napi_env env, napi_callback_info info) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); napi_value ret; int32_t result = 0; size_t argc = PARAM2; @@ -648,12 +648,11 @@ napi_value AuthenticatorImpl::CheckAvailability(napi_env env, napi_callback_info result = API7UserAuth::UserAuthAPI7::GetAuthenticator().CheckAvailability(checkAvailabilityInfo->type, checkAvailabilityInfo->level); NAPI_CALL(env,napi_create_int32(env, result, &ret)); return ret; - } napi_value AuthenticatorImpl::On(napi_env env, napi_callback_info info) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); size_t argc = PARAM2; napi_value argv[PARAM2] = {0}; FunctionOnAndOffInfo* functionOnAndOffInfo = new (std::nothrow) FunctionOnAndOffInfo(); @@ -684,7 +683,7 @@ napi_value AuthenticatorImpl::On(napi_env env, napi_callback_info info) napi_value AuthenticatorImpl::Off(napi_env env, napi_callback_info info) { - USERAUTH_HILOGI(MODULE_JS_NAPI,"%{public}s, start.", __func__); + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); size_t argc = PARAM2; napi_value argv[PARAM2] = {0}; FunctionOnAndOffInfo* functionOnAndOffInfo = new (std::nothrow) FunctionOnAndOffInfo(); @@ -716,16 +715,17 @@ static napi_value ModuleInit(napi_env env, napi_value exports) } extern "C" __attribute__((constructor)) void RegisterModule(void) { - napi_module module = {.nm_version = 1, // NAPI v1 - .nm_flags = 0, // normal + napi_module module = { + .nm_version = 1, + .nm_flags = 0, .nm_filename = nullptr, .nm_register_func = ModuleInit, .nm_modname = "UserAuth", .nm_priv = nullptr, - .reserved = {}}; + .reserved = {} + }; napi_module_register(&module); } - } // namespace UserAuth } // namespace UserIAM } // namespace OHOS diff --git a/interfaces/kits/napi/src/user_auth_helper_north.cpp b/interfaces/kits/napi/src/user_auth_helper_north.cpp index 4f8443a44..d39864d46 100755 --- a/interfaces/kits/napi/src/user_auth_helper_north.cpp +++ b/interfaces/kits/napi/src/user_auth_helper_north.cpp @@ -15,9 +15,9 @@ #include "user_auth_helper_north.h" -#include "userauth_hilog_wrapper.h" #include "user_auth_impl.h" #include "user_auth_helper.h" +#include "userauth_hilog_wrapper.h" using namespace OHOS::UserIAM::UserAuth; namespace OHOS { @@ -28,7 +28,7 @@ napi_value Constructor(napi_env env, napi_callback_info info) napi_value userAuth = nullptr; NAPI_CALL(env, napi_new_instance(env, GetCtor(env), 0, nullptr, &userAuth)); NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); - USERAUTH_HILOGI(MODULE_JS_NAPI,"UserAuthNorth, Constructor start"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "UserAuthNorth, Constructor start"); return userAuth; } @@ -54,7 +54,7 @@ void Init(napi_env env, napi_value exports) }; status = napi_define_properties(env, exports, sizeof(exportFuncs) / sizeof(*exportFuncs), exportFuncs); if (status != napi_ok) { - USERAUTH_HILOGE(MODULE_JS_NAPI,"napi_define_properties faild"); + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_define_properties faild"); } } @@ -66,8 +66,8 @@ static napi_value ModuleInit(napi_env env, napi_value exports) extern "C" __attribute__((constructor)) void RegisterModule(void) { napi_module module = { - .nm_version = 1, // NAPI v1 - .nm_flags = 0, // normal + .nm_version = 1, + .nm_flags = 0, .nm_filename = nullptr, .nm_register_func = ModuleInit, .nm_modname = "UserAuthNorth", @@ -76,6 +76,5 @@ extern "C" __attribute__((constructor)) void RegisterModule(void) }; napi_module_register(&module); } - } // namespace UserAuthNorth -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/services/src/userauth_adapter.cpp b/services/src/userauth_adapter.cpp index 5c08655bb..d3847843b 100644 --- a/services/src/userauth_adapter.cpp +++ b/services/src/userauth_adapter.cpp @@ -185,6 +185,7 @@ int32_t UserAuthAdapter::RequestAuthResult(uint64_t contextId, std::vector& return ret; } for (auto const &item : coAuthInfo.sessionIds) { - CoAuth::CoAuth::GetInstance().coAuth(item, authInfo, coAuthCallback); + CoAuth::CoAuth::GetInstance().BeginSchedule(item, authInfo, coAuthCallback); } return SUCCESS; diff --git a/services/src/userauth_excallback_impl.cpp b/services/src/userauth_excallback_impl.cpp index 5b6b2a0d7..26556452f 100644 --- a/services/src/userauth_excallback_impl.cpp +++ b/services/src/userauth_excallback_impl.cpp @@ -184,6 +184,7 @@ void UserAuthCallbackImplCoAuth::OnFinishHandle(uint32_t resultCode, std::vector } int32_t ret = UserAuthAdapter::GetInstance().RequestAuthResult(callbackContextID_, scheduleToken, authToken, sessionIds); + USERAUTH_HILOGD(MODULE_SERVICE, "RequestAuthResult ret:%{public}d", ret); if (ret == E_RET_UNDONE) { if (callbackNowCount_ == callbackCount_) { USERAUTH_HILOGD(MODULE_SERVICE, "UserAuthCallbackImplCoAuth E_RET_UNDONE"); diff --git a/utils/native/include/userauth_errors.h b/utils/native/include/userauth_errors.h deleted file mode 100644 index ebe2c4547..000000000 --- a/utils/native/include/userauth_errors.h +++ /dev/null @@ -1,36 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef USERAUTH_ERRORS_H -#define USERAUTH_ERRORS_H - -#include - -namespace OHOS { -namespace UserIAM { -namespace UserAuth { -enum { - E_WRITE_PARCEL_ERROR = 0, - E_READ_PARCEL_ERROR, - E_GET_SYSTEM_ABILITY_MANAGER_FAILED, - E_GET_POWER_SERVICE_FAILED, - E_ADD_DEATH_RECIPIENT_FAILED, - E_INNER_ERR -}; -} // namespace UserAuth -} // namespace UserIam -} // namespace OHOS - -#endif // USERAUTH_ERRORS_H -- Gitee From fb59c8669a7ac375d956252e1e50666164201f94 Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Mon, 14 Feb 2022 19:56:15 +0800 Subject: [PATCH 15/19] [user_auth]code update for review-2 1.fix napi code for review Signed-off-by: yanfang.gu --- interfaces/innerkits/napi/src/auth_build.cpp | 4 ++-- interfaces/innerkits/napi/src/result_convert.cpp | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/interfaces/innerkits/napi/src/auth_build.cpp b/interfaces/innerkits/napi/src/auth_build.cpp index 381793b1c..b4e22b606 100755 --- a/interfaces/innerkits/napi/src/auth_build.cpp +++ b/interfaces/innerkits/napi/src/auth_build.cpp @@ -100,14 +100,14 @@ uint64_t AuthBuild::GetUint8ArrayTo64(napi_env env, napi_value value) return 0; } if (offset != 0) { - USERAUTH_HILOGE(MODULE_JS_NAPI, "offset is %{public}d", offset); + USERAUTH_HILOGE(MODULE_JS_NAPI, "offset is %{public}zu", offset); return 0; } std::vector result(data, data + length); uint8_t tmp[sizeof(uint64_t)]; for (uint32_t i = 0; i < sizeof(uint64_t); i++) { tmp[i] = result[i]; - USERAUTH_HILOGI(MODULE_JS_NAPI, "GetUint8ArrayTo64 result is %{public}d", (unsigned)result[i]); + USERAUTH_HILOGI(MODULE_JS_NAPI, "GetUint8ArrayTo64 result is %{public}u", (unsigned)result[i]); } uint64_t *re = static_cast(static_cast(tmp)); USERAUTH_HILOGI(MODULE_JS_NAPI, "GetUint8ArrayTo64 resultUint64 is %{public}" PRIu64 "", *re); diff --git a/interfaces/innerkits/napi/src/result_convert.cpp b/interfaces/innerkits/napi/src/result_convert.cpp index 063dcc730..d55f9ea49 100644 --- a/interfaces/innerkits/napi/src/result_convert.cpp +++ b/interfaces/innerkits/napi/src/result_convert.cpp @@ -68,7 +68,7 @@ std::vector ResultConvert::NapiGetValueUint8Array(napi_env env, napi_va return RetNull; } if (offset != 0) { - USERAUTH_HILOGE(MODULE_JS_NAPI, "offset is %{public}d", offset); + USERAUTH_HILOGE(MODULE_JS_NAPI, "offset is %{public}zu", offset); return RetNull; } std::vector result(data, data + length); @@ -145,9 +145,9 @@ std::vector ResultConvert::GetInt32ArrayValueByKey(napi_env env, napi_ return std::vector(); } if (isArray) { - USERAUTH_HILOGI(MODULE_JS_NAPI, "args[PIN_PARAMS_ONE] is a array"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "args[PIN_PARAMS_ONE] is a array"); } else { - USERAUTH_HILOGI(MODULE_JS_NAPI, "args[PIN_PARAMS_ONE] is not a array"); + USERAUTH_HILOGI(MODULE_JS_NAPI, "args[PIN_PARAMS_ONE] is not a array"); return std::vector(); } return GetCppArrayUint32(env, array); -- Gitee From c437adb6b7f86eeae1d9af457f384b1e3bccede1 Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Tue, 15 Feb 2022 10:18:11 +0800 Subject: [PATCH 16/19] [user_auth]fix bug for napi 1.fix bug for napi Signed-off-by: yanfang.gu --- interfaces/innerkits/napi/src/user_auth_helper.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/interfaces/innerkits/napi/src/user_auth_helper.cpp b/interfaces/innerkits/napi/src/user_auth_helper.cpp index cf999249f..92c4ee50c 100755 --- a/interfaces/innerkits/napi/src/user_auth_helper.cpp +++ b/interfaces/innerkits/napi/src/user_auth_helper.cpp @@ -284,6 +284,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::GetAuthenticator), }; status = napi_define_properties(env, exports, sizeof(exportFuncs) / sizeof(*exportFuncs), exportFuncs); if (status != napi_ok) { -- Gitee From 035a45c90ffa01cd01b64d08c6e4df19218b401e Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Tue, 15 Feb 2022 13:56:32 +0800 Subject: [PATCH 17/19] [user_auth]fix bug for api7 InterFace Signed-off-by: yanfang.gu --- frameworks/kitsimpl/src/userauth_api7.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frameworks/kitsimpl/src/userauth_api7.cpp b/frameworks/kitsimpl/src/userauth_api7.cpp index 4744d64bc..4b59008d4 100644 --- a/frameworks/kitsimpl/src/userauth_api7.cpp +++ b/frameworks/kitsimpl/src/userauth_api7.cpp @@ -135,7 +135,7 @@ void UserAuthAPI7::On(std::string tip, std::shared_ptr tip USERAUTH_HILOGD(MODULE_INNERKIT, "userauthAPI7 On is start"); std::string tipInfo = "tip"; - if (!tipInfo.compare(tip)) { + if (tipInfo.compare(tip)) { USERAUTH_HILOGE(MODULE_INNERKIT, "userauthAPI7 On is not tip"); UserAuthAPI7Datamgr::GetInstance().SetAPI7Tip(false); return; -- Gitee From b488a07d612857272a1d16996658a6248d098ab7 Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Thu, 17 Feb 2022 18:22:38 +0800 Subject: [PATCH 18/19] [user_auth]update UT code Signed-off-by: yanfang.gu --- test/unittest/src/userauth_test.cpp | 67 ++++++++++++++++++++++++++--- 1 file changed, 61 insertions(+), 6 deletions(-) diff --git a/test/unittest/src/userauth_test.cpp b/test/unittest/src/userauth_test.cpp index 127f97cea..306820a14 100644 --- a/test/unittest/src/userauth_test.cpp +++ b/test/unittest/src/userauth_test.cpp @@ -147,7 +147,7 @@ HWTEST_F(UseriamUtTest, UseriamUtTest_004, TestSize.Level1) AuthType authType = FACE; AuthTurstLevel authTurstLevel = ATL1; std::shared_ptr callback = std::make_shared(); - EXPECT_EQ(123, UserAuth::GetInstance().Auth(challenge, authType, authTurstLevel, callback)); + EXPECT_NE(0, UserAuth::GetInstance().Auth(challenge, authType, authTurstLevel, callback)); } HWTEST_F(UseriamUtTest, UseriamUtTest_005, TestSize.Level1) @@ -157,13 +157,22 @@ HWTEST_F(UseriamUtTest, UseriamUtTest_005, TestSize.Level1) AuthType authType = FACE; AuthTurstLevel authTurstLevel = ATL1; std::shared_ptr callback = std::make_shared(); - EXPECT_EQ(123, UserAuth::GetInstance().AuthUser(userId, challenge, authType, authTurstLevel, callback)); + EXPECT_NE(0, UserAuth::GetInstance().AuthUser(userId, challenge, authType, authTurstLevel, callback)); } HWTEST_F(UseriamUtTest, UseriamUtTest_006, TestSize.Level1) { - uint64_t contextId = 123; - EXPECT_EQ(0, UserAuth::GetInstance().CancelAuth(contextId)); + int32_t userId = 100; + uint64_t challenge = 001; + AuthType authType = FACE; + AuthTurstLevel authTurstLevel = ATL1; + std::shared_ptr callback = std::make_shared(); + uint64_t contextID = UserAuth::GetInstance().AuthUser(userId, challenge, authType, authTurstLevel, callback); + if (contextID != 0) { + EXPECT_EQ(0, UserAuth::GetInstance().CancelAuth(contextID)); + } else { + EXPECT_NE(0, contextID); + } } HWTEST_F(UseriamUtTest, UseriamUtTest_007, TestSize.Level1) @@ -171,11 +180,31 @@ HWTEST_F(UseriamUtTest, UseriamUtTest_007, TestSize.Level1) std::shared_ptr callback = std::make_shared(); API7UserAuth::UserAuthAPI7::GetAuthenticator().Execute("FACE_ONLY", "S1", callback); + uint64_t contextID = 0; + uint32_t trytimes = 100; + while (contextID == 0 && trytimes != 0) { + API7UserAuth::UserAuthAPI7Datamgr::GetInstance().API7GetContextID(contextID); + trytimes--; + } + EXPECT_NE(0, contextID); } HWTEST_F(UseriamUtTest, UseriamUtTest_008, TestSize.Level1) { - EXPECT_EQ(0, API7UserAuth::UserAuthAPI7::GetAuthenticator().Cancel()); + std::shared_ptr callback = + std::make_shared(); + API7UserAuth::UserAuthAPI7::GetAuthenticator().Execute("FACE_ONLY", "S1", callback); + uint64_t contextID = 0; + uint32_t trytimes = 100; + while (contextID == 0 && trytimes != 0) { + API7UserAuth::UserAuthAPI7Datamgr::GetInstance().API7GetContextID(contextID); + trytimes--; + } + if (contextID != 0) { + EXPECT_EQ(0, API7UserAuth::UserAuthAPI7::GetAuthenticator().Cancel()); + } else { + EXPECT_NE(0, contextID); + } } HWTEST_F(UseriamUtTest, UseriamUtTest_009, TestSize.Level1) @@ -188,13 +217,39 @@ HWTEST_F(UseriamUtTest, UseriamUtTest_010, TestSize.Level1) std::shared_ptr callback = std::make_shared(); API7UserAuth::UserAuthAPI7::GetAuthenticator().On("tip", callback); + uint32_t trytimes = 100; + bool tipFlag = false; + while (tipFlag == false && trytimes != 0) { + tipFlag = API7UserAuth::UserAuthAPI7Datamgr::GetInstance().GetAPI7Tip(); + trytimes--; + } + EXPECT_TRUE(tipFlag); } HWTEST_F(UseriamUtTest, UseriamUtTest_011, TestSize.Level1) { std::shared_ptr callback = std::make_shared(); - API7UserAuth::UserAuthAPI7::GetAuthenticator().Off("tip", callback); + API7UserAuth::UserAuthAPI7::GetAuthenticator().On("tip", callback); + uint32_t trytimes = 100; + bool tipFlag = false; + while (tipFlag == false && trytimes != 0) { + tipFlag = API7UserAuth::UserAuthAPI7Datamgr::GetInstance().GetAPI7Tip(); + trytimes--; + } + if (tipFlag) { + std::shared_ptr callback = + std::make_shared(); + API7UserAuth::UserAuthAPI7::GetAuthenticator().Off("tip", callback); + trytimes = 100; + while (tipFlag == true && trytimes != 0) { + tipFlag = API7UserAuth::UserAuthAPI7Datamgr::GetInstance().GetAPI7Tip(); + trytimes--; + } + EXPECT_FALSE(tipFlag); + } else { + EXPECT_TRUE(tipFlag); + } } } } -- Gitee From df23bff1f7be38595c2fa49830de78fb13c53434 Mon Sep 17 00:00:00 2001 From: "yanfang.gu" Date: Thu, 17 Feb 2022 20:04:42 +0800 Subject: [PATCH 19/19] [user_auth]code update for sync master 1.code update for sync master 2.UT code update Signed-off-by: yanfang.gu --- README_ZH.md | 2 +- bundle.json | 25 +++- .../innerkits/js/ohos.UserIAM.userAuth.d.ts | 4 +- interfaces/innerkits/napi/BUILD.gn | 39 ++++++ .../innerkits/napi/include/auth_common.h | 32 +++-- .../innerkits/napi/include/authapi_callback.h | 7 +- .../innerkits/napi/include/user_auth_helper.h | 6 +- .../innerkits/napi/include/user_auth_impl.h | 16 ++- .../innerkits/napi/src/authapi_callback.cpp | 75 ++++++++++- .../innerkits/napi/src/user_auth_helper.cpp | 41 ++++-- .../innerkits/napi/src/user_auth_impl.cpp | 122 ++++++++++++++++-- .../kits/napi/src/user_auth_helper_north.cpp | 2 +- test/unittest/BUILD.gn | 24 +--- test/unittest/src/userauth_test.cpp | 1 + 14 files changed, 320 insertions(+), 76 deletions(-) diff --git a/README_ZH.md b/README_ZH.md index 0b898f8cb..cce87d8bc 100644 --- a/README_ZH.md +++ b/README_ZH.md @@ -45,7 +45,7 @@ | 接口名 | 描述 | | ------ | -------------------------------- | -| getAvailabeStatus(authType : AuthType, authTrustLevel : AuthTurstLevel) : number; | 指定ATL，查询是否支持目标认证方式 | +| getAvailableStatus(authType : AuthType, authTrustLevel : AuthTurstLevel) : number; | 指定ATL，查询是否支持目标认证方式 | | auth(challenge: BigInt, authType : AuthType, authTrustLevel: AuthTurstLevel, callback: IUserAuthCallback): BigInt; | 指定ATL和认证方式，完成用户身份认证 | ### 使用说明 diff --git a/bundle.json b/bundle.json index dc9f363e1..4cbefc74e 100644 --- a/bundle.json +++ b/bundle.json @@ -16,7 +16,7 @@ "name": "user_auth", "subsystem": "useriam", "adapted_system_type": [ "standard" ], - "syscap": ["SystemCapability.UserIAM.UserAuth"], + "syscap": ["SystemCapability.UserIAM.UserAuth.Core"], "features": [], "rom": "2400KB", "ram": "1500KB", @@ -30,8 +30,7 @@ "auth_executor_mgr" ], "third_party": [ - "openssl", - "googletest" + "openssl" ] }, "build": { @@ -41,7 +40,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": { @@ -62,7 +61,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": { @@ -77,6 +76,22 @@ ], "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_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/js/ohos.UserIAM.userAuth.d.ts b/interfaces/innerkits/js/ohos.UserIAM.userAuth.d.ts index 527826a6d..3599a1b85 100755 --- a/interfaces/innerkits/js/ohos.UserIAM.userAuth.d.ts +++ b/interfaces/innerkits/js/ohos.UserIAM.userAuth.d.ts @@ -49,9 +49,9 @@ declare namespace userIAM *

Permissions required: {@code ohos.permission.ACCESS_USER_AUTH_INTERNAL} * @param authType Credential type for authentication. * @param authTrustLevel Credibility level of certification results. - * @return Returns a check result, which is specified by getAvailabeStatus. + * @return Returns a check result, which is specified by getAvailableStatus. */ - getAvailabeStatus(authType : AuthType, authTrustLevel : AuthTrustLevel) : number; + getAvailableStatus(authType : AuthType, authTrustLevel : AuthTrustLevel) : number; /** * Get the attribute, pass in the credential type and the key to get, and return the value corresponding to the key. diff --git a/interfaces/innerkits/napi/BUILD.gn b/interfaces/innerkits/napi/BUILD.gn index 0626ef7ae..2e616129e 100755 --- a/interfaces/innerkits/napi/BUILD.gn +++ b/interfaces/innerkits/napi/BUILD.gn @@ -57,3 +57,42 @@ 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/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 7586cdad7..232e62058 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 @@ -83,6 +84,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; @@ -125,16 +137,16 @@ struct AuthUserInfo { uint32_t remainTimes; uint32_t freezingTime; }; -struct ExecuteInfo { - ExecuteInfo() : asyncWork(nullptr){}; - napi_env env; - std::string type; - std::string level; - napi_async_work asyncWork; - napi_ref callbackRef; - napi_deferred deferred; - napi_value promise; - napi_value result; +struct NapiExecuteInfo { + NapiExecuteInfo() : asyncWork(nullptr){}; + napi_env env; + std::string type; + std::string level; + napi_async_work asyncWork; + napi_ref callbackRef; + napi_deferred deferred; + napi_value promise; + napi_value result; }; struct CheckAvailabilityInfo { diff --git a/interfaces/innerkits/napi/include/authapi_callback.h b/interfaces/innerkits/napi/include/authapi_callback.h index 03a7a531d..4be400138 100755 --- a/interfaces/innerkits/napi/include/authapi_callback.h +++ b/interfaces/innerkits/napi/include/authapi_callback.h @@ -42,6 +42,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; @@ -54,9 +55,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 { @@ -84,10 +87,10 @@ private: class API7callback : public API7UserAuth::UserAuthAPI7Callback { public: - explicit API7callback(ExecuteInfo* executeInfo); + explicit API7callback(NapiExecuteInfo* executeInfo); explicit API7callback(FunctionOnAndOffInfo* functionOnAndOffInfo); virtual ~API7callback() = default; - ExecuteInfo* executeInfo_; + NapiExecuteInfo* executeInfo_; FunctionOnAndOffInfo* functionOnAndOffInfo_; void API7OnResult(const int32_t result) override; void TipCallback(const API7UserAuth::Tip result) override; diff --git a/interfaces/innerkits/napi/include/user_auth_helper.h b/interfaces/innerkits/napi/include/user_auth_helper.h index 76efacc2f..fff968ab3 100755 --- a/interfaces/innerkits/napi/include/user_auth_helper.h +++ b/interfaces/innerkits/napi/include/user_auth_helper.h @@ -97,7 +97,7 @@ napi_value GetVersion(napi_env env, napi_callback_info info); * @param info * @return napi_value Verify that the certification capability is available */ -napi_value GetAvailabeStatus(napi_env env, napi_callback_info info); +napi_value GetAvailableStatus(napi_env env, napi_callback_info info); /** * @brief Get the Property object @@ -127,6 +127,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 * @@ -152,7 +154,7 @@ napi_value CancelAuth(napi_env env, napi_callback_info info); * @param env * @return Returns the result of successful authentication */ -napi_value Execute(napi_env, napi_callback_info info); +napi_value NapiExecute(napi_env, napi_callback_info info); /** * @brief Cancel the current authentication process diff --git a/interfaces/innerkits/napi/include/user_auth_impl.h b/interfaces/innerkits/napi/include/user_auth_impl.h index f65133a9e..bbee3e59e 100755 --- a/interfaces/innerkits/napi/include/user_auth_impl.h +++ b/interfaces/innerkits/napi/include/user_auth_impl.h @@ -39,10 +39,11 @@ public: ~UserAuthImpl(); AuthBuild authBuild; napi_value GetVersion(napi_env env, napi_callback_info info); - napi_value GetAvailabeStatus(napi_env env, napi_callback_info info); + napi_value GetAvailableStatus(napi_env env, napi_callback_info info); 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); @@ -60,6 +61,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); @@ -71,16 +75,16 @@ class AuthenticatorImpl { public: AuthenticatorImpl(); ~AuthenticatorImpl(); - napi_value Execute(napi_env env, napi_callback_info info); + napi_value NapiExecute(napi_env env, napi_callback_info info); napi_value Cancel(napi_env env, napi_callback_info info); napi_value CheckAvailability(napi_env env, napi_callback_info info); napi_value On(napi_env env, napi_callback_info info); napi_value Off(napi_env env, napi_callback_info info); private: - napi_value ExecuteWrap(napi_env env, napi_callback_info info, ExecuteInfo* executeInfo); - napi_value ExecuteAsyncallback(napi_env env, napi_value* argv, ExecuteInfo* executeInfo); - napi_value ExecutePromise(napi_env env, napi_value* argv, ExecuteInfo* executeInfo); - void JudgeString(napi_env env, napi_value* argv, ExecuteInfo* executeInfo); + napi_value ExecuteWrap(napi_env env, napi_callback_info info, NapiExecuteInfo* executeInfo); + napi_value ExecuteAsyncallback(napi_env env, napi_value* argv, NapiExecuteInfo* executeInfo); + napi_value ExecutePromise(napi_env env, napi_value* argv, NapiExecuteInfo* executeInfo); + void JudgeString(napi_env env, napi_value* argv, NapiExecuteInfo* executeInfo); }; } // namespace UserAuth } // namespace UserIAM diff --git a/interfaces/innerkits/napi/src/authapi_callback.cpp b/interfaces/innerkits/napi/src/authapi_callback.cpp index 9252cba74..81c198a06 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() @@ -40,7 +49,7 @@ AuthApiCallback::~AuthApiCallback() } -API7callback::API7callback(ExecuteInfo* executeInfo) +API7callback::API7callback(NapiExecuteInfo* executeInfo) { executeInfo_ = executeInfo; } @@ -54,7 +63,7 @@ void API7callback::API7OnResultWrap(uv_loop_s *loop, uv_work_t *work) { USERAUTH_HILOGI(MODULE_JS_NAPI, "authFace : %{public}s, start.", __func__); uv_queue_work(loop, work, [] (uv_work_t *work) { }, [] (uv_work_t *work, int status) { - ExecuteInfo *executeInfo = reinterpret_cast(work->data); + NapiExecuteInfo *executeInfo = reinterpret_cast(work->data); if (executeInfo == nullptr) { delete work; work = nullptr; @@ -111,7 +120,7 @@ void API7callback::API7OnResult(const int32_t result) executeInfo_ = nullptr; return; } - ExecuteInfo *executeInfo = new (std::nothrow) ExecuteInfo(); + NapiExecuteInfo *executeInfo = new (std::nothrow) NapiExecuteInfo(); executeInfo = executeInfo_; if (executeInfo == nullptr) { delete work; @@ -444,6 +453,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) +{ + USERAUTH_HILOGI(MODULE_JS_NAPI, "Do OnExecuteResultWork"); + ExecuteInfo *executeInfo = reinterpret_cast(work->data); + if (executeInfo == nullptr) { + USERAUTH_HILOGE(MODULE_JS_NAPI, "executeInfo is null"); + delete work; + return; + } + napi_env env = executeInfo->env; + napi_value result; + if (napi_create_int32(env, executeInfo->result, &result) != napi_ok) { + USERAUTH_HILOGE(MODULE_JS_NAPI, "napi_create_int32 faild"); + delete work; + delete executeInfo; + return; + } + napi_value undefined; + napi_get_undefined(env, &undefined); + if (executeInfo->isPromise) { + USERAUTH_HILOGE(MODULE_JS_NAPI, "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; + USERAUTH_HILOGI(MODULE_JS_NAPI, "do callback %{public}d", napi_call_function(env, undefined, callback, 1, &result, &callResult)); + } + delete executeInfo; + delete work; +} + +void AuthApiCallback::OnExecuteResult(const int32_t result) +{ + USERAUTH_HILOGI(MODULE_JS_NAPI, "AuthApiCallback OnExecuteResult start"); + uv_loop_s *loop(nullptr); + napi_get_uv_event_loop(executeInfo_->env, &loop); + if (loop == nullptr) { + USERAUTH_HILOGE(MODULE_JS_NAPI, "loop is null"); + delete executeInfo_; + executeInfo_ = nullptr; + return; + } + uv_work_t *work = new (std::nothrow) uv_work_t; + if (work == nullptr) { + USERAUTH_HILOGE(MODULE_JS_NAPI, "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) { USERAUTH_HILOGI(MODULE_JS_NAPI, "AuthApiCallback onResult start result = %{public}d", result); @@ -457,6 +521,11 @@ void AuthApiCallback::onResult(const int32_t result, const AuthResult extraInfo) } else { USERAUTH_HILOGE(MODULE_JS_NAPI, "AuthApiCallback onResult authInfo_ is nullptr"); } + if (executeInfo_ != nullptr) { + OnExecuteResult(result); + } else { + USERAUTH_HILOGE(MODULE_JS_NAPI, "AuthApiCallback onResult executeInfo_ is nullptr "); + } USERAUTH_HILOGI(MODULE_JS_NAPI, "AuthApiCallback onResult end"); } diff --git a/interfaces/innerkits/napi/src/user_auth_helper.cpp b/interfaces/innerkits/napi/src/user_auth_helper.cpp index 92c4ee50c..f31f74a80 100755 --- a/interfaces/innerkits/napi/src/user_auth_helper.cpp +++ b/interfaces/innerkits/napi/src/user_auth_helper.cpp @@ -104,7 +104,7 @@ napi_value GetVersion(napi_env env, napi_callback_info info) * @param info * @return napi_value Verify that the certification capability is available */ -napi_value GetAvailabeStatus(napi_env env, napi_callback_info info) +napi_value GetAvailableStatus(napi_env env, napi_callback_info info) { napi_value thisVar = nullptr; size_t argcAsync = 0; @@ -112,8 +112,8 @@ napi_value GetAvailabeStatus(napi_env env, napi_callback_info info) 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)); - USERAUTH_HILOGI(MODULE_JS_NAPI, "UserAuthHelper, getAvailabeStatus"); - return userAuthImpl->GetAvailabeStatus(env, info); + USERAUTH_HILOGI(MODULE_JS_NAPI, "UserAuthHelper, getAvailableStatus"); + return userAuthImpl->GetAvailableStatus(env, info); } /** @@ -174,6 +174,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)); + USERAUTH_HILOGI(MODULE_JS_NAPI, "UserAuthHelper, Execute"); + return userAuthImpl->Execute(env, info); +} + /** * @brief user authentication * @@ -213,16 +225,16 @@ napi_value CancelAuth(napi_env env, napi_callback_info info) return userAuthImpl->CancelAuth(env, info); } -napi_value Execute(napi_env env, napi_callback_info info) +napi_value NapiExecute(napi_env env, napi_callback_info info) { - napi_value thisVar = nullptr; - size_t argcAsync = ARGS_THREE; - napi_value args[ARGS_MAX_COUNT] = {nullptr}; - NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); - AuthenticatorImpl *authenticatorImpl = nullptr; - NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); - USERAUTH_HILOGI(MODULE_JS_NAPI, "authenticatorImpl, Execute"); - return authenticatorImpl->Execute(env, info); + napi_value thisVar = nullptr; + size_t argcAsync = ARGS_THREE; + napi_value args[ARGS_MAX_COUNT] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr)); + AuthenticatorImpl *authenticatorImpl = nullptr; + NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&authenticatorImpl)); + USERAUTH_HILOGI(MODULE_JS_NAPI, "authenticatorImpl, Execute"); + return authenticatorImpl->NapiExecute(env, info); } napi_value Cancel(napi_env env, napi_callback_info info) @@ -322,12 +334,13 @@ napi_value GetCtor(napi_env env) napi_value cons = nullptr; napi_property_descriptor clzDes[] = { DECLARE_NAPI_FUNCTION("getVersion", UserAuth::GetVersion), - DECLARE_NAPI_FUNCTION("getAvailabeStatus", UserAuth::GetAvailabeStatus), + DECLARE_NAPI_FUNCTION("getAvailableStatus", UserAuth::GetAvailableStatus), DECLARE_NAPI_FUNCTION("getProperty", UserAuth::GetProperty), DECLARE_NAPI_FUNCTION("setProperty", UserAuth::SetProperty), 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)); @@ -339,7 +352,7 @@ napi_value GetCtorAPI7(napi_env env) USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); napi_value cons = nullptr; napi_property_descriptor clzDes[] = { - DECLARE_NAPI_FUNCTION("execute", UserAuth::Execute), + DECLARE_NAPI_FUNCTION("execute", UserAuth::NapiExecute), DECLARE_NAPI_FUNCTION("cancel", UserAuth::Cancel), DECLARE_NAPI_FUNCTION("checkAvailability", UserAuth::CheckAvailability), DECLARE_NAPI_FUNCTION("on", UserAuth::On), diff --git a/interfaces/innerkits/napi/src/user_auth_impl.cpp b/interfaces/innerkits/napi/src/user_auth_impl.cpp index 3228189ab..ee67d063a 100755 --- a/interfaces/innerkits/napi/src/user_auth_impl.cpp +++ b/interfaces/innerkits/napi/src/user_auth_impl.cpp @@ -16,6 +16,9 @@ #include #include "user_auth_impl.h" + +#include + #include "user_auth.h" #include "userauth_callback.h" #include "userauth_info.h" @@ -50,7 +53,7 @@ napi_value UserAuthImpl::GetVersion(napi_env env, napi_callback_info info) return version; } -napi_value UserAuthImpl::GetAvailabeStatus(napi_env env, napi_callback_info info) +napi_value UserAuthImpl::GetAvailableStatus(napi_env env, napi_callback_info info) { napi_value argv[ARGS_MAX_COUNT] = {nullptr}; size_t argc = ARGS_MAX_COUNT; @@ -392,6 +395,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) { + USERAUTH_HILOGE(MODULE_JS_NAPI, "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) +{ + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start", __func__); + ExecuteInfo *executeInfo = new (std::nothrow) ExecuteInfo(); + if (executeInfo == nullptr) { + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{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) { + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s argc check fail", __func__); + delete executeInfo; + return nullptr; + } + if (!GetExecuteInfo(env, argv, executeInfo)) { + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{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) +{ + USERAUTH_HILOGI(MODULE_JS_NAPI, "%{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) { + USERAUTH_HILOGE(MODULE_JS_NAPI, "%{public}s check type fail.", __func__); + return false; + } + return true; +} + napi_value UserAuthImpl::Auth(napi_env env, napi_callback_info info) { USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start", __func__); @@ -513,15 +617,15 @@ napi_value UserAuthImpl::CancelAuth(napi_env env, napi_callback_info info) return key; } -napi_value AuthenticatorImpl::Execute(napi_env env, napi_callback_info info) +napi_value AuthenticatorImpl::NapiExecute(napi_env env, napi_callback_info info) { USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); - ExecuteInfo *executeInfo = new (std::nothrow) ExecuteInfo(); + NapiExecuteInfo *executeInfo = new (std::nothrow) NapiExecuteInfo(); executeInfo->env = env; return ExecuteWrap(env, info, executeInfo); } -napi_value AuthenticatorImpl::ExecuteWrap(napi_env env, napi_callback_info info, ExecuteInfo* executeInfo) +napi_value AuthenticatorImpl::ExecuteWrap(napi_env env, napi_callback_info info, NapiExecuteInfo* executeInfo) { USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); size_t argc = ARGS_MAX_COUNT; @@ -540,7 +644,7 @@ napi_value AuthenticatorImpl::ExecuteWrap(napi_env env, napi_callback_info info, } } -void AuthenticatorImpl::JudgeString(napi_env env, napi_value* argv, ExecuteInfo* executeInfo) +void AuthenticatorImpl::JudgeString(napi_env env, napi_value* argv, NapiExecuteInfo* executeInfo) { USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); napi_valuetype valuetype; @@ -573,19 +677,19 @@ void AuthenticatorImpl::JudgeString(napi_env env, napi_value* argv, ExecuteInfo* napi_create_async_work( env, nullptr, resourceName, [](napi_env env, void *data) { - ExecuteInfo *executeInfo = (ExecuteInfo *)data; + NapiExecuteInfo *executeInfo = (NapiExecuteInfo *)data; std::shared_ptr userauthAPI7callback = std::make_shared(executeInfo); API7UserAuth::UserAuthAPI7::GetAuthenticator().Execute(executeInfo->type, executeInfo->level, userauthAPI7callback); }, [](napi_env env, napi_status status, void *data) { - ExecuteInfo *executeInfo = (ExecuteInfo *)data; + NapiExecuteInfo *executeInfo = (NapiExecuteInfo *)data; napi_delete_async_work(env, executeInfo->asyncWork); }, (void *)executeInfo, &executeInfo->asyncWork); napi_queue_async_work(env, executeInfo->asyncWork); } -napi_value AuthenticatorImpl::ExecuteAsyncallback(napi_env env, napi_value* argv, ExecuteInfo* executeInfo) +napi_value AuthenticatorImpl::ExecuteAsyncallback(napi_env env, napi_value* argv, NapiExecuteInfo* executeInfo) { USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); JudgeString(env,argv,executeInfo); @@ -594,7 +698,7 @@ napi_value AuthenticatorImpl::ExecuteAsyncallback(napi_env env, napi_value* argv return result; } -napi_value AuthenticatorImpl::ExecutePromise(napi_env env, napi_value* argv, ExecuteInfo* executeInfo) +napi_value AuthenticatorImpl::ExecutePromise(napi_env env, napi_value* argv, NapiExecuteInfo* executeInfo) { USERAUTH_HILOGI(MODULE_JS_NAPI, "%{public}s, start.", __func__); JudgeString(env,argv,executeInfo); diff --git a/interfaces/kits/napi/src/user_auth_helper_north.cpp b/interfaces/kits/napi/src/user_auth_helper_north.cpp index d39864d46..816e88a71 100755 --- a/interfaces/kits/napi/src/user_auth_helper_north.cpp +++ b/interfaces/kits/napi/src/user_auth_helper_north.cpp @@ -37,7 +37,7 @@ napi_value GetCtor(napi_env env) napi_value cons = nullptr; napi_property_descriptor clzDes[] = { DECLARE_NAPI_FUNCTION("getVersion", UserIAM::UserAuth::GetVersion), - DECLARE_NAPI_FUNCTION("getAvailabeStatus", UserIAM::UserAuth::GetAvailabeStatus), + DECLARE_NAPI_FUNCTION("getAvailableStatus", UserIAM::UserAuth::GetAvailableStatus), DECLARE_NAPI_FUNCTION("auth", UserIAM::UserAuth::Auth), }; NAPI_CALL(env, napi_define_class(env, "UserAuthNorth", NAPI_AUTO_LENGTH, diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 28cdb28e0..33399633f 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -20,10 +20,7 @@ module_output_path = "${userauth_native_part_name}/UserAuth_test" config("module_private_config") { visibility = [ ":*" ] - include_dirs = [ - "include", - "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", - ] + include_dirs = [ "include" ] } ##############################unittest########################################## @@ -34,30 +31,15 @@ ohos_unittest("unittest_test") { include_dirs = [ "include", - - #"//base/user_iam/user_idm/unittest/include", - "//out/hi3516dv300/innerkits/ohos-arm/ipc/ipc_single/include", "//base/user_iam/user_auth/interfaces/innerkits/include", - - #"//base/user_iam/user_idm/services/include", ] - configs = [ - #"${userauth_utils_path}:utils_config", - ":module_private_config", - ] + configs = [ ":module_private_config" ] deps = [ "${userauth_innerkits_path}/native:userauth_framework", - "//drivers/peripheral/display/hal:hdi_display_device", - "//third_party/googletest:gtest_main", "//utils/native/base:utils", ] - external_deps = [ - "hiviewdfx_hilog_native:libhilog", - "ipc:ipc_core", - "safwk:system_ability_fwk", - "samgr_standard:samgr_proxy", - ] + external_deps = [ "ipc:ipc_core" ] } diff --git a/test/unittest/src/userauth_test.cpp b/test/unittest/src/userauth_test.cpp index 306820a14..8d58ee5b8 100644 --- a/test/unittest/src/userauth_test.cpp +++ b/test/unittest/src/userauth_test.cpp @@ -18,6 +18,7 @@ #include #include "user_auth.h" #include "userauth_api7.h" +#include "userauth_api7_datamgr.h" #include "userauth_callback.h" #include "userauth_info.h" #include "userauth_test.h" -- Gitee