From 8073beb2ab874d8aa9fe79efc6278cf2f053a3b5 Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Fri, 5 Aug 2022 08:49:14 +0800 Subject: [PATCH 1/6] =?UTF-8?q?2022/08/05=20=E6=9D=83=E9=99=90=E6=8E=88?= =?UTF-8?q?=E6=9D=83=E7=8A=B6=E6=80=81=E7=9B=91=E5=90=ACnapi=20Signed-off-?= =?UTF-8?q?by:hanshu5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhhs9527 --- .../accesstoken/napi/include/napi_atmanager.h | 63 +++ .../accesstoken/napi/src/napi_atmanager.cpp | 458 +++++++++++++++++- 2 files changed, 520 insertions(+), 1 deletion(-) diff --git a/interfaces/kits/accesstoken/napi/include/napi_atmanager.h b/interfaces/kits/accesstoken/napi/include/napi_atmanager.h index 167e816c9..2054d85a3 100644 --- a/interfaces/kits/accesstoken/napi/include/napi_atmanager.h +++ b/interfaces/kits/accesstoken/napi/include/napi_atmanager.h @@ -19,9 +19,13 @@ #include #include #include +#include +#include "access_token.h" +#include "accesstoken_kit.h" #include "napi/native_api.h" #include "napi/native_node_api.h" +#include "perm_state_change_callback_customize.h" namespace OHOS { namespace Security { @@ -32,9 +36,55 @@ const int VALUE_BUFFER_SIZE = 256; const int ASYNC_CALL_BACK_VALUES_NUM = 2; const int VERIFY_OR_FLAG_INPUT_MAX_VALUES = 2; const int GRANT_OR_REVOKE_INPUT_MAX_VALUES = 4; +const size_t ARGS_SIZE_ONE = 1; +const size_t ARGS_SIZE_FOUR = 4; +const int PARAM0 = 0; +const int PARAM1 = 1; +const int PARAM2 = 2; +const int PARAM3 = 3; static thread_local napi_ref atManagerRef_; const std::string ATMANAGER_CLASS_NAME = "atManager"; +class RegisterPermStateChangeScopePtr : public PermStateChangeCallbackCustomize { +private: + napi_env env_ = nullptr; + napi_ref ref_ = nullptr; +public: + explicit RegisterPermStateChangeScopePtr(const PermStateChangeScope &subscribeInfo); + ~RegisterPermStateChangeScopePtr(); + void PermStateChangeCallback(PermStateChangeInfo& result); + void SetEnv(const napi_env &env); + void SetCallbackRef(const napi_ref &ref); +}; + +struct RegisterPermStateChangeWorker { + napi_env env = nullptr; + napi_ref ref = nullptr; + PermStateChangeInfo result; + RegisterPermStateChangeScopePtr *subscriber = nullptr; +}; + + +struct RegisterPermStateChangeInfo { + napi_env env = nullptr; + napi_async_work work = nullptr; + napi_ref callbackRef = nullptr; + std::string permStateChangeType; + PermStateChangeScope scopeInfo; + AccessTokenKit *accessTokenKit = nullptr; + std::shared_ptr subscriber = nullptr; +}; + +struct UnregisterPermStateChangeInfo { + napi_env env; + napi_async_work work; + napi_ref callbackRef; + size_t argc; + std::string permStateChangeType = 0; + PermStateChangeScope scopeInfo; + AccessTokenKit *accessTokenKit = nullptr; + std::shared_ptr subscriber; +}; struct AtManagerAsyncContext { napi_env env = nullptr; @@ -75,6 +125,19 @@ private: static void GetPermissionFlagsExcute(napi_env env, void *data); static void GetPermissionFlagsComplete(napi_env env, napi_status status, void *data); static void SetNamedProperty(napi_env env, napi_value dstObj, const int32_t objValue, const char *propName); + + static void ParseInputToRegister(const napi_env env, napi_value (&argv)[ARGS_SIZE_FOUR], std::string &type, + napi_ref &callback, std::vector& tokenIDs, std::vector& permList); + static napi_value RegisterPermStateChangeCallback(napi_env env, napi_callback_info cbinfo); + static void RegisterPermStateChangeExcute(napi_env env, void *data); + static void RegisterPermStateChangeComplete(napi_env env, napi_status status, void *data); + static void ParseInputToUnregister(const napi_env env, const size_t &argc, const napi_value (&argv)[ARGS_SIZE_FOUR], + std::string &type, napi_ref &callback, std::vector& tokenIDs, std::vector& permList); + static napi_value UnregisterPermStateChangeCallback(napi_env env, napi_callback_info cbinfo); + static void UnregisterPermStateChangeExcuteCB(napi_env env, void *data); + static void UnregisterPermStateChangeCompletedCB(napi_env env, napi_status status, void *data); + static void FindRegisterInMap(std::shared_ptr &subscriber, + UnregisterPermStateChangeInfo *unregisterPermStateChangeInfo, bool &isFind); }; } // namespace AccessToken } // namespace Security diff --git a/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp b/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp index a74f44ccc..7ea73c7af 100644 --- a/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp +++ b/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp @@ -16,6 +16,7 @@ #include #include +#include #include #include @@ -27,12 +28,189 @@ namespace OHOS { namespace Security { namespace AccessToken { +std::mutex g_lockForPermStateChangeRegisters; +std::map> g_PermStateChangeRegisters; namespace { static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "AccessTokenAbilityAccessCtrl" }; + +static napi_value WrapVoidToJS(napi_env env) +{ + napi_value result = nullptr; + NAPI_CALL(env, napi_get_null(env, &result)); + return result; +}; + +static std::vector ParseStringArray(const napi_env env, const napi_value value) +{ + std::vector res; + uint32_t length = 0; + + napi_get_array_length(env, value, &length); + napi_value valueArray; + for (uint32_t i = 0; i < length; i++) { + napi_get_element(env, value, i, &valueArray); + char valueChar[ VALUE_BUFFER_SIZE ] = { 0 }; + size_t resultout; + napi_get_value_string_utf8(env, valueArray, valueChar, + VALUE_BUFFER_SIZE + 1, &resultout); // get string + res.emplace_back(std::string(valueChar)); + } + return res; +}; + +static std::vector ParseAccessTokenIDArray(const napi_env env, const napi_value value) +{ + std::vector res; + uint32_t length = 0; + + napi_get_array_length(env, value, &length); + napi_value valueArray; + for (uint32_t i = 0; i < length; i++) { + napi_get_element(env, value, i, &valueArray); + AccessTokenID result; + napi_get_value_uint32(env, valueArray, &result); + res.emplace_back(result); + } + return res; +}; + +static void ConvertPermStateChangeInfo(napi_env env, napi_value value, const PermStateChangeInfo result) +{ + napi_create_object(env, &value); + napi_value type = nullptr; + napi_create_int32(env, result.PermStateChangeType, &type); + napi_set_named_property(env, value, "change", type); + ACCESSTOKEN_LOG_DEBUG(LABEL, "PermStateChangeType = %{public}d", result.PermStateChangeType); + napi_value tokenId = nullptr; + napi_create_int32(env, result.tokenID, &tokenId); + napi_set_named_property(env, value, "tokenID", tokenId); + ACCESSTOKEN_LOG_DEBUG(LABEL, "tokenID = %{public}d", result.tokenID); + napi_value permissionName = nullptr; + napi_create_string_utf8(env, result.permissionName.c_str(), + NAPI_AUTO_LENGTH, &permissionName); + napi_set_named_property(env, value, "permissionName", permissionName); + ACCESSTOKEN_LOG_DEBUG(LABEL, "permissionName = %{public}s", result.permissionName.c_str()); +}; + +static bool CompareScopeInfo(const PermStateChangeScope &scopeInfo, + const std::vector& tokenIDs, const std::vector& permList) +{ + std::vector targetTokenIDs = scopeInfo.tokenIDs; + std::vector targetPermList = scopeInfo.permList; + if (targetTokenIDs.size() != tokenIDs.size() || targetPermList.size() != permList.size()) { + return false; + } + std::sort(targetTokenIDs.begin(), targetTokenIDs.end()); + std::sort(targetPermList.begin(), targetPermList.end()); + for (size_t i = 0; i < tokenIDs.size(); i++) { + if (targetTokenIDs[i] != tokenIDs[i]) { + return false; + } + if (targetPermList[i] != permList[i]) { + return false; + } + } + return true; +} + +static void UvQueueWorkOnAccountsChanged(uv_work_t *work, int status) +{ + ACCESSTOKEN_LOG_DEBUG(LABEL, "UvQueueWorkOnAccountsChanged begin"); + if (work == nullptr || work->data == nullptr) { + ACCESSTOKEN_LOG_INFO(LABEL, "------work == nullptr || work->data == nullptr"); + return; + } + RegisterPermStateChangeWorker *registerPermStateChangeData = + reinterpret_cast(work->data); + napi_value result = nullptr; + ConvertPermStateChangeInfo(registerPermStateChangeData->env, result, registerPermStateChangeData->result); + napi_value undefined = nullptr; + napi_value callback = nullptr; + napi_value resultout = nullptr; + napi_get_undefined(registerPermStateChangeData->env, &undefined); + + // PermStateChangeScope targetScopeInfo; + // (*registerPermStateChangeData->subscriber).GetScope(targetScopeInfo); + // std::sort(targetScopeInfo.tokenIDs.begin(), targetScopeInfo.tokenIDs.end()); + // std::sort(targetScopeInfo.permList.begin(), targetScopeInfo.permList.end()); + bool isFound = false; + { + std::lock_guard lock(g_lockForPermStateChangeRegisters); + for (auto registersInstance : g_PermStateChangeRegisters) { + for (auto item : registersInstance.second) { + if (item->subscriber.get() == registerPermStateChangeData->subscriber) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "subscriber is found"); + isFound = true; + break; + } + } + } + } + if (isFound) { + napi_get_reference_value(registerPermStateChangeData->env, registerPermStateChangeData->ref, &callback); + } else { + ACCESSTOKEN_LOG_DEBUG(LABEL, "subscriber is not found"); + } + NAPI_CALL_RETURN_VOID(registerPermStateChangeData->env, + napi_call_function(registerPermStateChangeData->env, undefined, callback, ARGS_SIZE_ONE, &result, &resultout)); + ACCESSTOKEN_LOG_DEBUG(LABEL, "UvQueueWorkOnAccountsChanged end"); + delete registerPermStateChangeData; + registerPermStateChangeData = nullptr; + delete work; +}; } // namespace +RegisterPermStateChangeScopePtr::RegisterPermStateChangeScopePtr(const PermStateChangeScope &subscribeInfo) + : PermStateChangeCallbackCustomize(subscribeInfo) +{} + +RegisterPermStateChangeScopePtr::~RegisterPermStateChangeScopePtr() +{} + +void RegisterPermStateChangeScopePtr::PermStateChangeCallback(PermStateChangeInfo& result) +{ + ACCESSTOKEN_LOG_DEBUG(LABEL, "PermStateChangeCallback"); + uv_loop_s *loop = nullptr; + napi_get_uv_event_loop(env_, &loop); + if (loop == nullptr) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "loop instance is nullptr"); + return; + } + uv_work_t *work = new (std::nothrow) uv_work_t; + if (work == nullptr) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "insufficient memory for work!"); + return; + } + + RegisterPermStateChangeWorker *registerPermStateChangeWorker = + new (std::nothrow) RegisterPermStateChangeWorker(); + + if (registerPermStateChangeWorker == nullptr) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "insufficient memory for RegisterPermStateChangeWorker!"); + delete work; + return; + } + registerPermStateChangeWorker->env = env_; + registerPermStateChangeWorker->ref = ref_; + registerPermStateChangeWorker->result = result; + registerPermStateChangeWorker->subscriber = this; + work->data = reinterpret_cast(registerPermStateChangeWorker); + uv_queue_work(loop, work, [](uv_work_t *work) {}, UvQueueWorkOnAccountsChanged); + ACCESSTOKEN_LOG_DEBUG(LABEL, "PermStateChangeCallback end"); +} + +void RegisterPermStateChangeScopePtr::SetEnv(const napi_env &env) +{ + env_ = env; +} + +void RegisterPermStateChangeScopePtr::SetCallbackRef(const napi_ref &ref) +{ + ref_ = ref; +} + void NapiAtManager::SetNamedProperty(napi_env env, napi_value dstObj, const int32_t objValue, const char *propName) { napi_value prop = nullptr; @@ -54,7 +232,9 @@ napi_value NapiAtManager::Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("verifyAccessTokenSync", VerifyAccessTokenSync), DECLARE_NAPI_FUNCTION("grantUserGrantedPermission", GrantUserGrantedPermission), DECLARE_NAPI_FUNCTION("revokeUserGrantedPermission", RevokeUserGrantedPermission), - DECLARE_NAPI_FUNCTION("getPermissionFlags", GetPermissionFlags) + DECLARE_NAPI_FUNCTION("getPermissionFlags", GetPermissionFlags), + DECLARE_NAPI_FUNCTION("on", RegisterPermStateChangeCallback), + DECLARE_NAPI_FUNCTION("off", UnregisterPermStateChangeCallback), }; napi_value cons = nullptr; @@ -550,6 +730,282 @@ napi_value NapiAtManager::GetPermissionFlags(napi_env env, napi_callback_info in return result; } + +void NapiAtManager::ParseInputToRegister(const napi_env env, napi_value (&argv)[ARGS_SIZE_FOUR], std::string &type, napi_ref &callback, + std::vector& tokenIDs, std::vector& permList) +{ + napi_valuetype valueType = napi_undefined; + ACCESSTOKEN_LOG_DEBUG(LABEL, "ParseInputToRegister begin."); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_string) { + char typeName[ VALUE_BUFFER_SIZE ] = { 0 }; + size_t result; + napi_get_value_string_utf8(env, argv[PARAM0], typeName, + VALUE_BUFFER_SIZE + 1, &result); // get typeName + type = std::string(typeName); + } else { + ACCESSTOKEN_LOG_ERROR(LABEL, "Type matching failed"); + return; + } + tokenIDs = ParseAccessTokenIDArray(env, argv[PARAM1]); // get tokenIDs + permList = ParseStringArray(env, argv[PARAM2]); // get permList + napi_typeof(env, argv[PARAM3], &valueType); // get PARAM[3] type + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM3], 1, &callback); // get callback + } else { + ACCESSTOKEN_LOG_ERROR(LABEL, "Type matching failed"); + return; + } +} + +void NapiAtManager::RegisterPermStateChangeExcute(napi_env env, void *data) +{ + ACCESSTOKEN_LOG_DEBUG(LABEL, "napi_create_async_work running"); + RegisterPermStateChangeInfo *registerPermStateChangeInfo = + reinterpret_cast(data); + (*registerPermStateChangeInfo->subscriber).SetEnv(env); + (*registerPermStateChangeInfo->subscriber).SetCallbackRef(registerPermStateChangeInfo->callbackRef); + int errCode = AccessTokenKit::RegisterPermStateChangeCallback(registerPermStateChangeInfo->subscriber); + ACCESSTOKEN_LOG_DEBUG(LABEL, "error code is %{public}d", errCode); + if (errCode != RET_FAILED) { + std::lock_guard lock(g_lockForPermStateChangeRegisters); + g_PermStateChangeRegisters[registerPermStateChangeInfo->accessTokenKit].emplace_back(registerPermStateChangeInfo); + ACCESSTOKEN_LOG_DEBUG(LABEL, "g_PermStateChangeRegisters.size = %{public}zu", g_PermStateChangeRegisters.size()); + } +} + +void NapiAtManager::RegisterPermStateChangeComplete(napi_env env, napi_status status, void *data) +{ + ACCESSTOKEN_LOG_DEBUG(LABEL, "napi_create_async_work complete"); + + RegisterPermStateChangeInfo *registerPermStateChangeInfo = + reinterpret_cast(data); + napi_delete_async_work(env, registerPermStateChangeInfo->work); +} + +napi_value NapiAtManager::RegisterPermStateChangeCallback(napi_env env, napi_callback_info cbInfo) +{ + ACCESSTOKEN_LOG_DEBUG(LABEL, "RegisterPermStateChangeCallback begin."); + size_t argc = ARGS_SIZE_FOUR; + napi_value argv[ARGS_SIZE_FOUR] = {nullptr}; + napi_value thisVar = nullptr; + napi_ref callback = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, cbInfo, &argc, argv, &thisVar, NULL)); // cnInfo -> argv + std::string type; + std::vector tokenIDs; + std::vector permList; + ParseInputToRegister(env, argv, type, callback, tokenIDs, permList); + if (tokenIDs.size() == 0 || permList.size() == 0) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "Parse subscribe failed"); + return WrapVoidToJS(env); + } + RegisterPermStateChangeInfo *registerPermStateChangeInfo = + new (std::nothrow) RegisterPermStateChangeInfo(); + if (registerPermStateChangeInfo == nullptr) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "insufficient memory for subscribeCBInfo!"); + return WrapVoidToJS(env); + } + registerPermStateChangeInfo->env = env; + registerPermStateChangeInfo->work = nullptr; + registerPermStateChangeInfo->callbackRef = callback; + registerPermStateChangeInfo->permStateChangeType = type; + PermStateChangeScope scopeInfo; + scopeInfo.tokenIDs = tokenIDs; + scopeInfo.permList = permList; + registerPermStateChangeInfo->scopeInfo = scopeInfo; + registerPermStateChangeInfo->subscriber = std::make_shared(scopeInfo); + AccessTokenKit *accessTokenKitInfo = nullptr; + napi_unwrap(env, thisVar, reinterpret_cast(&accessTokenKitInfo)); + registerPermStateChangeInfo->accessTokenKit = accessTokenKitInfo; + napi_value resource = nullptr; + NAPI_CALL(env, napi_create_string_utf8(env, "RegisterPermStateChangeCallback", NAPI_AUTO_LENGTH, &resource)); + NAPI_CALL(env, napi_create_async_work(env, + nullptr, + resource, + RegisterPermStateChangeExcute, + RegisterPermStateChangeComplete, + reinterpret_cast(registerPermStateChangeInfo), + ®isterPermStateChangeInfo->work)); + napi_queue_async_work(env, registerPermStateChangeInfo->work); + return WrapVoidToJS(env); +} + +void NapiAtManager::ParseInputToUnregister(const napi_env env, const size_t &argc, const napi_value (&argv)[ARGS_SIZE_FOUR], std::string &type, + napi_ref &callback, std::vector& tokenIDs, std::vector& permList) +{ + napi_valuetype valueType = napi_undefined; + ACCESSTOKEN_LOG_DEBUG(LABEL, "ParseInputToUnregister begin."); + napi_typeof(env, argv[PARAM0], &valueType); + if (valueType == napi_string) { + char typeName[ VALUE_BUFFER_SIZE ] = { 0 }; + size_t result; + napi_get_value_string_utf8(env, argv[PARAM0], typeName, + VALUE_BUFFER_SIZE + 1, &result); // get typeName + type = std::string(typeName); + } else { + ACCESSTOKEN_LOG_ERROR(LABEL, "Type matching failed"); + return; + } + tokenIDs = ParseAccessTokenIDArray(env, argv[PARAM1]); // get tokenIDs + permList = ParseStringArray(env, argv[PARAM2]); // get permList + if (argc >= ARGS_SIZE_FOUR) { + napi_typeof(env, argv[PARAM3], &valueType); // get PRARM[3] type + if (valueType == napi_function) { + napi_create_reference(env, argv[PARAM3], 1, &callback); // get callback + } else { + ACCESSTOKEN_LOG_ERROR(LABEL, "Type matching failed"); + return; + } + } +} + +void NapiAtManager::UnregisterPermStateChangeExcuteCB(napi_env env, void *data) +{ + ACCESSTOKEN_LOG_DEBUG(LABEL, "napi_create_async_work running"); + UnregisterPermStateChangeInfo *unregisterPermStateChangeInfo = + reinterpret_cast(data); + auto subscriber = unregisterPermStateChangeInfo->subscriber; + (*subscriber).SetEnv(env); + (*subscriber).SetCallbackRef(unregisterPermStateChangeInfo->callbackRef); + int errCode = AccessTokenKit::UnRegisterPermStateChangeCallback(subscriber); + ACCESSTOKEN_LOG_DEBUG(LABEL, "error code is %{public}d", errCode); +} + +void NapiAtManager::UnregisterPermStateChangeCompletedCB(napi_env env, napi_status status, void *data) +{ + UnregisterPermStateChangeInfo *unregisterPermStateChangeInfo = + reinterpret_cast(data); + if (unregisterPermStateChangeInfo == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "unregisterPermStateChangeInfo == nullptr"); + return; + } + if (unregisterPermStateChangeInfo->argc >= ARGS_SIZE_FOUR) { + napi_value results = nullptr; + PermStateChangeInfo result; + result.PermStateChangeType = 0; + result.tokenID = 0; + result.permissionName = ""; + ConvertPermStateChangeInfo(unregisterPermStateChangeInfo->env, results, result); + napi_value callback = nullptr; + napi_get_reference_value(env, unregisterPermStateChangeInfo->callbackRef, &callback); + napi_value undefined; + napi_get_undefined(env, &undefined); + napi_value resultout = nullptr; + NAPI_CALL_RETURN_VOID(unregisterPermStateChangeInfo->env, + napi_call_function(unregisterPermStateChangeInfo->env, undefined, callback, ARGS_SIZE_ONE, &results, &resultout)); + } + if (unregisterPermStateChangeInfo->callbackRef != nullptr) { + napi_delete_reference(env, unregisterPermStateChangeInfo->callbackRef); + } + napi_delete_async_work(env, unregisterPermStateChangeInfo->work); + // erase the info from map + { + std::vector tokenIDs = unregisterPermStateChangeInfo->scopeInfo.tokenIDs; + std::vector permList = unregisterPermStateChangeInfo->scopeInfo.permList; + std::sort(tokenIDs.begin(), tokenIDs.end()); + std::sort(permList.begin(), permList.end()); + std::lock_guard lock(g_lockForPermStateChangeRegisters); + auto subscribers = g_PermStateChangeRegisters.find(unregisterPermStateChangeInfo->accessTokenKit); + if (subscribers != g_PermStateChangeRegisters.end()) { + auto it = subscribers->second.begin(); + while (it != subscribers->second.end()) { + if (CompareScopeInfo((*it)->scopeInfo, tokenIDs, permList)) { + napi_delete_reference(env, (*it)->callbackRef); + ACCESSTOKEN_LOG_DEBUG(LABEL, "Find subscribers in map, (*it)->scopeInfo.tokenId = %{public}d", (*it)->scopeInfo.tokenIDs[0]); + it = subscribers->second.erase(it); + break; + } else { + ++it; + } + } + if (subscribers->second.empty()) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "No subscriberInfo in the vector, erase the map."); + g_PermStateChangeRegisters.erase(subscribers); + } + } + } + delete unregisterPermStateChangeInfo; + unregisterPermStateChangeInfo = nullptr; +} + +napi_value NapiAtManager::UnregisterPermStateChangeCallback(napi_env env, napi_callback_info cbInfo) +{ + ACCESSTOKEN_LOG_DEBUG(LABEL, "UnregisterPermStateChangeCallback begin."); + size_t argc = ARGS_SIZE_FOUR; + napi_value argv[ARGS_SIZE_FOUR] = {nullptr}; + napi_value thisVar = nullptr; + napi_ref callback = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, cbInfo, &argc, argv, &thisVar, NULL)); + std::string type; + std::vector tokenIDs; + std::vector permList; + ParseInputToUnregister(env, argc, argv, type, callback, tokenIDs, permList); + if (tokenIDs.size() == 0 || permList.size() == 0) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "Parse subscribe failed"); + return WrapVoidToJS(env); + } + UnregisterPermStateChangeInfo *unregisterPermStateChangeInfo = + new (std::nothrow) UnregisterPermStateChangeInfo(); + if (unregisterPermStateChangeInfo == nullptr) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "insufficient memory for subscribeCBInfo!"); + return WrapVoidToJS(env); + } + AccessTokenKit *accessTokenKitInfo = nullptr; + napi_unwrap(env, thisVar, reinterpret_cast(&accessTokenKitInfo)); + unregisterPermStateChangeInfo->accessTokenKit = accessTokenKitInfo; + unregisterPermStateChangeInfo->callbackRef = callback; + unregisterPermStateChangeInfo->permStateChangeType = type; + unregisterPermStateChangeInfo->argc = argc; + PermStateChangeScope scopeInfo; + scopeInfo.tokenIDs = tokenIDs; + scopeInfo.permList = permList; + unregisterPermStateChangeInfo->scopeInfo = scopeInfo; + bool isFind = false; + std::shared_ptr subscriber; + FindRegisterInMap(subscriber, unregisterPermStateChangeInfo, isFind); + if (!isFind) { + ACCESSTOKEN_LOG_INFO(LABEL, "Unsubscribe failed. The current subscriber does not exist"); + ACCESSTOKEN_LOG_DEBUG(LABEL, "Unsubscribe failed. The current subscriber does not exist"); + return WrapVoidToJS(env); + } + ACCESSTOKEN_LOG_INFO(LABEL, "The current subscriber exist"); + unregisterPermStateChangeInfo->subscriber = subscriber; + napi_value resource = nullptr; + NAPI_CALL(env, napi_create_string_utf8(env, "RegisterPermStateChangeCallback", NAPI_AUTO_LENGTH, &resource)); + NAPI_CALL(env, napi_create_async_work(env, + nullptr, + resource, + UnregisterPermStateChangeExcuteCB, + UnregisterPermStateChangeCompletedCB, + reinterpret_cast(unregisterPermStateChangeInfo), + &(unregisterPermStateChangeInfo->work))); + napi_queue_async_work(env, unregisterPermStateChangeInfo->work); + return WrapVoidToJS(env); +} + +void NapiAtManager::FindRegisterInMap(std::shared_ptr &subscriber, + UnregisterPermStateChangeInfo *unregisterPermStateChangeInfo, bool &isFind) +{ + ACCESSTOKEN_LOG_DEBUG(LABEL, "FindRegisterInMap begin."); + std::lock_guard lock(g_lockForPermStateChangeRegisters); + std::vector tokenIDs = unregisterPermStateChangeInfo->scopeInfo.tokenIDs; + std::vector permList = unregisterPermStateChangeInfo->scopeInfo.permList; + std::sort(tokenIDs.begin(), tokenIDs.end()); + std::sort(permList.begin(), permList.end()); + for (auto registerInstance : g_PermStateChangeRegisters) { + if (registerInstance.first == unregisterPermStateChangeInfo->accessTokenKit) { + for (auto item : registerInstance.second) { + PermStateChangeScope scopeInfo; + item->subscriber->GetScope(scopeInfo); + if (CompareScopeInfo(scopeInfo, tokenIDs, permList)) { + subscriber = item->subscriber; + isFind = true; + break; + } + } + } + } +} } // namespace AccessToken } // namespace Security } // namespace OHOS -- Gitee From ea3649224c2561c2404340ae0076fbfd801eb8ef Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Mon, 8 Aug 2022 15:46:44 +0800 Subject: [PATCH 2/6] =?UTF-8?q?2022/08/08=20=E6=9D=83=E9=99=90=E6=8E=88?= =?UTF-8?q?=E6=9D=83=E7=8A=B6=E6=80=81=E7=9B=91=E5=90=ACnapi=20Signed-off-?= =?UTF-8?q?by:hanshu5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhhs9527 --- .../accesstoken/napi/include/napi_atmanager.h | 16 ++-- .../accesstoken/napi/src/napi_atmanager.cpp | 86 +++++++++---------- 2 files changed, 51 insertions(+), 51 deletions(-) diff --git a/interfaces/kits/accesstoken/napi/include/napi_atmanager.h b/interfaces/kits/accesstoken/napi/include/napi_atmanager.h index 2054d85a3..d9e197b26 100644 --- a/interfaces/kits/accesstoken/napi/include/napi_atmanager.h +++ b/interfaces/kits/accesstoken/napi/include/napi_atmanager.h @@ -37,12 +37,18 @@ const int ASYNC_CALL_BACK_VALUES_NUM = 2; const int VERIFY_OR_FLAG_INPUT_MAX_VALUES = 2; const int GRANT_OR_REVOKE_INPUT_MAX_VALUES = 4; const size_t ARGS_SIZE_ONE = 1; +const size_t ARGS_SIZE_TWO = 2; const size_t ARGS_SIZE_FOUR = 4; const int PARAM0 = 0; const int PARAM1 = 1; const int PARAM2 = 2; const int PARAM3 = 3; +enum PermStateChangeType { + PERMISSION_REVOKED_OPER = 0, + PERMISSION_GRANTED_OPER = 1, +}; + static thread_local napi_ref atManagerRef_; const std::string ATMANAGER_CLASS_NAME = "atManager"; class RegisterPermStateChangeScopePtr : public PermStateChangeCallbackCustomize { @@ -76,14 +82,14 @@ struct RegisterPermStateChangeInfo { }; struct UnregisterPermStateChangeInfo { - napi_env env; - napi_async_work work; - napi_ref callbackRef; + napi_env env = nullptr; + napi_async_work work = nullptr; + napi_ref callbackRef = nullptr; size_t argc; - std::string permStateChangeType = 0; + std::string permStateChangeType; PermStateChangeScope scopeInfo; AccessTokenKit *accessTokenKit = nullptr; - std::shared_ptr subscriber; + std::shared_ptr subscriber = nullptr; }; struct AtManagerAsyncContext { diff --git a/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp b/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp index 7ea73c7af..f91be0ae7 100644 --- a/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp +++ b/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp @@ -64,7 +64,6 @@ static std::vector ParseAccessTokenIDArray(const napi_env env, co { std::vector res; uint32_t length = 0; - napi_get_array_length(env, value, &length); napi_value valueArray; for (uint32_t i = 0; i < length; i++) { @@ -78,20 +77,17 @@ static std::vector ParseAccessTokenIDArray(const napi_env env, co static void ConvertPermStateChangeInfo(napi_env env, napi_value value, const PermStateChangeInfo result) { - napi_create_object(env, &value); + ACCESSTOKEN_LOG_DEBUG(LABEL, "ConvertPermStateChangeInfo"); napi_value type = nullptr; napi_create_int32(env, result.PermStateChangeType, &type); napi_set_named_property(env, value, "change", type); - ACCESSTOKEN_LOG_DEBUG(LABEL, "PermStateChangeType = %{public}d", result.PermStateChangeType); napi_value tokenId = nullptr; napi_create_int32(env, result.tokenID, &tokenId); napi_set_named_property(env, value, "tokenID", tokenId); - ACCESSTOKEN_LOG_DEBUG(LABEL, "tokenID = %{public}d", result.tokenID); napi_value permissionName = nullptr; napi_create_string_utf8(env, result.permissionName.c_str(), NAPI_AUTO_LENGTH, &permissionName); napi_set_named_property(env, value, "permissionName", permissionName); - ACCESSTOKEN_LOG_DEBUG(LABEL, "permissionName = %{public}s", result.permissionName.c_str()); }; static bool CompareScopeInfo(const PermStateChangeScope &scopeInfo, @@ -115,33 +111,30 @@ static bool CompareScopeInfo(const PermStateChangeScope &scopeInfo, return true; } -static void UvQueueWorkOnAccountsChanged(uv_work_t *work, int status) +static void UvQueueWorkPermStateChanged(uv_work_t *work, int status) { - ACCESSTOKEN_LOG_DEBUG(LABEL, "UvQueueWorkOnAccountsChanged begin"); + ACCESSTOKEN_LOG_DEBUG(LABEL, "UvQueueWorkPermStateChanged begin"); if (work == nullptr || work->data == nullptr) { - ACCESSTOKEN_LOG_INFO(LABEL, "------work == nullptr || work->data == nullptr"); + ACCESSTOKEN_LOG_ERROR(LABEL, "work == nullptr || work->data == nullptr"); return; } RegisterPermStateChangeWorker *registerPermStateChangeData = reinterpret_cast(work->data); - napi_value result = nullptr; - ConvertPermStateChangeInfo(registerPermStateChangeData->env, result, registerPermStateChangeData->result); + napi_value result[ARGS_SIZE_ONE] = {nullptr}; + napi_create_array(registerPermStateChangeData->env, &result[PARAM0]); + ConvertPermStateChangeInfo(registerPermStateChangeData->env, result[PARAM0], registerPermStateChangeData->result); napi_value undefined = nullptr; napi_value callback = nullptr; napi_value resultout = nullptr; napi_get_undefined(registerPermStateChangeData->env, &undefined); - // PermStateChangeScope targetScopeInfo; - // (*registerPermStateChangeData->subscriber).GetScope(targetScopeInfo); - // std::sort(targetScopeInfo.tokenIDs.begin(), targetScopeInfo.tokenIDs.end()); - // std::sort(targetScopeInfo.permList.begin(), targetScopeInfo.permList.end()); bool isFound = false; { std::lock_guard lock(g_lockForPermStateChangeRegisters); for (auto registersInstance : g_PermStateChangeRegisters) { for (auto item : registersInstance.second) { if (item->subscriber.get() == registerPermStateChangeData->subscriber) { - ACCESSTOKEN_LOG_DEBUG(LABEL, "subscriber is found"); + ACCESSTOKEN_LOG_DEBUG(LABEL, "subscriber is found"); isFound = true; break; } @@ -154,8 +147,8 @@ static void UvQueueWorkOnAccountsChanged(uv_work_t *work, int status) ACCESSTOKEN_LOG_DEBUG(LABEL, "subscriber is not found"); } NAPI_CALL_RETURN_VOID(registerPermStateChangeData->env, - napi_call_function(registerPermStateChangeData->env, undefined, callback, ARGS_SIZE_ONE, &result, &resultout)); - ACCESSTOKEN_LOG_DEBUG(LABEL, "UvQueueWorkOnAccountsChanged end"); + napi_call_function(registerPermStateChangeData->env, undefined, callback, ARGS_SIZE_ONE, &result[PARAM0], &resultout)); + ACCESSTOKEN_LOG_DEBUG(LABEL, "UvQueueWorkPermStateChanged end"); delete registerPermStateChangeData; registerPermStateChangeData = nullptr; delete work; @@ -197,7 +190,7 @@ void RegisterPermStateChangeScopePtr::PermStateChangeCallback(PermStateChangeInf registerPermStateChangeWorker->result = result; registerPermStateChangeWorker->subscriber = this; work->data = reinterpret_cast(registerPermStateChangeWorker); - uv_queue_work(loop, work, [](uv_work_t *work) {}, UvQueueWorkOnAccountsChanged); + uv_queue_work(loop, work, [](uv_work_t *work) {}, UvQueueWorkPermStateChanged); ACCESSTOKEN_LOG_DEBUG(LABEL, "PermStateChangeCallback end"); } @@ -250,8 +243,15 @@ napi_value NapiAtManager::Init(napi_env env, napi_value exports) SetNamedProperty(env, GrantStatus, PERMISSION_DENIED, "PERMISSION_DENIED"); SetNamedProperty(env, GrantStatus, PERMISSION_GRANTED, "PERMISSION_GRANTED"); + napi_value permStateChangeType = nullptr; + napi_create_object(env, &permStateChangeType); + + SetNamedProperty(env, permStateChangeType, PERMISSION_REVOKED_OPER, "PERMISSION_REVOKED_OPER"); + SetNamedProperty(env, permStateChangeType, PERMISSION_GRANTED_OPER, "PERMISSION_GRANTED_OPER"); + napi_property_descriptor exportFuncs[] = { DECLARE_NAPI_PROPERTY("GrantStatus", GrantStatus), + DECLARE_NAPI_PROPERTY("PermStateChangeType", permStateChangeType), }; napi_define_properties(env, exports, sizeof(exportFuncs) / sizeof(*exportFuncs), exportFuncs); @@ -744,7 +744,7 @@ void NapiAtManager::ParseInputToRegister(const napi_env env, napi_value (&argv)[ VALUE_BUFFER_SIZE + 1, &result); // get typeName type = std::string(typeName); } else { - ACCESSTOKEN_LOG_ERROR(LABEL, "Type matching failed"); + ACCESSTOKEN_LOG_ERROR(LABEL, "argv[PARAM0] type matching failed"); return; } tokenIDs = ParseAccessTokenIDArray(env, argv[PARAM1]); // get tokenIDs @@ -753,7 +753,7 @@ void NapiAtManager::ParseInputToRegister(const napi_env env, napi_value (&argv)[ if (valueType == napi_function) { napi_create_reference(env, argv[PARAM3], 1, &callback); // get callback } else { - ACCESSTOKEN_LOG_ERROR(LABEL, "Type matching failed"); + ACCESSTOKEN_LOG_ERROR(LABEL, "argv[PARAM3] type matching failed"); return; } } @@ -772,6 +772,7 @@ void NapiAtManager::RegisterPermStateChangeExcute(napi_env env, void *data) g_PermStateChangeRegisters[registerPermStateChangeInfo->accessTokenKit].emplace_back(registerPermStateChangeInfo); ACCESSTOKEN_LOG_DEBUG(LABEL, "g_PermStateChangeRegisters.size = %{public}zu", g_PermStateChangeRegisters.size()); } + ACCESSTOKEN_LOG_INFO(LABEL, "error code is %{public}d", errCode); } void NapiAtManager::RegisterPermStateChangeComplete(napi_env env, napi_status status, void *data) @@ -781,6 +782,7 @@ void NapiAtManager::RegisterPermStateChangeComplete(napi_env env, napi_status st RegisterPermStateChangeInfo *registerPermStateChangeInfo = reinterpret_cast(data); napi_delete_async_work(env, registerPermStateChangeInfo->work); + ACCESSTOKEN_LOG_DEBUG(LABEL, "RegisterPermStateChangeComplete end"); } napi_value NapiAtManager::RegisterPermStateChangeCallback(napi_env env, napi_callback_info cbInfo) @@ -795,10 +797,6 @@ napi_value NapiAtManager::RegisterPermStateChangeCallback(napi_env env, napi_cal std::vector tokenIDs; std::vector permList; ParseInputToRegister(env, argv, type, callback, tokenIDs, permList); - if (tokenIDs.size() == 0 || permList.size() == 0) { - ACCESSTOKEN_LOG_DEBUG(LABEL, "Parse subscribe failed"); - return WrapVoidToJS(env); - } RegisterPermStateChangeInfo *registerPermStateChangeInfo = new (std::nothrow) RegisterPermStateChangeInfo(); if (registerPermStateChangeInfo == nullptr) { @@ -843,7 +841,7 @@ void NapiAtManager::ParseInputToUnregister(const napi_env env, const size_t &arg VALUE_BUFFER_SIZE + 1, &result); // get typeName type = std::string(typeName); } else { - ACCESSTOKEN_LOG_ERROR(LABEL, "Type matching failed"); + ACCESSTOKEN_LOG_ERROR(LABEL, "argv[PARAM0] type matching failed"); return; } tokenIDs = ParseAccessTokenIDArray(env, argv[PARAM1]); // get tokenIDs @@ -853,7 +851,7 @@ void NapiAtManager::ParseInputToUnregister(const napi_env env, const size_t &arg if (valueType == napi_function) { napi_create_reference(env, argv[PARAM3], 1, &callback); // get callback } else { - ACCESSTOKEN_LOG_ERROR(LABEL, "Type matching failed"); + ACCESSTOKEN_LOG_ERROR(LABEL, "argv[PARAM3] type matching failed"); return; } } @@ -873,26 +871,22 @@ void NapiAtManager::UnregisterPermStateChangeExcuteCB(napi_env env, void *data) void NapiAtManager::UnregisterPermStateChangeCompletedCB(napi_env env, napi_status status, void *data) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "UnregisterPermStateChangeCompletedCB begin"); UnregisterPermStateChangeInfo *unregisterPermStateChangeInfo = reinterpret_cast(data); - if (unregisterPermStateChangeInfo == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "unregisterPermStateChangeInfo == nullptr"); - return; - } if (unregisterPermStateChangeInfo->argc >= ARGS_SIZE_FOUR) { - napi_value results = nullptr; - PermStateChangeInfo result; - result.PermStateChangeType = 0; - result.tokenID = 0; - result.permissionName = ""; - ConvertPermStateChangeInfo(unregisterPermStateChangeInfo->env, results, result); - napi_value callback = nullptr; - napi_get_reference_value(env, unregisterPermStateChangeInfo->callbackRef, &callback); + napi_value results[ARGS_SIZE_ONE] = {nullptr}; + napi_value result = nullptr; + napi_get_null(env, &result); napi_value undefined; napi_get_undefined(env, &undefined); napi_value resultout = nullptr; - NAPI_CALL_RETURN_VOID(unregisterPermStateChangeInfo->env, - napi_call_function(unregisterPermStateChangeInfo->env, undefined, callback, ARGS_SIZE_ONE, &results, &resultout)); + napi_value callback = nullptr; + + napi_get_reference_value(env, unregisterPermStateChangeInfo->callbackRef, &callback); + results[PARAM0] = result; + NAPI_CALL_RETURN_VOID(env, + napi_call_function(env, undefined, callback, ARGS_SIZE_ONE, &results[PARAM0], &resultout)); } if (unregisterPermStateChangeInfo->callbackRef != nullptr) { napi_delete_reference(env, unregisterPermStateChangeInfo->callbackRef); @@ -900,6 +894,7 @@ void NapiAtManager::UnregisterPermStateChangeCompletedCB(napi_env env, napi_stat napi_delete_async_work(env, unregisterPermStateChangeInfo->work); // erase the info from map { + ACCESSTOKEN_LOG_DEBUG(LABEL, "erase the info from map"); std::vector tokenIDs = unregisterPermStateChangeInfo->scopeInfo.tokenIDs; std::vector permList = unregisterPermStateChangeInfo->scopeInfo.permList; std::sort(tokenIDs.begin(), tokenIDs.end()); @@ -909,6 +904,7 @@ void NapiAtManager::UnregisterPermStateChangeCompletedCB(napi_env env, napi_stat if (subscribers != g_PermStateChangeRegisters.end()) { auto it = subscribers->second.begin(); while (it != subscribers->second.end()) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "erase before g_PermStateChangeRegisters.second size = %{public}zu", subscribers->second.size()); if (CompareScopeInfo((*it)->scopeInfo, tokenIDs, permList)) { napi_delete_reference(env, (*it)->callbackRef); ACCESSTOKEN_LOG_DEBUG(LABEL, "Find subscribers in map, (*it)->scopeInfo.tokenId = %{public}d", (*it)->scopeInfo.tokenIDs[0]); @@ -918,6 +914,7 @@ void NapiAtManager::UnregisterPermStateChangeCompletedCB(napi_env env, napi_stat ++it; } } + ACCESSTOKEN_LOG_DEBUG(LABEL, "erase after g_PermStateChangeRegisters.second size = %{public}zu", subscribers->second.size()); if (subscribers->second.empty()) { ACCESSTOKEN_LOG_DEBUG(LABEL, "No subscriberInfo in the vector, erase the map."); g_PermStateChangeRegisters.erase(subscribers); @@ -940,10 +937,7 @@ napi_value NapiAtManager::UnregisterPermStateChangeCallback(napi_env env, napi_c std::vector tokenIDs; std::vector permList; ParseInputToUnregister(env, argc, argv, type, callback, tokenIDs, permList); - if (tokenIDs.size() == 0 || permList.size() == 0) { - ACCESSTOKEN_LOG_DEBUG(LABEL, "Parse subscribe failed"); - return WrapVoidToJS(env); - } + UnregisterPermStateChangeInfo *unregisterPermStateChangeInfo = new (std::nothrow) UnregisterPermStateChangeInfo(); if (unregisterPermStateChangeInfo == nullptr) { @@ -964,11 +958,10 @@ napi_value NapiAtManager::UnregisterPermStateChangeCallback(napi_env env, napi_c std::shared_ptr subscriber; FindRegisterInMap(subscriber, unregisterPermStateChangeInfo, isFind); if (!isFind) { - ACCESSTOKEN_LOG_INFO(LABEL, "Unsubscribe failed. The current subscriber does not exist"); ACCESSTOKEN_LOG_DEBUG(LABEL, "Unsubscribe failed. The current subscriber does not exist"); return WrapVoidToJS(env); } - ACCESSTOKEN_LOG_INFO(LABEL, "The current subscriber exist"); + ACCESSTOKEN_LOG_DEBUG(LABEL, "The current subscriber exist"); unregisterPermStateChangeInfo->subscriber = subscriber; napi_value resource = nullptr; NAPI_CALL(env, napi_create_string_utf8(env, "RegisterPermStateChangeCallback", NAPI_AUTO_LENGTH, &resource)); @@ -998,6 +991,7 @@ void NapiAtManager::FindRegisterInMap(std::shared_ptrsubscriber->GetScope(scopeInfo); if (CompareScopeInfo(scopeInfo, tokenIDs, permList)) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "find subscriber in map"); subscriber = item->subscriber; isFind = true; break; -- Gitee From 5d679bb8757954afb11998c0b195ad4b01b1c846 Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Mon, 8 Aug 2022 15:48:41 +0800 Subject: [PATCH 3/6] =?UTF-8?q?2022/08/08=20=E6=9D=83=E9=99=90=E6=8E=88?= =?UTF-8?q?=E6=9D=83=E7=8A=B6=E6=80=81=E7=9B=91=E5=90=ACnapi=20Signed-off-?= =?UTF-8?q?by:hanshu5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhhs9527 --- .../accesstoken/napi/include/napi_atmanager.h | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/interfaces/kits/accesstoken/napi/include/napi_atmanager.h b/interfaces/kits/accesstoken/napi/include/napi_atmanager.h index d9e197b26..d6a569160 100644 --- a/interfaces/kits/accesstoken/napi/include/napi_atmanager.h +++ b/interfaces/kits/accesstoken/napi/include/napi_atmanager.h @@ -132,18 +132,18 @@ private: static void GetPermissionFlagsComplete(napi_env env, napi_status status, void *data); static void SetNamedProperty(napi_env env, napi_value dstObj, const int32_t objValue, const char *propName); - static void ParseInputToRegister(const napi_env env, napi_value (&argv)[ARGS_SIZE_FOUR], std::string &type, - napi_ref &callback, std::vector& tokenIDs, std::vector& permList); - static napi_value RegisterPermStateChangeCallback(napi_env env, napi_callback_info cbinfo); - static void RegisterPermStateChangeExcute(napi_env env, void *data); - static void RegisterPermStateChangeComplete(napi_env env, napi_status status, void *data); - static void ParseInputToUnregister(const napi_env env, const size_t &argc, const napi_value (&argv)[ARGS_SIZE_FOUR], - std::string &type, napi_ref &callback, std::vector& tokenIDs, std::vector& permList); - static napi_value UnregisterPermStateChangeCallback(napi_env env, napi_callback_info cbinfo); - static void UnregisterPermStateChangeExcuteCB(napi_env env, void *data); - static void UnregisterPermStateChangeCompletedCB(napi_env env, napi_status status, void *data); - static void FindRegisterInMap(std::shared_ptr &subscriber, - UnregisterPermStateChangeInfo *unregisterPermStateChangeInfo, bool &isFind); + static void ParseInputToRegister(const napi_env env, napi_value (&argv)[ARGS_SIZE_FOUR], std::string &type, + napi_ref &callback, std::vector& tokenIDs, std::vector& permList); + static napi_value RegisterPermStateChangeCallback(napi_env env, napi_callback_info cbinfo); + static void RegisterPermStateChangeExcute(napi_env env, void *data); + static void RegisterPermStateChangeComplete(napi_env env, napi_status status, void *data); + static void ParseInputToUnregister(const napi_env env, const size_t &argc, const napi_value (&argv)[ARGS_SIZE_FOUR], + std::string &type, napi_ref &callback, std::vector& tokenIDs, std::vector& permList); + static napi_value UnregisterPermStateChangeCallback(napi_env env, napi_callback_info cbinfo); + static void UnregisterPermStateChangeExcuteCB(napi_env env, void *data); + static void UnregisterPermStateChangeCompletedCB(napi_env env, napi_status status, void *data); + static void FindRegisterInMap(std::shared_ptr &subscriber, + UnregisterPermStateChangeInfo *unregisterPermStateChangeInfo, bool &isFind); }; } // namespace AccessToken } // namespace Security -- Gitee From dc775448e5e9f8e3018d150ad17bf6294f467bb1 Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Mon, 8 Aug 2022 16:27:23 +0800 Subject: [PATCH 4/6] =?UTF-8?q?2022/08/08=20=E6=9D=83=E9=99=90=E6=8E=88?= =?UTF-8?q?=E6=9D=83=E7=8A=B6=E6=80=81=E7=9B=91=E5=90=ACnapi=20Signed-off-?= =?UTF-8?q?by:hanshu5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhhs9527 --- .../accesstoken/napi/include/napi_atmanager.h | 7 ++-- .../accesstoken/napi/src/napi_atmanager.cpp | 36 +++++++++++-------- 2 files changed, 26 insertions(+), 17 deletions(-) diff --git a/interfaces/kits/accesstoken/napi/include/napi_atmanager.h b/interfaces/kits/accesstoken/napi/include/napi_atmanager.h index d6a569160..d2585cf7c 100644 --- a/interfaces/kits/accesstoken/napi/include/napi_atmanager.h +++ b/interfaces/kits/accesstoken/napi/include/napi_atmanager.h @@ -137,12 +137,13 @@ private: static napi_value RegisterPermStateChangeCallback(napi_env env, napi_callback_info cbinfo); static void RegisterPermStateChangeExcute(napi_env env, void *data); static void RegisterPermStateChangeComplete(napi_env env, napi_status status, void *data); - static void ParseInputToUnregister(const napi_env env, const size_t &argc, const napi_value (&argv)[ARGS_SIZE_FOUR], - std::string &type, napi_ref &callback, std::vector& tokenIDs, std::vector& permList); + static void ParseInputToUnregister(const napi_env env, const size_t &argc, + const napi_value (&argv)[ARGS_SIZE_FOUR], std::string &type, napi_ref &callback, + std::vector& tokenIDs, std::vector& permList); static napi_value UnregisterPermStateChangeCallback(napi_env env, napi_callback_info cbinfo); static void UnregisterPermStateChangeExcuteCB(napi_env env, void *data); static void UnregisterPermStateChangeCompletedCB(napi_env env, napi_status status, void *data); - static void FindRegisterInMap(std::shared_ptr &subscriber, + static void FindRegisterInMap(std::shared_ptr &subscriber, UnregisterPermStateChangeInfo *unregisterPermStateChangeInfo, bool &isFind); }; } // namespace AccessToken diff --git a/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp b/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp index f91be0ae7..44ac78788 100644 --- a/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp +++ b/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp @@ -54,7 +54,7 @@ static std::vector ParseStringArray(const napi_env env, const napi_ char valueChar[ VALUE_BUFFER_SIZE ] = { 0 }; size_t resultout; napi_get_value_string_utf8(env, valueArray, valueChar, - VALUE_BUFFER_SIZE + 1, &resultout); // get string + VALUE_BUFFER_SIZE + 1, &resultout); // get string res.emplace_back(std::string(valueChar)); } return res; @@ -70,7 +70,7 @@ static std::vector ParseAccessTokenIDArray(const napi_env env, co napi_get_element(env, value, i, &valueArray); AccessTokenID result; napi_get_value_uint32(env, valueArray, &result); - res.emplace_back(result); + res.emplace_back(result); } return res; }; @@ -147,7 +147,8 @@ static void UvQueueWorkPermStateChanged(uv_work_t *work, int status) ACCESSTOKEN_LOG_DEBUG(LABEL, "subscriber is not found"); } NAPI_CALL_RETURN_VOID(registerPermStateChangeData->env, - napi_call_function(registerPermStateChangeData->env, undefined, callback, ARGS_SIZE_ONE, &result[PARAM0], &resultout)); + napi_call_function(registerPermStateChangeData->env, + undefined, callback, ARGS_SIZE_ONE, &result[PARAM0], &resultout)); ACCESSTOKEN_LOG_DEBUG(LABEL, "UvQueueWorkPermStateChanged end"); delete registerPermStateChangeData; registerPermStateChangeData = nullptr; @@ -731,7 +732,8 @@ napi_value NapiAtManager::GetPermissionFlags(napi_env env, napi_callback_info in return result; } -void NapiAtManager::ParseInputToRegister(const napi_env env, napi_value (&argv)[ARGS_SIZE_FOUR], std::string &type, napi_ref &callback, +void NapiAtManager::ParseInputToRegister(const napi_env env, + napi_value (&argv)[ARGS_SIZE_FOUR], std::string &type, napi_ref &callback, std::vector& tokenIDs, std::vector& permList) { napi_valuetype valueType = napi_undefined; @@ -760,7 +762,7 @@ void NapiAtManager::ParseInputToRegister(const napi_env env, napi_value (&argv)[ void NapiAtManager::RegisterPermStateChangeExcute(napi_env env, void *data) { - ACCESSTOKEN_LOG_DEBUG(LABEL, "napi_create_async_work running"); + ACCESSTOKEN_LOG_DEBUG(LABEL, "napi_create_async_work running"); RegisterPermStateChangeInfo *registerPermStateChangeInfo = reinterpret_cast(data); (*registerPermStateChangeInfo->subscriber).SetEnv(env); @@ -769,8 +771,10 @@ void NapiAtManager::RegisterPermStateChangeExcute(napi_env env, void *data) ACCESSTOKEN_LOG_DEBUG(LABEL, "error code is %{public}d", errCode); if (errCode != RET_FAILED) { std::lock_guard lock(g_lockForPermStateChangeRegisters); - g_PermStateChangeRegisters[registerPermStateChangeInfo->accessTokenKit].emplace_back(registerPermStateChangeInfo); - ACCESSTOKEN_LOG_DEBUG(LABEL, "g_PermStateChangeRegisters.size = %{public}zu", g_PermStateChangeRegisters.size()); + g_PermStateChangeRegisters[registerPermStateChangeInfo->accessTokenKit].emplace_back( + registerPermStateChangeInfo); + ACCESSTOKEN_LOG_DEBUG(LABEL, "g_PermStateChangeRegisters->second.size = %{public}zu", + g_PermStateChangeRegisters[registerPermStateChangeInfo->accessTokenKit].size()); } ACCESSTOKEN_LOG_INFO(LABEL, "error code is %{public}d", errCode); } @@ -828,8 +832,9 @@ napi_value NapiAtManager::RegisterPermStateChangeCallback(napi_env env, napi_cal return WrapVoidToJS(env); } -void NapiAtManager::ParseInputToUnregister(const napi_env env, const size_t &argc, const napi_value (&argv)[ARGS_SIZE_FOUR], std::string &type, - napi_ref &callback, std::vector& tokenIDs, std::vector& permList) +void NapiAtManager::ParseInputToUnregister(const napi_env env, const size_t &argc, + const napi_value (&argv)[ARGS_SIZE_FOUR], std::string &type, napi_ref &callback, + std::vector& tokenIDs, std::vector& permList) { napi_valuetype valueType = napi_undefined; ACCESSTOKEN_LOG_DEBUG(LABEL, "ParseInputToUnregister begin."); @@ -904,17 +909,20 @@ void NapiAtManager::UnregisterPermStateChangeCompletedCB(napi_env env, napi_stat if (subscribers != g_PermStateChangeRegisters.end()) { auto it = subscribers->second.begin(); while (it != subscribers->second.end()) { - ACCESSTOKEN_LOG_DEBUG(LABEL, "erase before g_PermStateChangeRegisters.second size = %{public}zu", subscribers->second.size()); + ACCESSTOKEN_LOG_DEBUG(LABEL, "erase before g_PermStateChangeRegisters.second size = %{public}zu", + subscribers->second.size()); if (CompareScopeInfo((*it)->scopeInfo, tokenIDs, permList)) { napi_delete_reference(env, (*it)->callbackRef); - ACCESSTOKEN_LOG_DEBUG(LABEL, "Find subscribers in map, (*it)->scopeInfo.tokenId = %{public}d", (*it)->scopeInfo.tokenIDs[0]); + ACCESSTOKEN_LOG_DEBUG(LABEL, "Find subscribers in map, tokenId = %{public}d", + (*it)->scopeInfo.tokenIDs[0]); it = subscribers->second.erase(it); break; } else { ++it; } } - ACCESSTOKEN_LOG_DEBUG(LABEL, "erase after g_PermStateChangeRegisters.second size = %{public}zu", subscribers->second.size()); + ACCESSTOKEN_LOG_DEBUG(LABEL, "erase after g_PermStateChangeRegisters.second size = %{public}zu", + subscribers->second.size()); if (subscribers->second.empty()) { ACCESSTOKEN_LOG_DEBUG(LABEL, "No subscriberInfo in the vector, erase the map."); g_PermStateChangeRegisters.erase(subscribers); @@ -938,7 +946,7 @@ napi_value NapiAtManager::UnregisterPermStateChangeCallback(napi_env env, napi_c std::vector permList; ParseInputToUnregister(env, argc, argv, type, callback, tokenIDs, permList); - UnregisterPermStateChangeInfo *unregisterPermStateChangeInfo = + UnregisterPermStateChangeInfo *unregisterPermStateChangeInfo = new (std::nothrow) UnregisterPermStateChangeInfo(); if (unregisterPermStateChangeInfo == nullptr) { ACCESSTOKEN_LOG_DEBUG(LABEL, "insufficient memory for subscribeCBInfo!"); @@ -976,7 +984,7 @@ napi_value NapiAtManager::UnregisterPermStateChangeCallback(napi_env env, napi_c return WrapVoidToJS(env); } -void NapiAtManager::FindRegisterInMap(std::shared_ptr &subscriber, +void NapiAtManager::FindRegisterInMap(std::shared_ptr &subscriber, UnregisterPermStateChangeInfo *unregisterPermStateChangeInfo, bool &isFind) { ACCESSTOKEN_LOG_DEBUG(LABEL, "FindRegisterInMap begin."); -- Gitee From 8171694c3f329bd18af1fe66767eb52729ef4910 Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Mon, 8 Aug 2022 16:29:09 +0800 Subject: [PATCH 5/6] =?UTF-8?q?2022/08/08=20=E6=9D=83=E9=99=90=E6=8E=88?= =?UTF-8?q?=E6=9D=83=E7=8A=B6=E6=80=81=E7=9B=91=E5=90=ACnapi=20Signed-off-?= =?UTF-8?q?by:hanshu5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhhs9527 --- interfaces/kits/accesstoken/napi/include/napi_atmanager.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/interfaces/kits/accesstoken/napi/include/napi_atmanager.h b/interfaces/kits/accesstoken/napi/include/napi_atmanager.h index d2585cf7c..07352e091 100644 --- a/interfaces/kits/accesstoken/napi/include/napi_atmanager.h +++ b/interfaces/kits/accesstoken/napi/include/napi_atmanager.h @@ -52,15 +52,15 @@ enum PermStateChangeType { static thread_local napi_ref atManagerRef_; const std::string ATMANAGER_CLASS_NAME = "atManager"; class RegisterPermStateChangeScopePtr : public PermStateChangeCallbackCustomize { -private: - napi_env env_ = nullptr; - napi_ref ref_ = nullptr; public: explicit RegisterPermStateChangeScopePtr(const PermStateChangeScope &subscribeInfo); ~RegisterPermStateChangeScopePtr(); void PermStateChangeCallback(PermStateChangeInfo& result); void SetEnv(const napi_env &env); void SetCallbackRef(const napi_ref &ref); +private: + napi_env env_ = nullptr; + napi_ref ref_ = nullptr; }; struct RegisterPermStateChangeWorker { -- Gitee From fb87bd7585d324a861b25184214e4c3e2577249c Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Mon, 8 Aug 2022 17:25:38 +0800 Subject: [PATCH 6/6] =?UTF-8?q?2022/08/08=20=E6=9D=83=E9=99=90=E6=8E=88?= =?UTF-8?q?=E6=9D=83=E7=8A=B6=E6=80=81=E7=9B=91=E5=90=ACnapi=20Signed-off-?= =?UTF-8?q?by:hanshu5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhhs9527 --- interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp | 7 ------- 1 file changed, 7 deletions(-) diff --git a/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp b/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp index 44ac78788..a9add93e1 100644 --- a/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp +++ b/interfaces/kits/accesstoken/napi/src/napi_atmanager.cpp @@ -887,7 +887,6 @@ void NapiAtManager::UnregisterPermStateChangeCompletedCB(napi_env env, napi_stat napi_get_undefined(env, &undefined); napi_value resultout = nullptr; napi_value callback = nullptr; - napi_get_reference_value(env, unregisterPermStateChangeInfo->callbackRef, &callback); results[PARAM0] = result; NAPI_CALL_RETURN_VOID(env, @@ -897,9 +896,7 @@ void NapiAtManager::UnregisterPermStateChangeCompletedCB(napi_env env, napi_stat napi_delete_reference(env, unregisterPermStateChangeInfo->callbackRef); } napi_delete_async_work(env, unregisterPermStateChangeInfo->work); - // erase the info from map { - ACCESSTOKEN_LOG_DEBUG(LABEL, "erase the info from map"); std::vector tokenIDs = unregisterPermStateChangeInfo->scopeInfo.tokenIDs; std::vector permList = unregisterPermStateChangeInfo->scopeInfo.permList; std::sort(tokenIDs.begin(), tokenIDs.end()); @@ -909,8 +906,6 @@ void NapiAtManager::UnregisterPermStateChangeCompletedCB(napi_env env, napi_stat if (subscribers != g_PermStateChangeRegisters.end()) { auto it = subscribers->second.begin(); while (it != subscribers->second.end()) { - ACCESSTOKEN_LOG_DEBUG(LABEL, "erase before g_PermStateChangeRegisters.second size = %{public}zu", - subscribers->second.size()); if (CompareScopeInfo((*it)->scopeInfo, tokenIDs, permList)) { napi_delete_reference(env, (*it)->callbackRef); ACCESSTOKEN_LOG_DEBUG(LABEL, "Find subscribers in map, tokenId = %{public}d", @@ -921,8 +916,6 @@ void NapiAtManager::UnregisterPermStateChangeCompletedCB(napi_env env, napi_stat ++it; } } - ACCESSTOKEN_LOG_DEBUG(LABEL, "erase after g_PermStateChangeRegisters.second size = %{public}zu", - subscribers->second.size()); if (subscribers->second.empty()) { ACCESSTOKEN_LOG_DEBUG(LABEL, "No subscriberInfo in the vector, erase the map."); g_PermStateChangeRegisters.erase(subscribers); -- Gitee