diff --git a/frameworks/accesstoken/include/accesstoken_service_ipc_interface_code.h b/frameworks/accesstoken/include/accesstoken_service_ipc_interface_code.h index 5efbcf6aba0426b45795ffda95ee1ae816961541..0f1b6dda5b94b0a18d8b95616e39e63ba178954a 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 dd87188ad2d3bf2cc188b1ab4c1a7f926b3fe775..db5d63704610013747ed35a5dada2dd64d3240cc 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 ac8ad44e663390f79a81aeb5108abcf667ba2d11..285911a443f54652bbdfdae72de2edde488aaaf8 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 20fcc4f1bab03c7071c90fe9d68596aaa3fa8e5e..d2a863cd1235c3eb29a26402e12fcf19596de0da 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 986e41b5366edeac0a6bdbb1f0d0aa2e1161746a..590f15a5146d41af430f71b77421a4bb1115e97d 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 a5f21dabcf26cb0f4a44f718218553a3e046d430..ee84dcf54f953d5e733cf7d452cbfd0f303bd3d2 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 c0ca26d52b50faf35a949fcbd8f72fd1a530de00..b97a26df35dec91e452a248df21b580326e660a0 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 6d62f8ae99c0eae483a9c6b59551676fb776144b..133cd20073f6be8d07e69b9038e8f0c7c0d7c068 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 52cd5e2408bb0287500b63e833f93ae8aa7b67b9..10fc792bd7b71c45394c53818724b61f16c5d9b2 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 daff7e4df1c4b39a207ab0c72e8a099e694f8fb3..e37798e8c833868440f3886ee25f60447ecb35e8 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 134967a0036566e078f8a09df6b23d39b6c4a36f..fb80d3233db3213bf90fececd62c8859b2133b7d 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 32dc820e941ceec59cbaf638ca77f5e2ba537b5f..d9da9209b7967596ab3fdd7c5ee43458a064b57d 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 1ae74837c3f4d237c3bb1ba2fdaadf0a0495b6e4..e40010c80afe8d793c05c61f9e5c2c25e4475281 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 ee8766bf820fcacfa5be1b90cbd2303cf25a6f5c..7f98489edcfc9b1d98a70ae0b9691b8e72c24e43 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 d65c947186c854b3b95afe2c517d47effb20ef77..f19cf110a82d4672f73572300be29c4dfa737f9e 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()