From 5cc2a310dfcb56bd73fa16c5996c3b3eef61ee89 Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Tue, 23 Aug 2022 17:03:39 +0800 Subject: [PATCH 01/10] =?UTF-8?q?2022/08/23=20=E6=9D=83=E9=99=90=E4=BD=BF?= =?UTF-8?q?=E7=94=A8=E7=9B=91=E5=90=ACnapi=20Signed-off-by:hanshu5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhhs9527 --- interfaces/kits/common/include/napi_common.h | 1 + .../napi/include/napi_context_common.h | 39 +++ .../kits/privacy/napi/include/native_module.h | 2 +- .../include/permission_record_manager_napi.h | 12 +- .../privacy/napi/src/napi_context_common.cpp | 109 +++++++ .../kits/privacy/napi/src/native_module.cpp | 20 +- .../src/permission_record_manager_napi.cpp | 291 +++++++++++++++++- 7 files changed, 470 insertions(+), 4 deletions(-) diff --git a/interfaces/kits/common/include/napi_common.h b/interfaces/kits/common/include/napi_common.h index 22c776293..d08f4e1b0 100644 --- a/interfaces/kits/common/include/napi_common.h +++ b/interfaces/kits/common/include/napi_common.h @@ -22,6 +22,7 @@ namespace OHOS { namespace Security { namespace AccessToken { +const int ARGS_ONE = 1; const int ARGS_TWO = 2; const int ARGS_THREE = 3; const int ARGS_FIVE = 5; diff --git a/interfaces/kits/privacy/napi/include/napi_context_common.h b/interfaces/kits/privacy/napi/include/napi_context_common.h index 2cf08dbf8..ba46366c4 100644 --- a/interfaces/kits/privacy/napi/include/napi_context_common.h +++ b/interfaces/kits/privacy/napi/include/napi_context_common.h @@ -15,8 +15,13 @@ #ifndef INTERFACES_PRIVACY_KITS_NAPI_CONTEXT_COMMON_H #define INTERFACES_PRIVACY_KITS_NAPI_CONTEXT_COMMON_H +#include +#include "accesstoken_log.h" +#include "active_change_response_info.h" #include "napi/native_api.h" #include "napi/native_node_api.h" +#include "napi_common.h" +#include "perm_active_status_customized_cbk.h" namespace OHOS { namespace Security { @@ -30,6 +35,40 @@ struct PrivacyAsyncWorkData { napi_deferred deferred = nullptr; napi_ref callbackRef = nullptr; }; + +class PermActiveStatusPtr : public PermActiveStatusCustomizedCbk { +public: + explicit PermActiveStatusPtr(const std::vector& permList); + ~PermActiveStatusPtr(); + void ActiveStatusChangeCallback(ActiveChangeResponse& result) override; + void SetEnv(const napi_env& env); + void SetCallbackRef(const napi_ref& ref); +private: + napi_env env_ = nullptr; + napi_ref ref_ = nullptr; +}; + +struct PermActiveStatusWorker { + napi_env env = nullptr; + napi_ref ref = nullptr; + ActiveChangeResponse result; + PermActiveStatusPtr* subscriber = nullptr; // this +}; + +struct PermActiveChangeContext { + virtual ~PermActiveChangeContext(); + + napi_env env = nullptr; + napi_async_work work = nullptr; + napi_ref callbackRef = nullptr; + int32_t errCode = RET_FAILED; + std::string type; + std::shared_ptr subscriber = nullptr; +}; + +void UvQueueWorkActiveStatusChange(uv_work_t* work, int status); +bool ConvertActiveChangeResponse(napi_env env, napi_value value, const ActiveChangeResponse& result); + } // namespace AccessToken } // namespace Security } // namespace OHOS diff --git a/interfaces/kits/privacy/napi/include/native_module.h b/interfaces/kits/privacy/napi/include/native_module.h index 0e6d833bc..966e130c2 100644 --- a/interfaces/kits/privacy/napi/include/native_module.h +++ b/interfaces/kits/privacy/napi/include/native_module.h @@ -19,7 +19,7 @@ #include #include #include - +#include "napi_context_common.h" #include "napi/native_api.h" #include "napi/native_node_api.h" diff --git a/interfaces/kits/privacy/napi/include/permission_record_manager_napi.h b/interfaces/kits/privacy/napi/include/permission_record_manager_napi.h index fbe729de1..ee43d00a3 100644 --- a/interfaces/kits/privacy/napi/include/permission_record_manager_napi.h +++ b/interfaces/kits/privacy/napi/include/permission_record_manager_napi.h @@ -16,12 +16,13 @@ #define INTERFACES_KITS_PERMISSION_USED_MANAGER_NAPI_H #include +#include #include "access_token.h" +#include "active_change_response_info.h" #include "napi/native_api.h" #include "napi/native_node_api.h" #include "napi_context_common.h" -#include "napi_common.h" #include "permission_used_request.h" #include "permission_used_result.h" @@ -40,10 +41,19 @@ struct RecordManagerAsyncContext : public PrivacyAsyncWorkData { int32_t retCode = -1; }; +struct RegisterPermActiveChangeContext : public PermActiveChangeContext { +}; + +struct UnregisterPermActiveChangeContext : public PermActiveChangeContext { + ~UnregisterPermActiveChangeContext(); + std::vector permList; +}; napi_value AddPermissionUsedRecord(napi_env env, napi_callback_info cbinfo); napi_value StartUsingPermission(napi_env env, napi_callback_info cbinfo); napi_value StopUsingPermission(napi_env env, napi_callback_info cbinfo); napi_value GetPermissionUsedRecords(napi_env env, napi_callback_info cbinfo); +napi_value RegisterPermActiveChangeCallback(napi_env env, napi_callback_info cbInfo); +napi_value UnregisterPermActiveChangeCallback(napi_env env, napi_callback_info cbInfo); } // namespace AccessToken } // namespace Security } // namespace OHOS diff --git a/interfaces/kits/privacy/napi/src/napi_context_common.cpp b/interfaces/kits/privacy/napi/src/napi_context_common.cpp index b36467c88..972ee7501 100644 --- a/interfaces/kits/privacy/napi/src/napi_context_common.cpp +++ b/interfaces/kits/privacy/napi/src/napi_context_common.cpp @@ -17,6 +17,9 @@ namespace OHOS { namespace Security { namespace AccessToken { +namespace { +static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_PRIVACY, "PrivacyContextCommonNapi"}; +} PrivacyAsyncWorkData::PrivacyAsyncWorkData(napi_env envValue) { env = envValue; @@ -34,6 +37,112 @@ PrivacyAsyncWorkData::~PrivacyAsyncWorkData() asyncWork = nullptr; } } + +PermActiveChangeContext::~PermActiveChangeContext() +{ + if (callbackRef != nullptr) { + napi_delete_reference(env, callbackRef); + callbackRef = nullptr; + } +} + +PermActiveStatusPtr::PermActiveStatusPtr(const std::vector& permList) + : PermActiveStatusCustomizedCbk(permList) +{} + +PermActiveStatusPtr::~PermActiveStatusPtr() +{} + +void PermActiveStatusPtr::SetEnv(const napi_env& env) +{ + env_ = env; +} + +void PermActiveStatusPtr::SetCallbackRef(const napi_ref& ref) +{ + ref_ = ref; +} + +void PermActiveStatusPtr::ActiveStatusChangeCallback(ActiveChangeResponse& result) +{ + uv_loop_s* loop = nullptr; + NAPI_CALL_RETURN_VOID(env_, napi_get_uv_event_loop(env_, &loop)); + if (loop == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "loop instance is nullptr"); + return; + } + uv_work_t* work = new (std::nothrow) uv_work_t; + if (work == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "insufficient memory for work!"); + return; + } + std::unique_ptr uvWorkPtr {work}; + PermActiveStatusWorker* permActiveStatusWorker = new (std::nothrow) PermActiveStatusWorker(); + if (permActiveStatusWorker == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "insufficient memory for RegisterPermStateChangeWorker!"); + return; + } + std::unique_ptr workPtr {permActiveStatusWorker}; + permActiveStatusWorker->env = env_; + permActiveStatusWorker->ref = ref_; + permActiveStatusWorker->result = result; + ACCESSTOKEN_LOG_DEBUG(LABEL, + "result: tokenID = %{public}d, permissionName = %{public}s, deviceId = %{public}s, type = %{public}d", + result.tokenID, result.permissionName.c_str(), result.deviceId.c_str(), result.type); + permActiveStatusWorker->subscriber = this; + work->data = reinterpret_cast(permActiveStatusWorker); + NAPI_CALL_RETURN_VOID(env_, + uv_queue_work(loop, work, [](uv_work_t* work) {}, UvQueueWorkActiveStatusChange)); + uvWorkPtr.release(); + workPtr.release(); +} + +void UvQueueWorkActiveStatusChange(uv_work_t* work, int status) +{ + if (work == nullptr || work->data == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "work == nullptr || work->data == nullptr"); + return; + } + std::unique_ptr uvWorkPtr {work}; + PermActiveStatusWorker* permActiveStatusData = reinterpret_cast(work->data); + std::unique_ptr workPtr {permActiveStatusData}; + napi_value result[ARGS_ONE] = {nullptr}; + NAPI_CALL_RETURN_VOID(permActiveStatusData->env, + napi_create_array(permActiveStatusData->env, &result[PARAM0])); + if (!ConvertActiveChangeResponse(permActiveStatusData->env, result[PARAM0], permActiveStatusData->result)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "ConvertActiveChangeResponse failed"); + return; + } + napi_value undefined = nullptr; + napi_value callback = nullptr; + napi_value resultout = nullptr; + NAPI_CALL_RETURN_VOID(permActiveStatusData->env, + napi_get_undefined(permActiveStatusData->env, &undefined)); + NAPI_CALL_RETURN_VOID(permActiveStatusData->env, + napi_get_reference_value(permActiveStatusData->env, permActiveStatusData->ref, &callback)); + NAPI_CALL_RETURN_VOID(permActiveStatusData->env, + napi_call_function(permActiveStatusData->env, undefined, callback, ARGS_ONE, &result[PARAM0], &resultout)); + ACCESSTOKEN_LOG_DEBUG(LABEL, "UvQueueWorkActiveStatusChange end"); +} + +bool ConvertActiveChangeResponse(napi_env env, napi_value value, const ActiveChangeResponse& result) +{ + napi_value element; + NAPI_CALL_BASE(env, napi_create_uint32(env, result.tokenID, &element), false); + NAPI_CALL_BASE(env, napi_set_named_property(env, value, "tokenId", element), false); + element = nullptr; + NAPI_CALL_BASE(env, napi_create_string_utf8(env, result.permissionName.c_str(), + NAPI_AUTO_LENGTH, &element), false); + NAPI_CALL_BASE(env, napi_set_named_property(env, value, "permissionName", element), false); + element = nullptr; + NAPI_CALL_BASE(env, napi_create_string_utf8(env, result.deviceId.c_str(), + NAPI_AUTO_LENGTH, &element), false); + NAPI_CALL_BASE(env, napi_set_named_property(env, value, "deviceId", element), false); + element = nullptr; + NAPI_CALL_BASE(env, napi_create_int32(env, result.type, &element), false); + NAPI_CALL_BASE(env, napi_set_named_property(env, value, "activeStatus", element), false); + return true; +} } // namespace AccessToken } // namespace Security } // namespace OHOS \ No newline at end of file diff --git a/interfaces/kits/privacy/napi/src/native_module.cpp b/interfaces/kits/privacy/napi/src/native_module.cpp index a5f2e7d70..3d9a3426c 100644 --- a/interfaces/kits/privacy/napi/src/native_module.cpp +++ b/interfaces/kits/privacy/napi/src/native_module.cpp @@ -29,7 +29,9 @@ static napi_value Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("addPermissionUsedRecord", AddPermissionUsedRecord), DECLARE_NAPI_FUNCTION("startUsingPermission", StartUsingPermission), DECLARE_NAPI_FUNCTION("stopUsingPermission", StopUsingPermission), - DECLARE_NAPI_FUNCTION("getPermissionUsedRecords", GetPermissionUsedRecords) + DECLARE_NAPI_FUNCTION("getPermissionUsedRecords", GetPermissionUsedRecords), + DECLARE_NAPI_FUNCTION("on", RegisterPermActiveChangeCallback), + DECLARE_NAPI_FUNCTION("off", UnregisterPermActiveChangeCallback) }; napi_define_properties(env, exports, sizeof(descriptor) / sizeof(descriptor[0]), descriptor); @@ -45,8 +47,24 @@ static napi_value Init(napi_env env, napi_value exports) napi_create_int32(env, FLAG_PERMISSION_USAGE_DETAIL, &prop); napi_set_named_property(env, permissionUsageFlag, "FLAG_PERMISSION_USAGE_DETAIL", prop); + napi_value permActiveStatus = nullptr; + napi_create_object(env, &permActiveStatus); // create enmu permActiveStatus + + prop = nullptr; + napi_create_int32(env, PERM_INACTIVE, &prop); + napi_set_named_property(env, permActiveStatus, "PERM_INACTIVE", prop); + + prop = nullptr; + napi_create_int32(env, PERM_ACTIVE_IN_FOREGROUND, &prop); + napi_set_named_property(env, permActiveStatus, "PERM_ACTIVE_IN_FOREGROUND", prop); + + prop = nullptr; + napi_create_int32(env, PERM_ACTIVE_IN_BACKGROUND, &prop); + napi_set_named_property(env, permActiveStatus, "PERM_ACTIVE_IN_BACKGROUND", prop); + napi_property_descriptor exportFuncs[] = { DECLARE_NAPI_PROPERTY("PermissionUsageFlag ", permissionUsageFlag), + DECLARE_NAPI_PROPERTY("PermActiveStatus ", permActiveStatus) }; napi_define_properties(env, exports, sizeof(exportFuncs) / sizeof(exportFuncs[0]), exportFuncs); diff --git a/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp b/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp index 7798f1e7b..83e23069a 100644 --- a/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp +++ b/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp @@ -13,7 +13,7 @@ * limitations under the License. */ #include "permission_record_manager_napi.h" - +#include #include "privacy_kit.h" #include "accesstoken_log.h" #include "napi_context_common.h" @@ -24,6 +24,8 @@ namespace OHOS { namespace Security { namespace AccessToken { +std::mutex g_lockForPermActiveChangeSubscribers; +std::vector g_permActiveChangeSubscribers; namespace { static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_PRIVACY, "PermissionRecordManagerNapi"}; } // namespace @@ -548,6 +550,293 @@ napi_value GetPermissionUsedRecords(napi_env env, napi_callback_info cbinfo) callbackPtr.release(); return result; } + +UnregisterPermActiveChangeContext::~UnregisterPermActiveChangeContext() +{ + if (work != nullptr) { + napi_delete_async_work(env, work); + work = nullptr; + } +} + +static bool ParseInputToRegister(const napi_env env, const napi_callback_info cbInfo, + RegisterPermActiveChangeContext& registerPermActiveChangeContext) +{ + size_t argc = ARGS_THREE; + napi_value argv[ARGS_THREE] = {nullptr}; + napi_value thisVar = nullptr; + napi_ref callback = nullptr; + if (napi_get_cb_info(env, cbInfo, &argc, argv, &thisVar, NULL) != napi_ok) { + ACCESSTOKEN_LOG_ERROR(LABEL, "napi_get_cb_info failed"); + return false; + } + std::string type = ParseString(env, argv[PARAM0]); + std::vector permList = ParseStringArray(env, argv[PARAM1]); + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM2], &valueType); // get PRARM[2] callback + if (valueType == napi_function) { + if (napi_create_reference(env, argv[PARAM2], 1, &callback) != napi_ok) { + ACCESSTOKEN_LOG_ERROR(LABEL, "napi_create_reference failed"); + return false; + } + } else { + ACCESSTOKEN_LOG_ERROR(LABEL, "argv[PARAM2] callback matching failed"); + return false; + } + registerPermActiveChangeContext.env = env; + registerPermActiveChangeContext.work = nullptr; + registerPermActiveChangeContext.callbackRef = callback; + registerPermActiveChangeContext.type = type; + registerPermActiveChangeContext.subscriber = std::make_shared(permList); + return true; +} + +static bool ParseInputToUnregister(const napi_env env, const napi_callback_info cbInfo, + UnregisterPermActiveChangeContext& unregisterPermActiveChangeContext) +{ + size_t argc = ARGS_THREE; + napi_value argv[ARGS_THREE] = {nullptr}; + napi_value thisVar = nullptr; + napi_ref callback = nullptr; + if (napi_get_cb_info(env, cbInfo, &argc, argv, &thisVar, NULL) != napi_ok) { + ACCESSTOKEN_LOG_ERROR(LABEL, "napi_get_cb_info failed"); + return false; + } + std::string type = ParseString(env, argv[PARAM0]); + std::vector permList = ParseStringArray(env, argv[PARAM1]); + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[PARAM2], &valueType); // get PRARM[2] callback + if (argc >= ARGS_THREE) { + if (valueType == napi_function) { + if (napi_create_reference(env, argv[PARAM2], 1, &callback) != napi_ok) { + ACCESSTOKEN_LOG_ERROR(LABEL, "napi_create_reference failed"); + return false; + } + } else { + ACCESSTOKEN_LOG_ERROR(LABEL, "argv[PARAM2] callback matching failed"); + return false; + } + } + unregisterPermActiveChangeContext.env = env; + unregisterPermActiveChangeContext.work = nullptr; + unregisterPermActiveChangeContext.callbackRef = callback; + unregisterPermActiveChangeContext.type = type; + unregisterPermActiveChangeContext.permList = permList; + return true; +} + +static bool IsExistRegister(const PermActiveChangeContext* permActiveChangeContext) +{ + std::vector targetPermList; + permActiveChangeContext->subscriber->GetPermList(targetPermList); + std::sort(targetPermList.begin(), targetPermList.end()); + std::lock_guard lock(g_lockForPermActiveChangeSubscribers); + for (const auto& item : g_permActiveChangeSubscribers) { + std::vector permList; + item->subscriber->GetPermList(permList); + std::sort(permList.begin(), permList.end()); + if (permList == targetPermList) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "find subscriber in map"); + return true; + } + } + ACCESSTOKEN_LOG_ERROR(LABEL, "cannot find subscriber in map"); + return false; +} + +static void DeleteRegisterInVector(PermActiveChangeContext* permActiveChangeContext) +{ + std::vector targetPermList; + permActiveChangeContext->subscriber->GetPermList(targetPermList); + std::sort(targetPermList.begin(), targetPermList.end()); + std::lock_guard lock(g_lockForPermActiveChangeSubscribers); + auto item = g_permActiveChangeSubscribers.begin(); + while (item != g_permActiveChangeSubscribers.end()) { + std::vector permList; + (*item)->subscriber->GetPermList(permList); + std::sort(permList.begin(), permList.end()); + if (permList == targetPermList) { + delete *item; + *item = nullptr; + g_permActiveChangeSubscribers.erase(item); + ACCESSTOKEN_LOG_DEBUG(LABEL, "delete permActiveChangeContext"); + return; + } else { + ++item; + } + } +} + +static bool FindAndGetSubscriber(UnregisterPermActiveChangeContext* unregisterPermActiveChangeContext) +{ + std::vector targetPermList = unregisterPermActiveChangeContext->permList; + std::sort(targetPermList.begin(), targetPermList.end()); + std::lock_guard lock(g_lockForPermActiveChangeSubscribers); + for (const auto& item : g_permActiveChangeSubscribers) { + std::vector permList; + item->subscriber->GetPermList(permList); + std::sort(permList.begin(), permList.end()); + if (permList == targetPermList) { + unregisterPermActiveChangeContext->subscriber = item->subscriber; + ACCESSTOKEN_LOG_DEBUG(LABEL, "find and get subscriber in map"); + return true; + } + } + ACCESSTOKEN_LOG_ERROR(LABEL, "cannot find and get subscriber in map"); + return false; +} + +static void RegisterPermActiveChangeExecute(napi_env env, void* data) +{ + if (data == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "data is null"); + return; + } + RegisterPermActiveChangeContext* registerPermActiveChangeContext = + reinterpret_cast(data); + (*registerPermActiveChangeContext->subscriber).SetEnv(env); + (*registerPermActiveChangeContext->subscriber).SetCallbackRef(registerPermActiveChangeContext->callbackRef); + registerPermActiveChangeContext->errCode = + PrivacyKit::RegisterPermActiveStatusCallback(registerPermActiveChangeContext->subscriber); +} + +static void RegisterPermActiveChangeComplete(napi_env env, napi_status status, void *data) +{ + if (data == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "data is null"); + return; + } + RegisterPermActiveChangeContext* registerPermActiveChangeContext = + reinterpret_cast(data); + if (registerPermActiveChangeContext->errCode != RET_SUCCESS) { + ACCESSTOKEN_LOG_ERROR(LABEL, "errCode = %{public}d, delete register in map", + registerPermActiveChangeContext->errCode); + // Even if napi_delete_async_work failed, invalid registerPermActiveChangeContext needs to be deleted + napi_delete_async_work(env, registerPermActiveChangeContext->work); + registerPermActiveChangeContext->work = nullptr; + DeleteRegisterInVector(registerPermActiveChangeContext); + return; + } + NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, registerPermActiveChangeContext->work)); + registerPermActiveChangeContext->work = nullptr; +} + +napi_value RegisterPermActiveChangeCallback(napi_env env, napi_callback_info cbInfo) +{ + RegisterPermActiveChangeContext* registerPermActiveChangeContext = new (std::nothrow) RegisterPermActiveChangeContext(); + if (registerPermActiveChangeContext == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "insufficient memory for subscribeCBInfo!"); + return nullptr; + } + std::unique_ptr callbackPtr {registerPermActiveChangeContext}; + if (!ParseInputToRegister(env, cbInfo, *registerPermActiveChangeContext)) { + return nullptr; + } + if (IsExistRegister(registerPermActiveChangeContext)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Subscribe failed. The current subscriber has been existed"); + return nullptr; + } + { + // add to vector + std::lock_guard lock(g_lockForPermActiveChangeSubscribers); + g_permActiveChangeSubscribers.emplace_back(registerPermActiveChangeContext); + ACCESSTOKEN_LOG_DEBUG(LABEL, + "add g_permActiveChangeSubscribers.size = %{public}zu, registerPermActiveChangeContext = %{public}p", + g_permActiveChangeSubscribers.size(), registerPermActiveChangeContext); + } + napi_value resource = nullptr; + if (napi_create_string_utf8(env, "RegisterPermActiveChangeCallback", NAPI_AUTO_LENGTH, &resource) != napi_ok) { + DeleteRegisterInVector(registerPermActiveChangeContext); + return nullptr; + } + if (napi_create_async_work(env, + nullptr, + resource, + RegisterPermActiveChangeExecute, + RegisterPermActiveChangeComplete, + reinterpret_cast(registerPermActiveChangeContext), + ®isterPermActiveChangeContext->work) != napi_ok) { + DeleteRegisterInVector(registerPermActiveChangeContext); + return nullptr; + } + if (napi_queue_async_work(env, registerPermActiveChangeContext->work) != napi_ok) { + DeleteRegisterInVector(registerPermActiveChangeContext); + return nullptr; + } + callbackPtr.release(); + return nullptr; +} + +static void UnregisterPermActiveChangeExecute(napi_env env, void* data) +{ + if (data == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "data is null"); + return; + } + UnregisterPermActiveChangeContext* unregisterPermActiveChangeContext = + reinterpret_cast(data); + unregisterPermActiveChangeContext->errCode = + PrivacyKit::UnRegisterPermActiveStatusCallback(unregisterPermActiveChangeContext->subscriber); +} + +static void UnregisterPermActiveChangeCompleted(napi_env env, napi_status status, void *data) +{ + if (data == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "data is null"); + return; + } + UnregisterPermActiveChangeContext* unregisterPermActiveChangeContext = + reinterpret_cast(data); + std::unique_ptr callbackPtr {unregisterPermActiveChangeContext}; + if (unregisterPermActiveChangeContext->callbackRef != nullptr) { + napi_value results[ARGS_ONE] = {nullptr}; + NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &results[PARAM0])); + napi_value undefined; + NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined)); + napi_value resultout = nullptr; + napi_value callback = nullptr; + NAPI_CALL_RETURN_VOID(env, + napi_get_reference_value(env, unregisterPermActiveChangeContext->callbackRef, &callback)); + NAPI_CALL_RETURN_VOID(env, + napi_call_function(env, undefined, callback, ARGS_ONE, &results[PARAM0], &resultout)); + } + if (unregisterPermActiveChangeContext->errCode == RET_SUCCESS) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "ret = %{public}d", unregisterPermActiveChangeContext->errCode); + DeleteRegisterInVector(unregisterPermActiveChangeContext); + } else { + ACCESSTOKEN_LOG_ERROR(LABEL, "errCode = %{public}d", unregisterPermActiveChangeContext->errCode); + } +} + +napi_value UnregisterPermActiveChangeCallback(napi_env env, napi_callback_info cbInfo) +{ + UnregisterPermActiveChangeContext* unregisterPermActiveChangeContext = new (std::nothrow) UnregisterPermActiveChangeContext(); + if (unregisterPermActiveChangeContext == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "insufficient memory for subscribeCBInfo!"); + return nullptr; + } + std::unique_ptr callbackPtr {unregisterPermActiveChangeContext}; + if (!ParseInputToUnregister(env, cbInfo, *unregisterPermActiveChangeContext)) { + return nullptr; + } + if (!FindAndGetSubscriber(unregisterPermActiveChangeContext)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Unsubscribe failed. The current subscriber does not exist"); + return nullptr; + } + ACCESSTOKEN_LOG_ERROR(LABEL, "The current subscriber exist"); + napi_value resource = nullptr; + NAPI_CALL(env, napi_create_string_utf8(env, "UnregisterPermActiveChangeCallback", NAPI_AUTO_LENGTH, &resource)); + NAPI_CALL(env, napi_create_async_work(env, + nullptr, + resource, + UnregisterPermActiveChangeExecute, + UnregisterPermActiveChangeCompleted, + reinterpret_cast(unregisterPermActiveChangeContext), + &(unregisterPermActiveChangeContext->work))); + NAPI_CALL(env, napi_queue_async_work(env, unregisterPermActiveChangeContext->work)); + callbackPtr.release(); + return nullptr; +} } // namespace AccessToken } // namespace Security } // namespace OHOS \ No newline at end of file -- Gitee From 930eb3662a3e3ab4d75f762f355fcef7bc6d9466 Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Wed, 24 Aug 2022 16:06:07 +0800 Subject: [PATCH 02/10] =?UTF-8?q?2022/08/04=20=E6=9D=83=E9=99=90=E4=BD=BF?= =?UTF-8?q?=E7=94=A8=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 --- .../napi/include/napi_context_common.h | 1 - .../src/permission_record_manager_napi.cpp | 23 +++++++++++++++---- 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/interfaces/kits/privacy/napi/include/napi_context_common.h b/interfaces/kits/privacy/napi/include/napi_context_common.h index ba46366c4..58db8fbe6 100644 --- a/interfaces/kits/privacy/napi/include/napi_context_common.h +++ b/interfaces/kits/privacy/napi/include/napi_context_common.h @@ -68,7 +68,6 @@ struct PermActiveChangeContext { void UvQueueWorkActiveStatusChange(uv_work_t* work, int status); bool ConvertActiveChangeResponse(napi_env env, napi_value value, const ActiveChangeResponse& result); - } // namespace AccessToken } // namespace Security } // namespace OHOS diff --git a/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp b/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp index 83e23069a..239fc7186 100644 --- a/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp +++ b/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp @@ -26,6 +26,7 @@ namespace Security { namespace AccessToken { std::mutex g_lockForPermActiveChangeSubscribers; std::vector g_permActiveChangeSubscribers; +static const size_t MAX_CALLBACK_SIZE = 200; namespace { static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_PRIVACY, "PermissionRecordManagerNapi"}; } // namespace @@ -573,7 +574,10 @@ static bool ParseInputToRegister(const napi_env env, const napi_callback_info cb std::string type = ParseString(env, argv[PARAM0]); std::vector permList = ParseStringArray(env, argv[PARAM1]); napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[PARAM2], &valueType); // get PRARM[2] callback + if (napi_typeof(env, argv[PARAM2], &valueType) != napi_ok) { + ACCESSTOKEN_LOG_ERROR(LABEL, "get napi type failed"); + return false; + } // get PRARM[2] callback type if (valueType == napi_function) { if (napi_create_reference(env, argv[PARAM2], 1, &callback) != napi_ok) { ACCESSTOKEN_LOG_ERROR(LABEL, "napi_create_reference failed"); @@ -605,7 +609,10 @@ static bool ParseInputToUnregister(const napi_env env, const napi_callback_info std::string type = ParseString(env, argv[PARAM0]); std::vector permList = ParseStringArray(env, argv[PARAM1]); napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[PARAM2], &valueType); // get PRARM[2] callback + if (napi_typeof(env, argv[PARAM2], &valueType) != napi_ok) { + ACCESSTOKEN_LOG_ERROR(LABEL, "get napi type failed"); + return false; + } // get PRARM[2] callback type if (argc >= ARGS_THREE) { if (valueType == napi_function) { if (napi_create_reference(env, argv[PARAM2], 1, &callback) != napi_ok) { @@ -723,7 +730,8 @@ static void RegisterPermActiveChangeComplete(napi_env env, napi_status status, v napi_value RegisterPermActiveChangeCallback(napi_env env, napi_callback_info cbInfo) { - RegisterPermActiveChangeContext* registerPermActiveChangeContext = new (std::nothrow) RegisterPermActiveChangeContext(); + RegisterPermActiveChangeContext* registerPermActiveChangeContext = + new (std::nothrow) RegisterPermActiveChangeContext(); if (registerPermActiveChangeContext == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "insufficient memory for subscribeCBInfo!"); return nullptr; @@ -739,8 +747,12 @@ napi_value RegisterPermActiveChangeCallback(napi_env env, napi_callback_info cbI { // add to vector std::lock_guard lock(g_lockForPermActiveChangeSubscribers); + if (g_permActiveChangeSubscribers.size() >= MAX_CALLBACK_SIZE) { + ACCESSTOKEN_LOG_ERROR(LABEL, "subscribers size has reached max value"); + return nullptr; + } g_permActiveChangeSubscribers.emplace_back(registerPermActiveChangeContext); - ACCESSTOKEN_LOG_DEBUG(LABEL, + ACCESSTOKEN_LOG_DEBUG(LABEL, "add g_permActiveChangeSubscribers.size = %{public}zu, registerPermActiveChangeContext = %{public}p", g_permActiveChangeSubscribers.size(), registerPermActiveChangeContext); } @@ -810,7 +822,8 @@ static void UnregisterPermActiveChangeCompleted(napi_env env, napi_status status napi_value UnregisterPermActiveChangeCallback(napi_env env, napi_callback_info cbInfo) { - UnregisterPermActiveChangeContext* unregisterPermActiveChangeContext = new (std::nothrow) UnregisterPermActiveChangeContext(); + UnregisterPermActiveChangeContext* unregisterPermActiveChangeContext = + new (std::nothrow) UnregisterPermActiveChangeContext(); if (unregisterPermActiveChangeContext == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "insufficient memory for subscribeCBInfo!"); return nullptr; -- Gitee From af717a85f717400dce08015c8137f5e5344cc008 Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Mon, 29 Aug 2022 15:07:46 +0800 Subject: [PATCH 03/10] =?UTF-8?q?2022/08/29=20=E6=9D=83=E9=99=90=E4=BD=BF?= =?UTF-8?q?=E7=94=A8=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 --- .../napi/include/napi_context_common.h | 3 +- .../include/permission_record_manager_napi.h | 5 +- .../privacy/napi/src/napi_context_common.cpp | 32 ++- .../src/permission_record_manager_napi.cpp | 202 +++++------------- 4 files changed, 79 insertions(+), 163 deletions(-) diff --git a/interfaces/kits/privacy/napi/include/napi_context_common.h b/interfaces/kits/privacy/napi/include/napi_context_common.h index 58db8fbe6..af4e2217e 100644 --- a/interfaces/kits/privacy/napi/include/napi_context_common.h +++ b/interfaces/kits/privacy/napi/include/napi_context_common.h @@ -22,6 +22,7 @@ #include "napi/native_node_api.h" #include "napi_common.h" #include "perm_active_status_customized_cbk.h" +#include "privacy_kit.h" namespace OHOS { namespace Security { @@ -59,9 +60,7 @@ struct PermActiveChangeContext { virtual ~PermActiveChangeContext(); napi_env env = nullptr; - napi_async_work work = nullptr; napi_ref callbackRef = nullptr; - int32_t errCode = RET_FAILED; std::string type; std::shared_ptr subscriber = nullptr; }; diff --git a/interfaces/kits/privacy/napi/include/permission_record_manager_napi.h b/interfaces/kits/privacy/napi/include/permission_record_manager_napi.h index ee43d00a3..9a8892033 100644 --- a/interfaces/kits/privacy/napi/include/permission_record_manager_napi.h +++ b/interfaces/kits/privacy/napi/include/permission_record_manager_napi.h @@ -40,12 +40,9 @@ struct RecordManagerAsyncContext : public PrivacyAsyncWorkData { PermissionUsedResult result; int32_t retCode = -1; }; - -struct RegisterPermActiveChangeContext : public PermActiveChangeContext { -}; +typedef PermActiveChangeContext RegisterPermActiveChangeContext; struct UnregisterPermActiveChangeContext : public PermActiveChangeContext { - ~UnregisterPermActiveChangeContext(); std::vector permList; }; napi_value AddPermissionUsedRecord(napi_env env, napi_callback_info cbinfo); diff --git a/interfaces/kits/privacy/napi/src/napi_context_common.cpp b/interfaces/kits/privacy/napi/src/napi_context_common.cpp index 972ee7501..1e128d5f6 100644 --- a/interfaces/kits/privacy/napi/src/napi_context_common.cpp +++ b/interfaces/kits/privacy/napi/src/napi_context_common.cpp @@ -41,6 +41,7 @@ PrivacyAsyncWorkData::~PrivacyAsyncWorkData() PermActiveChangeContext::~PermActiveChangeContext() { if (callbackRef != nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "------~PermActiveChangeContext callback"); napi_delete_reference(env, callbackRef); callbackRef = nullptr; } @@ -65,29 +66,30 @@ void PermActiveStatusPtr::SetCallbackRef(const napi_ref& ref) void PermActiveStatusPtr::ActiveStatusChangeCallback(ActiveChangeResponse& result) { + ACCESSTOKEN_LOG_ERROR(LABEL, "------ActiveStatusChangeCallback begin"); uv_loop_s* loop = nullptr; NAPI_CALL_RETURN_VOID(env_, napi_get_uv_event_loop(env_, &loop)); if (loop == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "loop instance is nullptr"); + ACCESSTOKEN_LOG_ERROR(LABEL, "------loop instance is nullptr"); return; } uv_work_t* work = new (std::nothrow) uv_work_t; if (work == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "insufficient memory for work!"); + ACCESSTOKEN_LOG_ERROR(LABEL, "------insufficient memory for work!"); return; } std::unique_ptr uvWorkPtr {work}; PermActiveStatusWorker* permActiveStatusWorker = new (std::nothrow) PermActiveStatusWorker(); if (permActiveStatusWorker == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "insufficient memory for RegisterPermStateChangeWorker!"); + ACCESSTOKEN_LOG_ERROR(LABEL, "------insufficient memory for RegisterPermStateChangeWorker!"); return; } std::unique_ptr workPtr {permActiveStatusWorker}; permActiveStatusWorker->env = env_; permActiveStatusWorker->ref = ref_; permActiveStatusWorker->result = result; - ACCESSTOKEN_LOG_DEBUG(LABEL, - "result: tokenID = %{public}d, permissionName = %{public}s, deviceId = %{public}s, type = %{public}d", + ACCESSTOKEN_LOG_ERROR(LABEL, + "------result: tokenID = %{public}d, permissionName = %{public}s, deviceId = %{public}s, type = %{public}d", result.tokenID, result.permissionName.c_str(), result.deviceId.c_str(), result.type); permActiveStatusWorker->subscriber = this; work->data = reinterpret_cast(permActiveStatusWorker); @@ -100,7 +102,7 @@ void PermActiveStatusPtr::ActiveStatusChangeCallback(ActiveChangeResponse& resul void UvQueueWorkActiveStatusChange(uv_work_t* work, int status) { if (work == nullptr || work->data == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "work == nullptr || work->data == nullptr"); + ACCESSTOKEN_LOG_ERROR(LABEL, "------work == nullptr || work->data == nullptr"); return; } std::unique_ptr uvWorkPtr {work}; @@ -110,7 +112,7 @@ void UvQueueWorkActiveStatusChange(uv_work_t* work, int status) NAPI_CALL_RETURN_VOID(permActiveStatusData->env, napi_create_array(permActiveStatusData->env, &result[PARAM0])); if (!ConvertActiveChangeResponse(permActiveStatusData->env, result[PARAM0], permActiveStatusData->result)) { - ACCESSTOKEN_LOG_ERROR(LABEL, "ConvertActiveChangeResponse failed"); + ACCESSTOKEN_LOG_ERROR(LABEL, "------ConvertActiveChangeResponse failed"); return; } napi_value undefined = nullptr; @@ -122,24 +124,38 @@ void UvQueueWorkActiveStatusChange(uv_work_t* work, int status) napi_get_reference_value(permActiveStatusData->env, permActiveStatusData->ref, &callback)); NAPI_CALL_RETURN_VOID(permActiveStatusData->env, napi_call_function(permActiveStatusData->env, undefined, callback, ARGS_ONE, &result[PARAM0], &resultout)); - ACCESSTOKEN_LOG_DEBUG(LABEL, "UvQueueWorkActiveStatusChange end"); + ACCESSTOKEN_LOG_ERROR(LABEL, "------UvQueueWorkActiveStatusChange end"); } bool ConvertActiveChangeResponse(napi_env env, napi_value value, const ActiveChangeResponse& result) { + ACCESSTOKEN_LOG_ERROR(LABEL, + "------ConvertActiveChangeResponse : result 1: tokenID = %{public}d, permissionName = %{public}s, deviceId = %{public}s, type = %{public}d", + result.tokenID, result.permissionName.c_str(), result.deviceId.c_str(), result.type); napi_value element; + ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_create_uint32(env, result.tokenID, &element)"); NAPI_CALL_BASE(env, napi_create_uint32(env, result.tokenID, &element), false); + ACCESSTOKEN_LOG_ERROR(LABEL, + "------ConvertActiveChangeResponse : result 2: tokenID = %{public}d, permissionName = %{public}s, deviceId = %{public}s, type = %{public}d", + result.tokenID, result.permissionName.c_str(), result.deviceId.c_str(), result.type); + ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_set_named_property"); NAPI_CALL_BASE(env, napi_set_named_property(env, value, "tokenId", element), false); element = nullptr; + ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_create_string_utf8(env, result.permissionName.c_str()"); NAPI_CALL_BASE(env, napi_create_string_utf8(env, result.permissionName.c_str(), NAPI_AUTO_LENGTH, &element), false); + ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_set_named_property"); NAPI_CALL_BASE(env, napi_set_named_property(env, value, "permissionName", element), false); element = nullptr; + ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_create_string_utf8(env, result.deviceId.c_str()"); NAPI_CALL_BASE(env, napi_create_string_utf8(env, result.deviceId.c_str(), NAPI_AUTO_LENGTH, &element), false); + ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_set_named_property"); NAPI_CALL_BASE(env, napi_set_named_property(env, value, "deviceId", element), false); element = nullptr; + ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_create_int32(env, result.type, &element)"); NAPI_CALL_BASE(env, napi_create_int32(env, result.type, &element), false); + ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_set_named_property"); NAPI_CALL_BASE(env, napi_set_named_property(env, value, "activeStatus", element), false); return true; } diff --git a/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp b/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp index 239fc7186..1394d7f23 100644 --- a/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp +++ b/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp @@ -57,6 +57,7 @@ static void ParseAddPermissionRecord( static void ParseStartAndStopUsingPermission( const napi_env env, const napi_callback_info info, RecordManagerAsyncContext& asyncContext) { + ACCESSTOKEN_LOG_ERROR(LABEL, "------StartUsingPermission begin."); size_t argc = ARGS_THREE; napi_value argv[ARGS_THREE] = { 0 }; napi_value thisVar = nullptr; @@ -66,8 +67,11 @@ static void ParseStartAndStopUsingPermission( asyncContext.env = env; asyncContext.tokenId = ParseUint32(env, argv[PARAM0]); + ACCESSTOKEN_LOG_ERROR(LABEL, "------asyncContext.tokenId = %{public}d", asyncContext.tokenId); asyncContext.permissionName = ParseString(env, argv[PARAM1]); + ACCESSTOKEN_LOG_ERROR(LABEL, "------asyncContext.permissionName = %{public}s", asyncContext.permissionName.c_str()); if (argc == ARGS_THREE) { + ACCESSTOKEN_LOG_ERROR(LABEL, "------parse callback"); napi_valuetype valueType = napi_undefined; NAPI_CALL_RETURN_VOID(env, napi_typeof(env, argv[ARGS_THREE - 1], &valueType)) ; if (valueType == napi_function) { @@ -330,6 +334,7 @@ napi_value AddPermissionUsedRecord(napi_env env, napi_callback_info cbinfo) static void StartUsingPermissionExecute(napi_env env, void* data) { + ACCESSTOKEN_LOG_ERROR(LABEL, "------StartUsingPermission execute."); ACCESSTOKEN_LOG_DEBUG(LABEL, "StartUsingPermission execute."); RecordManagerAsyncContext* asyncContext = reinterpret_cast(data); if (asyncContext == nullptr) { @@ -342,6 +347,7 @@ static void StartUsingPermissionExecute(napi_env env, void* data) static void StartUsingPermissionComplete(napi_env env, napi_status status, void* data) { + ACCESSTOKEN_LOG_ERROR(LABEL, "------StartUsingPermissionComplete execute."); ACCESSTOKEN_LOG_DEBUG(LABEL, "StartUsingPermission complete."); RecordManagerAsyncContext* asyncContext = reinterpret_cast(data); if (asyncContext == nullptr) { @@ -354,8 +360,10 @@ static void StartUsingPermissionComplete(napi_env env, napi_status status, void* NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncContext->retCode, &results[PARAM1])); if (asyncContext->deferred) { + ACCESSTOKEN_LOG_ERROR(LABEL, "------asyncContext->deferred."); NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncContext->deferred, results[PARAM1])); + ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_resolve_deferred end"); } else { napi_value callback = nullptr; napi_value callResult = nullptr; @@ -371,7 +379,7 @@ static void StartUsingPermissionComplete(napi_env env, napi_status status, void* napi_value StartUsingPermission(napi_env env, napi_callback_info cbinfo) { ACCESSTOKEN_LOG_DEBUG(LABEL, "StartUsingPermission begin."); - + ACCESSTOKEN_LOG_ERROR(LABEL, "------StartUsingPermission begin."); auto *asyncContext = new (std::nothrow) RecordManagerAsyncContext(env); if (asyncContext == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "new struct fail."); @@ -552,14 +560,6 @@ napi_value GetPermissionUsedRecords(napi_env env, napi_callback_info cbinfo) return result; } -UnregisterPermActiveChangeContext::~UnregisterPermActiveChangeContext() -{ - if (work != nullptr) { - napi_delete_async_work(env, work); - work = nullptr; - } -} - static bool ParseInputToRegister(const napi_env env, const napi_callback_info cbInfo, RegisterPermActiveChangeContext& registerPermActiveChangeContext) { @@ -573,25 +573,26 @@ static bool ParseInputToRegister(const napi_env env, const napi_callback_info cb } std::string type = ParseString(env, argv[PARAM0]); std::vector permList = ParseStringArray(env, argv[PARAM1]); + std::sort(permList.begin(), permList.end()); napi_valuetype valueType = napi_undefined; if (napi_typeof(env, argv[PARAM2], &valueType) != napi_ok) { ACCESSTOKEN_LOG_ERROR(LABEL, "get napi type failed"); return false; } // get PRARM[2] callback type - if (valueType == napi_function) { - if (napi_create_reference(env, argv[PARAM2], 1, &callback) != napi_ok) { - ACCESSTOKEN_LOG_ERROR(LABEL, "napi_create_reference failed"); - return false; - } - } else { + if (valueType != napi_function) { ACCESSTOKEN_LOG_ERROR(LABEL, "argv[PARAM2] callback matching failed"); return false; } + if (napi_create_reference(env, argv[PARAM2], 1, &callback) != napi_ok) { + ACCESSTOKEN_LOG_ERROR(LABEL, "napi_create_reference failed"); + return false; + } registerPermActiveChangeContext.env = env; - registerPermActiveChangeContext.work = nullptr; registerPermActiveChangeContext.callbackRef = callback; registerPermActiveChangeContext.type = type; registerPermActiveChangeContext.subscriber = std::make_shared(permList); + registerPermActiveChangeContext.subscriber->SetEnv(env); + registerPermActiveChangeContext.subscriber->SetCallbackRef(callback); return true; } @@ -608,24 +609,23 @@ static bool ParseInputToUnregister(const napi_env env, const napi_callback_info } std::string type = ParseString(env, argv[PARAM0]); std::vector permList = ParseStringArray(env, argv[PARAM1]); + std::sort(permList.begin(), permList.end()); napi_valuetype valueType = napi_undefined; - if (napi_typeof(env, argv[PARAM2], &valueType) != napi_ok) { - ACCESSTOKEN_LOG_ERROR(LABEL, "get napi type failed"); - return false; - } // get PRARM[2] callback type if (argc >= ARGS_THREE) { - if (valueType == napi_function) { - if (napi_create_reference(env, argv[PARAM2], 1, &callback) != napi_ok) { - ACCESSTOKEN_LOG_ERROR(LABEL, "napi_create_reference failed"); - return false; - } - } else { + if (napi_typeof(env, argv[PARAM2], &valueType) != napi_ok) { + ACCESSTOKEN_LOG_ERROR(LABEL, "get napi type failed"); + return false; + } // get PRARM[2] callback type + if (valueType != napi_function) { ACCESSTOKEN_LOG_ERROR(LABEL, "argv[PARAM2] callback matching failed"); + return false; + } + if (napi_create_reference(env, argv[PARAM2], 1, &callback) != napi_ok) { + ACCESSTOKEN_LOG_ERROR(LABEL, "napi_create_reference failed"); return false; } } unregisterPermActiveChangeContext.env = env; - unregisterPermActiveChangeContext.work = nullptr; unregisterPermActiveChangeContext.callbackRef = callback; unregisterPermActiveChangeContext.type = type; unregisterPermActiveChangeContext.permList = permList; @@ -636,18 +636,15 @@ static bool IsExistRegister(const PermActiveChangeContext* permActiveChangeConte { std::vector targetPermList; permActiveChangeContext->subscriber->GetPermList(targetPermList); - std::sort(targetPermList.begin(), targetPermList.end()); std::lock_guard lock(g_lockForPermActiveChangeSubscribers); for (const auto& item : g_permActiveChangeSubscribers) { std::vector permList; item->subscriber->GetPermList(permList); - std::sort(permList.begin(), permList.end()); if (permList == targetPermList) { ACCESSTOKEN_LOG_DEBUG(LABEL, "find subscriber in map"); return true; } } - ACCESSTOKEN_LOG_ERROR(LABEL, "cannot find subscriber in map"); return false; } @@ -655,13 +652,11 @@ static void DeleteRegisterInVector(PermActiveChangeContext* permActiveChangeCont { std::vector targetPermList; permActiveChangeContext->subscriber->GetPermList(targetPermList); - std::sort(targetPermList.begin(), targetPermList.end()); std::lock_guard lock(g_lockForPermActiveChangeSubscribers); auto item = g_permActiveChangeSubscribers.begin(); while (item != g_permActiveChangeSubscribers.end()) { std::vector permList; (*item)->subscriber->GetPermList(permList); - std::sort(permList.begin(), permList.end()); if (permList == targetPermList) { delete *item; *item = nullptr; @@ -677,13 +672,12 @@ static void DeleteRegisterInVector(PermActiveChangeContext* permActiveChangeCont static bool FindAndGetSubscriber(UnregisterPermActiveChangeContext* unregisterPermActiveChangeContext) { std::vector targetPermList = unregisterPermActiveChangeContext->permList; - std::sort(targetPermList.begin(), targetPermList.end()); std::lock_guard lock(g_lockForPermActiveChangeSubscribers); for (const auto& item : g_permActiveChangeSubscribers) { std::vector permList; item->subscriber->GetPermList(permList); - std::sort(permList.begin(), permList.end()); if (permList == targetPermList) { + // targetCallback != nullptr, unregister the subscriber with same permList and callback unregisterPermActiveChangeContext->subscriber = item->subscriber; ACCESSTOKEN_LOG_DEBUG(LABEL, "find and get subscriber in map"); return true; @@ -693,45 +687,9 @@ static bool FindAndGetSubscriber(UnregisterPermActiveChangeContext* unregisterPe return false; } -static void RegisterPermActiveChangeExecute(napi_env env, void* data) -{ - if (data == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "data is null"); - return; - } - RegisterPermActiveChangeContext* registerPermActiveChangeContext = - reinterpret_cast(data); - (*registerPermActiveChangeContext->subscriber).SetEnv(env); - (*registerPermActiveChangeContext->subscriber).SetCallbackRef(registerPermActiveChangeContext->callbackRef); - registerPermActiveChangeContext->errCode = - PrivacyKit::RegisterPermActiveStatusCallback(registerPermActiveChangeContext->subscriber); -} - -static void RegisterPermActiveChangeComplete(napi_env env, napi_status status, void *data) -{ - if (data == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "data is null"); - return; - } - RegisterPermActiveChangeContext* registerPermActiveChangeContext = - reinterpret_cast(data); - if (registerPermActiveChangeContext->errCode != RET_SUCCESS) { - ACCESSTOKEN_LOG_ERROR(LABEL, "errCode = %{public}d, delete register in map", - registerPermActiveChangeContext->errCode); - // Even if napi_delete_async_work failed, invalid registerPermActiveChangeContext needs to be deleted - napi_delete_async_work(env, registerPermActiveChangeContext->work); - registerPermActiveChangeContext->work = nullptr; - DeleteRegisterInVector(registerPermActiveChangeContext); - return; - } - NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, registerPermActiveChangeContext->work)); - registerPermActiveChangeContext->work = nullptr; -} - napi_value RegisterPermActiveChangeCallback(napi_env env, napi_callback_info cbInfo) { - RegisterPermActiveChangeContext* registerPermActiveChangeContext = - new (std::nothrow) RegisterPermActiveChangeContext(); + RegisterPermActiveChangeContext* registerPermActiveChangeContext = new (std::nothrow) RegisterPermActiveChangeContext(); if (registerPermActiveChangeContext == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "insufficient memory for subscribeCBInfo!"); return nullptr; @@ -744,86 +702,27 @@ napi_value RegisterPermActiveChangeCallback(napi_env env, napi_callback_info cbI ACCESSTOKEN_LOG_ERROR(LABEL, "Subscribe failed. The current subscriber has been existed"); return nullptr; } + if (PrivacyKit::RegisterPermActiveStatusCallback(registerPermActiveChangeContext->subscriber) != RET_SUCCESS) { + ACCESSTOKEN_LOG_ERROR(LABEL, "RegisterPermActiveStatusCallback failed"); + return nullptr; + } { - // add to vector std::lock_guard lock(g_lockForPermActiveChangeSubscribers); if (g_permActiveChangeSubscribers.size() >= MAX_CALLBACK_SIZE) { ACCESSTOKEN_LOG_ERROR(LABEL, "subscribers size has reached max value"); return nullptr; } g_permActiveChangeSubscribers.emplace_back(registerPermActiveChangeContext); - ACCESSTOKEN_LOG_DEBUG(LABEL, - "add g_permActiveChangeSubscribers.size = %{public}zu, registerPermActiveChangeContext = %{public}p", - g_permActiveChangeSubscribers.size(), registerPermActiveChangeContext); - } - napi_value resource = nullptr; - if (napi_create_string_utf8(env, "RegisterPermActiveChangeCallback", NAPI_AUTO_LENGTH, &resource) != napi_ok) { - DeleteRegisterInVector(registerPermActiveChangeContext); - return nullptr; - } - if (napi_create_async_work(env, - nullptr, - resource, - RegisterPermActiveChangeExecute, - RegisterPermActiveChangeComplete, - reinterpret_cast(registerPermActiveChangeContext), - ®isterPermActiveChangeContext->work) != napi_ok) { - DeleteRegisterInVector(registerPermActiveChangeContext); - return nullptr; - } - if (napi_queue_async_work(env, registerPermActiveChangeContext->work) != napi_ok) { - DeleteRegisterInVector(registerPermActiveChangeContext); - return nullptr; + ACCESSTOKEN_LOG_DEBUG(LABEL, "add g_permActiveChangeSubscribers.size = %{public}zu", + g_permActiveChangeSubscribers.size()); } callbackPtr.release(); return nullptr; } -static void UnregisterPermActiveChangeExecute(napi_env env, void* data) -{ - if (data == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "data is null"); - return; - } - UnregisterPermActiveChangeContext* unregisterPermActiveChangeContext = - reinterpret_cast(data); - unregisterPermActiveChangeContext->errCode = - PrivacyKit::UnRegisterPermActiveStatusCallback(unregisterPermActiveChangeContext->subscriber); -} - -static void UnregisterPermActiveChangeCompleted(napi_env env, napi_status status, void *data) -{ - if (data == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "data is null"); - return; - } - UnregisterPermActiveChangeContext* unregisterPermActiveChangeContext = - reinterpret_cast(data); - std::unique_ptr callbackPtr {unregisterPermActiveChangeContext}; - if (unregisterPermActiveChangeContext->callbackRef != nullptr) { - napi_value results[ARGS_ONE] = {nullptr}; - NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &results[PARAM0])); - napi_value undefined; - NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined)); - napi_value resultout = nullptr; - napi_value callback = nullptr; - NAPI_CALL_RETURN_VOID(env, - napi_get_reference_value(env, unregisterPermActiveChangeContext->callbackRef, &callback)); - NAPI_CALL_RETURN_VOID(env, - napi_call_function(env, undefined, callback, ARGS_ONE, &results[PARAM0], &resultout)); - } - if (unregisterPermActiveChangeContext->errCode == RET_SUCCESS) { - ACCESSTOKEN_LOG_DEBUG(LABEL, "ret = %{public}d", unregisterPermActiveChangeContext->errCode); - DeleteRegisterInVector(unregisterPermActiveChangeContext); - } else { - ACCESSTOKEN_LOG_ERROR(LABEL, "errCode = %{public}d", unregisterPermActiveChangeContext->errCode); - } -} - napi_value UnregisterPermActiveChangeCallback(napi_env env, napi_callback_info cbInfo) { - UnregisterPermActiveChangeContext* unregisterPermActiveChangeContext = - new (std::nothrow) UnregisterPermActiveChangeContext(); + UnregisterPermActiveChangeContext* unregisterPermActiveChangeContext = new (std::nothrow) UnregisterPermActiveChangeContext(); if (unregisterPermActiveChangeContext == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "insufficient memory for subscribeCBInfo!"); return nullptr; @@ -836,18 +735,23 @@ napi_value UnregisterPermActiveChangeCallback(napi_env env, napi_callback_info c ACCESSTOKEN_LOG_ERROR(LABEL, "Unsubscribe failed. The current subscriber does not exist"); return nullptr; } - ACCESSTOKEN_LOG_ERROR(LABEL, "The current subscriber exist"); - napi_value resource = nullptr; - NAPI_CALL(env, napi_create_string_utf8(env, "UnregisterPermActiveChangeCallback", NAPI_AUTO_LENGTH, &resource)); - NAPI_CALL(env, napi_create_async_work(env, - nullptr, - resource, - UnregisterPermActiveChangeExecute, - UnregisterPermActiveChangeCompleted, - reinterpret_cast(unregisterPermActiveChangeContext), - &(unregisterPermActiveChangeContext->work))); - NAPI_CALL(env, napi_queue_async_work(env, unregisterPermActiveChangeContext->work)); - callbackPtr.release(); + if (PrivacyKit::UnRegisterPermActiveStatusCallback(unregisterPermActiveChangeContext->subscriber) == RET_SUCCESS) { + DeleteRegisterInVector(unregisterPermActiveChangeContext); + } else { + ACCESSTOKEN_LOG_ERROR(LABEL, "UnregisterPermActiveChangeCompleted failed"); + } + if (unregisterPermActiveChangeContext->callbackRef != nullptr) { + napi_value results[ARGS_ONE] = {nullptr}; + NAPI_CALL(env, napi_get_null(env, &results[PARAM0])); + napi_value undefined; + NAPI_CALL(env, napi_get_undefined(env, &undefined)); + napi_value resultout = nullptr; + napi_value callback = nullptr; + NAPI_CALL(env, + napi_get_reference_value(env, unregisterPermActiveChangeContext->callbackRef, &callback)); + NAPI_CALL(env, + napi_call_function(env, undefined, callback, ARGS_ONE, &results[PARAM0], &resultout)); + } return nullptr; } } // namespace AccessToken -- Gitee From b4db42b1c852a83327ae2ff1eb63a65a727f0414 Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Mon, 29 Aug 2022 15:16:38 +0800 Subject: [PATCH 04/10] =?UTF-8?q?2022/08/29=20=E6=9D=83=E9=99=90=E4=BD=BF?= =?UTF-8?q?=E7=94=A8=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 --- .../privacy/napi/src/napi_context_common.cpp | 31 +++++-------------- .../src/permission_record_manager_napi.cpp | 9 ------ 2 files changed, 7 insertions(+), 33 deletions(-) diff --git a/interfaces/kits/privacy/napi/src/napi_context_common.cpp b/interfaces/kits/privacy/napi/src/napi_context_common.cpp index 1e128d5f6..af9db347d 100644 --- a/interfaces/kits/privacy/napi/src/napi_context_common.cpp +++ b/interfaces/kits/privacy/napi/src/napi_context_common.cpp @@ -41,7 +41,6 @@ PrivacyAsyncWorkData::~PrivacyAsyncWorkData() PermActiveChangeContext::~PermActiveChangeContext() { if (callbackRef != nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "------~PermActiveChangeContext callback"); napi_delete_reference(env, callbackRef); callbackRef = nullptr; } @@ -66,30 +65,29 @@ void PermActiveStatusPtr::SetCallbackRef(const napi_ref& ref) void PermActiveStatusPtr::ActiveStatusChangeCallback(ActiveChangeResponse& result) { - ACCESSTOKEN_LOG_ERROR(LABEL, "------ActiveStatusChangeCallback begin"); uv_loop_s* loop = nullptr; NAPI_CALL_RETURN_VOID(env_, napi_get_uv_event_loop(env_, &loop)); if (loop == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "------loop instance is nullptr"); + ACCESSTOKEN_LOG_ERROR(LABEL, "loop instance is nullptr"); return; } uv_work_t* work = new (std::nothrow) uv_work_t; if (work == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "------insufficient memory for work!"); + ACCESSTOKEN_LOG_ERROR(LABEL, "insufficient memory for work!"); return; } std::unique_ptr uvWorkPtr {work}; PermActiveStatusWorker* permActiveStatusWorker = new (std::nothrow) PermActiveStatusWorker(); if (permActiveStatusWorker == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "------insufficient memory for RegisterPermStateChangeWorker!"); + ACCESSTOKEN_LOG_ERROR(LABEL, "insufficient memory for RegisterPermStateChangeWorker!"); return; } std::unique_ptr workPtr {permActiveStatusWorker}; permActiveStatusWorker->env = env_; permActiveStatusWorker->ref = ref_; permActiveStatusWorker->result = result; - ACCESSTOKEN_LOG_ERROR(LABEL, - "------result: tokenID = %{public}d, permissionName = %{public}s, deviceId = %{public}s, type = %{public}d", + ACCESSTOKEN_LOG_DEBUG(LABEL, + "result: tokenID = %{public}d, permissionName = %{public}s, deviceId = %{public}s, type = %{public}d", result.tokenID, result.permissionName.c_str(), result.deviceId.c_str(), result.type); permActiveStatusWorker->subscriber = this; work->data = reinterpret_cast(permActiveStatusWorker); @@ -102,7 +100,7 @@ void PermActiveStatusPtr::ActiveStatusChangeCallback(ActiveChangeResponse& resul void UvQueueWorkActiveStatusChange(uv_work_t* work, int status) { if (work == nullptr || work->data == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "------work == nullptr || work->data == nullptr"); + ACCESSTOKEN_LOG_ERROR(LABEL, "work == nullptr || work->data == nullptr"); return; } std::unique_ptr uvWorkPtr {work}; @@ -112,7 +110,7 @@ void UvQueueWorkActiveStatusChange(uv_work_t* work, int status) NAPI_CALL_RETURN_VOID(permActiveStatusData->env, napi_create_array(permActiveStatusData->env, &result[PARAM0])); if (!ConvertActiveChangeResponse(permActiveStatusData->env, result[PARAM0], permActiveStatusData->result)) { - ACCESSTOKEN_LOG_ERROR(LABEL, "------ConvertActiveChangeResponse failed"); + ACCESSTOKEN_LOG_ERROR(LABEL, "ConvertActiveChangeResponse failed"); return; } napi_value undefined = nullptr; @@ -124,38 +122,23 @@ void UvQueueWorkActiveStatusChange(uv_work_t* work, int status) napi_get_reference_value(permActiveStatusData->env, permActiveStatusData->ref, &callback)); NAPI_CALL_RETURN_VOID(permActiveStatusData->env, napi_call_function(permActiveStatusData->env, undefined, callback, ARGS_ONE, &result[PARAM0], &resultout)); - ACCESSTOKEN_LOG_ERROR(LABEL, "------UvQueueWorkActiveStatusChange end"); } bool ConvertActiveChangeResponse(napi_env env, napi_value value, const ActiveChangeResponse& result) { - ACCESSTOKEN_LOG_ERROR(LABEL, - "------ConvertActiveChangeResponse : result 1: tokenID = %{public}d, permissionName = %{public}s, deviceId = %{public}s, type = %{public}d", - result.tokenID, result.permissionName.c_str(), result.deviceId.c_str(), result.type); napi_value element; - ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_create_uint32(env, result.tokenID, &element)"); NAPI_CALL_BASE(env, napi_create_uint32(env, result.tokenID, &element), false); - ACCESSTOKEN_LOG_ERROR(LABEL, - "------ConvertActiveChangeResponse : result 2: tokenID = %{public}d, permissionName = %{public}s, deviceId = %{public}s, type = %{public}d", - result.tokenID, result.permissionName.c_str(), result.deviceId.c_str(), result.type); - ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_set_named_property"); NAPI_CALL_BASE(env, napi_set_named_property(env, value, "tokenId", element), false); element = nullptr; - ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_create_string_utf8(env, result.permissionName.c_str()"); NAPI_CALL_BASE(env, napi_create_string_utf8(env, result.permissionName.c_str(), NAPI_AUTO_LENGTH, &element), false); - ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_set_named_property"); NAPI_CALL_BASE(env, napi_set_named_property(env, value, "permissionName", element), false); element = nullptr; - ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_create_string_utf8(env, result.deviceId.c_str()"); NAPI_CALL_BASE(env, napi_create_string_utf8(env, result.deviceId.c_str(), NAPI_AUTO_LENGTH, &element), false); - ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_set_named_property"); NAPI_CALL_BASE(env, napi_set_named_property(env, value, "deviceId", element), false); element = nullptr; - ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_create_int32(env, result.type, &element)"); NAPI_CALL_BASE(env, napi_create_int32(env, result.type, &element), false); - ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_set_named_property"); NAPI_CALL_BASE(env, napi_set_named_property(env, value, "activeStatus", element), false); return true; } diff --git a/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp b/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp index 1394d7f23..89f922f9b 100644 --- a/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp +++ b/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp @@ -57,7 +57,6 @@ static void ParseAddPermissionRecord( static void ParseStartAndStopUsingPermission( const napi_env env, const napi_callback_info info, RecordManagerAsyncContext& asyncContext) { - ACCESSTOKEN_LOG_ERROR(LABEL, "------StartUsingPermission begin."); size_t argc = ARGS_THREE; napi_value argv[ARGS_THREE] = { 0 }; napi_value thisVar = nullptr; @@ -67,11 +66,8 @@ static void ParseStartAndStopUsingPermission( asyncContext.env = env; asyncContext.tokenId = ParseUint32(env, argv[PARAM0]); - ACCESSTOKEN_LOG_ERROR(LABEL, "------asyncContext.tokenId = %{public}d", asyncContext.tokenId); asyncContext.permissionName = ParseString(env, argv[PARAM1]); - ACCESSTOKEN_LOG_ERROR(LABEL, "------asyncContext.permissionName = %{public}s", asyncContext.permissionName.c_str()); if (argc == ARGS_THREE) { - ACCESSTOKEN_LOG_ERROR(LABEL, "------parse callback"); napi_valuetype valueType = napi_undefined; NAPI_CALL_RETURN_VOID(env, napi_typeof(env, argv[ARGS_THREE - 1], &valueType)) ; if (valueType == napi_function) { @@ -334,7 +330,6 @@ napi_value AddPermissionUsedRecord(napi_env env, napi_callback_info cbinfo) static void StartUsingPermissionExecute(napi_env env, void* data) { - ACCESSTOKEN_LOG_ERROR(LABEL, "------StartUsingPermission execute."); ACCESSTOKEN_LOG_DEBUG(LABEL, "StartUsingPermission execute."); RecordManagerAsyncContext* asyncContext = reinterpret_cast(data); if (asyncContext == nullptr) { @@ -347,7 +342,6 @@ static void StartUsingPermissionExecute(napi_env env, void* data) static void StartUsingPermissionComplete(napi_env env, napi_status status, void* data) { - ACCESSTOKEN_LOG_ERROR(LABEL, "------StartUsingPermissionComplete execute."); ACCESSTOKEN_LOG_DEBUG(LABEL, "StartUsingPermission complete."); RecordManagerAsyncContext* asyncContext = reinterpret_cast(data); if (asyncContext == nullptr) { @@ -360,10 +354,8 @@ static void StartUsingPermissionComplete(napi_env env, napi_status status, void* NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncContext->retCode, &results[PARAM1])); if (asyncContext->deferred) { - ACCESSTOKEN_LOG_ERROR(LABEL, "------asyncContext->deferred."); NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncContext->deferred, results[PARAM1])); - ACCESSTOKEN_LOG_ERROR(LABEL, "------napi_resolve_deferred end"); } else { napi_value callback = nullptr; napi_value callResult = nullptr; @@ -379,7 +371,6 @@ static void StartUsingPermissionComplete(napi_env env, napi_status status, void* napi_value StartUsingPermission(napi_env env, napi_callback_info cbinfo) { ACCESSTOKEN_LOG_DEBUG(LABEL, "StartUsingPermission begin."); - ACCESSTOKEN_LOG_ERROR(LABEL, "------StartUsingPermission begin."); auto *asyncContext = new (std::nothrow) RecordManagerAsyncContext(env); if (asyncContext == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "new struct fail."); -- Gitee From fdbdf7e55fb5f7e595fc895c5a375445fd0da8e9 Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Mon, 29 Aug 2022 16:02:53 +0800 Subject: [PATCH 05/10] =?UTF-8?q?2022/08/29=20=E6=9D=83=E9=99=90=E4=BD=BF?= =?UTF-8?q?=E7=94=A8=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 --- .../privacy/napi/src/permission_record_manager_napi.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp b/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp index 89f922f9b..c6f571bca 100644 --- a/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp +++ b/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp @@ -609,7 +609,7 @@ static bool ParseInputToUnregister(const napi_env env, const napi_callback_info } // get PRARM[2] callback type if (valueType != napi_function) { ACCESSTOKEN_LOG_ERROR(LABEL, "argv[PARAM2] callback matching failed"); - return false; + return false; } if (napi_create_reference(env, argv[PARAM2], 1, &callback) != napi_ok) { ACCESSTOKEN_LOG_ERROR(LABEL, "napi_create_reference failed"); @@ -680,7 +680,8 @@ static bool FindAndGetSubscriber(UnregisterPermActiveChangeContext* unregisterPe napi_value RegisterPermActiveChangeCallback(napi_env env, napi_callback_info cbInfo) { - RegisterPermActiveChangeContext* registerPermActiveChangeContext = new (std::nothrow) RegisterPermActiveChangeContext(); + RegisterPermActiveChangeContext* registerPermActiveChangeContext = + new (std::nothrow) RegisterPermActiveChangeContext(); if (registerPermActiveChangeContext == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "insufficient memory for subscribeCBInfo!"); return nullptr; @@ -713,7 +714,8 @@ napi_value RegisterPermActiveChangeCallback(napi_env env, napi_callback_info cbI napi_value UnregisterPermActiveChangeCallback(napi_env env, napi_callback_info cbInfo) { - UnregisterPermActiveChangeContext* unregisterPermActiveChangeContext = new (std::nothrow) UnregisterPermActiveChangeContext(); + UnregisterPermActiveChangeContext* unregisterPermActiveChangeContext = + new (std::nothrow) UnregisterPermActiveChangeContext(); if (unregisterPermActiveChangeContext == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "insufficient memory for subscribeCBInfo!"); return nullptr; -- Gitee From 25bd7a67d1d68e0dd726c691ab5ebf1940cb6d00 Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Tue, 30 Aug 2022 08:34:40 +0800 Subject: [PATCH 06/10] =?UTF-8?q?2022/08/30=20=E6=9D=83=E9=99=90=E4=BD=BF?= =?UTF-8?q?=E7=94=A8=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 --- .../kits/privacy/napi/include/permission_record_manager_napi.h | 2 ++ interfaces/kits/privacy/napi/src/napi_context_common.cpp | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/interfaces/kits/privacy/napi/include/permission_record_manager_napi.h b/interfaces/kits/privacy/napi/include/permission_record_manager_napi.h index 9a8892033..9de5b1b59 100644 --- a/interfaces/kits/privacy/napi/include/permission_record_manager_napi.h +++ b/interfaces/kits/privacy/napi/include/permission_record_manager_napi.h @@ -40,11 +40,13 @@ struct RecordManagerAsyncContext : public PrivacyAsyncWorkData { PermissionUsedResult result; int32_t retCode = -1; }; + typedef PermActiveChangeContext RegisterPermActiveChangeContext; struct UnregisterPermActiveChangeContext : public PermActiveChangeContext { std::vector permList; }; + napi_value AddPermissionUsedRecord(napi_env env, napi_callback_info cbinfo); napi_value StartUsingPermission(napi_env env, napi_callback_info cbinfo); napi_value StopUsingPermission(napi_env env, napi_callback_info cbinfo); diff --git a/interfaces/kits/privacy/napi/src/napi_context_common.cpp b/interfaces/kits/privacy/napi/src/napi_context_common.cpp index af9db347d..e712d5604 100644 --- a/interfaces/kits/privacy/napi/src/napi_context_common.cpp +++ b/interfaces/kits/privacy/napi/src/napi_context_common.cpp @@ -19,7 +19,7 @@ namespace Security { namespace AccessToken { namespace { static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_PRIVACY, "PrivacyContextCommonNapi"}; -} +} // namespace PrivacyAsyncWorkData::PrivacyAsyncWorkData(napi_env envValue) { env = envValue; -- Gitee From 4024ba633d6ccf146419e23865612a7c321446ee Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Tue, 30 Aug 2022 08:39:48 +0800 Subject: [PATCH 07/10] =?UTF-8?q?2022/08/30=20=E6=9D=83=E9=99=90=E4=BD=BF?= =?UTF-8?q?=E7=94=A8=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/privacy/napi/src/native_module.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interfaces/kits/privacy/napi/src/native_module.cpp b/interfaces/kits/privacy/napi/src/native_module.cpp index 3d9a3426c..f9beea9ab 100644 --- a/interfaces/kits/privacy/napi/src/native_module.cpp +++ b/interfaces/kits/privacy/napi/src/native_module.cpp @@ -64,7 +64,7 @@ static napi_value Init(napi_env env, napi_value exports) napi_property_descriptor exportFuncs[] = { DECLARE_NAPI_PROPERTY("PermissionUsageFlag ", permissionUsageFlag), - DECLARE_NAPI_PROPERTY("PermActiveStatus ", permActiveStatus) + DECLARE_NAPI_PROPERTY("PermissionActiveStatus ", permActiveStatus) }; napi_define_properties(env, exports, sizeof(exportFuncs) / sizeof(exportFuncs[0]), exportFuncs); -- Gitee From 08e93536d6640254f280babeb31597d469721448 Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Tue, 30 Aug 2022 10:13:20 +0800 Subject: [PATCH 08/10] =?UTF-8?q?2022/08/30=20=E6=9D=83=E9=99=90=E4=BD=BF?= =?UTF-8?q?=E7=94=A8=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/privacy/napi/src/napi_context_common.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/interfaces/kits/privacy/napi/src/napi_context_common.cpp b/interfaces/kits/privacy/napi/src/napi_context_common.cpp index e712d5604..50a2eaa33 100644 --- a/interfaces/kits/privacy/napi/src/napi_context_common.cpp +++ b/interfaces/kits/privacy/napi/src/napi_context_common.cpp @@ -99,6 +99,7 @@ void PermActiveStatusPtr::ActiveStatusChangeCallback(ActiveChangeResponse& resul void UvQueueWorkActiveStatusChange(uv_work_t* work, int status) { + (void)status; if (work == nullptr || work->data == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "work == nullptr || work->data == nullptr"); return; -- Gitee From 40bb996d4e3669d1f503017cdb80f5a854d12a14 Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Tue, 30 Aug 2022 12:56:40 +0800 Subject: [PATCH 09/10] =?UTF-8?q?2022/08/30=20=E6=9D=83=E9=99=90=E4=BD=BF?= =?UTF-8?q?=E7=94=A8=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 --- .../napi/src/permission_record_manager_napi.cpp | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp b/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp index c6f571bca..e41f10b75 100644 --- a/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp +++ b/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp @@ -571,7 +571,7 @@ static bool ParseInputToRegister(const napi_env env, const napi_callback_info cb return false; } // get PRARM[2] callback type if (valueType != napi_function) { - ACCESSTOKEN_LOG_ERROR(LABEL, "argv[PARAM2] callback matching failed"); + ACCESSTOKEN_LOG_ERROR(LABEL, "value type dismatch"); return false; } if (napi_create_reference(env, argv[PARAM2], 1, &callback) != napi_ok) { @@ -608,7 +608,7 @@ static bool ParseInputToUnregister(const napi_env env, const napi_callback_info return false; } // get PRARM[2] callback type if (valueType != napi_function) { - ACCESSTOKEN_LOG_ERROR(LABEL, "argv[PARAM2] callback matching failed"); + ACCESSTOKEN_LOG_ERROR(LABEL, "value type dismatch"); return false; } if (napi_create_reference(env, argv[PARAM2], 1, &callback) != napi_ok) { @@ -632,7 +632,6 @@ static bool IsExistRegister(const PermActiveChangeContext* permActiveChangeConte std::vector permList; item->subscriber->GetPermList(permList); if (permList == targetPermList) { - ACCESSTOKEN_LOG_DEBUG(LABEL, "find subscriber in map"); return true; } } @@ -652,7 +651,6 @@ static void DeleteRegisterInVector(PermActiveChangeContext* permActiveChangeCont delete *item; *item = nullptr; g_permActiveChangeSubscribers.erase(item); - ACCESSTOKEN_LOG_DEBUG(LABEL, "delete permActiveChangeContext"); return; } else { ++item; @@ -670,11 +668,9 @@ static bool FindAndGetSubscriber(UnregisterPermActiveChangeContext* unregisterPe if (permList == targetPermList) { // targetCallback != nullptr, unregister the subscriber with same permList and callback unregisterPermActiveChangeContext->subscriber = item->subscriber; - ACCESSTOKEN_LOG_DEBUG(LABEL, "find and get subscriber in map"); return true; } } - ACCESSTOKEN_LOG_ERROR(LABEL, "cannot find and get subscriber in map"); return false; } @@ -705,8 +701,6 @@ napi_value RegisterPermActiveChangeCallback(napi_env env, napi_callback_info cbI return nullptr; } g_permActiveChangeSubscribers.emplace_back(registerPermActiveChangeContext); - ACCESSTOKEN_LOG_DEBUG(LABEL, "add g_permActiveChangeSubscribers.size = %{public}zu", - g_permActiveChangeSubscribers.size()); } callbackPtr.release(); return nullptr; -- Gitee From f90bf2e2e0232bdee4dd6c86fbc3b44bb5df4776 Mon Sep 17 00:00:00 2001 From: hhhhs9527 Date: Tue, 30 Aug 2022 12:56:40 +0800 Subject: [PATCH 10/10] =?UTF-8?q?2022/08/30=20=E6=9D=83=E9=99=90=E4=BD=BF?= =?UTF-8?q?=E7=94=A8=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 --- .../kits/privacy/napi/src/napi_context_common.cpp | 4 ++-- .../napi/src/permission_record_manager_napi.cpp | 10 ++-------- 2 files changed, 4 insertions(+), 10 deletions(-) diff --git a/interfaces/kits/privacy/napi/src/napi_context_common.cpp b/interfaces/kits/privacy/napi/src/napi_context_common.cpp index 50a2eaa33..d9eae5ebe 100644 --- a/interfaces/kits/privacy/napi/src/napi_context_common.cpp +++ b/interfaces/kits/privacy/napi/src/napi_context_common.cpp @@ -87,8 +87,8 @@ void PermActiveStatusPtr::ActiveStatusChangeCallback(ActiveChangeResponse& resul permActiveStatusWorker->ref = ref_; permActiveStatusWorker->result = result; ACCESSTOKEN_LOG_DEBUG(LABEL, - "result: tokenID = %{public}d, permissionName = %{public}s, deviceId = %{public}s, type = %{public}d", - result.tokenID, result.permissionName.c_str(), result.deviceId.c_str(), result.type); + "result: tokenID = %{public}d, permissionName = %{public}s, type = %{public}d", + result.tokenID, result.permissionName.c_str(), result.type); permActiveStatusWorker->subscriber = this; work->data = reinterpret_cast(permActiveStatusWorker); NAPI_CALL_RETURN_VOID(env_, diff --git a/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp b/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp index c6f571bca..e41f10b75 100644 --- a/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp +++ b/interfaces/kits/privacy/napi/src/permission_record_manager_napi.cpp @@ -571,7 +571,7 @@ static bool ParseInputToRegister(const napi_env env, const napi_callback_info cb return false; } // get PRARM[2] callback type if (valueType != napi_function) { - ACCESSTOKEN_LOG_ERROR(LABEL, "argv[PARAM2] callback matching failed"); + ACCESSTOKEN_LOG_ERROR(LABEL, "value type dismatch"); return false; } if (napi_create_reference(env, argv[PARAM2], 1, &callback) != napi_ok) { @@ -608,7 +608,7 @@ static bool ParseInputToUnregister(const napi_env env, const napi_callback_info return false; } // get PRARM[2] callback type if (valueType != napi_function) { - ACCESSTOKEN_LOG_ERROR(LABEL, "argv[PARAM2] callback matching failed"); + ACCESSTOKEN_LOG_ERROR(LABEL, "value type dismatch"); return false; } if (napi_create_reference(env, argv[PARAM2], 1, &callback) != napi_ok) { @@ -632,7 +632,6 @@ static bool IsExistRegister(const PermActiveChangeContext* permActiveChangeConte std::vector permList; item->subscriber->GetPermList(permList); if (permList == targetPermList) { - ACCESSTOKEN_LOG_DEBUG(LABEL, "find subscriber in map"); return true; } } @@ -652,7 +651,6 @@ static void DeleteRegisterInVector(PermActiveChangeContext* permActiveChangeCont delete *item; *item = nullptr; g_permActiveChangeSubscribers.erase(item); - ACCESSTOKEN_LOG_DEBUG(LABEL, "delete permActiveChangeContext"); return; } else { ++item; @@ -670,11 +668,9 @@ static bool FindAndGetSubscriber(UnregisterPermActiveChangeContext* unregisterPe if (permList == targetPermList) { // targetCallback != nullptr, unregister the subscriber with same permList and callback unregisterPermActiveChangeContext->subscriber = item->subscriber; - ACCESSTOKEN_LOG_DEBUG(LABEL, "find and get subscriber in map"); return true; } } - ACCESSTOKEN_LOG_ERROR(LABEL, "cannot find and get subscriber in map"); return false; } @@ -705,8 +701,6 @@ napi_value RegisterPermActiveChangeCallback(napi_env env, napi_callback_info cbI return nullptr; } g_permActiveChangeSubscribers.emplace_back(registerPermActiveChangeContext); - ACCESSTOKEN_LOG_DEBUG(LABEL, "add g_permActiveChangeSubscribers.size = %{public}zu", - g_permActiveChangeSubscribers.size()); } callbackPtr.release(); return nullptr; -- Gitee