From 846d8008567b6f869b070ed998a06b1d86baf9c5 Mon Sep 17 00:00:00 2001 From: zhouyan Date: Sat, 23 Nov 2024 14:29:40 +0800 Subject: [PATCH] =?UTF-8?q?=E6=9D=83=E9=99=90=E4=BD=BF=E7=94=A8=E7=8A=B6?= =?UTF-8?q?=E6=80=81=E5=8F=98=E5=8C=96=E7=9B=91=E5=90=AC=E6=9C=BA=E5=88=B6?= =?UTF-8?q?=E5=A2=9E=E5=BC=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhouyan Change-Id: I3a2353f29ea31e37f2d359ec70760892b7579c36 --- .../napi/privacy/src/napi_context_common.cpp | 6 ++ .../src/permission_record_manager_napi.cpp | 69 ++++++++++++++++--- .../privacy/include/i_privacy_manager.h | 5 +- .../src/perm_active_response_parcel.cpp | 7 ++ .../include/active_change_response_info.h | 3 + .../innerkits/privacy/include/privacy_kit.h | 6 +- .../innerkits/privacy/libprivacy_sdk.map | 4 +- .../innerkits/privacy/src/privacy_kit.cpp | 17 +++-- .../privacy/src/privacy_manager_client.cpp | 11 ++- .../privacy/src/privacy_manager_client.h | 5 +- .../privacy/src/privacy_manager_proxy.cpp | 14 +++- .../privacy/src/privacy_manager_proxy.h | 5 +- .../include/permission_record_manager_napi.h | 1 + .../active/active_status_callback_manager.h | 7 +- .../record/permission_record_manager.h | 11 +-- .../include/service/privacy_manager_service.h | 5 +- .../active/active_status_callback_manager.cpp | 37 +++++----- .../src/record/permission_record_manager.cpp | 32 +++++---- .../src/service/privacy_manager_service.cpp | 18 ++--- .../src/service/privacy_manager_stub.cpp | 8 ++- .../unittest/privacy_manager_service_test.cpp | 5 +- 21 files changed, 185 insertions(+), 91 deletions(-) diff --git a/frameworks/js/napi/privacy/src/napi_context_common.cpp b/frameworks/js/napi/privacy/src/napi_context_common.cpp index 116ae4648..66e29103d 100644 --- a/frameworks/js/napi/privacy/src/napi_context_common.cpp +++ b/frameworks/js/napi/privacy/src/napi_context_common.cpp @@ -197,6 +197,9 @@ void NotifyChangeResponse(const PermActiveStatusWorker* permActiveStatusData) bool ConvertActiveChangeResponse(napi_env env, napi_value value, const ActiveChangeResponse& result) { napi_value element; + NAPI_CALL_BASE(env, napi_create_uint32(env, result.callingTokenID, &element), false); + NAPI_CALL_BASE(env, napi_set_named_property(env, value, "callingTokenId", element), false); + element = nullptr; 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; @@ -210,6 +213,9 @@ bool ConvertActiveChangeResponse(napi_env env, napi_value value, const ActiveCha 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); + element = nullptr; + NAPI_CALL_BASE(env, napi_create_int32(env, result.usedType, &element), false); + NAPI_CALL_BASE(env, napi_set_named_property(env, value, "usedType", element), false); return true; } } // namespace AccessToken diff --git a/frameworks/js/napi/privacy/src/permission_record_manager_napi.cpp b/frameworks/js/napi/privacy/src/permission_record_manager_napi.cpp index d8f3f53ac..d7b848626 100644 --- a/frameworks/js/napi/privacy/src/permission_record_manager_napi.cpp +++ b/frameworks/js/napi/privacy/src/permission_record_manager_napi.cpp @@ -34,7 +34,8 @@ static constexpr int32_t ADD_PERMISSION_RECORD_MAX_PARAMS = 5; static constexpr int32_t ADD_PERMISSION_RECORD_MIN_PARAMS = 4; static constexpr int32_t GET_PERMISSION_RECORD_MAX_PARAMS = 2; static constexpr int32_t ON_OFF_MAX_PARAMS = 3; -static constexpr int32_t START_STOP_MAX_PARAMS = 3; +static constexpr int32_t START_STOP_MAX_PARAMS = 4; +static constexpr int32_t START_STOP_MIN_PARAMS = 2; static constexpr int32_t GET_PERMISSION_USED_TYPE_MAX_PARAMS = 2; static constexpr int32_t GET_PERMISSION_USED_TYPE_ONE_PARAMS = 1; static constexpr int32_t FIRST_PARAM = 0; @@ -161,6 +162,9 @@ static bool ParseAddPermissionFifthParam(const napi_env env, const napi_value& v ParamResolveErrorThrow(env, "callback", "AsyncCallback"); return false; } + } else { + ParamResolveErrorThrow(env, "fifth param", "options or AsyncCallback"); + return false; } return true; @@ -216,6 +220,34 @@ static bool ParseAddPermissionRecord( return true; } +static bool ParseStartAndStopThirdParam(const napi_env env, const napi_value& value, + RecordManagerAsyncContext& asyncContext) +{ + napi_valuetype typeValue = napi_undefined; + if (napi_typeof(env, value, &typeValue) != napi_ok) { + return false; + } + + if (typeValue == napi_number) { + // pid + if (!ParseInt32(env, value, asyncContext.pid)) { + ParamResolveErrorThrow(env, "pid", "number"); + return false; + } + } else if (typeValue == napi_function) { + // callback + if (!IsUndefinedOrNull(env, value) && !ParseCallback(env, value, asyncContext.callbackRef)) { + ParamResolveErrorThrow(env, "callback", "AsyncCallback"); + return false; + } + } else { + ParamResolveErrorThrow(env, "third param", "pid or AsyncCallback"); + return false; + } + + return true; +} + static bool ParseStartAndStopUsingPermission( const napi_env env, const napi_callback_info info, RecordManagerAsyncContext& asyncContext) { @@ -225,30 +257,45 @@ static bool ParseStartAndStopUsingPermission( void* data = nullptr; NAPI_CALL_BASE(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, &data), false); - if (argc < START_STOP_MAX_PARAMS - 1) { + if (argc < START_STOP_MIN_PARAMS) { NAPI_CALL_BASE(env, napi_throw(env, GenerateBusinessError(env, JS_ERROR_PARAM_ILLEGAL, "Parameter is missing.")), false); return false; } asyncContext.env = env; - // 0: the first parameter of argv - if (!ParseUint32(env, argv[0], asyncContext.tokenId)) { + // 0: the first parameter of argv is tokenId + if (!ParseUint32(env, argv[FIRST_PARAM], asyncContext.tokenId)) { ParamResolveErrorThrow(env, "tokenId", "number"); return false; } - // 1: the second parameter of argv - if (!ParseString(env, argv[1], asyncContext.permissionName)) { + // 1: the second parameter of argv is permissionName + if (!ParseString(env, argv[SECOND_PARAM], asyncContext.permissionName)) { ParamResolveErrorThrow(env, "permissionName", "string"); return false; } - if (argc == START_STOP_MAX_PARAMS) { - // 2: the third parameter of argv - if (!IsUndefinedOrNull(env, argv[2]) && !ParseCallback(env, argv[2], asyncContext.callbackRef)) { - ParamResolveErrorThrow(env, "callback", "AsyncCallback"); + + if (argc == START_STOP_MAX_PARAMS - 1) { + // 2: the third paramter of argv, may be callback or pid + if (!ParseStartAndStopThirdParam(env, argv[THIRD_PARAM], asyncContext)) { return false; } + } else if (argc == START_STOP_MAX_PARAMS) { + // 2: the third paramter of argv is pid + if (!ParseInt32(env, argv[THIRD_PARAM], asyncContext.pid)) { + ParamResolveErrorThrow(env, "pid", "number"); + return false; + } + + // 3: the fourth paramter of argv is usedType + uint32_t usedType = 0; + if (!ParseUint32(env, argv[FOURTH_PARAM], usedType)) { + ParamResolveErrorThrow(env, "usedType", "number"); + return false; + } + + asyncContext.type = static_cast(usedType); } return true; } @@ -549,7 +596,7 @@ static void StartUsingPermissionExecute(napi_env env, void* data) } asyncContext->retCode = PrivacyKit::StartUsingPermission(asyncContext->tokenId, - asyncContext->permissionName); + asyncContext->permissionName, asyncContext->pid, asyncContext->type); } static void StartUsingPermissionComplete(napi_env env, napi_status status, void* data) diff --git a/frameworks/privacy/include/i_privacy_manager.h b/frameworks/privacy/include/i_privacy_manager.h index 2d4468cf9..19cbcce78 100644 --- a/frameworks/privacy/include/i_privacy_manager.h +++ b/frameworks/privacy/include/i_privacy_manager.h @@ -44,9 +44,10 @@ public: DECLARE_INTERFACE_DESCRIPTOR(u"ohos.security.accesstoken.IPrivacyManager"); virtual int32_t AddPermissionUsedRecord(const AddPermParamInfoParcel& infoParcel, bool asyncMode = false) = 0; - virtual int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName) = 0; virtual int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName, - const sptr& callback) = 0; + PermissionUsedType type = PermissionUsedType::NORMAL_TYPE) = 0; + virtual int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName, + const sptr& callback, PermissionUsedType type = PermissionUsedType::NORMAL_TYPE) = 0; virtual int32_t StopUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName) = 0; virtual int32_t RemovePermissionUsedRecords(AccessTokenID tokenID) = 0; virtual int32_t GetPermissionUsedRecords( diff --git a/frameworks/privacy/src/perm_active_response_parcel.cpp b/frameworks/privacy/src/perm_active_response_parcel.cpp index 49617f9d7..a66c8ca2b 100644 --- a/frameworks/privacy/src/perm_active_response_parcel.cpp +++ b/frameworks/privacy/src/perm_active_response_parcel.cpp @@ -21,10 +21,12 @@ namespace Security { namespace AccessToken { bool ActiveChangeResponseParcel::Marshalling(Parcel& out) const { + RETURN_IF_FALSE(out.WriteUint32(this->changeResponse.callingTokenID)); RETURN_IF_FALSE(out.WriteUint32(this->changeResponse.tokenID)); RETURN_IF_FALSE(out.WriteString(this->changeResponse.permissionName)); RETURN_IF_FALSE(out.WriteString(this->changeResponse.deviceId)); RETURN_IF_FALSE(out.WriteInt32(this->changeResponse.type)); + RETURN_IF_FALSE(out.WriteInt32(this->changeResponse.usedType)); return true; } @@ -35,6 +37,8 @@ ActiveChangeResponseParcel* ActiveChangeResponseParcel::Unmarshalling(Parcel& in return nullptr; } + RELEASE_IF_FALSE(in.ReadUint32(activeChangeResponseParcel->changeResponse.callingTokenID), + activeChangeResponseParcel); RELEASE_IF_FALSE(in.ReadUint32(activeChangeResponseParcel->changeResponse.tokenID), activeChangeResponseParcel); RELEASE_IF_FALSE(in.ReadString(activeChangeResponseParcel->changeResponse.permissionName), activeChangeResponseParcel); @@ -43,6 +47,9 @@ ActiveChangeResponseParcel* ActiveChangeResponseParcel::Unmarshalling(Parcel& in int32_t type; RELEASE_IF_FALSE(in.ReadInt32(type), activeChangeResponseParcel); activeChangeResponseParcel->changeResponse.type = static_cast(type); + int32_t usedType; + RELEASE_IF_FALSE(in.ReadInt32(usedType), activeChangeResponseParcel); + activeChangeResponseParcel->changeResponse.usedType = static_cast(usedType); return activeChangeResponseParcel; } } // namespace AccessToken diff --git a/interfaces/innerkits/privacy/include/active_change_response_info.h b/interfaces/innerkits/privacy/include/active_change_response_info.h index 44503ad2c..1244277b6 100644 --- a/interfaces/innerkits/privacy/include/active_change_response_info.h +++ b/interfaces/innerkits/privacy/include/active_change_response_info.h @@ -39,6 +39,7 @@ #include #include "access_token.h" +#include "permission_used_type.h" namespace OHOS { namespace Security { @@ -65,6 +66,7 @@ enum LockScreenStatusChangeType { * @brief Permission active state change response struct */ struct ActiveChangeResponse { + AccessTokenID callingTokenID; AccessTokenID tokenID; std::string permissionName; std::string deviceId; @@ -73,6 +75,7 @@ struct ActiveChangeResponse { * see the definition above. */ ActiveChangeType type; + PermissionUsedType usedType; }; } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/privacy/include/privacy_kit.h b/interfaces/innerkits/privacy/include/privacy_kit.h index 4902688c3..e37649e92 100644 --- a/interfaces/innerkits/privacy/include/privacy_kit.h +++ b/interfaces/innerkits/privacy/include/privacy_kit.h @@ -81,7 +81,8 @@ public: * @param permissionName permission nanme * @return error code, see privacy_error.h */ - static int32_t StartUsingPermission(AccessTokenID tokenID, const std::string& permissionName, int32_t pid = -1); + static int32_t StartUsingPermission(AccessTokenID tokenID, const std::string& permissionName, int32_t pid = -1, + PermissionUsedType type = PermissionUsedType::NORMAL_TYPE); /** * @brief Input tokenID start using input permission and return by callback, * only those services which has float window such as camera or @@ -92,7 +93,8 @@ public: * @return error code, see privacy_error.h */ static int32_t StartUsingPermission(AccessTokenID tokenID, const std::string& permissionName, - const std::shared_ptr& callback, int32_t pid = -1); + const std::shared_ptr& callback, int32_t pid = -1, + PermissionUsedType type = PermissionUsedType::NORMAL_TYPE); /** * @brief Input tokenID stop using input permission. * @param tokenID token id diff --git a/interfaces/innerkits/privacy/libprivacy_sdk.map b/interfaces/innerkits/privacy/libprivacy_sdk.map index c730121e6..f32079ed4 100644 --- a/interfaces/innerkits/privacy/libprivacy_sdk.map +++ b/interfaces/innerkits/privacy/libprivacy_sdk.map @@ -18,7 +18,7 @@ "OHOS::Security::AccessToken::PermActiveStatusCustomizedCbk::~PermActiveStatusCustomizedCbk()"; "OHOS::Security::AccessToken::PrivacyKit::AddPermissionUsedRecord(unsigned int, std::__h::basic_string, std::__h::allocator> const&, int, int, bool)"; "OHOS::Security::AccessToken::PrivacyKit::AddPermissionUsedRecord(OHOS::Security::AccessToken::AddPermParamInfo const&, bool)"; - "OHOS::Security::AccessToken::PrivacyKit::StartUsingPermission(unsigned int, std::__h::basic_string, std::__h::allocator> const&, int)"; + "OHOS::Security::AccessToken::PrivacyKit::StartUsingPermission(unsigned int, std::__h::basic_string, std::__h::allocator> const&, int, OHOS::Security::AccessToken::PermissionUsedTypeValue)"; "OHOS::Security::AccessToken::PrivacyKit::StopUsingPermission(unsigned int, std::__h::basic_string, std::__h::allocator> const&, int)"; "OHOS::Security::AccessToken::PrivacyKit::GetPermissionUsedRecords(OHOS::Security::AccessToken::PermissionUsedRequest const&, OHOS::Security::AccessToken::PermissionUsedResult&)"; "OHOS::Security::AccessToken::PermActiveStatusCustomizedCbk::GetPermList(std::__h::vector, std::__h::allocator>, std::__h::allocator, std::__h::allocator>>>&) const"; @@ -26,7 +26,7 @@ "OHOS::Security::AccessToken::PrivacyKit::UnRegisterPermActiveStatusCallback(std::__h::shared_ptr const&)"; "OHOS::Security::AccessToken::PrivacyKit::RemovePermissionUsedRecords(unsigned int)"; "OHOS::Security::AccessToken::StateCustomizedCbk::StateCustomizedCbk()"; - "OHOS::Security::AccessToken::PrivacyKit::StartUsingPermission(unsigned int, std::__h::basic_string, std::__h::allocator> const&, std::__h::shared_ptr const&, int)"; + "OHOS::Security::AccessToken::PrivacyKit::StartUsingPermission(unsigned int, std::__h::basic_string, std::__h::allocator> const&, std::__h::shared_ptr const&, int, OHOS::Security::AccessToken::PermissionUsedTypeValue)"; "OHOS::Security::AccessToken::PrivacyKit::GetPermissionUsedRecords(OHOS::Security::AccessToken::PermissionUsedRequest const&, OHOS::sptr const&)"; "OHOS::Security::AccessToken::PrivacyKit::IsAllowedUsingPermission(unsigned int, std::__h::basic_string, std::__h::allocator> const&)"; "OHOS::Security::AccessToken::PrivacyKit::RegisterSecCompEnhance(OHOS::Security::AccessToken::SecCompEnhanceData const&)"; diff --git a/interfaces/innerkits/privacy/src/privacy_kit.cpp b/interfaces/innerkits/privacy/src/privacy_kit.cpp index 572d1eb14..5618ac7f0 100644 --- a/interfaces/innerkits/privacy/src/privacy_kit.cpp +++ b/interfaces/innerkits/privacy/src/privacy_kit.cpp @@ -96,27 +96,32 @@ int32_t PrivacyKit::AddPermissionUsedRecord(const AddPermParamInfo& info, bool a return RET_SUCCESS; } -int32_t PrivacyKit::StartUsingPermission(AccessTokenID tokenID, const std::string& permissionName, int32_t pid) +int32_t PrivacyKit::StartUsingPermission(AccessTokenID tokenID, const std::string& permissionName, int32_t pid, + PermissionUsedType type) { - if (!DataValidator::IsTokenIDValid(tokenID) || !DataValidator::IsPermissionNameValid(permissionName)) { + if ((!DataValidator::IsTokenIDValid(tokenID)) || + (!DataValidator::IsPermissionNameValid(permissionName)) || + (!DataValidator::IsPermissionUsedTypeValid(type))) { return PrivacyError::ERR_PARAM_INVALID; } if (!DataValidator::IsHapCaller(tokenID)) { return PrivacyError::ERR_PARAM_INVALID; } - return PrivacyManagerClient::GetInstance().StartUsingPermission(tokenID, pid, permissionName); + return PrivacyManagerClient::GetInstance().StartUsingPermission(tokenID, pid, permissionName, type); } int32_t PrivacyKit::StartUsingPermission(AccessTokenID tokenID, const std::string& permissionName, - const std::shared_ptr& callback, int32_t pid) + const std::shared_ptr& callback, int32_t pid, PermissionUsedType type) { - if (!DataValidator::IsTokenIDValid(tokenID) || !DataValidator::IsPermissionNameValid(permissionName)) { + if ((!DataValidator::IsTokenIDValid(tokenID)) || + (!DataValidator::IsPermissionNameValid(permissionName)) || + (!DataValidator::IsPermissionUsedTypeValid(type))) { return PrivacyError::ERR_PARAM_INVALID; } if (!DataValidator::IsHapCaller(tokenID)) { return PrivacyError::ERR_PARAM_INVALID; } - return PrivacyManagerClient::GetInstance().StartUsingPermission(tokenID, pid, permissionName, callback); + return PrivacyManagerClient::GetInstance().StartUsingPermission(tokenID, pid, permissionName, callback, type); } int32_t PrivacyKit::StopUsingPermission(AccessTokenID tokenID, const std::string& permissionName, int32_t pid) diff --git a/interfaces/innerkits/privacy/src/privacy_manager_client.cpp b/interfaces/innerkits/privacy/src/privacy_manager_client.cpp index ec27452cf..16f423fa6 100644 --- a/interfaces/innerkits/privacy/src/privacy_manager_client.cpp +++ b/interfaces/innerkits/privacy/src/privacy_manager_client.cpp @@ -71,14 +71,14 @@ int32_t PrivacyManagerClient::AddPermissionUsedRecord(const AddPermParamInfo& in } int32_t PrivacyManagerClient::StartUsingPermission( - AccessTokenID tokenID, int32_t pid, const std::string& permissionName) + AccessTokenID tokenID, int32_t pid, const std::string& permissionName, PermissionUsedType type) { auto proxy = GetProxy(); if (proxy == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Proxy is null."); return PrivacyError::ERR_SERVICE_ABNORMAL; } - return proxy->StartUsingPermission(tokenID, pid, permissionName); + return proxy->StartUsingPermission(tokenID, pid, permissionName, type); } int32_t PrivacyManagerClient::CreateStateChangeCbk(uint64_t id, @@ -99,9 +99,8 @@ int32_t PrivacyManagerClient::CreateStateChangeCbk(uint64_t id, return RET_SUCCESS; } -int32_t PrivacyManagerClient::StartUsingPermission( - AccessTokenID tokenId, int32_t pid, const std::string& permissionName, - const std::shared_ptr& callback) +int32_t PrivacyManagerClient::StartUsingPermission(AccessTokenID tokenId, int32_t pid, + const std::string& permissionName, const std::shared_ptr& callback, PermissionUsedType type) { if (callback == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Callback is nullptr."); @@ -121,7 +120,7 @@ int32_t PrivacyManagerClient::StartUsingPermission( return PrivacyError::ERR_SERVICE_ABNORMAL; } - result = proxy->StartUsingPermission(tokenId, pid, permissionName, callbackWrap->AsObject()); + result = proxy->StartUsingPermission(tokenId, pid, permissionName, callbackWrap->AsObject(), type); if (result == RET_SUCCESS) { std::lock_guard lock(stateCbkMutex_); stateChangeCallbackMap_[id] = callbackWrap; diff --git a/interfaces/innerkits/privacy/src/privacy_manager_client.h b/interfaces/innerkits/privacy/src/privacy_manager_client.h index 94a361403..76a4c22b8 100644 --- a/interfaces/innerkits/privacy/src/privacy_manager_client.h +++ b/interfaces/innerkits/privacy/src/privacy_manager_client.h @@ -38,11 +38,12 @@ public: virtual ~PrivacyManagerClient(); int32_t AddPermissionUsedRecord(const AddPermParamInfo& info, bool asyncMode = false); - int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName); + int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName, + PermissionUsedType type); int32_t CreateStateChangeCbk(uint64_t id, const std::shared_ptr& callback, sptr& callbackWrap); int32_t StartUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName, - const std::shared_ptr& callback); + const std::shared_ptr& callback, PermissionUsedType type); int32_t StopUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName); int32_t RemovePermissionUsedRecords(AccessTokenID tokenID); int32_t GetPermissionUsedRecords(const PermissionUsedRequest& request, PermissionUsedResult& result); diff --git a/interfaces/innerkits/privacy/src/privacy_manager_proxy.cpp b/interfaces/innerkits/privacy/src/privacy_manager_proxy.cpp index 5495eed05..bbef0ea33 100644 --- a/interfaces/innerkits/privacy/src/privacy_manager_proxy.cpp +++ b/interfaces/innerkits/privacy/src/privacy_manager_proxy.cpp @@ -59,7 +59,7 @@ int32_t PrivacyManagerProxy::AddPermissionUsedRecord(const AddPermParamInfoParce } int32_t PrivacyManagerProxy::StartUsingPermission( - AccessTokenID tokenID, int32_t pid, const std::string& permissionName) + AccessTokenID tokenID, int32_t pid, const std::string& permissionName, PermissionUsedType type) { MessageParcel startData; startData.WriteInterfaceToken(IPrivacyManager::GetDescriptor()); @@ -75,6 +75,11 @@ int32_t PrivacyManagerProxy::StartUsingPermission( ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to write permissionName"); return PrivacyError::ERR_WRITE_PARCEL_FAILED; } + uint32_t usedType = static_cast(type); + if (!startData.WriteUint32(usedType)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to write type"); + return PrivacyError::ERR_WRITE_PARCEL_FAILED; + } MessageParcel reply; if (!SendRequest(PrivacyInterfaceCode::START_USING_PERMISSION, startData, reply)) { @@ -88,7 +93,7 @@ int32_t PrivacyManagerProxy::StartUsingPermission( int32_t PrivacyManagerProxy::StartUsingPermission( AccessTokenID tokenID, int32_t pid, const std::string& permissionName, - const sptr& callback) + const sptr& callback, PermissionUsedType type) { MessageParcel data; data.WriteInterfaceToken(IPrivacyManager::GetDescriptor()); @@ -108,6 +113,11 @@ int32_t PrivacyManagerProxy::StartUsingPermission( ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to write remote object."); return PrivacyError::ERR_WRITE_PARCEL_FAILED; } + uint32_t usedType = static_cast(type); + if (!data.WriteUint32(usedType)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to write type"); + return PrivacyError::ERR_WRITE_PARCEL_FAILED; + } MessageParcel reply; if (!SendRequest(PrivacyInterfaceCode::START_USING_PERMISSION_CALLBACK, data, reply)) { diff --git a/interfaces/innerkits/privacy/src/privacy_manager_proxy.h b/interfaces/innerkits/privacy/src/privacy_manager_proxy.h index 96c6ae5c2..52206a9b9 100644 --- a/interfaces/innerkits/privacy/src/privacy_manager_proxy.h +++ b/interfaces/innerkits/privacy/src/privacy_manager_proxy.h @@ -30,9 +30,10 @@ public: ~PrivacyManagerProxy() override; int32_t AddPermissionUsedRecord(const AddPermParamInfoParcel& infoParcel, bool asyncMode = false) override; - int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName) override; int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName, - const sptr& callback) override; + PermissionUsedType type) override; + int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName, + const sptr& callback, PermissionUsedType type) override; int32_t StopUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName) override; int32_t RemovePermissionUsedRecords(AccessTokenID tokenID) override; int32_t GetPermissionUsedRecords( diff --git a/interfaces/kits/js/napi/privacy/include/permission_record_manager_napi.h b/interfaces/kits/js/napi/privacy/include/permission_record_manager_napi.h index 36d48ceb8..931080ead 100644 --- a/interfaces/kits/js/napi/privacy/include/permission_record_manager_napi.h +++ b/interfaces/kits/js/napi/privacy/include/permission_record_manager_napi.h @@ -37,6 +37,7 @@ struct RecordManagerAsyncContext : public PrivacyAsyncWorkData { std::string permissionName; int32_t successCount = 0; int32_t failCount = 0; + int32_t pid = -1; PermissionUsedType type = PermissionUsedType::NORMAL_TYPE; PermissionUsedRequest request; PermissionUsedResult result; diff --git a/services/privacymanager/include/active/active_status_callback_manager.h b/services/privacymanager/include/active/active_status_callback_manager.h index fae559082..f1507daf2 100644 --- a/services/privacymanager/include/active/active_status_callback_manager.h +++ b/services/privacymanager/include/active/active_status_callback_manager.h @@ -24,6 +24,7 @@ #endif #include "access_token.h" #include "accesstoken_log.h" +#include "active_change_response_info.h" #include "perm_active_status_callback_death_recipient.h" #include "perm_active_status_change_callback_proxy.h" @@ -52,13 +53,11 @@ public: AccessTokenID regiterTokenId, const std::vector& permList, const sptr& callback); int32_t RemoveCallback(const sptr& callback); bool NeedCalled(const std::vector& permList, const std::string& permName); - void ExecuteCallbackAsync( - AccessTokenID tokenId, const std::string& permName, const std::string& deviceId, ActiveChangeType changeType); + void ExecuteCallbackAsync(ActiveChangeResponse& info); #ifdef EVENTHANDLER_ENABLE void InitEventHandler(const std::shared_ptr& eventHandler); #endif - void ActiveStatusChange(AccessTokenID tokenId, const std::string& permName, - const std::string& deviceId, ActiveChangeType changeType); + void ActiveStatusChange(ActiveChangeResponse& info); private: std::mutex mutex_; std::vector callbackDataList_; diff --git a/services/privacymanager/include/record/permission_record_manager.h b/services/privacymanager/include/record/permission_record_manager.h index 842fb3ea0..00bdcdbc7 100644 --- a/services/privacymanager/include/record/permission_record_manager.h +++ b/services/privacymanager/include/record/permission_record_manager.h @@ -78,15 +78,17 @@ public: int32_t GetPermissionUsedRecords(const PermissionUsedRequest& request, PermissionUsedResult& result); int32_t GetPermissionUsedRecordsAsync( const PermissionUsedRequest& request, const sptr& callback); - int32_t StartUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName); int32_t StartUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName, - const sptr& callback); + PermissionUsedType type = PermissionUsedType::NORMAL_TYPE); + int32_t StartUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName, + const sptr& callback, PermissionUsedType type = PermissionUsedType::NORMAL_TYPE); int32_t StopUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName); int32_t RegisterPermActiveStatusCallback( AccessTokenID regiterTokenId, const std::vector& permList, const sptr& callback); int32_t UnRegisterPermActiveStatusCallback(const sptr& callback); - void CallbackExecute(AccessTokenID tokenId, const std::string& permissionName, int32_t status); + void CallbackExecute(AccessTokenID tokenId, const std::string& permissionName, int32_t status, + PermissionUsedType type = PermissionUsedType::NORMAL_TYPE); int32_t PermissionListFilter(const std::vector& listSrc, std::vector& listRes); bool IsAllowedUsingPermission(AccessTokenID tokenId, const std::string& permissionName); int32_t GetPermissionUsedTypeInfos(const AccessTokenID tokenId, const std::string& permissionName, @@ -151,7 +153,8 @@ private: bool ShowGlobalDialog(const std::string& permissionName); #endif int32_t RemoveRecordFromStartList(AccessTokenID tokenId, int32_t pid, const std::string& permissionName); - int32_t AddRecordToStartList(uint32_t tokenId, int32_t pid, const std::string& permissionName, int32_t status); + int32_t AddRecordToStartList(uint32_t tokenId, int32_t pid, const std::string& permissionName, int32_t status, + PermissionUsedType type = PermissionUsedType::NORMAL_TYPE); void PermListToString(const std::vector& permList); bool GetGlobalSwitchStatus(const std::string& permissionName); diff --git a/services/privacymanager/include/service/privacy_manager_service.h b/services/privacymanager/include/service/privacy_manager_service.h index c628d5396..8048ef52c 100644 --- a/services/privacymanager/include/service/privacy_manager_service.h +++ b/services/privacymanager/include/service/privacy_manager_service.h @@ -40,9 +40,10 @@ public: void OnStop() override; int32_t AddPermissionUsedRecord(const AddPermParamInfoParcel& infoParcel, bool asyncMode = false) override; - int32_t StartUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName) override; int32_t StartUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName, - const sptr& callback) override; + PermissionUsedType type) override; + int32_t StartUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName, + const sptr& callback, PermissionUsedType type = PermissionUsedType::NORMAL_TYPE) override; int32_t StopUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName) override; int32_t RemovePermissionUsedRecords(AccessTokenID tokenId) override; int32_t GetPermissionUsedRecords( diff --git a/services/privacymanager/src/active/active_status_callback_manager.cpp b/services/privacymanager/src/active/active_status_callback_manager.cpp index 191f5c6fd..f4d162ed7 100644 --- a/services/privacymanager/src/active/active_status_callback_manager.cpp +++ b/services/privacymanager/src/active/active_status_callback_manager.cpp @@ -22,6 +22,7 @@ #include "accesstoken_dfx_define.h" #include "accesstoken_log.h" +#include "ipc_skeleton.h" #include "privacy_error.h" namespace OHOS { @@ -124,16 +125,16 @@ bool ActiveStatusCallbackManager::NeedCalled(const std::vector& per } -void ActiveStatusCallbackManager::ActiveStatusChange( - AccessTokenID tokenId, const std::string& permName, const std::string& deviceId, ActiveChangeType changeType) +void ActiveStatusCallbackManager::ActiveStatusChange(ActiveChangeResponse& info) { std::vector> list; { std::lock_guard lock(mutex_); for (auto it = callbackDataList_.begin(); it != callbackDataList_.end(); ++it) { std::vector permList = (*it).permList_; - if (!NeedCalled(permList, permName)) { - ACCESSTOKEN_LOG_INFO(LABEL, "TokenId %{public}u, perm %{public}s", tokenId, permName.c_str()); + if (!NeedCalled(permList, info.permissionName)) { + ACCESSTOKEN_LOG_INFO(LABEL, "TokenId %{public}u, perm %{public}s", info.tokenID, + info.permissionName.c_str()); continue; } list.emplace_back((*it).callbackObject_); @@ -142,26 +143,20 @@ void ActiveStatusCallbackManager::ActiveStatusChange( for (auto it = list.begin(); it != list.end(); ++it) { auto callback = new PermActiveStatusChangeCallbackProxy(*it); if (callback != nullptr) { - ActiveChangeResponse resInfo; - resInfo.type = changeType; - resInfo.permissionName = permName; - resInfo.tokenID = tokenId; - resInfo.deviceId = deviceId; - ACCESSTOKEN_LOG_INFO(LABEL, - "callback execute tokenId %{public}u, permision %{public}s changeType %{public}d", - tokenId, permName.c_str(), changeType); - callback->ActiveStatusChangeCallback(resInfo); + ACCESSTOKEN_LOG_INFO(LABEL, "callback execute callingTokenId %{public}u, tokenId %{public}u, " + "permision %{public}s, changeType %{public}d, usedType %{public}d", info.callingTokenID, + info.tokenID, info.permissionName.c_str(), info.type, info.usedType); + callback->ActiveStatusChangeCallback(info); } } } -void ActiveStatusCallbackManager::ExecuteCallbackAsync( - AccessTokenID tokenId, const std::string& permName, const std::string& deviceId, ActiveChangeType changeType) +void ActiveStatusCallbackManager::ExecuteCallbackAsync(ActiveChangeResponse& info) { - if (changeType == PERM_ACTIVE_IN_BACKGROUND) { + if (info.type == PERM_ACTIVE_IN_BACKGROUND) { HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::ACCESS_TOKEN, "PERMISSION_CHECK_EVENT", HiviewDFX::HiSysEvent::EventType::BEHAVIOR, "CODE", BACKGROUND_CALL_EVENT, - "CALLER_TOKENID", tokenId, "PERMISSION_NAME", permName, "REASON", "background call"); + "CALLER_TOKENID", info.tokenID, "PERMISSION_NAME", info.permissionName, "REASON", "background call"); } #ifdef EVENTHANDLER_ENABLE @@ -169,13 +164,13 @@ void ActiveStatusCallbackManager::ExecuteCallbackAsync( ACCESSTOKEN_LOG_ERROR(LABEL, "Fail to get EventHandler"); return; } - std::string taskName = permName + std::to_string(tokenId); + std::string taskName = info.permissionName + std::to_string(info.tokenID); ACCESSTOKEN_LOG_INFO(LABEL, "Add permission task name:%{public}s", taskName.c_str()); - std::function task = ([tokenId, permName, deviceId, changeType]() { - ActiveStatusCallbackManager::GetInstance().ActiveStatusChange(tokenId, permName, deviceId, changeType); + std::function task = ([info]() mutable { + ActiveStatusCallbackManager::GetInstance().ActiveStatusChange(info); ACCESSTOKEN_LOG_INFO(LABEL, "Token: %{public}u, permName: %{public}s, changeType: %{public}d, ActiveStatusChange end", - tokenId, permName.c_str(), changeType); + info.tokenID, info.permissionName.c_str(), info.type); }); eventHandler_->ProxyPostTask(task, taskName); ACCESSTOKEN_LOG_INFO(LABEL, "The callback execution is complete"); diff --git a/services/privacymanager/src/record/permission_record_manager.cpp b/services/privacymanager/src/record/permission_record_manager.cpp index a45910381..fc283e154 100644 --- a/services/privacymanager/src/record/permission_record_manager.cpp +++ b/services/privacymanager/src/record/permission_record_manager.cpp @@ -758,7 +758,7 @@ int32_t PermissionRecordManager::DeletePermissionRecord(int32_t days) } int32_t PermissionRecordManager::AddRecordToStartList( - uint32_t tokenId, int32_t pid, const std::string& permissionName, int32_t status) + uint32_t tokenId, int32_t pid, const std::string& permissionName, int32_t status, PermissionUsedType type) { int32_t ret = Constant::SUCCESS; int32_t opCode; @@ -794,7 +794,7 @@ int32_t PermissionRecordManager::AddRecordToStartList( } startRecordList_.emplace_back(record); } - CallbackExecute(tokenId, permissionName, status); + CallbackExecute(tokenId, permissionName, status, type); if (hasTokenStarted && hasPidStarted) { ret = PrivacyError::ERR_PERMISSION_ALREADY_START_USING; } @@ -1006,13 +1006,21 @@ void PermissionRecordManager::RemoveRecordFromStartListByOp(int32_t opCode) } void PermissionRecordManager::CallbackExecute( - AccessTokenID tokenId, const std::string& permissionName, int32_t status) + AccessTokenID tokenId, const std::string& permissionName, int32_t status, PermissionUsedType type) { ACCESSTOKEN_LOG_INFO(LABEL, - "ExecuteCallbackAsync, tokenId %{public}d using permission %{public}s, status %{public}d", - tokenId, permissionName.c_str(), status); - ActiveStatusCallbackManager::GetInstance().ExecuteCallbackAsync( - tokenId, permissionName, "", (ActiveChangeType)status); + "ExecuteCallbackAsync, tokenId %{public}d using permission %{public}s, status %{public}d, type %{public}d", + tokenId, permissionName.c_str(), status, type); + + ActiveChangeResponse info; + info.callingTokenID = IPCSkeleton::GetCallingTokenID(); + info.tokenID = tokenId; + info.permissionName = permissionName; + info.deviceId = ""; + info.type = static_cast(status); + info.usedType = type; + + ActiveStatusCallbackManager::GetInstance().ExecuteCallbackAsync(info); } bool PermissionRecordManager::GetGlobalSwitchStatus(const std::string& permissionName) @@ -1121,7 +1129,7 @@ void PermissionRecordManager::ExecuteCameraCallbackAsync(AccessTokenID tokenId, } int32_t PermissionRecordManager::StartUsingPermission( - AccessTokenID tokenId, int32_t pid, const std::string& permissionName) + AccessTokenID tokenId, int32_t pid, const std::string& permissionName, PermissionUsedType type) { if (AccessTokenKit::GetTokenTypeFlag(tokenId) != TOKEN_HAP) { ACCESSTOKEN_LOG_DEBUG(LABEL, "Not hap(%{public}d).", tokenId); @@ -1146,11 +1154,11 @@ int32_t PermissionRecordManager::StartUsingPermission( status = PERM_INACTIVE; } #endif - return AddRecordToStartList(tokenId, pid, permissionName, status); + return AddRecordToStartList(tokenId, pid, permissionName, status, type); } -int32_t PermissionRecordManager::StartUsingPermission( - AccessTokenID tokenId, int32_t pid, const std::string& permissionName, const sptr& callback) +int32_t PermissionRecordManager::StartUsingPermission(AccessTokenID tokenId, int32_t pid, + const std::string& permissionName, const sptr& callback, PermissionUsedType type) { if ((permissionName != CAMERA_PERMISSION_NAME) || (AccessTokenKit::GetTokenTypeFlag(tokenId) != TOKEN_HAP)) { ACCESSTOKEN_LOG_DEBUG(LABEL, "Token(%{public}u), perm(%{public}s).", tokenId, permissionName.c_str()); @@ -1181,7 +1189,7 @@ int32_t PermissionRecordManager::StartUsingPermission( cameraCallbackMap_.Erase(id); return PrivacyError::ERR_WINDOW_CALLBACK_FAILED; } - int32_t ret = AddRecordToStartList(tokenId, pid, permissionName, status); + int32_t ret = AddRecordToStartList(tokenId, pid, permissionName, status, type); if (ret != RET_SUCCESS) { cameraCallbackMap_.Erase(id); } diff --git a/services/privacymanager/src/service/privacy_manager_service.cpp b/services/privacymanager/src/service/privacy_manager_service.cpp index 052022618..05a23b3b1 100644 --- a/services/privacymanager/src/service/privacy_manager_service.cpp +++ b/services/privacymanager/src/service/privacy_manager_service.cpp @@ -102,19 +102,19 @@ int32_t PrivacyManagerService::AddPermissionUsedRecord(const AddPermParamInfoPar } int32_t PrivacyManagerService::StartUsingPermission( - AccessTokenID tokenId, int32_t pid, const std::string& permissionName) + AccessTokenID tokenId, int32_t pid, const std::string& permissionName, PermissionUsedType type) { - ACCESSTOKEN_LOG_INFO(LABEL, "id: %{public}u, pid: %{public}d, perm: %{public}s", - tokenId, pid, permissionName.c_str()); - return PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, pid, permissionName); + ACCESSTOKEN_LOG_INFO(LABEL, "Id: %{public}u, pid: %{public}d, perm: %{public}s, type: %{public}d.", + tokenId, pid, permissionName.c_str(), type); + return PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, pid, permissionName, type); } -int32_t PrivacyManagerService::StartUsingPermission( - AccessTokenID tokenId, int32_t pid, const std::string& permissionName, const sptr& callback) +int32_t PrivacyManagerService::StartUsingPermission(AccessTokenID tokenId, int32_t pid, + const std::string& permissionName, const sptr& callback, PermissionUsedType type) { - ACCESSTOKEN_LOG_INFO(LABEL, "id: %{public}u, pid: %{public}d, perm: %{public}s", - tokenId, pid, permissionName.c_str()); - return PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, pid, permissionName, callback); + ACCESSTOKEN_LOG_INFO(LABEL, "Id: %{public}u, pid: %{public}d, perm: %{public}s, type: %{public}d.", + tokenId, pid, permissionName.c_str(), type); + return PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, pid, permissionName, callback, type); } int32_t PrivacyManagerService::StopUsingPermission( diff --git a/services/privacymanager/src/service/privacy_manager_stub.cpp b/services/privacymanager/src/service/privacy_manager_stub.cpp index b9d89a68e..03406b184 100644 --- a/services/privacymanager/src/service/privacy_manager_stub.cpp +++ b/services/privacymanager/src/service/privacy_manager_stub.cpp @@ -144,7 +144,9 @@ void PrivacyManagerStub::StartUsingPermissionInner(MessageParcel& data, MessageP AccessTokenID tokenId = data.ReadUint32(); int32_t pid = data.ReadInt32(); std::string permissionName = data.ReadString(); - reply.WriteInt32(this->StartUsingPermission(tokenId, pid, permissionName)); + uint32_t usedType = data.ReadUint32(); + PermissionUsedType type = static_cast(usedType); + reply.WriteInt32(this->StartUsingPermission(tokenId, pid, permissionName, type)); } void PrivacyManagerStub::StartUsingPermissionCallbackInner(MessageParcel& data, MessageParcel& reply) @@ -162,7 +164,9 @@ void PrivacyManagerStub::StartUsingPermissionCallbackInner(MessageParcel& data, reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED); return; } - reply.WriteInt32(this->StartUsingPermission(tokenId, pid, permissionName, callback)); + uint32_t usedType = data.ReadUint32(); + PermissionUsedType type = static_cast(usedType); + reply.WriteInt32(this->StartUsingPermission(tokenId, pid, permissionName, callback, type)); } void PrivacyManagerStub::StopUsingPermissionInner(MessageParcel& data, MessageParcel& reply) diff --git a/services/privacymanager/test/unittest/privacy_manager_service_test.cpp b/services/privacymanager/test/unittest/privacy_manager_service_test.cpp index 491503907..ba11e3309 100644 --- a/services/privacymanager/test/unittest/privacy_manager_service_test.cpp +++ b/services/privacymanager/test/unittest/privacy_manager_service_test.cpp @@ -281,12 +281,13 @@ public: { return RET_SUCCESS; } - int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName) + int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName, + PermissionUsedType type = PermissionUsedType::NORMAL_TYPE) { return RET_SUCCESS; } int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName, - const sptr& callback) + const sptr& callback, PermissionUsedType type = PermissionUsedType::NORMAL_TYPE) { return RET_SUCCESS; } -- Gitee