From 72934d82431856fdf2fcacae2548babf1ef11ded Mon Sep 17 00:00:00 2001 From: AXYChen Date: Tue, 26 Nov 2024 20:58:45 +0800 Subject: [PATCH] =?UTF-8?q?=E6=94=AF=E6=8C=81=E5=BA=94=E7=94=A8=E7=9B=91?= =?UTF-8?q?=E5=90=AC=E6=9C=AC=E8=BF=9B=E7=A8=8B=E7=9A=84=E6=9D=83=E9=99=90?= =?UTF-8?q?=E7=9A=84=E6=8E=88=E6=9D=83=E5=8F=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: AXYChen Change-Id: I782c79a2b0be0c48e453c47864b190b16aac426a --- .../accesstoken_service_ipc_interface_code.h | 2 + .../include/i_accesstoken_manager.h | 3 + .../accesstoken/include/accesstoken_kit.h | 13 ++ .../accesstoken/libaccesstoken_sdk.map | 2 + .../accesstoken/src/accesstoken_kit.cpp | 14 ++ .../src/accesstoken_manager_client.cpp | 58 ++++++++ .../src/accesstoken_manager_client.h | 4 + .../src/accesstoken_manager_proxy.cpp | 57 ++++++++ .../src/accesstoken_manager_proxy.h | 3 + .../napi/accesstoken/include/napi_atmanager.h | 4 +- .../napi/accesstoken/src/napi_atmanager.cpp | 124 +++++++++++++++--- .../service/accesstoken_manager_service.h | 3 + .../service/accesstoken_manager_stub.h | 2 + .../service/accesstoken_manager_service.cpp | 11 ++ .../src/service/accesstoken_manager_stub.cpp | 46 +++++++ 15 files changed, 327 insertions(+), 19 deletions(-) diff --git a/frameworks/accesstoken/include/accesstoken_service_ipc_interface_code.h b/frameworks/accesstoken/include/accesstoken_service_ipc_interface_code.h index 5efbcf6ab..0f1b6dda5 100644 --- a/frameworks/accesstoken/include/accesstoken_service_ipc_interface_code.h +++ b/frameworks/accesstoken/include/accesstoken_service_ipc_interface_code.h @@ -70,6 +70,8 @@ enum class AccessTokenInterfaceCode { INIT_USER_POLICY, UPDATE_USER_POLICY, CLEAR_USER_POLICY, + REGISTER_APP_PERM_STATE_CHANGE_CALLBACK, + UNREGISTER_APP_PERM_STATE_CHANGE_CALLBACK, }; } // namespace AccessToken } // namespace Security diff --git a/frameworks/accesstoken/include/i_accesstoken_manager.h b/frameworks/accesstoken/include/i_accesstoken_manager.h index dd87188ad..db5d63704 100644 --- a/frameworks/accesstoken/include/i_accesstoken_manager.h +++ b/frameworks/accesstoken/include/i_accesstoken_manager.h @@ -81,6 +81,9 @@ public: virtual int32_t RegisterPermStateChangeCallback( const PermStateChangeScopeParcel& scope, const sptr& callback) = 0; virtual int32_t UnRegisterPermStateChangeCallback(const sptr& callback) = 0; + virtual int32_t RegisterAppPermStateChangeCallback( + const PermStateChangeScopeParcel& scope, const sptr& callback) = 0; + virtual int32_t UnRegisterAppPermStateChangeCallback(const sptr& callback) = 0; #ifndef ATM_BUILD_VARIANT_USER_ENABLE virtual int32_t ReloadNativeTokenInfo() = 0; #endif diff --git a/interfaces/innerkits/accesstoken/include/accesstoken_kit.h b/interfaces/innerkits/accesstoken/include/accesstoken_kit.h index ac8ad44e6..285911a44 100644 --- a/interfaces/innerkits/accesstoken/include/accesstoken_kit.h +++ b/interfaces/innerkits/accesstoken/include/accesstoken_kit.h @@ -307,6 +307,19 @@ public: * @return error code, see access_token_error.h */ static int32_t UnRegisterPermStateChangeCallback(const std::shared_ptr& callback); + /** + * @brief Register permission state change callback for app. + * @param callback smart point of class PermStateChangeCallbackCustomize quote + * @return error code, see access_token_error.h + */ + static int32_t RegisterAppPermStateChangeCallback( + const std::shared_ptr& callback); + /** + * @brief Unregister permission state change callback for app. + * @param callback smart point of class PermStateChangeCallbackCustomize quote + * @return error code, see access_token_error.h + */ + static int32_t UnRegisterAppPermStateChangeCallback(const std::shared_ptr& callback); /** * @brief Get current version. * @param version access token version. diff --git a/interfaces/innerkits/accesstoken/libaccesstoken_sdk.map b/interfaces/innerkits/accesstoken/libaccesstoken_sdk.map index 20fcc4f1b..d2a863cd1 100644 --- a/interfaces/innerkits/accesstoken/libaccesstoken_sdk.map +++ b/interfaces/innerkits/accesstoken/libaccesstoken_sdk.map @@ -30,6 +30,8 @@ "OHOS::Security::AccessToken::PermStateChangeCallbackCustomize::PermStateChangeCallbackCustomize(OHOS::Security::AccessToken::PermStateChangeScope const&)"; "OHOS::Security::AccessToken::AccessTokenKit::RegisterPermStateChangeCallback(std::__h::shared_ptr const&)"; "OHOS::Security::AccessToken::AccessTokenKit::UnRegisterPermStateChangeCallback(std::__h::shared_ptr const&)"; + "OHOS::Security::AccessToken::AccessTokenKit::RegisterAppPermStateChangeCallback(std::__h::shared_ptr const&)"; + "OHOS::Security::AccessToken::AccessTokenKit::UnRegisterAppPermStateChangeCallback(std::__h::shared_ptr const&)"; "OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo()"; "OHOS::Security::AccessToken::AccessTokenKit::GetNativeTokenId(std::__h::basic_string, std::__h::allocator> const&)"; "OHOS::Security::AccessToken::AccessTokenKit::DumpTokenInfo(OHOS::Security::AccessToken::AtmToolsParamInfo const&, std::__h::basic_string, std::__h::allocator>&)"; diff --git a/interfaces/innerkits/accesstoken/src/accesstoken_kit.cpp b/interfaces/innerkits/accesstoken/src/accesstoken_kit.cpp index 986e41b53..590f15a51 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_kit.cpp +++ b/interfaces/innerkits/accesstoken/src/accesstoken_kit.cpp @@ -463,6 +463,20 @@ int32_t AccessTokenKit::UnRegisterPermStateChangeCallback( return AccessTokenManagerClient::GetInstance().UnRegisterPermStateChangeCallback(callback); } +int32_t AccessTokenKit::RegisterAppPermStateChangeCallback( + const std::shared_ptr& callback) +{ + ACCESSTOKEN_LOG_INFO(LABEL, "Called"); + return AccessTokenManagerClient::GetInstance().RegisterAppPermStateChangeCallback(callback); +} + +int32_t AccessTokenKit::UnRegisterAppPermStateChangeCallback( + const std::shared_ptr& callback) +{ + ACCESSTOKEN_LOG_INFO(LABEL, "Called"); + return AccessTokenManagerClient::GetInstance().UnRegisterAppPermStateChangeCallback(callback); +} + int32_t AccessTokenKit::GetHapDlpFlag(AccessTokenID tokenID) { ACCESSTOKEN_LOG_DEBUG(LABEL, "TokenID=%{public}d.", tokenID); diff --git a/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.cpp b/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.cpp index a5f21dabc..ee84dcf54 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.cpp +++ b/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.cpp @@ -365,6 +365,64 @@ int32_t AccessTokenManagerClient::UnRegisterPermStateChangeCallback( return result; } +int32_t AccessTokenManagerClient::RegisterAppPermStateChangeCallback( + const std::shared_ptr& customizedCb) +{ + if (customizedCb == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "CustomizedCb is nullptr"); + return AccessTokenError::ERR_PARAM_INVALID; + } + + sptr callback = nullptr; + int32_t result = CreatePermStateChangeCallback(customizedCb, callback); + if (result != RET_SUCCESS) { + return result; + } + auto proxy = GetProxy(); + if (proxy == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Proxy is null"); + return AccessTokenError::ERR_SERVICE_ABNORMAL; + } + + PermStateChangeScopeParcel scopeParcel; + customizedCb->GetScope(scopeParcel.scope); + + if (scopeParcel.scope.permList.size() > PERMS_LIST_SIZE_MAX || + scopeParcel.scope.tokenIDs.size() > TOKENIDS_LIST_SIZE_MAX) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Scope oversize"); + return AccessTokenError::ERR_PARAM_INVALID; + } + result = proxy->RegisterAppPermStateChangeCallback(scopeParcel, callback->AsObject()); + if (result == RET_SUCCESS) { + std::lock_guard lock(callbackMutex_); + callbackMap_[customizedCb] = callback; + } + return result; +} + +int32_t AccessTokenManagerClient::UnRegisterAppPermStateChangeCallback( + const std::shared_ptr& customizedCb) +{ + auto proxy = GetProxy(); + if (proxy == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Proxy is null"); + return AccessTokenError::ERR_SERVICE_ABNORMAL; + } + + std::lock_guard lock(callbackMutex_); + auto goalCallback = callbackMap_.find(customizedCb); + if (goalCallback == callbackMap_.end()) { + ACCESSTOKEN_LOG_ERROR(LABEL, "GoalCallback already is not exist"); + return AccessTokenError::ERR_INTERFACE_NOT_USED_TOGETHER; + } + + int32_t result = proxy->UnRegisterAppPermStateChangeCallback(goalCallback->second->AsObject()); + if (result == RET_SUCCESS) { + callbackMap_.erase(goalCallback); + } + return result; +} + AccessTokenIDEx AccessTokenManagerClient::AllocHapToken(const HapInfoParams& info, const HapPolicyParams& policy) { AccessTokenIDEx tokenIdEx = { 0 }; diff --git a/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.h b/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.h index c0ca26d52..b97a26df3 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.h +++ b/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.h @@ -82,6 +82,10 @@ public: const std::shared_ptr& customizedCb); int32_t UnRegisterPermStateChangeCallback( const std::shared_ptr& customizedCb); + int32_t RegisterAppPermStateChangeCallback( + const std::shared_ptr& customizedCb); + int32_t UnRegisterAppPermStateChangeCallback( + const std::shared_ptr& customizedCb); #ifdef TOKEN_SYNC_ENABLE int GetHapTokenInfoFromRemote(AccessTokenID tokenID, HapTokenInfoForSync& hapSync); diff --git a/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.cpp b/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.cpp index 6d62f8ae9..133cd2007 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.cpp +++ b/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.cpp @@ -589,6 +589,63 @@ int32_t AccessTokenManagerProxy::UnRegisterPermStateChangeCallback(const sptr& callback) +{ + MessageParcel data; + if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) { + ACCESSTOKEN_LOG_ERROR(LABEL, "WriteInterfaceToken failed."); + return ERR_WRITE_PARCEL_FAILED; + } + if (!data.WriteParcelable(&scope)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "WriteParcelable failed."); + return ERR_WRITE_PARCEL_FAILED; + } + if (!data.WriteRemoteObject(callback)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "WriteRemoteObject failed."); + return ERR_WRITE_PARCEL_FAILED; + } + MessageParcel reply; + if (!SendRequest(AccessTokenInterfaceCode::REGISTER_APP_PERM_STATE_CHANGE_CALLBACK, data, reply)) { + return ERR_SERVICE_ABNORMAL; + } + + int32_t ret; + if (!reply.ReadInt32(ret)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "ReadInt32 failed."); + return ERR_READ_PARCEL_FAILED; + } + ACCESSTOKEN_LOG_INFO(LABEL, "Result from server (error=%{public}d).", ret); + return ret; +} + +int32_t AccessTokenManagerProxy::UnRegisterAppPermStateChangeCallback(const sptr& callback) +{ + MessageParcel data; + if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) { + ACCESSTOKEN_LOG_ERROR(LABEL, "WriteInterfaceToken failed."); + return ERR_WRITE_PARCEL_FAILED; + } + if (!data.WriteRemoteObject(callback)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "WriteRemoteObject failed."); + return ERR_WRITE_PARCEL_FAILED; + } + + MessageParcel reply; + if (!SendRequest( + AccessTokenInterfaceCode::UNREGISTER_APP_PERM_STATE_CHANGE_CALLBACK, data, reply)) { + return ERR_SERVICE_ABNORMAL; + } + + int32_t result; + if (!reply.ReadInt32(result)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "ReadInt32 failed."); + return ERR_READ_PARCEL_FAILED; + } + ACCESSTOKEN_LOG_INFO(LABEL, "Result from server (error=%{public}d).", result); + return result; +} + AccessTokenIDEx AccessTokenManagerProxy::AllocHapToken( const HapInfoParcel& hapInfo, const HapPolicyParcel& policyParcel) { diff --git a/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.h b/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.h index 52cd5e240..10fc792bd 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.h +++ b/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.h @@ -80,6 +80,9 @@ public: int32_t RegisterPermStateChangeCallback( const PermStateChangeScopeParcel& scope, const sptr& callback) override; int32_t UnRegisterPermStateChangeCallback(const sptr& callback) override; + int32_t RegisterAppPermStateChangeCallback( + const PermStateChangeScopeParcel& scope, const sptr& callback) override; + int32_t UnRegisterAppPermStateChangeCallback(const sptr& callback) override; AccessTokenID GetNativeTokenId(const std::string& processName) override; int32_t InitUserPolicy(const std::vector& userList, const std::vector& permList) override; int32_t UpdateUserPolicy(const std::vector& userList) override; diff --git a/interfaces/kits/napi/accesstoken/include/napi_atmanager.h b/interfaces/kits/napi/accesstoken/include/napi_atmanager.h index daff7e4df..e37798e8c 100644 --- a/interfaces/kits/napi/accesstoken/include/napi_atmanager.h +++ b/interfaces/kits/napi/accesstoken/include/napi_atmanager.h @@ -142,8 +142,10 @@ private: static void CreateObjects(napi_env env, napi_value exports); static bool FillPermStateChangeInfo(const napi_env env, const napi_value* argv, const std::string& type, const napi_value thisVar, RegisterPermStateChangeInfo& registerPermStateChangeInfo); + static bool FillAppPermStateChangeInfo(const napi_env env, const napi_value* argv, const std::string& type, + const napi_value thisVar, RegisterPermStateChangeInfo& registerPermStateChangeInfo); static bool ParseInputToRegister(const napi_env env, const napi_callback_info cbInfo, - RegisterPermStateChangeInfo& registerPermStateChangeInfo); + RegisterPermStateChangeInfo& registerPermStateChangeInfo, bool& isSystemApi); static napi_value RegisterPermStateChangeCallback(napi_env env, napi_callback_info cbInfo); static bool IsExistRegister(const napi_env env, const RegisterPermStateChangeInfo* registerPermStateChangeInfo); static bool ParseInputToUnregister(const napi_env env, napi_callback_info cbInfo, diff --git a/interfaces/kits/napi/accesstoken/src/napi_atmanager.cpp b/interfaces/kits/napi/accesstoken/src/napi_atmanager.cpp index 134967a00..fb80d3233 100644 --- a/interfaces/kits/napi/accesstoken/src/napi_atmanager.cpp +++ b/interfaces/kits/napi/accesstoken/src/napi_atmanager.cpp @@ -1124,6 +1124,56 @@ napi_value NapiAtManager::GetPermissionRequestToggleStatus(napi_env env, napi_ca return result; } +bool NapiAtManager::FillAppPermStateChangeInfo(const napi_env env, const napi_value* argv, const std::string& type, + const napi_value thisVar, RegisterPermStateChangeInfo& registerPermStateChangeInfo) +{ + static uint64_t selfTokenId = GetSelfTokenID(); + PermStateChangeScope scopeInfo; + std::string errMsg; + napi_ref callback = nullptr; + + scopeInfo.tokenIDs = {selfTokenId}; + // 1: the second parameter of argv + if (!ParseStringArray(env, argv[1], scopeInfo.permList)) { + errMsg = GetParamErrorMsg("tokenIDList", "Array"); + napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); + return false; + } + // 2: the third parameter of argv + if (!ParseCallback(env, argv[2], callback)) { + errMsg = GetParamErrorMsg("tokenIDList", "Callback"); + napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); + return false; + } + std::sort(scopeInfo.tokenIDs.begin(), scopeInfo.tokenIDs.end()); + std::sort(scopeInfo.permList.begin(), scopeInfo.permList.end()); + registerPermStateChangeInfo.env = env; + registerPermStateChangeInfo.callbackRef = callback; + registerPermStateChangeInfo.permStateChangeType = type; + registerPermStateChangeInfo.subscriber = std::make_shared(scopeInfo); + registerPermStateChangeInfo.subscriber->SetEnv(env); + registerPermStateChangeInfo.subscriber->SetCallbackRef(callback); + registerPermStateChangeInfo.threadId_ = std::this_thread::get_id(); + std::shared_ptr *subscriber = + new (std::nothrow) std::shared_ptr( + registerPermStateChangeInfo.subscriber); + if (subscriber == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to create subscriber"); + return false; + } + napi_wrap(env, thisVar, reinterpret_cast(subscriber), [](napi_env nev, void *data, void *hint) { + ACCESSTOKEN_LOG_DEBUG(LABEL, "RegisterPermStateChangeScopePtr delete"); + std::shared_ptr* subscriber = + static_cast*>(data); + if (subscriber != nullptr && *subscriber != nullptr) { + (*subscriber)->SetValid(false); + delete subscriber; + } + }, nullptr, nullptr); + + return true; +} + bool NapiAtManager::FillPermStateChangeInfo(const napi_env env, const napi_value* argv, const std::string& type, const napi_value thisVar, RegisterPermStateChangeInfo& registerPermStateChangeInfo) { @@ -1179,13 +1229,13 @@ bool NapiAtManager::FillPermStateChangeInfo(const napi_env env, const napi_value } bool NapiAtManager::ParseInputToRegister(const napi_env env, const napi_callback_info cbInfo, - RegisterPermStateChangeInfo& registerPermStateChangeInfo) + RegisterPermStateChangeInfo& registerPermStateChangeInfo, bool& isSystemApi) { size_t argc = NapiContextCommon::MAX_PARAMS_FOUR; napi_value argv[NapiContextCommon::MAX_PARAMS_FOUR] = {nullptr}; napi_value thisVar = nullptr; NAPI_CALL_BASE(env, napi_get_cb_info(env, cbInfo, &argc, argv, &thisVar, nullptr), false); - if (argc < NapiContextCommon::MAX_PARAMS_FOUR) { + if (argc < NapiContextCommon::MAX_PARAMS_THREE) { napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, "Parameter is missing.")); return false; } @@ -1206,10 +1256,25 @@ bool NapiAtManager::ParseInputToRegister(const napi_env env, const napi_callback napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); return false; } - if (!FillPermStateChangeInfo(env, argv, type, thisVar, registerPermStateChangeInfo)) { - return false; + if (type == "selfPermissionStateChange") { + if (argc < NapiContextCommon::MAX_PARAMS_THREE) { + napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, "Parameter is missing.")); + return false; + } + if (!FillAppPermStateChangeInfo(env, argv, type, thisVar, registerPermStateChangeInfo)) { + return false; + } + } + else if (type == "permissionStateChange") { + if (argc < NapiContextCommon::MAX_PARAMS_FOUR) { + napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, "Parameter is missing.")); + return false; + } + isSystemApi = true; + if (!FillPermStateChangeInfo(env, argv, type, thisVar, registerPermStateChangeInfo)) { + return false; + } } - return true; } @@ -1221,8 +1286,9 @@ napi_value NapiAtManager::RegisterPermStateChangeCallback(napi_env env, napi_cal ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for subscribeCBInfo!"); return nullptr; } + bool isSystemApi = false; std::unique_ptr callbackPtr {registerPermStateChangeInfo}; - if (!ParseInputToRegister(env, cbInfo, *registerPermStateChangeInfo)) { + if (!ParseInputToRegister(env, cbInfo, *registerPermStateChangeInfo, isSystemApi)) { return nullptr; } if (IsExistRegister(env, registerPermStateChangeInfo)) { @@ -1231,7 +1297,13 @@ napi_value NapiAtManager::RegisterPermStateChangeCallback(napi_env env, napi_cal NAPI_CALL(env, napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_INVALID, errMsg))); return nullptr; } - int32_t result = AccessTokenKit::RegisterPermStateChangeCallback(registerPermStateChangeInfo->subscriber); + int32_t result; + if (isSystemApi) { + result = AccessTokenKit::RegisterPermStateChangeCallback(registerPermStateChangeInfo->subscriber); + } + else{ + result = AccessTokenKit::RegisterAppPermStateChangeCallback(registerPermStateChangeInfo->subscriber); + } if (result != RET_SUCCESS) { ACCESSTOKEN_LOG_ERROR(LABEL, "RegisterPermStateChangeCallback failed"); registerPermStateChangeInfo->errCode = result; @@ -1263,33 +1335,43 @@ bool NapiAtManager::ParseInputToUnregister(const napi_env env, napi_callback_inf return false; } // 1: off required minnum argc - if (argc < NapiContextCommon::MAX_PARAMS_FOUR - 1) { + if (argc < NapiContextCommon::MAX_PARAMS_THREE - 1) { napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, "Parameter is missing.")); return false; } // 0: the first parameter of argv std::string type; if (!ParseString(env, argv[0], type)) { - errMsg = GetParamErrorMsg("type", "permissionStateChange"); + errMsg = GetParamErrorMsg("type", "permissionStateChange or selfPermissionStateChange"); napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); return false; } + int i = 1; PermStateChangeScope scopeInfo; - // 1: the second parameter of argv - if (!ParseAccessTokenIDArray(env, argv[1], scopeInfo.tokenIDs)) { - errMsg = GetParamErrorMsg("tokenIDList", "Array"); - napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); - return false; + if (type == "permissionStateChange") { + // 1: the second parameter of argv + if (!ParseAccessTokenIDArray(env, argv[1], scopeInfo.tokenIDs)) { + errMsg = GetParamErrorMsg("tokenIDList", "Array"); + napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); + return false; + } + ++i; + } + else if (type == "selfPermissionStateChange") { + static uint64_t selfTokenId = GetSelfTokenID(); + scopeInfo.tokenIDs = {selfTokenId}; } // 2: the third parameter of argv - if (!ParseStringArray(env, argv[2], scopeInfo.permList)) { + if (!ParseStringArray(env, argv[i], scopeInfo.permList)) { errMsg = GetParamErrorMsg("permissionNameList", "Array"); napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); return false; } - if (argc == NapiContextCommon::MAX_PARAMS_FOUR) { + ++i; + if ((type == "permissionStateChange" && argc == NapiContextCommon::MAX_PARAMS_FOUR) || + (type == "selfPermissionStateChange" && argc == NapiContextCommon::MAX_PARAMS_THREE)) { // 3: the fourth parameter of argv - if (!ParseCallback(env, argv[3], callback)) { + if (!ParseCallback(env, argv[i], callback)) { errMsg = GetParamErrorMsg("callback", "Callback"); napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); return false; @@ -1329,7 +1411,13 @@ napi_value NapiAtManager::UnregisterPermStateChangeCallback(napi_env env, napi_c for (const auto& item : batchPermStateChangeRegisters) { PermStateChangeScope scopeInfo; item->subscriber->GetScope(scopeInfo); - int32_t result = AccessTokenKit::UnRegisterPermStateChangeCallback(item->subscriber); + int32_t result; + if (unregisterPermStateChangeInfo->permStateChangeType == "permissionStateChange") { + result = AccessTokenKit::UnRegisterPermStateChangeCallback(item->subscriber); + } + else { + result = AccessTokenKit::UnRegisterAppPermStateChangeCallback(item->subscriber); + } if (result == RET_SUCCESS) { DeleteRegisterFromVector(scopeInfo, env, item->callbackRef); } else { diff --git a/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_service.h b/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_service.h index 32dc820e9..d9da9209b 100644 --- a/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_service.h +++ b/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_service.h @@ -78,6 +78,9 @@ public: int32_t RegisterPermStateChangeCallback( const PermStateChangeScopeParcel& scope, const sptr& callback) override; int32_t UnRegisterPermStateChangeCallback(const sptr& callback) override; + int32_t RegisterAppPermStateChangeCallback( + const PermStateChangeScopeParcel& scope, const sptr& callback) override; + int32_t UnRegisterAppPermStateChangeCallback(const sptr& callback) override; #ifndef ATM_BUILD_VARIANT_USER_ENABLE int32_t ReloadNativeTokenInfo() override; #endif diff --git a/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_stub.h b/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_stub.h index 1ae74837c..e40010c80 100644 --- a/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_stub.h +++ b/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_stub.h @@ -59,6 +59,8 @@ private: void GetTokenTypeInner(MessageParcel& data, MessageParcel& reply); void RegisterPermStateChangeCallbackInner(MessageParcel& data, MessageParcel& reply); void UnRegisterPermStateChangeCallbackInner(MessageParcel& data, MessageParcel& reply); + void RegisterAppPermStateChangeCallbackInner(MessageParcel& data, MessageParcel& reply); + void UnRegisterAppPermStateChangeCallbackInner(MessageParcel& data, MessageParcel& reply); #ifndef ATM_BUILD_VARIANT_USER_ENABLE void ReloadNativeTokenInfoInner(MessageParcel& data, MessageParcel& reply); void DumpPermDefInfoInner(MessageParcel& data, MessageParcel& reply); diff --git a/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_service.cpp b/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_service.cpp index ee8766bf8..7f98489ed 100644 --- a/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_service.cpp +++ b/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_service.cpp @@ -314,6 +314,17 @@ int32_t AccessTokenManagerService::UnRegisterPermStateChangeCallback(const sptr< return PermissionManager::GetInstance().RemovePermStateChangeCallback(callback); } +int32_t AccessTokenManagerService::RegisterAppPermStateChangeCallback( + const PermStateChangeScopeParcel& scope, const sptr& callback) +{ + return PermissionManager::GetInstance().AddPermStateChangeCallback(scope.scope, callback); +} + +int32_t AccessTokenManagerService::UnRegisterAppPermStateChangeCallback(const sptr& callback) +{ + return PermissionManager::GetInstance().RemovePermStateChangeCallback(callback); +} + AccessTokenIDEx AccessTokenManagerService::AllocHapToken(const HapInfoParcel& info, const HapPolicyParcel& policy) { ACCESSTOKEN_LOG_INFO(LABEL, "BundleName: %{public}s", info.hapInfoParameter.bundleName.c_str()); diff --git a/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_stub.cpp b/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_stub.cpp index d65c94718..f19cf110a 100644 --- a/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_stub.cpp +++ b/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_stub.cpp @@ -625,6 +625,46 @@ void AccessTokenManagerStub::UnRegisterPermStateChangeCallbackInner(MessageParce IF_FALSE_PRINT_LOG(LABEL, reply.WriteInt32(result), "WriteInt32 failed."); } +void AccessTokenManagerStub::RegisterAppPermStateChangeCallbackInner(MessageParcel& data, MessageParcel& reply) +{ + uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID(); + if (this->GetTokenType(callingTokenID) != TOKEN_HAP) { + IF_FALSE_PRINT_LOG(LABEL, reply.WriteInt32(AccessTokenError::ERR_TOKEN_INVALID), "WriteInt32 failed."); + return; + } + sptr scopeParcel = data.ReadParcelable(); + if (scopeParcel == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Read scopeParcel fail"); + IF_FALSE_PRINT_LOG(LABEL, reply.WriteInt32(AccessTokenError::ERR_READ_PARCEL_FAILED), "WriteInt32 failed."); + return; + } + sptr callback = data.ReadRemoteObject(); + if (callback == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Read callback fail"); + IF_FALSE_PRINT_LOG(LABEL, reply.WriteInt32(AccessTokenError::ERR_READ_PARCEL_FAILED), "WriteInt32 failed."); + return; + } + int32_t result = this->RegisterAppPermStateChangeCallback(*scopeParcel, callback); + IF_FALSE_PRINT_LOG(LABEL, reply.WriteInt32(result), "WriteInt32 failed."); +} + +void AccessTokenManagerStub::UnRegisterAppPermStateChangeCallbackInner(MessageParcel& data, MessageParcel& reply) +{ + uint32_t callingToken = IPCSkeleton::GetCallingTokenID(); + if (this->GetTokenType(callingToken) != TOKEN_HAP) { + IF_FALSE_PRINT_LOG(LABEL, reply.WriteInt32(AccessTokenError::ERR_TOKEN_INVALID), "WriteInt32 failed."); + return; + } + sptr callback = data.ReadRemoteObject(); + if (callback == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Read callback fail"); + IF_FALSE_PRINT_LOG(LABEL, reply.WriteInt32(AccessTokenError::ERR_READ_PARCEL_FAILED), "WriteInt32 failed."); + return; + } + int32_t result = this->UnRegisterPermStateChangeCallback(callback); + IF_FALSE_PRINT_LOG(LABEL, reply.WriteInt32(result), "WriteInt32 failed."); +} + #ifndef ATM_BUILD_VARIANT_USER_ENABLE void AccessTokenManagerStub::ReloadNativeTokenInfoInner(MessageParcel& data, MessageParcel& reply) { @@ -1055,6 +1095,12 @@ void AccessTokenManagerStub::SetPermissionOpFuncInMap() &AccessTokenManagerStub::SetPermissionRequestToggleStatusInner; requestFuncMap_[static_cast(AccessTokenInterfaceCode::GET_PERMISSION_REQUEST_TOGGLE_STATUS)] = &AccessTokenManagerStub::GetPermissionRequestToggleStatusInner; + requestFuncMap_[ + static_cast(AccessTokenInterfaceCode::REGISTER_APP_PERM_STATE_CHANGE_CALLBACK)] = + &AccessTokenManagerStub::RegisterAppPermStateChangeCallbackInner; + requestFuncMap_[ + static_cast(AccessTokenInterfaceCode::UNREGISTER_APP_PERM_STATE_CHANGE_CALLBACK)] = + &AccessTokenManagerStub::UnRegisterAppPermStateChangeCallbackInner; } AccessTokenManagerStub::AccessTokenManagerStub() -- Gitee