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 95a56c4fd9a2a34ae0bff03fb5e9e5df6bb8920b..d156905533aebd5502a93afa8ad0061971b9b920 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 bf765c1bd72e44f524f6e0b93cd00e7a2c3a6203..02ced1e1890ef6be7c7a80020b9958457dbe6403 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, CreateBooleanObject(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 = CreateBooleanObject(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 451a5e6ba08241a698196a039631a2faf4abb04c..6b3e593e99aa1e61301a5d0b3b8ede715813360e 100644 --- a/frameworks/ets/ani/accesstoken/src/ani_request_permission.cpp +++ b/frameworks/ets/ani/accesstoken/src/ani_request_permission.cpp @@ -110,20 +110,18 @@ 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) { - ACCESSTOKEN_LOG_ERROR(LABEL, "1111111111111111"); + 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) { 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)) { - ACCESSTOKEN_LOG_ERROR(LABEL, "333333333333"); + 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)) { return nullptr; } return aObject; @@ -413,7 +411,7 @@ static void RequestPermissionsFromUserProcess(std::shared_ptr& asyncContext) { ani_vm* vm; @@ -434,11 +432,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 +443,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 cf1397fb2e8d2ccb59801a6971757f99677b4286..3d8dc482e85454333f582f147871cb5cb5b1b22f 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 c1766592853643e9c0a9878b81a5be8b866130b8..6a188d547b753cabd5b0b327928e19b11b321aef 100644 --- a/frameworks/ets/ani/common/include/ani_utils.h +++ b/frameworks/ets/ani/common/include/ani_utils.h @@ -25,43 +25,53 @@ namespace OHOS { namespace Security { namespace AccessToken { -bool AniFindNameSpace(ani_env* env, const char* namespaceDescriptor, ani_namespace& out); -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 AniFindNameSpace(ani_env* env, const std::string& namespaceDescriptor, ani_namespace& out); +bool AniFindClass(ani_env* env, const std::string& classDescriptor, ani_class& out); +bool AniClassFindMethod( + ani_env* env, const ani_class& aniClass, const std::string& methodDescriptor, + const std::string& signature, ani_method& out); +bool AniClassFindField(ani_env* env, const ani_class& aniClass, const std::string& fieldName, ani_field& 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); +bool GetBoolProperty(ani_env* env, const ani_object& object, const std::string& property, bool& value); +bool GetIntProperty(ani_env* env, const ani_object& object, const std::string& property, int32_t& value); +bool GetLongProperty(ani_env* env, const ani_object& object, const std::string& property, int64_t& value); +bool GetStringProperty(ani_env* env, const ani_object& object, const std::string& property, std::string& value); +bool GetEnumProperty(ani_env* env, const ani_object& object, const std::string& property, int32_t& value); +bool GetStringVecProperty( + ani_env* env, const ani_object& object, const std::string& property, std::vector& value); -bool AniObjectSetFieldInt(ani_env* env, const ani_class& aniClass, ani_object& aniObject, const char* fieldName, - 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 SetBoolProperty(ani_env* env, ani_object& object, const std::string& property, bool in); +bool SetIntProperty(ani_env* env, ani_object& object, const std::string& property, int32_t in); +bool SetLongProperty(ani_env* env, ani_object& object, const std::string& property, int64_t in); +bool SetRefProperty(ani_env* env, ani_object& object, const std::string& property, const ani_ref& in); +bool SetStringProperty(ani_env* env, ani_object& aniObject, const std::string& property, const std::string& in); +bool SetEnumProperty( + ani_env* env, ani_object& aniObject, const std::string& enumDescription, + const std::string& property, ani_size value); +bool SetOptionalIntProperty(ani_env* env, ani_object& aniObject, const std::string& property, int32_t 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 CreateIntObject(ani_env *env, int32_t value); +ani_object CreateBooleanObject(ani_env *env, bool value); +ani_object CreateClassObject(ani_env* env, const std::string& classDescriptor); +ani_object CreateArrayObject(ani_env* env, uint32_t length); + +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 ffa8f3b69dfa08975bdbee9f7521b9c05dace09b..4f9b222f588b2c79b0c009ae2f4d469948de8965 100644 --- a/frameworks/ets/ani/common/src/ani_utils.cpp +++ b/frameworks/ets/ani/common/src/ani_utils.cpp @@ -21,31 +21,31 @@ namespace Security { namespace AccessToken { namespace { static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "AccessTokenAniUtils" }; -constexpr const char* CLASSNAME_BOOLEAN = "Lstd/core/Boolean;"; } // namespace -bool AniFindNameSpace(ani_env* env, const char* namespaceDescriptor, ani_namespace& out) +bool AniFindNameSpace(ani_env* env, const std::string& namespaceDescriptor, ani_namespace& out) { - if (env->FindNamespace(namespaceDescriptor, &out) != ANI_OK) { + if (env->FindNamespace(namespaceDescriptor.c_str(), &out) != ANI_OK) { ACCESSTOKEN_LOG_ERROR(LABEL, "FindNamespace failed!"); return false; } return true; } -bool AniFindClass(ani_env* env, const char* classDescriptor, ani_class& out) +bool AniFindClass(ani_env* env, const std::string& classDescriptor, ani_class& out) { - if (env->FindClass(classDescriptor, &out) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "FindClass failed!"); + if (env->FindClass(classDescriptor.c_str(), &out) != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "FindClass(%{public}s) failed.", classDescriptor.c_str()); return false; } return true; } -bool AniClassFindMethod(ani_env* env, const ani_class& aniClass, const char* methodDescriptor, const char* signature, - ani_method& out) +bool AniClassFindMethod( + ani_env* env, const ani_class& aniClass, const std::string& methodDescriptor, + const std::string& signature, ani_method& out) { - if (env->Class_FindMethod(aniClass, methodDescriptor, signature, &out) != ANI_OK) { + if (env->Class_FindMethod(aniClass, methodDescriptor.c_str(), signature.c_str(), &out) != ANI_OK) { ACCESSTOKEN_LOG_ERROR(LABEL, "Class_FindMethod failed!"); return false; } @@ -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,85 +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 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); -} - -bool AniNewClassObject(ani_env* env, const ani_class aniClass, const char* methodDescriptor, const char* signature, - ani_object& out) -{ - ani_method aniMethod; - if (!AniClassFindMethod(env, aniClass, methodDescriptor, signature, aniMethod)) { - return false; + return aniStr; } - - if (env->Object_New(aniClass, aniMethod, &out) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Object_New failed!"); - return false; - } - return true; -} - -bool AniObjectSetFieldInt(ani_env* env, const ani_class& aniClass, ani_object& aniObject, const char* fieldName, - ani_int in) -{ - ani_field aniField; - if (!AniClassFindField(env, aniClass, fieldName, aniField)) { - return false; - } - - if (env->Object_SetField_Int(aniObject, aniField, in) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Object_SetField_Int failed!"); - return false; - } - return true; -} - -bool AniObjectSetFieldRef(ani_env* env, const ani_class& aniClass, ani_object& aniObject, const char* fieldName, - const ani_ref& in) -{ - ani_field aniField; - if (!AniClassFindField(env, aniClass, fieldName, aniField)) { - return false; - } - - if (env->Object_SetField_Ref(aniObject, aniField, in) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Object_SetField_Ref failed!"); - return false; - } - 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; + return aniStr; } bool IsCurrentThread(std::thread::id threadId) @@ -256,7 +143,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 +163,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, "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, "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, "Array_New_Ref failed."); return nullptr; } ani_string aString = nullptr; @@ -301,18 +188,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, "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, "Array_New_Int failed."); return nullptr; } for (ani_size i = 0; i < length; ++i) { @@ -320,18 +207,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, "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, "Array_New_Boolean failed."); return nullptr; } std::vector boolArray(length); @@ -343,57 +230,336 @@ 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, "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 CreateBooleanObject(ani_env *env, bool value) { ani_class persionCls; ani_status status = ANI_ERROR; - if ((status = env->FindClass(CLASSNAME_BOOLEAN, &persionCls)) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "status : %{public}d", static_cast(status)); + if ((status = env->FindClass("Lstd/core/Boolean;", &persionCls)) != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "FindClass fail, status : %{public}d.", static_cast(status)); return nullptr; } ani_method personInfoCtor; if ((status = env->Class_FindMethod(persionCls, "", "Z:V", &personInfoCtor)) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "status : %{public}d", static_cast(status)); + ACCESSTOKEN_LOG_ERROR(LABEL, "FindMethod fail, status : %{public}d.", static_cast(status)); return nullptr; } ani_object personInfoObj; if ((status = env->Object_New(persionCls, personInfoCtor, &personInfoObj, value)) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "status : %{public}d", static_cast(status)); + ACCESSTOKEN_LOG_ERROR(LABEL, "Object_New fail, status : %{public}d.", static_cast(status)); return nullptr; } return personInfoObj; } + +ani_object CreateIntObject(ani_env *env, int32_t value) +{ + ani_class persionCls; + ani_status status = ANI_ERROR; + if ((status = env->FindClass("Lstd/core/Int;", &persionCls)) != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "FindClass fail, status : %{public}d.", static_cast(status)); + return nullptr; + } + ani_method aniMethod; + if ((status = env->Class_FindMethod(persionCls, "", "I:V", &aniMethod)) != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "FindMethod fail, status : %{public}d.", static_cast(status)); + return nullptr; + } + ani_object aniObject; + if ((status = env->Object_New(persionCls, aniMethod, &aniObject, value)) != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Object_New fail, status : %{public}d.", static_cast(status)); + return nullptr; + } + return aniObject; +} + +ani_object CreateClassObject(ani_env* env, const std::string& classDescriptor) +{ + ani_class aniClass; + ani_status status = ANI_ERROR; + if ((status = env->FindClass(classDescriptor.c_str(), &aniClass)) != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "FindClass fail, status : %{public}d.", static_cast(status)); + return nullptr; + } + ani_method aniMethod; + status = env->Class_FindMethod(aniClass, "", ":V", &aniMethod); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Class_FindMethod failed, status: %{public}d!", status); + return nullptr; + } + ani_object out; + status = env->Object_New(aniClass, aniMethod, &out); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Object_New failed, status %{public}d!", status); + return nullptr; + } + return out; +} + +ani_object CreateArrayObject(ani_env* env, uint32_t length) +{ + ani_class aniClass; + if (!AniFindClass(env, "Lescompat/Array;", aniClass)) { + return nullptr; + } + ani_method aniMethod; + ani_status status = env->Class_FindMethod(aniClass, "", "I:V", &aniMethod); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "FindMethod failed, status: %{public}d!", status); + return nullptr; + } + ani_object out; + status = env->Object_New(aniClass, aniMethod, &out, length); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Object_New failed(size: %{public}d), status %{public}d!", length, status); + return nullptr; + } + return out; +} + +bool GetBoolProperty(ani_env* env, const ani_object& object, const std::string& property, bool& value) +{ + ani_ref ref; + ani_status status = env->Object_GetPropertyByName_Ref(object, property.c_str(), &ref); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Get property(%{public}s) failed, status: %{public}d!", + property.c_str(), status); + return false; + } + if (AniIsRefUndefined(env, ref)) { + return true; + } + + ani_boolean boolValue; + if (env->Object_CallMethodByName_Boolean(static_cast(ref), "unboxed", nullptr, &boolValue) != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Get bool value of property(%{public}s) failed.", property.c_str()); + return false; + } + value = static_cast(boolValue); + return true; +} + +bool GetIntProperty(ani_env* env, const ani_object& object, const std::string& property, int32_t& value) +{ + ani_ref ref; + ani_status status = env->Object_GetPropertyByName_Ref(object, property.c_str(), &ref); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Get property(%{public}s) failed, status: %{public}d.", + property.c_str(), static_cast(status)); + return false; + } + if (AniIsRefUndefined(env, ref)) { + ACCESSTOKEN_LOG_INFO(LABEL, "Property(%{public}s) is undefned!", property.c_str()); + return true; + } + + ani_int intValue; + status = env->Object_CallMethodByName_Int(static_cast(ref), "unboxed", nullptr, &intValue); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Get int value of property(%{public}s) failed, status: %{public}d.", + property.c_str(), static_cast(status)); + return false; + } + value = static_cast(intValue); + return true; +} + +bool GetLongProperty(ani_env* env, const ani_object& object, const std::string& property, int64_t& value) +{ + ani_ref ref; + ani_status status = env->Object_GetPropertyByName_Ref(object, property.c_str(), &ref); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Get property(%{public}s) failed, status: %{public}d!", + property.c_str(), status); + return false; + } + if (AniIsRefUndefined(env, ref)) { + return true; + } + + ani_long longValue; + if (env->Object_CallMethodByName_Long(static_cast(ref), "unboxed", nullptr, &longValue) != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Get int64 value of property(%{public}s) failed.", property.c_str()); + return false; + } + value = static_cast(longValue); + return true; +} + +bool GetStringProperty(ani_env* env, const ani_object& object, const std::string& property, std::string& value) +{ + ani_ref ref; + ani_status status = env->Object_GetPropertyByName_Ref(object, property.c_str(), &ref); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Get property(%{public}s) failed, status: %{public}d!", + property.c_str(), status); + return false; + } + if (AniIsRefUndefined(env, ref)) { + return true; + } + value = ParseAniString(env, static_cast(ref)); + return true; +} + +bool GetEnumProperty(ani_env* env, const ani_object& object, const std::string& property, int32_t& value) +{ + ani_ref ref; + ani_status status = env->Object_GetPropertyByName_Ref(object, property.c_str(), &ref); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Get property(%{public}s) failed, status: %{public}d!", + property.c_str(), status); + return false; + } + if (AniIsRefUndefined(env, ref)) { + return true; + } + ani_enum_item aniEnum = static_cast(ref); + ani_int aniInt; + if (env->EnumItem_GetValue_Int(aniEnum, &aniInt) != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Get enum value of property(%{public}s) failed.", property.c_str()); + return false; + } + value = static_cast(aniInt); + return true; +} + +bool GetStringVecProperty( + ani_env* env, const ani_object& object, const std::string& property, std::vector& value) +{ + ani_ref ref; + ani_status status = env->Object_GetPropertyByName_Ref(object, property.c_str(), &ref); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Get property(%{public}s) failed, status: %{public}d!", + property.c_str(), status); + return false; + } + if (AniIsRefUndefined(env, ref)) { + return true; + } + ani_array_ref anirefArray = static_cast(ref); + value = ParseAniStringVector(env, anirefArray); + return true; +} + +bool SetBoolProperty(ani_env* env, ani_object& object, const std::string& property, bool in) +{ + if ((env == nullptr) || (object == nullptr)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Input param is nullptr, property(%{public}s).", property.c_str()); + return false; + } + ani_status status = env->Object_SetPropertyByName_Boolean(object, property.c_str(), static_cast(in)); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Set property(%{public}s) failed, status: %{public}d!", + property.c_str(), status); + return false; + } + return true; +} + +bool SetIntProperty(ani_env* env, ani_object& object, const std::string& property, int32_t in) +{ + if ((env == nullptr) || (object == nullptr)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Input param is nullptr, property(%{public}s).", property.c_str()); + return false; + } + ani_status status = env->Object_SetPropertyByName_Int(object, property.c_str(), static_cast(in)); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Set property(%{public}s) failed, status: %{public}d!", + property.c_str(), status); + return false; + } + return true; +} + +bool SetLongProperty(ani_env* env, ani_object& aniObject, const std::string& property, int64_t in) +{ + if ((env == nullptr) || (aniObject == nullptr)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Input param is nullptr, property(%{public}s).", property.c_str()); + return false; + } + ani_status status = env->Object_SetPropertyByName_Long(aniObject, property.c_str(), static_cast(in)); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Set property(%{public}s) failed, status: %{public}d!", + property.c_str(), status); + return false; + } + return true; +} + +bool SetRefProperty(ani_env* env, ani_object& aniObject, const std::string& property, const ani_ref& in) +{ + if ((env == nullptr) || (aniObject == nullptr) || (in == nullptr)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Input param is nullptr, property(%{public}s).", property.c_str()); + return false; + } + ani_status status = env->Object_SetPropertyByName_Ref(aniObject, property.c_str(), in); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Set property(%{public}s) failed, status: %{public}d!", + property.c_str(), status); + return false; + } + return true; +} + +bool SetOptionalIntProperty(ani_env* env, ani_object& aniObject, const std::string& property, int32_t in) +{ + if ((env == nullptr) || (aniObject == nullptr)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Input param is nullptr, property(%{public}s).", property.c_str()); + return false; + } + ani_object intObject = CreateIntObject(env, in); + if (intObject == nullptr) { + return false; + } + + if (!SetRefProperty(env, aniObject, property.c_str(), intObject)) { + return false; + } + + return true; +} + +bool SetStringProperty(ani_env* env, ani_object& aniObject, const std::string& property, const std::string& in) +{ + if ((env == nullptr) || (aniObject == nullptr)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Input param is nullptr, property(%{public}s).", property.c_str()); + return false; + } + ani_ref aniString = static_cast(CreateAniString(env, in)); + if (!SetRefProperty(env, aniObject, property.c_str(), aniString)) { + return false; + } + return true; +} + +bool SetEnumProperty(ani_env* env, ani_object& aniObject, + const std::string& enumDescription, const std::string& property, ani_size value) +{ + if ((env == nullptr) || (aniObject == nullptr)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Input param is nullptr, property(%{public}s).", property.c_str()); + return false; + } + ani_enum aniEnum; + if (env->FindEnum(enumDescription.c_str(), &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, property.c_str(), 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 5ddd54b013558632781ac9f8b59aa6aedd64d8c3..0f2fb079bebd9c07a5c9617220c1dc67bdbd09e9 100644 --- a/frameworks/ets/ani/privacy/ets/@ohos.privacyManager.ets +++ b/frameworks/ets/ani/privacy/ets/@ohos.privacyManager.ets @@ -205,8 +205,9 @@ export default namespace privacyManager { } export function getPermissionUsedRecord(request: PermissionUsedRequest): Promise { - return new Promise( - (resolve: (data: PermissionUsedResponse) => void, reject: (error: BusinessError) => void): PermissionUsedResponse => { + return new Promise(( + resolve: (data: PermissionUsedResponse) => void, + reject: (error: BusinessError) => void): PermissionUsedResponse => { let p1 = taskpool.execute((): PermissionUsedResponse => { return getPermissionUsedRecordExecute(request); }); @@ -230,7 +231,7 @@ export default namespace privacyManager { resolve(e as Array); }).catch((err: Error): void => { reject(err as BusinessError); - }) + }); }); } @@ -244,7 +245,7 @@ export default namespace privacyManager { resolve(undefined); }).catch((err: Error): void => { reject(err as BusinessError); - }) + }); }); } @@ -258,7 +259,7 @@ export default namespace privacyManager { resolve(e as boolean); }).catch((err: Error): void =>{ reject(err as BusinessError); - }) + }); }); } @@ -347,7 +348,7 @@ export default namespace privacyManager { lockScreenStatus?: int; timestamp: long; count?: int; - accessDuration: int; + accessDuration: long; usedType?: PermissionUsedType; } @@ -356,14 +357,13 @@ export default namespace privacyManager { lockScreenStatus?: int; timestamp: long; count?: int; - accessDuration: int; + accessDuration: long; usedType?: PermissionUsedType; } interface PermissionUsedRecord { permissionName: Permissions; accessCount: int; - secAccessCount: int; rejectCount: int; lastAccessTime: long; lastRejectTime: long; @@ -375,7 +375,6 @@ export default namespace privacyManager { class PermissionUsedRecordInner implements PermissionUsedRecord { permissionName: Permissions; accessCount: int; - secAccessCount: int; rejectCount: int; lastAccessTime: long; lastRejectTime: long; @@ -389,7 +388,7 @@ export default namespace privacyManager { isRemote: boolean; deviceId: string; bundleName: string; - permissionNames: Array; + permissionRecords: Array; } class BundleUsedRecordInner implements BundleUsedRecord { @@ -397,7 +396,7 @@ export default namespace privacyManager { isRemote: boolean; deviceId: string; bundleName: string; - permissionNames: Array; + permissionRecords: Array; } export interface PermissionUsedResponse { diff --git a/frameworks/ets/ani/privacy/src/privacy_manager.cpp b/frameworks/ets/ani/privacy/src/privacy_manager.cpp index bd6409808dbf3e5de1d01ee1321ae168fffcc188..221c7e291c07b247e9d5170bc0c5ce274e2709a2 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.", @@ -109,24 +105,10 @@ static void AddPermissionUsedRecordExecute([[maybe_unused]] ani_env* env, return; } - ani_status status = ANI_ERROR; - ani_ref usedTypeRef; - if (ANI_OK != (status = env->Object_GetPropertyByName_Ref(options, "usedType", &usedTypeRef))) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Object_GetFieldByName_Ref Faild status : %{public}d", status); + int32_t usedType = 0; + if (!GetEnumProperty(env, options, "usedType", usedType)) { return; } - ani_int usedType = 0; - ani_boolean isUndefined = true; - if (ANI_OK != (status = env->Reference_IsUndefined(usedTypeRef, &isUndefined))) { - ACCESSTOKEN_LOG_ERROR(LABEL, "status : %{public}d", status); - return; - } - if (!isUndefined) { - ani_enum_item usedTypeEnum = static_cast(usedTypeRef); - if (ANI_OK != env->EnumItem_GetValue_Int(usedTypeEnum, &usedType)) { - return; - } - } AddPermParamInfo info; info.tokenId = static_cast(tokenID); info.permissionName = permission; @@ -192,157 +174,35 @@ void PermActiveStatusPtr::SetThreadId(const std::thread::id threadId) threadId_ = threadId; } -static bool GenerateAniClassAndObject(ani_env* env, ani_class& aniClass, ani_object& aniObject) -{ - const char* classDescriptor = "L@ohos/privacyManager/privacyManager/ActiveChangeResponseInner;"; - if (!AniFindClass(env, classDescriptor, aniClass)) { - return false; - } - - const char* methodDescriptor = ""; - const char* signature = nullptr; - if (!AniNewClassObject(env, aniClass, methodDescriptor, signature, aniObject)) { - return false; - } - - 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) +static ani_object ConvertActiveChangeResponse(ani_env* env, const ActiveChangeResponse& result) { - 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) -{ - // class implements from interface should use property, independent class use field - ani_class aniClass; - if (!GenerateAniClassAndObject(env, aniClass, aniObject)) { - return; + ani_object aniObject = CreateClassObject(env, "L@ohos/privacyManager/privacyManager/ActiveChangeResponseInner;"); + if (aniObject == nullptr) { + return nullptr; } // 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 +226,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 +243,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 +480,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.", @@ -640,7 +493,8 @@ static void StopUsingPermissionExecute( auto retCode = PrivacyKit::StopUsingPermission(tokenID, permission, pid); if (retCode != RET_SUCCESS) { - BusinessErrorAni::ThrowError(env, retCode, GetErrorMessage(GetStsErrorCode(retCode))); + int32_t stsCode = GetStsErrorCode(retCode); + BusinessErrorAni::ThrowError(env, stsCode, GetErrorMessage(stsCode)); } } @@ -653,7 +507,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 +525,258 @@ static void StartUsingPermissionExecute([[maybe_unused]] ani_env* env, } } -static ani_object GetPermissionUsedRecordExecute([[maybe_unused]] ani_env* env, ani_object request) +static ani_object ConvertSingelUsedRecordDetail(ani_env* env, const UsedRecordDetail& record) +{ + ani_object arrayObj = CreateClassObject(env, "L@ohos/privacyManager/privacyManager/UsedRecordDetailInner;"); + if (arrayObj == nullptr) { + return nullptr; + } + if (!SetIntProperty(env, arrayObj, "status", record.status)) { + return nullptr; + } + if (!SetOptionalIntProperty(env, arrayObj, "lockScreenStatus", record.lockScreenStatus)) { + return nullptr; + } + if (!SetLongProperty(env, arrayObj, "timestamp", record.timestamp)) { + return nullptr; + } + if (!SetLongProperty(env, arrayObj, "accessDuration", record.accessDuration)) { + return nullptr; + } + if (!SetOptionalIntProperty(env, arrayObj, "count", record.count)) { + return nullptr; + } + if (!SetEnumProperty(env, arrayObj, "L@ohos/privacyManager/privacyManager/PermissionUsedType;", "usedType", + static_cast(record.type))) { + return nullptr; + } + return arrayObj; +} + +static ani_object ConvertUsedRecordDetails(ani_env* env, const std::vector& details) +{ + ani_object arrayObj = CreateArrayObject(env, details.size()); + if (arrayObj == nullptr) { + return nullptr; + } + ani_size index = 0; + for (const auto& record: details) { + ani_ref aniRecord = ConvertSingelUsedRecordDetail(env, record); + if (aniRecord == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Null aniRecord."); + break; + } + ani_status status = env->Object_CallMethodByName_Void( + arrayObj, "$_set", "ILstd/core/Object;:V", index, aniRecord); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "status : %{public}d", status); + break; + } + ++index; + } + return arrayObj; +} + +static ani_object ConvertSinglePermissionRecord(ani_env* env, const PermissionUsedRecord& record) +{ + ani_object arrayObj = CreateClassObject(env, "L@ohos/privacyManager/privacyManager/PermissionUsedRecordInner;"); + if (arrayObj == nullptr) { + return nullptr; + } + if (!SetStringProperty(env, arrayObj, "permissionName", record.permissionName)) { + return nullptr; + } + if (!SetIntProperty(env, arrayObj, "accessCount", record.accessCount)) { + return nullptr; + } + if (!SetIntProperty(env, arrayObj, "rejectCount", record.rejectCount)) { + return nullptr; + } + if (!SetLongProperty(env, arrayObj, "lastAccessTime", record.lastAccessTime)) { + return nullptr; + } + if (!SetLongProperty(env, arrayObj, "lastRejectTime", record.lastRejectTime)) { + return nullptr; + } + if (!SetLongProperty(env, arrayObj, "lastAccessDuration", record.lastAccessDuration)) { + return nullptr; + } + if (!SetRefProperty(env, arrayObj, "accessRecords", ConvertUsedRecordDetails(env, record.accessRecords))) { + return nullptr; + } + if (!SetRefProperty(env, arrayObj, "rejectRecords", ConvertUsedRecordDetails(env, record.rejectRecords))) { + return nullptr; + } + return arrayObj; +} + +static ani_ref ConvertPermissionRecords(ani_env* env, const std::vector& permRecords) +{ + ani_object arrayObj = CreateArrayObject(env, permRecords.size()); + if (arrayObj == nullptr) { + return nullptr; + } + ani_size index = 0; + for (const auto& record: permRecords) { + ani_ref aniRecord = ConvertSinglePermissionRecord(env, record); + if (aniRecord == nullptr) { + break; + } + ani_status status = env->Object_CallMethodByName_Void( + arrayObj, "$_set", "ILstd/core/Object;:V", index, aniRecord); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR( + LABEL, "Set permission record fail, status: %{public}d.", static_cast(status)); + break; + } + ++index; + } + return arrayObj; +} + +static ani_object ConvertBundleUsedRecord(ani_env* env, const BundleUsedRecord& record) +{ + ani_object aniRecord = CreateClassObject(env, "L@ohos/privacyManager/privacyManager/BundleUsedRecordInner;"); + if (aniRecord == nullptr) { + return nullptr; + } + if (!SetIntProperty(env, aniRecord, "tokenId", static_cast(record.tokenId))) { + return nullptr; + } + if (!SetBoolProperty(env, aniRecord, "isRemote", record.isRemote)) { + return nullptr; + } + + if (!SetStringProperty(env, aniRecord, "deviceId", record.deviceId)) { + return nullptr; + } + + if (!SetStringProperty(env, aniRecord, "bundleName", record.bundleName)) { + return nullptr; + } + + if (!SetRefProperty(env, aniRecord, "permissionRecords", ConvertPermissionRecords(env, record.permissionRecords))) { + return nullptr; + } + return aniRecord; +} + +static ani_object ConvertBundleUsedRecords(ani_env* env, const std::vector& bundleRecord) +{ + ani_object arrayObj = CreateArrayObject(env, bundleRecord.size()); + if (arrayObj == nullptr) { + return nullptr; + } + ani_size index = 0; + for (const auto& record : bundleRecord) { + ani_ref aniRecord = ConvertBundleUsedRecord(env, record); + if (aniRecord == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "aniRecord is null."); + continue; + } + ani_status status = env->Object_CallMethodByName_Void( + arrayObj, "$_set", "ILstd/core/Object;:V", index, aniRecord); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Set bundle record fail, status: %{public}d.", static_cast(status)); + continue; + } + ++index; + } + return arrayObj; +} + +static ani_object ProcessRecordResult(ani_env* env, const PermissionUsedResult& result) +{ + ani_object aObject = CreateClassObject(env, "L@ohos/privacyManager/privacyManager/PermissionUsedResponseInner;"); + if (aObject == nullptr) { + return nullptr; + } + if (!SetLongProperty(env, aObject, "beginTime", result.beginTimeMillis)) { + return nullptr; + } + if (!SetLongProperty(env, aObject, "endTime", result.endTimeMillis)) { + return nullptr; + } + + if (!SetRefProperty(env, aObject, "bundleRecords", ConvertBundleUsedRecords(env, result.bundleRecords))) { + return nullptr; + } + return aObject; +} + +static bool ParseRequest(ani_env* env, const ani_object& aniRequest, PermissionUsedRequest& request) +{ + ani_class requestClass; + if (ANI_OK != env->FindClass("L@ohos/privacyManager/privacyManager/PermissionUsedRequest;", &requestClass)) { + return false; + } + ani_boolean isRequestObject = false; + if (ANI_OK != env->Object_InstanceOf(static_cast(aniRequest), requestClass, &isRequestObject)) { + return false; + } + if (!isRequestObject) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Object is not request type."); + return false; + } + + int32_t value; + if (!GetIntProperty(env, aniRequest, "tokenId", value)) { + return false; + } + request.tokenId = static_cast(value); + + if (!GetBoolProperty(env, aniRequest, "isRemote", request.isRemote)) { + return false; + } + + if (!GetStringProperty(env, aniRequest, "deviceId", request.deviceId)) { + return false; + } + + if (!GetStringProperty(env, aniRequest, "bundleName", request.bundleName)) { + return false; + } + + if (!GetLongProperty(env, aniRequest, "beginTime", request.beginTimeMillis)) { + return false; + } + + if (!GetLongProperty(env, aniRequest, "endTime", request.endTimeMillis)) { + return false; + } + + if (!GetStringVecProperty(env, aniRequest, "permissionNames", request.permissionList)) { + return false; + } + + int32_t flag; + if (!GetEnumProperty(env, aniRequest, "flag", flag)) { + return false; + } + request.flag = static_cast(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) { + int32_t stsCode = GetStsErrorCode(errcode); + BusinessErrorAni::ThrowError(env, stsCode, GetErrorMessage(stsCode)); + return nullptr; + } + return ProcessRecordResult(env, retResult); } static ani_ref GetPermissionUsedTypeInfosExecute([[maybe_unused]] ani_env* env,