From bd4e1abd20933ba6606cc851457996d408e2a00c Mon Sep 17 00:00:00 2001 From: AXYChen Date: Tue, 26 Nov 2024 22:26:47 +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: I7136b8bbc025dfdcbfd4cc45b770536d89c44947 --- .../accesstoken_service_ipc_interface_code.h | 2 + .../include/i_accesstoken_manager.h | 7 +- .../napi/accesstoken/src/napi_atmanager.cpp | 139 ++- .../accesstoken/include/access_token.h | 7 + .../accesstoken/include/accesstoken_kit.h | 14 + .../accesstoken/libaccesstoken_sdk.map | 2 + .../accesstoken/src/accesstoken_kit.cpp | 16 +- .../src/accesstoken_manager_client.cpp | 31 +- .../src/accesstoken_manager_client.h | 4 +- .../src/accesstoken_manager_proxy.cpp | 61 ++ .../src/accesstoken_manager_proxy.h | 7 +- .../src/accesstoken_kit_extension_test.cpp | 940 ++++++++++++++++++ .../napi/accesstoken/include/napi_atmanager.h | 4 + .../service/accesstoken_manager_service.h | 7 +- .../service/accesstoken_manager_stub.h | 2 + .../service/accesstoken_manager_service.cpp | 11 + .../src/service/accesstoken_manager_stub.cpp | 48 + 17 files changed, 1239 insertions(+), 63 deletions(-) diff --git a/frameworks/accesstoken/include/accesstoken_service_ipc_interface_code.h b/frameworks/accesstoken/include/accesstoken_service_ipc_interface_code.h index 3f15f41fd..6102f8bd1 100644 --- a/frameworks/accesstoken/include/accesstoken_service_ipc_interface_code.h +++ b/frameworks/accesstoken/include/accesstoken_service_ipc_interface_code.h @@ -71,6 +71,8 @@ enum class AccessTokenInterfaceCode { UPDATE_USER_POLICY, CLEAR_USER_POLICY, GET_HAP_TOKENINFO_EXT, + REGISTER_SELF_PERM_STATE_CHANGE_CALLBACK, + UNREGISTER_SELF_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 0a49f90f3..accbfb3dd 100644 --- a/frameworks/accesstoken/include/i_accesstoken_manager.h +++ b/frameworks/accesstoken/include/i_accesstoken_manager.h @@ -78,9 +78,12 @@ public: virtual int GetHapTokenInfo(AccessTokenID tokenID, HapTokenInfoParcel& hapTokenInfoRes) = 0; virtual int32_t UpdateHapToken( AccessTokenIDEx& tokenIdEx, const UpdateHapInfoParams& info, const HapPolicyParcel& policyParcel) = 0; - virtual int32_t RegisterPermStateChangeCallback( - const PermStateChangeScopeParcel& scope, const sptr& callback) = 0; + virtual int32_t RegisterPermStateChangeCallback(const PermStateChangeScopeParcel& scope, + const sptr& callback) = 0; virtual int32_t UnRegisterPermStateChangeCallback(const sptr& callback) = 0; + virtual int32_t RegisterSelfPermStateChangeCallback(const PermStateChangeScopeParcel& scope, + const sptr& callback) = 0; + virtual int32_t UnRegisterSelfPermStateChangeCallback(const sptr& callback) = 0; #ifndef ATM_BUILD_VARIANT_USER_ENABLE virtual int32_t ReloadNativeTokenInfo() = 0; #endif diff --git a/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp b/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp index 134967a00..57b9795ce 100644 --- a/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp +++ b/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp @@ -35,6 +35,11 @@ static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "AccessTokenAbilityAccessCtrl" }; static const char* PERMISSION_STATUS_CHANGE_KEY = "accesstoken.permission.change"; +static const char* REGISTER_PERMISSION_STATE_CHANGE_TYPE = "permissionStateChange"; +static const char* REGISTER_SELF_PERMISSION_STATE_CHANGE_TYPE = "selfPermissionStateChange"; +constexpr uint32_t THIRD_PARAM = 2; +constexpr uint32_t FORTH_PARAM = 3; + static void ReturnPromiseResult(napi_env env, int32_t contextResult, napi_deferred deferred, napi_value result) { if (contextResult != RET_SUCCESS) { @@ -1124,6 +1129,49 @@ napi_value NapiAtManager::GetPermissionRequestToggleStatus(napi_env env, napi_ca return result; } +bool NapiAtManager::GetPermStateChangeType(const napi_env env, const size_t argc, const napi_value* argv, + std::string& type) +{ + std::string errMsg; + if (argc == 0) { + napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, "Parameter is missing.")); + return false; + } + // 0: the first parameter of argv + if (!ParseString(env, argv[0], type)) { + errMsg = GetParamErrorMsg("type", "permissionStateChange or selfPermissionStateChange"); + napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); + return false; + } + if ((type != REGISTER_SELF_PERMISSION_STATE_CHANGE_TYPE) && (type != REGISTER_PERMISSION_STATE_CHANGE_TYPE)) { + napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, "type is invalid")); + return false; + } + return true; +} + +bool NapiAtManager::FillPermStateChangeScope(const napi_env env, const napi_value* argv, + const std::string& type, PermStateChangeScope& scopeInfo) +{ + std::string errMsg; + int index = 1; + if (type == REGISTER_PERMISSION_STATE_CHANGE_TYPE) { + if (!ParseAccessTokenIDArray(env, argv[index++], scopeInfo.tokenIDs)) { + errMsg = GetParamErrorMsg("tokenIDList", "Array"); + napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); + return false; + } + } else if (type == REGISTER_SELF_PERMISSION_STATE_CHANGE_TYPE) { + scopeInfo.tokenIDs = {GetSelfTokenID()}; + } + if (!ParseStringArray(env, argv[index++], scopeInfo.permList)) { + errMsg = GetParamErrorMsg("permissionNameList", "Array"); + napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); + return false; + } + return true; +} + bool NapiAtManager::FillPermStateChangeInfo(const napi_env env, const napi_value* argv, const std::string& type, const napi_value thisVar, RegisterPermStateChangeInfo& registerPermStateChangeInfo) { @@ -1131,42 +1179,33 @@ bool NapiAtManager::FillPermStateChangeInfo(const napi_env env, const napi_value std::string errMsg; napi_ref callback = nullptr; - // 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)); + if (!FillPermStateChangeScope(env, argv, type, scopeInfo)) { return false; } - // 2: the third parameter of argv - if (!ParseStringArray(env, argv[2], scopeInfo.permList)) { - errMsg = GetParamErrorMsg("tokenIDList", "Array"); - napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); - return false; + uint32_t index; + if (type == REGISTER_SELF_PERMISSION_STATE_CHANGE_TYPE) { + index = THIRD_PARAM; + } else { + index = FORTH_PARAM; } - // 3: the fourth parameter of argv - if (!ParseCallback(env, argv[3], callback)) { - errMsg = GetParamErrorMsg("tokenIDList", "Callback"); + if (!ParseCallback(env, argv[index], callback)) { + errMsg = GetParamErrorMsg("callback", "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) { @@ -1185,10 +1224,6 @@ bool NapiAtManager::ParseInputToRegister(const napi_env env, const napi_callback 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) { - napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, "Parameter is missing.")); - return false; - } if (thisVar == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "ThisVar is nullptr"); return false; @@ -1199,17 +1234,24 @@ bool NapiAtManager::ParseInputToRegister(const napi_env env, const napi_callback ACCESSTOKEN_LOG_ERROR(LABEL, "ThisVar is undefined"); return false; } - // 0: the first parameter of argv std::string type; - if (!ParseString(env, argv[0], type)) { - std::string errMsg = GetParamErrorMsg("type", "string"); - napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); + if (!GetPermStateChangeType(env, argc, argv, type)) { return false; } + if ((type == REGISTER_SELF_PERMISSION_STATE_CHANGE_TYPE) && (argc < NapiContextCommon::MAX_PARAMS_THREE)) { + napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, "Parameter is missing.")); + return false; + } + if ((type == REGISTER_PERMISSION_STATE_CHANGE_TYPE) && (argc < NapiContextCommon::MAX_PARAMS_FOUR)) { + napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, "Parameter is missing.")); + return false; + } + registerPermStateChangeInfo.env = env; + registerPermStateChangeInfo.permStateChangeType = type; + registerPermStateChangeInfo.threadId_ = std::this_thread::get_id(); if (!FillPermStateChangeInfo(env, argv, type, thisVar, registerPermStateChangeInfo)) { return false; } - return true; } @@ -1231,7 +1273,12 @@ 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 (registerPermStateChangeInfo->permStateChangeType == REGISTER_PERMISSION_STATE_CHANGE_TYPE) { + result = AccessTokenKit::RegisterPermStateChangeCallback(registerPermStateChangeInfo->subscriber); + } else { + result = AccessTokenKit::RegisterSelfPermStateChangeCallback(registerPermStateChangeInfo->subscriber); + } if (result != RET_SUCCESS) { ACCESSTOKEN_LOG_ERROR(LABEL, "RegisterPermStateChangeCallback failed"); registerPermStateChangeInfo->errCode = result; @@ -1263,33 +1310,30 @@ 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 == 0) { 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"); - napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); + if (!GetPermStateChangeType(env, argc, argv, type)) { return false; } - 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)); + if ((type == REGISTER_SELF_PERMISSION_STATE_CHANGE_TYPE) && (argc < NapiContextCommon::MAX_PARAMS_THREE - 1)) { + napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, "Parameter is missing.")); return false; } - // 2: the third parameter of argv - if (!ParseStringArray(env, argv[2], scopeInfo.permList)) { - errMsg = GetParamErrorMsg("permissionNameList", "Array"); - napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); + if ((type == REGISTER_PERMISSION_STATE_CHANGE_TYPE) && (argc < NapiContextCommon::MAX_PARAMS_FOUR - 1)) { + napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, "Parameter is missing.")); return false; } - if (argc == NapiContextCommon::MAX_PARAMS_FOUR) { - // 3: the fourth parameter of argv - if (!ParseCallback(env, argv[3], callback)) { + PermStateChangeScope scopeInfo; + if (!FillPermStateChangeScope(env, argv, type, scopeInfo)) { + return false; + } + if (((type == REGISTER_PERMISSION_STATE_CHANGE_TYPE) && (argc == NapiContextCommon::MAX_PARAMS_FOUR)) || + ((type == REGISTER_SELF_PERMISSION_STATE_CHANGE_TYPE) && (argc == NapiContextCommon::MAX_PARAMS_THREE))) { + int callbackIndex = (type == REGISTER_PERMISSION_STATE_CHANGE_TYPE) ? FORTH_PARAM : THIRD_PARAM; + if (!ParseCallback(env, argv[callbackIndex], callback)) { errMsg = GetParamErrorMsg("callback", "Callback"); napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)); return false; @@ -1329,7 +1373,12 @@ 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 == REGISTER_PERMISSION_STATE_CHANGE_TYPE) { + result = AccessTokenKit::UnRegisterPermStateChangeCallback(item->subscriber); + } else { + result = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(item->subscriber); + } if (result == RET_SUCCESS) { DeleteRegisterFromVector(scopeInfo, env, item->callbackRef); } else { diff --git a/interfaces/innerkits/accesstoken/include/access_token.h b/interfaces/innerkits/accesstoken/include/access_token.h index d44d6a062..448dd86b4 100644 --- a/interfaces/innerkits/accesstoken/include/access_token.h +++ b/interfaces/innerkits/accesstoken/include/access_token.h @@ -284,6 +284,13 @@ typedef enum TypeOptType { /** get toggle status */ TOGGLE_GET, } OptType; + +typedef enum RegisterPermissionChangeType { + /** system app register permissions state change info of selected haps */ + SYSTEM_REGISTER_TYPE = 0, + /** app register permissions state change info of itself */ + SELF_REGISTER_TYPE = 1, +} RegisterPermChangeType; } // namespace AccessToken } // namespace Security } // namespace OHOS diff --git a/interfaces/innerkits/accesstoken/include/accesstoken_kit.h b/interfaces/innerkits/accesstoken/include/accesstoken_kit.h index 0442d19bf..e5a4a533f 100644 --- a/interfaces/innerkits/accesstoken/include/accesstoken_kit.h +++ b/interfaces/innerkits/accesstoken/include/accesstoken_kit.h @@ -307,6 +307,20 @@ 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 RegisterSelfPermStateChangeCallback( + 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 UnRegisterSelfPermStateChangeCallback( + 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 7f35bfed9..765f788c8 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::RegisterSelfPermStateChangeCallback(std::__h::shared_ptr const&)"; + "OHOS::Security::AccessToken::AccessTokenKit::UnRegisterSelfPermStateChangeCallback(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 7feb24573..8e09b0ff5 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_kit.cpp +++ b/interfaces/innerkits/accesstoken/src/accesstoken_kit.cpp @@ -453,14 +453,26 @@ int32_t AccessTokenKit::RegisterPermStateChangeCallback( const std::shared_ptr& callback) { ACCESSTOKEN_LOG_INFO(LABEL, "Called"); - return AccessTokenManagerClient::GetInstance().RegisterPermStateChangeCallback(callback); + return AccessTokenManagerClient::GetInstance().RegisterPermStateChangeCallback(callback, SYSTEM_REGISTER_TYPE); } int32_t AccessTokenKit::UnRegisterPermStateChangeCallback( const std::shared_ptr& callback) { ACCESSTOKEN_LOG_INFO(LABEL, "Called"); - return AccessTokenManagerClient::GetInstance().UnRegisterPermStateChangeCallback(callback); + return AccessTokenManagerClient::GetInstance().UnRegisterPermStateChangeCallback(callback, SYSTEM_REGISTER_TYPE); +} + +int32_t AccessTokenKit::RegisterSelfPermStateChangeCallback( + const std::shared_ptr& callback) +{ + return AccessTokenManagerClient::GetInstance().RegisterPermStateChangeCallback(callback, SELF_REGISTER_TYPE); +} + +int32_t AccessTokenKit::UnRegisterSelfPermStateChangeCallback( + const std::shared_ptr& callback) +{ + return AccessTokenManagerClient::GetInstance().UnRegisterPermStateChangeCallback(callback, SELF_REGISTER_TYPE); } int32_t AccessTokenKit::GetHapDlpFlag(AccessTokenID tokenID) diff --git a/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.cpp b/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.cpp index 7d3ba7a82..0c78c1918 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.cpp +++ b/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.cpp @@ -308,7 +308,7 @@ int32_t AccessTokenManagerClient::CreatePermStateChangeCallback( } int32_t AccessTokenManagerClient::RegisterPermStateChangeCallback( - const std::shared_ptr& customizedCb) + const std::shared_ptr& customizedCb, RegisterPermChangeType type) { if (customizedCb == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "CustomizedCb is nullptr"); @@ -329,12 +329,23 @@ int32_t AccessTokenManagerClient::RegisterPermStateChangeCallback( 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"); + if (scopeParcel.scope.permList.size() > PERMS_LIST_SIZE_MAX) { + ACCESSTOKEN_LOG_ERROR(LABEL, "PermList scope oversize"); return AccessTokenError::ERR_PARAM_INVALID; } - result = proxy->RegisterPermStateChangeCallback(scopeParcel, callback->AsObject()); + if (type == SYSTEM_REGISTER_TYPE) { + if (scopeParcel.scope.tokenIDs.size() > TOKENIDS_LIST_SIZE_MAX) { + ACCESSTOKEN_LOG_ERROR(LABEL, "TokenIDs scope oversize"); + return AccessTokenError::ERR_PARAM_INVALID; + } + result = proxy->RegisterPermStateChangeCallback(scopeParcel, callback->AsObject()); + } else { + if (scopeParcel.scope.tokenIDs.size() != 1) { + ACCESSTOKEN_LOG_ERROR(LABEL, "TokenIDs scope invalid"); + return AccessTokenError::ERR_PARAM_INVALID; + } + result = proxy->RegisterSelfPermStateChangeCallback(scopeParcel, callback->AsObject()); + } if (result == RET_SUCCESS) { std::lock_guard lock(callbackMutex_); callbackMap_[customizedCb] = callback; @@ -343,7 +354,7 @@ int32_t AccessTokenManagerClient::RegisterPermStateChangeCallback( } int32_t AccessTokenManagerClient::UnRegisterPermStateChangeCallback( - const std::shared_ptr& customizedCb) + const std::shared_ptr& customizedCb, RegisterPermChangeType type) { auto proxy = GetProxy(); if (proxy == nullptr) { @@ -357,8 +368,12 @@ int32_t AccessTokenManagerClient::UnRegisterPermStateChangeCallback( ACCESSTOKEN_LOG_ERROR(LABEL, "GoalCallback already is not exist"); return AccessTokenError::ERR_INTERFACE_NOT_USED_TOGETHER; } - - int32_t result = proxy->UnRegisterPermStateChangeCallback(goalCallback->second->AsObject()); + int32_t result; + if (type == SYSTEM_REGISTER_TYPE) { + result = proxy->UnRegisterPermStateChangeCallback(goalCallback->second->AsObject()); + } else { + result = proxy->UnRegisterSelfPermStateChangeCallback(goalCallback->second->AsObject()); + } if (result == RET_SUCCESS) { callbackMap_.erase(goalCallback); } diff --git a/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.h b/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.h index 61ceeb353..7efeae82f 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.h +++ b/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.h @@ -80,9 +80,9 @@ public: int GetHapTokenInfoExtension(AccessTokenID tokenID, HapTokenInfoExt& info); AccessTokenID GetNativeTokenId(const std::string& processName); int32_t RegisterPermStateChangeCallback( - const std::shared_ptr& customizedCb); + const std::shared_ptr& customizedCb, RegisterPermChangeType type); int32_t UnRegisterPermStateChangeCallback( - const std::shared_ptr& customizedCb); + const std::shared_ptr& customizedCb, RegisterPermChangeType type); #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 b7685d1c8..4cd85a820 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.cpp +++ b/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.cpp @@ -579,6 +579,67 @@ 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_SELF_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::UnRegisterSelfPermStateChangeCallback(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_SELF_PERM_STATE_CHANGE_CALLBACK, data, reply)) { + return ERR_SERVICE_ABNORMAL; + } int32_t result; if (!reply.ReadInt32(result)) { diff --git a/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.h b/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.h index 88131f667..8315e840b 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.h +++ b/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.h @@ -77,9 +77,12 @@ public: #ifndef ATM_BUILD_VARIANT_USER_ENABLE int32_t ReloadNativeTokenInfo() override; #endif - int32_t RegisterPermStateChangeCallback( - const PermStateChangeScopeParcel& scope, const sptr& callback) override; + int32_t RegisterPermStateChangeCallback(const PermStateChangeScopeParcel& scope, + const sptr& callback) override; int32_t UnRegisterPermStateChangeCallback(const sptr& callback) override; + int32_t RegisterSelfPermStateChangeCallback(const PermStateChangeScopeParcel& scope, + const sptr& callback) override; + int32_t UnRegisterSelfPermStateChangeCallback(const sptr& callback) override; AccessTokenID GetNativeTokenId(const std::string& processName) override; int GetHapTokenInfoExtension(AccessTokenID tokenID, HapTokenInfoParcel& hapTokenInfoRes, std::string& appID) override; diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_extension_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_extension_test.cpp index 689a5b530..c8859b155 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_extension_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_extension_test.cpp @@ -1765,6 +1765,946 @@ HWTEST_F(AccessTokenKitExtensionTest, UnRegisterPermStateChangeCallback003, Test ASSERT_EQ(RET_SUCCESS, res); } +/** + * @tc.name: RegisterSelfPermStateChangeCallback001 + * @tc.desc: RegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback001, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(selfTokenId_); + + res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + + res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); + ASSERT_EQ(PERMISSION_GRANTED, res); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + SetSelfTokenID(tokenID); + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(selfTokenId_); + + res = AccessTokenKit::DeleteToken(tokenID); + ASSERT_EQ(RET_SUCCESS, res); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback002 + * @tc.desc: RegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback002, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static PermissionStateFull infoManagerTestStateB = { + .permissionName = "ohos.permission.GET_BUNDLE_INFO", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA, infoManagerTestStateB} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(selfTokenId_); + + res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + SetSelfTokenID(tokenID); + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(selfTokenId_); + + res = AccessTokenKit::DeleteToken(tokenID); + ASSERT_EQ(RET_SUCCESS, res); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback003 + * @tc.desc: RegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback003, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(selfTokenId_); + + res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + + res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); + ASSERT_EQ(PERMISSION_GRANTED, res); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + SetSelfTokenID(tokenID); + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(selfTokenId_); + + res = AccessTokenKit::DeleteToken(tokenID); + ASSERT_EQ(RET_SUCCESS, res); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback004 + * @tc.desc: RegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback004, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static PermissionStateFull infoManagerTestStateB = { + .permissionName = "ohos.permission.GET_BUNDLE_INFO", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA, infoManagerTestStateB} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA", "ohos.permission.GET_BUNDLE_INFO"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr)); + SetSelfTokenID(selfTokenId_); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2)); + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2)); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, "ohos.permission.GET_BUNDLE_INFO", 2)); + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RevokePermission(tokenID, "ohos.permission.GET_BUNDLE_INFO", 2)); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + SetSelfTokenID(tokenID); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr)); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback005 + * @tc.desc: RegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback005, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.INVALID"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr1 = std::make_shared(scopeInfo); + callbackPtr1->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr1); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + + scopeInfo.permList = {"ohos.permission.INVALID", "ohos.permission.CAMERA"}; + auto callbackPtr = std::make_shared(scopeInfo); + res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(selfTokenId_); + + res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + + res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); + ASSERT_EQ(PERMISSION_GRANTED, res); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + SetSelfTokenID(tokenID); + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + + res = AccessTokenKit::DeleteToken(tokenID); + ASSERT_EQ(RET_SUCCESS, res); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback006 + * @tc.desc: RegisterSelfPermStateChangeCallback with permList, whose size is 1024/1025 + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback006, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.GET_BUNDLE_INFO", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + SetSelfTokenID(tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {}; + scopeInfo.tokenIDs = {tokenID}; + for (int32_t i = 1; i <= 1025; i++) { // 1025 is a invalid size + scopeInfo.permList.emplace_back("ohos.permission.GET_BUNDLE_INFO"); + if (i == 1025) { // 1025 is a invalid size + auto callbackPtr = std::make_shared(scopeInfo); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + break; + } + auto callbackPtr = std::make_shared(scopeInfo); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + } + SetSelfTokenID(selfTokenId_); + + int32_t res = AccessTokenKit::DeleteToken(tokenID); + ASSERT_EQ(RET_SUCCESS, res); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback007 + * @tc.desc: RegisterSelfPermStateChangeCallback without set TokenID. + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback007, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + + res = AccessTokenKit::DeleteToken(tokenID); + ASSERT_EQ(RET_SUCCESS, res); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback008 + * @tc.desc: RegisterSelfPermStateChangeCallback with none or two tokenIDs. + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback008, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + HapInfoParams g_infoManagerTestInfoParms2 = { + .userID = 1, + .bundleName = "accesstoken_test_2", + .instIndex = 0, + .appIDDesc = "test2", + .apiVersion = DEFAULT_API_VERSION + }; + + AccessTokenIDEx tokenIdEx2 = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms2, + infoManagerTestPolicyPrams1); + AccessTokenID tokenID2 = tokenIdEx2.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID2); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA"}; + scopeInfo.tokenIDs = {}; + auto callbackPtr1 = std::make_shared(scopeInfo); + callbackPtr1->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr1); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + + scopeInfo.tokenIDs = {tokenID, tokenID2}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + + SetSelfTokenID(selfTokenId_); + res = AccessTokenKit::DeleteToken(tokenID); + ASSERT_EQ(RET_SUCCESS, res); + res = AccessTokenKit::DeleteToken(tokenID2); + ASSERT_EQ(RET_SUCCESS, res); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback009 + * @tc.desc: RegisterSelfPermStateChangeCallback + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback009, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {}; + scopeInfo.tokenIDs = {tokenID}; + std::vector> callbackList; + SetSelfTokenID(tokenID); + + for (int32_t i = 0; i < 200; i++) { // 200 is the max size + if (i == 200) { // 200 is the max size + auto callbackPtr = std::make_shared(scopeInfo); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(AccessTokenError::ERR_CALLBACKS_EXCEED_LIMITATION, res); + break; + } + auto callbackPtr = std::make_shared(scopeInfo); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + callbackList.emplace_back(callbackPtr); + } + for (int32_t i = 0; i < 200; i++) { // release 200 callback + auto callbackPtr = callbackList[i]; + int32_t res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + } + callbackList.clear(); + SetSelfTokenID(selfTokenId_); + + int32_t res = AccessTokenKit::DeleteToken(tokenID); + ASSERT_EQ(RET_SUCCESS, res); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback010 + * @tc.desc: RegisterSelfPermStateChangeCallback with nullptr + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback010, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(nullptr); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + SetSelfTokenID(selfTokenId_); + + res = AccessTokenKit::DeleteToken(tokenID); + ASSERT_EQ(RET_SUCCESS, res); +} + +/** + * @tc.name: UnRegisterSelfPermStateChangeCallback001 + * @tc.desc: UnRegisterSelfPermStateChangeCallback with invalid input. + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, UnRegisterSelfPermStateChangeCallback001, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(AccessTokenError::ERR_INTERFACE_NOT_USED_TOGETHER, res); + SetSelfTokenID(selfTokenId_); +} + +/** + * @tc.name: UnRegisterSelfPermStateChangeCallback002 + * @tc.desc: UnRegisterSelfPermStateChangeCallback repeatedly. + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, UnRegisterSelfPermStateChangeCallback002, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(AccessTokenError::ERR_CALLBACK_ALREADY_EXIST, res); + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(AccessTokenError::ERR_INTERFACE_NOT_USED_TOGETHER, res); + SetSelfTokenID(selfTokenId_); + + res = AccessTokenKit::DeleteToken(tokenID); + ASSERT_EQ(RET_SUCCESS, res); +} + +/** + * @tc.name: UnRegisterSelfPermStateChangeCallback003 + * @tc.desc: UnRegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, UnRegisterSelfPermStateChangeCallback003, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(selfTokenId_); + + callbackPtr->ready_ = false; + + res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + res = AccessTokenKit::DeleteToken(tokenID); + ASSERT_EQ(RET_SUCCESS, res); +} + +/** + * @tc.name: UnRegisterSelfPermStateChangeCallback004 + * @tc.desc: UnRegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, UnRegisterSelfPermStateChangeCallback004, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static PermissionStateFull infoManagerTestStateB = { + .permissionName = "ohos.permission.GET_BUNDLE_INFO", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA, infoManagerTestStateB} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(selfTokenId_); + + callbackPtr->ready_ = false; + + res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + res = AccessTokenKit::DeleteToken(tokenID); + ASSERT_EQ(RET_SUCCESS, res); +} + +/** + * @tc.name: UnRegisterSelfPermStateChangeCallback005 + * @tc.desc: UnRegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, UnRegisterSelfPermStateChangeCallback005, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(selfTokenId_); + + SetSelfTokenID(tokenID); + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(selfTokenId_); + + callbackPtr->ready_ = false; + + res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + res = AccessTokenKit::DeleteToken(tokenID); + ASSERT_EQ(RET_SUCCESS, res); +} + +/** + * @tc.name: UnRegisterSelfPermStateChangeCallback006 + * @tc.desc: UnRegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, UnRegisterSelfPermStateChangeCallback006, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static PermissionStateFull infoManagerTestStateB = { + .permissionName = "ohos.permission.GET_BUNDLE_INFO", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA, infoManagerTestStateB} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA", "ohos.permission.GET_BUNDLE_INFO"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr)); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr)); + SetSelfTokenID(selfTokenId_); + + callbackPtr->ready_ = false; + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2)); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2)); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, "ohos.permission.GET_BUNDLE_INFO", 2)); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RevokePermission(tokenID, "ohos.permission.GET_BUNDLE_INFO", 2)); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); +} + +/** + * @tc.name: UnRegisterSelfPermStateChangeCallback007 + * @tc.desc: UnRegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(AccessTokenKitExtensionTest, UnRegisterSelfPermStateChangeCallback007, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.INVALID", "ohos.permission.CAMERA"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(selfTokenId_); + + callbackPtr->ready_ = false; + + res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + res = AccessTokenKit::DeleteToken(tokenID); + ASSERT_EQ(RET_SUCCESS, res); +} + /** * @tc.name: GetVersion001 * @tc.desc: GetVersion caller is normal app. diff --git a/interfaces/kits/js/napi/accesstoken/include/napi_atmanager.h b/interfaces/kits/js/napi/accesstoken/include/napi_atmanager.h index daff7e4df..f8c671cf2 100644 --- a/interfaces/kits/js/napi/accesstoken/include/napi_atmanager.h +++ b/interfaces/kits/js/napi/accesstoken/include/napi_atmanager.h @@ -140,12 +140,16 @@ private: static void GetPermissionRequestToggleStatusComplete(napi_env env, napi_status status, void *data); static void SetNamedProperty(napi_env env, napi_value dstObj, const int32_t objValue, const char *propName); static void CreateObjects(napi_env env, napi_value exports); + static bool GetPermStateChangeType(const napi_env env, const size_t argc, const napi_value* argv, + std::string& type); static bool FillPermStateChangeInfo(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); static napi_value RegisterPermStateChangeCallback(napi_env env, napi_callback_info cbInfo); static bool IsExistRegister(const napi_env env, const RegisterPermStateChangeInfo* registerPermStateChangeInfo); + static bool FillPermStateChangeScope(const napi_env env, const napi_value* argv, + const std::string& type, PermStateChangeScope& scopeInfo); static bool ParseInputToUnregister(const napi_env env, napi_callback_info cbInfo, UnregisterPermStateChangeInfo& unregisterPermStateChangeInfo); static napi_value UnregisterPermStateChangeCallback(napi_env env, napi_callback_info cbInfo); 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 2b8ddac09..a204bc502 100644 --- a/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_service.h +++ b/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_service.h @@ -75,9 +75,12 @@ public: int GetHapTokenInfo(AccessTokenID tokenID, HapTokenInfoParcel& infoParcel) override; int32_t UpdateHapToken(AccessTokenIDEx& tokenIdEx, const UpdateHapInfoParams& info, const HapPolicyParcel& policyParcel) override; - int32_t RegisterPermStateChangeCallback( - const PermStateChangeScopeParcel& scope, const sptr& callback) override; + int32_t RegisterPermStateChangeCallback(const PermStateChangeScopeParcel& scope, + const sptr& callback) override; int32_t UnRegisterPermStateChangeCallback(const sptr& callback) override; + int32_t RegisterSelfPermStateChangeCallback(const PermStateChangeScopeParcel& scope, + const sptr& callback) override; + int32_t UnRegisterSelfPermStateChangeCallback(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 45b6ef695..aa65c49fa 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 RegisterSelfPermStateChangeCallbackInner(MessageParcel& data, MessageParcel& reply); + void UnRegisterSelfPermStateChangeCallbackInner(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 fb71e32eb..c25234e77 100644 --- a/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_service.cpp +++ b/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_service.cpp @@ -315,6 +315,17 @@ int32_t AccessTokenManagerService::UnRegisterPermStateChangeCallback(const sptr< return PermissionManager::GetInstance().RemovePermStateChangeCallback(callback); } +int32_t AccessTokenManagerService::RegisterSelfPermStateChangeCallback( + const PermStateChangeScopeParcel& scope, const sptr& callback) +{ + return PermissionManager::GetInstance().AddPermStateChangeCallback(scope.scope, callback); +} + +int32_t AccessTokenManagerService::UnRegisterSelfPermStateChangeCallback(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 70a235a1b..206263f3d 100644 --- a/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_stub.cpp +++ b/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_stub.cpp @@ -641,6 +641,48 @@ void AccessTokenManagerStub::UnRegisterPermStateChangeCallbackInner(MessageParce IF_FALSE_PRINT_LOG(LABEL, reply.WriteInt32(result), "WriteInt32 failed."); } +void AccessTokenManagerStub::RegisterSelfPermStateChangeCallbackInner(MessageParcel& data, MessageParcel& reply) +{ + uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID(); + if (this->GetTokenType(callingTokenID) != TOKEN_HAP) { + ACCESSTOKEN_LOG_ERROR(LABEL, "TokenID is not hap."); + IF_FALSE_PRINT_LOG(LABEL, reply.WriteInt32(AccessTokenError::ERR_PARAM_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->RegisterSelfPermStateChangeCallback(*scopeParcel, callback); + IF_FALSE_PRINT_LOG(LABEL, reply.WriteInt32(result), "WriteInt32 failed."); +} + +void AccessTokenManagerStub::UnRegisterSelfPermStateChangeCallbackInner(MessageParcel& data, MessageParcel& reply) +{ + uint32_t callingToken = IPCSkeleton::GetCallingTokenID(); + if (this->GetTokenType(callingToken) != TOKEN_HAP) { + ACCESSTOKEN_LOG_ERROR(LABEL, "TokenID is not hap."); + IF_FALSE_PRINT_LOG(LABEL, reply.WriteInt32(AccessTokenError::ERR_PARAM_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->UnRegisterSelfPermStateChangeCallback(callback); + IF_FALSE_PRINT_LOG(LABEL, reply.WriteInt32(result), "WriteInt32 failed."); +} + #ifndef ATM_BUILD_VARIANT_USER_ENABLE void AccessTokenManagerStub::ReloadNativeTokenInfoInner(MessageParcel& data, MessageParcel& reply) { @@ -1073,6 +1115,12 @@ void AccessTokenManagerStub::SetPermissionOpFuncInMap() &AccessTokenManagerStub::SetPermissionRequestToggleStatusInner; requestFuncMap_[static_cast(AccessTokenInterfaceCode::GET_PERMISSION_REQUEST_TOGGLE_STATUS)] = &AccessTokenManagerStub::GetPermissionRequestToggleStatusInner; + requestFuncMap_[ + static_cast(AccessTokenInterfaceCode::REGISTER_SELF_PERM_STATE_CHANGE_CALLBACK)] = + &AccessTokenManagerStub::RegisterSelfPermStateChangeCallbackInner; + requestFuncMap_[ + static_cast(AccessTokenInterfaceCode::UNREGISTER_SELF_PERM_STATE_CHANGE_CALLBACK)] = + &AccessTokenManagerStub::UnRegisterSelfPermStateChangeCallbackInner; } AccessTokenManagerStub::AccessTokenManagerStub() -- Gitee