diff --git a/frameworks/ets/ani/accesstoken/BUILD.gn b/frameworks/ets/ani/accesstoken/BUILD.gn index 6fe0a656122a59623b4de891af30a7b0119da6af..296e2969ce1f22d127b80a1ff10dd204da5e507d 100644 --- a/frameworks/ets/ani/accesstoken/BUILD.gn +++ b/frameworks/ets/ani/accesstoken/BUILD.gn @@ -31,7 +31,7 @@ ohos_shared_library("accesstoken_ani") { "${access_token_path}/interfaces/innerkits/token_callback/include", "${access_token_path}/frameworks/ets/ani/common/include", ] - sources = [ "src/ability_access_ctrl.cpp" ] + sources = [ "src/ani_ability_access_ctrl.cpp" ] deps = [ "${access_token_path}/frameworks/ets/ani/common:libani_common", diff --git a/frameworks/ets/ani/accesstoken/ets/@ohos.abilityAccessCtrl.ets b/frameworks/ets/ani/accesstoken/ets/@ohos.abilityAccessCtrl.ets index abf473cca852dadbb8f356595bde68d1daa8e71d..b8c11cbb69e78788e9b54524dfec2e974daa5dde 100644 --- a/frameworks/ets/ani/accesstoken/ets/@ohos.abilityAccessCtrl.ets +++ b/frameworks/ets/ani/accesstoken/ets/@ohos.abilityAccessCtrl.ets @@ -115,7 +115,7 @@ export default namespace abilityAccessCtrl { requestPermissionOnSetting( context: Context, permissionList: Array): Promise>; - + grantUserGrantedPermission( tokenID: int, permissionName: Permissions, @@ -123,8 +123,8 @@ export default namespace abilityAccessCtrl { callback: AsyncCallback): void; grantUserGrantedPermission( - tokenID: int, - permissionName: Permissions, + tokenID: int, + permissionName: Permissions, permissionFlags: int): Promise; revokeUserGrantedPermission(tokenID: int, permissionName: Permissions, permissionFlags: int): Promise; @@ -280,7 +280,7 @@ export default namespace abilityAccessCtrl { callback(err as BusinessError, undefined); }) } - + grantUserGrantedPermission(tokenID: int, permissionName: Permissions, permissionFlags: int): Promise { return new Promise( (resolve: (v: undefined) => void, reject: (error: BusinessError) => void) : void => { @@ -294,7 +294,7 @@ export default namespace abilityAccessCtrl { }) }); } - + revokeUserGrantedPermission(tokenID: int, permissionName: Permissions, permissionFlags: int): Promise { return new Promise( (resolve: (v: undefined) => void, reject: (error: BusinessError) => void): void => { diff --git a/frameworks/ets/ani/accesstoken/include/ability_access_ctrl.h b/frameworks/ets/ani/accesstoken/include/ani_ability_access_ctrl.h similarity index 100% rename from frameworks/ets/ani/accesstoken/include/ability_access_ctrl.h rename to frameworks/ets/ani/accesstoken/include/ani_ability_access_ctrl.h diff --git a/frameworks/ets/ani/accesstoken/src/ability_access_ctrl.cpp b/frameworks/ets/ani/accesstoken/src/ani_ability_access_ctrl.cpp similarity index 98% rename from frameworks/ets/ani/accesstoken/src/ability_access_ctrl.cpp rename to frameworks/ets/ani/accesstoken/src/ani_ability_access_ctrl.cpp index 41be0f49ac00133eeb714b12e87440bf635fbc0e..a2db3800966624d185c944b3eafdd1bce03cb943 100644 --- a/frameworks/ets/ani/accesstoken/src/ability_access_ctrl.cpp +++ b/frameworks/ets/ani/accesstoken/src/ani_ability_access_ctrl.cpp @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "ability_access_ctrl.h" +#include "ani_ability_access_ctrl.h" #include #include @@ -357,26 +357,6 @@ static inline bool CallSetter(ani_env* env, ani_class cls, ani_object object, co return true; } -std::string ANIUtils_ANIStringToStdString(ani_env* env, ani_string ani_str) -{ - ani_size strSize; - if (env->String_GetUTF8Size(ani_str, &strSize) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "String_GetUTF8Size error"); - return ""; - } - std::vector buffer(strSize + 1); - char* utf8_buffer = buffer.data(); - - ani_size bytes_written = 0; - if (env->String_GetUTF8(ani_str, utf8_buffer, strSize + 1, &bytes_written) != ANI_OK) { - ACCESSTOKEN_LOG_ERROR(LABEL, "String_GetUTF8 error"); - return ""; - } - utf8_buffer[bytes_written] = '\0'; - std::string content = std::string(utf8_buffer); - return content; -} - static bool ProcessArrayString([[maybe_unused]] ani_env* env, [[maybe_unused]] ani_object object, ani_array_ref arrayObj, std::vector& permissionList) { @@ -392,7 +372,7 @@ static bool ProcessArrayString([[maybe_unused]] ani_env* env, [[maybe_unused]] a ACCESSTOKEN_LOG_ERROR(LABEL, "Object_CallMethodByName_Ref _get Failed"); return false; } - auto strEntryRef = ANIUtils_ANIStringToStdString(env, static_cast(stringEntryRef)); + auto strEntryRef = ANIStringToStdString(env, static_cast(stringEntryRef)); if (strEntryRef.empty()) { return false; } else { @@ -888,7 +868,7 @@ static ani_int CheckAccessTokenSync([[maybe_unused]] ani_env* env, [[maybe_unuse BusinessErrorAni::ThrowError(env, STS_ERROR_PARAM_INVALID, errMsg); return AccessToken::PermissionState::PERMISSION_DENIED; } - std::string stdPermissionName = ANIUtils_ANIStringToStdString(env, static_cast(permissionName)); + std::string stdPermissionName = ANIStringToStdString(env, static_cast(permissionName)); if (stdPermissionName.empty() || stdPermissionName.length() > MAX_LENGTH) { std::string errMsg = GetErrorMessage( STS_ERROR_PARAM_INVALID, "The permissionName is empty or exceeds 256 characters."); @@ -1342,7 +1322,7 @@ static void GrantUserGrantedPermissionExecute([[maybe_unused]] ani_env *env, [[m GetErrorMessage(STSErrorCode::STS_ERROR_PERMISSION_NOT_EXIST)); return; } - + if (def.grantMode != USER_GRANT || !GetPermissionBriefDef(permissionName, def)) { std::string errMsg = GetErrorMessage(STS_ERROR_PERMISSION_NOT_EXIST, "The specified permission does not exist or is not a user_grant permission."); @@ -1373,7 +1353,7 @@ static void RevokeUserGrantedPermissionExecute([[maybe_unused]] ani_env* env, GetParamErrorMsg("permissionName", "Permissions")); return; } - + if (!IsPermissionFlagValid(static_cast (permissionFlags))) { std::string errMsg = GetErrorMessage(STS_ERROR_PARAM_INVALID, "The permissionFlags is invalid."); BusinessErrorAni::ThrowError(env, STS_ERROR_PARAM_INVALID, errMsg); @@ -1534,40 +1514,30 @@ static ani_int GetPermissionRequestToggleStatusExecute([[maybe_unused]] ani_env* return flag; } -extern "C" { -ANI_EXPORT ani_status ANI_Constructor(ani_vm* vm, uint32_t* result) +void InitAbilityCtrlFunction(ani_env *env) { - if (vm == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "nullptr vm"); - return ANI_INVALID_ARGS; - } - ani_env* env; - if (ANI_OK != vm->GetEnv(ANI_VERSION_1, &env)) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Unsupported ANI_VERSION_1"); - return ANI_OUT_OF_MEMORY; - } if (env == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "nullptr env"); - return ANI_NOT_FOUND; + return; } const char* spaceName = "L@ohos/abilityAccessCtrl/abilityAccessCtrl;"; ani_namespace spc; if (ANI_OK != env->FindNamespace(spaceName, &spc)) { ACCESSTOKEN_LOG_ERROR(LABEL, "Not found %{public}s", spaceName); - return ANI_NOT_FOUND; + return; } std::array methods = { ani_native_function { "createAtManager", nullptr, reinterpret_cast(CreateAtManager) }, }; if (ANI_OK != env->Namespace_BindNativeFunctions(spc, methods.data(), methods.size())) { ACCESSTOKEN_LOG_ERROR(LABEL, "Cannot bind native methods to %{public}s", spaceName); - return ANI_ERROR; + return; }; const char* className = "L@ohos/abilityAccessCtrl/abilityAccessCtrl/AtManagerInner;"; ani_class cls; if (ANI_OK != env->FindClass(className, &cls)) { ACCESSTOKEN_LOG_ERROR(LABEL, "Not found %{public}s", className); - return ANI_ERROR; + return; } std::array claMethods = { ani_native_function { @@ -1594,8 +1564,22 @@ ANI_EXPORT ani_status ANI_Constructor(ani_vm* vm, uint32_t* result) }; if (ANI_OK != env->Class_BindNativeMethods(cls, claMethods.data(), claMethods.size())) { ACCESSTOKEN_LOG_ERROR(LABEL, "Cannot bind native methods to %{public}s", className); - return ANI_ERROR; + return; }; +} +extern "C" { +ANI_EXPORT ani_status ANI_Constructor(ani_vm* vm, uint32_t* result) +{ + if (vm == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "nullptr vm"); + return ANI_INVALID_ARGS; + } + ani_env* env; + if (ANI_OK != vm->GetEnv(ANI_VERSION_1, &env)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Unsupported ANI_VERSION_1"); + return ANI_OUT_OF_MEMORY; + } + InitAbilityCtrlFunction(env); *result = ANI_VERSION_1; return ANI_OK; } diff --git a/frameworks/ets/ani/common/include/ani_error.h b/frameworks/ets/ani/common/include/ani_error.h index d8fc49028618ba0d1ca37efc131d1f7944ffe3cf..5343f927aec36c8ba024defb8431931370ff9a01 100644 --- a/frameworks/ets/ani/common/include/ani_error.h +++ b/frameworks/ets/ani/common/include/ani_error.h @@ -18,6 +18,7 @@ #include #include +#include "access_token.h" namespace OHOS { namespace Security { @@ -59,6 +60,8 @@ public: static void ThrowParameterTypeError(ani_env* env, int32_t err, const std::string& errMsg); static void ThrowError(ani_env* env, int32_t err, const std::string& errMsg = ""); static int32_t GetStsErrorCode(int32_t errCode); + static bool ValidateTokenIDdWithThrowError(ani_env* env, AccessTokenID tokenID); + static bool ValidatePermissionWithThrowError(ani_env* env, const std::string& permission); private: static void ThrowError(ani_env* env, ani_object err); diff --git a/frameworks/ets/ani/common/include/ani_utils.h b/frameworks/ets/ani/common/include/ani_utils.h index f86989e112f4e8e7ad8a4160c188b8497859da97..d487ef64cbe2b42b37ede8fbed49f754e4b14f28 100644 --- a/frameworks/ets/ani/common/include/ani_utils.h +++ b/frameworks/ets/ani/common/include/ani_utils.h @@ -36,7 +36,7 @@ bool AniGetEnumItemByIndex(ani_env* env, const ani_enum& aniEnum, ani_size index 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& isUndefined); +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); @@ -54,6 +54,7 @@ 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); } // namespace AccessToken } // namespace Security } // namespace OHOS diff --git a/frameworks/ets/ani/common/src/ani_error.cpp b/frameworks/ets/ani/common/src/ani_error.cpp index 29dfc88f2b297c5887e43e24129508a15d3cffd6..d2d94bdd023707c84460529d871e9ec129049b7f 100644 --- a/frameworks/ets/ani/common/src/ani_error.cpp +++ b/frameworks/ets/ani/common/src/ani_error.cpp @@ -18,6 +18,7 @@ #include "access_token_error.h" #include "accesstoken_log.h" +#include "data_validator.h" namespace OHOS { namespace Security { @@ -25,7 +26,6 @@ namespace AccessToken { namespace { static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, SECURITY_DOMAIN_PRIVACY, "CommonAni" }; } // namespace -constexpr const int32_t RET_SUCCESS = 0; constexpr const char* BUSINESS_ERROR_CLASS = "L@ohos/base/BusinessError;"; static const std::unordered_map g_errorStringMap = { { STS_ERROR_PERMISSION_DENIED, "Permission denied." }, @@ -192,6 +192,27 @@ int32_t BusinessErrorAni::GetStsErrorCode(int32_t errCode) ACCESSTOKEN_LOG_DEBUG(LABEL, "GetStsErrorCode nativeCode(%{public}d) stsCode(%{public}d).", errCode, stsCode); return stsCode; } + +bool BusinessErrorAni::ValidateTokenIDdWithThrowError(ani_env* env, AccessTokenID tokenID) +{ + if (!DataValidator::IsTokenIDValid(tokenID)) { + std::string errMsg = GetErrorMessage(STS_ERROR_PARAM_INVALID, "The tokenID is 0."); + BusinessErrorAni::ThrowError(env, STS_ERROR_PARAM_INVALID, errMsg); + return false; + } + return true; +} + +bool BusinessErrorAni::ValidatePermissionWithThrowError(ani_env* env, const std::string& permission) +{ + if (!DataValidator::IsPermissionNameValid(permission)) { + std::string errMsg = GetErrorMessage( + STS_ERROR_PARAM_INVALID, "The permissionName is empty or exceeds 256 characters."); + BusinessErrorAni::ThrowError(env, STS_ERROR_PARAM_INVALID, errMsg); + return false; + } + return true; +} } // 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 22200802f27bfe0a4c9aa552c2f0dff4cf8c14db..0a6cf33d4755c0ddae61e8907c12cb8f232db542 100644 --- a/frameworks/ets/ani/common/src/ani_utils.cpp +++ b/frameworks/ets/ani/common/src/ani_utils.cpp @@ -138,15 +138,14 @@ bool AniParseCallback(ani_env* env, const ani_ref& ani_callback, ani_ref& out) return true; } -bool AniIsRefUndefined(ani_env* env, const ani_ref& ref, bool& isUndefined) +bool AniIsRefUndefined(ani_env* env, const ani_ref& ref) { ani_boolean isUnd; if (env->Reference_IsUndefined(ref, &isUnd) != ANI_OK) { ACCESSTOKEN_LOG_ERROR(LABEL, "Reference_IsUndefined failed!"); return false; } - isUndefined = isUnd ? true : false; - return true; + return isUnd ? true : false; } bool AniNewString(ani_env* env, const std::string in, ani_string& out) @@ -264,6 +263,26 @@ bool AniFunctionalObjectCall(ani_env *env, const ani_fn_object& fn, ani_size siz } return true; } + +std::string ANIStringToStdString(ani_env* env, ani_string aniStr) +{ + ani_size strSize; + if (env->String_GetUTF8Size(aniStr, &strSize) != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "String_GetUTF8Size error."); + return ""; + } + std::vector buffer(strSize + 1); + 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 error."); + return ""; + } + + utf8Buffer[bytesWritten] = '\0'; + std::string content = std::string(utf8Buffer); + return content; +} } // namespace AccessToken } // namespace Security } // namespace OHOS diff --git a/frameworks/ets/ani/privacy/BUILD.gn b/frameworks/ets/ani/privacy/BUILD.gn index cb1ddd50250328bff9049eab799990c576ea846d..0d7a756ad9a7549c8c62c5c99dac704df4947a4d 100644 --- a/frameworks/ets/ani/privacy/BUILD.gn +++ b/frameworks/ets/ani/privacy/BUILD.gn @@ -34,6 +34,7 @@ ohos_shared_library("privacy_ani") { sources = [ "src/privacy_manager.cpp" ] deps = [ + "${access_token_path}/frameworks/common:accesstoken_common_cxx", "${access_token_path}/frameworks/ets/ani/common:libani_common", "${access_token_path}/interfaces/innerkits/privacy:libprivacy_sdk", ] diff --git a/frameworks/ets/ani/privacy/ets/@ohos.privacyManager.ets b/frameworks/ets/ani/privacy/ets/@ohos.privacyManager.ets index 9b3413d4582d1f2724591a687d7b8480101e0c5f..5ddd54b013558632781ac9f8b59aa6aedd64d8c3 100644 --- a/frameworks/ets/ani/privacy/ets/@ohos.privacyManager.ets +++ b/frameworks/ets/ani/privacy/ets/@ohos.privacyManager.ets @@ -25,79 +25,24 @@ export { Permissions } export default namespace privacyManager { loadLibrary("privacy_ani.z"); - enum PermissionUsedType { - NORMAL_TYPE = 0, - PICKER_TYPE = 1, - SECURITY_COMPONENT_TYPE = 2 - } - - enum PermissionActiveStatus { - PERM_INACTIVE = 0, - PERM_ACTIVE_IN_FOREGROUND = 1, - PERM_ACTIVE_IN_BACKGROUND = 2 - } - - enum STSErrorCode { - STS_OK = 0, - STS_ERROR_PERMISSION_DENIED = 201, - STS_ERROR_NOT_SYSTEM_APP = 202, - STS_ERROR_PARAM_ILLEGAL = 401, - STS_ERROR_SYSTEM_CAPABILITY_NOT_SUPPORT = 801, - } ; - - interface AddPermissionUsedRecordOptions { - usedType?: PermissionUsedType; - } - - class AddPermissionUsedRecordOptionsInner implements AddPermissionUsedRecordOptions { - usedType: PermissionUsedType|undefined; - } - - class PrivacyManagerInner { - native addPermissionUsedRecordSync(tokenID: int, permissionName: Permissions, successCount: int, failCount: int, - options: AddPermissionUsedRecordOptionsInner): void; - - native stopUsingPermissionExecute(tokenID: int, permissionName: Permissions, pid: int): void; - - native startUsingPermissionExecute(tokenID: int, permissionName: Permissions, pid: int, - usedType: int): void; - - } - - interface UsedRecordDetail { - status: number; - lockScreenStatus?: number; - timestamp: number; - count?: number; - accessDuration: number; - usedType?: PermissionUsedType; - } - - interface PermissionUsedTypeInfo { - tokenId: number; - permissionName: Permissions; - usedType: PermissionUsedType; - } + native function addPermissionUsedRecordExecute( + tokenID: int, permissionName: Permissions, successCount: int, failCount: int, + options: AddPermissionUsedRecordOptions): void; - interface ActiveChangeResponse { - callingTokenId?: int; - tokenId: int; - permissionName: Permissions; - deviceId: string; - activeStatus: PermissionActiveStatus; - usedType?: PermissionUsedType; - } + native function startUsingPermissionExecute( + tokenID: int, permissionName: Permissions, pid: int, usedType: int): void; + native function stopUsingPermissionExecute(tokenID: int, permissionName: Permissions, pid: int): void; + native function getPermissionUsedRecordExecute(request: PermissionUsedRequest): PermissionUsedResponse; + native function getPermissionUsedTypeInfosExecute( + tokenId: int, permissionName: Permissions): Array; + native function setPermissionUsedRecordToggleStatusExecute(status: boolean): void; + native function getPermissionUsedRecordToggleStatusExecute(): boolean; + native function onExecute( + type: string, permissionList: Array, callback: Callback): void; + native function offExecute( + type: string, permissionList: Array, callback?: Callback): void; - class ActiveChangeResponseInner implements ActiveChangeResponse { - callingTokenId?: int; - tokenId: int; - permissionName: Permissions; - deviceId: string; - activeStatus: PermissionActiveStatus; - usedType?: PermissionUsedType; - } - - function addPermissionUsedRecord(tokenID: int, permissionName: Permissions, successCount: int, + export function addPermissionUsedRecord(tokenID: int, permissionName: Permissions, successCount: int, failCount: int, options?: AddPermissionUsedRecordOptions): Promise { if (typeof permissionName !== "string") { let err = new BusinessError(); @@ -105,12 +50,13 @@ export default namespace privacyManager { err.data = PARAM_ERROR_MSG("permissionName", "Permissions"); throw err; } - let usedTypeTemp : PermissionUsedType|undefined = options ? options.usedType : PermissionUsedType.NORMAL_TYPE; - let optionsLocal: AddPermissionUsedRecordOptionsInner = { usedType: usedTypeTemp }; + let optionsLocal: AddPermissionUsedRecordOptions = { usedType: usedTypeTemp }; let p = new Promise((resolve: (v: undefined) => void, reject: (error: BusinessError) => void): void => { - let p1 = taskpool.execute((): void => { return new PrivacyManagerInner().addPermissionUsedRecordSync( - tokenID, permissionName, successCount, failCount, optionsLocal) }); + let p1 = taskpool.execute((): void => { + addPermissionUsedRecordExecute( + tokenID, permissionName, successCount, failCount, optionsLocal); + }); p1.then(() => { resolve(undefined); }).catch((err: Error): void => { @@ -120,7 +66,7 @@ export default namespace privacyManager { return p; } - function addPermissionUsedRecord(tokenID: int, permissionName: Permissions, successCount: int, + export function addPermissionUsedRecord(tokenID: int, permissionName: Permissions, successCount: int, failCount: int, callback: AsyncCallback): void { if (typeof permissionName !== "string") { let err = new BusinessError(); @@ -128,29 +74,29 @@ export default namespace privacyManager { err.data = PARAM_ERROR_MSG("permissionName", "Permissions"); throw err; } - let optionsLocal: AddPermissionUsedRecordOptionsInner = { usedType: PermissionUsedType.NORMAL_TYPE }; - let p2 = taskpool.execute((): void => { - return new PrivacyManagerInner().addPermissionUsedRecordSync(tokenID, permissionName, - successCount, failCount, optionsLocal)}); - p2.then(() => { + let options: AddPermissionUsedRecordOptions = { usedType: PermissionUsedType.NORMAL_TYPE }; + let p = taskpool.execute((): void => { + addPermissionUsedRecordExecute(tokenID, permissionName, + successCount, failCount, options); + }); + p.then(() => { let err = new BusinessError(); callback(err, undefined); },(err: Error): void=> { callback(err as BusinessError, undefined); - }) + }); } - function stopUsingPermission(tokenID: int, permissionName: Permissions): Promise { + export function stopUsingPermission(tokenID: int, permissionName: Permissions): Promise { if (typeof permissionName !== "string") { let err = new BusinessError(); err.code = STSErrorCode.STS_ERROR_PARAM_ILLEGAL; err.data = PARAM_ERROR_MSG("permissionName", "Permissions"); throw err; } - let optionalPid = -1; let p = new Promise((resolve: (v: undefined) => void, reject: (error: BusinessError) => void): void => { let p1 = taskpool.execute((): void => { - return new PrivacyManagerInner().stopUsingPermissionExecute(tokenID, permissionName, optionalPid) }); + return stopUsingPermissionExecute(tokenID, permissionName, -1) }); p1.then(() => { resolve(undefined); }).catch((err: Error): void => { @@ -160,25 +106,24 @@ export default namespace privacyManager { return p; } - function stopUsingPermission(tokenID: int, permissionName: Permissions, callback: AsyncCallback): void { + export function stopUsingPermission(tokenID: int, permissionName: Permissions, callback: AsyncCallback): void { if (typeof permissionName !== "string") { let err = new BusinessError(); err.code = STSErrorCode.STS_ERROR_PARAM_ILLEGAL; err.data = PARAM_ERROR_MSG("permissionName", "Permissions"); throw err; } - let optionalPid = -1; - let p2 = taskpool.execute((): void => { - return new PrivacyManagerInner().stopUsingPermissionExecute(tokenID, permissionName, optionalPid) }); - p2.then(() => { + let p = taskpool.execute((): void => { + return stopUsingPermissionExecute(tokenID, permissionName, -1) }); + p.then(() => { let err = new BusinessError(); callback(err, undefined); },(err: Error): void=> { callback(err as BusinessError, undefined); - }) + }); } - function stopUsingPermission(tokenID: int, permissionName: Permissions, pid?: int): Promise { + export function stopUsingPermission(tokenID: int, permissionName: Permissions, pid?: int): Promise { if (typeof permissionName !== "string") { let err = new BusinessError(); err.code = STSErrorCode.STS_ERROR_PARAM_ILLEGAL; @@ -187,8 +132,8 @@ export default namespace privacyManager { } let optionalPid: int = pid ?? -1; let p = new Promise((resolve: (v: undefined) => void, reject: (error: BusinessError) => void): void => { - let p1 = taskpool.execute((): void => { - return new PrivacyManagerInner().stopUsingPermissionExecute(tokenID, permissionName, optionalPid) }); + let p1 = taskpool.execute((): void => { + return stopUsingPermissionExecute(tokenID, permissionName, optionalPid) }); p1.then(() => { resolve(undefined); }).catch((err: Error): void => { @@ -198,19 +143,17 @@ export default namespace privacyManager { return p; } - function startUsingPermission(tokenID: int, permissionName: Permissions): Promise { + export function startUsingPermission(tokenID: int, permissionName: Permissions): Promise { if (typeof permissionName !== "string") { let err = new BusinessError(); err.code = STSErrorCode.STS_ERROR_PARAM_ILLEGAL; err.data = PARAM_ERROR_MSG("permissionName", "Permissions"); throw err; } - let optionalPid = -1; - let optionalUsedType = PermissionUsedType.NORMAL_TYPE; let p = new Promise((resolve: (v: undefined) => void, reject: (error: BusinessError) => void): void => { let p1 = taskpool.execute((): void => { - return new PrivacyManagerInner().startUsingPermissionExecute(tokenID, permissionName, - optionalPid, optionalUsedType) }); + return startUsingPermissionExecute(tokenID, permissionName, + -1, PermissionUsedType.NORMAL_TYPE) }); p1.then(() => { resolve(undefined); }).catch((err: Error): void => { @@ -220,19 +163,17 @@ export default namespace privacyManager { return p; } - function startUsingPermission(tokenID: int, permissionName: Permissions, callback: AsyncCallback): void { + export function startUsingPermission(tokenID: int, permissionName: Permissions, callback: AsyncCallback): void { if (typeof permissionName !== "string") { let err = new BusinessError(); err.code = STSErrorCode.STS_ERROR_PARAM_ILLEGAL; err.data = PARAM_ERROR_MSG("permissionName", "Permissions"); throw err; } - let optionalPid = -1; - let optionalUsedType = PermissionUsedType.NORMAL_TYPE; - let p2 = taskpool.execute((): void => { - return new PrivacyManagerInner().startUsingPermissionExecute(tokenID, permissionName, - optionalPid, optionalUsedType) }); - p2.then(() => { + let p = taskpool.execute((): void => { + return startUsingPermissionExecute(tokenID, permissionName, + -1, PermissionUsedType.NORMAL_TYPE) }); + p.then(() => { let err = new BusinessError(); callback(err, undefined); },(err: Error): void => { @@ -240,7 +181,7 @@ export default namespace privacyManager { }) } - function startUsingPermission(tokenID: int, permissionName: Permissions, pid?: int, + export function startUsingPermission(tokenID: int, permissionName: Permissions, pid?: int, usedType?: PermissionUsedType): Promise { if (typeof permissionName !== "string") { let err = new BusinessError(); @@ -252,7 +193,7 @@ export default namespace privacyManager { let optionalUsedType = usedType ?? PermissionUsedType.NORMAL_TYPE; let p = new Promise((resolve: (v: undefined) => void, reject: (error: BusinessError) => void): void => { let p1 = taskpool.execute((): void => { - return new PrivacyManagerInner().startUsingPermissionExecute(tokenID, permissionName, + return startUsingPermissionExecute(tokenID, permissionName, optionalPid, optionalUsedType) }); p1.then(() => { resolve(undefined); @@ -263,9 +204,211 @@ export default namespace privacyManager { return p; } - export native function on(type: 'activeStateChange', permissionList: Array, - callback: Callback): void; + export function getPermissionUsedRecord(request: PermissionUsedRequest): Promise { + return new Promise( + (resolve: (data: PermissionUsedResponse) => void, reject: (error: BusinessError) => void): PermissionUsedResponse => { + let p1 = taskpool.execute((): PermissionUsedResponse => { + return getPermissionUsedRecordExecute(request); + }); + p1.then((e: NullishType):void => { + resolve(e as PermissionUsedResponse); + }).catch((err: Error): void => { + reject(err as BusinessError); + }); + }); + } + + export function getPermissionUsedTypeInfos(tokenId?: int, permissionName?: Permissions): Promise>{ + let tokenIdIn = tokenId ? tokenId : 0; + let permissionNameIn = permissionName ?? ""; + return new Promise>( + (resolve: (v: Array) => void, reject: (err:BusinessError) => void): Array => { + let p1 = taskpool.execute((): Array => { + return getPermissionUsedTypeInfosExecute(tokenIdIn, permissionNameIn); + }); + p1.then((e: NullishType): void => { + resolve(e as Array); + }).catch((err: Error): void => { + reject(err as BusinessError); + }) + }); + } - export native function off(type: 'activeStateChange', permissionList: Array, - callback?: Callback): void; + export function setPermissionUsedRecordToggleStatus(status: boolean): Promise{ + return new Promise( + (resolve: (v: undefined) => void, reject: (err: BusinessError) => void): void => { + let p1 = taskpool.execute((): void => { + setPermissionUsedRecordToggleStatusExecute(status); + }); + p1.then((e: NullishType): void => { + resolve(undefined); + }).catch((err: Error): void => { + reject(err as BusinessError); + }) + }); + } + + export function getPermissionUsedRecordToggleStatus(): Promise{ + return new Promise( + (resolve: (v: boolean) => void, reject: (err:BusinessError) => void): void => { + let p1 = taskpool.execute((): boolean => { + return getPermissionUsedRecordToggleStatusExecute(); + }); + p1.then((e: NullishType): void => { + resolve(e as boolean); + }).catch((err: Error): void =>{ + reject(err as BusinessError); + }) + }); + } + + export function on( + type: string, permissionList: Array, callback: Callback): void { + onExecute(type, permissionList, callback); + } + + export function off( + type: string, permissionList: Array, callback?: Callback): void { + offExecute(type, permissionList, callback); + } + + export enum PermissionUsedType { + NORMAL_TYPE = 0, + PICKER_TYPE = 1, + SECURITY_COMPONENT_TYPE = 2 + }; + + export enum PermissionActiveStatus { + PERM_INACTIVE = 0, + PERM_ACTIVE_IN_FOREGROUND = 1, + PERM_ACTIVE_IN_BACKGROUND = 2 + }; + + enum STSErrorCode { + STS_OK = 0, + STS_ERROR_PERMISSION_DENIED = 201, + STS_ERROR_NOT_SYSTEM_APP = 202, + STS_ERROR_PARAM_ILLEGAL = 401, + STS_ERROR_SYSTEM_CAPABILITY_NOT_SUPPORT = 801, + }; + + export enum PermissionUsageFlag { + FLAG_PERMISSION_USAGE_SUMMARY = 0, + FLAG_PERMISSION_USAGE_DETAIL = 1 + }; + + export interface AddPermissionUsedRecordOptions { + usedType?: PermissionUsedType; + } + + export interface PermissionUsedTypeInfo { + tokenId: int; + permissionName: Permissions; + usedType: PermissionUsedType; + } + + class PermissionUsedTypeInfoInner implements PermissionUsedTypeInfo { + tokenId: int; + permissionName: Permissions; + usedType: PermissionUsedType; + } + + export interface ActiveChangeResponse { + callingTokenId?: int; + tokenId: int; + permissionName: Permissions; + deviceId: string; + activeStatus: PermissionActiveStatus; + usedType?: PermissionUsedType; + } + + class ActiveChangeResponseInner implements ActiveChangeResponse { + callingTokenId?: int; + tokenId: int; + permissionName: Permissions; + deviceId: string; + activeStatus: PermissionActiveStatus; + usedType?: PermissionUsedType; + } + + export interface PermissionUsedRequest { + tokenId?: int; + isRemote?: boolean; + deviceId?: string; + bundleName?: string; + permissionNames?: Array; + beginTime?: long; + endTime?: long; + flag: PermissionUsageFlag; + } + + export interface UsedRecordDetail { + status: int; + lockScreenStatus?: int; + timestamp: long; + count?: int; + accessDuration: int; + usedType?: PermissionUsedType; + } + + class UsedRecordDetailInner implements UsedRecordDetail { + status: int; + lockScreenStatus?: int; + timestamp: long; + count?: int; + accessDuration: int; + usedType?: PermissionUsedType; + } + + interface PermissionUsedRecord { + permissionName: Permissions; + accessCount: int; + secAccessCount: int; + rejectCount: int; + lastAccessTime: long; + lastRejectTime: long; + lastAccessDuration: long; + accessRecords: Array; + rejectRecords: Array; + } + + class PermissionUsedRecordInner implements PermissionUsedRecord { + permissionName: Permissions; + accessCount: int; + secAccessCount: int; + rejectCount: int; + lastAccessTime: long; + lastRejectTime: long; + lastAccessDuration: long; + accessRecords: Array; + rejectRecords: Array; + } + + export interface BundleUsedRecord{ + tokenId: int; + isRemote: boolean; + deviceId: string; + bundleName: string; + permissionNames: Array; + } + + class BundleUsedRecordInner implements BundleUsedRecord { + tokenId: int; + isRemote: boolean; + deviceId: string; + bundleName: string; + permissionNames: Array; + } + + export interface PermissionUsedResponse { + beginTime: long; + endTime: long; + bundleRecords: Array; + } + + class PermissionUsedResponseInner implements PermissionUsedResponse { + beginTime: long; + endTime: long; + bundleRecords: Array; + } } diff --git a/frameworks/ets/ani/privacy/src/privacy_manager.cpp b/frameworks/ets/ani/privacy/src/privacy_manager.cpp index 4b2208f522c6e235d53ef4259428c58ab0e5c66f..7e828ab504db4681b7010f4e50847009ca824a63 100644 --- a/frameworks/ets/ani/privacy/src/privacy_manager.cpp +++ b/frameworks/ets/ani/privacy/src/privacy_manager.cpp @@ -94,44 +94,24 @@ static int32_t GetStsErrorCode(int32_t errCode) return stsCode; } -static void AddPermissionUsedRecordSync(ani_env* env, const AddPermParamInfo& info) -{ - auto retCode = PrivacyKit::AddPermissionUsedRecord(info); - if (retCode != RET_SUCCESS) { - int32_t stsCode = GetStsErrorCode(retCode); - BusinessErrorAni::ThrowError(env, stsCode, GetErrorMessage(stsCode)); - return; - } - ACCESSTOKEN_LOG_INFO(LABEL, "call addPermissionUsedRecord retCode : %{public}d", retCode); -} - -static void AddPermissionUsedRecord([[maybe_unused]] ani_env* env, [[maybe_unused]] ani_object object, - ani_int tokenID, ani_string permissionName, ani_int successCount, ani_int failCount, ani_object options) +static void AddPermissionUsedRecordExecute([[maybe_unused]] ani_env* env, + ani_int aniTokenID, ani_string aniPermission, ani_int successCount, ani_int failCount, ani_object options) { if (env == nullptr) { - BusinessErrorAni::ThrowError(env, STS_ERROR_INNER, GetErrorMessage(STSErrorCode::STS_ERROR_INNER)); - return; - } - ani_size strSize; - ani_status status = ANI_ERROR; - if (ANI_OK != (status = env->String_GetUTF8Size(permissionName, &strSize))) { - ACCESSTOKEN_LOG_ERROR(LABEL, "String_GetUTF8Size_Faild status : %{public}d", status); - BusinessErrorAni::ThrowError(env, STS_ERROR_INNER, GetErrorMessage(STSErrorCode::STS_ERROR_INNER)); return; } - std::vector buffer(strSize + 1); - char* utf8Buffer = buffer.data(); - ani_size bytesWritten = 0; - if (ANI_OK != (status = env->String_GetUTF8(permissionName, utf8Buffer, strSize + 1, &bytesWritten))) { - ACCESSTOKEN_LOG_ERROR(LABEL, "get String_GetUTF8 Faild status : %{public}d", status); - BusinessErrorAni::ThrowError(env, STS_ERROR_INNER, GetErrorMessage(STSErrorCode::STS_ERROR_INNER)); + AccessTokenID tokenID = static_cast(aniTokenID); + std::string permission = ANIStringToStdString(env, static_cast(aniPermission)); + if ((!BusinessErrorAni::ValidateTokenIDdWithThrowError(env, tokenID)) || + (!BusinessErrorAni::ValidatePermissionWithThrowError(env, permission))) { + ACCESSTOKEN_LOG_ERROR(LABEL, "TokenId(%{public}u) or Permission(%{public}s) is invalid.", + tokenID, permission.c_str()); return; } - utf8Buffer[bytesWritten] = '\0'; - std::string outputPermissionName = std::string(utf8Buffer); + + ani_status status = ANI_ERROR; ani_ref usedTypeRef; if (ANI_OK != (status = env->Object_GetPropertyByName_Ref(options, "usedType", &usedTypeRef))) { - BusinessErrorAni::ThrowError(env, STS_ERROR_INNER, GetErrorMessage(STSErrorCode::STS_ERROR_INNER)); ACCESSTOKEN_LOG_ERROR(LABEL, "Object_GetFieldByName_Ref Faild status : %{public}d", status); return; } @@ -139,23 +119,26 @@ static void AddPermissionUsedRecord([[maybe_unused]] ani_env* env, [[maybe_unuse ani_boolean isUndefined = true; if (ANI_OK != (status = env->Reference_IsUndefined(usedTypeRef, &isUndefined))) { ACCESSTOKEN_LOG_ERROR(LABEL, "status : %{public}d", status); - BusinessErrorAni::ThrowError(env, STS_ERROR_INNER, GetErrorMessage(STSErrorCode::STS_ERROR_INNER)); return; } if (!isUndefined) { ani_enum_item usedTypeEnum = static_cast(usedTypeRef); if (ANI_OK != env->EnumItem_GetValue_Int(usedTypeEnum, &usedType)) { - BusinessErrorAni::ThrowError(env, STS_ERROR_INNER, GetErrorMessage(STSErrorCode::STS_ERROR_INNER)); return; } } AddPermParamInfo info; info.tokenId = static_cast(tokenID); - info.permissionName = outputPermissionName; + info.permissionName = permission; info.successCount = successCount; info.failCount = failCount; info.type = static_cast(usedType); - AddPermissionUsedRecordSync(env, info); + auto retCode = PrivacyKit::AddPermissionUsedRecord(info); + if (retCode != RET_SUCCESS) { + int32_t stsCode = GetStsErrorCode(retCode); + BusinessErrorAni::ThrowError(env, stsCode, GetErrorMessage(stsCode)); + return; + } } PermActiveStatusPtr::PermActiveStatusPtr(const std::vector& permList) @@ -174,7 +157,7 @@ PermActiveStatusPtr::~PermActiveStatusPtr() if (isSameThread) { env = env_; } else { - ani_option interopEnabled {"--interop=disable", nullptr}; + ani_option interopEnabled {"--interop=enable", nullptr}; ani_options aniArgs {1, &interopEnabled}; vm_->AttachCurrentThread(&aniArgs, ANI_VERSION_1, &env); } @@ -404,34 +387,29 @@ static bool ParseInputToRegister(const ani_string& aniType, const ani_array_ref& { std::string type; // type: the first parameter is string if (!AniParseString(context->env, aniType, type)) { - BusinessErrorAni::ThrowError(context->env, STS_ERROR_PARAM_INVALID, GetParamErrorMsg("type", "string")); + BusinessErrorAni::ThrowParameterTypeError( + context->env, STS_ERROR_PARAM_INVALID, GetParamErrorMsg("type", "string")); return false; } std::vector permList; // permissionList: the second parameter is Array if (!AniParseStringArray(context->env, aniArray, permList)) { - BusinessErrorAni::ThrowError(context->env, STS_ERROR_PARAM_INVALID, GetParamErrorMsg( - "permissionList", "Array")); + BusinessErrorAni::ThrowParameterTypeError( + context->env, STS_ERROR_PARAM_INVALID, GetParamErrorMsg("permissionList", "Array")); return false; } std::sort(permList.begin(), permList.end()); bool hasCallback = true; if (!isReg) { - bool isUndefined = true; - if (!AniIsRefUndefined(context->env, aniCallback, isUndefined)) { - BusinessErrorAni::ThrowError( - context->env, STS_ERROR_PARAM_INVALID, GetErrorMessage(STSErrorCode::STS_ERROR_PARAM_INVALID)); - return false; - } - hasCallback = !isUndefined; + hasCallback = !AniIsRefUndefined(context->env, aniCallback); } ani_ref callback = nullptr; // callback: the third parameter is function if (hasCallback) { if (!AniParseCallback(context->env, aniCallback, callback)) { - BusinessErrorAni::ThrowError(context->env, STS_ERROR_PARAM_INVALID, GetParamErrorMsg( - "callback", "Callback")); + BusinessErrorAni::ThrowParameterTypeError( + context->env, STS_ERROR_PARAM_INVALID, GetParamErrorMsg("callback", "Callback")); return false; } } @@ -495,15 +473,12 @@ static void RegisterPermActiveStatusCallback([[maybe_unused]] ani_env* env, ani_string aniType, ani_array_ref aniArray, ani_ref callback) { if (env == nullptr) { - BusinessErrorAni::ThrowError(env, STS_ERROR_INNER, GetErrorMessage(STSErrorCode::STS_ERROR_INNER)); return; } RegisterPermActiveChangeContext* context = new (std::nothrow) RegisterPermActiveChangeContext(); if (context == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to allocate memory for RegisterPermActiveChangeContext!"); - BusinessErrorAni::ThrowError(env, STS_ERROR_OUT_OF_MEMORY, GetErrorMessage( - STSErrorCode::STS_ERROR_OUT_OF_MEMORY)); return; } context->env = env; @@ -514,10 +489,10 @@ static void RegisterPermActiveStatusCallback([[maybe_unused]] ani_env* env, } if (IsExistRegister(context)) { - ACCESSTOKEN_LOG_ERROR(LABEL, - "Subscribe failed. The current subscriber has existed or Reference_StrictEquals failed!"); + std::string errMsg = GetErrorMessage( + STS_ERROR_NOT_USE_TOGETHER, "The API reuses the same input. The subscriber already exists."); BusinessErrorAni::ThrowError( - env, STSErrorCode::STS_ERROR_NOT_USE_TOGETHER, GetErrorMessage(STSErrorCode::STS_ERROR_NOT_USE_TOGETHER)); + env, STS_ERROR_NOT_USE_TOGETHER, GetErrorMessage(STS_ERROR_NOT_USE_TOGETHER, errMsg)); return; } @@ -545,15 +520,6 @@ static void RegisterPermActiveStatusCallback([[maybe_unused]] ani_env* env, return; } -static bool IsRefUndefined(ani_env* env, const ani_ref& ref) -{ - bool isUndef = false; - if (!AniIsRefUndefined(env, ref, isUndef)) { - return false; - } - return isUndef; -} - static bool FindAndGetSubscriber(const RegisterPermActiveChangeContext* context, std::vector& batchPermActiveChangeSubscribers) { @@ -561,7 +527,7 @@ static bool FindAndGetSubscriber(const RegisterPermActiveChangeContext* context, std::lock_guard lock(g_mutex); bool callbackEqual; ani_ref callbackRef = context->callbackRef; - bool isUndef = IsRefUndefined(context->env, context->callbackRef); + bool isUndef = AniIsRefUndefined(context->env, context->callbackRef); for (const auto& item : g_subScribers) { std::vector permList; item->subscriber->GetPermList(permList); @@ -585,10 +551,7 @@ static bool FindAndGetSubscriber(const RegisterPermActiveChangeContext* context, } } } - if (!batchPermActiveChangeSubscribers.empty()) { - return true; - } - return false; + return !batchPermActiveChangeSubscribers.empty(); } static void DeleteRegisterInVector(const RegisterPermActiveChangeContext* context) @@ -624,50 +587,44 @@ static void UnRegisterPermActiveStatusCallback([[maybe_unused]] ani_env* env, ani_string aniType, ani_array_ref aniArray, ani_ref callback) { if (env == nullptr) { - BusinessErrorAni::ThrowError(env, STS_ERROR_INNER, GetErrorMessage(STSErrorCode::STS_ERROR_INNER)); return; } RegisterPermActiveChangeContext* context = new (std::nothrow) RegisterPermActiveChangeContext(); if (context == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to allocate memory for RegisterPermActiveChangeContext!"); - BusinessErrorAni::ThrowError(env, STS_ERROR_OUT_OF_MEMORY, GetErrorMessage( - STSErrorCode::STS_ERROR_OUT_OF_MEMORY)); return; } context->env = env; std::unique_ptr callbackPtr {context}; - if (!ParseInputToRegister(aniType, aniArray, callback, context, false)) { return; } std::vector batchPermActiveChangeSubscribers; if (!FindAndGetSubscriber(context, batchPermActiveChangeSubscribers)) { - ACCESSTOKEN_LOG_ERROR(LABEL, - "Unsubscribe failed. The current subscriber does not exist or Reference_StrictEquals failed!"); + std::string errMsg = GetErrorMessage( + STS_ERROR_NOT_USE_TOGETHER, "The API is not used in pair with 'on'. The subscriber does not exist."); BusinessErrorAni::ThrowError( - env, STSErrorCode::STS_ERROR_NOT_USE_TOGETHER, GetErrorMessage(STSErrorCode::STS_ERROR_NOT_USE_TOGETHER)); + env, STS_ERROR_NOT_USE_TOGETHER, GetErrorMessage(STS_ERROR_NOT_USE_TOGETHER, errMsg)); return; } for (const auto& item : batchPermActiveChangeSubscribers) { int32_t result = PrivacyKit::UnRegisterPermActiveStatusCallback(item->subscriber); - if (result != RET_SUCCESS) { + if (result == RET_SUCCESS) { + DeleteRegisterInVector(item); + } else { ACCESSTOKEN_LOG_ERROR(LABEL, "UnregisterPermActiveChangeCompleted failed"); int32_t stsCode = GetStsErrorCode(result); BusinessErrorAni::ThrowError(env, stsCode, GetErrorMessage(stsCode)); - return; } - - DeleteRegisterInVector(item); } ACCESSTOKEN_LOG_INFO(LABEL, "UnRegisterPermActiveStatusCallback success!"); return; } -static void StopUsingPermissionExecute([[maybe_unused]] ani_env* env, [[maybe_unused]] ani_object object, - ani_int tokenID, ani_string permissionName, ani_int pid) +static void StopUsingPermissionExecute( + [[maybe_unused]] ani_env* env, ani_int aniTokenID, ani_string aniPermission, ani_int pid) { ACCESSTOKEN_LOG_INFO(LABEL, "StopUsingPermissionExecute begin."); if (env == nullptr) { @@ -675,111 +632,151 @@ static void StopUsingPermissionExecute([[maybe_unused]] ani_env* env, [[maybe_un return; } - std::string permissionNameString; - if (!AniParseString(env, permissionName, permissionNameString)) { - BusinessErrorAni::ThrowParameterTypeError(env, STS_ERROR_PARAM_ILLEGAL, - GetParamErrorMsg("permissionName", "Permissions")); + AccessTokenID tokenID = static_cast(aniTokenID); + std::string permission = ANIStringToStdString(env, static_cast(aniPermission)); + if ((!BusinessErrorAni::ValidateTokenIDdWithThrowError(env, tokenID)) || + (!BusinessErrorAni::ValidatePermissionWithThrowError(env, permission))) { + ACCESSTOKEN_LOG_ERROR(LABEL, "TokenId(%{public}u) or Permission(%{public}s) is invalid.", + tokenID, permission.c_str()); return; } - ACCESSTOKEN_LOG_INFO(LABEL, - "PermissionName : %{public}s, tokenID : %{public}u, pid : %{public}d", - permissionNameString.c_str(), tokenID, pid); + ACCESSTOKEN_LOG_INFO(LABEL, "PermissionName : %{public}s, tokenID : %{public}u, pid : %{public}d", + permission.c_str(), tokenID, pid); - auto retCode = PrivacyKit::StopUsingPermission(tokenID, permissionNameString, pid); + auto retCode = PrivacyKit::StopUsingPermission(tokenID, permission, pid); if (retCode != RET_SUCCESS) { int32_t stsCode = GetStsErrorCode(retCode); BusinessErrorAni::ThrowError(env, stsCode, GetErrorMessage(stsCode)); } } -static void StartUsingPermissionExecute([[maybe_unused]] ani_env* env, [[maybe_unused]] ani_object object, - ani_int tokenID, ani_string permissionName, ani_int pid, PermissionUsedType usedType) +static void StartUsingPermissionExecute([[maybe_unused]] ani_env* env, + ani_int aniTokenID, ani_string aniPermission, ani_int pid, PermissionUsedType usedType) { ACCESSTOKEN_LOG_INFO(LABEL, "StartUsingPermissionExecute begin."); if (env == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Env null"); return; } - - std::string permissionNameString; - if (!AniParseString(env, permissionName, permissionNameString)) { - BusinessErrorAni::ThrowParameterTypeError(env, STS_ERROR_PARAM_ILLEGAL, - GetParamErrorMsg("permissionName", "Permissions")); + AccessTokenID tokenID = static_cast(aniTokenID); + std::string permission = ANIStringToStdString(env, static_cast(aniPermission)); + if ((!BusinessErrorAni::ValidateTokenIDdWithThrowError(env, tokenID)) || + (!BusinessErrorAni::ValidatePermissionWithThrowError(env, permission))) { + ACCESSTOKEN_LOG_ERROR(LABEL, "TokenId(%{public}u) or Permission(%{public}s) is invalid.", + tokenID, permission.c_str()); return; } - ACCESSTOKEN_LOG_INFO(LABEL, - "PermissionName : %{public}s, tokenID : %{public}u, pid : %{public}d, UsedType : %{public}d", - permissionNameString.c_str(), tokenID, pid, usedType); + ACCESSTOKEN_LOG_INFO(LABEL, "PermissionName : %{public}s, tokenID : %{public}u, pid : %{public}d", + permission.c_str(), tokenID, pid); - auto retCode = PrivacyKit::StartUsingPermission(tokenID, permissionNameString, pid, usedType); + auto retCode = PrivacyKit::StartUsingPermission(tokenID, permission, pid, usedType); if (retCode != RET_SUCCESS) { int32_t stsCode = GetStsErrorCode(retCode); BusinessErrorAni::ThrowError(env, stsCode, GetErrorMessage(stsCode)); } } -extern "C" { -ANI_EXPORT ani_status ANI_Constructor(ani_vm* vm, uint32_t* result) + +static ani_object GetPermissionUsedRecordExecute([[maybe_unused]] ani_env* env, ani_object request) { - if (vm == nullptr || result == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "nullptr vm or result"); - return ANI_INVALID_ARGS; + ACCESSTOKEN_LOG_INFO(LABEL, "GetPermissionUsedRecordExecute Call"); + if (env == nullptr || request == nullptr) { + return nullptr; } - ani_env* env; - if (ANI_OK != vm->GetEnv(ANI_VERSION_1, &env)) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Unsupported ANI_VERSION_1"); - return ANI_OUT_OF_MEMORY; + + return nullptr; +} + +static ani_ref GetPermissionUsedTypeInfosExecute([[maybe_unused]] ani_env* env, + ani_int aniTokenID, ani_string aniPermission) +{ + if (env == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Env is null"); } + return nullptr; +} +static void SetPermissionUsedRecordToggleStatusExecute([[maybe_unused]] ani_env* env, ani_boolean status) +{ + ACCESSTOKEN_LOG_INFO(LABEL, "SetPermissionUsedRecordToggleStatusExecute Call"); if (env == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "nullptr env"); - return ANI_NOT_FOUND; - } - - const char* className = "L@ohos/privacyManager/privacyManager/PrivacyManagerInner;"; - ani_class cls; - if (ANI_OK != env->FindClass(className, &cls)) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Not found %{public}s", className); - return ANI_NOT_FOUND; - } - - std::array methods = { - ani_native_function { "addPermissionUsedRecordSync", - "ILstd/core/String;IIL@ohos/privacyManager/privacyManager/AddPermissionUsedRecordOptionsInner;:V", - reinterpret_cast(AddPermissionUsedRecord) }, - ani_native_function { "stopUsingPermissionExecute", - nullptr, - reinterpret_cast(StopUsingPermissionExecute) }, - ani_native_function { "startUsingPermissionExecute", - nullptr, - reinterpret_cast(StartUsingPermissionExecute) }, - }; + return; + } +} - if (ANI_OK != env->Class_BindNativeMethods(cls, methods.data(), methods.size())) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Cannot bind native methods to %{public}s", className); - return ANI_ERROR; - }; +static ani_boolean GetPermissionUsedRecordToggleStatusExecute([[maybe_unused]] ani_env* env) +{ + ACCESSTOKEN_LOG_INFO(LABEL, "GetPermissionUsedRecordToggleStatusExecute Call"); + if (env == nullptr) { + return false; + } + bool isToggleStaus = false; + return isToggleStaus; +} + +void InitPrivacyFunction(ani_env *env) +{ + ACCESSTOKEN_LOG_INFO(LABEL, "InitPrivacyFunction call"); + if (env == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Env is null."); + return; + } + if (env->ResetError() != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "ResetError failed."); + } - static const char *name = "L@ohos/privacyManager/privacyManager;"; ani_namespace ns; - if (ANI_OK != env->FindNamespace(name, &ns)) { - ACCESSTOKEN_LOG_ERROR(LABEL, "FindNamespace %{public}s failed.", name); - return ANI_ERROR; + if (ANI_OK != env->FindNamespace("L@ohos/privacyManager/privacyManager;", &ns)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "FindNamespace privacyManager failed."); + return; } // namespace method input param without ani_object std::array nsMethods = { - ani_native_function { "on", nullptr, reinterpret_cast(RegisterPermActiveStatusCallback) }, - ani_native_function { "off", nullptr, reinterpret_cast(UnRegisterPermActiveStatusCallback) }, - }; - - if (ANI_OK != env->Namespace_BindNativeFunctions(ns, nsMethods.data(), nsMethods.size())) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Namespace_BindNativeFunctions %{public}s failed.", name); - return ANI_ERROR; + ani_native_function {"addPermissionUsedRecordExecute", nullptr, + reinterpret_cast(AddPermissionUsedRecordExecute)}, + ani_native_function {"startUsingPermissionExecute", nullptr, + reinterpret_cast(StartUsingPermissionExecute)}, + ani_native_function {"stopUsingPermissionExecute", nullptr, + reinterpret_cast(StopUsingPermissionExecute)}, + ani_native_function {"getPermissionUsedRecordExecute", nullptr, + reinterpret_cast(GetPermissionUsedRecordExecute)}, + ani_native_function {"getPermissionUsedTypeInfosExecute", nullptr, + reinterpret_cast(GetPermissionUsedTypeInfosExecute)}, + ani_native_function {"setPermissionUsedRecordToggleStatusExecute", + nullptr, reinterpret_cast(SetPermissionUsedRecordToggleStatusExecute)}, + ani_native_function {"getPermissionUsedRecordToggleStatusExecute", + nullptr, reinterpret_cast(GetPermissionUsedRecordToggleStatusExecute)}, + ani_native_function {"onExecute", nullptr, reinterpret_cast(RegisterPermActiveStatusCallback)}, + ani_native_function {"offExecute", nullptr, reinterpret_cast(UnRegisterPermActiveStatusCallback)}, }; + ani_status status = env->Namespace_BindNativeFunctions(ns, nsMethods.data(), nsMethods.size()); + if (status != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Namespace_BindNativeFunctions failed status : %{public}d.", status); + } + if (env->ResetError() != ANI_OK) { + ACCESSTOKEN_LOG_ERROR(LABEL, "ResetError failed."); + } + ACCESSTOKEN_LOG_INFO(LABEL, "InitPrivacyFunction end"); +} +extern "C" { +ANI_EXPORT ani_status ANI_Constructor(ani_vm* vm, uint32_t* result) +{ + ACCESSTOKEN_LOG_INFO(LABEL, "ANI_Constructor begin"); + if (vm == nullptr || result == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "nullptr vm or result"); + return ANI_INVALID_ARGS; + } + ani_env* env; + if (ANI_OK != vm->GetEnv(ANI_VERSION_1, &env)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Unsupported ANI_VERSION_1"); + return ANI_OUT_OF_MEMORY; + } + InitPrivacyFunction(env); *result = ANI_VERSION_1; + ACCESSTOKEN_LOG_INFO(LABEL, "ANI_Constructor end"); return ANI_OK; } }