From 228410c50f2588fb0f697be70a530c6636921fee Mon Sep 17 00:00:00 2001 From: chennian Date: Sat, 21 Jun 2025 15:02:35 +0800 Subject: [PATCH] =?UTF-8?q?=E6=96=B0=E5=A2=9EgetPermissionUsedRecord?= =?UTF-8?q?=E9=80=82=E9=85=8Darkts1.2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: chennian Change-Id: Ia50e4be1451232070a23880b44823627b53324bc --- .../src/ani_ability_access_ctrl.cpp | 20 +- .../ani_request_global_switch_on_setting.cpp | 4 +- .../src/ani_request_permission.cpp | 36 ++- .../src/ani_request_permission_on_setting.cpp | 8 +- frameworks/ets/ani/common/include/ani_utils.h | 32 +-- frameworks/ets/ani/common/src/ani_utils.cpp | 216 ++++++++-------- .../ani/privacy/ets/@ohos.privacyManager.ets | 6 +- .../ets/ani/privacy/src/privacy_manager.cpp | 233 ++++++++---------- 8 files changed, 244 insertions(+), 311 deletions(-) diff --git a/frameworks/ets/ani/accesstoken/src/ani_ability_access_ctrl.cpp b/frameworks/ets/ani/accesstoken/src/ani_ability_access_ctrl.cpp index 95a56c4fd..d15690553 100644 --- a/frameworks/ets/ani/accesstoken/src/ani_ability_access_ctrl.cpp +++ b/frameworks/ets/ani/accesstoken/src/ani_ability_access_ctrl.cpp @@ -136,7 +136,7 @@ static ani_int CheckAccessTokenExecute([[maybe_unused]] ani_env* env, [[maybe_un return AccessToken::PermissionState::PERMISSION_DENIED; } AccessTokenID tokenID = static_cast(aniTokenID); - std::string permissionName = ANIStringToStdString(env, static_cast(aniPermission)); + std::string permissionName = ParseAniString(env, static_cast(aniPermission)); if ((!BusinessErrorAni::ValidateTokenIDdWithThrowError(env, tokenID)) || (!BusinessErrorAni::ValidatePermissionWithThrowError(env, permissionName))) { ACCESSTOKEN_LOG_ERROR(LABEL, "TokenId(%{public}u) or Permission(%{public}s) is invalid.", @@ -169,7 +169,7 @@ static void GrantUserGrantedPermissionExecute([[maybe_unused]] ani_env *env, [[m return; } AccessTokenID tokenID = static_cast(aniTokenID); - std::string permissionName = ANIStringToStdString(env, static_cast(aniPermission)); + std::string permissionName = ParseAniString(env, static_cast(aniPermission)); uint32_t permissionFlags = static_cast(aniFlags); if ((!BusinessErrorAni::ValidateTokenIDdWithThrowError(env, tokenID)) || (!BusinessErrorAni::ValidatePermissionWithThrowError(env, permissionName)) || @@ -203,7 +203,7 @@ static void RevokeUserGrantedPermissionExecute([[maybe_unused]] ani_env* env, return; } AccessTokenID tokenID = static_cast(aniTokenID); - std::string permissionName = ANIStringToStdString(env, static_cast(aniPermission)); + std::string permissionName = ParseAniString(env, static_cast(aniPermission)); uint32_t permissionFlags = static_cast(aniFlags); if ((!BusinessErrorAni::ValidateTokenIDdWithThrowError(env, tokenID)) || (!BusinessErrorAni::ValidatePermissionWithThrowError(env, permissionName)) || @@ -259,11 +259,7 @@ static ani_ref GetPermissionsStatusExecute([[maybe_unused]] ani_env* env, ACCESSTOKEN_LOG_ERROR(LABEL, "TokenId(%{public}u) is invalid.", tokenID); return nullptr; } - std::vector permissionList; - if (!AniParseStringArray(env, aniPermissionList, permissionList)) { - return nullptr; - } - + std::vector permissionList = ParseAniStringVector(env, aniPermissionList); if (permissionList.empty()) { BusinessErrorAni::ThrowError( env, STS_ERROR_INNER, GetErrorMessage(STS_ERROR_INNER, "The permissionList is empty.")); @@ -290,7 +286,7 @@ static ani_ref GetPermissionsStatusExecute([[maybe_unused]] ani_env* env, permissionQueryResults.emplace_back(permState.state); } - return ConvertAniArrayInt(env, permissionQueryResults); + return CreateAniArrayInt(env, permissionQueryResults); } static ani_int GetPermissionFlagsExecute([[maybe_unused]] ani_env* env, @@ -302,7 +298,7 @@ static ani_int GetPermissionFlagsExecute([[maybe_unused]] ani_env* env, return flag; } AccessTokenID tokenID = static_cast(aniTokenID); - std::string permissionName = ANIStringToStdString(env, static_cast(aniPermissionName)); + std::string permissionName = ParseAniString(env, static_cast(aniPermissionName)); if ((!BusinessErrorAni::ValidateTokenIDdWithThrowError(env, tokenID)) || (!BusinessErrorAni::ValidatePermissionWithThrowError(env, permissionName))) { ACCESSTOKEN_LOG_ERROR(LABEL, "TokenId(%{public}u) or Permission(%{public}s) is invalid.", @@ -327,7 +323,7 @@ static void SetPermissionRequestToggleStatusExecute([[maybe_unused]] ani_env* en ACCESSTOKEN_LOG_ERROR(LABEL, "Env is null"); return; } - std::string permissionName = ANIStringToStdString(env, static_cast(aniPermissionName)); + std::string permissionName = ParseAniString(env, static_cast(aniPermissionName)); if (!BusinessErrorAni::ValidatePermissionWithThrowError(env, permissionName)) { ACCESSTOKEN_LOG_ERROR(LABEL, "Permission(%{public}s) is invalid.", permissionName.c_str()); return; @@ -348,7 +344,7 @@ static ani_int GetPermissionRequestToggleStatusExecute([[maybe_unused]] ani_env* ACCESSTOKEN_LOG_ERROR(LABEL, "Env is null"); return flag; } - std::string permissionName = ANIStringToStdString(env, static_cast(aniPermissionName)); + std::string permissionName = ParseAniString(env, static_cast(aniPermissionName)); if (!BusinessErrorAni::ValidatePermissionWithThrowError(env, permissionName)) { ACCESSTOKEN_LOG_ERROR(LABEL, "Permission(%{public}s) is invalid.", permissionName.c_str()); return flag; diff --git a/frameworks/ets/ani/accesstoken/src/ani_request_global_switch_on_setting.cpp b/frameworks/ets/ani/accesstoken/src/ani_request_global_switch_on_setting.cpp index bf765c1bd..24dd8438a 100644 --- a/frameworks/ets/ani/accesstoken/src/ani_request_global_switch_on_setting.cpp +++ b/frameworks/ets/ani/accesstoken/src/ani_request_global_switch_on_setting.cpp @@ -171,7 +171,7 @@ static void GlobalSwitchResultsCallbackUI(bool switchStatus, std::shared_ptrresult.errorCode); ani_object error = BusinessErrorAni::CreateError(env, stsCode, GetErrorMessage(stsCode, data->result.errorMsg)); ExecuteAsyncCallback( - env, reinterpret_cast(data->callbackRef), error, CreateBoolean(env, data->switchStatus)); + env, reinterpret_cast(data->callbackRef), error, CreateAniBoolean(env, data->switchStatus)); if (!isSameThread && data->vm->DetachCurrentThread() != ANI_OK) { ACCESSTOKEN_LOG_ERROR(LABEL, "DetachCurrentThread failed!"); @@ -483,7 +483,7 @@ void RequestGlobalSwitchExecute([[maybe_unused]] ani_env* env, return; } - ani_object result = CreateBoolean(env, false); + ani_object result = CreateAniBoolean(env, false); static AccessTokenID selfTokenID = static_cast(GetSelfTokenID()); if (selfTokenID != asyncContext->tokenId) { ACCESSTOKEN_LOG_ERROR(LABEL, "The context tokenID %{public}d is not same with selfTokenID %{public}d.", diff --git a/frameworks/ets/ani/accesstoken/src/ani_request_permission.cpp b/frameworks/ets/ani/accesstoken/src/ani_request_permission.cpp index 451a5e6ba..2e796d9ac 100644 --- a/frameworks/ets/ani/accesstoken/src/ani_request_permission.cpp +++ b/frameworks/ets/ani/accesstoken/src/ani_request_permission.cpp @@ -110,19 +110,19 @@ static ani_object WrapResult(ani_env* env, std::shared_ptr& return nullptr; } auto state = asyncContext->needDynamicRequest ? asyncContext->grantResults : asyncContext->permissionsState; - ani_ref strPermissions = ConvertAniArrayString(env, asyncContext->permissionList); - ani_ref intAuthResults = ConvertAniArrayInt(env, state); - ani_ref boolDialogShownResults = ConvertAniArrayBool(env, asyncContext->dialogShownResults); - ani_ref intPermissionQueryResults = ConvertAniArrayInt(env, asyncContext->permissionQueryResults); - if (strPermissions == nullptr || intAuthResults == nullptr || boolDialogShownResults == nullptr || - intPermissionQueryResults == nullptr) { + ani_ref aniPermissions = CreateAniArrayString(env, asyncContext->permissionList); + ani_ref aniAuthResults = CreateAniArrayInt(env, state); + ani_ref aniDialogShownResults = CreateAniArrayBool(env, asyncContext->dialogShownResults); + ani_ref aniPermissionQueryResults = CreateAniArrayInt(env, asyncContext->permissionQueryResults); + if (aniPermissions == nullptr || aniAuthResults == nullptr || aniDialogShownResults == nullptr || + aniPermissionQueryResults == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "1111111111111111"); return nullptr; } - if (!CallSetter(env, cls, aObject, SETTER_METHOD_NAME(permissions), strPermissions) || - !CallSetter(env, cls, aObject, SETTER_METHOD_NAME(authResults), intAuthResults) || - !CallSetter(env, cls, aObject, SETTER_METHOD_NAME(dialogShownResults), boolDialogShownResults) || - !CallSetter(env, cls, aObject, SETTER_METHOD_NAME(errorReasons), intPermissionQueryResults)) { + if (!CallSetter(env, cls, aObject, SETTER_METHOD_NAME(permissions), aniPermissions) || + !CallSetter(env, cls, aObject, SETTER_METHOD_NAME(authResults), aniAuthResults) || + !CallSetter(env, cls, aObject, SETTER_METHOD_NAME(dialogShownResults), aniDialogShownResults) || + !CallSetter(env, cls, aObject, SETTER_METHOD_NAME(errorReasons), aniPermissionQueryResults)) { ACCESSTOKEN_LOG_ERROR(LABEL, "333333333333"); return nullptr; } @@ -413,7 +413,7 @@ static void RequestPermissionsFromUserProcess(std::shared_ptr& asyncContext) { ani_vm* vm; @@ -434,11 +434,7 @@ static bool ParseRequestPermissionFromUser(ani_env* env, ani_object aniContext, GetParamErrorMsg("context", "UIAbility or UIExtension Context")); return false; } - if (!AniParaseArrayString(env, nullptr, permissionList, asyncContext->permissionList)) { - BusinessErrorAni::ThrowParameterTypeError(env, STS_ERROR_PARAM_ILLEGAL, - GetParamErrorMsg("permissionList", "Array")); - return false; - } + asyncContext->permissionList = ParseAniStringVector(env, aniPermissionList); if (!AniParseCallback(env, reinterpret_cast(callback), asyncContext->callbackRef)) { return false; } @@ -449,14 +445,14 @@ static bool ParseRequestPermissionFromUser(ani_env* env, ani_object aniContext, } void RequestPermissionsFromUserExecute([[maybe_unused]] ani_env* env, [[maybe_unused]] ani_object object, - ani_object aniContext, ani_array_ref permissionList, ani_object callback) + ani_object aniContext, ani_array_ref aniPermissionList, ani_object callback) { - if (env == nullptr || permissionList == nullptr || callback == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Parenv or permissionList or callback is null."); + if (env == nullptr || aniPermissionList == nullptr || callback == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Parenv or aniPermissionList or callback is null."); return; } std::shared_ptr asyncContext = std::make_shared(); - if (!ParseRequestPermissionFromUser(env, aniContext, permissionList, callback, asyncContext)) { + if (!ParseRequestPermissionFromUser(env, aniContext, aniPermissionList, callback, asyncContext)) { return; } diff --git a/frameworks/ets/ani/accesstoken/src/ani_request_permission_on_setting.cpp b/frameworks/ets/ani/accesstoken/src/ani_request_permission_on_setting.cpp index cf1397fb2..3d8dc482e 100644 --- a/frameworks/ets/ani/accesstoken/src/ani_request_permission_on_setting.cpp +++ b/frameworks/ets/ani/accesstoken/src/ani_request_permission_on_setting.cpp @@ -91,7 +91,7 @@ static ani_status GetContext( return ANI_OK; } -static bool ParseRequestPermissionOnSetting(ani_env* env, ani_object& aniContext, ani_array_ref& permissionList, +static bool ParseRequestPermissionOnSetting(ani_env* env, ani_object& aniContext, ani_array_ref& aniPermissionList, ani_object callback, std::shared_ptr& asyncContext) { ani_vm* vm; @@ -110,11 +110,7 @@ static bool ParseRequestPermissionOnSetting(ani_env* env, ani_object& aniContext GetParamErrorMsg("context", "UIAbility or UIExtension Context")); return false; } - if (!AniParaseArrayString(env, nullptr, permissionList, asyncContext->permissionList)) { - BusinessErrorAni::ThrowParameterTypeError(env, STS_ERROR_PARAM_ILLEGAL, - GetParamErrorMsg("permissionList", "Array")); - return false; - } + asyncContext->permissionList = ParseAniStringVector(env, aniPermissionList); if (!AniParseCallback(env, reinterpret_cast(callback), asyncContext->callbackRef)) { return false; } diff --git a/frameworks/ets/ani/common/include/ani_utils.h b/frameworks/ets/ani/common/include/ani_utils.h index c17665928..98a95d712 100644 --- a/frameworks/ets/ani/common/include/ani_utils.h +++ b/frameworks/ets/ani/common/include/ani_utils.h @@ -30,16 +30,10 @@ bool AniFindClass(ani_env* env, const char* classDescriptor, ani_class& out); bool AniClassFindMethod(ani_env* env, const ani_class& aniClass, const char* methodDescriptor, const char* signature, ani_method& out); bool AniClassFindField(ani_env* env, const ani_class& aniClass, const char *fieldName, ani_field& out); -bool AniFindEnum(ani_env* env, const char *enumDescriptor, ani_enum& out); -bool AniGetEnumItemByIndex(ani_env* env, const ani_enum& aniEnum, ani_size index, ani_enum_item& out); -bool AniParseString(ani_env* env, const ani_string& ani_str, std::string& out); -bool AniParseStringArray(ani_env* env, const ani_array_ref& ani_str_arr, std::vector& out); bool AniParseCallback(ani_env* env, const ani_ref& ani_callback, ani_ref& out); bool AniIsRefUndefined(ani_env* env, const ani_ref& ref); -bool AniNewString(ani_env* env, const std::string in, ani_string& out); -bool AniNewEnumIteam(ani_env* env, const char* enumDescriptor, ani_size index, ani_enum_item& out); bool AniNewClassObject(ani_env* env, const ani_class aniClass, const char* methodDescriptor, const char* signature, ani_object& out); @@ -47,21 +41,29 @@ bool AniObjectSetFieldInt(ani_env* env, const ani_class& aniClass, ani_object& a ani_int in); bool AniObjectSetFieldRef(ani_env* env, const ani_class& aniClass, ani_object& aniObject, const char* fieldName, const ani_ref& in); -bool AniObjectSetPropertyByNameInt(ani_env* env, ani_object& object, const char *propertyName, int32_t in); -bool AniObjectSetPropertyByNameRef(ani_env* env, ani_object& object, const char *propertyName, ani_ref in); + +bool SetIntProperty(ani_env* env, ani_object& object, const char *propertyName, int32_t in); +bool SetRefProperty(ani_env* env, ani_object& object, const char* propertyName, ani_ref in); +bool SetStringProperty(ani_env* env, ani_object& aniObject, const char* propertyName, const std::string& in); +bool SetEnumProperty(ani_env* env, ani_object& aniObject, const char* enumDescription, const char* propertyName, + ani_size value); +bool SetOptionalIntProperty(ani_env* env, ani_object& aniObject, const char* propertyName, const ani_int in); bool IsCurrentThread(std::thread::id threadId); bool AniIsCallbackRefEqual(ani_env* env, const ani_ref& compareRef, const ani_ref& targetRref, std::thread::id threadId, bool& isEqual); bool AniFunctionalObjectCall(ani_env *env, const ani_fn_object& fn, ani_size size, ani_ref* argv, ani_ref& result); -std::string ANIStringToStdString(ani_env* env, ani_string aniStr); -bool AniParaseArrayString([[maybe_unused]] ani_env* env, [[maybe_unused]] ani_object object, - ani_array_ref arrayObj, std::vector& permissionList); -ani_ref ConvertAniArrayBool(ani_env* env, const std::vector& cArray); -ani_ref ConvertAniArrayInt(ani_env* env, const std::vector& cArray); -ani_ref ConvertAniArrayString(ani_env* env, const std::vector& cArray); -ani_object CreateBoolean(ani_env *env, ani_boolean value); +// ani to naitive +std::string ParseAniString(ani_env* env, ani_string aniStr); +std::vector ParseAniStringVector(ani_env* env, const ani_array_ref& aniStrArr); + +// native to ani +ani_string CreateAniString(ani_env *env, const std::string& str); +ani_object CreateAniBoolean(ani_env *env, bool value); +ani_ref CreateAniArrayBool(ani_env* env, const std::vector& cArray); +ani_ref CreateAniArrayInt(ani_env* env, const std::vector& cArray); +ani_ref CreateAniArrayString(ani_env* env, const std::vector& cArray); } // namespace AccessToken } // namespace Security } // namespace OHOS diff --git a/frameworks/ets/ani/common/src/ani_utils.cpp b/frameworks/ets/ani/common/src/ani_utils.cpp index ffa8f3b69..b69fa7569 100644 --- a/frameworks/ets/ani/common/src/ani_utils.cpp +++ b/frameworks/ets/ani/common/src/ani_utils.cpp @@ -61,69 +61,27 @@ bool AniClassFindField(ani_env* env, const ani_class& aniClass, const char *fiel return true; } -bool AniFindEnum(ani_env* env, const char *enumDescriptor, ani_enum& out) -{ - if (env->FindEnum(enumDescriptor, &out) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "FindEnum failed!"); - return false; - } - return true; -} - -bool AniGetEnumItemByIndex(ani_env* env, const ani_enum& aniEnum, ani_size index, ani_enum_item& out) -{ - if (env->Enum_GetEnumItemByIndex(aniEnum, index, &out) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Enum_GetEnumItemByIndex failed!"); - return false; - } - return true; -} - - -bool AniParseString(ani_env* env, const ani_string& anistr, std::string& out) -{ - ani_size strSize; - if (env->String_GetUTF8Size(anistr, &strSize) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "String_GetUTF8Size failed!"); - return false; - } - - std::vector buffer(strSize + 1); // +1 for null terminator - char* utf8Buffer = buffer.data(); - ani_size bytesWritten = 0; - if (env->String_GetUTF8(anistr, utf8Buffer, strSize + 1, &bytesWritten) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "String_GetUTF8 failed!"); - return false; - } - if (bytesWritten == 0) { - ACCESSTOKEN_LOG_ERROR(LABEL, "String is empty!"); - return false; - } - utf8Buffer[bytesWritten] = '\0'; - - out = std::string(utf8Buffer); - return true; -} -bool AniParseStringArray(ani_env* env, const ani_array_ref& aniStrArr, std::vector& out) +std::vector ParseAniStringVector(ani_env* env, const ani_array_ref& aniStrArr) { + std::vector out; ani_size size = 0; if (env->Array_GetLength(aniStrArr, &size) != ANI_OK) { ACCESSTOKEN_LOG_ERROR(LABEL, "Array_GetLength failed!"); - return false; + return out; } for (ani_size i = 0; i < size; ++i) { ani_ref aniRef; if (env->Array_Get_Ref(aniStrArr, i, &aniRef) != ANI_OK) { ACCESSTOKEN_LOG_ERROR(LABEL, "Array_Get_Ref failed!"); - return false; + return out; } - std::string stdStr = ANIStringToStdString(env, static_cast(aniRef)); + std::string stdStr = ParseAniString(env, static_cast(aniRef)); out.emplace_back(stdStr); } - return true; + return out; } bool AniParseCallback(ani_env* env, const ani_ref& aniCallback, ani_ref& out) @@ -145,22 +103,14 @@ bool AniIsRefUndefined(ani_env* env, const ani_ref& ref) return isUnd ? true : false; } -bool AniNewString(ani_env* env, const std::string in, ani_string& out) +ani_string CreateAniString(ani_env* env, const std::string& str) { - if (env->String_NewUTF8(in.c_str(), in.size(), &out) != ANI_OK) { + ani_string aniStr = {}; + if (env->String_NewUTF8(str.c_str(), str.size(), &aniStr) != ANI_OK) { ACCESSTOKEN_LOG_ERROR(LABEL, "String_NewUTF8 failed!"); - return false; + return aniStr; } - return true; -} - -bool AniNewEnumIteam(ani_env* env, const char* enumDescriptor, ani_size index, ani_enum_item& out) -{ - ani_enum aniEnum; - if (!AniFindEnum(env, enumDescriptor, aniEnum)) { - return false; - } - return AniGetEnumItemByIndex(env, aniEnum, index, out); + return aniStr; } bool AniNewClassObject(ani_env* env, const ani_class aniClass, const char* methodDescriptor, const char* signature, @@ -208,24 +158,6 @@ bool AniObjectSetFieldRef(ani_env* env, const ani_class& aniClass, ani_object& a return true; } -bool AniObjectSetPropertyByNameInt(ani_env* env, ani_object& object, const char *propertyName, ani_int in) -{ - if (env->Object_SetPropertyByName_Int(object, propertyName, in) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Object_SetPropertyByName_Int failed!"); - return false; - } - return true; -} - -bool AniObjectSetPropertyByNameRef(ani_env* env, ani_object& object, const char *propertyName, ani_ref in) -{ - if (env->Object_SetPropertyByName_Ref(object, propertyName, in) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Object_SetPropertyByName_Ref failed!"); - return false; - } - return true; -} - bool IsCurrentThread(std::thread::id threadId) { return threadId == std::this_thread::get_id(); @@ -256,7 +188,7 @@ bool AniFunctionalObjectCall(ani_env *env, const ani_fn_object& fn, ani_size siz return true; } -std::string ANIStringToStdString(ani_env* env, ani_string aniStr) +std::string ParseAniString(ani_env* env, ani_string aniStr) { ani_size strSize; if (env->String_GetUTF8Size(aniStr, &strSize) != ANI_OK) { @@ -276,22 +208,22 @@ std::string ANIStringToStdString(ani_env* env, ani_string aniStr) return content; } -ani_ref ConvertAniArrayString(ani_env* env, const std::vector& cArray) +ani_ref CreateAniArrayString(ani_env* env, const std::vector& cArray) { ani_size length = cArray.size(); ani_array_ref aArrayRef = nullptr; ani_class aStringcls = nullptr; if (env->FindClass("Lstd/core/String;", &aStringcls) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "ConvertAniArrayString FindClass String failed"); + ACCESSTOKEN_LOG_ERROR(LABEL, "CreateAniArrayString FindClass String failed"); return nullptr; } ani_ref undefinedRef = nullptr; if (ANI_OK != env->GetUndefined(&undefinedRef)) { - ACCESSTOKEN_LOG_ERROR(LABEL, "ConvertAniArrayString GetUndefined failed"); + ACCESSTOKEN_LOG_ERROR(LABEL, "CreateAniArrayString GetUndefined failed"); return nullptr; } if (env->Array_New_Ref(aStringcls, length, undefinedRef, &aArrayRef) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "ConvertAniArrayString Array_New_Ref failed "); + ACCESSTOKEN_LOG_ERROR(LABEL, "CreateAniArrayString Array_New_Ref failed "); return nullptr; } ani_string aString = nullptr; @@ -301,18 +233,18 @@ ani_ref ConvertAniArrayString(ani_env* env, const std::vector& cArr } ani_ref aRef = nullptr; if (env->GlobalReference_Create(aArrayRef, &aRef) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "ConvertAniArrayString GlobalReference_Create failed "); + ACCESSTOKEN_LOG_ERROR(LABEL, "CreateAniArrayString GlobalReference_Create failed "); return nullptr; } return aRef; } -ani_ref ConvertAniArrayInt(ani_env* env, const std::vector& cArray) +ani_ref CreateAniArrayInt(ani_env* env, const std::vector& cArray) { ani_size length = cArray.size(); ani_array_int aArrayInt = nullptr; if (env->Array_New_Int(length, &aArrayInt) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "ConvertAniArrayInt Array_New_Int failed "); + ACCESSTOKEN_LOG_ERROR(LABEL, "CreateAniArrayInt Array_New_Int failed "); return nullptr; } for (ani_size i = 0; i < length; ++i) { @@ -320,18 +252,18 @@ ani_ref ConvertAniArrayInt(ani_env* env, const std::vector& cArray) } ani_ref aRef = nullptr; if (env->GlobalReference_Create(aArrayInt, &aRef) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "ConvertAniArrayInt GlobalReference_Create failed "); + ACCESSTOKEN_LOG_ERROR(LABEL, "CreateAniArrayInt GlobalReference_Create failed "); return nullptr; } return aRef; } -ani_ref ConvertAniArrayBool(ani_env* env, const std::vector& cArray) +ani_ref CreateAniArrayBool(ani_env* env, const std::vector& cArray) { ani_size length = cArray.size(); ani_array_boolean aArrayBool = nullptr; if (env->Array_New_Boolean(length, &aArrayBool) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "ConvertAniArrayBool Array_New_Boolean failed "); + ACCESSTOKEN_LOG_ERROR(LABEL, "CreateAniArrayBool Array_New_Boolean failed "); return nullptr; } std::vector boolArray(length); @@ -343,38 +275,13 @@ ani_ref ConvertAniArrayBool(ani_env* env, const std::vector& cArray) } ani_ref aRef = nullptr; if (env->GlobalReference_Create(aArrayBool, &aRef) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "ConvertAniArrayBool GlobalReference_Create failed "); + ACCESSTOKEN_LOG_ERROR(LABEL, "CreateAniArrayBool GlobalReference_Create failed "); return nullptr; } return aRef; } -bool AniParaseArrayString([[maybe_unused]] ani_env* env, [[maybe_unused]] ani_object object, - ani_array_ref arrayObj, std::vector& permissionList) -{ - ani_size length; - if (ANI_OK != env->Array_GetLength(arrayObj, &length)) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Array_GetLength FAILED"); - return false; - } - for (ani_size i = 0; i < length; i++) { - ani_ref stringEntryRef; - if (ANI_OK != env->Object_CallMethodByName_Ref( - arrayObj, "$_get", "I:Lstd/core/Object;", &stringEntryRef, static_cast(i))) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Object_CallMethodByName_Ref _get Failed"); - return false; - } - auto strEntryRef = ANIStringToStdString(env, static_cast(stringEntryRef)); - if (strEntryRef.empty()) { - return false; - } else { - permissionList.emplace_back(strEntryRef); - } - } - return true; -} - -ani_object CreateBoolean(ani_env *env, ani_boolean value) +ani_object CreateAniBoolean(ani_env *env, bool value) { ani_class persionCls; ani_status status = ANI_ERROR; @@ -394,6 +301,81 @@ ani_object CreateBoolean(ani_env *env, ani_boolean value) } return personInfoObj; } + +bool SetIntProperty(ani_env* env, ani_object& object, const char *propertyName, int32_t in) +{ + if (env->Object_SetPropertyByName_Int(object, propertyName, static_cast(in)) != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Object_SetPropertyByName_Int failed!"); + return false; + } + return true; +} + +bool SetRefProperty(ani_env* env, ani_object& object, const char *propertyName, ani_ref in) +{ + if (env->Object_SetPropertyByName_Ref(object, propertyName, in) != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Object_SetPropertyByName_Ref failed!"); + return false; + } + return true; +} + +bool SetOptionalIntProperty(ani_env* env, ani_object& aniObject, const char* propertyName, const ani_int in) +{ + ani_class aniClass; + const char* classDescriptor = "Lstd/core/Int;"; + if (!AniFindClass(env, classDescriptor, aniClass)) { + return false; + } + + const char* methodDescriptor = ""; // means constructor + const char* signature = "I:V"; // I:V means input is int, return is void + ani_method aniMethod; + if (!AniClassFindMethod(env, aniClass, methodDescriptor, signature, aniMethod)) { + return false; + } + + ani_object intObject; + if (env->Object_New(aniClass, aniMethod, &intObject, in) != ANI_OK) { + return false; + } + + if (!SetRefProperty(env, aniObject, propertyName, intObject)) { + return false; + } + + return true; +} + +bool SetStringProperty(ani_env* env, ani_object& aniObject, const char* propertyName, const std::string& in) +{ + ani_ref aniString = CreateAniString(env, in); + if (!SetRefProperty(env, aniObject, propertyName, aniString)) { + return false; + } + + return true; +} + +bool SetEnumProperty( + ani_env* env, ani_object& aniObject, const char* enumDescription, const char* propertyName, ani_size value) +{ + ani_enum aniEnum; + if (env->FindEnum(enumDescription, &aniEnum) != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "FindEnum failed!"); + return false; + } + ani_enum_item aniEnumItem; + if (env->Enum_GetEnumItemByIndex(aniEnum, value, &aniEnumItem) != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Enum_GetEnumItemByIndex failed!"); + return false; + } + if (!SetRefProperty(env, aniObject, propertyName, aniEnumItem)) { + return false; + } + + return true; +} } // namespace AccessToken } // namespace Security } // namespace OHOS diff --git a/frameworks/ets/ani/privacy/ets/@ohos.privacyManager.ets b/frameworks/ets/ani/privacy/ets/@ohos.privacyManager.ets index 5ddd54b01..2da458715 100644 --- a/frameworks/ets/ani/privacy/ets/@ohos.privacyManager.ets +++ b/frameworks/ets/ani/privacy/ets/@ohos.privacyManager.ets @@ -230,7 +230,7 @@ export default namespace privacyManager { resolve(e as Array); }).catch((err: Error): void => { reject(err as BusinessError); - }) + }); }); } @@ -244,7 +244,7 @@ export default namespace privacyManager { resolve(undefined); }).catch((err: Error): void => { reject(err as BusinessError); - }) + }); }); } @@ -258,7 +258,7 @@ export default namespace privacyManager { resolve(e as boolean); }).catch((err: Error): void =>{ reject(err as BusinessError); - }) + }); }); } diff --git a/frameworks/ets/ani/privacy/src/privacy_manager.cpp b/frameworks/ets/ani/privacy/src/privacy_manager.cpp index bd6409808..354221543 100644 --- a/frameworks/ets/ani/privacy/src/privacy_manager.cpp +++ b/frameworks/ets/ani/privacy/src/privacy_manager.cpp @@ -31,10 +31,6 @@ static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, SECURITY_DOMAIN std::mutex g_mutex; std::vector g_subScribers; static constexpr size_t MAX_CALLBACK_SIZE = 200; -static constexpr ani_size ACTIVE_CHANGE_TYPE_INDEX_ONE = 1; -static constexpr ani_size ACTIVE_CHANGE_TYPE_INDEX_TWO = 2; -static constexpr ani_size PERMMISSION_USED_TYPE_INDEX_ONE = 1; -static constexpr ani_size PERMMISSION_USED_TYPE_INDEX_TWO = 2; constexpr const char* ACTIVE_CHANGE_FIELD_CALLING_TOKEN_ID = "callingTokenId"; constexpr const char* ACTIVE_CHANGE_FIELD_TOKEN_ID = "tokenId"; constexpr const char* ACTIVE_CHANGE_FIELD_PERMISSION_NAME = "permissionName"; @@ -101,7 +97,7 @@ static void AddPermissionUsedRecordExecute([[maybe_unused]] ani_env* env, return; } AccessTokenID tokenID = static_cast(aniTokenID); - std::string permission = ANIStringToStdString(env, static_cast(aniPermission)); + std::string permission = ParseAniString(env, aniPermission); if ((!BusinessErrorAni::ValidateTokenIDdWithThrowError(env, tokenID)) || (!BusinessErrorAni::ValidatePermissionWithThrowError(env, permission))) { ACCESSTOKEN_LOG_ERROR(LABEL, "TokenId(%{public}u) or Permission(%{public}s) is invalid.", @@ -208,141 +204,37 @@ static bool GenerateAniClassAndObject(ani_env* env, ani_class& aniClass, ani_obj return true; } -static bool SetOptionalIntProperty(ani_env* env, ani_object& aniObject, const char* propertyName, const ani_int in) -{ - ani_class aniClass; - const char* classDescriptor = "Lstd/core/Int;"; - if (!AniFindClass(env, classDescriptor, aniClass)) { - return false; - } - - const char* methodDescriptor = ""; // means constructor - const char* signature = "I:V"; // I:V means input is int, return is void - ani_method aniMethod; - if (!AniClassFindMethod(env, aniClass, methodDescriptor, signature, aniMethod)) { - return false; - } - - ani_object intObject; - if (env->Object_New(aniClass, aniMethod, &intObject, in) != ANI_OK) { - return false; - } - - if (!AniObjectSetPropertyByNameRef(env, aniObject, propertyName, intObject)) { - return false; - } - - return true; -} - -static bool SetStringProperty(ani_env* env, ani_object& aniObject, const char* propertyName, const std::string in) -{ - ani_string aniString; - if (!AniNewString(env, in, aniString)) { - return false; - } - - if (!AniObjectSetPropertyByNameRef(env, aniObject, propertyName, aniString)) { - return false; - } - - return true; -} - -static bool SetEnumProperty(ani_env* env, ani_object& aniObject, const char* enumDescription, const char* propertyName, - ani_size index) -{ - ani_enum_item aniEnumItem; - if (!AniNewEnumIteam(env, enumDescription, index, aniEnumItem)) { - return false; - } - - if (!AniObjectSetPropertyByNameRef(env, aniObject, propertyName, aniEnumItem)) { - return false; - } - - return true; -} - -static bool TransFormActiveChangeTypeToIndex(ActiveChangeType type, ani_size& index) -{ - if (type == ActiveChangeType::PERM_INACTIVE) { - index = 0; - } else if (type == ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND) { - index = ACTIVE_CHANGE_TYPE_INDEX_ONE; - } else if (type == ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND) { - index = ACTIVE_CHANGE_TYPE_INDEX_TWO; - } else { - ACCESSTOKEN_LOG_ERROR(LABEL, "Invalid ActiveChangeType value!"); - return false; - } - return true; -} - -static bool TransFormPermissionUsedTypeToIndex(PermissionUsedType type, ani_size& index) -{ - if (type == PermissionUsedType::NORMAL_TYPE) { - index = 0; - } else if (type == PermissionUsedType::PICKER_TYPE) { - index = PERMMISSION_USED_TYPE_INDEX_ONE; - } else if (type == PermissionUsedType::SECURITY_COMPONENT_TYPE) { - index = PERMMISSION_USED_TYPE_INDEX_TWO; - } else { - ACCESSTOKEN_LOG_ERROR(LABEL, "Invalid PermissionUsedType value!"); - return false; - } - return true; -} - -static void ConvertActiveChangeResponse(ani_env* env, const ActiveChangeResponse& result, ani_object& aniObject) +static ani_object ConvertActiveChangeResponse(ani_env* env, const ActiveChangeResponse& result) { + ani_object aniObject{}; // class implements from interface should use property, independent class use field ani_class aniClass; if (!GenerateAniClassAndObject(env, aniClass, aniObject)) { - return; + return aniObject; } // set callingTokenID?: int optional parameter callingTokenID need box as a object - if (!SetOptionalIntProperty(env, aniObject, ACTIVE_CHANGE_FIELD_CALLING_TOKEN_ID, - static_cast(result.callingTokenID))) { - return; - } + SetIntProperty(env, aniObject, ACTIVE_CHANGE_FIELD_CALLING_TOKEN_ID, static_cast(result.callingTokenID)); // set tokenID: int - if (!AniObjectSetPropertyByNameInt(env, aniObject, ACTIVE_CHANGE_FIELD_TOKEN_ID, - static_cast(result.tokenID))) { - return; - } + SetIntProperty(env, aniObject, ACTIVE_CHANGE_FIELD_TOKEN_ID, static_cast(result.tokenID)); // set permissionName: string - if (!SetStringProperty(env, aniObject, ACTIVE_CHANGE_FIELD_PERMISSION_NAME, result.permissionName)) { - return; - } + SetStringProperty(env, aniObject, ACTIVE_CHANGE_FIELD_PERMISSION_NAME, result.permissionName); // set deviceId: string - if (!SetStringProperty(env, aniObject, ACTIVE_CHANGE_FIELD_DEVICE_ID, result.deviceId)) { - return; - } + SetStringProperty(env, aniObject, ACTIVE_CHANGE_FIELD_DEVICE_ID, result.deviceId); // set activeStatus: PermissionActiveStatus - ani_size index = 0; - if (!TransFormActiveChangeTypeToIndex(result.type, index)) { - return; - } const char* activeStatusDes = "L@ohos/privacyManager/privacyManager/PermissionActiveStatus;"; - if (!SetEnumProperty(env, aniObject, activeStatusDes, ACTIVE_CHANGE_FIELD_ACTIVE_STATUS, index)) { - return; - } + SetEnumProperty( + env, aniObject, activeStatusDes, ACTIVE_CHANGE_FIELD_ACTIVE_STATUS, static_cast(result.type)); // set usedType?: PermissionUsedType - index = 0; - if (!TransFormPermissionUsedTypeToIndex(result.usedType, index)) { - return; - } const char* permUsedTypeDes = "L@ohos/privacyManager/privacyManager/PermissionUsedType;"; - if (!SetEnumProperty(env, aniObject, permUsedTypeDes, ACTIVE_CHANGE_FIELD_USED_TYPE, index)) { - return; - } + SetEnumProperty( + env, aniObject, permUsedTypeDes, ACTIVE_CHANGE_FIELD_USED_TYPE, static_cast(result.usedType)); + return aniObject; } void PermActiveStatusPtr::ActiveStatusChangeCallback(ActiveChangeResponse& activeChangeResponse) @@ -366,9 +258,7 @@ void PermActiveStatusPtr::ActiveStatusChangeCallback(ActiveChangeResponse& activ return; } - ani_object aniObject; - ConvertActiveChangeResponse(env, activeChangeResponse, aniObject); - + ani_object aniObject = ConvertActiveChangeResponse(env, activeChangeResponse); std::vector args; args.emplace_back(aniObject); ani_ref result; @@ -385,13 +275,8 @@ void PermActiveStatusPtr::ActiveStatusChangeCallback(ActiveChangeResponse& activ static bool ParseInputToRegister(const ani_string& aniType, const ani_array_ref& aniArray, const ani_ref& aniCallback, RegisterPermActiveChangeContext* context, bool isReg) { - std::string type = ANIStringToStdString(context->env, static_cast(aniType)); - std::vector permList; // permissionList: the second parameter is Array - if (!AniParseStringArray(context->env, aniArray, permList)) { - BusinessErrorAni::ThrowParameterTypeError( - context->env, STS_ERROR_PARAM_INVALID, GetParamErrorMsg("permissionList", "Array")); - return false; - } + std::string type = ParseAniString(context->env, static_cast(aniType)); + std::vector permList = ParseAniStringVector(context->env, aniArray); std::sort(permList.begin(), permList.end()); bool hasCallback = true; @@ -627,7 +512,7 @@ static void StopUsingPermissionExecute( } AccessTokenID tokenID = static_cast(aniTokenID); - std::string permission = ANIStringToStdString(env, static_cast(aniPermission)); + std::string permission = ParseAniString(env, aniPermission); if ((!BusinessErrorAni::ValidateTokenIDdWithThrowError(env, tokenID)) || (!BusinessErrorAni::ValidatePermissionWithThrowError(env, permission))) { ACCESSTOKEN_LOG_ERROR(LABEL, "TokenId(%{public}u) or Permission(%{public}s) is invalid.", @@ -653,7 +538,7 @@ static void StartUsingPermissionExecute([[maybe_unused]] ani_env* env, return; } AccessTokenID tokenID = static_cast(aniTokenID); - std::string permission = ANIStringToStdString(env, static_cast(aniPermission)); + std::string permission = ParseAniString(env, aniPermission); if ((!BusinessErrorAni::ValidateTokenIDdWithThrowError(env, tokenID)) || (!BusinessErrorAni::ValidatePermissionWithThrowError(env, permission))) { ACCESSTOKEN_LOG_ERROR(LABEL, "TokenId(%{public}u) or Permission(%{public}s) is invalid.", @@ -671,14 +556,90 @@ static void StartUsingPermissionExecute([[maybe_unused]] ani_env* env, } } -static ani_object GetPermissionUsedRecordExecute([[maybe_unused]] ani_env* env, ani_object request) +static bool ParseRequest(ani_env* env, ani_object aniRequest, PermissionUsedRequest& request) +{ + ani_status status = ANI_ERROR; + ani_int aniTokenId; + if (ANI_OK != (status = env->Object_GetPropertyByName_Int(aniRequest, "tokenId", &aniTokenId))) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse tokenId fail, status : %{public}d", static_cast(status)); + return false; + } + request.tokenId = static_cast(aniTokenId); + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse tokenId: %{public}d", request.tokenId); + + ani_boolean aniIsRemote; + if (ANI_OK != (status = env->Object_GetPropertyByName_Boolean(aniRequest, "isRemote", &aniIsRemote))) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse isRemote fail, status : %{public}d", static_cast(status)); + return false; + } + request.isRemote = aniIsRemote ? true : false; + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse isRemote: %{public}d", request.isRemote); + + ani_ref aniDeviceId; + if (ANI_OK != (status = env->Object_GetPropertyByName_Ref(aniRequest, "deviceId", &aniDeviceId))) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse deviceId fail, status : %{public}d", static_cast(status)); + return false; + } + request.deviceId = ParseAniString(env, static_cast(aniDeviceId)); + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse deviceId: %{public}s", request.deviceId.c_str()); + + ani_ref aniBundleName; + if (ANI_OK != (status = env->Object_GetPropertyByName_Ref(aniRequest, "bundleName", &aniBundleName))) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse bundleName fail, status : %{public}d", static_cast(status)); + return false; + } + request.bundleName = ParseAniString(env, static_cast(aniBundleName)); + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse bundleName: %{public}s", request.bundleName.c_str()); + + ani_ref aniPermissionNames; + if (ANI_OK != (status = env->Object_GetFieldByName_Ref(aniRequest, "permissionNames", &aniPermissionNames))) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Object_GetFieldByName_Ref failed, status : %{public}d", status); + return false; + } + ani_array_ref anirefArrayPermissionList = static_cast(aniPermissionNames); + request.permissionList = ParseAniStringVector(env, anirefArrayPermissionList); + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse permissionList size: %{public}zu", request.permissionList.size()); + + if (ANI_OK != (status = env->Object_GetFieldByName_Long(aniRequest, "beginTime", &request.beginTimeMillis))) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse beginTime fail, status : %{public}d", static_cast(status)); + return false; + } + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse beginTime: %{public}lld", request.beginTimeMillis); + + if (ANI_OK != (status = env->Object_GetFieldByName_Long(aniRequest, "endTime", &request.endTimeMillis))) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse endTime fail, status : %{public}d", static_cast(status)); + return false; + } + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse endTime: %{public}lld", request.endTimeMillis); + + ani_int aniFlag; + if (ANI_OK != (status = env->Object_GetPropertyByName_Int(aniRequest, "flag", &aniFlag))) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse tokenId fail, status : %{public}d", static_cast(status)); + return false; + } + request.flag = static_cast(aniFlag); + ACCESSTOKEN_LOG_ERROR(LABEL, "Parse flag: %{public}d", request.flag); + return true; +} + +static ani_object GetPermissionUsedRecordExecute([[maybe_unused]] ani_env* env, ani_object aniRequest) { ACCESSTOKEN_LOG_INFO(LABEL, "GetPermissionUsedRecordExecute Call"); - if (env == nullptr || request == nullptr) { + if (env == nullptr || aniRequest == nullptr) { return nullptr; } - return nullptr; + PermissionUsedRequest request; + if(!ParseRequest(env, aniRequest, request)){ + return nullptr; + } + + PermissionUsedResult retResult; + int32_t errcode = PrivacyKit::GetPermissionUsedRecords(request, retResult); + if(errcode != ANI_OK){ + return nullptr; + } + return nullptr;//WrapResult(env, retResult); } static ani_ref GetPermissionUsedTypeInfosExecute([[maybe_unused]] ani_env* env, -- Gitee