From c09db4aeeb85e24f7d8b514f7c3dc33c5cd7b7c8 Mon Sep 17 00:00:00 2001 From: hero100 Date: Thu, 10 Apr 2025 17:55:19 +0800 Subject: [PATCH 1/6] =?UTF-8?q?=E5=A4=9A=E8=AE=BE=E5=A4=87=E5=A4=9A?= =?UTF-8?q?=E9=A9=AC=E8=BE=BE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hero100 --- .../vibrator/include/vibrator_napi_utils.h | 24 + .../js/napi/vibrator/src/vibrator_js.cpp | 444 +++++- .../napi/vibrator/src/vibrator_napi_utils.cpp | 174 +++ .../vibrator/all/IMiscdeviceService.idl | 25 +- .../vibrator/include/i_vibrator_client.h | 7 + .../vibrator/include/vibrator_client_proxy.h | 66 + .../vibrator/include/vibrator_client_stub.h | 1 + .../include/vibrator_service_client.h | 57 +- .../vibrator/part/IMiscdeviceService.idl | 23 +- .../vibrator/src/vibrator_client_stub.cpp | 38 +- .../vibrator/src/vibrator_service_client.cpp | 328 ++++- frameworks/native/vibrator/vibrator_agent.cpp | 325 ++++- .../inner_api/vibrator/vibrator_agent.h | 198 +++ .../inner_api/vibrator/vibrator_agent_type.h | 107 ++ services/miscdevice_service/BUILD.gn | 3 + .../include/custom_vibration_matcher.h | 1 + .../src/custom_vibration_matcher.cpp | 17 +- .../adapter/include/compatible_connection.h | 30 +- .../adapter/include/hdi_connection.h | 33 +- .../adapter/include/vibrator_plug_callback.h | 44 + .../adapter/src/compatible_connection.cpp | 54 +- .../adapter/src/hdi_connection.cpp | 254 +++- .../adapter/src/vibrator_plug_callback.cpp | 38 + .../include/i_vibrator_hdi_connection.h | 75 +- .../include/vibrator_hdi_connection.h | 27 +- .../interface/src/vibrator_hdi_connection.cpp | 87 +- .../include/miscdevice_service.h | 90 +- .../include/vibration_priority_manager.h | 5 +- .../include/vibrator_thread.h | 24 +- .../src/miscdevice_service.cpp | 706 +++++++-- .../src/vibration_priority_manager.cpp | 45 +- .../src/vibrator_thread.cpp | 84 +- .../vibrator/native/vibrator_agent_test.cpp | 1264 +++++++++++++++++ utils/common/include/sensors_errors.h | 1 + utils/common/include/vibrator_infos.h | 27 + utils/common/src/vibrator_infos.cpp | 148 ++ 36 files changed, 4415 insertions(+), 459 deletions(-) create mode 100644 frameworks/native/vibrator/include/vibrator_client_proxy.h create mode 100644 services/miscdevice_service/hdi_connection/adapter/include/vibrator_plug_callback.h create mode 100644 services/miscdevice_service/hdi_connection/adapter/src/vibrator_plug_callback.cpp diff --git a/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h b/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h index 3cb87e7..0aee2a4 100644 --- a/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h +++ b/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h @@ -34,10 +34,21 @@ using std::string; constexpr int32_t CALLBACK_NUM = 3; constexpr uint32_t STRING_LENGTH_MAX = 64; +#define CHKNRF(env, state, message) \ + do { \ + if ((state) != napi_ok) { \ + MISC_HILOGE("(%{public}s) fail", #message); \ + return false; \ + } \ + } while (0) + enum CallbackType { SYSTEM_VIBRATE_CALLBACK = 1, COMMON_CALLBACK, IS_SUPPORT_EFFECT_CALLBACK, + GET_VIBRATOR_INFO_LIST, + GET_EFFECT_INFO, + VIBRATOR_STATE_CHANGE, }; struct VibrateInfo { @@ -71,6 +82,11 @@ public: AsyncCallbackError error; CallbackType callbackType = COMMON_CALLBACK; bool isSupportEffect {false}; + std::vector vibratorInfos; + int32_t arrayLength; + //VibratorInfos vibratorInfos[MAX_LOCAL_VIBRATOR_SIZE] = {}; + EffectInfo vibratorEffectInfo; + VibratorDeviceInfo vibratorDeviceInfo; std::string flag; AsyncCallbackInfo(napi_env env) : env(env) {} ~AsyncCallbackInfo(); @@ -94,10 +110,18 @@ bool GetPropertyInt32(const napi_env &env, const napi_value &value, const std::s bool GetPropertyInt64(const napi_env &env, const napi_value &value, const std::string &type, int64_t &result); bool GetNapiParam(const napi_env &env, const napi_callback_info &info, size_t &argc, napi_value &argv); bool ConvertErrorToResult(const napi_env &env, sptr asyncCallbackInfo, napi_value &result); +napi_value ConvertToJsVibratorInfo(const napi_env& env,const VibratorInfos& vibratorInfo); +napi_value ConvertToJsEffectInfo(const napi_env& env, const EffectInfo& effectInfo); bool ConstructCommonResult(const napi_env &env, sptr asyncCallbackInfo, napi_value result[], int32_t length); bool ConstructIsSupportEffectResult(const napi_env &env, sptr asyncCallbackInfo, napi_value result[], int32_t length); +bool ConstructGetVibratorInfoListResult(const napi_env &env, sptr asyncCallbackInfo, + napi_value result[], int32_t length); +bool ConstructIsSupportEffectInfoResult(const napi_env &env, sptr asyncCallbackInfo, + napi_value result[], int32_t length); +bool ConstructVibratorPlugInfoResult(const napi_env &env, sptr asyncCallbackInfo, + napi_value result[], int32_t length); void EmitAsyncCallbackWork(sptr async_callback_info); void EmitPromiseWork(sptr asyncCallbackInfo); bool ClearVibratorPattern(VibratorPattern &vibratorPattern); diff --git a/frameworks/js/napi/vibrator/src/vibrator_js.cpp b/frameworks/js/napi/vibrator/src/vibrator_js.cpp index 0273505..a745d2f 100644 --- a/frameworks/js/napi/vibrator/src/vibrator_js.cpp +++ b/frameworks/js/napi/vibrator/src/vibrator_js.cpp @@ -68,6 +68,9 @@ static std::map g_usageType = { }; static std::set g_allowedTypes = {"time", "preset", "file", "pattern"}; +static std::map>> g_onCallbackInfos; +static std::mutex g_onMutex; +static std::mutex g_mutex; static napi_value EmitAsyncWork(napi_value param, sptr info) { @@ -84,6 +87,7 @@ static napi_value EmitAsyncWork(napi_value param, sptr info) } napi_deferred deferred = nullptr; napi_value promise = nullptr; + MISC_HILOGD("this is promise task"); status = napi_create_promise(info->env, &deferred, &promise); if (status != napi_ok) { MISC_HILOGE("napi_create_promise fail"); @@ -383,9 +387,21 @@ static bool CheckVibratorPatternParameter(VibratorPattern &vibratorPattern) return true; } -bool ParseParameter(napi_env env, napi_value args[], size_t argc, VibrateInfo &info) +bool ParseVibratorParams(napi_env env, napi_value value, VibratorParams ¶ms) { - CHKCF((argc >= PARAMETER_TWO), "Wrong argument number"); + CALL_LOG_ENTER; + bool deviceIdResult = GetPropertyInt32(env, value, "deviceId", params.deviceId); + bool vibratorIdResult = GetPropertyInt32(env, value, "vibratorId", params.vibratorId); + if(deviceIdResult || vibratorIdResult) { + MISC_HILOGI("Get vibrate params success"); + return true; + } + return false; +} + +bool ParseParameter(napi_env env, napi_value args[], size_t argc, VibrateInfo &info, VibratorParams ¶ms) +{ + CHKCF((argc >= PARAMETER_THREE), "Wrong argument number"); CHKCF(GetPropertyString(env, args[0], "type", info.type), "Get vibrate type fail"); if (info.type == "time") { CHKCF(GetPropertyInt32(env, args[0], "duration", info.duration), "Get vibrate duration fail"); @@ -416,22 +432,28 @@ bool ParseParameter(napi_env env, napi_value args[], size_t argc, VibrateInfo &i if (!GetPropertyBool(env, args[1], "systemUsage", info.systemUsage)) { info.systemUsage = false; } + if (!GetPropertyInt32(env, args[1], "deviceId", params.deviceId)) { + params.deviceId = -1; + } + if (!GetPropertyInt32(env, args[1], "id", params.vibratorId)) { + params.vibratorId = -1; + } return true; } -bool SetUsage(const std::string &usage, bool systemUsage) +bool SetUsage(const VibratorParams ¶ms, const std::string &usage, bool systemUsage) { if (auto iter = g_usageType.find(usage); iter == g_usageType.end()) { MISC_HILOGE("Wrong usage type"); return false; } - return SetUsage(g_usageType[usage], systemUsage); + return SetUsageEnhanced(params, g_usageType[usage], systemUsage); } -int32_t CheckParameters(const VibrateInfo &info) +int32_t CheckParameters(const VibrateInfo &info, const VibratorParams ¶ms) { CALL_LOG_ENTER; - if (!SetUsage(info.usage, info.systemUsage)) { + if (!SetUsage(params, info.usage, info.systemUsage)) { MISC_HILOGE("SetUsage fail"); return PARAMETER_ERROR; } @@ -442,32 +464,33 @@ int32_t CheckParameters(const VibrateInfo &info) return ERR_OK; } -int32_t StartVibrate(const VibrateInfo &info) +int32_t StartVibrate(const VibrateInfo &info, const VibratorParams ¶ms) { CALL_LOG_ENTER; - if (CheckParameters(info) != ERR_OK) { + if (CheckParameters(info, params) != ERR_OK) { MISC_HILOGE("CheckParameters fail"); return PARAMETER_ERROR; } if (info.type == "file") { - return PlayVibratorCustom(info.fd, info.offset, info.length); + return PlayVibratorCustomEnhanced(params, info.fd, info.offset, info.length); } else if (info.type == "pattern") { - return PlayPattern(info.vibratorPattern); + return PlayPatternEnhanced(params, info.vibratorPattern); } - return StartVibratorOnce(info.duration); + return StartVibratorOnceEnhanced(params, info.duration); } static napi_value VibrateEffect(napi_env env, napi_value args[], size_t argc) { sptr asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env); CHKPP(asyncCallbackInfo); - if (!ParseParameter(env, args, argc, asyncCallbackInfo->info)) { + VibratorParams params; + if (!ParseParameter(env, args, argc, asyncCallbackInfo->info, params)) { MISC_HILOGE("ParseParameter fail"); ThrowErr(env, PARAMETER_ERROR, "ParseParameter fail"); return nullptr; } if (asyncCallbackInfo->info.type == "preset") { - if (!SetLoopCount(asyncCallbackInfo->info.count) || CheckParameters(asyncCallbackInfo->info) != ERR_OK || + if (!SetLoopCountEnhanced(params, asyncCallbackInfo->info.count) || CheckParameters(asyncCallbackInfo->info, params) != ERR_OK || asyncCallbackInfo->info.effectId.empty()) { MISC_HILOGE("SetLoopCount fail or parameter invalid"); ThrowErr(env, PARAMETER_ERROR, "SetLoopCount fail or parameter invalid"); @@ -475,7 +498,7 @@ static napi_value VibrateEffect(napi_env env, napi_value args[], size_t argc) } asyncCallbackInfo->flag = "preset"; } else { - asyncCallbackInfo->error.code = StartVibrate(asyncCallbackInfo->info); + asyncCallbackInfo->error.code = StartVibrate(asyncCallbackInfo->info, params); if (asyncCallbackInfo->info.vibratorPattern.events != nullptr) { CHKCP(ClearVibratorPattern(asyncCallbackInfo->info.vibratorPattern), "ClearVibratorPattern fail"); } @@ -533,34 +556,48 @@ static napi_value Vibrate(napi_env env, napi_callback_info info) static napi_value Cancel(napi_env env, napi_callback_info info) { - size_t argc = 1; - napi_value args[1] = {}; + size_t argc = 2; + napi_value args[2] = {}; napi_value thisArg = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, args, &thisArg, nullptr); if (status != napi_ok) { ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail"); return nullptr; } + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; sptr asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env); CHKPP(asyncCallbackInfo); - asyncCallbackInfo->error.code = Cancel(); if ((argc > 0) && (IsMatchType(env, args[0], napi_function))) { + asyncCallbackInfo->error.code = CancelEnhanced(params); return EmitAsyncWork(args[0], asyncCallbackInfo); + }else if((argc > 0) && IsMatchType(env, args[0], napi_object) && ParseVibratorParams(env, args[0], params)) { + asyncCallbackInfo->error.code = CancelEnhanced(params); + return EmitAsyncWork(nullptr, asyncCallbackInfo); + }else { + asyncCallbackInfo->error.code = CancelEnhanced(params); + return EmitAsyncWork(nullptr, asyncCallbackInfo); } - return EmitAsyncWork(nullptr, asyncCallbackInfo); } static napi_value Stop(napi_env env, napi_callback_info info) { - size_t argc = 2; - napi_value args[2] = {}; + size_t argc = 3; + napi_value args[3] = {}; napi_value thisArg = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, args, &thisArg, nullptr); if (status != napi_ok) { ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail"); return nullptr; } + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; if (argc >= 1 && IsMatchType(env, args[0], napi_string)) { + MISC_HILOGD("1111111111111111111111111111111111111"); string mode; if (!GetStringValue(env, args[0], mode)) { ThrowErr(env, PARAMETER_ERROR, "Parameters invalid"); @@ -568,16 +605,17 @@ static napi_value Stop(napi_env env, napi_callback_info info) } sptr asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env); CHKPP(asyncCallbackInfo); - asyncCallbackInfo->error.code = StopVibrator(mode.c_str()); + asyncCallbackInfo->error.code = StopVibratorEnhanced(params, mode.c_str()); if ((asyncCallbackInfo->error.code != SUCCESS) && (asyncCallbackInfo->error.code == PARAMETER_ERROR)) { ThrowErr(env, PARAMETER_ERROR, "Parameters invalid"); return nullptr; } - if (argc >= PARAMETER_TWO && IsMatchType(env, args[1], napi_function)) { + if (argc >= PARAMETER_TWO && (IsMatchType(env, args[1], napi_function))) { return EmitAsyncWork(args[1], asyncCallbackInfo); } return EmitAsyncWork(nullptr, asyncCallbackInfo); } else { + MISC_HILOGD("2222222222222222222222222222222222222"); return Cancel(env, info); } } @@ -587,13 +625,22 @@ static napi_value StopVibrationSync(napi_env env, napi_callback_info info) napi_value result = nullptr; napi_get_undefined(env, &result); napi_value thisArg = nullptr; - size_t argc = 0; - napi_status status = napi_get_cb_info(env, info, &argc, nullptr, &thisArg, nullptr); + size_t argc = 1; + napi_value args[1] = {}; + napi_status status = napi_get_cb_info(env, info, &argc, args, &thisArg, nullptr); if (status != napi_ok) { ThrowErr(env, PARAMETER_ERROR, "Get the parameter info fail"); return result; } - int32_t ret = Cancel(); + + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + if (argc >= 1 && IsMatchType(env, args[0], napi_object)) { + ParseVibratorParams(env, args[0], params); + } + int32_t ret = CancelEnhanced(params); if (ret != SUCCESS) { ThrowErr(env, ret, "Cancel execution fail"); } @@ -748,6 +795,345 @@ static napi_value CreateEnumEffectId(const napi_env env, const napi_value export return exports; } +static napi_value CreateEnumEventType(const napi_env& env, napi_value exports) +{ + CALL_LOG_ENTER; + napi_value deviceState = nullptr; + NAPI_CALL(env, napi_create_int32(env, VIBRATOR_DEVICE_STATE_CHANGE , &deviceState)); + + napi_property_descriptor desc[] = { + DECLARE_NAPI_STATIC_PROPERTY("VIBRATOR_DEVICE_STATE_CHANGE", deviceState), + }; + napi_value result = nullptr; + NAPI_CALL(env, napi_define_class(env, "VibratorStateEventType", NAPI_AUTO_LENGTH, EnumClassConstructor, nullptr, + sizeof(desc) / sizeof(*desc), desc, &result)); + NAPI_CALL(env, napi_set_named_property(env, exports, "VibratorStateEventType", result)); + return exports; +} + +static napi_value GetVibratorListSync(napi_env env, napi_callback_info info) { + CALL_LOG_ENTER; + size_t argc = 1; + napi_value args[1] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr)); + + VibratorParams params; + if (argc > 0) { + if (!ParseVibratorParams(env, args[0], params)) { + MISC_HILOGW("deviceId and vibratorId is undefined, set default value deviceId = -1 and vibratorId = -1"); + } + MISC_HILOGD("params=[deviceId=%{public}d, vibratorId=%{pubilc}d]", params.deviceId, params.vibratorId); + } + napi_value jsArray; + NAPI_CALL(env, napi_create_array(env, &jsArray)); + std::vector vibratorInfo; + //VibratorInfos vibratorInfo[MAX_LOCAL_VIBRATOR_SIZE] = {}; c interface + int32_t length = 0; + //int32_t ret = GetVibratorIdList(params, vibratorInfo, length); + int32_t ret = GetVibratorIdList(params, vibratorInfo); + + if (ret == 0) { + for (auto& info : vibratorInfo) { + napi_value jsInfo = ConvertToJsVibratorInfo(env, info); + NAPI_CALL(env, napi_set_element(env, jsArray, length++, jsInfo)); + } + // for (int i = 0; i < length ; ++i) { c interface + // napi_value jsInfo = ConvertToJsVibratorInfo(env, vibratorInfo[i]); + // NAPI_CALL(env, napi_set_element(env, jsArray, i, jsInfo)); + // } + } else { + ThrowErr(env, ret, "Failed to get vibrator list"); + return nullptr; + } + return jsArray; +} + +static napi_value GetVibratorListAsync(napi_env env, napi_callback_info info) { + CALL_LOG_ENTER; + size_t argc = 1; + napi_value args[2] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr)); + + VibratorParams params; + if (argc > 0 && IsMatchType(env, args[0], napi_number)) { + if (!ParseVibratorParams(env, args[0], params)) { + MISC_HILOGW("deviceId and vibratorId is undefined, set default value deviceId = -1 and vibratorId = -1"); + } + MISC_HILOGD("params=[deviceId=%{public}d, vibratorId=%{pubilc}d]", params.deviceId, params.vibratorId); + } + + sptr asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env); + CHKPP(asyncCallbackInfo); + asyncCallbackInfo->callbackType = GET_VIBRATOR_INFO_LIST; + //asyncCallbackInfo->error.code = GetVibratorIdList(params, asyncCallbackInfo->vibratorInfos, asyncCallbackInfo->arrayLength); + asyncCallbackInfo->error.code = GetVibratorIdList(params, asyncCallbackInfo->vibratorInfos); + if ((argc > 0) && IsMatchType(env, args[1], napi_function)) { + return EmitAsyncWork(args[1], asyncCallbackInfo); + } + return EmitAsyncWork(nullptr, asyncCallbackInfo); +} + +static napi_value isSupportEffectInfo(napi_env env, napi_callback_info info) { + CALL_LOG_ENTER; + size_t argc = 2; + napi_value args[2] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr)); + + std::vector buffer(64); + NAPI_CALL(env, napi_get_value_string_utf8(env, args[0], buffer.data(), 64, nullptr)); + std::string effectType(buffer.data()); + MISC_HILOGD("effectType = %{public}s", effectType.c_str()); + + VibratorParams params; + if (argc > 1) { + if (!ParseVibratorParams(env, args[1], params)) { + MISC_HILOGW("deviceId and vibratorId is undefined, set default value deviceId = -1 and vibratorId = -1"); + } + MISC_HILOGD("params=[deviceId=%{public}d, vibratorId=%{pubilc}d]", params.deviceId, params.vibratorId); + } + + EffectInfo effectInfo; + //int32_t ret = GetEffectInfo(params, effectType.c_str(), effectInfo); + int32_t ret = GetEffectInfo(params, effectType, effectInfo); + MISC_HILOGD("isSupportEffect=%{public}s", (effectInfo.isSupportEffect? "true":"false")); + + napi_value jsEffectInfo = nullptr; + if (ret == 0) { + jsEffectInfo = ConvertToJsEffectInfo(env, effectInfo); + } + return jsEffectInfo; +} + +static napi_value isSupportEffectInfoAsync(napi_env env, napi_callback_info info) { + CALL_LOG_ENTER; + size_t argc = 3; + napi_value args[3]; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr)); + + std::vector buffer(64); + NAPI_CALL(env, napi_get_value_string_utf8(env, args[0], buffer.data(), 64, nullptr)); + std::string effectType(buffer.data()); + MISC_HILOGD("effectType = %{public}s", effectType.c_str()); + + VibratorParams params; + if (argc > 1) { + if (!ParseVibratorParams(env, args[1], params)) { + MISC_HILOGW("deviceId and vibratorId is undefined, set default value deviceId = -1 and vibratorId = -1"); + } + MISC_HILOGD("params=[deviceId=%{public}d, vibratorId=%{pubilc}d]", params.deviceId, params.vibratorId); + } + + sptr asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env); + CHKPP(asyncCallbackInfo); + asyncCallbackInfo->callbackType = GET_EFFECT_INFO; + //asyncCallbackInfo->error.code = GetEffectInfo(params, effectType.c_str(), asyncCallbackInfo->vibratorEffectInfo); + asyncCallbackInfo->error.code = GetEffectInfo(params, effectType, asyncCallbackInfo->vibratorEffectInfo); + if ((argc > 1) && (IsMatchType(env, args[2], napi_function))) { + return EmitAsyncWork(args[2], asyncCallbackInfo); + } + return EmitAsyncWork(nullptr, asyncCallbackInfo); +} + +bool IsSameValue(const napi_env &env, const napi_value &lhs, const napi_value &rhs) +{ + CALL_LOG_ENTER; + bool result = false; + CHKNRF(env, napi_strict_equals(env, lhs, rhs, &result), "napi_strict_equals"); + return result; +} + +static bool IsSubscribed(const napi_env& env, int32_t vibratorEventId, napi_value callback) +{ + CALL_LOG_ENTER; + MISC_HILOGD("g_onCallbackInfos.size() = %{public}d", g_onCallbackInfos.size()); + if (g_onCallbackInfos.empty()){ + return true; + } + if (auto iter = g_onCallbackInfos.find(vibratorEventId); iter == g_onCallbackInfos.end()) { + MISC_HILOGW("No client subscribe, vibratorEventId:%{public}d", vibratorEventId); + return false; + } + std::vector> callbackInfos = g_onCallbackInfos[vibratorEventId]; + for (auto callbackInfo : callbackInfos) { + CHKPC(callbackInfo); + if (callbackInfo->env != env) { + continue; + } + napi_value vibratorCallback = nullptr; + CHKNRF(env, napi_get_reference_value(env, callbackInfo->callback[0], &vibratorCallback), + "napi_get_reference_value"); + if (IsSameValue(env, callback, vibratorCallback)) { + return true; + } + } + return false; +} + +static void UpdateCallbackInfos(const napi_env& env, int32_t vibratorEventId, napi_value callback) +{ + CALL_LOG_ENTER; + std::lock_guard onCallbackLock(g_onMutex); + CHKCV(IsSubscribed(env, vibratorEventId, callback), "The callback has been subscribed"); + sptr asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env); + CHKPV(asyncCallbackInfo); + + if (vibratorEventId == 0) { + asyncCallbackInfo->callbackType = VIBRATOR_STATE_CHANGE; + } + napi_status status = napi_create_reference(env, callback, 1, &asyncCallbackInfo->callback[0]); + if (status != napi_ok) { + ThrowErr(env, PARAMETER_ERROR, "napi_create_reference fail"); + return; + } + + std::vector> callbackInfos = g_onCallbackInfos[vibratorEventId]; + callbackInfos.push_back(asyncCallbackInfo); + g_onCallbackInfos[vibratorEventId] = callbackInfos; +} + +static int32_t UpdatePlugInfo(VibratorDeviceInfo *deviceInfo, sptr &asyncCallbackInfo) +{ + CALL_LOG_ENTER; + MISC_HILOGD("deviceInfo : [ type = %{public}d, deviceId = %{public}d]", deviceInfo->type, deviceInfo->deviceId); + CHKPR(deviceInfo, PARAMETER_ERROR); + if (deviceInfo->type == PLUG_STATE_EVENT_UNKNOWN || + deviceInfo->deviceId == -1) { + return PARAMETER_ERROR; + } + asyncCallbackInfo->vibratorDeviceInfo.type = deviceInfo->type; + asyncCallbackInfo->vibratorDeviceInfo.deviceId = deviceInfo->deviceId; + MISC_HILOGD("asyncCallbackInfo->VibratorDeviceInfo : [ VibratorPlugState = %{public}d, deviceId = %{public}d]", + asyncCallbackInfo->vibratorDeviceInfo.type, asyncCallbackInfo->vibratorDeviceInfo.deviceId); + return 0; +} + +void DataCallbackImpl(VibratorDeviceInfo *deviceInfo) +{ + CALL_LOG_ENTER; + CHKPV(deviceInfo); + std::lock_guard subscribeLock(g_mutex); + std::vector> callBackArry; + for (auto& allCallBack : g_onCallbackInfos) { + callBackArry = allCallBack.second; + for (auto& callback : callBackArry) { + if (callback->callbackType == VIBRATOR_STATE_CHANGE) { + MISC_HILOGD("VIBRATOR_STATE_CHANGE"); + callback->error.code = UpdatePlugInfo(deviceInfo, callback); + EmitAsyncCallbackWork(callback); + } + } + } +} + +const VibratorUser user = { + .callback = DataCallbackImpl +}; + +int32_t SubscribeVibrator(RecordVibratorPlugCallback callback) +{ + CALL_LOG_ENTER; + int32_t ret = SubscribeVibrator(user); + if (ret != ERR_OK) { + MISC_HILOGE("SubscribeVibrator failed"); + return ret; + } + return ret; +} + +static napi_value On(napi_env env, napi_callback_info info) { + CALL_LOG_ENTER; + size_t argc = 2; + napi_value args[2]; + napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr); + if (status != napi_ok || argc < 2) { + ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid"); + return nullptr; + } + if ((!IsMatchType(env, args[0], napi_number)) || (!IsMatchType(env, args[1], napi_function))) { + ThrowErr(env, PARAMETER_ERROR, "Wrong argument type"); + return nullptr; + } + int32_t eventType; + status = napi_get_value_int32(env, args[0], &eventType); + if (status != napi_ok) { + ThrowErr(env, PARAMETER_ERROR, "napi_get_value_int32 fail, the number of parameter invalid"); + return nullptr; + } + MISC_HILOGD("eventType = %{public}d", eventType); + + int32_t ret = SubscribeVibrator(DataCallbackImpl); + if (ret != ERR_OK) { + ThrowErr(env, ret, "SubscribeVibrator fail"); + return nullptr; + } + UpdateCallbackInfos(env, eventType, args[1]); + return nullptr; +} + +static int32_t RemoveAllCallback(const napi_env& env, int32_t eventType) +{ + CALL_LOG_ENTER; + std::lock_guard onCallbackLock(g_onMutex); + std::vector> callbackInfos = g_onCallbackInfos[eventType]; + for (auto iter = callbackInfos.begin(); iter != callbackInfos.end();) { + CHKPC(*iter); + if ((*iter)->env != env) { + ++iter; + continue; + } + iter = callbackInfos.erase(iter); + } + if (callbackInfos.empty()) { + MISC_HILOGD("No subscription to change"); + g_onCallbackInfos.erase(eventType); + return 0; + } + g_onCallbackInfos[eventType] = callbackInfos; + return callbackInfos.size(); +} + +static napi_value Off(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr); + if (status != napi_ok || argc < 2) { + ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid"); + return nullptr; + } + if ((!IsMatchType(env, args[0], napi_number)) || (!IsMatchType(env, args[1], napi_function))) { + ThrowErr(env, PARAMETER_ERROR, "Wrong argument type"); + return nullptr; + } + int32_t eventType; + status = napi_get_value_int32(env, args[0], &eventType); + if (status != napi_ok) { + ThrowErr(env, PARAMETER_ERROR, "napi_get_value_int32 fail, the number of parameter invalid"); + return nullptr; + } + + int32_t subscribeSize = -1; + if (IsMatchType(env, args[1], napi_function)) { + subscribeSize = RemoveAllCallback(env, eventType); + } else { + ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, args[1] should is napi_function"); + return nullptr; + } + if (subscribeSize > 0) { + MISC_HILOGW("There are other client subscribe system js api as well, not need unsubscribe"); + return nullptr; + } + + int32_t ret = UnSubscribeVibrator(user); + if (ret != ERR_OK && ret != CALLBACK_UNSUBSCRIBED) { + ThrowErr(env, ret, "UnSubscribeVibrator fail"); + return nullptr; + } else if (ret == CALLBACK_UNSUBSCRIBED) { + MISC_HILOGW("User callback has been unsubscribed"); + return nullptr; + } + return nullptr; +} + static napi_value CreateEnumHapticFeedback(const napi_env env, napi_value exports) { napi_value effectSoft = nullptr; @@ -789,6 +1175,12 @@ static napi_value Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("isHdHapticSupported", IsHdHapticSupported), DECLARE_NAPI_FUNCTION("isSupportEffect", IsSupportEffect), DECLARE_NAPI_FUNCTION("isSupportEffectSync", IsSupportEffectSync), + DECLARE_NAPI_FUNCTION("GetVibratorList", GetVibratorListAsync), + DECLARE_NAPI_FUNCTION("GetVibratorListSync", GetVibratorListSync), + DECLARE_NAPI_FUNCTION("isSupportEffectInfo", isSupportEffectInfoAsync), + DECLARE_NAPI_FUNCTION("isSupportEffectInfoSync", isSupportEffectInfo), + DECLARE_NAPI_FUNCTION("on", On), + DECLARE_NAPI_FUNCTION("off", Off), }; NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(napi_property_descriptor), desc)); NAPI_ASSERT_BASE(env, CreateEnumStopMode(env, exports) != nullptr, "Create enum stop mode fail", exports); @@ -799,6 +1191,8 @@ static napi_value Init(napi_env env, napi_value exports) "CreateClassVibratePattern fail", exports); NAPI_ASSERT_BASE(env, CreateEnumVibratorEventType(env, exports) != nullptr, "Create enum vibrator Event type fail", exports); + NAPI_ASSERT_BASE(env, CreateEnumEventType(env, exports) != nullptr, + "Create enum Event type fail", exports); return exports; } diff --git a/frameworks/js/napi/vibrator/src/vibrator_napi_utils.cpp b/frameworks/js/napi/vibrator/src/vibrator_napi_utils.cpp index bebac3d..63e8b33 100644 --- a/frameworks/js/napi/vibrator/src/vibrator_napi_utils.cpp +++ b/frameworks/js/napi/vibrator/src/vibrator_napi_utils.cpp @@ -258,6 +258,9 @@ bool GetPropertyBool(const napi_env &env, const napi_value &value, const std::st std::map g_convertFuncList = { {COMMON_CALLBACK, ConstructCommonResult}, {IS_SUPPORT_EFFECT_CALLBACK, ConstructIsSupportEffectResult}, + {GET_VIBRATOR_INFO_LIST, ConstructGetVibratorInfoListResult}, + {GET_EFFECT_INFO, ConstructIsSupportEffectInfoResult}, + {VIBRATOR_STATE_CHANGE, ConstructVibratorPlugInfoResult}, }; bool ConvertErrorToResult(const napi_env &env, sptr asyncCallbackInfo, napi_value &result) @@ -304,6 +307,177 @@ bool ConstructIsSupportEffectResult(const napi_env &env, sptr return true; } +napi_value ConvertToJsVibratorInfo(const napi_env& env, const VibratorInfos& vibratorInfo) +{ + CALL_LOG_ENTER; + napi_value jsObject = nullptr; + napi_status status = napi_create_object(env, &jsObject); + if (status != napi_ok) { + return nullptr; + } + MISC_HILOGD("VibratorInfos: [deviceId = %{public}d, vibratorId = %{public}d, deviceName = %{public}s, isSupportHdHaptic = %{public}s, isLocalVibrator = %{public}s]", vibratorInfo.deviceId, + vibratorInfo.vibratorId, vibratorInfo.deviceName.c_str(), (vibratorInfo.isSupportHdHaptic ? "true":"false"), + (vibratorInfo.isLocalVibrator ? "true":"false")); + napi_value jsDeviceId; + status = napi_create_int32(env, vibratorInfo.deviceId, &jsDeviceId); + if (status == napi_ok) { + napi_set_named_property(env, jsObject, "deviceId", jsDeviceId); + } + napi_value jsVibratorId; + status = napi_create_int32(env, vibratorInfo.vibratorId, &jsVibratorId); + if (status == napi_ok) { + napi_set_named_property(env, jsObject, "vibratorId", jsVibratorId); + } + napi_value jsDeviceName; + status = napi_create_string_utf8(env, vibratorInfo.deviceName.c_str(), + vibratorInfo.deviceName.length(), &jsDeviceName); + if (status == napi_ok) { + napi_set_named_property(env, jsObject, "deviceName", jsDeviceName); + } + napi_value jsIsSupportHdHaptic; + status = napi_get_boolean(env, vibratorInfo.isSupportHdHaptic, &jsIsSupportHdHaptic); + if (status == napi_ok) { + napi_set_named_property(env, jsObject, "isSupportHdHaptic", jsIsSupportHdHaptic); + } + napi_value jsIsLocalVibrator; + status = napi_get_boolean(env, vibratorInfo.isLocalVibrator, &jsIsLocalVibrator); + if (status == napi_ok) { + napi_set_named_property(env, jsObject, "isLocalVibrator", jsIsLocalVibrator); + } + return jsObject; +} + +napi_value ConvertToJsEffectInfo(const napi_env& env, const EffectInfo& effectInfo) { + CALL_LOG_ENTER; + napi_value jsObject = nullptr; + napi_status status = napi_create_object(env, &jsObject); + if (status != napi_ok) { + return nullptr; + } + + napi_value jsIsSupportEffect; + status = napi_get_boolean(env, effectInfo.isSupportEffect, &jsIsSupportEffect); + if (status == napi_ok) { + napi_set_named_property(env, jsObject, "isSupportEffect", jsIsSupportEffect); + } + + return jsObject; +} + +napi_value ConvertToJsVibratorPlungInfo(const napi_env& env, const VibratorDeviceInfo& deviceInfo) { + CALL_LOG_ENTER; + MISC_HILOGD("deviceInfo : [type = %{public}d, deviceId = %{public}d]", deviceInfo.type, deviceInfo.deviceId); + bool plugFlag = false; + napi_value jsObject; + napi_status status = napi_create_object(env, &jsObject); + if (status != napi_ok) { + napi_throw_error(env, nullptr, "Failed to create JS object"); + return nullptr; + } + if (deviceInfo.type == PLUG_STATE_EVENT_PLUG_IN) { + plugFlag = true; + } else if (deviceInfo.type == PLUG_STATE_EVENT_PLUG_OUT) { + plugFlag = false; + } + MISC_HILOGD("plugFlag = %{public}s", plugFlag? "true":"false"); + napi_value jsBoolValue; + status = napi_get_boolean(env, plugFlag, &jsBoolValue); + if (status != napi_ok) { + napi_throw_error(env, nullptr, "Failed to create JS property for plugstate"); + return nullptr; + } + status = napi_set_named_property(env, jsObject, "VibratorPlugState", jsBoolValue); + if (status != napi_ok) { + napi_throw_error(env, nullptr, "Failed to set named property 'VibratorPlugState'"); + return nullptr; + } + + napi_value jsDeviceId; + status = napi_create_int32(env, deviceInfo.deviceId, &jsDeviceId); + if (status != napi_ok) { + napi_throw_error(env, nullptr, "Failed to create JS property for deviceId"); + return nullptr; + } + status = napi_set_named_property(env, jsObject, "deviceId", jsDeviceId); + if (status != napi_ok) { + napi_throw_error(env, nullptr, "Failed to set named property 'deviceId'"); + return nullptr; + } + + return jsObject; +} + +bool ConstructGetVibratorInfoListResult(const napi_env &env, sptr asyncCallbackInfo, + napi_value result[], int32_t length) +{ + CALL_LOG_ENTER; + CHKPF(asyncCallbackInfo); + CHKCF(length == RESULT_LENGTH, "Array length is different"); + if (asyncCallbackInfo->error.code != SUCCESS) { + CHKCF(ConvertErrorToResult(env, asyncCallbackInfo, result[0]), "Create napi err fail in async work"); + CHKCF((napi_get_undefined(env, &result[1]) == napi_ok), "napi_get_undefined fail"); + } else { + CHKCF((napi_get_undefined(env, &result[0]) == napi_ok), "napi_get_undefined fail"); + napi_value jsArray; + CHKCF((napi_create_array(env, &jsArray) == napi_ok), "napi_set_element fail"); + for (size_t i = 0; i < asyncCallbackInfo->vibratorInfos.size(); ++i) { + napi_value jsInfo = ConvertToJsVibratorInfo(env, asyncCallbackInfo->vibratorInfos[i]); + CHKPF(jsInfo); + CHKCF((napi_set_element(env, jsArray, i, jsInfo) == napi_ok), "napi_set_element fail"); + } + // for (int32_t i = 0; i < asyncCallbackInfo->arrayLength ; ++i) { + // napi_value jsInfo = ConvertToJsVibratorInfo(env, asyncCallbackInfo->vibratorInfos[i]); + // CHKPF(jsInfo); + // CHKCF((napi_set_element(env, jsArray, i, jsInfo) == napi_ok), "napi_set_element fail"); + // } + result[1] = jsArray; + } + return true; +} + +bool ConstructIsSupportEffectInfoResult(const napi_env &env, sptr asyncCallbackInfo, + napi_value result[], int32_t length) +{ + CALL_LOG_ENTER; + CHKPF(asyncCallbackInfo); + CHKCF(length == RESULT_LENGTH, "Array length is different"); + if (asyncCallbackInfo->error.code != SUCCESS) { + CHKCF(ConvertErrorToResult(env, asyncCallbackInfo, result[0]), "Create napi err fail in async work"); + CHKCF((napi_get_undefined(env, &result[1]) == napi_ok), "napi_get_undefined fail"); + } else { + CHKCF((napi_get_undefined(env, &result[0]) == napi_ok), "napi_get_undefined fail"); + napi_value jsEffectInfo; + jsEffectInfo = ConvertToJsEffectInfo(env, asyncCallbackInfo->vibratorEffectInfo); + CHKPF(jsEffectInfo); + result[1] = jsEffectInfo; + } + return true; +} + +bool ConstructVibratorPlugInfoResult(const napi_env &env, sptr asyncCallbackInfo, + napi_value result[], int32_t length) +{ + CALL_LOG_ENTER; + CHKPF(asyncCallbackInfo); + CHKCF(length == RESULT_LENGTH, "Array length is different"); + if (asyncCallbackInfo->error.code != SUCCESS) { + CHKCF(ConvertErrorToResult(env, asyncCallbackInfo, result[0]), "Create napi err fail in async work"); + CHKCF((napi_get_undefined(env, &result[1]) == napi_ok), "napi_get_undefined fail"); + } else { + CHKCF((napi_get_undefined(env, &result[1]) == napi_ok), "napi_get_undefined fail"); + napi_value jsDevicePlugInfo; + jsDevicePlugInfo = ConvertToJsVibratorPlungInfo(env, asyncCallbackInfo->vibratorDeviceInfo); + CHKPF(jsDevicePlugInfo); + result[0] = jsDevicePlugInfo; + napi_value jsArray; + CHKCF((napi_create_array(env, &jsArray) == napi_ok), "Failed to create array for results"); + CHKCF((napi_set_element(env, jsArray, 0, jsDevicePlugInfo) == napi_ok), "napi_set_element fail"); + + CHKCF((napi_get_undefined(env, &result[1]) == napi_ok), "napi_get_undefined fail"); + } + return true; +} + void EmitSystemCallback(const napi_env &env, sptr asyncCallbackInfo) { CHKPV(asyncCallbackInfo); diff --git a/frameworks/native/vibrator/all/IMiscdeviceService.idl b/frameworks/native/vibrator/all/IMiscdeviceService.idl index 2e2ceea..787c8de 100644 --- a/frameworks/native/vibrator/all/IMiscdeviceService.idl +++ b/frameworks/native/vibrator/all/IMiscdeviceService.idl @@ -21,20 +21,25 @@ sequenceable raw_file_descriptor..OHOS.Sensors.RawFileDescriptor; sequenceable vibrator_infos..OHOS.Sensors.VibrateParameter; sequenceable vibrator_infos..OHOS.Sensors.VibratePattern; sequenceable vibrator_infos..OHOS.Sensors.VibratorCapacity; +sequenceable vibrator_infos..OHOS.Sensors.VibratorParamsIPC; +sequenceable vibrator_infos..OHOS.Sensors.VibratorInfoIPC; +sequenceable vibrator_infos..OHOS.Sensors.EffectInfoIPC; interface OHOS.Sensors.IMiscdeviceService { - void Vibrate([in] int vibratorId, [in] int timeOut, [in] int usage, [in] boolean systemUsage); - void PlayVibratorEffect([in] int vibratorId, [in] String effect, [in] int loopCount, [in] int usage, [in] boolean systemUsage); - void PlayVibratorCustom([in] int vibratorId, [in] FileDescriptor fd, [in] long offset, [in] long length, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter); - void StopVibrator([in] int vibratorId); - void StopVibratorByMode([in] int vibratorId, [in] String mode); - void IsSupportEffect([in] String effect, [out] boolean state); + void Vibrate([in] VibratorParamsIPC params, [in] int vibratorId, [in] int timeOut, [in] int usage, [in] boolean systemUsage); + void PlayVibratorEffect([in] VibratorParamsIPC params, [in] int vibratorId, [in] String effect, [in] int loopCount, [in] int usage, [in] boolean systemUsage); + void PlayVibratorCustom([in] VibratorParamsIPC params, [in] int vibratorId, [in] FileDescriptor fd, [in] long offset, [in] long length, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter); + void StopVibrator([in] VibratorParamsIPC params, [in] int vibratorId); + void StopVibratorByMode([in] VibratorParamsIPC params, [in] int vibratorId, [in] String mode); + void IsSupportEffect([in] VibratorParamsIPC params, [in] String effect, [out] boolean state); void GetLightList([out] LightInfoIPC[] lightInfoIpcList); void TurnOn([in] int lightId, [in] int singleColor, [in] LightAnimationIPC animation); void TurnOff([in] int lightId); - void GetDelayTime([out] int delayTime); - void PlayPattern([in] VibratePattern pattern, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter); + void GetDelayTime([in] VibratorParamsIPC params, [out] int delayTime); + void PlayPattern([in] VibratorParamsIPC params, [in] VibratePattern pattern, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter); void TransferClientRemoteObject([in] IRemoteObject vibratorClient); - void PlayPrimitiveEffect([in] int vibratorId, [in] String effect, [in] int intensity, [in] int usage, [in] boolean systemUsage, [in] int count); - void GetVibratorCapacity([out] VibratorCapacity capacity); + void PlayPrimitiveEffect([in] VibratorParamsIPC params, [in] int vibratorId, [in] String effect, [in] int intensity, [in] int usage, [in] boolean systemUsage, [in] int count); + void GetVibratorCapacity([in] VibratorParamsIPC params, [out] VibratorCapacity capacity); + void GetVibratorIdList([in] VibratorParamsIPC params, [out] VibratorInfoIPC[] vibratorInfoIPC); + void GetEffectInfo([in] VibratorParamsIPC params, [in] String effectType, [out] EffectInfoIPC effectInfoIPC); } \ No newline at end of file diff --git a/frameworks/native/vibrator/include/i_vibrator_client.h b/frameworks/native/vibrator/include/i_vibrator_client.h index 8c83ed0..8aec78a 100644 --- a/frameworks/native/vibrator/include/i_vibrator_client.h +++ b/frameworks/native/vibrator/include/i_vibrator_client.h @@ -22,8 +22,15 @@ namespace OHOS { namespace Sensors { class IVibratorClient : public IRemoteBroker { public: + enum VibratorClientInterFaceId { + GET_FOO_NAME = 0, + SEND_ASYNC_REPLY = 1, + SEND_WRONG_REPLY = 2, + TRANS_ID_PING_ABILITY = 5, + }; IVibratorClient() = default; virtual ~IVibratorClient() = default; + virtual int ProcessPlugEvent(int32_t eventCode, int32_t deviceId) = 0; DECLARE_INTERFACE_DESCRIPTOR(u"IVibratorClient"); }; } // namespace Sensors diff --git a/frameworks/native/vibrator/include/vibrator_client_proxy.h b/frameworks/native/vibrator/include/vibrator_client_proxy.h new file mode 100644 index 0000000..e0ef8e5 --- /dev/null +++ b/frameworks/native/vibrator/include/vibrator_client_proxy.h @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef VIBRATOR_CLIENT_STUB_H +#define VIBRATOR_CLIENT_STUB_H + +#include "message_parcel.h" +#include "miscdevice_log.h" +#include "iremote_proxy.h" +#include "i_vibrator_client.h" + +#undef LOG_TAG +#define LOG_TAG "VibratorClientProxy" + +namespace OHOS { +namespace Sensors { +class VibratorClientProxy : public IRemoteProxy { +public: + explicit VibratorClientProxy(const sptr &impl) : IRemoteProxy(impl){} + virtual ~VibratorClientProxy() = default; + int ProcessPlugEvent(int32_t eventCode, int32_t deviceId) override + { + MessageOption option; + MessageParcel dataParcel; + MessageParcel replyParcel; + + if (!dataParcel.WriteInterfaceToken(GetDescriptor())) { + MISC_HILOGE("Failed to write descriptor to parcelable"); + return PARAMETER_ERROR; + } + if (!dataParcel.WriteInt32(eventCode)) { + MISC_HILOGE("Failed to write eventCode to parcelable"); + return PARAMETER_ERROR; + } + if (!dataParcel.WriteInt32(deviceId)) { + MISC_HILOGE("Failed to write deviceId to parcelable"); + return PARAMETER_ERROR; + } + int error = Remote()->SendRequest(TRANS_ID_PING_ABILITY, dataParcel, replyParcel, option); + if (error != ERR_NONE) { + MISC_HILOGE("failed, error code is: %{public}d", error); + return PARAMETER_ERROR; + } + int result = (error == ERR_NONE) ? replyParcel.ReadInt32() : -1; + return result; + } + +private: + DISALLOW_COPY_AND_MOVE(VibratorClientProxy); + static inline BrokerDelegator delegator_; +}; +} // namespace Sensors +} // namespace OHOS +#endif // VIBRATOR_CLIENT_STUB_H diff --git a/frameworks/native/vibrator/include/vibrator_client_stub.h b/frameworks/native/vibrator/include/vibrator_client_stub.h index 1f55bbd..dab55ed 100644 --- a/frameworks/native/vibrator/include/vibrator_client_stub.h +++ b/frameworks/native/vibrator/include/vibrator_client_stub.h @@ -28,6 +28,7 @@ public: virtual ~VibratorClientStub() = default; virtual int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override; + int ProcessPlugEvent(int32_t eventCode, int32_t deviceId) override; }; } // namespace Sensors } // namespace OHOS diff --git a/frameworks/native/vibrator/include/vibrator_service_client.h b/frameworks/native/vibrator/include/vibrator_service_client.h index 9b5d1c5..4b0134e 100644 --- a/frameworks/native/vibrator/include/vibrator_service_client.h +++ b/frameworks/native/vibrator/include/vibrator_service_client.h @@ -18,6 +18,9 @@ #include #include +#include +#include +#include #include "iremote_object.h" #include "singleton.h" @@ -54,35 +57,47 @@ struct VibratorDecodeHandle { class VibratorServiceClient : public Singleton { public: ~VibratorServiceClient() override; - int32_t Vibrate(int32_t vibratorId, int32_t timeOut, int32_t usage, bool systemUsage); - int32_t Vibrate(int32_t vibratorId, const std::string &effect, int32_t loopCount, int32_t usage, bool systemUsage); + int32_t Vibrate(const VibratorParams ¶ms, int32_t vibratorId, int32_t timeOut, + int32_t usage, bool systemUsage); + int32_t Vibrate(const VibratorParams ¶ms, int32_t vibratorId, const std::string &effect, + int32_t loopCount, int32_t usage, bool systemUsage); #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - int32_t PlayVibratorCustom(int32_t vibratorId, const RawFileDescriptor &rawFd, int32_t usage, - bool systemUsage, const VibratorParameter ¶meter); + int32_t PlayVibratorCustom(const VibratorParams ¶ms, int32_t vibratorId, const RawFileDescriptor &rawFd, + int32_t usage, bool systemUsage, const VibratorParameter ¶meter); #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - int32_t StopVibrator(int32_t vibratorId, const std::string &mode); - int32_t StopVibrator(int32_t vibratorId); - bool IsHdHapticSupported(); - int32_t IsSupportEffect(const std::string &effect, bool &state); + int32_t StopVibrator(const VibratorParams ¶ms, int32_t vibratorId, const std::string &mode); + int32_t StopVibrator(const VibratorParams ¶ms, int32_t vibratorId); + bool IsHdHapticSupported(const VibratorParams ¶ms); + int32_t IsSupportEffect(const VibratorParams ¶ms, const std::string &effect, bool &state); void ProcessDeathObserver(const wptr &object); int32_t PreProcess(const VibratorFileDescription &fd, VibratorPackage &package); - int32_t GetDelayTime(int32_t &delayTime); - int32_t InitPlayPattern(const VibratorPattern &pattern, int32_t usage, bool systemUsage, - const VibratorParameter ¶meter); - int32_t PlayPattern(const VibratorPattern &pattern, int32_t usage, bool systemUsage, - const VibratorParameter ¶meter); + int32_t GetDelayTime(const VibratorParams ¶ms, int32_t &delayTime); + int32_t InitPlayPattern(const VibratorParams ¶ms, const VibratorPattern &pattern, int32_t usage, + bool systemUsage, const VibratorParameter ¶meter); + int32_t PlayPattern(const VibratorParams ¶ms, const VibratorPattern &pattern, int32_t usage, + bool systemUsage, const VibratorParameter ¶meter); int32_t FreeVibratorPackage(VibratorPackage &package); - int32_t PlayPrimitiveEffect(int32_t vibratorId, const std::string &effect, int32_t intensity, int32_t usage, - bool systemUsage, int32_t count); - bool IsSupportVibratorCustom(); + int32_t PlayPrimitiveEffect(const VibratorParams ¶ms, int32_t vibratorId, const std::string &effect, + int32_t intensity, int32_t usage, bool systemUsage, int32_t count); + bool IsSupportVibratorCustom(const VibratorParams ¶ms); int32_t SeekTimeOnPackage(int32_t seekTime, const VibratorPackage &completePackage, VibratorPackage &seekPackage); + int32_t SubscribeVibratorPlugInfo(const VibratorUser *user); + int32_t UnsubscribeVibratorPlugInfo(const VibratorUser *user); + std::set GetSubscribeUserCallback(int32_t deviceId); + bool HandleVibratorData(VibratorDeviceInfo info); + void SetUsage(const VibratorParams ¶ms, int32_t usage, bool systemUsage); + void SetLoopCount(const VibratorParams ¶ms, int32_t count); + void SetParameters(const VibratorParams ¶ms, const VibratorParameter ¶meter); + VibratorEffectParameter GetVibratorEffectParameter(const VibratorParams ¶ms); + int32_t GetVibratorIdList(const VibratorParams& params, std::vector& vibratorInfo); + int32_t GetEffectInfo(const VibratorParams& params,const std::string& effectType, EffectInfo& effectInfo); private: int32_t InitServiceClient(); int32_t LoadDecoderLibrary(const std::string& path); int32_t ConvertVibratorPackage(const VibratePackage& inPkg, VibratorPackage &outPkg); int32_t TransferClientRemoteObject(); - int32_t GetVibratorCapacity(); + int32_t GetVibratorCapacity(const VibratorParams ¶ms, VibratorCapacity &capacity); void ConvertSeekVibratorPackage(const VibratorPackage &completePackage, VibratePackage &convertPackage, int32_t seekTime); void ConvertVibratorPattern(const VibratorPattern &vibratorPattern, VibratePattern &vibratePattern); @@ -94,9 +109,15 @@ private: sptr miscdeviceProxy_ = nullptr; sptr vibratorClient_ = nullptr; VibratorDecodeHandle decodeHandle_; - VibratorCapacity capacity_; + // VibratorCapacity capacity_; std::mutex clientMutex_; std::mutex decodeMutex_; + + std::recursive_mutex subscribeMutex_; + std::set subscribeSet_; + + std::mutex VibratorEffectMutex_; + std::map VibratorEffectMap_; }; } // namespace Sensors } // namespace OHOS diff --git a/frameworks/native/vibrator/part/IMiscdeviceService.idl b/frameworks/native/vibrator/part/IMiscdeviceService.idl index 2415e99..20a1a4d 100644 --- a/frameworks/native/vibrator/part/IMiscdeviceService.idl +++ b/frameworks/native/vibrator/part/IMiscdeviceService.idl @@ -21,19 +21,24 @@ sequenceable raw_file_descriptor..OHOS.Sensors.RawFileDescriptor; sequenceable vibrator_infos..OHOS.Sensors.VibrateParameter; sequenceable vibrator_infos..OHOS.Sensors.VibratePattern; sequenceable vibrator_infos..OHOS.Sensors.VibratorCapacity; +sequenceable vibrator_infos..OHOS.Sensors.VibratorParamsIPC; +sequenceable vibrator_infos..OHOS.Sensors.VibratorInfoIPC; +sequenceable vibrator_infos..OHOS.Sensors.EffectInfoIPC; interface OHOS.Sensors.IMiscdeviceService { - void Vibrate([in] int vibratorId, [in] int timeOut, [in] int usage, [in] boolean systemUsage); - void PlayVibratorEffect([in] int vibratorId, [in] String effect, [in] int loopCount, [in] int usage, [in] boolean systemUsage); - void StopVibrator([in] int vibratorId); - void StopVibratorByMode([in] int vibratorId, [in] String mode); - void IsSupportEffect([in] String effect, [out] boolean state); + void Vibrate([in] VibratorParamsIPC params, [in] int vibratorId, [in] int timeOut, [in] int usage, [in] boolean systemUsage); + void PlayVibratorEffect([in] VibratorParamsIPC params, [in] int vibratorId, [in] String effect, [in] int loopCount, [in] int usage, [in] boolean systemUsage); + void StopVibrator([in] VibratorParamsIPC params, [in] int vibratorId); + void StopVibratorByMode([in] VibratorParamsIPC params, [in] int vibratorId, [in] String mode); + void IsSupportEffect([in] VibratorParamsIPC params, [in] String effect, [out] boolean state); void GetLightList([out] LightInfoIPC[] lightInfoIpcList); void TurnOn([in] int lightId, [in] int singleColor, [in] LightAnimationIPC animation); void TurnOff([in] int lightId); - void GetDelayTime([out] int delayTime); - void PlayPattern([in] VibratePattern pattern, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter); + void GetDelayTime([in] VibratorParamsIPC params, [out] int delayTime); + void PlayPattern([in] VibratorParamsIPC params, [in] VibratePattern pattern, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter); void TransferClientRemoteObject([in] IRemoteObject vibratorClient); - void PlayPrimitiveEffect([in] int vibratorId, [in] String effect, [in] int intensity, [in] int usage, [in] boolean systemUsage, [in] int count); - void GetVibratorCapacity([out] VibratorCapacity capacity); + void PlayPrimitiveEffect([in] VibratorParamsIPC params, [in] int vibratorId, [in] String effect, [in] int intensity, [in] int usage, [in] boolean systemUsage, [in] int count); + void GetVibratorCapacity([in] VibratorParamsIPC params, [out] VibratorCapacity capacity); + void GetVibratorIdList([in] VibratorParamsIPC params, [out] VibratorInfoIPC[] vibratorInfoIPC); + void GetEffectInfo([in] VibratorParamsIPC params, [in] String effectType, [out] EffectInfoIPC effectInfoIPC); } \ No newline at end of file diff --git a/frameworks/native/vibrator/src/vibrator_client_stub.cpp b/frameworks/native/vibrator/src/vibrator_client_stub.cpp index f6dc8c4..ad9fe72 100644 --- a/frameworks/native/vibrator/src/vibrator_client_stub.cpp +++ b/frameworks/native/vibrator/src/vibrator_client_stub.cpp @@ -18,11 +18,13 @@ #include "message_parcel.h" #include "miscdevice_log.h" +#include "vibrator_service_client.h" #undef LOG_TAG #define LOG_TAG "VibratorClientStub" namespace OHOS { namespace Sensors { +using OHOS::Sensors::VibratorServiceClient; int32_t VibratorClientStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) @@ -33,7 +35,41 @@ int32_t VibratorClientStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MISC_HILOGE("Client and service descriptors are inconsistent"); return OBJECT_NULL; } - MISC_HILOGD("Begin, cmd:%{public}u", code); + MISC_HILOGD("Begin, cmd:%{public}u", code); + switch (code) { + case TRANS_ID_PING_ABILITY: { + int32_t eventCode = 0; + int32_t deviceId = -1; + if (!data.ReadInt32(eventCode)) { + MISC_HILOGE("Read eventCode failed."); + return PARAMETER_ERROR; + } + if (!data.ReadInt32(deviceId)) { + MISC_HILOGE("Read eventCode failed."); + return PARAMETER_ERROR; + } + int result = ProcessPlugEvent(eventCode, deviceId); + reply.WriteInt32(result); + return NO_ERROR; + } + } + return NO_ERROR; +} + +int VibratorClientStub::ProcessPlugEvent(int32_t eventCode, int32_t deviceId) +{ + MISC_HILOGD("Begin, eventCode=%{public}d, deviceId:%{public}d", eventCode, deviceId); + VibratorDeviceInfo info = { + .type = static_cast(eventCode), + .deviceId = deviceId + }; + auto &client = VibratorServiceClient::GetInstance(); + bool ret = client.HandleVibratorData(info); + if (!ret) { + MISC_HILOGD("Handle bibrator data failed, ret:%{public}d", ret); + return PARAMETER_ERROR; + } + MISC_HILOGD("Success to process plug event"); return NO_ERROR; } } // namespace Sensors diff --git a/frameworks/native/vibrator/src/vibrator_service_client.cpp b/frameworks/native/vibrator/src/vibrator_service_client.cpp index 9252808..3c96930 100644 --- a/frameworks/native/vibrator/src/vibrator_service_client.cpp +++ b/frameworks/native/vibrator/src/vibrator_service_client.cpp @@ -92,11 +92,6 @@ int32_t VibratorServiceClient::InitServiceClient() MISC_HILOGE("TransferClientRemoteObject failed, ret:%{public}d", ret); return ERROR; } - ret = GetVibratorCapacity(); - if (ret != ERR_OK) { - MISC_HILOGE("GetVibratorCapacity failed, ret:%{public}d", ret); - return ERROR; - } return ERR_OK; } #ifdef HIVIEWDFX_HISYSEVENT_ENABLE @@ -123,7 +118,8 @@ int32_t VibratorServiceClient::TransferClientRemoteObject() return ret; } -int32_t VibratorServiceClient::Vibrate(int32_t vibratorId, int32_t timeOut, int32_t usage, bool systemUsage) +int32_t VibratorServiceClient::Vibrate(const VibratorParams ¶ms, int32_t vibratorId, int32_t timeOut, + int32_t usage, bool systemUsage) { MISC_HILOGD("Vibrate begin, time:%{public}d, usage:%{public}d", timeOut, usage); int32_t ret = InitServiceClient(); @@ -136,7 +132,10 @@ int32_t VibratorServiceClient::Vibrate(int32_t vibratorId, int32_t timeOut, int3 #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "VibrateTime"); #endif // HIVIEWDFX_HITRACE_ENABLE - ret = miscdeviceProxy_->Vibrate(vibratorId, timeOut, usage, systemUsage); + VibratorParamsIPC vibrateParams; + vibrateParams.deviceId = params.deviceId; + vibrateParams.vibratorId = params.vibratorId; + ret = miscdeviceProxy_->Vibrate(vibrateParams, vibratorId, timeOut, usage, systemUsage); WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_VIBRATE, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -147,8 +146,8 @@ int32_t VibratorServiceClient::Vibrate(int32_t vibratorId, int32_t timeOut, int3 return ret; } -int32_t VibratorServiceClient::Vibrate(int32_t vibratorId, const std::string &effect, - int32_t loopCount, int32_t usage, bool systemUsage) +int32_t VibratorServiceClient::Vibrate(const VibratorParams ¶ms, int32_t vibratorId, const std::string &effect, + int32_t loopCount, int32_t usage, bool systemUsage) { MISC_HILOGD("Vibrate begin, effect:%{public}s, loopCount:%{public}d, usage:%{public}d", effect.c_str(), loopCount, usage); @@ -162,7 +161,10 @@ int32_t VibratorServiceClient::Vibrate(int32_t vibratorId, const std::string &ef #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "VibrateEffect"); #endif // HIVIEWDFX_HITRACE_ENABLE - ret = miscdeviceProxy_->PlayVibratorEffect(vibratorId, effect, loopCount, usage, systemUsage); + VibratorParamsIPC vibrateParams; + vibrateParams.deviceId = params.deviceId; + vibrateParams.vibratorId = params.vibratorId; + ret = miscdeviceProxy_->PlayVibratorEffect(vibrateParams, vibratorId, effect, loopCount, usage, systemUsage); WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_PLAY_VIBRATOR_EFFECT, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -175,7 +177,7 @@ int32_t VibratorServiceClient::Vibrate(int32_t vibratorId, const std::string &ef } #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -int32_t VibratorServiceClient::PlayVibratorCustom(int32_t vibratorId, const RawFileDescriptor &rawFd, int32_t usage, +int32_t VibratorServiceClient::PlayVibratorCustom(const VibratorParams ¶ms, int32_t vibratorId, const RawFileDescriptor &rawFd, int32_t usage, bool systemUsage, const VibratorParameter ¶meter) { MISC_HILOGD("Vibrate begin, fd:%{public}d, offset:%{public}lld, length:%{public}lld, usage:%{public}d", @@ -193,8 +195,11 @@ int32_t VibratorServiceClient::PlayVibratorCustom(int32_t vibratorId, const RawF VibrateParameter vibateParameter; vibateParameter.intensity = parameter.intensity; vibateParameter.frequency = parameter.frequency; - ret = miscdeviceProxy_->PlayVibratorCustom(vibratorId, rawFd.fd, rawFd.offset, rawFd.length, usage, systemUsage, - vibateParameter); + VibratorParamsIPC vibrateParams; + vibrateParams.deviceId = params.deviceId; + vibrateParams.vibratorId = params.vibratorId; + ret = miscdeviceProxy_->PlayVibratorCustom(vibrateParams, vibratorId, rawFd.fd, rawFd.offset, + rawFd.length, usage, systemUsage, vibateParameter); WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_PLAY_VIBRATOR_CUSTOM, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -206,7 +211,7 @@ int32_t VibratorServiceClient::PlayVibratorCustom(int32_t vibratorId, const RawF } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -int32_t VibratorServiceClient::StopVibrator(int32_t vibratorId, const std::string &mode) +int32_t VibratorServiceClient::StopVibrator(const VibratorParams ¶ms, int32_t vibratorId, const std::string &mode) { MISC_HILOGD("StopVibrator begin, vibratorId:%{public}d, mode:%{public}s", vibratorId, mode.c_str()); int32_t ret = InitServiceClient(); @@ -219,7 +224,10 @@ int32_t VibratorServiceClient::StopVibrator(int32_t vibratorId, const std::strin #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "StopVibratorByMode"); #endif // HIVIEWDFX_HITRACE_ENABLE - ret = miscdeviceProxy_->StopVibratorByMode(vibratorId, mode); + VibratorParamsIPC vibrateParams; + vibrateParams.deviceId = params.deviceId; + vibrateParams.vibratorId = params.vibratorId; + ret = miscdeviceProxy_->StopVibratorByMode(vibrateParams, vibratorId, mode); WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_STOP_VIBRATOR_BY_MODE, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -230,7 +238,7 @@ int32_t VibratorServiceClient::StopVibrator(int32_t vibratorId, const std::strin return ret; } -int32_t VibratorServiceClient::StopVibrator(int32_t vibratorId) +int32_t VibratorServiceClient::StopVibrator(const VibratorParams ¶ms, int32_t vibratorId) { MISC_HILOGD("StopVibrator begin, vibratorId:%{public}d", vibratorId); int32_t ret = InitServiceClient(); @@ -243,7 +251,10 @@ int32_t VibratorServiceClient::StopVibrator(int32_t vibratorId) #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "StopVibratorAll"); #endif // HIVIEWDFX_HITRACE_ENABLE - ret = miscdeviceProxy_->StopVibrator(vibratorId); + VibratorParamsIPC vibrateParams; + vibrateParams.deviceId = params.deviceId; + vibrateParams.vibratorId = params.vibratorId; + ret = miscdeviceProxy_->StopVibrator(vibrateParams, vibratorId); WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_STOP_VIBRATOR, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -254,7 +265,7 @@ int32_t VibratorServiceClient::StopVibrator(int32_t vibratorId) return ret; } -bool VibratorServiceClient::IsHdHapticSupported() +bool VibratorServiceClient::IsHdHapticSupported(const VibratorParams ¶ms) { CALL_LOG_ENTER; int32_t ret = InitServiceClient(); @@ -262,10 +273,23 @@ bool VibratorServiceClient::IsHdHapticSupported() MISC_HILOGE("InitServiceClient failed, ret:%{public}d", ret); return MISC_NATIVE_GET_SERVICE_ERR; } + VibratorCapacity capacity_; + std::lock_guard clientLock(clientMutex_); + CHKPR(miscdeviceProxy_, ERROR); +#ifdef HIVIEWDFX_HITRACE_ENABLE + StartTrace(HITRACE_TAG_SENSORS, "IsHdHapticSupported"); +#endif // HIVIEWDFX_HITRACE_ENABLE + ret = GetVibratorCapacity(params, capacity_); +#ifdef HIVIEWDFX_HITRACE_ENABLE + FinishTrace(HITRACE_TAG_SENSORS); +#endif // HIVIEWDFX_HITRACE_ENABLE + if (ret != ERR_OK) { + MISC_HILOGE("Is hd haptic supported, ret:%{public}d", ret); + } return capacity_.isSupportHdHaptic; } -int32_t VibratorServiceClient::IsSupportEffect(const std::string &effect, bool &state) +int32_t VibratorServiceClient::IsSupportEffect(const VibratorParams ¶ms, const std::string &effect, bool &state) { MISC_HILOGD("IsSupportEffect begin, effect:%{public}s", effect.c_str()); int32_t ret = InitServiceClient(); @@ -278,7 +302,10 @@ int32_t VibratorServiceClient::IsSupportEffect(const std::string &effect, bool & #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "VibrateEffect"); #endif // HIVIEWDFX_HITRACE_ENABLE - ret = miscdeviceProxy_->IsSupportEffect(effect, state); + VibratorParamsIPC vibrateParams; + vibrateParams.deviceId = params.deviceId; + vibrateParams.vibratorId = params.vibratorId; + ret = miscdeviceProxy_->IsSupportEffect(vibrateParams, effect, state); WriteOtherHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_IS_SUPPORT_EFFECT, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -364,7 +391,7 @@ int32_t VibratorServiceClient::PreProcess(const VibratorFileDescription &fd, Vib return ConvertVibratorPackage(pkg, package); } -int32_t VibratorServiceClient::GetDelayTime(int32_t &delayTime) +int32_t VibratorServiceClient::GetDelayTime(const VibratorParams ¶ms, int32_t &delayTime) { int32_t ret = InitServiceClient(); if (ret != ERR_OK) { @@ -376,7 +403,10 @@ int32_t VibratorServiceClient::GetDelayTime(int32_t &delayTime) #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "GetDelayTime"); #endif // HIVIEWDFX_HITRACE_ENABLE - ret = miscdeviceProxy_->GetDelayTime(delayTime); + VibratorParamsIPC vibrateParams; + vibrateParams.deviceId = params.deviceId; + vibrateParams.vibratorId = params.vibratorId; + ret = miscdeviceProxy_->GetDelayTime(vibrateParams, delayTime); WriteOtherHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_GET_DELAY_TIME, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -387,7 +417,7 @@ int32_t VibratorServiceClient::GetDelayTime(int32_t &delayTime) return ret; } -int32_t VibratorServiceClient::InitPlayPattern(const VibratorPattern &pattern, int32_t usage, +int32_t VibratorServiceClient::InitPlayPattern(const VibratorParams ¶ms, const VibratorPattern &pattern, int32_t usage, bool systemUsage, const VibratorParameter ¶meter) { VibratePattern vibratePattern = {}; @@ -421,14 +451,17 @@ int32_t VibratorServiceClient::InitPlayPattern(const VibratorPattern &pattern, i VibrateParameter vibateParameter; vibateParameter.intensity = parameter.intensity; vibateParameter.frequency = parameter.frequency; + VibratorParamsIPC vibrateParams; + vibrateParams.deviceId = params.deviceId; + vibrateParams.vibratorId = params.vibratorId; std::lock_guard clientLock(clientMutex_); CHKPR(miscdeviceProxy_, ERROR); - int32_t ret = miscdeviceProxy_->PlayPattern(vibratePattern, usage, systemUsage, vibateParameter); + int32_t ret = miscdeviceProxy_->PlayPattern(vibrateParams, vibratePattern, usage, systemUsage, vibateParameter); WriteOtherHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_PLAY_PATTERN, ret); return ret; } -int32_t VibratorServiceClient::PlayPattern(const VibratorPattern &pattern, int32_t usage, +int32_t VibratorServiceClient::PlayPattern(const VibratorParams ¶ms, const VibratorPattern &pattern, int32_t usage, bool systemUsage, const VibratorParameter ¶meter) { MISC_HILOGD("Vibrate begin, usage:%{public}d", usage); @@ -440,7 +473,7 @@ int32_t VibratorServiceClient::PlayPattern(const VibratorPattern &pattern, int32 #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "PlayPattern"); #endif // HIVIEWDFX_HITRACE_ENABLE - ret = InitPlayPattern(pattern, usage, systemUsage, parameter); + ret = InitPlayPattern(params, pattern, usage, systemUsage, parameter); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE @@ -532,7 +565,7 @@ int32_t VibratorServiceClient::FreeVibratorPackage(VibratorPackage &package) return ERR_OK; } -int32_t VibratorServiceClient::PlayPrimitiveEffect(int32_t vibratorId, const std::string &effect, int32_t intensity, +int32_t VibratorServiceClient::PlayPrimitiveEffect(const VibratorParams ¶ms, int32_t vibratorId, const std::string &effect, int32_t intensity, int32_t usage, bool systemUsage, int32_t count) { MISC_HILOGD("Vibrate begin, effect:%{public}s, intensity:%{public}d, usage:%{public}d, count:%{public}d", @@ -547,7 +580,10 @@ int32_t VibratorServiceClient::PlayPrimitiveEffect(int32_t vibratorId, const std #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "PlayPrimitiveEffect"); #endif // HIVIEWDFX_HITRACE_ENABLE - ret = miscdeviceProxy_->PlayPrimitiveEffect(vibratorId, effect, intensity, usage, systemUsage, count); + VibratorParamsIPC vibrateParams; + vibrateParams.deviceId = params.deviceId; + vibrateParams.vibratorId = params.vibratorId; + ret = miscdeviceProxy_->PlayPrimitiveEffect(vibrateParams, vibratorId, effect, intensity, usage, systemUsage, count); WriteOtherHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_PLAY_PRIMITIVE_EFFECT, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -559,26 +595,44 @@ int32_t VibratorServiceClient::PlayPrimitiveEffect(int32_t vibratorId, const std return ret; } -int32_t VibratorServiceClient::GetVibratorCapacity() +int32_t VibratorServiceClient::GetVibratorCapacity(const VibratorParams ¶ms, VibratorCapacity &capacity) { CHKPR(miscdeviceProxy_, ERROR); #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "GetVibratorCapacity"); #endif // HIVIEWDFX_HITRACE_ENABLE - int32_t ret = miscdeviceProxy_->GetVibratorCapacity(capacity_); + VibratorParamsIPC vibrateParams; + vibrateParams.deviceId = params.deviceId; + vibrateParams.vibratorId = params.vibratorId; + int32_t ret = miscdeviceProxy_->GetVibratorCapacity(vibrateParams, capacity); WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_GET_VIBRATOR_CAPACITY, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE - capacity_.Dump(); + capacity.Dump(); return ret; } -bool VibratorServiceClient::IsSupportVibratorCustom() +bool VibratorServiceClient::IsSupportVibratorCustom(const VibratorParams ¶ms) { + MISC_HILOGD("Vibrate begin"); int32_t ret = InitServiceClient(); if (ret != ERR_OK) { MISC_HILOGE("InitServiceClient failed, ret:%{public}d", ret); + return MISC_NATIVE_GET_SERVICE_ERR; + } + VibratorCapacity capacity_; + std::lock_guard clientLock(clientMutex_); + CHKPR(miscdeviceProxy_, ERROR); +#ifdef HIVIEWDFX_HITRACE_ENABLE + StartTrace(HITRACE_TAG_SENSORS, "IsSupportVibratorCustom"); +#endif // HIVIEWDFX_HITRACE_ENABLE + ret = GetVibratorCapacity(params, capacity_); +#ifdef HIVIEWDFX_HITRACE_ENABLE + FinishTrace(HITRACE_TAG_SENSORS); +#endif // HIVIEWDFX_HITRACE_ENABLE + if (ret != ERR_OK) { + MISC_HILOGE("Is support vibrator custom, ret:%{public}d", ret); } return (capacity_.isSupportHdHaptic || capacity_.isSupportPresetMapping || capacity_.isSupportTimeDelay); } @@ -591,6 +645,133 @@ int32_t VibratorServiceClient::SeekTimeOnPackage(int32_t seekTime, const Vibrato return ConvertVibratorPackage(convertPackage, seekPackage); } +int32_t VibratorServiceClient::SubscribeVibratorPlugInfo(const VibratorUser *user) +{ + MISC_HILOGD("In, SubscribeVibratorPlugInfo"); + CHKPR(user, OHOS::Sensors::ERROR); + CHKPR(user->callback, OHOS::Sensors::ERROR); + + int32_t ret = InitServiceClient(); + if (ret != ERR_OK) { + MISC_HILOGE("InitServiceClient failed, ret:%{public}d", ret); + return MISC_NATIVE_GET_SERVICE_ERR; + } + + std::lock_guard subscribeLock(subscribeMutex_); + auto status = subscribeSet_.insert(user); + if (!status.second) { + MISC_HILOGD("User has been subscribed"); + } + return OHOS::Sensors::SUCCESS; +} + +int32_t VibratorServiceClient::UnsubscribeVibratorPlugInfo(const VibratorUser *user) +{ + MISC_HILOGD("In, UnsubscribeVibratorPlugInfo"); + CHKPR(user, OHOS::Sensors::ERROR); + CHKPR(user->callback, OHOS::Sensors::ERROR); + + std::lock_guard subscribeLock(subscribeMutex_); + if (subscribeSet_.find(user) == subscribeSet_.end()) { + MISC_HILOGD("Deactivate user first"); + return OHOS::Sensors::CALLBACK_UNSUBSCRIBED; + } + subscribeSet_.erase(user); + return OHOS::Sensors::SUCCESS; +} + +std::set VibratorServiceClient::GetSubscribeUserCallback(int32_t deviceId) +{ + CALL_LOG_ENTER; + std::lock_guard subscribeLock(subscribeMutex_); + std::set callback; + for (const auto &it : subscribeSet_) { + auto ret = callback.insert(it->callback); + if (!ret.second) { + MISC_HILOGD("callback insert fail"); + } + } + return callback; +} + +bool VibratorServiceClient::HandleVibratorData(VibratorDeviceInfo info) __attribute__((no_sanitize("cfi"))) +{ + CALL_LOG_ENTER; + if(info.type == 1) { + std::lock_guard VibratorEffectLock(VibratorEffectMutex_); + for (auto it = VibratorEffectMap_.begin(); it != VibratorEffectMap_.end(); ) { + if (it->first.deviceId == info.deviceId) { + it = VibratorEffectMap_.erase(it); + } else { + ++it; + } + } + } + std::lock_guard subscribeLock(subscribeMutex_); + auto callbacks = GetSubscribeUserCallback(info.deviceId); + MISC_HILOGD("callbacks.size() = %{public}d", callbacks.size()); + MISC_HILOGD("VibratorDeviceInfo = [type = %{public}d, deviceId = %{public}d]", info.type, info.deviceId); + for (const auto &callback : callbacks) { + MISC_HILOGD("callback is run"); + if(callback != nullptr) + callback(&info); + } + return true; +} + +void VibratorServiceClient::SetUsage(const VibratorParams ¶ms, int32_t usage, bool systemUsage) +{ + std::lock_guard VibratorEffectLock(VibratorEffectMutex_); + auto it = VibratorEffectMap_.find(params); + if (it != VibratorEffectMap_.end()) { + it->second.g_usage = usage; + it->second.g_systemUsage = systemUsage; + } else { + VibratorEffectParameter param = { + .g_usage = usage, + .g_systemUsage = systemUsage, + }; + VibratorEffectMap_[params] = param; + } +} + +void VibratorServiceClient::SetLoopCount(const VibratorParams ¶ms, int32_t count) +{ + std::lock_guard VibratorEffectLock(VibratorEffectMutex_); + auto it = VibratorEffectMap_.find(params); + if (it != VibratorEffectMap_.end()) { + it->second.g_loopCount = count; + } else { + VibratorEffectParameter param = { + .g_loopCount = count, + }; + VibratorEffectMap_[params] = param; + } +} + +void VibratorServiceClient::SetParameters(const VibratorParams ¶ms, const VibratorParameter ¶meter) +{ + std::lock_guard VibratorEffectLock(VibratorEffectMutex_); + auto it = VibratorEffectMap_.find(params); + if (it != VibratorEffectMap_.end()) { + it->second.g_vibratorParameter = parameter; + } else { + VibratorEffectParameter param = { + .g_vibratorParameter = parameter, + }; + VibratorEffectMap_[params] = param; + } +} + +VibratorEffectParameter VibratorServiceClient::GetVibratorEffectParameter(const VibratorParams ¶ms) { + std::lock_guard VibratorEffectLock(VibratorEffectMutex_); + auto it = VibratorEffectMap_.find(params); + if (it != VibratorEffectMap_.end()) { + return it->second; + } + return VibratorEffectParameter(); +} + void VibratorServiceClient::ConvertSeekVibratorPackage(const VibratorPackage &completePackage, VibratePackage &convertPackage, int32_t seekTime) { @@ -681,6 +862,81 @@ bool VibratorServiceClient::SkipEventAndConvertVibratorEvent(const VibratorEvent return false; } +int32_t VibratorServiceClient::GetVibratorIdList(const VibratorParams& params, std::vector& vibratorInfo) +{ + CALL_LOG_ENTER; + MISC_HILOGD("VibratorParams = [deviceId = %{public}d, vibratorId = %{public}d]", params.deviceId, params.vibratorId); + int32_t ret = InitServiceClient(); + if (ret != ERR_OK) { + MISC_HILOGE("InitServiceClient failed, ret:%{public}d", ret); + return MISC_NATIVE_GET_SERVICE_ERR; + } + CHKPR(miscdeviceProxy_, OHOS::Sensors::ERROR); + + VibratorParamsIPC param; + param.deviceId = params.deviceId; + param.vibratorId = params.vibratorId; + std::vector vibratorInfoList; +#ifdef HIVIEWDFX_HITRACE_ENABLE + StartTrace(HITRACE_TAG_SENSORS, "GetVibratorIdList"); +#endif // HIVIEWDFX_HITRACE_ENABLE + ret = miscdeviceProxy_->GetVibratorIdList(param, vibratorInfoList); + WriteOtherHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_GET_VIBRATOR_ID_LIST, ret); +#ifdef HIVIEWDFX_HITRACE_ENABLE + FinishTrace(HITRACE_TAG_SENSORS); +#endif // HIVIEWDFX_HITRACE_ENABLE + if (ret != ERR_OK) { + MISC_HILOGE("Get vibrator info list failed, [ret = %{public}d, deviceId = %{public}d,\ + vibratorId = %{public}d]", ret, params.deviceId, params.vibratorId); + return ret; + } + VibratorInfos resInfo; + for (auto &info : vibratorInfoList) { + resInfo.deviceId = info.deviceId; + resInfo.vibratorId = info.vibratorId; + resInfo.deviceName = info.deviceName; + resInfo.isSupportHdHaptic = info.isSupportHdHaptic; + resInfo.isLocalVibrator = info.isLocalVibrator; + vibratorInfo.push_back(resInfo); + } + return OHOS::Sensors::SUCCESS; +} + +int32_t VibratorServiceClient::GetEffectInfo(const VibratorParams& params, + const std::string& effectType, EffectInfo& effectInfo) +{ + CALL_LOG_ENTER; + MISC_HILOGD("VibratorParams = [deviceId = %{public}d, vibratorId = %{public}d]", + params.deviceId, params.vibratorId); + MISC_HILOGD("effectType = %{public}s", effectType.c_str()); + int32_t ret = InitServiceClient(); + if (ret != OHOS::Sensors::SUCCESS) { + MISC_HILOGE("InitServiceClient failed, ret:%{public}d", ret); + return MISC_NATIVE_GET_SERVICE_ERR; + } + CHKPR(miscdeviceProxy_, OHOS::Sensors::ERROR); + VibratorParamsIPC param; + param.deviceId = params.deviceId; + param.vibratorId = params.vibratorId; + EffectInfoIPC resInfo; +#ifdef HIVIEWDFX_HITRACE_ENABLE + StartTrace(HITRACE_TAG_SENSORS, "GetEffectInfo"); +#endif // HIVIEWDFX_HITRACE_ENABLE + ret = miscdeviceProxy_->GetEffectInfo(param, effectType, resInfo); + WriteOtherHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_GET_EFFECT_INFO, ret); +#ifdef HIVIEWDFX_HITRACE_ENABLE + FinishTrace(HITRACE_TAG_SENSORS); +#endif // HIVIEWDFX_HITRACE_ENABLE +if (ret != ERR_OK) { + MISC_HILOGE("Get effect info list failed, [ret = %{public}d, deviceId = %{public}d, vibratorId = %{public}d,\ + effectType = %{public}s]", ret, params.deviceId, params.vibratorId, effectType.c_str()); + return ret; +} + effectInfo.isSupportEffect = resInfo.isSupportEffect; + return OHOS::Sensors::SUCCESS; +} + + void VibratorServiceClient::WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode code, int32_t ret) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE @@ -710,6 +966,14 @@ void VibratorServiceClient::WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "MISC_SERVICE_IPC_EXCEPTION", HiSysEvent::EventType::FAULT, "PKG_NAME", "GetVibratorCapacity", "ERROR_CODE", ret); break; + case IMiscdeviceServiceIpcCode::COMMAND_GET_VIBRATOR_ID_LIST: + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "MISC_SERVICE_IPC_EXCEPTION", + HiSysEvent::EventType::FAULT, "PKG_NAME", "GetVibratorIdList", "ERROR_CODE", ret); + break; + case IMiscdeviceServiceIpcCode::COMMAND_GET_EFFECT_INFO: + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "MISC_SERVICE_IPC_EXCEPTION", + HiSysEvent::EventType::FAULT, "PKG_NAME", "GetEffectInfo", "ERROR_CODE", ret); + break; default: MISC_HILOGW("Code does not exist, code:%{public}d", static_cast(code)); break; diff --git a/frameworks/native/vibrator/vibrator_agent.cpp b/frameworks/native/vibrator/vibrator_agent.cpp index af47f7b..aa93793 100644 --- a/frameworks/native/vibrator/vibrator_agent.cpp +++ b/frameworks/native/vibrator/vibrator_agent.cpp @@ -28,10 +28,6 @@ using OHOS::Sensors::VibratorServiceClient; namespace { constexpr int32_t DEFAULT_VIBRATOR_ID = 123; -int32_t g_loopCount = 1; -int32_t g_usage = USAGE_UNKNOWN; -bool g_systemUsage = false; -VibratorParameter g_vibratorParameter; const std::string PHONE_TYPE = "phone"; const int32_t INTENSITY_ADJUST_MIN = 0; const int32_t INTENSITY_ADJUST_MAX = 100; @@ -51,6 +47,9 @@ static int32_t NormalizeErrCode(int32_t code) case IS_NOT_SUPPORTED: { return IS_NOT_SUPPORTED; } + case CALLBACK_UNSUBSCRIBED : { + return CALLBACK_UNSUBSCRIBED; + } default: { return DEVICE_OPERATION_FAILED; } @@ -58,24 +57,45 @@ static int32_t NormalizeErrCode(int32_t code) } bool SetLoopCount(int32_t count) +{ + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + return SetLoopCountEnhanced(params, count); +} + +bool SetLoopCountEnhanced(const VibratorParams params, int32_t count) { if (count <= 0) { MISC_HILOGE("Input invalid, count is %{public}d", count); return false; } - g_loopCount = count; + auto &client = VibratorServiceClient::GetInstance(); + client.SetLoopCount(params, count); return true; } + int32_t StartVibrator(const char *effectId) +{ + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + return StartVibratorEnhanced(params, effectId); +} + +int32_t StartVibratorEnhanced(const VibratorParams params, const char *effectId) { MISC_HILOGD("Time delay measurement:start time"); CHKPR(effectId, PARAMETER_ERROR); auto &client = VibratorServiceClient::GetInstance(); - int32_t ret = client.Vibrate(DEFAULT_VIBRATOR_ID, effectId, g_loopCount, g_usage, g_systemUsage); - g_loopCount = 1; - g_usage = USAGE_UNKNOWN; - g_systemUsage = false; + VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(params); + int32_t ret = client.Vibrate(params, DEFAULT_VIBRATOR_ID, effectId, vibratorEffectParameter.g_loopCount, + vibratorEffectParameter.g_usage, vibratorEffectParameter.g_systemUsage); + client.SetUsage(params, USAGE_UNKNOWN, false); + client.SetLoopCount(params, 1); if (ret != ERR_OK) { MISC_HILOGD("Vibrate effectId failed, ret:%{public}d", ret); return NormalizeErrCode(ret); @@ -84,15 +104,25 @@ int32_t StartVibrator(const char *effectId) } int32_t StartVibratorOnce(int32_t duration) +{ + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + return StartVibratorOnceEnhanced(params, duration); +} + +int32_t StartVibratorOnceEnhanced(const VibratorParams params, int32_t duration) { if (duration <= 0) { MISC_HILOGE("duration is invalid"); return PARAMETER_ERROR; } auto &client = VibratorServiceClient::GetInstance(); - int32_t ret = client.Vibrate(DEFAULT_VIBRATOR_ID, duration, g_usage, g_systemUsage); - g_usage = USAGE_UNKNOWN; - g_systemUsage = false; + VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(params); + int32_t ret = client.Vibrate(params, DEFAULT_VIBRATOR_ID, duration, vibratorEffectParameter.g_usage, + vibratorEffectParameter.g_systemUsage); + client.SetUsage(params, USAGE_UNKNOWN, false); if (ret != ERR_OK) { MISC_HILOGD("Vibrate duration failed, ret:%{public}d", ret); return NormalizeErrCode(ret); @@ -101,12 +131,30 @@ int32_t StartVibratorOnce(int32_t duration) } bool IsSupportVibratorCustom() +{ + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + return IsSupportVibratorCustomEnhanced(params); +} + +bool IsSupportVibratorCustomEnhanced(const VibratorParams params) { auto &client = VibratorServiceClient::GetInstance(); - return client.IsSupportVibratorCustom(); + return client.IsSupportVibratorCustom(params); } int32_t PlayVibratorCustom(int32_t fd, int64_t offset, int64_t length) +{ + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + return PlayVibratorCustomEnhanced(params, fd, offset, length); +} + +int32_t PlayVibratorCustomEnhanced(const VibratorParams params, int32_t fd, int64_t offset, int64_t length) { #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM MISC_HILOGD("Time delay measurement:start time"); @@ -121,11 +169,13 @@ int32_t PlayVibratorCustom(int32_t fd, int64_t offset, int64_t length) .offset = offset, .length = length }; - int32_t ret = client.PlayVibratorCustom(DEFAULT_VIBRATOR_ID, rawFd, g_usage, g_systemUsage, g_vibratorParameter); - g_usage = USAGE_UNKNOWN; - g_systemUsage = false; - g_vibratorParameter.intensity = INTENSITY_ADJUST_MAX; - g_vibratorParameter.frequency = 0; + VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(params); + int32_t ret = client.PlayVibratorCustom(params, DEFAULT_VIBRATOR_ID, rawFd, vibratorEffectParameter.g_usage, + vibratorEffectParameter.g_systemUsage, vibratorEffectParameter.g_vibratorParameter); + vibratorEffectParameter.g_vibratorParameter.intensity = INTENSITY_ADJUST_MAX; + vibratorEffectParameter.g_vibratorParameter.frequency = 0; + client.SetUsage(params, USAGE_UNKNOWN, false); + client.SetParameters(params, vibratorEffectParameter.g_vibratorParameter); if (ret != ERR_OK) { MISC_HILOGD("PlayVibratorCustom failed, ret:%{public}d", ret); return NormalizeErrCode(ret); @@ -138,6 +188,15 @@ int32_t PlayVibratorCustom(int32_t fd, int64_t offset, int64_t length) } int32_t StopVibrator(const char *mode) +{ + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + return StopVibratorEnhanced(params, mode); +} + +int32_t StopVibratorEnhanced(const VibratorParams params, const char *mode) { CHKPR(mode, PARAMETER_ERROR); if (strcmp(mode, "time") != 0 && strcmp(mode, "preset") != 0) { @@ -145,7 +204,7 @@ int32_t StopVibrator(const char *mode) return PARAMETER_ERROR; } auto &client = VibratorServiceClient::GetInstance(); - int32_t ret = client.StopVibrator(DEFAULT_VIBRATOR_ID, mode); + int32_t ret = client.StopVibrator(params, DEFAULT_VIBRATOR_ID, mode); if (ret != ERR_OK) { MISC_HILOGD("StopVibrator by mode failed, ret:%{public}d, mode:%{public}s", ret, mode); return NormalizeErrCode(ret); @@ -154,9 +213,18 @@ int32_t StopVibrator(const char *mode) } int32_t Cancel() +{ + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + return CancelEnhanced(params); +} + +int32_t CancelEnhanced(const VibratorParams params) { auto &client = VibratorServiceClient::GetInstance(); - int32_t ret = client.StopVibrator(DEFAULT_VIBRATOR_ID); + int32_t ret = client.StopVibrator(params, DEFAULT_VIBRATOR_ID); if (ret != ERR_OK) { MISC_HILOGD("StopVibrator failed, ret:%{public}d", ret); return NormalizeErrCode(ret); @@ -165,27 +233,54 @@ int32_t Cancel() } bool SetUsage(int32_t usage, bool systemUsage) +{ + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + return SetUsageEnhanced(params, usage, systemUsage); +} + +bool SetUsageEnhanced(const VibratorParams params, int32_t usage, bool systemUsage) { if ((usage < 0) || (usage >= USAGE_MAX)) { MISC_HILOGE("Input invalid, usage is %{public}d", usage); return false; } - g_usage = usage; - g_systemUsage = systemUsage; + auto &client = VibratorServiceClient::GetInstance(); + client.SetUsage(params, usage, systemUsage); return true; } bool IsHdHapticSupported() +{ + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + return IsHdHapticSupportedEnhanced(params); +} + +bool IsHdHapticSupportedEnhanced(const VibratorParams params) { auto &client = VibratorServiceClient::GetInstance(); - return client.IsHdHapticSupported(); + return client.IsHdHapticSupported(params); } int32_t IsSupportEffect(const char *effectId, bool *state) +{ + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + return IsSupportEffectEnhanced(params, effectId, state); +} + +int32_t IsSupportEffectEnhanced(const VibratorParams params, const char *effectId, bool *state) { CHKPR(effectId, PARAMETER_ERROR); auto &client = VibratorServiceClient::GetInstance(); - int32_t ret = client.IsSupportEffect(effectId, *state); + int32_t ret = client.IsSupportEffect(params, effectId, *state); if (ret != ERR_OK) { MISC_HILOGD("Query effect support failed, ret:%{public}d, effectId:%{public}s", ret, effectId); return NormalizeErrCode(ret); @@ -205,9 +300,18 @@ int32_t PreProcess(const VibratorFileDescription &fd, VibratorPackage &package) } int32_t GetDelayTime(int32_t &delayTime) +{ + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + return GetDelayTimeEnhanced(params, delayTime); +} + +int32_t GetDelayTimeEnhanced(const VibratorParams params, int32_t &delayTime) { auto &client = VibratorServiceClient::GetInstance(); - int32_t ret = client.GetDelayTime(delayTime); + int32_t ret = client.GetDelayTime(params, delayTime); if (ret != ERR_OK) { MISC_HILOGD("GetDelayTime failed, ret:%{public}d", ret); return NormalizeErrCode(ret); @@ -216,13 +320,24 @@ int32_t GetDelayTime(int32_t &delayTime) } int32_t PlayPattern(const VibratorPattern &pattern) +{ + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + return PlayPatternEnhanced(params, pattern); +} + +int32_t PlayPatternEnhanced(const VibratorParams params, const VibratorPattern &pattern) { auto &client = VibratorServiceClient::GetInstance(); - int32_t ret = client.PlayPattern(pattern, g_usage, g_systemUsage, g_vibratorParameter); - g_usage = USAGE_UNKNOWN; - g_systemUsage = false; - g_vibratorParameter.intensity = INTENSITY_ADJUST_MAX; - g_vibratorParameter.frequency = 0; + VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(params); + int32_t ret = client.PlayPattern(params, pattern, vibratorEffectParameter.g_usage, vibratorEffectParameter.g_systemUsage, + vibratorEffectParameter.g_vibratorParameter); + vibratorEffectParameter.g_vibratorParameter.intensity = INTENSITY_ADJUST_MAX; + vibratorEffectParameter.g_vibratorParameter.frequency = 0; + client.SetUsage(params, USAGE_UNKNOWN, false); + client.SetParameters(params, vibratorEffectParameter.g_vibratorParameter); if (ret != ERR_OK) { MISC_HILOGD("PlayPattern failed, ret:%{public}d", ret); return NormalizeErrCode(ret); @@ -253,6 +368,15 @@ int32_t FreeVibratorPackage(VibratorPackage &package) } bool SetParameters(const VibratorParameter ¶meter) +{ + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + return SetParametersEnhanced(params, parameter); +} + +bool SetParametersEnhanced(const VibratorParams params, const VibratorParameter ¶meter) { if ((parameter.intensity < INTENSITY_ADJUST_MIN) || (parameter.intensity > INTENSITY_ADJUST_MAX) || (parameter.frequency < FREQUENCY_ADJUST_MIN) || (parameter.frequency > FREQUENCY_ADJUST_MAX)) { @@ -260,25 +384,154 @@ bool SetParameters(const VibratorParameter ¶meter) parameter.intensity, parameter.frequency); return false; } - g_vibratorParameter = parameter; + auto &client = VibratorServiceClient::GetInstance(); + client.SetParameters(params, parameter); return true; } int32_t PlayPrimitiveEffect(const char *effectId, int32_t intensity) +{ + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1 + }; + return PlayPrimitiveEffectEnhanced(params, effectId, intensity); +} + +int32_t PlayPrimitiveEffectEnhanced(const VibratorParams params, const char *effectId, int32_t intensity) { MISC_HILOGD("Time delay measurement:start time"); CHKPR(effectId, PARAMETER_ERROR); auto &client = VibratorServiceClient::GetInstance(); - int32_t ret = client.PlayPrimitiveEffect(DEFAULT_VIBRATOR_ID, effectId, intensity, - g_usage, g_systemUsage, g_loopCount); - g_loopCount = 1; - g_usage = USAGE_UNKNOWN; - g_systemUsage = false; + VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(params); + int32_t ret = client.PlayPrimitiveEffect(params, DEFAULT_VIBRATOR_ID, effectId, intensity, + vibratorEffectParameter.g_usage, vibratorEffectParameter.g_systemUsage, + vibratorEffectParameter.g_loopCount); + client.SetUsage(params, USAGE_UNKNOWN, false); + client.SetLoopCount(params, 1); if (ret != ERR_OK) { MISC_HILOGD("Play primitive effect failed, ret:%{public}d", ret); return NormalizeErrCode(ret); } return SUCCESS; } + +/*================================c++ interface start================================*/ +int32_t GetVibratorIdList(const VibratorParams& param, std::vector& vibratorInfo) +{ + CALL_LOG_ENTER; + CHKCR(¶m, PARAMETER_ERROR, "Invalid parameters"); + MISC_HILOGD("VibratorParams = [deviceId = %{public}d, vibratorId = %{public}d]", param.deviceId, param.vibratorId); + auto &client = VibratorServiceClient::GetInstance(); + int32_t ret = client.GetVibratorIdList(param, vibratorInfo); + if (ret != ERR_OK) { + MISC_HILOGE("Get vibrator list failed, ret:%{public}d", ret); + return NormalizeErrCode(ret); + } + return SUCCESS; +} + +int32_t GetEffectInfo(const VibratorParams& param, const std::string& effectType, EffectInfo& effectInfo) +{ + CALL_LOG_ENTER; + CHKCR(¶m, PARAMETER_ERROR, "Invalid parameters"); + MISC_HILOGD("VibratorParams = [deviceId = %{public}d, vibratorId = %{public}d]", param.deviceId, param.vibratorId); + auto &client = VibratorServiceClient::GetInstance(); + int32_t ret = client.GetEffectInfo(param, effectType, effectInfo); + if (ret != ERR_OK) { + MISC_HILOGE("Get effect info failed, ret:%{public}d", ret); + return NormalizeErrCode(ret); + } + return SUCCESS; +} + +int32_t SubscribeVibrator(const VibratorUser& user) +{ + CALL_LOG_ENTER; + CHKCR(user.callback, PARAMETER_ERROR, "Invalid parameters"); + auto &client = VibratorServiceClient::GetInstance(); + int32_t ret = client.SubscribeVibratorPlugInfo(&user); + if (ret != ERR_OK) { + MISC_HILOGE("SubscribeVibrator failed, ret:%{public}d", ret); + return NormalizeErrCode(ret); + } + return SUCCESS; +} + +int32_t UnSubscribeVibrator(const VibratorUser& user) +{ + CALL_LOG_ENTER; + CHKCR(user.callback, PARAMETER_ERROR, "Invalid parameters"); + auto &client = VibratorServiceClient::GetInstance(); + int32_t ret = client.UnsubscribeVibratorPlugInfo(&user); + if (ret != ERR_OK) { + MISC_HILOGE("UnsubscribeVibratorPlugInfo failed, ret:%{public}d", ret); + return NormalizeErrCode(ret); + } + return SUCCESS; +} +/*================================c++ interface end================================*/ +/*================================c interface start================================*/ +// int32_t GetVibratorIdList(const VibratorParams ¶m, VibratorInfos vibratorInfo[], int32_t &infoSize) +// { +// CALL_LOG_ENTER; +// CHKCR(¶m, PARAMETER_ERROR, "Invalid parameters"); +// auto &client = VibratorServiceClient::GetInstance(); +// std::vector vibratorListInfo; +// int32_t ret = client.GetVibratorIdList(param, vibratorListInfo); +// if (ret != ERR_OK) { +// MISC_HILOGE("Get vibrator list failed, ret:%{public}d", ret); +// return NormalizeErrCode(ret); +// } +// int32_t i = 0; +// for (auto &info : vibratorListInfo) { +// vibratorInfo[i] = info; +// if (i < MAX_LOCAL_VIBRATOR_SIZE) { +// ++i; +// } +// } +// infoSize = vibratorListInfo.size(); +// return SUCCESS; +// } + +// int32_t GetEffectInfo(const VibratorParams ¶m, const char* effectType, EffectInfo &effectInfo) +// { +// CALL_LOG_ENTER; +// CHKCR(¶m, PARAMETER_ERROR, "Invalid parameters"); +// auto &client = VibratorServiceClient::GetInstance(); +// int32_t ret = client.GetEffectInfo(param, effectType, effectInfo); +// if (ret != ERR_OK) { +// MISC_HILOGE("Get effect info failed, ret:%{public}d", ret); +// return NormalizeErrCode(ret); +// } +// return SUCCESS; +// } + +// int32_t SubscribeVibrator(const VibratorUser &user) +// { +// CALL_LOG_ENTER; +// CHKCR(user.callback, PARAMETER_ERROR, "Invalid parameters"); +// auto &client = VibratorServiceClient::GetInstance(); +// int32_t ret = client.SubscribeVibratorPlugInfo(&user); +// if (ret != ERR_OK) { +// MISC_HILOGE("SubscribeVibrator failed, ret:%{public}d", ret); +// return NormalizeErrCode(ret); +// } +// return SUCCESS; +// } + +// int32_t UnSubscribeVibrator(const VibratorUser &user) +// { +// CALL_LOG_ENTER; +// CHKCR(user.callback, PARAMETER_ERROR, "Invalid parameters"); +// auto &client = VibratorServiceClient::GetInstance(); +// int32_t ret = client.UnsubscribeVibratorPlugInfo(&user); +// if (ret != ERR_OK) { +// MISC_HILOGE("UnsubscribeVibratorPlugInfo failed, ret:%{public}d", ret); +// return NormalizeErrCode(ret); +// } +// return SUCCESS; +// } +/*================================c interface end================================*/ } // namespace Sensors } // namespace OHOS \ No newline at end of file diff --git a/interfaces/inner_api/vibrator/vibrator_agent.h b/interfaces/inner_api/vibrator/vibrator_agent.h index 859d7ea..ae2a33b 100644 --- a/interfaces/inner_api/vibrator/vibrator_agent.h +++ b/interfaces/inner_api/vibrator/vibrator_agent.h @@ -29,6 +29,7 @@ */ #ifndef VIBRATOR_AGENT_H #include +#include #include "vibrator_agent_type.h" #define VIBRATOR_AGENT_H @@ -218,6 +219,203 @@ bool SetParameters(const VibratorParameter ¶meter); * @since 12 */ int32_t PlayPrimitiveEffect(const char *effectId, int32_t intensity); + +/** + * @brief Controls this vibrator to perform a vibration with a preset vibration effect. + * + * @param effectId Indicates the preset vibration effect, which is described in {@link vibrator_agent_type.h}, for + * example:{@link VIBRATOR_TYPE_CLOCK_TIMER}: Describes the vibration effect of the vibrator when a user adjusts the + * timer. + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @return Returns 0 if the vibrator vibrates as expected; returns -1 otherwise, for example, the preset + * vibration effect is not supported. + * + * @since 18 + */ +int32_t StartVibratorEnhanced(const VibratorParams param, const char *effectId); + +/** + * @brief Controls this vibrator to perform a one-shot vibration at a given duration. + * + * @param duration Indicates the duration that the one-shot vibration lasts, in milliseconds. + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @return Returns 0 if the vibrator vibrates as expected; returns -1 otherwise, for example, the given + * duration for the one-shot vibration is invalid. + * + * @since 18 + */ +int32_t StartVibratorOnceEnhanced(const VibratorParams param, int32_t duration); + +/** + * @brief Query whether the device supports custom vibration. + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @return Returning true indicates support; otherwise, it indicates no support. + * + * @since 18 + */ +bool IsSupportVibratorCustomEnhanced(const VibratorParams param); + +/** + * @brief Play a custom vibration sequence. + * + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @param fd Indicates the file handle for custom vibration sequence. + * @param offset Indicates the starting address (in bytes) of the custom vibration sequence. + * @param length Indicates the total length (in bytes) of the custom vibration sequence. + * @return Returning 0 indicates success; otherwise, it indicates failure. + * + * @since 18 + */ +int32_t PlayVibratorCustomEnhanced(const VibratorParams param, int32_t fd, int64_t offset, int64_t length); + +/** + * @brief Sets the number of cycles for vibration. + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @param count Indicates the number of cycles for vibration. + * @since 18 + */ +bool SetLoopCountEnhanced(const VibratorParams param, int32_t count); + +/** + * @brief Stop the motor vibration according to the input mode. + * + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @param mode Indicates the mode of the vibration to stop. The values can be time and preset, + * respectively representing a one-shot vibration mode and a preset vibration mode. + * @return Returns 0 if the vibration is stopped as expected; returns -1 otherwise. + * @since 18 + */ +int32_t StopVibratorEnhanced(const VibratorParams param, const char *mode); + +/** + * @brief Cancel the current motor vibration. + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @return Returning 0 indicates success; otherwise, it indicates failure. + * @since 18 + */ +int32_t CancelEnhanced(const VibratorParams param); + +/** + * @brief Set the usage of vibration. + * + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @param usage Indicates the vibration usage, which is described in {@link vibrator_agent_type.h},for + * example:{@link USAGE_ALARM}: Describes the vibration is used for alarm. + * @since 18 + */ +bool SetUsageEnhanced(const VibratorParams param, int32_t usage, bool systemUsage = false); + +/** + * @brief Query whether the HdHaptic is supported. + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @return Returning true indicates support; otherwise, it indicates no support. + * + * @since 18 + */ +bool IsHdHapticSupportedEnhanced(const VibratorParams param); + +/** + * @brief Query whether a vibration effect is supported. + * + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @param effectId Indicates the preset vibration effect, which is described in {@link vibrator_agent_type.h}, for + * example:{@link VIBRATOR_TYPE_CLOCK_TIMER}: Describes the vibration effect of the vibrator when a user adjusts the + * timer. + * @param state Indicates a pointer to the query result. + * @return Returning 0 indicates success; otherwise, it indicates failure. + * + * @since 18 + */ +int32_t IsSupportEffectEnhanced(const VibratorParams param, const char *effectId, bool *state); + +/** + * @brief Obtain the vibration delay, the time interval from the time the vibration is issued + * to the time when the vibration is started, which can be used in the scene of sound + * and vibration coordination. + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @param delayTime: Out of the parameter, return the vibration time delay, the time interval + * from the time the vibration is issued to the start of the vibration, in milliseconds. + * @return 0 indicates success, otherwise indicates failure. + * @since 18 + */ +int32_t GetDelayTimeEnhanced(const VibratorParams param, int32_t &delayTime); + +/** + * @brief Play the vibration sequence. + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @param pattern: Vibration sequences, such as {@link VibratorPattern}. + * @return 0 indicates success, otherwise indicates failure. + * @since 18 + */ +int32_t PlayPatternEnhanced(const VibratorParams params, const VibratorPattern &pattern); + +/** + * @brief Set the vibration effect adjustment parameters. + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @param parameter: Vibration adjustment parameter, such as {@link VibratorParameter}. + * @return true indicates success, otherwise indicates failure. + * @since 18 + */ +bool SetParametersEnhanced(const VibratorParams param, const VibratorParameter ¶meter); + +/** + * @brief Control the vibrator to perform vibration with a preset vibration effect at a certain intensity. + * + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @param effectId Indicates the preset vibration effect, which is described in {@link vibrator_agent_type.h}, for + * example:{@link VIBRATOR_TYPE_HARD}: Describes the hard vibration effect of the vibrator. + * @param intensity Indicates the intensity of vibration, ranging from 1 to 100. + * @return Returns 0 if the vibrator vibrates as expected; otherwise indicates failure. + * + * @since 18 + */ +int32_t PlayPrimitiveEffectEnhanced(const VibratorParams param, const char *effectId, int32_t intensity); + + + + +/** + * @brief Obtains information about this device contains vibrator that support setting intensity and frequency in the system. + * @param vibratorInfo Indicates the pointer to the vibration effect, For details, see {@link VibratorInfo}. + * @return Returns 0 if the operation is successful. + * @return Returns negative value if the get failed. + */ +int32_t GetVibratorIdList(const VibratorParams& param, std::vector& vibratorInfo); + +/** + * @brief Obtains the vibration effect information with the specified effect type. + * @param effectType Indicates the pointer to the preset effect type. It is recommended that the + * maximum length be 64 bytes. + * @param effectInfo Indicates the pointer to the vibration effect information. For details, + * see {@link EffectInfo}. + * @return Returns 0 if the operation is successful. + * @return Returns negative value if the get failed. + */ +int32_t GetEffectInfo(const VibratorParams& param, const std::string& effectType, EffectInfo& effectInfo); + +int32_t SubscribeVibrator(const VibratorUser& user); +int32_t UnSubscribeVibrator(const VibratorUser& user); + + +// int32_t GetVibratorIdList(const VibratorParams ¶m, VibratorInfos vibratorInfo[], int32_t &infoSize); +// int32_t GetEffectInfo(const VibratorParams ¶m, const char* effectType, EffectInfo &effectInfo); +// int32_t SubscribeVibrator(const VibratorUser &user); +// int32_t UnSubscribeVibrator(const VibratorUser &user); + } // namespace Sensors } // namespace OHOS #ifdef __cplusplus diff --git a/interfaces/inner_api/vibrator/vibrator_agent_type.h b/interfaces/inner_api/vibrator/vibrator_agent_type.h index 9c33672..ab80670 100644 --- a/interfaces/inner_api/vibrator/vibrator_agent_type.h +++ b/interfaces/inner_api/vibrator/vibrator_agent_type.h @@ -15,11 +15,23 @@ #ifndef VIBRATOR_AGENT_TYPE_H #define VIBRATOR_AGENT_TYPE_H +#include +#include #ifdef __cplusplus extern "C" { #endif +#ifndef NAME_MAX_LEN +#define NAME_MAX_LEN 128 +#endif /* NAME_MAX_LEN */ +#ifndef VIBRATOR_USER_DATA_SIZE +#define VIBRATOR_USER_DATA_SIZE 104 +#endif /* VIBRATOR_USER_DATA_SIZE */ +// #ifndef MAX_LOCAL_VIBRATOR_SIZE +// #define MAX_LOCAL_VIBRATOR_SIZE 10 +// #endif /* MAX_LOCAL_VIBRATOR_SIZE */ + /** * @brief Describes the vibration effect of the vibrator when a user adjusts the timer. * @@ -225,6 +237,101 @@ typedef struct VibratorParameter { int32_t frequency = 0; // from -100 to 100 int32_t reserved = 0; } VibratorParameter; + +typedef enum VibratorStateEventType { + VIBRATOR_DEVICE_STATE_CHANGE = 0, +} VibratorStateEventType; + +/** + * @brief Represents the information about a vibrator device in the system. + * + * @since 18 + */ +typedef struct VibratorInfos { + int32_t deviceId; + int32_t vibratorId; + std::string deviceName; + bool isSupportHdHaptic; + bool isLocalVibrator; +} VibratorInfos; + +/** + * @brief Represents the parameters for querying vibrator information. + * + * @since 18 + */ +typedef struct VibratorParams { + int32_t deviceId = -1; //Unique identifier for the device that contains the vibrator. + int32_t vibratorId = -1; + bool operator<(const VibratorParams& other) const { + if (deviceId != other.deviceId) { + return deviceId < other.deviceId; + } + return vibratorId < other.vibratorId; + } +} VibratorParams; + +/** + * @brief Defines the vibration effect information. + * + * The information include the capability to set the effect and the vibration duration of the effect. + * + * @since 18 + */ +typedef struct EffectInfo { + bool isSupportEffect; +} EffectInfo; + +typedef enum VibratorPlugState { + PLUG_STATE_EVENT_UNKNOWN = -1, /**< Unknown plug and unplug state event */ + PLUG_STATE_EVENT_PLUG_IN = 0, /**< Event indicating that the vibrator is plugged in */ + PLUG_STATE_EVENT_PLUG_OUT = 1, /**< Event indicating that the vibrator is unplugged */ + PLUG_STATE_EVENT_ONLINE = 2, /**< Event indicating that the vibrator is online */ + PLUG_STATE_EVENT_OFFLINE = 3 /**< Event indicating that the vibrator is offline */ +} VibratorPlugState; + +typedef struct VibratorDeviceInfo { + VibratorPlugState type = PLUG_STATE_EVENT_UNKNOWN; + int32_t deviceId = 0; +} VibratorDeviceInfo; + +/** + * @brief Defines the callback for data reporting by the sensor agent. + * + * @since 18 + */ +typedef void (*RecordVibratorPlugCallback)(VibratorDeviceInfo *deviceInfo); + +/** + * @brief Defines a reserved field for the sensor data subscriber. + * + * @since 18 + */ +typedef struct UserData { + char userData[VIBRATOR_USER_DATA_SIZE]; /**< Reserved for the sensor data subscriber */ +} UserData; + +/** + * @brief Defines information about the sensor data subscriber. + * + * @since 18 + */ +typedef struct VibratorUser { + RecordVibratorPlugCallback callback; /**< Callback for reporting sensor data */ + UserData *userData = nullptr; /**< Reserved field for the sensor data subscriber */ +} VibratorUser; + +/** + * @brief Defines information about vibrator effects + * + * @since 18 + */ +typedef struct VibratorEffectParameter { + int32_t g_loopCount = 1; + int32_t g_usage = USAGE_UNKNOWN; + bool g_systemUsage = false; + VibratorParameter g_vibratorParameter; +}VibratorEffectParameter; /** @} */ #ifdef __cplusplus }; diff --git a/services/miscdevice_service/BUILD.gn b/services/miscdevice_service/BUILD.gn index 418469d..0c37eef 100644 --- a/services/miscdevice_service/BUILD.gn +++ b/services/miscdevice_service/BUILD.gn @@ -20,6 +20,7 @@ ohos_shared_library("libmiscdevice_service") { "hdi_connection/adapter/src/compatible_light_connection.cpp", "hdi_connection/interface/src/light_hdi_connection.cpp", "hdi_connection/interface/src/vibrator_hdi_connection.cpp", + "hdi_connection/adapter/src/vibrator_plug_callback.cpp", "src/miscdevice_common_event_subscriber.cpp", "src/miscdevice_dump.cpp", "src/miscdevice_observer.cpp", @@ -105,6 +106,7 @@ ohos_shared_library("libmiscdevice_service") { "drivers_interface_vibrator:libvibrator_proxy_1.1", "drivers_interface_vibrator:libvibrator_proxy_1.2", "drivers_interface_vibrator:libvibrator_proxy_1.3", + "drivers_interface_vibrator:libvibrator_proxy_2.0", ] } @@ -219,6 +221,7 @@ ohos_static_library("libmiscdevice_service_static") { "drivers_interface_vibrator:libvibrator_proxy_1.1", "drivers_interface_vibrator:libvibrator_proxy_1.2", "drivers_interface_vibrator:libvibrator_proxy_1.3", + "drivers_interface_vibrator:libvibrator_proxy_2.0", ] } diff --git a/services/miscdevice_service/haptic_matcher/include/custom_vibration_matcher.h b/services/miscdevice_service/haptic_matcher/include/custom_vibration_matcher.h index 1df08ed..463c732 100644 --- a/services/miscdevice_service/haptic_matcher/include/custom_vibration_matcher.h +++ b/services/miscdevice_service/haptic_matcher/include/custom_vibration_matcher.h @@ -26,6 +26,7 @@ class CustomVibrationMatcher { public: ~CustomVibrationMatcher() = default; static CustomVibrationMatcher &GetInstance(); + CustomVibrationMatcher(const VibratorParamsIPC& params, std::vector wareInfo); #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR int32_t TransformTime(const VibratePackage &package, std::vector &compositeEffects); int32_t TransformEffect(const VibratePackage &package, std::vector &compositeEffects); diff --git a/services/miscdevice_service/haptic_matcher/src/custom_vibration_matcher.cpp b/services/miscdevice_service/haptic_matcher/src/custom_vibration_matcher.cpp index 27967db..e1ef862 100644 --- a/services/miscdevice_service/haptic_matcher/src/custom_vibration_matcher.cpp +++ b/services/miscdevice_service/haptic_matcher/src/custom_vibration_matcher.cpp @@ -54,7 +54,10 @@ CustomVibrationMatcher::CustomVibrationMatcher() { #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR auto &VibratorDevice = VibratorHdiConnection::GetInstance(); - int32_t ret = VibratorDevice.GetAllWaveInfo(hdfWaveInfos_); + VibratorParamsIPC params; + params.deviceId = -1; + params.vibratorId = -1; + int32_t ret = VibratorDevice.GetAllWaveInfo(params, hdfWaveInfos_); if (ret != ERR_OK) { MISC_HILOGE("GetAllWaveInfo failed infoSize:%{public}zu", hdfWaveInfos_.size()); return; @@ -68,6 +71,18 @@ CustomVibrationMatcher::CustomVibrationMatcher() } } +CustomVibrationMatcher::CustomVibrationMatcher(const VibratorParamsIPC& params, std::vector wareInfo) +{ + hdfWaveInfos_ = wareInfo; + if (!hdfWaveInfos_.empty()) { + for (auto it = hdfWaveInfos_.begin(); it != hdfWaveInfos_.end(); ++it) { + MISC_HILOGI("waveId:%{public}d, intensity:%{public}f, frequency:%{public}f, duration:%{public}d", + it->waveId, it->intensity, it->frequency, it->duration); + } + NormalizedWaveInfo(); + } +} + void CustomVibrationMatcher::NormalizedWaveInfo() { CALL_LOG_ENTER; diff --git a/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h b/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h index 954c274..802b1e5 100644 --- a/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h +++ b/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h @@ -27,25 +27,31 @@ public: CompatibleConnection() = default; virtual ~CompatibleConnection() {}; int32_t ConnectHdi() override; - int32_t StartOnce(uint32_t duration) override; - int32_t Start(const std::string &effectType) override; + int32_t StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) override; + int32_t Start(const VibratorParamsIPC ¶ms, const std::string &effectType) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - int32_t EnableCompositeEffect(const HdfCompositeEffect &hdfCompositeEffect) override; - bool IsVibratorRunning() override; + int32_t EnableCompositeEffect(const VibratorParamsIPC ¶ms, const HdfCompositeEffect &hdfCompositeEffect) override; + bool IsVibratorRunning(const VibratorParamsIPC ¶ms) override; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - std::optional GetEffectInfo(const std::string &effect) override; - int32_t Stop(HdfVibratorModeV1_2 mode) override; + std::optional GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effect) override; + int32_t Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR - int32_t GetDelayTime(int32_t mode, int32_t &delayTime) override; - int32_t GetVibratorCapacity(VibratorCapacity &capacity) override; - int32_t PlayPattern(const VibratePattern &pattern) override; + int32_t GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) override; + int32_t GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) override; + int32_t PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) override; int32_t DestroyHdiConnection() override; - int32_t StartByIntensity(const std::string &effect, int32_t intensity) override; + int32_t StartByIntensity(const VibratorParamsIPC ¶ms, const std::string &effect, int32_t intensity) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - int32_t GetAllWaveInfo(std::vector &waveInfos) override; + int32_t GetVibratorInfo(std::vector &hdfVibratorInfo) override; + int32_t GetAllWaveInfo(const VibratorParamsIPC ¶ms, std::vector &waveInfos) override; + int32_t GetVibratorIdList(const VibratorParamsIPC ¶ms, std::vector &vibratorInfoIpc) override; + int32_t GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, + HdfEffectInfo &effectInfo) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR - + int32_t RegisterVibratorPlugCallback(DevicePlugCallback cb) override; + DevicePlugCallback GetVibratorPlugCb() override; + private: DISALLOW_COPY_AND_MOVE(CompatibleConnection); std::thread vibrateThread_; diff --git a/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h b/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h index 0c4426f..a50007c 100644 --- a/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h +++ b/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h @@ -17,14 +17,14 @@ #define HDI_CONNECTION_H #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR -#include "v1_3/vibrator_interface_proxy.h" +#include "v2_0/vibrator_interface_proxy.h" #endif // HDF_DRIVERS_INTERFACE_VIBRATOR #include "death_recipient_template.h" #include "i_vibrator_hdi_connection.h" #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR -using OHOS::HDI::Vibrator::V1_3::IVibratorInterface; +using OHOS::HDI::Vibrator::V2_0::IVibratorInterface; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR namespace OHOS { namespace Sensors { @@ -33,25 +33,31 @@ public: HdiConnection() = default; virtual ~HdiConnection() {}; int32_t ConnectHdi() override; - int32_t StartOnce(uint32_t duration) override; - int32_t Start(const std::string &effectType) override; + int32_t StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) override; + int32_t Start(const VibratorParamsIPC ¶ms, const std::string &effectType) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - int32_t EnableCompositeEffect(const HdfCompositeEffect &hdfCompositeEffect) override; - bool IsVibratorRunning() override; + int32_t EnableCompositeEffect(const VibratorParamsIPC ¶ms, const HdfCompositeEffect &hdfCompositeEffect) override; + bool IsVibratorRunning(const VibratorParamsIPC ¶ms) override; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - std::optional GetEffectInfo(const std::string &effect) override; - int32_t Stop(HdfVibratorModeV1_2 mode) override; + std::optional GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effect) override; + int32_t Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR - int32_t GetDelayTime(int32_t mode, int32_t &delayTime) override; - int32_t GetVibratorCapacity(VibratorCapacity &capacity) override; - int32_t PlayPattern(const VibratePattern &pattern) override; + int32_t GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) override; + int32_t GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) override; + int32_t PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) override; int32_t DestroyHdiConnection() override; void ProcessDeathObserver(const wptr &object); - int32_t StartByIntensity(const std::string &effect, int32_t intensity) override; + int32_t StartByIntensity(const VibratorParamsIPC ¶ms, const std::string &effect, int32_t intensity) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - int32_t GetAllWaveInfo(std::vector &waveInfos) override; + int32_t GetVibratorInfo(std::vector &hdfVibratorInfo) override; + int32_t GetAllWaveInfo(const VibratorParamsIPC ¶ms, std::vector &waveInfos) override; + int32_t GetVibratorIdList(const VibratorParamsIPC ¶ms, std::vector &vibratorInfoIpc) override; + int32_t GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, + HdfEffectInfo &effectInfo) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR + int32_t RegisterVibratorPlugCallback(DevicePlugCallback cb) override; + DevicePlugCallback GetVibratorPlugCb() override; private: DISALLOW_COPY_AND_MOVE(HdiConnection); @@ -59,6 +65,7 @@ private: sptr vibratorInterface_ = nullptr; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR sptr hdiDeathObserver_ = nullptr; + static DevicePlugCallback devicePlugCb_; void RegisterHdiDeathRecipient(); void UnregisterHdiDeathRecipient(); void Reconnect(); diff --git a/services/miscdevice_service/hdi_connection/adapter/include/vibrator_plug_callback.h b/services/miscdevice_service/hdi_connection/adapter/include/vibrator_plug_callback.h new file mode 100644 index 0000000..461f273 --- /dev/null +++ b/services/miscdevice_service/hdi_connection/adapter/include/vibrator_plug_callback.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + #ifndef VIBRATOR_PLUG_CALLBACK_H + #define VIBRATOR_PLUG_CALLBACK_H + + #include + #include + #include + + #include + #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR + #include "v2_0/ivibrator_interface.h" + #include "v2_0/ivibrator_plug_callback.h" + #include "v2_0/vibrator_types.h" + #endif // HDF_DRIVERS_INTERFACE_VIBRATOR + + #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR + using OHOS::HDI::Vibrator::V2_0::IVibratorPlugCallback; + #endif // HDF_DRIVERS_INTERFACE_VIBRATOR + + namespace OHOS { + namespace Sensors { + class VibratorPlugCallback : public IVibratorPlugCallback { + public: + virtual ~VibratorPlugCallback() {} + int32_t OnVibratorPlugEvent(const HdfVibratorPlugInfo &vibratorPlugInfo) override; + }; + } // namespace Sensors + } // namespace OHOS + #endif // VIBRATOR_PLUG_CALLBACK_H + \ No newline at end of file diff --git a/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp b/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp index ebecb24..d9d85d0 100644 --- a/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp +++ b/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp @@ -43,7 +43,7 @@ std::unordered_map g_vibratorEffect = { {"haptic.notice.warning", 2200} }; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR -HdfVibratorModeV1_2 g_vibrateMode; +HdfVibratorMode g_vibrateMode; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR constexpr int32_t VIBRATE_DELAY_TIME = 10; } // namespace @@ -56,7 +56,7 @@ int32_t CompatibleConnection::ConnectHdi() return ERR_OK; } -int32_t CompatibleConnection::StartOnce(uint32_t duration) +int32_t CompatibleConnection::StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) { CALL_LOG_ENTER; duration_ = static_cast(duration); @@ -71,7 +71,7 @@ int32_t CompatibleConnection::StartOnce(uint32_t duration) return ERR_OK; } -int32_t CompatibleConnection::Start(const std::string &effectType) +int32_t CompatibleConnection::Start(const VibratorParamsIPC ¶ms, const std::string &effectType) { CALL_LOG_ENTER; if (g_vibratorEffect.find(effectType) == g_vibratorEffect.end()) { @@ -93,7 +93,8 @@ int32_t CompatibleConnection::Start(const std::string &effectType) #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -int32_t CompatibleConnection::EnableCompositeEffect(const HdfCompositeEffect &hdfCompositeEffect) +int32_t CompatibleConnection::EnableCompositeEffect(const VibratorParamsIPC ¶ms, + const HdfCompositeEffect &hdfCompositeEffect) { CALL_LOG_ENTER; if (hdfCompositeEffect.compositeEffects.empty()) { @@ -118,14 +119,14 @@ int32_t CompatibleConnection::EnableCompositeEffect(const HdfCompositeEffect &hd return ERR_OK; } -bool CompatibleConnection::IsVibratorRunning() +bool CompatibleConnection::IsVibratorRunning(const VibratorParamsIPC ¶ms) { CALL_LOG_ENTER; return (!isStop_); } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -std::optional CompatibleConnection::GetEffectInfo(const std::string &effect) +std::optional CompatibleConnection::GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effect) { CALL_LOG_ENTER; HdfEffectInfo effectInfo; @@ -140,7 +141,7 @@ std::optional CompatibleConnection::GetEffectInfo(const std::stri return effectInfo; } -int32_t CompatibleConnection::Stop(HdfVibratorModeV1_2 mode) +int32_t CompatibleConnection::Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) { CALL_LOG_ENTER; if (mode < 0 || mode >= HDF_VIBRATOR_MODE_BUTT) { @@ -160,19 +161,19 @@ int32_t CompatibleConnection::Stop(HdfVibratorModeV1_2 mode) } #endif // HDF_DRIVERS_INTERFACE_VIBRATOR -int32_t CompatibleConnection::GetDelayTime(int32_t mode, int32_t &delayTime) +int32_t CompatibleConnection::GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) { CALL_LOG_ENTER; delayTime = VIBRATE_DELAY_TIME; return ERR_OK; } -int32_t CompatibleConnection::GetVibratorCapacity(VibratorCapacity &capacity) +int32_t CompatibleConnection::GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) { return ERR_OK; } -int32_t CompatibleConnection::PlayPattern(const VibratePattern &pattern) +int32_t CompatibleConnection::PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) { return ERR_OK; } @@ -198,7 +199,7 @@ void CompatibleConnection::VibrateProcess() return; } -int32_t CompatibleConnection::StartByIntensity(const std::string &effect, int32_t intensity) +int32_t CompatibleConnection::StartByIntensity(const VibratorParamsIPC ¶ms, const std::string &effect, int32_t intensity) { CALL_LOG_ENTER; if (g_vibratorEffect.find(effect) == g_vibratorEffect.end()) { @@ -218,11 +219,40 @@ int32_t CompatibleConnection::StartByIntensity(const std::string &effect, int32_ } #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR -int32_t CompatibleConnection::GetAllWaveInfo(std::vector &waveInfos) +int32_t CompatibleConnection::GetVibratorInfo(std::vector &hdfVibratorInfo) { return ERR_OK; } +int32_t CompatibleConnection::GetAllWaveInfo(const VibratorParamsIPC ¶ms, + std::vector &waveInfos) +{ + return ERR_OK; +} + +int32_t CompatibleConnection::GetVibratorIdList(const VibratorParamsIPC ¶ms, + std::vector &vibratorInfoIpc) +{ + CALL_LOG_ENTER; + return ERR_OK; +} + +int32_t CompatibleConnection::GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, + HdfEffectInfo &effectInfo) +{ + CALL_LOG_ENTER; + return ERR_OK; +} #endif // HDF_DRIVERS_INTERFACE_VIBRATOR +int32_t CompatibleConnection::RegisterVibratorPlugCallback(DevicePlugCallback cb) +{ + return ERR_OK; +} + +DevicePlugCallback CompatibleConnection::GetVibratorPlugCb() +{ + return NULL; +} + } // namespace Sensors } // namespace OHOS diff --git a/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp b/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp index 6d22d80..7ef57a6 100644 --- a/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp +++ b/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp @@ -21,6 +21,7 @@ #endif // HIVIEWDFX_HISYSEVENT_ENABLE #include "sensors_errors.h" +#include "vibrator_plug_callback.h" #undef LOG_TAG #define LOG_TAG "HdiConnection" @@ -29,17 +30,23 @@ namespace OHOS { namespace Sensors { using namespace OHOS::HiviewDFX; namespace { +sptr g_eventCallback = nullptr; constexpr int32_t GET_HDI_SERVICE_COUNT = 10; constexpr uint32_t WAIT_MS = 100; } // namespace +DevicePlugCallback HdiConnection::devicePlugCb_ = nullptr; int32_t HdiConnection::ConnectHdi() { + return ERR_OK; CALL_LOG_ENTER; int32_t retry = 0; while (retry < GET_HDI_SERVICE_COUNT) { vibratorInterface_ = IVibratorInterface::Get(); if (vibratorInterface_ != nullptr) { + MISC_HILOGW("Connect v2_0 hdi success"); + g_eventCallback = new (std::nothrow) VibratorPlugCallback(); + CHKPR(g_eventCallback, ERR_NO_INIT); RegisterHdiDeathRecipient(); return ERR_OK; } @@ -55,10 +62,11 @@ int32_t HdiConnection::ConnectHdi() return ERR_INVALID_VALUE; } -int32_t HdiConnection::StartOnce(uint32_t duration) +int32_t HdiConnection::StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) { - CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->StartOnce(duration); + // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + // int32_t ret = vibratorInterface_->StartOnce(params.deviceId, params.vibratorId, duration); + int32_t ret = 0; if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -70,15 +78,17 @@ int32_t HdiConnection::StartOnce(uint32_t duration) return ERR_OK; } -int32_t HdiConnection::Start(const std::string &effectType) +int32_t HdiConnection::Start(const VibratorParamsIPC ¶ms, const std::string &effectType) { MISC_HILOGD("Time delay measurement:end time"); if (effectType.empty()) { MISC_HILOGE("effectType is null"); return VIBRATOR_ON_ERR; } - CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->Start(effectType); + // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + // int32_t ret = vibratorInterface_->Start(params.deviceId, params.vibratorId, effectType); + int32_t ret = 0; + if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -91,15 +101,17 @@ int32_t HdiConnection::Start(const std::string &effectType) } #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -int32_t HdiConnection::EnableCompositeEffect(const HdfCompositeEffect &hdfCompositeEffect) +int32_t HdiConnection::EnableCompositeEffect(const VibratorParamsIPC ¶ms, const HdfCompositeEffect &hdfCompositeEffect) { MISC_HILOGD("Time delay measurement:end time"); if (hdfCompositeEffect.compositeEffects.empty()) { MISC_HILOGE("compositeEffects is empty"); return VIBRATOR_ON_ERR; } - CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->EnableCompositeEffect(hdfCompositeEffect); + // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + // int32_t ret = vibratorInterface_->EnableCompositeEffect(params.deviceId, params.vibratorId, hdfCompositeEffect); + int32_t ret = 0; + if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -111,23 +123,29 @@ int32_t HdiConnection::EnableCompositeEffect(const HdfCompositeEffect &hdfCompos return ERR_OK; } -bool HdiConnection::IsVibratorRunning() +bool HdiConnection::IsVibratorRunning(const VibratorParamsIPC ¶ms) { bool state = false; - CHKPR(vibratorInterface_, false); - vibratorInterface_->IsVibratorRunning(state); + // CHKPR(vibratorInterface_, false); + // vibratorInterface_->IsVibratorRunning(params.deviceId, params.vibratorId, state); + state = true; + return state; } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -std::optional HdiConnection::GetEffectInfo(const std::string &effect) +std::optional HdiConnection::GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effect) { - if (vibratorInterface_ == nullptr) { - MISC_HILOGE("Connect v1_1 hdi failed"); - return std::nullopt; - } + // if (vibratorInterface_ == nullptr) { + // MISC_HILOGE("Connect v1_1 hdi failed"); + // return std::nullopt; + // } HdfEffectInfo effectInfo; - int32_t ret = vibratorInterface_->GetEffectInfo(effect, effectInfo); + // int32_t ret = vibratorInterface_->GetEffectInfo(params.deviceId, params.vibratorId, effect, effectInfo); + effectInfo.duration = 2000; + effectInfo.isSupportEffect = true; + int32_t ret = 0; + if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -139,10 +157,12 @@ std::optional HdiConnection::GetEffectInfo(const std::string &eff return effectInfo; } -int32_t HdiConnection::Stop(HdfVibratorModeV1_2 mode) +int32_t HdiConnection::Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) { - CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->StopV1_2(mode); + // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + // int32_t ret = vibratorInterface_->Stop(params.deviceId, params.vibratorId, mode); + int32_t ret = 0; + if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -154,10 +174,13 @@ int32_t HdiConnection::Stop(HdfVibratorModeV1_2 mode) return ERR_OK; } -int32_t HdiConnection::GetDelayTime(int32_t mode, int32_t &delayTime) +int32_t HdiConnection::GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) { - CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->GetHapticStartUpTime(mode, delayTime); + // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + // int32_t ret = vibratorInterface_->GetHapticStartUpTime(params.deviceId, params.vibratorId, mode, delayTime); + int32_t ret = 0; + delayTime = 2000; + if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -169,11 +192,17 @@ int32_t HdiConnection::GetDelayTime(int32_t mode, int32_t &delayTime) return ERR_OK; } -int32_t HdiConnection::GetVibratorCapacity(VibratorCapacity &capacity) +int32_t HdiConnection::GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) { - CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); HapticCapacity hapticCapacity; - int32_t ret = vibratorInterface_->GetHapticCapacity(hapticCapacity); + // int32_t ret = vibratorInterface_->GetHapticCapacity(params.deviceId, hapticCapacity); + int32_t ret = 0; + capacity.isSupportHdHaptic = true; + capacity.isSupportPresetMapping = true; + capacity.isSupportTimeDelay = true; + return ERR_OK; + if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -189,9 +218,9 @@ int32_t HdiConnection::GetVibratorCapacity(VibratorCapacity &capacity) return ERR_OK; } -int32_t HdiConnection::PlayPattern(const VibratePattern &pattern) +int32_t HdiConnection::PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) { - CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); HapticPaket packet = {}; packet.time = pattern.startTime; int32_t eventNum = static_cast(pattern.events.size()); @@ -215,7 +244,9 @@ int32_t HdiConnection::PlayPattern(const VibratePattern &pattern) } packet.events.emplace_back(hapticEvent); } - int32_t ret = vibratorInterface_->PlayHapticPattern(packet); + // int32_t ret = vibratorInterface_->PlayHapticPattern(params.deviceId, packet); + int32_t ret = 0; + if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -229,12 +260,26 @@ int32_t HdiConnection::PlayPattern(const VibratePattern &pattern) int32_t HdiConnection::DestroyHdiConnection() { + CALL_LOG_ENTER; + CHKPR(vibratorInterface_, ERR_NO_INIT); + int32_t ret = vibratorInterface_->UnRegVibratorPlugCallback(g_eventCallback); + if (ret != 0) { +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", + HiSysEvent::EventType::FAULT, "PKG_NAME", "DestroyHdiConnection", "ERROR_CODE", ret); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + MISC_HILOGE("UnRegVibratorPlugCallback is failed"); + return ret; + } + g_eventCallback = nullptr; UnregisterHdiDeathRecipient(); return ERR_OK; } void HdiConnection::RegisterHdiDeathRecipient() { + return; + CALL_LOG_ENTER; if (vibratorInterface_ == nullptr) { MISC_HILOGE("Connect v1_1 hdi failed"); @@ -281,15 +326,17 @@ void HdiConnection::Reconnect() } } -int32_t HdiConnection::StartByIntensity(const std::string &effect, int32_t intensity) +int32_t HdiConnection::StartByIntensity(const VibratorParamsIPC ¶ms, const std::string &effect, int32_t intensity) { MISC_HILOGD("Time delay measurement:end time, effect:%{public}s, intensity:%{public}d", effect.c_str(), intensity); if (effect.empty()) { MISC_HILOGE("effect is null"); return VIBRATOR_ON_ERR; } - CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->StartByIntensity(effect, intensity); + // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + // int32_t ret = vibratorInterface_->StartByIntensity(params.deviceId, params.vibratorId, effect, intensity); + int32_t ret = 0; + if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -301,16 +348,149 @@ int32_t HdiConnection::StartByIntensity(const std::string &effect, int32_t inten return ERR_OK; } -int32_t HdiConnection::GetAllWaveInfo(std::vector &waveInfos) +int32_t HdiConnection::GetVibratorInfo(std::vector &hdfVibratorInfo) { - CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t vibratorId = 1; - int32_t ret = vibratorInterface_->GetAllWaveInfo(vibratorId, waveInfos); + // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + // int32_t ret = vibratorInterface_->GetVibratorInfo(hdfVibratorInfo); + int32_t ret = 0; + HdfVibratorInfo info; + info.isSupportIntensity = true; + info.isSupportFrequency = false; + info.intensityMaxValue = 255; + info.intensityMinValue = 0; + info.frequencyMaxValue = 200; + info.frequencyMinValue = 50; + info.deviceId = 2; + info.vibratorId = 99; + info.isLocal = 1; + hdfVibratorInfo.push_back(info); + + HdfVibratorInfo info1; + info1.isSupportIntensity = true; + info1.isSupportFrequency = false; + info1.intensityMaxValue = 255; + info1.intensityMinValue = 0; + info1.frequencyMaxValue = 200; + info1.frequencyMinValue = 50; + info1.deviceId = 2; + info1.vibratorId = 100; + info1.isLocal = 1; + hdfVibratorInfo.push_back(info1); + + if (ret != ERR_OK) { + MISC_HILOGE("GetVibratorInfo failed"); + } + return ret; + +} + +int32_t HdiConnection::GetAllWaveInfo(const VibratorParamsIPC ¶ms, std::vector &waveInfos) +{ + // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + // int32_t ret = vibratorInterface_->GetAllWaveInfo(params.deviceId, params.vibratorId, waveInfos); + int32_t ret = 0; + HdfWaveInformation info1; + info1.vibratorId = 1; + info1.waveId = 101; + info1.intensity = 0.8f; + info1.frequency = 50.0f; + info1.duration = 200; + info1.reserved = 0; + waveInfos.push_back(info1); + + HdfWaveInformation info2; + info2.vibratorId = 2; + info2.waveId = 102; + info2.intensity = 0.6f; + info2.frequency = 60.0f; + info2.duration = 300; + info2.reserved = 0; + waveInfos.push_back(info2); + if (ret != ERR_OK) { MISC_HILOGE("GetAllWaveInfo failed"); } return ret; } +int32_t HdiConnection::GetVibratorIdList(const VibratorParamsIPC ¶ms, + std::vector &vibratorInfo) +{ + // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + // int32_t ret = vibratorInterface_->GetVibratorIdSingle(params.deviceId, vibratorInfo); + int32_t ret = 0; + HdfVibratorInfo info; + info.isSupportIntensity = true; + info.isSupportFrequency = false; + info.intensityMaxValue = 255; + info.intensityMinValue = 0; + info.frequencyMaxValue = 200; + info.frequencyMinValue = 50; + info.deviceId = 2; + info.vibratorId = 101; + info.isLocal = 0; + vibratorInfo.push_back(info); + + HdfVibratorInfo info1; + info1.isSupportIntensity = true; + info1.isSupportFrequency = false; + info1.intensityMaxValue = 255; + info1.intensityMinValue = 0; + info1.frequencyMaxValue = 200; + info1.frequencyMinValue = 50; + info1.deviceId = 2; + info1.vibratorId = 102; + info1.isLocal = 0; + vibratorInfo.push_back(info1); + + + if (ret != ERR_OK) { + MISC_HILOGE("GetVibratorIdList failed"); + } + return ret; +} + +int32_t HdiConnection::GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, + HdfEffectInfo &effectInfo) +{ + // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + // int32_t ret = vibratorInterface_->GetEffectInfo(params.deviceId, params.vibratorId, effectType, effectInfo); + int32_t ret = 0; + effectInfo.duration = 2000; + effectInfo.isSupportEffect = true; + + if (ret != ERR_OK) { + MISC_HILOGE("GetVibratorIdList failed"); + } + return ret; +} + +int32_t HdiConnection::RegisterVibratorPlugCallback(DevicePlugCallback cb) +{ + CALL_LOG_ENTER; + CHKPR(cb, ERR_NO_INIT); + // CHKPR(vibratorInterface_, ERR_NO_INIT); + devicePlugCb_ = cb; + // int32_t ret = vibratorInterface_->RegVibratorPlugCallback(g_eventCallback); + int32_t ret = 0; + + if (ret != 0) { +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", + HiSysEvent::EventType::FAULT, "PKG_NAME", "RegisterVibratorCallback", "ERROR_CODE", ret); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + MISC_HILOGE("RegVibratorPlugCallback is failed"); + return ret; + } + return ERR_OK; +} + +DevicePlugCallback HdiConnection::GetVibratorPlugCb() +{ + if (devicePlugCb_ == nullptr) { + MISC_HILOGE("GetVibratorPlugCb cannot be null"); + } + return devicePlugCb_; +} } // namespace Sensors } // namespace OHOS diff --git a/services/miscdevice_service/hdi_connection/adapter/src/vibrator_plug_callback.cpp b/services/miscdevice_service/hdi_connection/adapter/src/vibrator_plug_callback.cpp new file mode 100644 index 0000000..52c9c20 --- /dev/null +++ b/services/miscdevice_service/hdi_connection/adapter/src/vibrator_plug_callback.cpp @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include "hdi_connection.h" +#include "vibrator_plug_callback.h" +#include "sensors_errors.h" + +#undef LOG_TAG +#define LOG_TAG "VibratorPlugCallback" + +namespace OHOS { +namespace Sensors { +using namespace OHOS::HiviewDFX; +namespace { +std::unique_ptr HdiConnection_ = std::make_unique(); +} // namespace + +int32_t VibratorPlugCallback::OnVibratorPlugEvent(const HdfVibratorPlugInfo &vibratorPlugInfo) +{ + DevicePlugCallback devicePlugCb_ = HdiConnection_->GetVibratorPlugCb(); + CHKPR(devicePlugCb_, ERR_NO_INIT); + devicePlugCb_(vibratorPlugInfo); + return ERR_OK; +} +} // namespace Sensors +} // namespace OHOS \ No newline at end of file diff --git a/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h b/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h index 008b3db..ebacfd6 100644 --- a/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h +++ b/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h @@ -17,59 +17,66 @@ #define I_VIBRATOR_HDI_CONNECTION_H #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR -#include "v1_3/ivibrator_interface.h" +#include "v2_0/ivibrator_interface.h" #endif // HDF_DRIVERS_INTERFACE_VIBRATOR #include "vibrator_infos.h" namespace OHOS { namespace Sensors { #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR -using OHOS::HDI::Vibrator::V1_2::HdfVibratorModeV1_2; -using OHOS::HDI::Vibrator::V1_2::HDF_VIBRATOR_MODE_ONCE; -using OHOS::HDI::Vibrator::V1_2::HDF_VIBRATOR_MODE_PRESET; -using OHOS::HDI::Vibrator::V1_2::HDF_VIBRATOR_MODE_HDHAPTIC; -using OHOS::HDI::Vibrator::V1_2::HDF_VIBRATOR_MODE_BUTT; -using OHOS::HDI::Vibrator::V1_2::CurvePoint; -using OHOS::HDI::Vibrator::V1_2::EVENT_TYPE; -using OHOS::HDI::Vibrator::V1_2::HapticCapacity; -using OHOS::HDI::Vibrator::V1_2::HapticPaket; -using OHOS::HDI::Vibrator::V1_2::HapticEvent; -using OHOS::HDI::Vibrator::V1_1::HdfEffectInfo; -using OHOS::HDI::Vibrator::V1_3::HdfWaveInformation; -#ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -using OHOS::HDI::Vibrator::V1_1::HdfEffectType; -using OHOS::HDI::Vibrator::V1_1::HDF_EFFECT_TYPE_TIME; -using OHOS::HDI::Vibrator::V1_1::HDF_EFFECT_TYPE_PRIMITIVE; -using OHOS::HDI::Vibrator::V1_1::HDF_EFFECT_TYPE_BUTT; -using OHOS::HDI::Vibrator::V1_1::TimeEffect; -using OHOS::HDI::Vibrator::V1_1::PrimitiveEffect; -using OHOS::HDI::Vibrator::V1_1::CompositeEffect; -using OHOS::HDI::Vibrator::V1_1::HdfCompositeEffect; -#endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM +using OHOS::HDI::Vibrator::V2_0::HdfVibratorMode; +using OHOS::HDI::Vibrator::V2_0::HDF_VIBRATOR_MODE_ONCE; +using OHOS::HDI::Vibrator::V2_0::HDF_VIBRATOR_MODE_PRESET; +using OHOS::HDI::Vibrator::V2_0::HDF_VIBRATOR_MODE_HDHAPTIC; +using OHOS::HDI::Vibrator::V2_0::HDF_VIBRATOR_MODE_BUTT; +using OHOS::HDI::Vibrator::V2_0::CurvePoint; +using OHOS::HDI::Vibrator::V2_0::EVENT_TYPE; +using OHOS::HDI::Vibrator::V2_0::HapticCapacity; +using OHOS::HDI::Vibrator::V2_0::HapticPaket; +using OHOS::HDI::Vibrator::V2_0::HapticEvent; +using OHOS::HDI::Vibrator::V2_0::HdfEffectInfo; +using OHOS::HDI::Vibrator::V2_0::HdfWaveInformation; +using OHOS::HDI::Vibrator::V2_0::HdfVibratorPlugInfo; +using OHOS::HDI::Vibrator::V2_0::HdfVibratorInfo; +using OHOS::HDI::Vibrator::V2_0::HdfEffectType; +using OHOS::HDI::Vibrator::V2_0::HDF_EFFECT_TYPE_TIME; +using OHOS::HDI::Vibrator::V2_0::HDF_EFFECT_TYPE_PRIMITIVE; +using OHOS::HDI::Vibrator::V2_0::HDF_EFFECT_TYPE_BUTT; +using OHOS::HDI::Vibrator::V2_0::TimeEffect; +using OHOS::HDI::Vibrator::V2_0::PrimitiveEffect; +using OHOS::HDI::Vibrator::V2_0::CompositeEffect; +using OHOS::HDI::Vibrator::V2_0::HdfCompositeEffect; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR + +using DevicePlugCallback = std::function; class IVibratorHdiConnection { public: IVibratorHdiConnection() = default; virtual ~IVibratorHdiConnection() = default; virtual int32_t ConnectHdi() = 0; - virtual int32_t StartOnce(uint32_t duration) = 0; - virtual int32_t Start(const std::string &effectType) = 0; + virtual int32_t StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) = 0; + virtual int32_t Start(const VibratorParamsIPC ¶ms, const std::string &effectType) = 0; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - virtual int32_t EnableCompositeEffect(const HdfCompositeEffect &hdfCompositeEffect) = 0; - virtual bool IsVibratorRunning() = 0; + virtual int32_t EnableCompositeEffect(const VibratorParamsIPC ¶ms, const HdfCompositeEffect &hdfCompositeEffect) = 0; + virtual bool IsVibratorRunning(const VibratorParamsIPC ¶ms) = 0; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - virtual std::optional GetEffectInfo(const std::string &effect) = 0; - virtual int32_t Stop(HdfVibratorModeV1_2 mode) = 0; + virtual std::optional GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effect) = 0; + virtual int32_t Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) = 0; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR virtual int32_t DestroyHdiConnection() = 0; - virtual int32_t GetDelayTime(int32_t mode, int32_t &delayTime) = 0; - virtual int32_t GetVibratorCapacity(VibratorCapacity &capacity) = 0; - virtual int32_t PlayPattern(const VibratePattern &pattern) = 0; - virtual int32_t StartByIntensity(const std::string &effect, int32_t intensity) = 0; + virtual int32_t GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) = 0; + virtual int32_t GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) = 0; + virtual int32_t PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) = 0; + virtual int32_t StartByIntensity(const VibratorParamsIPC ¶ms, const std::string &effect, int32_t intensity) = 0; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - virtual int32_t GetAllWaveInfo(std::vector &waveInfos) = 0; + virtual int32_t GetVibratorInfo(std::vector &hdfVibratorInfo) = 0; + virtual int32_t GetAllWaveInfo(const VibratorParamsIPC ¶ms, std::vector &waveInfos) = 0; + virtual int32_t GetVibratorIdList(const VibratorParamsIPC ¶ms, std::vector &hdfVibratorInfo) = 0; + virtual int32_t GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, HdfEffectInfo &effectInfo) = 0; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR + virtual int32_t RegisterVibratorPlugCallback(DevicePlugCallback cb) = 0; + virtual DevicePlugCallback GetVibratorPlugCb() = 0; private: DISALLOW_COPY_AND_MOVE(IVibratorHdiConnection); diff --git a/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h b/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h index a604d20..7c2122b 100644 --- a/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h +++ b/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h @@ -27,24 +27,29 @@ public: VibratorHdiConnection() = default; virtual ~VibratorHdiConnection() {} int32_t ConnectHdi() override; - int32_t StartOnce(uint32_t duration) override; - int32_t Start(const std::string &effectType) override; + int32_t StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) override; + int32_t Start(const VibratorParamsIPC ¶ms, const std::string &effectType) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - int32_t EnableCompositeEffect(const HdfCompositeEffect &hdfCompositeEffect) override; - bool IsVibratorRunning() override; + int32_t EnableCompositeEffect(const VibratorParamsIPC ¶ms, const HdfCompositeEffect &hdfCompositeEffect) override; + bool IsVibratorRunning(const VibratorParamsIPC ¶ms) override; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - std::optional GetEffectInfo(const std::string &effect) override; - int32_t Stop(HdfVibratorModeV1_2 mode) override; + std::optional GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effect) override; + int32_t Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR int32_t DestroyHdiConnection() override; - int32_t GetDelayTime(int32_t mode, int32_t &delayTime) override; - int32_t GetVibratorCapacity(VibratorCapacity &capacity) override; - int32_t PlayPattern(const VibratePattern &pattern) override; - int32_t StartByIntensity(const std::string &effect, int32_t intensity) override; + int32_t GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) override; + int32_t GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) override; + int32_t PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) override; + int32_t StartByIntensity(const VibratorParamsIPC ¶ms, const std::string &effect, int32_t intensity) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - int32_t GetAllWaveInfo(std::vector &waveInfos) override; + int32_t GetVibratorInfo(std::vector &hdfVibratorInfo) override; + int32_t GetAllWaveInfo(const VibratorParamsIPC ¶ms, std::vector &waveInfos) override; + int32_t GetVibratorIdList(const VibratorParamsIPC ¶ms, std::vector &hdfVibratorInfo) override; + int32_t GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, HdfEffectInfo &effectInfo) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR + int32_t RegisterVibratorPlugCallback(DevicePlugCallback cb) override; + DevicePlugCallback GetVibratorPlugCb() override; private: DISALLOW_COPY_AND_MOVE(VibratorHdiConnection); diff --git a/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp b/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp index a135b1c..949b0ed 100644 --- a/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp +++ b/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp @@ -50,13 +50,13 @@ int32_t VibratorHdiConnection::ConnectHdi() return ret; } -int32_t VibratorHdiConnection::StartOnce(uint32_t duration) +int32_t VibratorHdiConnection::StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "StartOnce"); #endif // HIVIEWDFX_HITRACE_ENABLE - int32_t ret = iVibratorHdiConnection_->StartOnce(duration); + int32_t ret = iVibratorHdiConnection_->StartOnce(params, duration); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE @@ -67,13 +67,13 @@ int32_t VibratorHdiConnection::StartOnce(uint32_t duration) return ERR_OK; } -int32_t VibratorHdiConnection::Start(const std::string &effectType) +int32_t VibratorHdiConnection::Start(const VibratorParamsIPC ¶ms, const std::string &effectType) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "Start"); #endif // HIVIEWDFX_HITRACE_ENABLE - int32_t ret = iVibratorHdiConnection_->Start(effectType); + int32_t ret = iVibratorHdiConnection_->Start(params, effectType); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE @@ -86,13 +86,14 @@ int32_t VibratorHdiConnection::Start(const std::string &effectType) #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -int32_t VibratorHdiConnection::EnableCompositeEffect(const HdfCompositeEffect &hdfCompositeEffect) +int32_t VibratorHdiConnection::EnableCompositeEffect(const VibratorParamsIPC ¶ms, + const HdfCompositeEffect &hdfCompositeEffect) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "EnableCompositeEffect"); #endif // HIVIEWDFX_HITRACE_ENABLE - int32_t ret = iVibratorHdiConnection_->EnableCompositeEffect(hdfCompositeEffect); + int32_t ret = iVibratorHdiConnection_->EnableCompositeEffect(params, hdfCompositeEffect); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE @@ -103,14 +104,15 @@ int32_t VibratorHdiConnection::EnableCompositeEffect(const HdfCompositeEffect &h return ERR_OK; } -bool VibratorHdiConnection::IsVibratorRunning() +bool VibratorHdiConnection::IsVibratorRunning(const VibratorParamsIPC ¶ms) { CHKPR(iVibratorHdiConnection_, false); - return iVibratorHdiConnection_->IsVibratorRunning(); + return iVibratorHdiConnection_->IsVibratorRunning(params); } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -std::optional VibratorHdiConnection::GetEffectInfo(const std::string &effect) +std::optional VibratorHdiConnection::GetEffectInfo(const VibratorParamsIPC ¶ms, + const std::string &effect) { if (iVibratorHdiConnection_ == nullptr) { MISC_HILOGE("Connect hdi failed"); @@ -119,20 +121,20 @@ std::optional VibratorHdiConnection::GetEffectInfo(const std::str #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "GetEffectInfo"); #endif // HIVIEWDFX_HITRACE_ENABLE - std::optional ret = iVibratorHdiConnection_->GetEffectInfo(effect); + std::optional ret = iVibratorHdiConnection_->GetEffectInfo(params, effect); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE return ret; } -int32_t VibratorHdiConnection::Stop(HdfVibratorModeV1_2 mode) +int32_t VibratorHdiConnection::Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "Stop"); #endif // HIVIEWDFX_HITRACE_ENABLE - int32_t ret = iVibratorHdiConnection_->Stop(mode); + int32_t ret = iVibratorHdiConnection_->Stop(params, mode); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE @@ -144,22 +146,22 @@ int32_t VibratorHdiConnection::Stop(HdfVibratorModeV1_2 mode) } #endif // HDF_DRIVERS_INTERFACE_VIBRATOR -int32_t VibratorHdiConnection::GetDelayTime(int32_t mode, int32_t &delayTime) +int32_t VibratorHdiConnection::GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); - return iVibratorHdiConnection_->GetDelayTime(mode, delayTime); + return iVibratorHdiConnection_->GetDelayTime(params, mode, delayTime); } -int32_t VibratorHdiConnection::GetVibratorCapacity(VibratorCapacity &capacity) +int32_t VibratorHdiConnection::GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); - return iVibratorHdiConnection_->GetVibratorCapacity(capacity); + return iVibratorHdiConnection_->GetVibratorCapacity(params, capacity); } -int32_t VibratorHdiConnection::PlayPattern(const VibratePattern &pattern) +int32_t VibratorHdiConnection::PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); - return iVibratorHdiConnection_->PlayPattern(pattern); + return iVibratorHdiConnection_->PlayPattern(params, pattern); } int32_t VibratorHdiConnection::DestroyHdiConnection() @@ -173,13 +175,14 @@ int32_t VibratorHdiConnection::DestroyHdiConnection() return ERR_OK; } -int32_t VibratorHdiConnection::StartByIntensity(const std::string &effect, int32_t intensity) +int32_t VibratorHdiConnection::StartByIntensity(const VibratorParamsIPC ¶ms, + const std::string &effect, int32_t intensity) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "StartByIntensity"); #endif // HIVIEWDFX_HITRACE_ENABLE - int32_t ret = iVibratorHdiConnection_->StartByIntensity(effect, intensity); + int32_t ret = iVibratorHdiConnection_->StartByIntensity(params, effect, intensity); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE @@ -191,12 +194,52 @@ int32_t VibratorHdiConnection::StartByIntensity(const std::string &effect, int32 } #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR -int32_t VibratorHdiConnection::GetAllWaveInfo(std::vector &waveInfos) +int32_t VibratorHdiConnection::GetVibratorInfo(std::vector &hdfVibratorInfo) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); - return iVibratorHdiConnection_->GetAllWaveInfo(waveInfos); + return iVibratorHdiConnection_->GetVibratorInfo(hdfVibratorInfo); +} + +int32_t VibratorHdiConnection::GetAllWaveInfo(const VibratorParamsIPC ¶ms, std::vector &waveInfos) +{ + CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); + return iVibratorHdiConnection_->GetAllWaveInfo(params, waveInfos); +} + +int32_t VibratorHdiConnection::GetVibratorIdList(const VibratorParamsIPC ¶ms, std::vector &vibratorInfo) +{ + CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); + return iVibratorHdiConnection_->GetVibratorIdList(params, vibratorInfo); +} + +int32_t VibratorHdiConnection::GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, HdfEffectInfo &effectInfo) +{ + CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); + return iVibratorHdiConnection_->GetEffectInfo(params, effectType, effectInfo); } #endif // HDF_DRIVERS_INTERFACE_VIBRATOR +int32_t VibratorHdiConnection::RegisterVibratorPlugCallback(DevicePlugCallback cb) +{ + CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); + #ifdef HIVIEWDFX_HITRACE_ENABLE + StartTrace(HITRACE_TAG_SENSORS, "RegisterVibratorPlugCallback"); +#endif // HIVIEWDFX_HITRACE_ENABLE + int32_t ret = iVibratorHdiConnection_->RegisterVibratorPlugCallback(cb); +#ifdef HIVIEWDFX_HITRACE_ENABLE + FinishTrace(HITRACE_TAG_SENSORS); +#endif // HIVIEWDFX_HITRACE_ENABLE + if (ret != 0) { + MISC_HILOGE("RegisterVibratorPlugCallback failed"); + return VIBRATOR_ON_ERR; + } + return ERR_OK; +} + +DevicePlugCallback VibratorHdiConnection::GetVibratorPlugCb() +{ + CHKPP(iVibratorHdiConnection_); + return NULL; +} } // namespace Sensors } // namespace OHOS diff --git a/services/miscdevice_service/include/miscdevice_service.h b/services/miscdevice_service/include/miscdevice_service.h index 2c15952..6ebd336 100644 --- a/services/miscdevice_service/include/miscdevice_service.h +++ b/services/miscdevice_service/include/miscdevice_service.h @@ -36,6 +36,33 @@ enum class MiscdeviceServiceState { STATE_RUNNING, }; +struct VibratorControlInfo { + int motorCount; + std::unordered_map> vibratorThreads; + + VibratorControlInfo(const std::vector& motorIds) : motorCount(static_cast(motorIds.size())) { + for (int motorId : motorIds) { + vibratorThreads[motorId] = std::make_shared(); + } + } + + std::shared_ptr GetVibratorThread(int motorId) const { + auto it = vibratorThreads.find(motorId); + if (it != vibratorThreads.end()) { + return it->second; + } + return nullptr; + } +}; + +struct VibratorAllInfos{ + std::vector baseInfo; + VibratorControlInfo controlInfo; + VibratorCapacity capacityInfo; + std::vector waveInfo; + VibratorAllInfos(const std::vector& motorIds) : controlInfo(motorIds) {} +}; + class MiscdeviceService : public SystemAbility, public MiscdeviceServiceStub { DECLARE_SYSTEM_ABILITY(MiscdeviceService) MISCDEVICE_DECLARE_DELAYED_SP_SINGLETON(MiscdeviceService); @@ -49,36 +76,43 @@ public: bool IsLightAnimationValid(const LightAnimationIPC &animation); int32_t Dump(int32_t fd, const std::vector &args) override; void ProcessDeathObserver(const wptr &object); - virtual int32_t Vibrate(int32_t vibratorId, int32_t timeOut, int32_t usage, bool systemUsage) override; - virtual int32_t PlayVibratorEffect(int32_t vibratorId, const std::string &effect, - int32_t loopCount, int32_t usage, bool systemUsage) override; + virtual int32_t Vibrate(const VibratorParamsIPC& params, int32_t vibratorId, int32_t timeOut, + int32_t usage, bool systemUsage) override; + virtual int32_t PlayVibratorEffect(const VibratorParamsIPC& params, int32_t vibratorId, const std::string &effect, + int32_t loopCount, int32_t usage, bool systemUsage) override; #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - virtual int32_t PlayVibratorCustom(int32_t vibratorId, int32_t fd, int64_t offset, int64_t length, int32_t usage, - bool systemUsage, const VibrateParameter ¶meter) override; + virtual int32_t PlayVibratorCustom(const VibratorParamsIPC& params, int32_t vibratorId, int32_t fd, int64_t offset, + int64_t length, int32_t usage, bool systemUsage, const VibrateParameter ¶meter) override; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - virtual int32_t StopVibrator(int32_t vibratorId) override; - virtual int32_t StopVibratorByMode(int32_t vibratorId, const std::string &mode) override; - virtual int32_t IsSupportEffect(const std::string &effect, bool &state) override; + virtual int32_t StopVibrator(const VibratorParamsIPC& params, int32_t vibratorId) override; + virtual int32_t StopVibratorByMode(const VibratorParamsIPC& params, int32_t vibratorId, + const std::string &mode) override; + virtual int32_t IsSupportEffect(const VibratorParamsIPC& params, const std::string &effect, bool &state) override; virtual int32_t GetLightList(std::vector &lightInfoIpcList) override; virtual int32_t TurnOn(int32_t lightId, int32_t singleColor, const LightAnimationIPC &animation) override; virtual int32_t TurnOff(int32_t lightId) override; - virtual int32_t PlayPattern(const VibratePattern &pattern, int32_t usage, + virtual int32_t PlayPattern(const VibratorParamsIPC& params, const VibratePattern &pattern, int32_t usage, bool systemUsage, const VibrateParameter ¶meter) override; - virtual int32_t GetDelayTime(int32_t &delayTime) override; + virtual int32_t GetDelayTime(const VibratorParamsIPC& params, int32_t &delayTime) override; virtual int32_t TransferClientRemoteObject(const sptr &vibratorServiceClient) override; - virtual int32_t PlayPrimitiveEffect(int32_t vibratorId, const std::string &effect, int32_t intensity, - int32_t usage, bool systemUsage, int32_t count) override; - virtual int32_t GetVibratorCapacity(VibratorCapacity &capacity) override; + virtual int32_t PlayPrimitiveEffect(const VibratorParamsIPC& params, int32_t vibratorId, const std::string &effect, + int32_t intensity, int32_t usage, bool systemUsage, int32_t count) override; + virtual int32_t GetVibratorCapacity(const VibratorParamsIPC& params, VibratorCapacity &capacity) override; + virtual int32_t GetVibratorIdList(const VibratorParamsIPC& params, std::vector& vibratorInfoIPC) override; + virtual int32_t GetEffectInfo(const VibratorParamsIPC& params, const std::string& effectType, EffectInfoIPC& effectInfoIPC) override; private: DISALLOW_COPY_AND_MOVE(MiscdeviceService); bool InitInterface(); bool InitLightInterface(); std::string GetPackageName(AccessTokenID tokenId); - void StartVibrateThread(VibrateInfo info); - int32_t StopVibratorService(int32_t vibratorId); - void StopVibrateThread(); - bool ShouldIgnoreVibrate(const VibrateInfo &info); + void StartVibrateThread(VibrateInfo info, const VibratorParamsIPC& params); + int32_t StopVibratorService(const VibratorParamsIPC& params, int32_t vibratorId); + void SendMsgToClient(HdfVibratorPlugInfo info); + int32_t RegisterVibratorPlugCb(); + std::shared_ptr GetVibratorThread(const VibratorParamsIPC& params); + void StopVibrateThread(std::shared_ptr vibratorThread); + bool ShouldIgnoreVibrate(const VibrateInfo &info, const VibratorParamsIPC& params, bool isLocalDevice); std::string GetCurrentTime(); void MergeVibratorParmeters(const VibrateParameter ¶meter, VibratePackage &package); bool CheckVibratorParmeters(const VibrateParameter ¶meter); @@ -90,13 +124,25 @@ private: void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; int32_t SubscribeCommonEvent(const std::string &eventName, EventReceiver receiver); void OnReceiveEvent(const EventFwk::CommonEventData &data); -#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB + #ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB void OnReceiveUserSwitchEvent(const EventFwk::CommonEventData &data); -#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB - int32_t CheckAuthAndParam(int32_t usage, const VibrateParameter ¶meter); + #endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB + int32_t CheckAuthAndParam(int32_t usage, const VibrateParameter ¶meter, const VibratorParamsIPC& params); int32_t PlayPatternCheckAuthAndParam(int32_t usage, const VibrateParameter ¶meter); int32_t PlayPrimitiveEffectCheckAuthAndParam(int32_t intensity, int32_t usage); int32_t PlayVibratorEffectCheckAuthAndParam(int32_t count, int32_t usage); + int32_t GetHapticCapacityInfo(const VibratorParamsIPC& params, VibratorCapacity& capacityInfo); + int32_t GetAllWaveInfo(const VibratorParamsIPC& params, std::vector& waveInfo); + int32_t GetHapticStartUpTime(const VibratorParamsIPC& params, int32_t mode, int32_t &startUpTime); + void FirstGetLocalVibratorInfo(); + std::vector CheckDeviceIdIsValid(const VibratorParamsIPC& params); + int32_t StartVibrateThreadControl(const VibratorParamsIPC& params, VibrateInfo& info); + bool UpdateVibratorAllInfo(const VibratorParamsIPC ¶msIpc, const HdfVibratorPlugInfo &info, + VibratorAllInfos &vibratorAllInfos); + void ConvertToServerInfos(const std::vector &baseVibratorInfo, + const VibratorCapacity &vibratorCapacity, const std::vector &waveInfomation, + const HdfVibratorPlugInfo &info, VibratorAllInfos &vibratorAllInfos); + std::mutex isVibrationPriorityReadyMutex_; static bool isVibrationPriorityReady_; VibratorHdiConnection &vibratorHdiConnection_ = VibratorHdiConnection::GetInstance(); @@ -106,7 +152,7 @@ private: std::vector lightInfos_; std::map miscDeviceIdMap_; MiscdeviceServiceState state_; - std::shared_ptr vibratorThread_ = nullptr; + //std::shared_ptr vibratorThread_ = nullptr; std::mutex vibratorThreadMutex_; sptr clientDeathObserver_ = nullptr; std::mutex clientDeathObserverMutex_; @@ -114,6 +160,8 @@ private: std::mutex clientPidMapMutex_; std::mutex miscDeviceIdMapMutex_; std::mutex lightInfosMutex_; + std::mutex devicesManageMutex_; + // std::map devicesManageMap_; }; } // namespace Sensors } // namespace OHOS diff --git a/services/miscdevice_service/include/vibration_priority_manager.h b/services/miscdevice_service/include/vibration_priority_manager.h index b78cafe..acf1411 100644 --- a/services/miscdevice_service/include/vibration_priority_manager.h +++ b/services/miscdevice_service/include/vibration_priority_manager.h @@ -80,7 +80,8 @@ class VibrationPriorityManager { public: DISALLOW_COPY_AND_MOVE(VibrationPriorityManager); bool Init(); - VibrateStatus ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo, std::shared_ptr vibratorThread); + VibrateStatus ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo, + std::shared_ptr vibratorThread, const VibratorParamsIPC& params, bool isLocalDevice); #ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB void InitDoNotDisturbData(); void UpdateCurrentUserId(); @@ -93,7 +94,7 @@ public: #endif private: - bool IsCurrentVibrate(std::shared_ptr vibratorThread) const; + bool IsCurrentVibrate(std::shared_ptr vibratorThread, const VibratorParamsIPC& params) const; bool IsLoopVibrate(const VibrateInfo &vibrateInfo) const; VibrateStatus ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo, VibrateInfo currentVibrateInfo) const; #ifdef OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD diff --git a/services/miscdevice_service/include/vibrator_thread.h b/services/miscdevice_service/include/vibrator_thread.h index 14d5c02..f4ddeb0 100644 --- a/services/miscdevice_service/include/vibrator_thread.h +++ b/services/miscdevice_service/include/vibrator_thread.h @@ -26,25 +26,33 @@ namespace OHOS { namespace Sensors { class VibratorThread : public Thread { public: - void UpdateVibratorEffect(const VibrateInfo &vibrateInfo); + void UpdateVibratorEffect(const VibrateInfo &vibrateInfo, const VibratorParamsIPC& params, + std::vector &waveInfos); VibrateInfo GetCurrentVibrateInfo(); + std::vector GetCurrentWareInfo(); void SetExitStatus(bool status); void WakeUp(); - + void ResetVibrateInfo(); protected: virtual bool Run(); private: - int32_t PlayOnce(const VibrateInfo &info); - int32_t PlayEffect(const VibrateInfo &info); - int32_t PlayCustomByHdHptic(const VibrateInfo &info); - void HandleMultipleVibrations(); + VibratorParamsIPC GetCurrentVibrateParams(); + int32_t PlayOnce(const VibrateInfo &info, const VibratorParamsIPC& params); + int32_t PlayEffect(const VibrateInfo &info, const VibratorParamsIPC& params); + int32_t PlayCustomByHdHptic(const VibrateInfo &info, const VibratorParamsIPC& params); + void HandleMultipleVibrations(const VibratorParamsIPC& params); #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - int32_t PlayCustomByCompositeEffect(const VibrateInfo &info); - int32_t PlayCompositeEffect(const VibrateInfo &info, const HdfCompositeEffect &hdfCompositeEffect); + int32_t PlayCustomByCompositeEffect(const VibrateInfo &info, const VibratorParamsIPC& params, + std::vector wareInfo); + int32_t PlayCompositeEffect(const VibrateInfo &info, const HdfCompositeEffect &hdfCompositeEffect, + const VibratorParamsIPC& params); #endif // HDF_DRIVERS_INTERFACE_VIBRATOR std::mutex currentVibrationMutex_; VibrateInfo currentVibration_; + std::vector waveInfos_; + std::mutex currentVibrateParamsMutex_; + VibratorParamsIPC currentVibrateParams_; std::mutex vibrateMutex_; std::condition_variable cv_; std::atomic exitFlag_ = false; diff --git a/services/miscdevice_service/src/miscdevice_service.cpp b/services/miscdevice_service/src/miscdevice_service.cpp index 50c2066..099bada 100644 --- a/services/miscdevice_service/src/miscdevice_service.cpp +++ b/services/miscdevice_service/src/miscdevice_service.cpp @@ -29,6 +29,7 @@ #include "sensors_errors.h" #include "vibration_priority_manager.h" +#include "vibrator_client_proxy.h" #ifdef HDF_DRIVERS_INTERFACE_LIGHT #include "v1_0/light_interface_proxy.h" @@ -68,27 +69,38 @@ constexpr int32_t VIBRATOR_ID = 0; constexpr int32_t BASE_YEAR = 1900; constexpr int32_t BASE_MON = 1; constexpr int32_t CONVERSION_RATE = 1000; -VibratorCapacity g_capacity; +// VibratorCapacity g_capacity; #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM const std::string PHONE_TYPE = "phone"; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM } // namespace bool MiscdeviceService::isVibrationPriorityReady_ = false; +std::map devicesManageMap_; MiscdeviceService::MiscdeviceService() : SystemAbility(MISCDEVICE_SERVICE_ABILITY_ID, true), lightExist_(false), vibratorExist_(false), - state_(MiscdeviceServiceState::STATE_STOPPED), - vibratorThread_(nullptr) + state_(MiscdeviceServiceState::STATE_STOPPED) { MISC_HILOGD("Add SystemAbility"); } MiscdeviceService::~MiscdeviceService() { - StopVibrateThread(); + std::lock_guard lock(devicesManageMutex_); + auto it = devicesManageMap_.begin(); + while (it != devicesManageMap_.end()) { + int deviceId = it->first; + const VibratorControlInfo& vibratorControlInfo_ = it->second.controlInfo; + MISC_HILOGI("Device ID:%d, Motor Count:%d", deviceId, vibratorControlInfo_.motorCount); + VibratorParamsIPC params; + params.deviceId = deviceId; + params.vibratorId = -1; + StopVibratorService(params, VIBRATOR_ID); + it = devicesManageMap_.erase(it); + } } void MiscdeviceService::OnDump() @@ -198,7 +210,6 @@ void MiscdeviceService::OnReceiveUserSwitchEvent(const EventFwk::CommonEventData } } #endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB - void MiscdeviceService::OnStart() { CALL_LOG_ENTER; @@ -232,6 +243,18 @@ void MiscdeviceService::OnStart() AddSystemAbilityListener(MEMORY_MANAGER_SA_ID); #endif // MEMMGR_ENABLE AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID); + RegisterVibratorPlugCb(); +} + +int32_t MiscdeviceService::RegisterVibratorPlugCb() +{ + auto ret = vibratorHdiConnection_.RegisterVibratorPlugCallback( + std::bind(&MiscdeviceService::SendMsgToClient, this, std::placeholders::_1)); + if (ret != ERR_OK) { + MISC_HILOGE("InitVibratorServiceImpl failed"); + return false; + } + return true; } void MiscdeviceService::OnStartFuzz() @@ -268,9 +291,7 @@ bool MiscdeviceService::InitInterface() MISC_HILOGE("InitVibratorServiceImpl failed"); return false; } - if (vibratorHdiConnection_.GetVibratorCapacity(g_capacity) != ERR_OK) { - MISC_HILOGE("GetVibratorCapacity failed"); - } + (void)FirstGetLocalVibratorInfo(); return true; } @@ -332,7 +353,8 @@ void MiscdeviceService::OnStop() #endif // MEMMGR_ENABLE } -bool MiscdeviceService::ShouldIgnoreVibrate(const VibrateInfo &info) +bool MiscdeviceService::ShouldIgnoreVibrate(const VibrateInfo &info, const VibratorParamsIPC& params, + bool isLocalDevice) { std::lock_guard lock(isVibrationPriorityReadyMutex_); if (!isVibrationPriorityReady_) { @@ -340,14 +362,16 @@ bool MiscdeviceService::ShouldIgnoreVibrate(const VibrateInfo &info) return VIBRATION; } std::string curVibrateTime = GetCurrentTime(); - int32_t ret = PriorityManager->ShouldIgnoreVibrate(info, vibratorThread_); + auto vibratorThread_ = GetVibratorThread(params); + int32_t ret = PriorityManager->ShouldIgnoreVibrate(info, vibratorThread_, params, isLocalDevice); if (ret != VIBRATION) { MISC_HILOGE("ShouldIgnoreVibrate currentTime:%{public}s, ret:%{public}d", curVibrateTime.c_str(), ret); } return (ret != VIBRATION); } -int32_t MiscdeviceService::Vibrate(int32_t vibratorId, int32_t timeOut, int32_t usage, bool systemUsage) +int32_t MiscdeviceService::Vibrate(const VibratorParamsIPC& params, int32_t vibratorId, int32_t timeOut, + int32_t usage, bool systemUsage) { PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); @@ -375,18 +399,20 @@ int32_t MiscdeviceService::Vibrate(int32_t vibratorId, int32_t timeOut, int32_t }; std::lock_guard lock(vibratorThreadMutex_); std::string curVibrateTime = GetCurrentTime(); - if (ShouldIgnoreVibrate(info)) { - MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); - return ERROR; + { + std::lock_guard lock(devicesManageMutex_); + if (StartVibrateThreadControl(params, info) != ERR_OK) { + MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); + return ERROR; + } } - StartVibrateThread(info); MISC_HILOGI("Start vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, usage:%{public}d," "vibratorId:%{public}d, duration:%{public}d", curVibrateTime.c_str(), info.packageName.c_str(), info.pid, info.usage, vibratorId, info.duration); return NO_ERROR; } -int32_t MiscdeviceService::StopVibrator(int32_t vibratorId) +int32_t MiscdeviceService::StopVibrator(const VibratorParamsIPC& params, int32_t vibratorId) { PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); @@ -398,29 +424,46 @@ int32_t MiscdeviceService::StopVibrator(int32_t vibratorId) MISC_HILOGE("Result:%{public}d", ret); return PERMISSION_DENIED; } - return StopVibratorService(vibratorId); + std::lock_guard lock(devicesManageMutex_); + return StopVibratorService(params, vibratorId); } -int32_t MiscdeviceService::StopVibratorService(int32_t vibratorId) +int32_t MiscdeviceService::StopVibratorService(const VibratorParamsIPC& params, int32_t vibratorId) { std::lock_guard lock(vibratorThreadMutex_); -#if defined (OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM) && defined (HDF_DRIVERS_INTERFACE_VIBRATOR) - if ((vibratorThread_ == nullptr) || (!vibratorThread_->IsRunning() && - !vibratorHdiConnection_.IsVibratorRunning())) { - MISC_HILOGD("No vibration, no need to stop"); - return ERROR; - } - if (vibratorHdiConnection_.IsVibratorRunning()) { - vibratorHdiConnection_.Stop(HDF_VIBRATOR_MODE_PRESET); - vibratorHdiConnection_.Stop(HDF_VIBRATOR_MODE_HDHAPTIC); - } -#else - if ((vibratorThread_ == nullptr) || (!vibratorThread_->IsRunning())) { + std::vector result = CheckDeviceIdIsValid(params); + int ignoreVibrateNum = 0; + if(result.empty()) { MISC_HILOGD("No vibration, no need to stop"); return ERROR; + }else { + for (const auto& paramIt : result) { + auto vibratorThread_ = GetVibratorThread(paramIt); + #if defined (OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM) && defined (HDF_DRIVERS_INTERFACE_VIBRATOR) + if ((vibratorThread_ == nullptr) || (!vibratorThread_->IsRunning() && + !vibratorHdiConnection_.IsVibratorRunning(paramIt))) { + MISC_HILOGD("No vibration, no need to stop"); + ignoreVibrateNum ++; + continue; + } + if (vibratorHdiConnection_.IsVibratorRunning(paramIt)) { + vibratorHdiConnection_.Stop(paramIt, HDF_VIBRATOR_MODE_PRESET); + vibratorHdiConnection_.Stop(paramIt, HDF_VIBRATOR_MODE_HDHAPTIC); + } + #else + if ((vibratorThread_ == nullptr) || (!vibratorThread_->IsRunning())) { + MISC_HILOGD("No vibration, no need to stop"); + ignoreVibrateNum ++; + continue; + } + #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM && HDF_DRIVERS_INTERFACE_VIBRATOR + StopVibrateThread(vibratorThread_); + } + if(ignoreVibrateNum == result.size()) + { + return ERROR; + } } -#endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM && HDF_DRIVERS_INTERFACE_VIBRATOR - StopVibrateThread(); std::string packageName = GetPackageName(GetCallingTokenID()); std::string curVibrateTime = GetCurrentTime(); MISC_HILOGI("Stop vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, vibratorId:%{public}d", @@ -428,8 +471,8 @@ int32_t MiscdeviceService::StopVibratorService(int32_t vibratorId) return NO_ERROR; } -int32_t MiscdeviceService::PlayVibratorEffect(int32_t vibratorId, const std::string &effect, - int32_t count, int32_t usage, bool systemUsage) +int32_t MiscdeviceService::PlayVibratorEffect(const VibratorParamsIPC& params, int32_t vibratorId, + const std::string &effect, int32_t count, int32_t usage, bool systemUsage) { int32_t checkResult = PlayVibratorEffectCheckAuthAndParam(count, usage); if (checkResult != ERR_OK) { @@ -437,7 +480,7 @@ int32_t MiscdeviceService::PlayVibratorEffect(int32_t vibratorId, const std::str return checkResult; } #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - std::optional effectInfo = vibratorHdiConnection_.GetEffectInfo(effect); + std::optional effectInfo = vibratorHdiConnection_.GetEffectInfo(params, effect); if (!effectInfo) { MISC_HILOGE("GetEffectInfo fail"); return ERROR; @@ -463,11 +506,13 @@ int32_t MiscdeviceService::PlayVibratorEffect(int32_t vibratorId, const std::str }; std::lock_guard lock(vibratorThreadMutex_); std::string curVibrateTime = GetCurrentTime(); - if (ShouldIgnoreVibrate(info)) { - MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); - return ERROR; + { + std::lock_guard lock(devicesManageMutex_); + if (StartVibrateThreadControl(params, info) != ERR_OK) { + MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); + return ERROR; + } } - StartVibrateThread(info); MISC_HILOGI("Start vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, usage:%{public}d," "vibratorId:%{public}d, duration:%{public}d, effect:%{public}s, count:%{public}d", curVibrateTime.c_str(), info.packageName.c_str(), info.pid, info.usage, vibratorId, info.duration, info.effect.c_str(), info.count); @@ -493,34 +538,44 @@ int32_t MiscdeviceService::PlayVibratorEffectCheckAuthAndParam(int32_t count, in return ERR_OK; } -void MiscdeviceService::StartVibrateThread(VibrateInfo info) +void MiscdeviceService::StartVibrateThread(VibrateInfo info, const VibratorParamsIPC& params) { + auto vibratorThread_ = GetVibratorThread(params); if (vibratorThread_ == nullptr) { - vibratorThread_ = std::make_shared(); + MISC_HILOGD("No effective vibrator thread"); + return; } - StopVibrateThread(); + StopVibrateThread(vibratorThread_); #if defined (OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM) && defined (HDF_DRIVERS_INTERFACE_VIBRATOR) - if (vibratorHdiConnection_.IsVibratorRunning()) { - vibratorHdiConnection_.Stop(HDF_VIBRATOR_MODE_PRESET); - vibratorHdiConnection_.Stop(HDF_VIBRATOR_MODE_HDHAPTIC); + if (vibratorHdiConnection_.IsVibratorRunning(params)) { + vibratorHdiConnection_.Stop(params, HDF_VIBRATOR_MODE_PRESET); + vibratorHdiConnection_.Stop(params, HDF_VIBRATOR_MODE_HDHAPTIC); } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM && HDF_DRIVERS_INTERFACE_VIBRATOR - vibratorThread_->UpdateVibratorEffect(info); + std::vector waveInfo; + if(GetAllWaveInfo(params, waveInfo) != ERR_OK) + { + MISC_HILOGE("GetAllWaveInfo failed"); + return; + } + vibratorThread_->UpdateVibratorEffect(info, params, waveInfo); vibratorThread_->Start("VibratorThread"); DumpHelper->SaveVibrateRecord(info); } -void MiscdeviceService::StopVibrateThread() +void MiscdeviceService::StopVibrateThread(std::shared_ptr vibratorThread) { - if ((vibratorThread_ != nullptr) && (vibratorThread_->IsRunning())) { - vibratorThread_->SetExitStatus(true); - vibratorThread_->WakeUp(); - vibratorThread_->NotifyExitSync(); - vibratorThread_->SetExitStatus(false); + if ((vibratorThread != nullptr) && (vibratorThread->IsRunning())) { + vibratorThread->SetExitStatus(true); + vibratorThread->WakeUp(); + vibratorThread->NotifyExitSync(); + vibratorThread->SetExitStatus(false); + vibratorThread->ResetVibrateInfo(); } } -int32_t MiscdeviceService::StopVibratorByMode(int32_t vibratorId, const std::string &mode) +int32_t MiscdeviceService::StopVibratorByMode(const VibratorParamsIPC& params, int32_t vibratorId, + const std::string &mode) { std::lock_guard lock(vibratorThreadMutex_); PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); @@ -533,24 +588,39 @@ int32_t MiscdeviceService::StopVibratorByMode(int32_t vibratorId, const std::str MISC_HILOGE("CheckVibratePermission failed, ret:%{public}d", ret); return PERMISSION_DENIED; } - if ((vibratorThread_ == nullptr) || (!vibratorThread_->IsRunning())) { -#if defined (OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM) && defined (HDF_DRIVERS_INTERFACE_VIBRATOR) - if (vibratorHdiConnection_.IsVibratorRunning()) { - vibratorHdiConnection_.Stop(HDF_VIBRATOR_MODE_PRESET); - vibratorHdiConnection_.Stop(HDF_VIBRATOR_MODE_HDHAPTIC); - MISC_HILOGD("StopVibratorByMode"); - return NO_ERROR; - } -#endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM && HDF_DRIVERS_INTERFACE_VIBRATOR + std::vector result = CheckDeviceIdIsValid(params); + int ignoreVibrateNum = 0; + if(result.empty()) { MISC_HILOGD("No vibration, no need to stop"); return ERROR; + }else { + for (const auto& paramIt : result) { + auto vibratorThread_ = GetVibratorThread(paramIt); + if ((vibratorThread_ == nullptr) || (!vibratorThread_->IsRunning())) { +#if defined (OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM) && defined (HDF_DRIVERS_INTERFACE_VIBRATOR) + if (vibratorHdiConnection_.IsVibratorRunning(paramIt)) { + vibratorHdiConnection_.Stop(paramIt, HDF_VIBRATOR_MODE_PRESET); + vibratorHdiConnection_.Stop(paramIt, HDF_VIBRATOR_MODE_HDHAPTIC); + MISC_HILOGD("StopVibratorByMode"); + return NO_ERROR; + } +#endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM && HDF_DRIVERS_INTERFACE_VIBRATOR + MISC_HILOGD("No vibration, no need to stop"); + ignoreVibrateNum ++; + continue; + } + const VibrateInfo info = vibratorThread_->GetCurrentVibrateInfo(); + if (info.mode != mode) { + MISC_HILOGD("Stop vibration information mismatch"); + continue; + } + StopVibrateThread(vibratorThread_); + } + if(ignoreVibrateNum == result.size()) + { + return ERROR; + } } - const VibrateInfo info = vibratorThread_->GetCurrentVibrateInfo(); - if (info.mode != mode) { - MISC_HILOGD("Stop vibration information mismatch"); - return ERROR; - } - StopVibrateThread(); std::string packageName = GetPackageName(GetCallingTokenID()); std::string curVibrateTime = GetCurrentTime(); MISC_HILOGI("Stop vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, vibratorId:%{public}d," @@ -558,10 +628,10 @@ int32_t MiscdeviceService::StopVibratorByMode(int32_t vibratorId, const std::str return NO_ERROR; } -int32_t MiscdeviceService::IsSupportEffect(const std::string &effect, bool &state) +int32_t MiscdeviceService::IsSupportEffect(const VibratorParamsIPC& params, const std::string &effect, bool &state) { #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - std::optional effectInfo = vibratorHdiConnection_.GetEffectInfo(effect); + std::optional effectInfo = vibratorHdiConnection_.GetEffectInfo(params, effect); if (!effectInfo) { MISC_HILOGE("GetEffectInfo fail"); return ERROR; @@ -594,10 +664,10 @@ std::string MiscdeviceService::GetCurrentTime() } #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -int32_t MiscdeviceService::PlayVibratorCustom(int32_t vibratorId, int32_t fd, int64_t offset, int64_t length, - int32_t usage, bool systemUsage, const VibrateParameter ¶meter) +int32_t MiscdeviceService::PlayVibratorCustom(const VibratorParamsIPC& params, int32_t vibratorId, int32_t fd, + int64_t offset, int64_t length, int32_t usage, bool systemUsage, const VibrateParameter ¶meter) { - int32_t checkResult = CheckAuthAndParam(usage, parameter); + int32_t checkResult = CheckAuthAndParam(usage, parameter, params); if (checkResult != ERR_OK) { MISC_HILOGE("CheckAuthAndParam failed, ret:%{public}d", checkResult); return checkResult; @@ -626,6 +696,12 @@ int32_t MiscdeviceService::PlayVibratorCustom(int32_t vibratorId, int32_t fd, in .systemUsage = systemUsage, .package = package, }; + VibratorCapacity g_capacity; + if(GetHapticCapacityInfo(params, g_capacity) != ERR_OK) + { + MISC_HILOGE("GetVibratorCapacity failed"); + return ERROR; + } if (g_capacity.isSupportHdHaptic) { info.mode = VIBRATE_CUSTOM_HD; } else if (g_capacity.isSupportPresetMapping) { @@ -635,11 +711,13 @@ int32_t MiscdeviceService::PlayVibratorCustom(int32_t vibratorId, int32_t fd, in } std::lock_guard lock(vibratorThreadMutex_); std::string curVibrateTime = GetCurrentTime(); - if (ShouldIgnoreVibrate(info)) { - MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); - return ERROR; + { + std::lock_guard lock(devicesManageMutex_); + if (StartVibrateThreadControl(params, info) != ERR_OK) { + MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); + return ERROR; + } } - StartVibrateThread(info); MISC_HILOGI("Start vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, usage:%{public}d," "vibratorId:%{public}d, duration:%{public}d", curVibrateTime.c_str(), info.packageName.c_str(), info.pid, info.usage, vibratorId, package.packageDuration); @@ -647,7 +725,8 @@ int32_t MiscdeviceService::PlayVibratorCustom(int32_t vibratorId, int32_t fd, in } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -int32_t MiscdeviceService::CheckAuthAndParam(int32_t usage, const VibrateParameter ¶meter) +int32_t MiscdeviceService::CheckAuthAndParam(int32_t usage, const VibrateParameter ¶meter, + const VibratorParamsIPC& params) { PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); @@ -659,6 +738,12 @@ int32_t MiscdeviceService::CheckAuthAndParam(int32_t usage, const VibrateParamet MISC_HILOGE("CheckVibratePermission failed, ret:%{public}d", ret); return PERMISSION_DENIED; } + VibratorCapacity g_capacity; + if(GetHapticCapacityInfo(params, g_capacity) != ERR_OK) + { + MISC_HILOGE("GetVibratorCapacity failed"); + return ERROR; + } if (!(g_capacity.isSupportHdHaptic || g_capacity.isSupportPresetMapping || g_capacity.isSupportTimeDelay)) { MISC_HILOGE("The device does not support this operation"); return IS_NOT_SUPPORTED; @@ -802,8 +887,8 @@ int32_t MiscdeviceService::Dump(int32_t fd, const std::vector &a return ERR_OK; } -int32_t MiscdeviceService::PlayPattern(const VibratePattern &pattern, int32_t usage, - bool systemUsage, const VibrateParameter ¶meter) +int32_t MiscdeviceService::PlayPattern(const VibratorParamsIPC& params, const VibratePattern &pattern, + int32_t usage, bool systemUsage, const VibrateParameter ¶meter) { int32_t checkResult = PlayPatternCheckAuthAndParam(usage, parameter); if (checkResult != ERR_OK) { @@ -827,15 +912,23 @@ int32_t MiscdeviceService::PlayPattern(const VibratePattern &pattern, int32_t us .usage = usage, .systemUsage = systemUsage }; + VibratorCapacity g_capacity; + if(GetHapticCapacityInfo(params, g_capacity) != ERR_OK) + { + MISC_HILOGE("GetVibratorCapacity failed"); + return ERROR; + } if (g_capacity.isSupportHdHaptic) { std::lock_guard lock(vibratorThreadMutex_); std::string curVibrateTime = GetCurrentTime(); - if (ShouldIgnoreVibrate(info)) { - MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); - return ERROR; + { + std::lock_guard lock(devicesManageMutex_); + if (StartVibrateThreadControl(params, info) != ERR_OK) { + MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); + return ERROR; + } } - StartVibrateThread(info); - return vibratorHdiConnection_.PlayPattern(package.patterns.front()); + return vibratorHdiConnection_.PlayPattern(params, package.patterns.front()); } else if (g_capacity.isSupportPresetMapping) { info.mode = VIBRATE_CUSTOM_COMPOSITE_EFFECT; } else if (g_capacity.isSupportTimeDelay) { @@ -844,11 +937,13 @@ int32_t MiscdeviceService::PlayPattern(const VibratePattern &pattern, int32_t us info.package = package; std::lock_guard lock(vibratorThreadMutex_); std::string curVibrateTime = GetCurrentTime(); - if (ShouldIgnoreVibrate(info)) { - MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); - return ERROR; + { + std::lock_guard lock(devicesManageMutex_); + if (StartVibrateThreadControl(params, info) != ERR_OK) { + MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); + return ERROR; + } } - StartVibrateThread(info); MISC_HILOGI("Start vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, usage:%{public}d," "duration:%{public}d", curVibrateTime.c_str(), info.packageName.c_str(), info.pid, info.usage, pattern.patternDuration); @@ -874,11 +969,17 @@ int32_t MiscdeviceService::PlayPatternCheckAuthAndParam(int32_t usage, const Vib return ERR_OK; } -int32_t MiscdeviceService::GetDelayTime(int32_t &delayTime) +int32_t MiscdeviceService::GetDelayTime(const VibratorParamsIPC& params, int32_t &delayTime) { std::string packageName = GetPackageName(GetCallingTokenID()); MISC_HILOGD("GetDelayTime, package:%{public}s", packageName.c_str()); - return vibratorHdiConnection_.GetDelayTime(g_capacity.GetVibrateMode(), delayTime); + VibratorCapacity g_capacity; + if(GetHapticCapacityInfo(params, g_capacity) != ERR_OK) + { + MISC_HILOGE("GetVibratorCapacity failed"); + return ERROR; + } + return vibratorHdiConnection_.GetDelayTime(params, g_capacity.GetVibrateMode(), delayTime); } bool MiscdeviceService::CheckVibratorParmeters(const VibrateParameter ¶meter) @@ -919,6 +1020,41 @@ void MiscdeviceService::MergeVibratorParmeters(const VibrateParameter ¶meter } } +void MiscdeviceService::SendMsgToClient(HdfVibratorPlugInfo info) +{ + std::lock_guard lock(clientPidMapMutex_); + for (auto it = clientPidMap_.begin(); it != clientPidMap_.end(); ++it) { + const sptr& key = it->first; + + sptr clientProxy = iface_cast(key); + if (clientProxy != nullptr) { + clientProxy->ProcessPlugEvent(info.status, info.deviceId); + } + } + std::lock_guard lockManage(devicesManageMutex_); + if(info.status == 1) { + auto it = devicesManageMap_.find(info.deviceId); + if (it != devicesManageMap_.end()) { + VibratorParamsIPC params; + params.deviceId = info.deviceId; + params.vibratorId = -1; + StopVibratorService(params, VIBRATOR_ID); + devicesManageMap_.erase(it); + MISC_HILOGI("Device %{public}d is offline and removed from the map.", info.deviceId); + } else { + MISC_HILOGI("Device %{public}d is not in the map, so no action taken.", info.deviceId); + } + }else { + VibratorParamsIPC params; + params.deviceId = info.deviceId; + VibratorAllInfos newAllInfo({}); + if (!UpdateVibratorAllInfo(params, info, newAllInfo)) { + MISC_HILOGE("Update new vibrator info failed"); + return; + } + } +} + int32_t MiscdeviceService::TransferClientRemoteObject(const sptr &vibratorServiceClient) { auto clientPid = GetCallingPid(); @@ -927,6 +1063,24 @@ int32_t MiscdeviceService::TransferClientRemoteObject(const sptr return ERROR; } RegisterClientDeathRecipient(vibratorServiceClient, clientPid); + // std::thread thread([this]() mutable { + // while (1) + // { + // sleep(30); + // HdfVibratorPlugInfo info; + // info.status = 1; + // info.deviceId = 123; + // this->SendMsgToClient(info); + // sleep(30); + // { + // HdfVibratorPlugInfo info; + // info.status = 0; + // info.deviceId = 123; + // this->SendMsgToClient(info); + // } + // } + // }); + // thread.detach(); return ERR_OK; } @@ -936,17 +1090,31 @@ void MiscdeviceService::ProcessDeathObserver(const wptr &object) sptr client = object.promote(); int32_t clientPid = FindClientPid(client); VibrateInfo info; - { - std::lock_guard lock(vibratorThreadMutex_); - if (vibratorThread_ == nullptr) { - vibratorThread_ = std::make_shared(); + std::lock_guard lock(devicesManageMutex_); + for (const auto& pair : devicesManageMap_) { + int deviceId = pair.first; + const VibratorControlInfo& vibratorControlInfo_ = pair.second.controlInfo; + MISC_HILOGI("Device ID:%{public}d, , Motor Count:%{public}d", deviceId, vibratorControlInfo_.motorCount); + for (const auto& motorPair : vibratorControlInfo_.vibratorThreads) { + int motorId = motorPair.first; + { + std::lock_guard lock(vibratorThreadMutex_); + auto vibratorThread_ = motorPair.second; + if (vibratorThread_ == nullptr) { + MISC_HILOGE("MotorId:%{public}d, Vibrate thread no found in devicesManageMap_", motorId); + vibratorThread_ = std::make_shared(); + } + info = vibratorThread_->GetCurrentVibrateInfo(); + } + int32_t vibratePid = info.pid; + MISC_HILOGI("ClientPid:%{public}d, VibratePid:%{public}d", clientPid, vibratePid); + if ((clientPid != INVALID_PID) && (clientPid == vibratePid)) { + VibratorParamsIPC params; + params.deviceId = deviceId; + params.vibratorId = motorId; + StopVibratorService(params, VIBRATOR_ID); + } } - info = vibratorThread_->GetCurrentVibrateInfo(); - } - int32_t vibratePid = info.pid; - MISC_HILOGI("ClientPid:%{public}d, VibratePid:%{public}d", clientPid, vibratePid); - if ((clientPid != INVALID_PID) && (clientPid == vibratePid)) { - StopVibratorService(VIBRATOR_ID); } UnregisterClientDeathRecipient(client); } @@ -1025,8 +1193,8 @@ void MiscdeviceService::DestroyClientPid(const sptr &vibratorServ clientPidMap_.erase(it); } -int32_t MiscdeviceService::PlayPrimitiveEffect(int32_t vibratorId, const std::string &effect, - int32_t intensity, int32_t usage, bool systemUsage, int32_t count) +int32_t MiscdeviceService::PlayPrimitiveEffect(const VibratorParamsIPC& params, int32_t vibratorId, + const std::string &effect, int32_t intensity, int32_t usage, bool systemUsage, int32_t count) { int32_t checkResult = PlayPrimitiveEffectCheckAuthAndParam(intensity, usage); if (checkResult != ERR_OK) { @@ -1034,7 +1202,7 @@ int32_t MiscdeviceService::PlayPrimitiveEffect(int32_t vibratorId, const std::st return checkResult; } #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - std::optional effectInfo = vibratorHdiConnection_.GetEffectInfo(effect); + std::optional effectInfo = vibratorHdiConnection_.GetEffectInfo(params, effect); if (!effectInfo) { MISC_HILOGE("GetEffectInfo fail"); return ERROR; @@ -1060,11 +1228,13 @@ int32_t MiscdeviceService::PlayPrimitiveEffect(int32_t vibratorId, const std::st }; std::lock_guard lock(vibratorThreadMutex_); std::string curVibrateTime = GetCurrentTime(); - if (ShouldIgnoreVibrate(info)) { - MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); - return ERROR; + { + std::lock_guard lock(devicesManageMutex_); + if (StartVibrateThreadControl(params, info) != ERR_OK) { + MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); + return ERROR; + } } - StartVibrateThread(info); MISC_HILOGI("Start vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, usage:%{public}d," "vibratorId:%{public}d, duration:%{public}d, effect:%{public}s", curVibrateTime.c_str(), info.packageName.c_str(), info.pid, info.usage, vibratorId, info.duration, info.effect.c_str()); @@ -1090,10 +1260,328 @@ int32_t MiscdeviceService::PlayPrimitiveEffectCheckAuthAndParam(int32_t intensit return ERR_OK; } -int32_t MiscdeviceService::GetVibratorCapacity(VibratorCapacity &capacity) +int32_t MiscdeviceService::GetVibratorIdList(const VibratorParamsIPC& params, + std::vector& vibratorInfoIPC) +{ + CALL_LOG_ENTER; + MISC_HILOGD("devicesManageMap_.size() = %{public}d", devicesManageMap_.size()); + MISC_HILOGD("VibratorParamsIPC = [deviceId = %{public}d, vibratorId = %{public}d]", + params.deviceId, params.vibratorId); +// PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); +// int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); +// if (ret != PERMISSION_GRANTED) { +// #ifdef HIVIEWDFX_HISYSEVENT_ENABLE +// HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_PERMISSIONS_EXCEPTION", +// HiSysEvent::EventType::SECURITY, "PKG_NAME", "PlayPrimitiveEffectStub", "ERROR_CODE", ret); +// #endif // HIVIEWDFX_HISYSEVENT_ENABLE +// MISC_HILOGE("CheckVibratePermission failed, ret:%{public}d", ret); +// return PERMISSION_DENIED; +// } + if (devicesManageMap_.empty()) { + MISC_HILOGI("No vibrator device online"); + return NO_ERROR; + } + if ((params.deviceId == -1 && params.vibratorId == -1) || + (params.deviceId == -1 && params.vibratorId != -1)) { + for (auto &value : devicesManageMap_) { + vibratorInfoIPC.insert(vibratorInfoIPC.end(), value.second.baseInfo.begin(), + value.second.baseInfo.end()); + } + return NO_ERROR; + } else if (params.deviceId != -1 && params.vibratorId == -1) { + auto it = devicesManageMap_.find(params.deviceId); + if (it == devicesManageMap_.end()) { + MISC_HILOGD("Device manager map has no vibrator info"); + return NO_ERROR; + } + vibratorInfoIPC = it->second.baseInfo; + return NO_ERROR; + } else { + auto it = devicesManageMap_.find(params.deviceId); + if (it == devicesManageMap_.end()) { + MISC_HILOGD("Device manager map has no vibrator info"); + return NO_ERROR; + } + for (auto &value : it->second.baseInfo) { + if (params.vibratorId == value.vibratorId) { + vibratorInfoIPC.emplace_back(value); + } + } + return NO_ERROR; + } + return NO_ERROR; +} + +int32_t MiscdeviceService::GetEffectInfo(const VibratorParamsIPC& params, const std::string& effectType, + EffectInfoIPC& effectInfoIPC) { + CALL_LOG_ENTER; +// PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); +// int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); +// if (ret != PERMISSION_GRANTED) { +// #ifdef HIVIEWDFX_HISYSEVENT_ENABLE +// HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_PERMISSIONS_EXCEPTION", +// HiSysEvent::EventType::SECURITY, "PKG_NAME", "PlayPrimitiveEffectStub", "ERROR_CODE", ret); +// #endif // HIVIEWDFX_HISYSEVENT_ENABLE +// MISC_HILOGE("CheckVibratePermission failed, ret:%{public}d", ret); +// return PERMISSION_DENIED; +// } + MISC_HILOGD("VibratorParamsIpc = [deviceId = %{public}d, vibratorId = %{public}d]", + params.deviceId, params.vibratorId); + HdfEffectInfo hdfEffectInfo; + auto ret = vibratorHdiConnection_.GetEffectInfo(params, effectType, hdfEffectInfo); + if (ret != NO_ERROR) { + MISC_HILOGE("HDI::GetEffectInfo return error"); + return ERROR; + } + effectInfoIPC.duration = hdfEffectInfo.duration; + effectInfoIPC.isSupportEffect = hdfEffectInfo.isSupportEffect; + return NO_ERROR; +} + +int32_t MiscdeviceService::GetVibratorCapacity(const VibratorParamsIPC& params, VibratorCapacity &capacity) +{ + VibratorCapacity g_capacity; + if(GetHapticCapacityInfo(params, g_capacity) != ERR_OK) + { + MISC_HILOGE("GetVibratorCapacity failed"); + return ERROR; + } capacity = g_capacity; return ERR_OK; } + +std::shared_ptr MiscdeviceService::GetVibratorThread(const VibratorParamsIPC& params) +{ + CALL_LOG_ENTER; + auto deviceIt = devicesManageMap_.find(params.deviceId); + if (deviceIt != devicesManageMap_.end()) { + auto thread = deviceIt->second.controlInfo.GetVibratorThread(params.vibratorId); + if (thread) { + MISC_HILOGI("Success: Vibrate thread found."); + return thread; + } else { + MISC_HILOGE("Failed: Vibrate thread no found."); + return nullptr; + } + } + return nullptr; +} + +int32_t MiscdeviceService::GetHapticCapacityInfo(const VibratorParamsIPC& params, VibratorCapacity& capacityInfo) +{ + CALL_LOG_ENTER; + std::lock_guard lock(devicesManageMutex_); + auto deviceIt = devicesManageMap_.find(params.deviceId); + if (deviceIt == devicesManageMap_.end()) { + MISC_HILOGE("No vibrator information found for device ID: %{public}d", params.deviceId); + return PARAMETER_ERROR; + } + capacityInfo = deviceIt->second.capacityInfo; + return ERR_OK; +} + +int32_t MiscdeviceService::GetAllWaveInfo(const VibratorParamsIPC& params, std::vector& waveInfo) +{ + CALL_LOG_ENTER; + auto deviceIt = devicesManageMap_.find(params.deviceId); + if (deviceIt == devicesManageMap_.end()) { + MISC_HILOGE("No vibrator information found for device ID: %{public}d", params.deviceId); + return PARAMETER_ERROR; + } + waveInfo = deviceIt->second.waveInfo; + return ERR_OK; +} + +int32_t MiscdeviceService::GetHapticStartUpTime(const VibratorParamsIPC& params, int32_t mode, int32_t &startUpTime) +{ + CALL_LOG_ENTER; + auto ret = vibratorHdiConnection_.GetDelayTime(params, mode, startUpTime); + if (ret != NO_ERROR) { + MISC_HILOGE("HDI::GetHapticStartUpTime return error"); + return ERROR; + } + return NO_ERROR; +} + +bool MiscdeviceService::UpdateVibratorAllInfo(const VibratorParamsIPC ¶ms, + const HdfVibratorPlugInfo &info, VibratorAllInfos &vibratorAllInfos) +{ + CALL_LOG_ENTER; + std::vector baseInfo; + std::vector vibratorIdList; + int32_t ret = -1; + if (params.deviceId < 0 || (params.deviceId < 0 && params.vibratorId < 0)) { + ret = vibratorHdiConnection_.GetVibratorInfo(baseInfo); + } else { + ret = vibratorHdiConnection_.GetVibratorIdList(params, baseInfo); + } + if (ret != NO_ERROR || baseInfo.empty()) { + MISC_HILOGE("HDI::GetVibratorInfoList return error"); + return false; + } + for (auto& value: baseInfo) { + vibratorIdList.push_back(value.vibratorId); + } + VibratorAllInfos tVibratorInfo(vibratorIdList); + vibratorAllInfos = tVibratorInfo; + VibratorCapacity vibratorCapacity; + ret = vibratorHdiConnection_.GetVibratorCapacity(params, vibratorCapacity); + if (ret != NO_ERROR) { + MISC_HILOGE("HDI::GetHapticCapacity return error"); + return false; + } + std::vector waveInfo; + ret = vibratorHdiConnection_.GetAllWaveInfo(params, waveInfo); + if (ret != NO_ERROR || waveInfo.empty()) { + MISC_HILOGE("HDI::GetAllWaveInfo return error"); + return false; + } + (void)ConvertToServerInfos(baseInfo, vibratorCapacity, waveInfo, info, vibratorAllInfos); + devicesManageMap_.insert(std::make_pair(params.deviceId, vibratorAllInfos)); + return true; +} + +void MiscdeviceService::ConvertToServerInfos(const std::vector &baseVibratorInfo, + const VibratorCapacity &vibratorCapacity, const std::vector &waveInfomation, + const HdfVibratorPlugInfo &info, VibratorAllInfos& vibratorAllInfos) +{ + VibratorInfoIPC vibratorInfo; + for (auto infos : baseVibratorInfo) { + vibratorInfo.deviceId = infos.deviceId; + vibratorInfo.vibratorId = infos.vibratorId; + vibratorInfo.deviceName = "LocalVibrator"; + if (infos.isLocal != 1) { + vibratorInfo.deviceName = info.deviceName; + } + vibratorInfo.isSupportHdHaptic = vibratorCapacity.isSupportHdHaptic; + vibratorInfo.isLocalVibrator = infos.isLocal; + vibratorAllInfos.baseInfo.emplace_back(vibratorInfo); + } + vibratorAllInfos.capacityInfo = vibratorCapacity; + vibratorAllInfos.waveInfo = waveInfomation; +} + +void MiscdeviceService::FirstGetLocalVibratorInfo() +{ + std::vector vibratorInfo; + auto ret = vibratorHdiConnection_.GetVibratorInfo(vibratorInfo); + if (ret != NO_ERROR || vibratorInfo.empty()) { + MISC_HILOGW("Device not contain the local vibrator"); + return; + } + std::vector localInfo; + HdfVibratorPlugInfo mockInfo; + VibratorParamsIPC param; + for (auto &info : vibratorInfo) { + if (info.isLocal == 1) { + localInfo.emplace_back(info); + param.deviceId = info.deviceId; + } + } + VibratorCapacity capacity; + ret = vibratorHdiConnection_.GetVibratorCapacity(param, capacity); + if (ret != NO_ERROR) { + MISC_HILOGE("Get local hapticCapacity fail"); + return; + } + std::vector waveInfo; + ret = vibratorHdiConnection_.GetAllWaveInfo(param, waveInfo); + if (ret != NO_ERROR || waveInfo.empty()) { + MISC_HILOGE("Get local waveInfo fail"); + return; + } + std::vector vibratorIdList; + for (auto &value : localInfo) { + vibratorIdList.push_back(value.vibratorId); + } + VibratorAllInfos localVibratorInfo(vibratorIdList); + ConvertToServerInfos(localInfo, capacity, waveInfo, mockInfo, localVibratorInfo); + devicesManageMap_.insert(std::make_pair(param.deviceId, localVibratorInfo)); +} + +int32_t MiscdeviceService::StartVibrateThreadControl(const VibratorParamsIPC& params, VibrateInfo& info) +{ + std::string curVibrateTime = GetCurrentTime(); + std::vector result = CheckDeviceIdIsValid(params); + int ignoreVibrateNum = 0; + if(result.empty()) + { + MISC_HILOGD("No vibration found"); + return ERROR; + }else { + for (const auto& paramIt : result) { + if (ShouldIgnoreVibrate(info, paramIt, params.deviceId == -1)) { + ignoreVibrateNum ++; + continue; + } + StartVibrateThread(info, paramIt); + } + } + if(ignoreVibrateNum == result.size()) + { + return ERROR; + } + return ERR_OK; +} + +std::vector MiscdeviceService::CheckDeviceIdIsValid(const VibratorParamsIPC& params) +{ + CALL_LOG_ENTER; + std::vector result; + MISC_HILOGE("参数111,:%{public}d,:%{public}d,:%{public}d", params.deviceId, params.vibratorId, devicesManageMap_.size()); + if(params.deviceId == -1 && params.vibratorId == -1) { ////整个参数不传递，可能代码需要操作的是本地的默认马达 + MISC_HILOGE("2222222222222222参数,:%{public}d,:%{public}d", params.deviceId, params.deviceId); + for (const auto& pair : devicesManageMap_) { + for (const auto& info : pair.second.baseInfo) { + MISC_HILOGE("1111111111111参数,:%{public}d,:%{public}d", info.deviceId, info.vibratorId); + if (info.isLocalVibrator) { + VibratorParamsIPC newParams; + newParams.deviceId = info.deviceId; + newParams.vibratorId = info.vibratorId; + result.push_back(newParams); + MISC_HILOGE("1111压入result队列中,:%{public}d,:%{public}d", newParams.deviceId, newParams.deviceId); + } + } + } + }else if(params.deviceId != -1 && params.vibratorId == -1) { //如果只传了DeviceID，可能默认查询/控制 对应设备上的马达、 + auto deviceIt = devicesManageMap_.find(params.deviceId); + if (deviceIt != devicesManageMap_.end()) { + for (const auto& info : deviceIt->second.baseInfo) { + VibratorParamsIPC newParams; + newParams.deviceId = params.deviceId; + newParams.vibratorId = info.vibratorId; + result.push_back(newParams); + MISC_HILOGE("22222压入result队列中,:%{public}d,:%{public}d", newParams.deviceId, newParams.deviceId); + } + } + } else if(params.deviceId != -1 && params.vibratorId != -1) { //正常传递deviceId和vibratorId + auto deviceIt = devicesManageMap_.find(params.deviceId); + if (deviceIt != devicesManageMap_.end()) { + for (const auto& info : deviceIt->second.baseInfo) { + if (info.vibratorId == params.vibratorId) { + VibratorParamsIPC newParams; + newParams.deviceId = params.deviceId; + newParams.vibratorId = info.vibratorId; + result.push_back(newParams); + MISC_HILOGE("333333压入result队列中,:%{public}d,:%{public}d", newParams.deviceId, newParams.deviceId); + } + } + } + } else if(params.deviceId == -1 && params.vibratorId != -1) { //如果只传了VibratorID，可能默认查询/控制 是本地的默认马达 + for (const auto& pair : devicesManageMap_) { + for (const auto& info : pair.second.baseInfo) { + if (info.isLocalVibrator && info.vibratorId == params.vibratorId) { + VibratorParamsIPC newParams; + newParams.deviceId = info.deviceId; + newParams.vibratorId = info.vibratorId; + result.push_back(newParams); + MISC_HILOGE("444444压入result队列中,:%{public}d,:%{public}d", newParams.deviceId, newParams.deviceId); + } + } + } + } + return result; +} } // namespace Sensors } // namespace OHOS diff --git a/services/miscdevice_service/src/vibration_priority_manager.cpp b/services/miscdevice_service/src/vibration_priority_manager.cpp index 20eb99e..471e0c4 100644 --- a/services/miscdevice_service/src/vibration_priority_manager.cpp +++ b/services/miscdevice_service/src/vibration_priority_manager.cpp @@ -662,32 +662,34 @@ bool VibrationPriorityManager::ShouldIgnoreInputMethod(const VibrateInfo &vibrat #endif // OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD VibrateStatus VibrationPriorityManager::ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo, - std::shared_ptr vibratorThread) + std::shared_ptr vibratorThread, const VibratorParamsIPC& params, bool isLocalDevice) { UpdateStatus(); - if (!IsSystemCalling() || vibrateInfo.systemUsage == false) { + if(isLocalDevice) { //本机的优先级 + if (!IsSystemCalling() || vibrateInfo.systemUsage == false) { #ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB if (IgnoreAppVibrations(vibrateInfo)) { MISC_HILOGD("Vibration is ignored for doNotDisturb, usage:%{public}d", vibrateInfo.usage); return IGNORE_GLOBAL_SETTINGS; } #endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB - if ((vibrateInfo.usage == USAGE_ALARM || vibrateInfo.usage == USAGE_RING - || vibrateInfo.usage == USAGE_NOTIFICATION || vibrateInfo.usage == USAGE_COMMUNICATION) - && (miscAudioRingerMode_ == RINGER_MODE_SILENT)) { - MISC_HILOGD("Vibration is ignored for ringer mode:%{public}d", static_cast(miscAudioRingerMode_)); - return IGNORE_RINGER_MODE; - } - if (((vibrateInfo.usage == USAGE_TOUCH || vibrateInfo.usage == USAGE_MEDIA || vibrateInfo.usage == USAGE_UNKNOWN - || vibrateInfo.usage == USAGE_PHYSICAL_FEEDBACK || vibrateInfo.usage == USAGE_SIMULATE_REALITY) - && (miscFeedback_ == FEEDBACK_MODE_OFF)) -#ifdef OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD - && !ShouldIgnoreInputMethod(vibrateInfo)) { -#else // OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD - ) { -#endif // OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD - MISC_HILOGD("Vibration is ignored for feedback:%{public}d", static_cast(miscFeedback_)); - return IGNORE_FEEDBACK; + if ((vibrateInfo.usage == USAGE_ALARM || vibrateInfo.usage == USAGE_RING + || vibrateInfo.usage == USAGE_NOTIFICATION || vibrateInfo.usage == USAGE_COMMUNICATION) + && (miscAudioRingerMode_ == RINGER_MODE_SILENT)) { + MISC_HILOGD("Vibration is ignored for ringer mode:%{public}d", static_cast(miscAudioRingerMode_)); + return IGNORE_RINGER_MODE; + } + if (((vibrateInfo.usage == USAGE_TOUCH || vibrateInfo.usage == USAGE_MEDIA || vibrateInfo.usage == USAGE_UNKNOWN + || vibrateInfo.usage == USAGE_PHYSICAL_FEEDBACK || vibrateInfo.usage == USAGE_SIMULATE_REALITY) + && (miscFeedback_ == FEEDBACK_MODE_OFF)) + #ifdef OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD + && !ShouldIgnoreInputMethod(vibrateInfo)) { + #else // OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD + ) { + #endif // OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD + MISC_HILOGD("Vibration is ignored for feedback:%{public}d", static_cast(miscFeedback_)); + return IGNORE_FEEDBACK; + } } } #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CROWN @@ -700,7 +702,7 @@ VibrateStatus VibrationPriorityManager::ShouldIgnoreVibrate(const VibrateInfo &v MISC_HILOGD("There is no vibration, it can vibrate"); return VIBRATION; } - if (!IsCurrentVibrate(vibratorThread)) { + if (!IsCurrentVibrate(vibratorThread, params)) { MISC_HILOGD("There is no vibration at the moment, it can vibrate"); return VIBRATION; } @@ -711,10 +713,11 @@ VibrateStatus VibrationPriorityManager::ShouldIgnoreVibrate(const VibrateInfo &v return ShouldIgnoreVibrate(vibrateInfo, vibratorThread->GetCurrentVibrateInfo()); } -bool VibrationPriorityManager::IsCurrentVibrate(std::shared_ptr vibratorThread) const +bool VibrationPriorityManager::IsCurrentVibrate(std::shared_ptr vibratorThread, + const VibratorParamsIPC& params) const { #if defined(OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM) && defined(HDF_DRIVERS_INTERFACE_VIBRATOR) - return ((vibratorThread != nullptr) && (vibratorThread->IsRunning() || VibratorDevice.IsVibratorRunning())); + return ((vibratorThread != nullptr) && (vibratorThread->IsRunning() || VibratorDevice.IsVibratorRunning(params))); #else return ((vibratorThread != nullptr) && (vibratorThread->IsRunning())); #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM && HDF_DRIVERS_INTERFACE_VIBRATOR diff --git a/services/miscdevice_service/src/vibrator_thread.cpp b/services/miscdevice_service/src/vibrator_thread.cpp index cf1b5dd..09056e6 100644 --- a/services/miscdevice_service/src/vibrator_thread.cpp +++ b/services/miscdevice_service/src/vibrator_thread.cpp @@ -40,27 +40,29 @@ bool VibratorThread::Run() CALL_LOG_ENTER; prctl(PR_SET_NAME, VIBRATE_CONTROL_THREAD_NAME.c_str()); VibrateInfo info = GetCurrentVibrateInfo(); + VibratorParamsIPC params = GetCurrentVibrateParams(); + std::vector wareInfos = GetCurrentWareInfo(); if (info.mode == VIBRATE_TIME) { - int32_t ret = PlayOnce(info); + int32_t ret = PlayOnce(info, params); if (ret != SUCCESS) { MISC_HILOGE("Play once vibration fail, package:%{public}s", info.packageName.c_str()); return false; } } else if (info.mode == VIBRATE_PRESET) { - int32_t ret = PlayEffect(info); + int32_t ret = PlayEffect(info, params); if (ret != SUCCESS) { MISC_HILOGE("Play effect vibration fail, package:%{public}s", info.packageName.c_str()); return false; } } else if (info.mode == VIBRATE_CUSTOM_HD) { - int32_t ret = PlayCustomByHdHptic(info); + int32_t ret = PlayCustomByHdHptic(info, params); if (ret != SUCCESS) { MISC_HILOGE("Play custom vibration by hd haptic fail, package:%{public}s", info.packageName.c_str()); return false; } } else if (info.mode == VIBRATE_CUSTOM_COMPOSITE_EFFECT || info.mode == VIBRATE_CUSTOM_COMPOSITE_TIME) { #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - int32_t ret = PlayCustomByCompositeEffect(info); + int32_t ret = PlayCustomByCompositeEffect(info, params, wareInfos); if (ret != SUCCESS) { MISC_HILOGE("Play custom vibration by composite effect fail, package:%{public}s", info.packageName.c_str()); return false; @@ -70,10 +72,10 @@ bool VibratorThread::Run() return false; } -int32_t VibratorThread::PlayOnce(const VibrateInfo &info) +int32_t VibratorThread::PlayOnce(const VibrateInfo &info, const VibratorParamsIPC& params) { std::unique_lock vibrateLck(vibrateMutex_); - int32_t ret = VibratorDevice.StartOnce(static_cast(info.duration)); + int32_t ret = VibratorDevice.StartOnce(params, static_cast(info.duration)); if (ret != SUCCESS) { MISC_HILOGE("StartOnce fail, duration:%{public}d", info.duration); return ERROR; @@ -81,7 +83,7 @@ int32_t VibratorThread::PlayOnce(const VibrateInfo &info) cv_.wait_for(vibrateLck, std::chrono::milliseconds(info.duration), [this] { return exitFlag_.load(); }); if (exitFlag_) { #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - VibratorDevice.Stop(HDF_VIBRATOR_MODE_ONCE); + VibratorDevice.Stop(params, HDF_VIBRATOR_MODE_ONCE); #endif // HDF_DRIVERS_INTERFACE_VIBRATOR MISC_HILOGD("Stop duration:%{public}d, package:%{public}s", info.duration, info.packageName.c_str()); return SUCCESS; @@ -89,12 +91,12 @@ int32_t VibratorThread::PlayOnce(const VibrateInfo &info) return SUCCESS; } -void VibratorThread::HandleMultipleVibrations() +void VibratorThread::HandleMultipleVibrations(const VibratorParamsIPC& params) { - if (VibratorDevice.IsVibratorRunning()) { - VibratorDevice.Stop(HDF_VIBRATOR_MODE_PRESET); + if (VibratorDevice.IsVibratorRunning(params)) { + VibratorDevice.Stop(params, HDF_VIBRATOR_MODE_PRESET); for (size_t i = 0; i < RETRY_NUMBER; i++) { - if (!VibratorDevice.IsVibratorRunning()) { + if (!VibratorDevice.IsVibratorRunning(params)) { MISC_HILOGI("No running vibration"); return; } @@ -104,17 +106,17 @@ void VibratorThread::HandleMultipleVibrations() } } -int32_t VibratorThread::PlayEffect(const VibrateInfo &info) +int32_t VibratorThread::PlayEffect(const VibrateInfo &info, const VibratorParamsIPC& params) { std::unique_lock vibrateLck(vibrateMutex_); for (int32_t i = 0; i < info.count; ++i) { std::string effect = info.effect; int32_t duration = info.duration; if (i >= 1) { /**Multiple vibration treatment*/ - HandleMultipleVibrations(); + HandleMultipleVibrations(params); duration += DELAY_TIME2; } - int32_t ret = VibratorDevice.StartByIntensity(effect, info.intensity); + int32_t ret = VibratorDevice.StartByIntensity(params, effect, info.intensity); if (ret != SUCCESS) { MISC_HILOGE("Vibrate effect %{public}s failed, ", effect.c_str()); return ERROR; @@ -122,7 +124,7 @@ int32_t VibratorThread::PlayEffect(const VibrateInfo &info) cv_.wait_for(vibrateLck, std::chrono::milliseconds(duration), [this] { return exitFlag_.load(); }); if (exitFlag_) { #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - VibratorDevice.Stop(HDF_VIBRATOR_MODE_PRESET); + VibratorDevice.Stop(params, HDF_VIBRATOR_MODE_PRESET); #endif // HDF_DRIVERS_INTERFACE_VIBRATOR MISC_HILOGD("Stop effect:%{public}s, package:%{public}s", effect.c_str(), info.packageName.c_str()); return SUCCESS; @@ -131,7 +133,7 @@ int32_t VibratorThread::PlayEffect(const VibrateInfo &info) return SUCCESS; } -int32_t VibratorThread::PlayCustomByHdHptic(const VibrateInfo &info) +int32_t VibratorThread::PlayCustomByHdHptic(const VibrateInfo &info, const VibratorParamsIPC& params) { std::unique_lock vibrateLck(vibrateMutex_); const std::vector &patterns = info.package.patterns; @@ -146,12 +148,12 @@ int32_t VibratorThread::PlayCustomByHdHptic(const VibrateInfo &info) cv_.wait_for(vibrateLck, std::chrono::milliseconds(delayTime), [this] { return exitFlag_.load(); }); if (exitFlag_) { #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - VibratorDevice.Stop(HDF_VIBRATOR_MODE_HDHAPTIC); + VibratorDevice.Stop(params, HDF_VIBRATOR_MODE_HDHAPTIC); #endif // HDF_DRIVERS_INTERFACE_VIBRATOR MISC_HILOGD("Stop hd haptic, package:%{public}s", info.packageName.c_str()); return SUCCESS; } - int32_t ret = VibratorDevice.PlayPattern(patterns[i]); + int32_t ret = VibratorDevice.PlayPattern(params, patterns[i]); if (ret != SUCCESS) { MISC_HILOGE("Vibrate hd haptic failed"); return ERROR; @@ -161,9 +163,10 @@ int32_t VibratorThread::PlayCustomByHdHptic(const VibrateInfo &info) } #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR -int32_t VibratorThread::PlayCustomByCompositeEffect(const VibrateInfo &info) +int32_t VibratorThread::PlayCustomByCompositeEffect(const VibrateInfo &info, const VibratorParamsIPC& params, + std::vector wareInfo) { - auto &matcher = CustomVibrationMatcher::GetInstance(); + CustomVibrationMatcher matcher(params, wareInfo); HdfCompositeEffect hdfCompositeEffect; if (info.mode == VIBRATE_CUSTOM_COMPOSITE_EFFECT) { hdfCompositeEffect.type = HDF_EFFECT_TYPE_PRIMITIVE; @@ -180,10 +183,11 @@ int32_t VibratorThread::PlayCustomByCompositeEffect(const VibrateInfo &info) return ERROR; } } - return PlayCompositeEffect(info, hdfCompositeEffect); + return PlayCompositeEffect(info, hdfCompositeEffect, params); } -int32_t VibratorThread::PlayCompositeEffect(const VibrateInfo &info, const HdfCompositeEffect &hdfCompositeEffect) +int32_t VibratorThread::PlayCompositeEffect(const VibrateInfo &info, const HdfCompositeEffect &hdfCompositeEffect, + const VibratorParamsIPC& params) { std::unique_lock vibrateLck(vibrateMutex_); HdfCompositeEffect effectsPart; @@ -201,7 +205,7 @@ int32_t VibratorThread::PlayCompositeEffect(const VibrateInfo &info, const HdfCo return ERROR; } if ((effectsPart.compositeEffects.size() >= COMPOSITE_EFFECT_PART) || (i == (effectSize - 1))) { - int32_t ret = VibratorDevice.EnableCompositeEffect(effectsPart); + int32_t ret = VibratorDevice.EnableCompositeEffect(params, effectsPart); if (ret != SUCCESS) { MISC_HILOGE("EnableCompositeEffect failed"); return ERROR; @@ -211,7 +215,7 @@ int32_t VibratorThread::PlayCompositeEffect(const VibrateInfo &info, const HdfCo effectsPart.compositeEffects.clear(); } if (exitFlag_) { - VibratorDevice.Stop(HDF_VIBRATOR_MODE_PRESET); + VibratorDevice.Stop(params, HDF_VIBRATOR_MODE_PRESET); MISC_HILOGD("Stop composite effect part, package:%{public}s", info.packageName.c_str()); return SUCCESS; } @@ -220,10 +224,13 @@ int32_t VibratorThread::PlayCompositeEffect(const VibrateInfo &info, const HdfCo } #endif // HDF_DRIVERS_INTERFACE_VIBRATOR -void VibratorThread::UpdateVibratorEffect(const VibrateInfo &info) +void VibratorThread::UpdateVibratorEffect(const VibrateInfo &info, const VibratorParamsIPC& params, + std::vector &waveInfos) { std::unique_lock lck(currentVibrationMutex_); currentVibration_ = info; + currentVibrateParams_ = params; + waveInfos_ = waveInfos; } VibrateInfo VibratorThread::GetCurrentVibrateInfo() @@ -232,6 +239,18 @@ VibrateInfo VibratorThread::GetCurrentVibrateInfo() return currentVibration_; } +VibratorParamsIPC VibratorThread::GetCurrentVibrateParams() +{ + std::unique_lock lck(currentVibrateParamsMutex_); + return currentVibrateParams_; +} + +std::vector VibratorThread::GetCurrentWareInfo() +{ + std::unique_lock lck(currentVibrateParamsMutex_); + return waveInfos_; +} + void VibratorThread::SetExitStatus(bool status) { exitFlag_.store(status); @@ -242,5 +261,20 @@ void VibratorThread::WakeUp() MISC_HILOGD("Notify the vibratorThread"); cv_.notify_one(); } + +void VibratorThread::ResetVibrateInfo() +{ + std::unique_lock lck(currentVibrationMutex_); + currentVibration_.mode = ""; + currentVibration_.packageName = ""; + currentVibration_.pid = -1; + currentVibration_.uid = -1; + currentVibration_.usage = 0; + currentVibration_.systemUsage = false; + currentVibration_.duration = 0; + currentVibration_.effect = ""; + currentVibration_.count = 0; + currentVibration_.intensity = 0; +} } // namespace Sensors } // namespace OHOS diff --git a/test/unittest/vibrator/native/vibrator_agent_test.cpp b/test/unittest/vibrator/native/vibrator_agent_test.cpp index 3f30ed2..acab482 100644 --- a/test/unittest/vibrator/native/vibrator_agent_test.cpp +++ b/test/unittest/vibrator/native/vibrator_agent_test.cpp @@ -1345,5 +1345,1269 @@ HWTEST_F(VibratorAgentTest, IsHdHapticSupported_001, TestSize.Level1) } Cancel(); } + +bool IsSupportVibratorEffectEnhanced(const VibratorParams params, const char* effectId) +{ + bool state { false }; + IsSupportEffectEnhanced(params, effectId, &state); + return state; +} + +HWTEST_F(VibratorAgentTest, StartVibratorEnhancedTest_001, TestSize.Level1) +{ + MISC_HILOGI("StartVibratorEnhancedTest_001 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorEffectEnhanced(params, VIBRATOR_TYPE_CLOCK_TIMER); + if (isSupport) { + int32_t ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_CLOCK_TIMER); + ASSERT_EQ(ret, 0); + } else { + ASSERT_EQ(isSupport, false); + } +} + +HWTEST_F(VibratorAgentTest, StartVibratorEnhancedTest_002, TestSize.Level1) +{ + MISC_HILOGI("StartVibratorEnhancedTest_002 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + int32_t ret = StartVibratorEnhanced(params, ""); + ASSERT_NE(ret, 0); +} + +HWTEST_F(VibratorAgentTest, StartVibratorEnhancedTest_003, TestSize.Level1) +{ + MISC_HILOGI("StartVibratorTest_003 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + int32_t ret = StartVibratorEnhanced(params, nullptr); + ASSERT_NE(ret, 0); +} + +HWTEST_F(VibratorAgentTest, StartVibratorOnceEnhancedTest_001, TestSize.Level1) +{ + MISC_HILOGI("StartVibratorOnceEnhancedTest_001 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + int32_t ret = StartVibratorOnceEnhanced(params, 300); + ASSERT_EQ(ret, 0); +} + +HWTEST_F(VibratorAgentTest, StartVibratorOnceEnhancedTest_002, TestSize.Level1) +{ + MISC_HILOGI("StartVibratorOnceEnhancedTest_002 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + int32_t ret = StartVibratorOnceEnhanced(params, 0); + ASSERT_NE(ret, 0); +} + +HWTEST_F(VibratorAgentTest, StartVibratorOnceEnhancedTest_003, TestSize.Level1) +{ + MISC_HILOGI("StartVibratorOnceEnhancedTest_003 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + int32_t ret = StartVibratorOnceEnhanced(params, 1800000); + ASSERT_EQ(ret, 0); +} + +HWTEST_F(VibratorAgentTest, StartVibratorOnceEnhancedTest_004, TestSize.Level1) +{ + MISC_HILOGI("StartVibratorOnceEnhancedTest_004 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + int32_t ret = StartVibratorOnceEnhanced(params, 1800001); + ASSERT_NE(ret, 0); +} + +HWTEST_F(VibratorAgentTest, StopVibratorEnhancedTest_001, TestSize.Level1) +{ + MISC_HILOGI("StopVibratorEnhancedTest_001 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + int32_t ret = StopVibratorEnhanced(params, "time"); + ASSERT_EQ(ret, 0); +} + +HWTEST_F(VibratorAgentTest, StopVibratorEnhancedTest_002, TestSize.Level1) +{ + MISC_HILOGI("StopVibratorEnhancedTest_002 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + int32_t ret = StopVibratorEnhanced(params, "preset"); + ASSERT_NE(ret, 0); +} + +HWTEST_F(VibratorAgentTest, StopVibratorEnhancedTest_003, TestSize.Level1) +{ + MISC_HILOGI("StopVibratorEnhancedTest_003 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + int32_t ret = StopVibratorEnhanced(params, ""); + ASSERT_NE(ret, 0); +} + +HWTEST_F(VibratorAgentTest, StopVibratorEnhancedTest_004, TestSize.Level1) +{ + MISC_HILOGI("StopVibratorEnhancedTest_004 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + int32_t ret = StopVibratorEnhanced(params, nullptr); + ASSERT_NE(ret, 0); +} + +HWTEST_F(VibratorAgentTest, StopVibratorEnhancedTest_005, TestSize.Level1) +{ + MISC_HILOGI("StopVibratorEnhancedTest_005 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + int32_t ret = StartVibratorOnceEnhanced(params, 300); + ASSERT_EQ(ret, 0); + ret = StopVibratorEnhanced(params, "time"); + ASSERT_EQ(ret, 0); +} + +HWTEST_F(VibratorAgentTest, SetLoopCountEnhanced_001, TestSize.Level1) +{ + MISC_HILOGI("SetLoopCountEnhanced_001 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool ret = SetLoopCountEnhanced(params, 300); + ASSERT_TRUE(ret); +} + +HWTEST_F(VibratorAgentTest, SetLoopCountEnhanced_002, TestSize.Level1) +{ + MISC_HILOGI("SetLoopCount_002 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool ret = SetLoopCountEnhanced(params, -1); + ASSERT_FALSE(ret); +} + +HWTEST_F(VibratorAgentTest, SetLoopCountEnhanced_003, TestSize.Level1) +{ + MISC_HILOGI("SetLoopCountEnhanced_003 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool ret = SetLoopCountEnhanced(params, 0); + ASSERT_FALSE(ret); +} + +HWTEST_F(VibratorAgentTest, SetUsageEnhanced_001, TestSize.Level1) +{ + MISC_HILOGI("SetUsageEnhanced_001 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool ret = SetUsageEnhanced(params, 0); + ASSERT_TRUE(ret); +} + +HWTEST_F(VibratorAgentTest, SetUsageEnhanced_002, TestSize.Level1) +{ + MISC_HILOGI("SetUsageEnhanced_002 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool ret = SetUsageEnhanced(params, -1); + ASSERT_FALSE(ret); +} + +HWTEST_F(VibratorAgentTest, SetUsageEnhanced_003, TestSize.Level1) +{ + MISC_HILOGI("SetUsage_003 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool ret = SetUsageEnhanced(params, USAGE_MAX); + ASSERT_FALSE(ret); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_001, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_001 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/coin_drop.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_002, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_002 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_003, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_003 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = (IsSupportVibratorCustomEnhanced(params) && IsSupportVibratorEffectEnhanced(params, VIBRATOR_TYPE_FAIL)); + if (isSupport) { + bool flag = SetLoopCountEnhanced(params, 2); + ASSERT_TRUE(flag); + int32_t ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_FAIL); + ASSERT_EQ(ret, 0); + FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_NE(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_004, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_004 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = (IsSupportVibratorCustomEnhanced(params) && IsSupportVibratorEffectEnhanced(params, VIBRATOR_TYPE_FAIL)); + if (isSupport) { + bool flag = SetUsageEnhanced(params, USAGE_ALARM); + ASSERT_TRUE(flag); + int32_t ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_FAIL); + ASSERT_EQ(ret, 0); + FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_NE(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_005, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_005 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = (IsSupportVibratorCustomEnhanced(params) && IsSupportVibratorEffectEnhanced(params, VIBRATOR_TYPE_FAIL)); + if (isSupport) { + bool flag = SetUsageEnhanced(params, USAGE_UNKNOWN); + ASSERT_TRUE(flag); + int32_t ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_FAIL); + ASSERT_EQ(ret, 0); + FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_006, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_006 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = (IsSupportVibratorCustomEnhanced(params) && IsSupportVibratorEffectEnhanced(params, VIBRATOR_TYPE_FAIL)); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + bool flag = SetUsageEnhanced(params, USAGE_ALARM); + ASSERT_TRUE(flag); + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_FAIL); + ASSERT_NE(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_007, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_007 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = (IsSupportVibratorCustomEnhanced(params) && IsSupportVibratorEffectEnhanced(params, VIBRATOR_TYPE_FAIL)); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + bool flag = SetUsageEnhanced(params, USAGE_UNKNOWN); + ASSERT_TRUE(flag); + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_FAIL); + ASSERT_EQ(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_008, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_008 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + bool flag = SetUsageEnhanced(params, USAGE_ALARM); + ASSERT_TRUE(flag); + int32_t ret = StartVibratorOnceEnhanced(params, 500); + ASSERT_EQ(ret, 0); + FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_NE(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_009, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_009 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + bool flag = SetUsage(USAGE_UNKNOWN); + ASSERT_TRUE(flag); + int32_t ret = StartVibratorOnceEnhanced(params, 500); + ASSERT_EQ(ret, 0); + FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_010, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_010 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + bool flag = SetUsageEnhanced(params, USAGE_ALARM); + ASSERT_TRUE(flag); + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + ret = StartVibratorOnceEnhanced(params, 500); + ASSERT_NE(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_011, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_011 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + bool flag = SetUsageEnhanced(params, USAGE_UNKNOWN); + ASSERT_TRUE(flag); + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + ret = StartVibratorOnceEnhanced(params, 500); + ASSERT_EQ(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_012, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_012 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/test_128_event.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_013, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_013 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/test_invalid_type.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_NE(ret, 0); + } + } else { + ASSERT_EQ(isSupport, false); + } +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_014, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_014 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/test_invalid_startTime.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_NE(ret, 0); + } + } else { + ASSERT_EQ(isSupport, false); + } +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_015, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_015 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/test_invalid_duration.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_NE(ret, 0); + } + } else { + ASSERT_EQ(isSupport, false); + } +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_016, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_016 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/test_invalid_intensity.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_NE(ret, 0); + } + } else { + ASSERT_EQ(isSupport, false); + } +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_017, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_017 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/test_invalid_frequency.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_NE(ret, 0); + } + } else { + ASSERT_EQ(isSupport, false); + } +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_018, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_018 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/test_129_event.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_NE(ret, 0); + } + } else { + ASSERT_EQ(isSupport, false); + } +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_019, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_019 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/test_big_file_size.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_NE(ret, 0); + } + } else { + ASSERT_EQ(isSupport, false); + } +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_020, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_020 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/test_event_overlap_1.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + } + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_021, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_021 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/test_event_overlap_2.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + } + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_022, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_022 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/Jet_N2O.he"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_023, TestSize.Level1) +{ + MISC_HILOGI("PlayVibratorCustomEnhanced_023 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/Racing_Start.he"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, SetParametersEnhanced_001, TestSize.Level1) +{ + MISC_HILOGI("SetParametersEnhanced_001 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + VibratorParameter parameter = { + .intensity = -1, + .frequency = -15 + }; + bool ret = SetParametersEnhanced(params, parameter); + ASSERT_FALSE(ret); +} + +HWTEST_F(VibratorAgentTest, SetParametersEnhanced_002, TestSize.Level1) +{ + MISC_HILOGI("SetParametersEnhanced_002 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + VibratorParameter parameter = { + .intensity = 70, + .frequency = 150 + }; + bool ret = SetParametersEnhanced(params, parameter); + ASSERT_FALSE(ret); +} + +HWTEST_F(VibratorAgentTest, SetParametersEnhanced_003, TestSize.Level1) +{ + MISC_HILOGI("SetParametersEnhanced_003 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/coin_drop.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + VibratorParameter parameter = { + .intensity = 50, + .frequency = -15 + }; + bool flag = SetParametersEnhanced(params, parameter); + ASSERT_TRUE(flag); + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, SetParametersEnhanced_004, TestSize.Level1) +{ + MISC_HILOGI("SetParametersEnhanced_004 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + VibratorParameter parameter = { + .intensity = 33, + .frequency = 55 + }; + bool flag = SetParametersEnhanced(params, parameter); + ASSERT_TRUE(flag); + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} + +HWTEST_F(VibratorAgentTest, CancelEnhanced_001, TestSize.Level1) +{ + MISC_HILOGI("CancelEnhanced_001 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + int32_t ret = CancelEnhanced(params); + ASSERT_NE(ret, 0); +} + +HWTEST_F(VibratorAgentTest, CancelEnhanced_002, TestSize.Level1) +{ + MISC_HILOGI("CancelEnhanced_002 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/coin_drop.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + ret = CancelEnhanced(params); + ASSERT_EQ(ret, 0); + } + } else { + ASSERT_EQ(isSupport, false); + } +} + +HWTEST_F(VibratorAgentTest, CancelEnhanced_003, TestSize.Level1) +{ + MISC_HILOGI("CancelEnhanced_003 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + int32_t ret = StartVibratorOnceEnhanced(params, 500); + ASSERT_EQ(ret, 0); + ret = CancelEnhanced(params); + ASSERT_EQ(ret, 0); +} + +HWTEST_F(VibratorAgentTest, CancelEnhanced_004, TestSize.Level1) +{ + MISC_HILOGI("CancelEnhanced_004 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + if (IsSupportVibratorEffectEnhanced(params, VIBRATOR_TYPE_FAIL)) { + int32_t ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_FAIL); + ASSERT_EQ(ret, 0); + ret = CancelEnhanced(params); + ASSERT_EQ(ret, 0); + } + ASSERT_TRUE(true); +} + +HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_001, TestSize.Level1) +{ + MISC_HILOGI("IsSupportEffectEnhanced_001 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool state { false }; + int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_CLOCK_TIMER, &state); + ASSERT_EQ(ret, 0); + if (state) { + ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_CLOCK_TIMER); + ASSERT_EQ(ret, 0); + CancelEnhanced(params); + } else { + MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_CLOCK_TIMER); + } +} + +HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_002, TestSize.Level1) +{ + MISC_HILOGI("IsSupportEffectEnhanced_002 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool state { false }; + int32_t ret = IsSupportEffectEnhanced(params, "haptic.xxx.yyy", &state); + ASSERT_EQ(ret, 0); + ASSERT_FALSE(state); +} + +HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_003, TestSize.Level1) +{ + MISC_HILOGI("IsSupportEffectEnhanced_003 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool state { false }; + int32_t ret = IsSupportEffectEnhanced(params, nullptr, &state); + ASSERT_NE(ret, 0); + ASSERT_FALSE(state); +} + +HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_004, TestSize.Level1) +{ + MISC_HILOGI("IsSupportEffectEnhanced_004 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool state { false }; + int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_FAIL, &state); + ASSERT_EQ(ret, 0); + if (state) { + ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_FAIL); + ASSERT_EQ(ret, 0); + CancelEnhanced(params); + } else { + MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_FAIL); + } +} + +HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_005, TestSize.Level1) +{ + MISC_HILOGI("IsSupportEffectEnhanced_005 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool state { false }; + int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_CHARGING, &state); + ASSERT_EQ(ret, 0); + if (state) { + ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_CHARGING); + ASSERT_EQ(ret, 0); + CancelEnhanced(params); + } else { + MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_CHARGING); + } +} + +HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_006, TestSize.Level1) +{ + MISC_HILOGI("IsSupportEffectEnhanced_006 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool state { false }; + int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_LONG_PRESS_HEAVY, &state); + ASSERT_EQ(ret, 0); + if (state) { + ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_LONG_PRESS_HEAVY); + ASSERT_EQ(ret, 0); + CancelEnhanced(params); + } else { + MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_LONG_PRESS_HEAVY); + } +} + +HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_007, TestSize.Level1) +{ + MISC_HILOGI("IsSupportEffectEnhanced_007 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool state { false }; + int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_LONG_PRESS_LIGHT, &state); + ASSERT_EQ(ret, 0); + if (state) { + ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_LONG_PRESS_LIGHT); + ASSERT_EQ(ret, 0); + CancelEnhanced(params); + } else { + MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_LONG_PRESS_LIGHT); + } +} + +HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_008, TestSize.Level1) +{ + MISC_HILOGI("IsSupportEffectEnhanced_008 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool state { false }; + int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_LONG_PRESS_MEDIUM, &state); + ASSERT_EQ(ret, 0); + if (state) { + ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_LONG_PRESS_MEDIUM); + ASSERT_EQ(ret, 0); + CancelEnhanced(params); + } else { + MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_LONG_PRESS_MEDIUM); + } +} + +HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_009, TestSize.Level1) +{ + MISC_HILOGI("IsSupportEffectEnhanced_009 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool state { false }; + int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_SLIDE_LIGHT, &state); + ASSERT_EQ(ret, 0); + if (state) { + ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_SLIDE_LIGHT); + ASSERT_EQ(ret, 0); + CancelEnhanced(params); + } else { + MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_SLIDE_LIGHT); + } +} + +HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_010, TestSize.Level1) +{ + MISC_HILOGI("IsSupportEffectEnhanced_010 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool state { false }; + int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_THRESHOID, &state); + ASSERT_EQ(ret, 0); + if (state) { + ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_THRESHOID); + ASSERT_EQ(ret, 0); + CancelEnhanced(params); + } else { + MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_THRESHOID); + } +} + +HWTEST_F(VibratorAgentTest, GetDelayTimeEnhanced_001, TestSize.Level1) +{ + MISC_HILOGI("GetDelayTimeEnhanced_001 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + int32_t delayTime { -1 }; + int32_t ret = GetDelayTimeEnhanced(params, delayTime); + ASSERT_EQ(ret, 0); + } else { + ASSERT_EQ(isSupport, false); + } +} + +HWTEST_F(VibratorAgentTest, PlayPatternEnhanced_001, TestSize.Level1) +{ + MISC_HILOGI("PlayPatternEnhanced_001 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = IsSupportVibratorCustomEnhanced(params); + if (isSupport) { + int32_t delayTime { -1 }; + int32_t ret = GetDelayTimeEnhanced(params, delayTime); + ASSERT_EQ(ret, 0); + MISC_HILOGD("delayTime:%{public}d", delayTime); + FileDescriptor fileDescriptor("/data/test/vibrator/coin_drop.json"); + MISC_HILOGD("fd:%{public}d", fileDescriptor.fd); + VibratorFileDescription vfd; + VibratorPackage package; + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + vfd.fd = fileDescriptor.fd; + vfd.offset = 0; + vfd.length = statbuf.st_size; + ret = PreProcess(vfd, package); + ASSERT_EQ(ret, 0); + for (int32_t i = 0; i < package.patternNum; ++i) { + if (i == 0) { + std::this_thread::sleep_for(std::chrono::milliseconds(package.patterns[i].time)); + } else { + std::this_thread::sleep_for(std::chrono::milliseconds(package.patterns[i].time) - + std::chrono::milliseconds(package.patterns[i - 1].time)); + } + ASSERT_EQ(SetUsageEnhanced(params, USAGE_UNKNOWN), true); + MISC_HILOGD("pointNum:%{public}d", package.patterns[i].events[i].pointNum); + ret = PlayPatternEnhanced(params, package.patterns[i]); + ASSERT_EQ(ret, 0); + } + } + ret = FreeVibratorPackage(package); + ASSERT_EQ(ret, 0); + CancelEnhanced(params); + } else { + ASSERT_EQ(isSupport, false); + } +} + +HWTEST_F(VibratorAgentTest, PlayPrimitiveEffectEnhanced_001, TestSize.Level1) +{ + MISC_HILOGI("PlayPrimitiveEffectEnhanced_001 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + int32_t ret = PlayPrimitiveEffectEnhanced(params, nullptr, INTENSITY_HIGH); + ASSERT_EQ(ret, PARAMETER_ERROR); +} + +HWTEST_F(VibratorAgentTest, PlayPrimitiveEffectEnhanced_002, TestSize.Level1) +{ + MISC_HILOGI("PlayPrimitiveEffectEnhanced_002 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool state { false }; + int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, &state); + ASSERT_EQ(ret, 0); + if (state) { + ret = PlayPrimitiveEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, INTENSITY_INVALID); + ASSERT_EQ(ret, PARAMETER_ERROR); + } else { + MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_SLIDE); + } +} + +HWTEST_F(VibratorAgentTest, PlayPrimitiveEffectEnhanced_003, TestSize.Level1) +{ + MISC_HILOGI("PlayPrimitiveEffectEnhanced_003 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool state { false }; + int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, &state); + ASSERT_EQ(ret, 0); + if (state) { + ret = PlayPrimitiveEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, INTENSITY_LOW); + ASSERT_EQ(ret, 0); + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + CancelEnhanced(params); + } else { + MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_SLIDE); + } +} + +HWTEST_F(VibratorAgentTest, PlayPrimitiveEffectEnhanced_004, TestSize.Level1) +{ + MISC_HILOGI("PlayPrimitiveEffectEnhanced_004 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool state { false }; + int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, &state); + ASSERT_EQ(ret, 0); + if (state) { + ret = PlayPrimitiveEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, INTENSITY_MEDIUM); + ASSERT_EQ(ret, 0); + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + CancelEnhanced(params); + } else { + MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_SLIDE); + } +} + +HWTEST_F(VibratorAgentTest, PlayPrimitiveEffectEnhanced_005, TestSize.Level1) +{ + MISC_HILOGI("PlayPrimitiveEffectEnhanced_005 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool state { false }; + int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, &state); + ASSERT_EQ(ret, 0); + if (state) { + ret = PlayPrimitiveEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, INTENSITY_HIGH); + ASSERT_EQ(ret, 0); + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + CancelEnhanced(params); + } else { + MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_SLIDE); + } +} + +HWTEST_F(VibratorAgentTest, IsHdHapticSupportedEnhanced_001, TestSize.Level1) +{ + MISC_HILOGI("IsHdHapticSupportedEnhanced_001 in"); + VibratorParams params = { + .deviceId = -1, + .vibratorId = -1, + }; + bool isSupport = (IsSupportVibratorCustomEnhanced(params) && IsHdHapticSupportedEnhanced(params)); + if (isSupport) { + FileDescriptor fileDescriptor("/data/test/vibrator/coin_drop.json"); + MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); + struct stat64 statbuf = { 0 }; + if (fstat64(fileDescriptor.fd, &statbuf) == 0) { + int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ASSERT_EQ(ret, 0); + } + std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); + } else { + ASSERT_EQ(isSupport, false); + } + CancelEnhanced(params); +} } // namespace Sensors } // namespace OHOS diff --git a/utils/common/include/sensors_errors.h b/utils/common/include/sensors_errors.h index 5214aa5..90e88e6 100644 --- a/utils/common/include/sensors_errors.h +++ b/utils/common/include/sensors_errors.h @@ -30,6 +30,7 @@ enum ErrorCode : int32_t { PARAMETER_ERROR = 401, // Use this error code when the input parameter type or range does not match. IS_NOT_SUPPORTED = 801, // Use this error code when capability not supported. DEVICE_OPERATION_FAILED = 14600101, // Use this error code when operating the device fail. + CALLBACK_UNSUBSCRIBED = 14600102, //Use this error code when the user callback function is deregistered repeatedly. }; enum { diff --git a/utils/common/include/vibrator_infos.h b/utils/common/include/vibrator_infos.h index 140d3c2..ef5ef94 100644 --- a/utils/common/include/vibrator_infos.h +++ b/utils/common/include/vibrator_infos.h @@ -136,6 +136,33 @@ struct VibrateParameter : public Parcelable { bool Marshalling(Parcel &parcel) const; static VibrateParameter* Unmarshalling(Parcel &data); }; + +struct VibratorInfoIPC : public Parcelable{ + int32_t deviceId = -1; + int32_t vibratorId = -1; //是否需要 + std::string deviceName = ""; + bool isSupportHdHaptic; + bool isLocalVibrator; + void Dump() const; + bool Marshalling(Parcel &parcel) const; + static VibratorInfoIPC* Unmarshalling(Parcel &data); +}; + +struct VibratorParamsIPC : public Parcelable { + int32_t deviceId = -1; + int32_t vibratorId = -1; + void Dump() const; + bool Marshalling(Parcel &parcel) const; + static VibratorParamsIPC* Unmarshalling(Parcel &data); +}; + +struct EffectInfoIPC : public Parcelable{ + int32_t duration = -1; + bool isSupportEffect; + void Dump() const; + bool Marshalling(Parcel &parcel) const; + static EffectInfoIPC* Unmarshalling(Parcel &data); +}; } // namespace Sensors } // namespace OHOS #endif // VIBRATOR_INFOS_H diff --git a/utils/common/src/vibrator_infos.cpp b/utils/common/src/vibrator_infos.cpp index e373e0a..3f90f60 100644 --- a/utils/common/src/vibrator_infos.cpp +++ b/utils/common/src/vibrator_infos.cpp @@ -255,5 +255,153 @@ VibrateParameter* VibrateParameter::Unmarshalling(Parcel &data) } return parameter; } + + +bool VibratorInfoIPC::Marshalling(Parcel &parcel) const +{ + if (!parcel.WriteInt32(deviceId)) { + MISC_HILOGE("Write deviceId failed"); + return false; + } + if (!parcel.WriteInt32(vibratorId)) { + MISC_HILOGE("Write vibratorId failed"); + return false; + } + if (!parcel.WriteString(deviceName)) { + MISC_HILOGE("Write vibratorId failed"); + return false; + } + if (!parcel.WriteBool(isSupportHdHaptic)) { + MISC_HILOGE("Write isSupportHdHaptic failed"); + return false; + } + if (!parcel.WriteBool(isLocalVibrator)) { + MISC_HILOGE("Write isLocalVibrator failed"); + return false; + } + return true; +} + +VibratorInfoIPC* VibratorInfoIPC::Unmarshalling(Parcel &data) +{ + auto vibratorInfoIPC = new (std::nothrow) VibratorInfoIPC(); + if (vibratorInfoIPC == nullptr) { + MISC_HILOGE("Read init vibratorInfoIPC failed"); + return nullptr; + } + if (!data.ReadInt32(vibratorInfoIPC->deviceId)) { + MISC_HILOGE("Read deviceId failed"); + vibratorInfoIPC = nullptr; + return vibratorInfoIPC; + } + if (!data.ReadInt32(vibratorInfoIPC->vibratorId)) { + MISC_HILOGE("Read vibratorId failed"); + vibratorInfoIPC = nullptr; + return vibratorInfoIPC; + } + if (!data.ReadString(vibratorInfoIPC->deviceName)) { + MISC_HILOGE("Read deviceName failed"); + vibratorInfoIPC = nullptr; + return vibratorInfoIPC; + } + if (!data.ReadBool(vibratorInfoIPC->isSupportHdHaptic)) { + MISC_HILOGE("Read isSupportHdHaptic failed"); + vibratorInfoIPC = nullptr; + return vibratorInfoIPC; + } + if (!data.ReadBool(vibratorInfoIPC->isLocalVibrator)) { + MISC_HILOGE("Read isLocalVibrator failed"); + vibratorInfoIPC = nullptr; + return vibratorInfoIPC; + } + return vibratorInfoIPC; +} + +void VibratorInfoIPC::Dump() const +{ + std::string retStr; + retStr = "deviceId: "+ std::to_string(deviceId); + retStr += ("vibratorId: " + std::to_string(vibratorId)); + retStr += ("deviceName: " + deviceName); + retStr += ("isSupportHdHaptic: " + (isSupportHdHaptic? std::string("true"):std::string("false"))); + MISC_HILOGI("VibratorInfoIPC: [%{public}s]", retStr.c_str()); +} + +void VibratorParamsIPC::Dump() const +{ + MISC_HILOGI("deviceId:%{public}d, vibratorId:%{public}d", deviceId, vibratorId); +} + +bool VibratorParamsIPC::Marshalling(Parcel &parcel) const +{ + if (!parcel.WriteInt32(deviceId)) { + MISC_HILOGE("Write parameter's deviceId failed"); + return false; + } + if (!parcel.WriteInt32(vibratorId)) { + MISC_HILOGE("Write parameter's vibratorId failed"); + return false; + } + return true; +} + +VibratorParamsIPC* VibratorParamsIPC::Unmarshalling(Parcel &data) +{ + auto params = new (std::nothrow) VibratorParamsIPC(); + if (params == nullptr) { + MISC_HILOGE("Read init parameter failed"); + return nullptr; + } + if (!(data.ReadInt32(params->deviceId))) { + MISC_HILOGE("Read parameter's deviceId or vibratorId failed"); + params = nullptr; + } + if (!(data.ReadInt32(params->vibratorId))) { + MISC_HILOGE("Read parameter's deviceId or vibratorId failed"); + params = nullptr; + } + return params; +} + +bool EffectInfoIPC::Marshalling(Parcel &parcel) const +{ + if (!parcel.WriteInt32(duration)) { + MISC_HILOGE("Write duration failed"); + return false; + } + if (!parcel.WriteBool(isSupportEffect)) { + MISC_HILOGE("Write isSupportEffect failed"); + return false; + } + return true; +} + +EffectInfoIPC* EffectInfoIPC::Unmarshalling(Parcel &data) +{ + auto effectInfoIPC = new (std::nothrow) EffectInfoIPC(); + if (effectInfoIPC == nullptr) { + MISC_HILOGE("Read init EffectInfoIPC failed"); + return nullptr; + } + if (!data.ReadInt32(effectInfoIPC->duration)) { + MISC_HILOGE("Read duration failed"); + effectInfoIPC = nullptr; + return effectInfoIPC; + } + if (!data.ReadBool(effectInfoIPC->isSupportEffect)) { + MISC_HILOGE("Read isSupportEffect failed"); + effectInfoIPC = nullptr; + return effectInfoIPC; + } + return effectInfoIPC; +} + +void EffectInfoIPC::Dump() const +{ + std::string retStr; + retStr = "duration: "+ std::to_string(duration); + retStr += ("isSupportEffect: " + (isSupportEffect? std::string("true"):std::string("false"))); + MISC_HILOGI("EffectInfoIPC: [%{public}s]", retStr.c_str()); +} } // namespace Sensors } // namespace OHOS -- Gitee From 662a99c392e5bc1990901510865f01c6531f32eb Mon Sep 17 00:00:00 2001 From: hero100 Date: Fri, 11 Apr 2025 11:19:36 +0800 Subject: [PATCH 2/6] =?UTF-8?q?=E5=A4=9A=E8=AE=BE=E5=A4=87=E5=A4=9A?= =?UTF-8?q?=E9=A9=AC=E8=BE=BE2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hero100 --- .../vibrator/include/vibrator_napi_utils.h | 3 + .../js/napi/vibrator/src/vibrator_js.cpp | 2 - .../napi/vibrator/src/vibrator_napi_utils.cpp | 131 +++++++------ .../include/vibrator_service_client.h | 1 - frameworks/native/vibrator/vibrator_agent.cpp | 64 ------- .../inner_api/vibrator/vibrator_agent.h | 66 ++++--- .../inner_api/vibrator/vibrator_agent_type.h | 36 ++-- .../adapter/src/hdi_connection.cpp | 172 ++++-------------- .../src/miscdevice_service.cpp | 86 ++++----- utils/common/include/vibrator_infos.h | 2 +- utils/common/src/vibrator_infos.cpp | 10 +- 11 files changed, 206 insertions(+), 367 deletions(-) diff --git a/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h b/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h index 0aee2a4..be17219 100644 --- a/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h +++ b/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h @@ -96,6 +96,9 @@ using ConstructResultFunc = bool(*)(const napi_env &env, sptr napi_value result[], int32_t length); bool CreateInt32Property(napi_env env, napi_value &eventObj, const char* name, int32_t value); +bool CreateStringProperty(napi_env env, napi_value &eventObj, const char* name, + const char* value, int32_t valueLength); +bool CreateBooleanProperty(napi_env env, napi_value &eventObj, const char* name, bool value); bool IsMatchArrayType(const napi_env &env, const napi_value &value); bool IsMatchType(const napi_env &env, const napi_value &value, const napi_valuetype &type); bool GetNapiInt32(const napi_env &env, const int32_t value, napi_value &result); diff --git a/frameworks/js/napi/vibrator/src/vibrator_js.cpp b/frameworks/js/napi/vibrator/src/vibrator_js.cpp index a745d2f..1de4296 100644 --- a/frameworks/js/napi/vibrator/src/vibrator_js.cpp +++ b/frameworks/js/napi/vibrator/src/vibrator_js.cpp @@ -597,7 +597,6 @@ static napi_value Stop(napi_env env, napi_callback_info info) .vibratorId = -1 }; if (argc >= 1 && IsMatchType(env, args[0], napi_string)) { - MISC_HILOGD("1111111111111111111111111111111111111"); string mode; if (!GetStringValue(env, args[0], mode)) { ThrowErr(env, PARAMETER_ERROR, "Parameters invalid"); @@ -615,7 +614,6 @@ static napi_value Stop(napi_env env, napi_callback_info info) } return EmitAsyncWork(nullptr, asyncCallbackInfo); } else { - MISC_HILOGD("2222222222222222222222222222222222222"); return Cancel(env, info); } } diff --git a/frameworks/js/napi/vibrator/src/vibrator_napi_utils.cpp b/frameworks/js/napi/vibrator/src/vibrator_napi_utils.cpp index 63e8b33..ab9ee07 100644 --- a/frameworks/js/napi/vibrator/src/vibrator_napi_utils.cpp +++ b/frameworks/js/napi/vibrator/src/vibrator_napi_utils.cpp @@ -78,6 +78,33 @@ bool CreateInt32Property(napi_env env, napi_value &eventObj, const char* name, i return true; } +bool CreateStringProperty(napi_env env, napi_value &eventObj, const char* name, + const char* value, int32_t valueLength) +{ + CALL_LOG_ENTER; + napi_value propValue = nullptr; + napi_status status = napi_create_string_utf8(env, value, valueLength, &propValue); + if (status != napi_ok) { + MISC_HILOGE("napi_create_string_utf8 fail"); + return false; + } + CHKCF((napi_set_named_property(env, eventObj, name, propValue) == napi_ok), "napi_set_named_property fail"); + return true; +} + +bool CreateBooleanProperty(napi_env env, napi_value &eventObj, const char* name, bool value) +{ + CALL_LOG_ENTER; + napi_value propValue = nullptr; + napi_status status = napi_get_boolean(env, value, &propValue); + if (status != napi_ok) { + MISC_HILOGE("napi_get_boolean fail"); + return false; + } + CHKCF((napi_set_named_property(env, eventObj, name, propValue) == napi_ok), "napi_set_named_property fail"); + return true; +} + bool IsMatchArrayType(const napi_env &env, const napi_value &value) { bool result = false; @@ -313,36 +340,32 @@ napi_value ConvertToJsVibratorInfo(const napi_env& env, const VibratorInfos& vib napi_value jsObject = nullptr; napi_status status = napi_create_object(env, &jsObject); if (status != napi_ok) { - return nullptr; + return jsObject; } - MISC_HILOGD("VibratorInfos: [deviceId = %{public}d, vibratorId = %{public}d, deviceName = %{public}s, isSupportHdHaptic = %{public}s, isLocalVibrator = %{public}s]", vibratorInfo.deviceId, + MISC_HILOGD("VibratorInfos: [deviceId = %{public}d, vibratorId = %{public}d, deviceName = %{public}s,\ + isSupportHdHaptic = %{public}s, isLocalVibrator = %{public}s]", vibratorInfo.deviceId, vibratorInfo.vibratorId, vibratorInfo.deviceName.c_str(), (vibratorInfo.isSupportHdHaptic ? "true":"false"), (vibratorInfo.isLocalVibrator ? "true":"false")); - napi_value jsDeviceId; - status = napi_create_int32(env, vibratorInfo.deviceId, &jsDeviceId); - if (status == napi_ok) { - napi_set_named_property(env, jsObject, "deviceId", jsDeviceId); - } - napi_value jsVibratorId; - status = napi_create_int32(env, vibratorInfo.vibratorId, &jsVibratorId); - if (status == napi_ok) { - napi_set_named_property(env, jsObject, "vibratorId", jsVibratorId); - } - napi_value jsDeviceName; - status = napi_create_string_utf8(env, vibratorInfo.deviceName.c_str(), - vibratorInfo.deviceName.length(), &jsDeviceName); - if (status == napi_ok) { - napi_set_named_property(env, jsObject, "deviceName", jsDeviceName); - } - napi_value jsIsSupportHdHaptic; - status = napi_get_boolean(env, vibratorInfo.isSupportHdHaptic, &jsIsSupportHdHaptic); - if (status == napi_ok) { - napi_set_named_property(env, jsObject, "isSupportHdHaptic", jsIsSupportHdHaptic); - } - napi_value jsIsLocalVibrator; - status = napi_get_boolean(env, vibratorInfo.isLocalVibrator, &jsIsLocalVibrator); - if (status == napi_ok) { - napi_set_named_property(env, jsObject, "isLocalVibrator", jsIsLocalVibrator); + if (!CreateInt32Property(env, jsObject, "deviceId", vibratorInfo.deviceId)) { + MISC_HILOGE("Create vibratorInfo.deviceId failed"); + return jsObject; + } + if (!CreateInt32Property(env, jsObject, "vibratorId", vibratorInfo.vibratorId)) { + MISC_HILOGE("Create vibratorInfo.vibratorId failed"); + return jsObject; + } + if (!CreateStringProperty(env, jsObject, "deviceName", vibratorInfo.deviceName.c_str(), + vibratorInfo.deviceName.length())) { + MISC_HILOGE("Create vibratorInfo.deviceName failed"); + return jsObject; + } + if (!CreateBooleanProperty(env, jsObject, "isSupportHdHaptic", vibratorInfo.isSupportHdHaptic)) { + MISC_HILOGE("Create vibratorInfo.isSupportHdHaptic failed"); + return jsObject; + } + if (!CreateBooleanProperty(env, jsObject, "isLocalVibrator", vibratorInfo.isLocalVibrator)) { + MISC_HILOGE("Create vibratorInfo.isLocalVibrator failed"); + return jsObject; } return jsObject; } @@ -352,27 +375,24 @@ napi_value ConvertToJsEffectInfo(const napi_env& env, const EffectInfo& effectIn napi_value jsObject = nullptr; napi_status status = napi_create_object(env, &jsObject); if (status != napi_ok) { - return nullptr; + return jsObject; } - - napi_value jsIsSupportEffect; - status = napi_get_boolean(env, effectInfo.isSupportEffect, &jsIsSupportEffect); - if (status == napi_ok) { - napi_set_named_property(env, jsObject, "isSupportEffect", jsIsSupportEffect); + if (!CreateBooleanProperty(env, jsObject, "isSupportEffect", effectInfo.isSupportEffect)) { + MISC_HILOGE("Create effectInfo.isSupportEffect failed"); + return jsObject; } - return jsObject; } napi_value ConvertToJsVibratorPlungInfo(const napi_env& env, const VibratorDeviceInfo& deviceInfo) { CALL_LOG_ENTER; - MISC_HILOGD("deviceInfo : [type = %{public}d, deviceId = %{public}d]", deviceInfo.type, deviceInfo.deviceId); + MISC_HILOGD("deviceInfo: [type = %{public}d, deviceId = %{public}d]", deviceInfo.type, deviceInfo.deviceId); bool plugFlag = false; - napi_value jsObject; + napi_value jsObject = nullptr; napi_status status = napi_create_object(env, &jsObject); if (status != napi_ok) { napi_throw_error(env, nullptr, "Failed to create JS object"); - return nullptr; + return jsObject; } if (deviceInfo.type == PLUG_STATE_EVENT_PLUG_IN) { plugFlag = true; @@ -380,28 +400,13 @@ napi_value ConvertToJsVibratorPlungInfo(const napi_env& env, const VibratorDevic plugFlag = false; } MISC_HILOGD("plugFlag = %{public}s", plugFlag? "true":"false"); - napi_value jsBoolValue; - status = napi_get_boolean(env, plugFlag, &jsBoolValue); - if (status != napi_ok) { - napi_throw_error(env, nullptr, "Failed to create JS property for plugstate"); - return nullptr; - } - status = napi_set_named_property(env, jsObject, "VibratorPlugState", jsBoolValue); - if (status != napi_ok) { - napi_throw_error(env, nullptr, "Failed to set named property 'VibratorPlugState'"); - return nullptr; - } - - napi_value jsDeviceId; - status = napi_create_int32(env, deviceInfo.deviceId, &jsDeviceId); - if (status != napi_ok) { - napi_throw_error(env, nullptr, "Failed to create JS property for deviceId"); - return nullptr; + if (!CreateBooleanProperty(env, jsObject, "VibratorPlugState", plugFlag)) { + MISC_HILOGE("Create plugFlag failed"); + return jsObject; } - status = napi_set_named_property(env, jsObject, "deviceId", jsDeviceId); - if (status != napi_ok) { - napi_throw_error(env, nullptr, "Failed to set named property 'deviceId'"); - return nullptr; + if (!CreateInt32Property(env, jsObject, "deviceId", deviceInfo.deviceId)) { + MISC_HILOGE("Create deviceInfo.deviceId failed"); + return jsObject; } return jsObject; @@ -425,11 +430,6 @@ bool ConstructGetVibratorInfoListResult(const napi_env &env, sptrarrayLength ; ++i) { - // napi_value jsInfo = ConvertToJsVibratorInfo(env, asyncCallbackInfo->vibratorInfos[i]); - // CHKPF(jsInfo); - // CHKCF((napi_set_element(env, jsArray, i, jsInfo) == napi_ok), "napi_set_element fail"); - // } result[1] = jsArray; } return true; @@ -464,15 +464,10 @@ bool ConstructVibratorPlugInfoResult(const napi_env &env, sptrvibratorDeviceInfo); CHKPF(jsDevicePlugInfo); result[0] = jsDevicePlugInfo; - napi_value jsArray; - CHKCF((napi_create_array(env, &jsArray) == napi_ok), "Failed to create array for results"); - CHKCF((napi_set_element(env, jsArray, 0, jsDevicePlugInfo) == napi_ok), "napi_set_element fail"); - CHKCF((napi_get_undefined(env, &result[1]) == napi_ok), "napi_get_undefined fail"); } return true; diff --git a/frameworks/native/vibrator/include/vibrator_service_client.h b/frameworks/native/vibrator/include/vibrator_service_client.h index 4b0134e..fdb2cd4 100644 --- a/frameworks/native/vibrator/include/vibrator_service_client.h +++ b/frameworks/native/vibrator/include/vibrator_service_client.h @@ -109,7 +109,6 @@ private: sptr miscdeviceProxy_ = nullptr; sptr vibratorClient_ = nullptr; VibratorDecodeHandle decodeHandle_; - // VibratorCapacity capacity_; std::mutex clientMutex_; std::mutex decodeMutex_; diff --git a/frameworks/native/vibrator/vibrator_agent.cpp b/frameworks/native/vibrator/vibrator_agent.cpp index aa93793..8c884db 100644 --- a/frameworks/native/vibrator/vibrator_agent.cpp +++ b/frameworks/native/vibrator/vibrator_agent.cpp @@ -416,7 +416,6 @@ int32_t PlayPrimitiveEffectEnhanced(const VibratorParams params, const char *eff return SUCCESS; } -/*================================c++ interface start================================*/ int32_t GetVibratorIdList(const VibratorParams& param, std::vector& vibratorInfo) { CALL_LOG_ENTER; @@ -470,68 +469,5 @@ int32_t UnSubscribeVibrator(const VibratorUser& user) } return SUCCESS; } -/*================================c++ interface end================================*/ -/*================================c interface start================================*/ -// int32_t GetVibratorIdList(const VibratorParams ¶m, VibratorInfos vibratorInfo[], int32_t &infoSize) -// { -// CALL_LOG_ENTER; -// CHKCR(¶m, PARAMETER_ERROR, "Invalid parameters"); -// auto &client = VibratorServiceClient::GetInstance(); -// std::vector vibratorListInfo; -// int32_t ret = client.GetVibratorIdList(param, vibratorListInfo); -// if (ret != ERR_OK) { -// MISC_HILOGE("Get vibrator list failed, ret:%{public}d", ret); -// return NormalizeErrCode(ret); -// } -// int32_t i = 0; -// for (auto &info : vibratorListInfo) { -// vibratorInfo[i] = info; -// if (i < MAX_LOCAL_VIBRATOR_SIZE) { -// ++i; -// } -// } -// infoSize = vibratorListInfo.size(); -// return SUCCESS; -// } - -// int32_t GetEffectInfo(const VibratorParams ¶m, const char* effectType, EffectInfo &effectInfo) -// { -// CALL_LOG_ENTER; -// CHKCR(¶m, PARAMETER_ERROR, "Invalid parameters"); -// auto &client = VibratorServiceClient::GetInstance(); -// int32_t ret = client.GetEffectInfo(param, effectType, effectInfo); -// if (ret != ERR_OK) { -// MISC_HILOGE("Get effect info failed, ret:%{public}d", ret); -// return NormalizeErrCode(ret); -// } -// return SUCCESS; -// } - -// int32_t SubscribeVibrator(const VibratorUser &user) -// { -// CALL_LOG_ENTER; -// CHKCR(user.callback, PARAMETER_ERROR, "Invalid parameters"); -// auto &client = VibratorServiceClient::GetInstance(); -// int32_t ret = client.SubscribeVibratorPlugInfo(&user); -// if (ret != ERR_OK) { -// MISC_HILOGE("SubscribeVibrator failed, ret:%{public}d", ret); -// return NormalizeErrCode(ret); -// } -// return SUCCESS; -// } - -// int32_t UnSubscribeVibrator(const VibratorUser &user) -// { -// CALL_LOG_ENTER; -// CHKCR(user.callback, PARAMETER_ERROR, "Invalid parameters"); -// auto &client = VibratorServiceClient::GetInstance(); -// int32_t ret = client.UnsubscribeVibratorPlugInfo(&user); -// if (ret != ERR_OK) { -// MISC_HILOGE("UnsubscribeVibratorPlugInfo failed, ret:%{public}d", ret); -// return NormalizeErrCode(ret); -// } -// return SUCCESS; -// } -/*================================c interface end================================*/ } // namespace Sensors } // namespace OHOS \ No newline at end of file diff --git a/interfaces/inner_api/vibrator/vibrator_agent.h b/interfaces/inner_api/vibrator/vibrator_agent.h index ae2a33b..0f804f6 100644 --- a/interfaces/inner_api/vibrator/vibrator_agent.h +++ b/interfaces/inner_api/vibrator/vibrator_agent.h @@ -385,37 +385,61 @@ bool SetParametersEnhanced(const VibratorParams param, const VibratorParameter & */ int32_t PlayPrimitiveEffectEnhanced(const VibratorParams param, const char *effectId, int32_t intensity); - - - /** - * @brief Obtains information about this device contains vibrator that support setting intensity and frequency in the system. - * @param vibratorInfo Indicates the pointer to the vibration effect, For details, see {@link VibratorInfo}. - * @return Returns 0 if the operation is successful. - * @return Returns negative value if the get failed. + * @brief Retrieve a list of vibrator IDs available for the specified parameters. + * + * This function fetches the identifiers of all vibrators that match the given parameters. + * + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @param vibratorInfo A reference to a vector that will be populated with available vibrator information, + * each represented as a `VibratorInfos` structure. + * @return Returns 0 if the operation is successful; otherwise, indicates failure with an error code. + * + * @since 18 */ int32_t GetVibratorIdList(const VibratorParams& param, std::vector& vibratorInfo); /** - * @brief Obtains the vibration effect information with the specified effect type. - * @param effectType Indicates the pointer to the preset effect type. It is recommended that the - * maximum length be 64 bytes. - * @param effectInfo Indicates the pointer to the vibration effect information. For details, - * see {@link EffectInfo}. - * @return Returns 0 if the operation is successful. - * @return Returns negative value if the get failed. + * @brief Retrieve information about a specific vibration effect type. + * + * This function obtains detailed information regarding the specified vibration effect, such as its support status + * and duration. + * + * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * {@link vibrator_agent_type.h}. + * @param effectType A string representing the type of vibration effect to query, as defined in + * {@link vibrator_agent_type.h}. + * @param effectInfo A reference to an `EffectInfo` structure that will be populated with the effect's details. + * @return Returns 0 if the operation is successful; otherwise, indicates failure with an error code. + * + * @since 18 */ int32_t GetEffectInfo(const VibratorParams& param, const std::string& effectType, EffectInfo& effectInfo); +/** + * @brief Subscribe a user to receive updates from the vibrator. + * + * This function registers a specified user to receive notifications about vibrator state changes or events. + * + * @param user The user information that needs to be subscribed to the vibrator notifications, defined as `VibratorUser`. + * @return Returns 0 if the subscription is successful; otherwise, indicates failure with an error code. + * + * @since 18 + */ int32_t SubscribeVibrator(const VibratorUser& user); -int32_t UnSubscribeVibrator(const VibratorUser& user); - - -// int32_t GetVibratorIdList(const VibratorParams ¶m, VibratorInfos vibratorInfo[], int32_t &infoSize); -// int32_t GetEffectInfo(const VibratorParams ¶m, const char* effectType, EffectInfo &effectInfo); -// int32_t SubscribeVibrator(const VibratorUser &user); -// int32_t UnSubscribeVibrator(const VibratorUser &user); +/** + * @brief Unsubscribe a user from receiving updates from the vibrator. + * + * This function removes a specified user from receiving notifications about vibrator state changes or events. + * + * @param user The user information that needs to be unsubscribed from the vibrator notifications, defined as `VibratorUser`. + * @return Returns 0 if the unsubscription is successful; otherwise, indicates failure with an error code. + * + * @since 18 + */ +int32_t UnSubscribeVibrator(const VibratorUser& user); } // namespace Sensors } // namespace OHOS #ifdef __cplusplus diff --git a/interfaces/inner_api/vibrator/vibrator_agent_type.h b/interfaces/inner_api/vibrator/vibrator_agent_type.h index ab80670..7afff03 100644 --- a/interfaces/inner_api/vibrator/vibrator_agent_type.h +++ b/interfaces/inner_api/vibrator/vibrator_agent_type.h @@ -28,9 +28,6 @@ extern "C" { #ifndef VIBRATOR_USER_DATA_SIZE #define VIBRATOR_USER_DATA_SIZE 104 #endif /* VIBRATOR_USER_DATA_SIZE */ -// #ifndef MAX_LOCAL_VIBRATOR_SIZE -// #define MAX_LOCAL_VIBRATOR_SIZE 10 -// #endif /* MAX_LOCAL_VIBRATOR_SIZE */ /** * @brief Describes the vibration effect of the vibrator when a user adjusts the timer. @@ -282,14 +279,31 @@ typedef struct EffectInfo { bool isSupportEffect; } EffectInfo; +/** + * @brief Defines the plug state events for the vibrator device. + * + * This enumeration represents the various plug and unplug state events + * that can occur with the vibrator device, including its connection status. + * + * @since 18 + */ typedef enum VibratorPlugState { - PLUG_STATE_EVENT_UNKNOWN = -1, /**< Unknown plug and unplug state event */ - PLUG_STATE_EVENT_PLUG_IN = 0, /**< Event indicating that the vibrator is plugged in */ - PLUG_STATE_EVENT_PLUG_OUT = 1, /**< Event indicating that the vibrator is unplugged */ - PLUG_STATE_EVENT_ONLINE = 2, /**< Event indicating that the vibrator is online */ - PLUG_STATE_EVENT_OFFLINE = 3 /**< Event indicating that the vibrator is offline */ + PLUG_STATE_EVENT_UNKNOWN = -1, /* Unknown plug and unplug state event */ + PLUG_STATE_EVENT_PLUG_IN = 0, /* Event indicating that the vibrator is plugged in */ + PLUG_STATE_EVENT_PLUG_OUT = 1, /* Event indicating that the vibrator is unplugged */ + PLUG_STATE_EVENT_ONLINE = 2, /* Event indicating that the vibrator is online */ + PLUG_STATE_EVENT_OFFLINE = 3 /* Event indicating that the vibrator is offline */ } VibratorPlugState; +/** + * @brief Contains information about a vibrator device's status. + * + * This structure holds the current plug state of the vibrator device and its + * unique identifier. It is used to monitor and manage the vibrator's connectivity + * and operational mode. + * + * @since 18 + */ typedef struct VibratorDeviceInfo { VibratorPlugState type = PLUG_STATE_EVENT_UNKNOWN; int32_t deviceId = 0; @@ -308,7 +322,7 @@ typedef void (*RecordVibratorPlugCallback)(VibratorDeviceInfo *deviceInfo); * @since 18 */ typedef struct UserData { - char userData[VIBRATOR_USER_DATA_SIZE]; /**< Reserved for the sensor data subscriber */ + char userData[VIBRATOR_USER_DATA_SIZE]; /* Reserved for the sensor data subscriber */ } UserData; /** @@ -317,8 +331,8 @@ typedef struct UserData { * @since 18 */ typedef struct VibratorUser { - RecordVibratorPlugCallback callback; /**< Callback for reporting sensor data */ - UserData *userData = nullptr; /**< Reserved field for the sensor data subscriber */ + RecordVibratorPlugCallback callback; /* Callback for reporting sensor data */ + UserData *userData = nullptr; /* Reserved field for the sensor data subscriber */ } VibratorUser; /** diff --git a/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp b/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp index 7ef57a6..75030cd 100644 --- a/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp +++ b/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp @@ -38,7 +38,6 @@ DevicePlugCallback HdiConnection::devicePlugCb_ = nullptr; int32_t HdiConnection::ConnectHdi() { - return ERR_OK; CALL_LOG_ENTER; int32_t retry = 0; while (retry < GET_HDI_SERVICE_COUNT) { @@ -64,9 +63,8 @@ int32_t HdiConnection::ConnectHdi() int32_t HdiConnection::StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) { - // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - // int32_t ret = vibratorInterface_->StartOnce(params.deviceId, params.vibratorId, duration); - int32_t ret = 0; + CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + int32_t ret = vibratorInterface_->StartOnce(params.deviceId, params.vibratorId, duration); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -85,10 +83,8 @@ int32_t HdiConnection::Start(const VibratorParamsIPC ¶ms, const std::string MISC_HILOGE("effectType is null"); return VIBRATOR_ON_ERR; } - // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - // int32_t ret = vibratorInterface_->Start(params.deviceId, params.vibratorId, effectType); - int32_t ret = 0; - + CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + int32_t ret = vibratorInterface_->Start(params.deviceId, params.vibratorId, effectType); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -108,10 +104,8 @@ int32_t HdiConnection::EnableCompositeEffect(const VibratorParamsIPC ¶ms, co MISC_HILOGE("compositeEffects is empty"); return VIBRATOR_ON_ERR; } - // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - // int32_t ret = vibratorInterface_->EnableCompositeEffect(params.deviceId, params.vibratorId, hdfCompositeEffect); - int32_t ret = 0; - + CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + int32_t ret = vibratorInterface_->EnableCompositeEffect(params.deviceId, params.vibratorId, hdfCompositeEffect); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -126,26 +120,20 @@ int32_t HdiConnection::EnableCompositeEffect(const VibratorParamsIPC ¶ms, co bool HdiConnection::IsVibratorRunning(const VibratorParamsIPC ¶ms) { bool state = false; - // CHKPR(vibratorInterface_, false); - // vibratorInterface_->IsVibratorRunning(params.deviceId, params.vibratorId, state); - state = true; - + CHKPR(vibratorInterface_, false); + vibratorInterface_->IsVibratorRunning(params.deviceId, params.vibratorId, state); return state; } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM std::optional HdiConnection::GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effect) { - // if (vibratorInterface_ == nullptr) { - // MISC_HILOGE("Connect v1_1 hdi failed"); - // return std::nullopt; - // } + if (vibratorInterface_ == nullptr) { + MISC_HILOGE("Connect v1_1 hdi failed"); + return std::nullopt; + } HdfEffectInfo effectInfo; - // int32_t ret = vibratorInterface_->GetEffectInfo(params.deviceId, params.vibratorId, effect, effectInfo); - effectInfo.duration = 2000; - effectInfo.isSupportEffect = true; - int32_t ret = 0; - + int32_t ret = vibratorInterface_->GetEffectInfo(params.deviceId, params.vibratorId, effect, effectInfo); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -159,10 +147,8 @@ std::optional HdiConnection::GetEffectInfo(const VibratorParamsIP int32_t HdiConnection::Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) { - // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - // int32_t ret = vibratorInterface_->Stop(params.deviceId, params.vibratorId, mode); - int32_t ret = 0; - + CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + int32_t ret = vibratorInterface_->Stop(params.deviceId, params.vibratorId, mode); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -176,11 +162,8 @@ int32_t HdiConnection::Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mod int32_t HdiConnection::GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) { - // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - // int32_t ret = vibratorInterface_->GetHapticStartUpTime(params.deviceId, params.vibratorId, mode, delayTime); - int32_t ret = 0; - delayTime = 2000; - + CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + int32_t ret = vibratorInterface_->GetHapticStartUpTime(params.deviceId, params.vibratorId, mode, delayTime); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -194,15 +177,9 @@ int32_t HdiConnection::GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mod int32_t HdiConnection::GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) { - // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + CHKPR(vibratorInterface_, ERR_INVALID_VALUE); HapticCapacity hapticCapacity; - // int32_t ret = vibratorInterface_->GetHapticCapacity(params.deviceId, hapticCapacity); - int32_t ret = 0; - capacity.isSupportHdHaptic = true; - capacity.isSupportPresetMapping = true; - capacity.isSupportTimeDelay = true; - return ERR_OK; - + int32_t ret = vibratorInterface_->GetHapticCapacity(params.deviceId, hapticCapacity); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -220,7 +197,7 @@ int32_t HdiConnection::GetVibratorCapacity(const VibratorParamsIPC ¶ms, Vibr int32_t HdiConnection::PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) { - // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + CHKPR(vibratorInterface_, ERR_INVALID_VALUE); HapticPaket packet = {}; packet.time = pattern.startTime; int32_t eventNum = static_cast(pattern.events.size()); @@ -244,9 +221,7 @@ int32_t HdiConnection::PlayPattern(const VibratorParamsIPC ¶ms, const Vibrat } packet.events.emplace_back(hapticEvent); } - // int32_t ret = vibratorInterface_->PlayHapticPattern(params.deviceId, packet); - int32_t ret = 0; - + int32_t ret = vibratorInterface_->PlayHapticPattern(params.deviceId, packet); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -278,8 +253,6 @@ int32_t HdiConnection::DestroyHdiConnection() void HdiConnection::RegisterHdiDeathRecipient() { - return; - CALL_LOG_ENTER; if (vibratorInterface_ == nullptr) { MISC_HILOGE("Connect v1_1 hdi failed"); @@ -333,10 +306,8 @@ int32_t HdiConnection::StartByIntensity(const VibratorParamsIPC ¶ms, const s MISC_HILOGE("effect is null"); return VIBRATOR_ON_ERR; } - // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - // int32_t ret = vibratorInterface_->StartByIntensity(params.deviceId, params.vibratorId, effect, intensity); - int32_t ret = 0; - + CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + int32_t ret = vibratorInterface_->StartByIntensity(params.deviceId, params.vibratorId, effect, intensity); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -350,63 +321,18 @@ int32_t HdiConnection::StartByIntensity(const VibratorParamsIPC ¶ms, const s int32_t HdiConnection::GetVibratorInfo(std::vector &hdfVibratorInfo) { - // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - // int32_t ret = vibratorInterface_->GetVibratorInfo(hdfVibratorInfo); - int32_t ret = 0; - HdfVibratorInfo info; - info.isSupportIntensity = true; - info.isSupportFrequency = false; - info.intensityMaxValue = 255; - info.intensityMinValue = 0; - info.frequencyMaxValue = 200; - info.frequencyMinValue = 50; - info.deviceId = 2; - info.vibratorId = 99; - info.isLocal = 1; - hdfVibratorInfo.push_back(info); - - HdfVibratorInfo info1; - info1.isSupportIntensity = true; - info1.isSupportFrequency = false; - info1.intensityMaxValue = 255; - info1.intensityMinValue = 0; - info1.frequencyMaxValue = 200; - info1.frequencyMinValue = 50; - info1.deviceId = 2; - info1.vibratorId = 100; - info1.isLocal = 1; - hdfVibratorInfo.push_back(info1); - + CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + int32_t ret = vibratorInterface_->GetVibratorInfo(hdfVibratorInfo); if (ret != ERR_OK) { MISC_HILOGE("GetVibratorInfo failed"); } return ret; - } int32_t HdiConnection::GetAllWaveInfo(const VibratorParamsIPC ¶ms, std::vector &waveInfos) { - // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - // int32_t ret = vibratorInterface_->GetAllWaveInfo(params.deviceId, params.vibratorId, waveInfos); - int32_t ret = 0; - HdfWaveInformation info1; - info1.vibratorId = 1; - info1.waveId = 101; - info1.intensity = 0.8f; - info1.frequency = 50.0f; - info1.duration = 200; - info1.reserved = 0; - waveInfos.push_back(info1); - - HdfWaveInformation info2; - info2.vibratorId = 2; - info2.waveId = 102; - info2.intensity = 0.6f; - info2.frequency = 60.0f; - info2.duration = 300; - info2.reserved = 0; - waveInfos.push_back(info2); - + CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + int32_t ret = vibratorInterface_->GetAllWaveInfo(params.deviceId, params.vibratorId, waveInfos); if (ret != ERR_OK) { MISC_HILOGE("GetAllWaveInfo failed"); } @@ -416,34 +342,8 @@ int32_t HdiConnection::GetAllWaveInfo(const VibratorParamsIPC ¶ms, std::vect int32_t HdiConnection::GetVibratorIdList(const VibratorParamsIPC ¶ms, std::vector &vibratorInfo) { - // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - // int32_t ret = vibratorInterface_->GetVibratorIdSingle(params.deviceId, vibratorInfo); - int32_t ret = 0; - HdfVibratorInfo info; - info.isSupportIntensity = true; - info.isSupportFrequency = false; - info.intensityMaxValue = 255; - info.intensityMinValue = 0; - info.frequencyMaxValue = 200; - info.frequencyMinValue = 50; - info.deviceId = 2; - info.vibratorId = 101; - info.isLocal = 0; - vibratorInfo.push_back(info); - - HdfVibratorInfo info1; - info1.isSupportIntensity = true; - info1.isSupportFrequency = false; - info1.intensityMaxValue = 255; - info1.intensityMinValue = 0; - info1.frequencyMaxValue = 200; - info1.frequencyMinValue = 50; - info1.deviceId = 2; - info1.vibratorId = 102; - info1.isLocal = 0; - vibratorInfo.push_back(info1); - - + CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + int32_t ret = vibratorInterface_->GetVibratorIdSingle(params.deviceId, vibratorInfo); if (ret != ERR_OK) { MISC_HILOGE("GetVibratorIdList failed"); } @@ -453,12 +353,8 @@ int32_t HdiConnection::GetVibratorIdList(const VibratorParamsIPC ¶ms, int32_t HdiConnection::GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, HdfEffectInfo &effectInfo) { - // CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - // int32_t ret = vibratorInterface_->GetEffectInfo(params.deviceId, params.vibratorId, effectType, effectInfo); - int32_t ret = 0; - effectInfo.duration = 2000; - effectInfo.isSupportEffect = true; - + CHKPR(vibratorInterface_, ERR_INVALID_VALUE); + int32_t ret = vibratorInterface_->GetEffectInfo(params.deviceId, params.vibratorId, effectType, effectInfo); if (ret != ERR_OK) { MISC_HILOGE("GetVibratorIdList failed"); } @@ -469,11 +365,9 @@ int32_t HdiConnection::RegisterVibratorPlugCallback(DevicePlugCallback cb) { CALL_LOG_ENTER; CHKPR(cb, ERR_NO_INIT); - // CHKPR(vibratorInterface_, ERR_NO_INIT); + CHKPR(vibratorInterface_, ERR_NO_INIT); devicePlugCb_ = cb; - // int32_t ret = vibratorInterface_->RegVibratorPlugCallback(g_eventCallback); - int32_t ret = 0; - + int32_t ret = vibratorInterface_->RegVibratorPlugCallback(g_eventCallback); if (ret != 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", diff --git a/services/miscdevice_service/src/miscdevice_service.cpp b/services/miscdevice_service/src/miscdevice_service.cpp index 099bada..1eb00be 100644 --- a/services/miscdevice_service/src/miscdevice_service.cpp +++ b/services/miscdevice_service/src/miscdevice_service.cpp @@ -1063,24 +1063,6 @@ int32_t MiscdeviceService::TransferClientRemoteObject(const sptr return ERROR; } RegisterClientDeathRecipient(vibratorServiceClient, clientPid); - // std::thread thread([this]() mutable { - // while (1) - // { - // sleep(30); - // HdfVibratorPlugInfo info; - // info.status = 1; - // info.deviceId = 123; - // this->SendMsgToClient(info); - // sleep(30); - // { - // HdfVibratorPlugInfo info; - // info.status = 0; - // info.deviceId = 123; - // this->SendMsgToClient(info); - // } - // } - // }); - // thread.detach(); return ERR_OK; } @@ -1264,19 +1246,17 @@ int32_t MiscdeviceService::GetVibratorIdList(const VibratorParamsIPC& params, std::vector& vibratorInfoIPC) { CALL_LOG_ENTER; - MISC_HILOGD("devicesManageMap_.size() = %{public}d", devicesManageMap_.size()); - MISC_HILOGD("VibratorParamsIPC = [deviceId = %{public}d, vibratorId = %{public}d]", - params.deviceId, params.vibratorId); -// PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); -// int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); -// if (ret != PERMISSION_GRANTED) { -// #ifdef HIVIEWDFX_HISYSEVENT_ENABLE -// HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_PERMISSIONS_EXCEPTION", -// HiSysEvent::EventType::SECURITY, "PKG_NAME", "PlayPrimitiveEffectStub", "ERROR_CODE", ret); -// #endif // HIVIEWDFX_HISYSEVENT_ENABLE -// MISC_HILOGE("CheckVibratePermission failed, ret:%{public}d", ret); -// return PERMISSION_DENIED; -// } + PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); + int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); + if (ret != PERMISSION_GRANTED) { +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_PERMISSIONS_EXCEPTION", + HiSysEvent::EventType::SECURITY, "PKG_NAME", "PlayPrimitiveEffectStub", "ERROR_CODE", ret); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + MISC_HILOGE("CheckVibratePermission failed, ret:%{public}d", ret); + return PERMISSION_DENIED; + } + params.Dump(); if (devicesManageMap_.empty()) { MISC_HILOGI("No vibrator device online"); return NO_ERROR; @@ -1316,18 +1296,17 @@ int32_t MiscdeviceService::GetEffectInfo(const VibratorParamsIPC& params, const EffectInfoIPC& effectInfoIPC) { CALL_LOG_ENTER; -// PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); -// int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); -// if (ret != PERMISSION_GRANTED) { -// #ifdef HIVIEWDFX_HISYSEVENT_ENABLE -// HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_PERMISSIONS_EXCEPTION", -// HiSysEvent::EventType::SECURITY, "PKG_NAME", "PlayPrimitiveEffectStub", "ERROR_CODE", ret); -// #endif // HIVIEWDFX_HISYSEVENT_ENABLE -// MISC_HILOGE("CheckVibratePermission failed, ret:%{public}d", ret); -// return PERMISSION_DENIED; -// } - MISC_HILOGD("VibratorParamsIpc = [deviceId = %{public}d, vibratorId = %{public}d]", - params.deviceId, params.vibratorId); + PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); + int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); + if (ret != PERMISSION_GRANTED) { +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_PERMISSIONS_EXCEPTION", + HiSysEvent::EventType::SECURITY, "PKG_NAME", "PlayPrimitiveEffectStub", "ERROR_CODE", ret); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + MISC_HILOGE("CheckVibratePermission failed, ret:%{public}d", ret); + return PERMISSION_DENIED; + } + params.Dump(); HdfEffectInfo hdfEffectInfo; auto ret = vibratorHdiConnection_.GetEffectInfo(params, effectType, hdfEffectInfo); if (ret != NO_ERROR) { @@ -1336,11 +1315,13 @@ int32_t MiscdeviceService::GetEffectInfo(const VibratorParamsIPC& params, const } effectInfoIPC.duration = hdfEffectInfo.duration; effectInfoIPC.isSupportEffect = hdfEffectInfo.isSupportEffect; + effectInfoIPC.Dump(); return NO_ERROR; } int32_t MiscdeviceService::GetVibratorCapacity(const VibratorParamsIPC& params, VibratorCapacity &capacity) { + CALL_LOG_ENTER; VibratorCapacity g_capacity; if(GetHapticCapacityInfo(params, g_capacity) != ERR_OK) { @@ -1446,6 +1427,7 @@ void MiscdeviceService::ConvertToServerInfos(const std::vector const VibratorCapacity &vibratorCapacity, const std::vector &waveInfomation, const HdfVibratorPlugInfo &info, VibratorAllInfos& vibratorAllInfos) { + CALL_LOG_ENTER; VibratorInfoIPC vibratorInfo; for (auto infos : baseVibratorInfo) { vibratorInfo.deviceId = infos.deviceId; @@ -1464,6 +1446,7 @@ void MiscdeviceService::ConvertToServerInfos(const std::vector void MiscdeviceService::FirstGetLocalVibratorInfo() { + CALL_LOG_ENTER; std::vector vibratorInfo; auto ret = vibratorHdiConnection_.GetVibratorInfo(vibratorInfo); if (ret != NO_ERROR || vibratorInfo.empty()) { @@ -1496,7 +1479,7 @@ void MiscdeviceService::FirstGetLocalVibratorInfo() vibratorIdList.push_back(value.vibratorId); } VibratorAllInfos localVibratorInfo(vibratorIdList); - ConvertToServerInfos(localInfo, capacity, waveInfo, mockInfo, localVibratorInfo); + (void)ConvertToServerInfos(localInfo, capacity, waveInfo, mockInfo, localVibratorInfo); devicesManageMap_.insert(std::make_pair(param.deviceId, localVibratorInfo)); } @@ -1529,22 +1512,18 @@ std::vector MiscdeviceService::CheckDeviceIdIsValid(const Vib { CALL_LOG_ENTER; std::vector result; - MISC_HILOGE("参数111,:%{public}d,:%{public}d,:%{public}d", params.deviceId, params.vibratorId, devicesManageMap_.size()); - if(params.deviceId == -1 && params.vibratorId == -1) { ////整个参数不传递，可能代码需要操作的是本地的默认马达 - MISC_HILOGE("2222222222222222参数,:%{public}d,:%{public}d", params.deviceId, params.deviceId); + if(params.deviceId == -1 && params.vibratorId == -1) { for (const auto& pair : devicesManageMap_) { for (const auto& info : pair.second.baseInfo) { - MISC_HILOGE("1111111111111参数,:%{public}d,:%{public}d", info.deviceId, info.vibratorId); if (info.isLocalVibrator) { VibratorParamsIPC newParams; newParams.deviceId = info.deviceId; newParams.vibratorId = info.vibratorId; result.push_back(newParams); - MISC_HILOGE("1111压入result队列中,:%{public}d,:%{public}d", newParams.deviceId, newParams.deviceId); } } } - }else if(params.deviceId != -1 && params.vibratorId == -1) { //如果只传了DeviceID，可能默认查询/控制 对应设备上的马达、 + }else if(params.deviceId != -1 && params.vibratorId == -1) { auto deviceIt = devicesManageMap_.find(params.deviceId); if (deviceIt != devicesManageMap_.end()) { for (const auto& info : deviceIt->second.baseInfo) { @@ -1552,10 +1531,9 @@ std::vector MiscdeviceService::CheckDeviceIdIsValid(const Vib newParams.deviceId = params.deviceId; newParams.vibratorId = info.vibratorId; result.push_back(newParams); - MISC_HILOGE("22222压入result队列中,:%{public}d,:%{public}d", newParams.deviceId, newParams.deviceId); } } - } else if(params.deviceId != -1 && params.vibratorId != -1) { //正常传递deviceId和vibratorId + } else if(params.deviceId != -1 && params.vibratorId != -1) { auto deviceIt = devicesManageMap_.find(params.deviceId); if (deviceIt != devicesManageMap_.end()) { for (const auto& info : deviceIt->second.baseInfo) { @@ -1564,11 +1542,10 @@ std::vector MiscdeviceService::CheckDeviceIdIsValid(const Vib newParams.deviceId = params.deviceId; newParams.vibratorId = info.vibratorId; result.push_back(newParams); - MISC_HILOGE("333333压入result队列中,:%{public}d,:%{public}d", newParams.deviceId, newParams.deviceId); } } } - } else if(params.deviceId == -1 && params.vibratorId != -1) { //如果只传了VibratorID，可能默认查询/控制 是本地的默认马达 + } else if(params.deviceId == -1 && params.vibratorId != -1) { for (const auto& pair : devicesManageMap_) { for (const auto& info : pair.second.baseInfo) { if (info.isLocalVibrator && info.vibratorId == params.vibratorId) { @@ -1576,7 +1553,6 @@ std::vector MiscdeviceService::CheckDeviceIdIsValid(const Vib newParams.deviceId = info.deviceId; newParams.vibratorId = info.vibratorId; result.push_back(newParams); - MISC_HILOGE("444444压入result队列中,:%{public}d,:%{public}d", newParams.deviceId, newParams.deviceId); } } } diff --git a/utils/common/include/vibrator_infos.h b/utils/common/include/vibrator_infos.h index ef5ef94..f547eb5 100644 --- a/utils/common/include/vibrator_infos.h +++ b/utils/common/include/vibrator_infos.h @@ -139,7 +139,7 @@ struct VibrateParameter : public Parcelable { struct VibratorInfoIPC : public Parcelable{ int32_t deviceId = -1; - int32_t vibratorId = -1; //是否需要 + int32_t vibratorId = -1; std::string deviceName = ""; bool isSupportHdHaptic; bool isLocalVibrator; diff --git a/utils/common/src/vibrator_infos.cpp b/utils/common/src/vibrator_infos.cpp index 3f90f60..cfdd731 100644 --- a/utils/common/src/vibrator_infos.cpp +++ b/utils/common/src/vibrator_infos.cpp @@ -320,10 +320,10 @@ VibratorInfoIPC* VibratorInfoIPC::Unmarshalling(Parcel &data) void VibratorInfoIPC::Dump() const { std::string retStr; - retStr = "deviceId: "+ std::to_string(deviceId); - retStr += ("vibratorId: " + std::to_string(vibratorId)); - retStr += ("deviceName: " + deviceName); - retStr += ("isSupportHdHaptic: " + (isSupportHdHaptic? std::string("true"):std::string("false"))); + retStr = "deviceId: "+ std::to_string(deviceId) + " "; + retStr += ("vibratorId: " + std::to_string(vibratorId) + " "); + retStr += ("deviceName: " + deviceName + " "); + retStr += ("isSupportHdHaptic: " + (isSupportHdHaptic? std::string("true"):std::string("false")) + " "); MISC_HILOGI("VibratorInfoIPC: [%{public}s]", retStr.c_str()); } @@ -399,7 +399,7 @@ EffectInfoIPC* EffectInfoIPC::Unmarshalling(Parcel &data) void EffectInfoIPC::Dump() const { std::string retStr; - retStr = "duration: "+ std::to_string(duration); + retStr = "duration: "+ std::to_string(duration) + " "; retStr += ("isSupportEffect: " + (isSupportEffect? std::string("true"):std::string("false"))); MISC_HILOGI("EffectInfoIPC: [%{public}s]", retStr.c_str()); } -- Gitee From b3b7745344a445864942cb81cde2505d79a84dff Mon Sep 17 00:00:00 2001 From: hero100 Date: Mon, 14 Apr 2025 16:26:19 +0800 Subject: [PATCH 3/6] =?UTF-8?q?=E5=A4=9A=E8=AE=BE=E5=A4=87=E5=A4=9A?= =?UTF-8?q?=E9=A9=AC=E8=BE=BE3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hero100 --- .../vibrator/include/vibrator_napi_utils.h | 7 +- .../js/napi/vibrator/src/vibrator_js.cpp | 156 +++--- .../napi/vibrator/src/vibrator_napi_utils.cpp | 4 +- .../vibrator/all/IMiscdeviceService.idl | 26 +- .../vibrator/include/i_vibrator_client.h | 7 +- .../vibrator/include/vibrator_client_proxy.h | 4 +- .../include/vibrator_service_client.h | 42 +- .../vibrator/part/IMiscdeviceService.idl | 24 +- .../vibrator/src/vibrator_client_stub.cpp | 2 +- .../vibrator/src/vibrator_service_client.cpp | 224 +++++---- frameworks/native/vibrator/vibrator_agent.cpp | 168 ++++--- .../inner_api/vibrator/vibrator_agent.h | 62 +-- .../inner_api/vibrator/vibrator_agent_type.h | 18 +- .../include/custom_vibration_matcher.h | 2 +- .../src/custom_vibration_matcher.cpp | 12 +- .../adapter/include/compatible_connection.h | 28 +- .../adapter/include/hdi_connection.h | 28 +- .../adapter/include/vibrator_plug_callback.h | 4 - .../adapter/src/compatible_connection.cpp | 26 +- .../adapter/src/hdi_connection.cpp | 52 +- .../include/i_vibrator_hdi_connection.h | 26 +- .../include/vibrator_hdi_connection.h | 26 +- .../interface/src/vibrator_hdi_connection.cpp | 52 +- .../include/miscdevice_service.h | 65 +-- .../include/vibration_priority_manager.h | 4 +- .../include/vibrator_thread.h | 22 +- .../src/miscdevice_service.cpp | 369 +++++++------- .../src/vibration_priority_manager.cpp | 8 +- .../src/vibrator_thread.cpp | 62 +-- .../vibrator/native/vibrator_agent_test.cpp | 470 +++++++++--------- utils/common/include/vibrator_infos.h | 4 +- utils/common/src/vibrator_infos.cpp | 20 +- 32 files changed, 1005 insertions(+), 1019 deletions(-) diff --git a/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h b/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h index be17219..6302cd2 100644 --- a/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h +++ b/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h @@ -84,9 +84,8 @@ public: bool isSupportEffect {false}; std::vector vibratorInfos; int32_t arrayLength; - //VibratorInfos vibratorInfos[MAX_LOCAL_VIBRATOR_SIZE] = {}; - EffectInfo vibratorEffectInfo; - VibratorDeviceInfo vibratorDeviceInfo; + EffectInfo effectInfo; + VibratorDeviceInfo deviceInfo; std::string flag; AsyncCallbackInfo(napi_env env) : env(env) {} ~AsyncCallbackInfo(); @@ -113,7 +112,7 @@ bool GetPropertyInt32(const napi_env &env, const napi_value &value, const std::s bool GetPropertyInt64(const napi_env &env, const napi_value &value, const std::string &type, int64_t &result); bool GetNapiParam(const napi_env &env, const napi_callback_info &info, size_t &argc, napi_value &argv); bool ConvertErrorToResult(const napi_env &env, sptr asyncCallbackInfo, napi_value &result); -napi_value ConvertToJsVibratorInfo(const napi_env& env,const VibratorInfos& vibratorInfo); +napi_value ConvertToJsVibratorInfo(const napi_env& env, const VibratorInfos& vibratorInfo); napi_value ConvertToJsEffectInfo(const napi_env& env, const EffectInfo& effectInfo); bool ConstructCommonResult(const napi_env &env, sptr asyncCallbackInfo, napi_value result[], int32_t length); diff --git a/frameworks/js/napi/vibrator/src/vibrator_js.cpp b/frameworks/js/napi/vibrator/src/vibrator_js.cpp index 1de4296..83010a1 100644 --- a/frameworks/js/napi/vibrator/src/vibrator_js.cpp +++ b/frameworks/js/napi/vibrator/src/vibrator_js.cpp @@ -69,8 +69,8 @@ static std::map g_usageType = { static std::set g_allowedTypes = {"time", "preset", "file", "pattern"}; static std::map>> g_onCallbackInfos; -static std::mutex g_onMutex; -static std::mutex g_mutex; +static std::mutex g_Mutex; +static std::mutex g_plugCallbackMutex; static napi_value EmitAsyncWork(napi_value param, sptr info) { @@ -387,19 +387,19 @@ static bool CheckVibratorPatternParameter(VibratorPattern &vibratorPattern) return true; } -bool ParseVibratorParams(napi_env env, napi_value value, VibratorParams ¶ms) +bool ParseVibratorIdentifier(napi_env env, napi_value value, VibratorIdentifier &identifier) { CALL_LOG_ENTER; - bool deviceIdResult = GetPropertyInt32(env, value, "deviceId", params.deviceId); - bool vibratorIdResult = GetPropertyInt32(env, value, "vibratorId", params.vibratorId); + bool deviceIdResult = GetPropertyInt32(env, value, "deviceId", identifier.deviceId); + bool vibratorIdResult = GetPropertyInt32(env, value, "vibratorId", identifier.vibratorId); if(deviceIdResult || vibratorIdResult) { - MISC_HILOGI("Get vibrate params success"); + MISC_HILOGI("Get vibrate identifier success"); return true; } return false; } -bool ParseParameter(napi_env env, napi_value args[], size_t argc, VibrateInfo &info, VibratorParams ¶ms) +bool ParseParameter(napi_env env, napi_value args[], size_t argc, VibrateInfo &info, VibratorIdentifier &identifier) { CHKCF((argc >= PARAMETER_THREE), "Wrong argument number"); CHKCF(GetPropertyString(env, args[0], "type", info.type), "Get vibrate type fail"); @@ -432,28 +432,28 @@ bool ParseParameter(napi_env env, napi_value args[], size_t argc, VibrateInfo &i if (!GetPropertyBool(env, args[1], "systemUsage", info.systemUsage)) { info.systemUsage = false; } - if (!GetPropertyInt32(env, args[1], "deviceId", params.deviceId)) { - params.deviceId = -1; + if (!GetPropertyInt32(env, args[1], "deviceId", identifier.deviceId)) { + identifier.deviceId = -1; } - if (!GetPropertyInt32(env, args[1], "id", params.vibratorId)) { - params.vibratorId = -1; + if (!GetPropertyInt32(env, args[1], "id", identifier.vibratorId)) { + identifier.vibratorId = -1; } return true; } -bool SetUsage(const VibratorParams ¶ms, const std::string &usage, bool systemUsage) +bool SetUsage(const VibratorIdentifier &identifier, const std::string &usage, bool systemUsage) { if (auto iter = g_usageType.find(usage); iter == g_usageType.end()) { MISC_HILOGE("Wrong usage type"); return false; } - return SetUsageEnhanced(params, g_usageType[usage], systemUsage); + return SetUsageEnhanced(identifier, g_usageType[usage], systemUsage); } -int32_t CheckParameters(const VibrateInfo &info, const VibratorParams ¶ms) +int32_t CheckParameters(const VibrateInfo &info, const VibratorIdentifier &identifier) { CALL_LOG_ENTER; - if (!SetUsage(params, info.usage, info.systemUsage)) { + if (!SetUsage(identifier, info.usage, info.systemUsage)) { MISC_HILOGE("SetUsage fail"); return PARAMETER_ERROR; } @@ -464,33 +464,33 @@ int32_t CheckParameters(const VibrateInfo &info, const VibratorParams ¶ms) return ERR_OK; } -int32_t StartVibrate(const VibrateInfo &info, const VibratorParams ¶ms) +int32_t StartVibrate(const VibrateInfo &info, const VibratorIdentifier &identifier) { CALL_LOG_ENTER; - if (CheckParameters(info, params) != ERR_OK) { + if (CheckParameters(info, identifier) != ERR_OK) { MISC_HILOGE("CheckParameters fail"); return PARAMETER_ERROR; } if (info.type == "file") { - return PlayVibratorCustomEnhanced(params, info.fd, info.offset, info.length); + return PlayVibratorCustomEnhanced(identifier, info.fd, info.offset, info.length); } else if (info.type == "pattern") { - return PlayPatternEnhanced(params, info.vibratorPattern); + return PlayPatternEnhanced(identifier, info.vibratorPattern); } - return StartVibratorOnceEnhanced(params, info.duration); + return StartVibratorOnceEnhanced(identifier, info.duration); } static napi_value VibrateEffect(napi_env env, napi_value args[], size_t argc) { sptr asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env); CHKPP(asyncCallbackInfo); - VibratorParams params; - if (!ParseParameter(env, args, argc, asyncCallbackInfo->info, params)) { + VibratorIdentifier identifier; + if (!ParseParameter(env, args, argc, asyncCallbackInfo->info, identifier)) { MISC_HILOGE("ParseParameter fail"); ThrowErr(env, PARAMETER_ERROR, "ParseParameter fail"); return nullptr; } if (asyncCallbackInfo->info.type == "preset") { - if (!SetLoopCountEnhanced(params, asyncCallbackInfo->info.count) || CheckParameters(asyncCallbackInfo->info, params) != ERR_OK || + if (!SetLoopCountEnhanced(identifier, asyncCallbackInfo->info.count) || CheckParameters(asyncCallbackInfo->info, identifier) != ERR_OK || asyncCallbackInfo->info.effectId.empty()) { MISC_HILOGE("SetLoopCount fail or parameter invalid"); ThrowErr(env, PARAMETER_ERROR, "SetLoopCount fail or parameter invalid"); @@ -498,7 +498,7 @@ static napi_value VibrateEffect(napi_env env, napi_value args[], size_t argc) } asyncCallbackInfo->flag = "preset"; } else { - asyncCallbackInfo->error.code = StartVibrate(asyncCallbackInfo->info, params); + asyncCallbackInfo->error.code = StartVibrate(asyncCallbackInfo->info, identifier); if (asyncCallbackInfo->info.vibratorPattern.events != nullptr) { CHKCP(ClearVibratorPattern(asyncCallbackInfo->info.vibratorPattern), "ClearVibratorPattern fail"); } @@ -564,20 +564,20 @@ static napi_value Cancel(napi_env env, napi_callback_info info) ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail"); return nullptr; } - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; sptr asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env); CHKPP(asyncCallbackInfo); if ((argc > 0) && (IsMatchType(env, args[0], napi_function))) { - asyncCallbackInfo->error.code = CancelEnhanced(params); + asyncCallbackInfo->error.code = CancelEnhanced(identifier); return EmitAsyncWork(args[0], asyncCallbackInfo); - }else if((argc > 0) && IsMatchType(env, args[0], napi_object) && ParseVibratorParams(env, args[0], params)) { - asyncCallbackInfo->error.code = CancelEnhanced(params); + }else if((argc > 0) && IsMatchType(env, args[0], napi_object) && ParseVibratorIdentifier(env, args[0], identifier)) { + asyncCallbackInfo->error.code = CancelEnhanced(identifier); return EmitAsyncWork(nullptr, asyncCallbackInfo); }else { - asyncCallbackInfo->error.code = CancelEnhanced(params); + asyncCallbackInfo->error.code = CancelEnhanced(identifier); return EmitAsyncWork(nullptr, asyncCallbackInfo); } } @@ -592,7 +592,7 @@ static napi_value Stop(napi_env env, napi_callback_info info) ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail"); return nullptr; } - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; @@ -604,7 +604,7 @@ static napi_value Stop(napi_env env, napi_callback_info info) } sptr asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env); CHKPP(asyncCallbackInfo); - asyncCallbackInfo->error.code = StopVibratorEnhanced(params, mode.c_str()); + asyncCallbackInfo->error.code = StopVibratorEnhanced(identifier, mode.c_str()); if ((asyncCallbackInfo->error.code != SUCCESS) && (asyncCallbackInfo->error.code == PARAMETER_ERROR)) { ThrowErr(env, PARAMETER_ERROR, "Parameters invalid"); return nullptr; @@ -631,14 +631,14 @@ static napi_value StopVibrationSync(napi_env env, napi_callback_info info) return result; } - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; if (argc >= 1 && IsMatchType(env, args[0], napi_object)) { - ParseVibratorParams(env, args[0], params); + ParseVibratorIdentifier(env, args[0], identifier); } - int32_t ret = CancelEnhanced(params); + int32_t ret = CancelEnhanced(identifier); if (ret != SUCCESS) { ThrowErr(env, ret, "Cancel execution fail"); } @@ -809,36 +809,31 @@ static napi_value CreateEnumEventType(const napi_env& env, napi_value exports) return exports; } -static napi_value GetVibratorListSync(napi_env env, napi_callback_info info) { +static napi_value GetVibratorListSync(napi_env env, napi_callback_info info) +{ CALL_LOG_ENTER; size_t argc = 1; napi_value args[1] = {0}; NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr)); - VibratorParams params; + VibratorIdentifier identifier; if (argc > 0) { - if (!ParseVibratorParams(env, args[0], params)) { + if (!ParseVibratorIdentifier(env, args[0], identifier)) { MISC_HILOGW("deviceId and vibratorId is undefined, set default value deviceId = -1 and vibratorId = -1"); } - MISC_HILOGD("params=[deviceId=%{public}d, vibratorId=%{pubilc}d]", params.deviceId, params.vibratorId); + MISC_HILOGD("identifier=[deviceId=%{public}d, vibratorId=%{pubilc}d]", identifier.deviceId, identifier.vibratorId); } napi_value jsArray; NAPI_CALL(env, napi_create_array(env, &jsArray)); std::vector vibratorInfo; - //VibratorInfos vibratorInfo[MAX_LOCAL_VIBRATOR_SIZE] = {}; c interface - int32_t length = 0; - //int32_t ret = GetVibratorIdList(params, vibratorInfo, length); - int32_t ret = GetVibratorIdList(params, vibratorInfo); + int32_t ret = GetVibratorIdList(identifier, vibratorInfo); - if (ret == 0) { + if (ret == SUCCESS) { + int32_t length = 0; for (auto& info : vibratorInfo) { napi_value jsInfo = ConvertToJsVibratorInfo(env, info); NAPI_CALL(env, napi_set_element(env, jsArray, length++, jsInfo)); } - // for (int i = 0; i < length ; ++i) { c interface - // napi_value jsInfo = ConvertToJsVibratorInfo(env, vibratorInfo[i]); - // NAPI_CALL(env, napi_set_element(env, jsArray, i, jsInfo)); - // } } else { ThrowErr(env, ret, "Failed to get vibrator list"); return nullptr; @@ -846,54 +841,54 @@ static napi_value GetVibratorListSync(napi_env env, napi_callback_info info) { return jsArray; } -static napi_value GetVibratorListAsync(napi_env env, napi_callback_info info) { +static napi_value GetVibratorList(napi_env env, napi_callback_info info) +{ CALL_LOG_ENTER; size_t argc = 1; napi_value args[2] = {0}; NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr)); - VibratorParams params; + VibratorIdentifier identifier; if (argc > 0 && IsMatchType(env, args[0], napi_number)) { - if (!ParseVibratorParams(env, args[0], params)) { + if (!ParseVibratorIdentifier(env, args[0], identifier)) { MISC_HILOGW("deviceId and vibratorId is undefined, set default value deviceId = -1 and vibratorId = -1"); } - MISC_HILOGD("params=[deviceId=%{public}d, vibratorId=%{pubilc}d]", params.deviceId, params.vibratorId); + MISC_HILOGD("identifier=[deviceId=%{public}d, vibratorId=%{pubilc}d]", identifier.deviceId, identifier.vibratorId); } sptr asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env); CHKPP(asyncCallbackInfo); asyncCallbackInfo->callbackType = GET_VIBRATOR_INFO_LIST; - //asyncCallbackInfo->error.code = GetVibratorIdList(params, asyncCallbackInfo->vibratorInfos, asyncCallbackInfo->arrayLength); - asyncCallbackInfo->error.code = GetVibratorIdList(params, asyncCallbackInfo->vibratorInfos); + asyncCallbackInfo->error.code = GetVibratorIdList(identifier, asyncCallbackInfo->vibratorInfos); if ((argc > 0) && IsMatchType(env, args[1], napi_function)) { return EmitAsyncWork(args[1], asyncCallbackInfo); } return EmitAsyncWork(nullptr, asyncCallbackInfo); } -static napi_value isSupportEffectInfo(napi_env env, napi_callback_info info) { +static napi_value IsSupportEffectInfoSync(napi_env env, napi_callback_info info) +{ CALL_LOG_ENTER; size_t argc = 2; napi_value args[2] = {0}; NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr)); - std::vector buffer(64); - NAPI_CALL(env, napi_get_value_string_utf8(env, args[0], buffer.data(), 64, nullptr)); + std::vector buffer(STRING_LENGTH_MAX); + NAPI_CALL(env, napi_get_value_string_utf8(env, args[0], buffer.data(), STRING_LENGTH_MAX, nullptr)); std::string effectType(buffer.data()); MISC_HILOGD("effectType = %{public}s", effectType.c_str()); - VibratorParams params; + VibratorIdentifier identifier; if (argc > 1) { - if (!ParseVibratorParams(env, args[1], params)) { + if (!ParseVibratorIdentifier(env, args[1], identifier)) { MISC_HILOGW("deviceId and vibratorId is undefined, set default value deviceId = -1 and vibratorId = -1"); } - MISC_HILOGD("params=[deviceId=%{public}d, vibratorId=%{pubilc}d]", params.deviceId, params.vibratorId); + MISC_HILOGD("identifier=[deviceId=%{public}d, vibratorId=%{pubilc}d]", identifier.deviceId, identifier.vibratorId); } EffectInfo effectInfo; - //int32_t ret = GetEffectInfo(params, effectType.c_str(), effectInfo); - int32_t ret = GetEffectInfo(params, effectType, effectInfo); - MISC_HILOGD("isSupportEffect=%{public}s", (effectInfo.isSupportEffect? "true":"false")); + int32_t ret = GetEffectInfo(identifier, effectType, effectInfo); + MISC_HILOGD("effectInfo=[%{public}s]", (effectInfo.isSupportEffect? "true" : "false")); napi_value jsEffectInfo = nullptr; if (ret == 0) { @@ -902,7 +897,8 @@ static napi_value isSupportEffectInfo(napi_env env, napi_callback_info info) { return jsEffectInfo; } -static napi_value isSupportEffectInfoAsync(napi_env env, napi_callback_info info) { +static napi_value IsSupportEffectInfo(napi_env env, napi_callback_info info) +{ CALL_LOG_ENTER; size_t argc = 3; napi_value args[3]; @@ -913,19 +909,18 @@ static napi_value isSupportEffectInfoAsync(napi_env env, napi_callback_info info std::string effectType(buffer.data()); MISC_HILOGD("effectType = %{public}s", effectType.c_str()); - VibratorParams params; + VibratorIdentifier identifier; if (argc > 1) { - if (!ParseVibratorParams(env, args[1], params)) { + if (!ParseVibratorIdentifier(env, args[1], identifier)) { MISC_HILOGW("deviceId and vibratorId is undefined, set default value deviceId = -1 and vibratorId = -1"); } - MISC_HILOGD("params=[deviceId=%{public}d, vibratorId=%{pubilc}d]", params.deviceId, params.vibratorId); + MISC_HILOGD("identifier=[deviceId=%{public}d, vibratorId=%{pubilc}d]", identifier.deviceId, identifier.vibratorId); } sptr asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env); CHKPP(asyncCallbackInfo); asyncCallbackInfo->callbackType = GET_EFFECT_INFO; - //asyncCallbackInfo->error.code = GetEffectInfo(params, effectType.c_str(), asyncCallbackInfo->vibratorEffectInfo); - asyncCallbackInfo->error.code = GetEffectInfo(params, effectType, asyncCallbackInfo->vibratorEffectInfo); + asyncCallbackInfo->error.code = GetEffectInfo(identifier, effectType, asyncCallbackInfo->effectInfo); if ((argc > 1) && (IsMatchType(env, args[2], napi_function))) { return EmitAsyncWork(args[2], asyncCallbackInfo); } @@ -970,7 +965,7 @@ static bool IsSubscribed(const napi_env& env, int32_t vibratorEventId, napi_valu static void UpdateCallbackInfos(const napi_env& env, int32_t vibratorEventId, napi_value callback) { CALL_LOG_ENTER; - std::lock_guard onCallbackLock(g_onMutex); + std::lock_guard onSubcribeLock(g_Mutex); CHKCV(IsSubscribed(env, vibratorEventId, callback), "The callback has been subscribed"); sptr asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env); CHKPV(asyncCallbackInfo); @@ -996,12 +991,13 @@ static int32_t UpdatePlugInfo(VibratorDeviceInfo *deviceInfo, sptrtype == PLUG_STATE_EVENT_UNKNOWN || deviceInfo->deviceId == -1) { + MISC_HILOGE("UpdatePlugInfo failed"); return PARAMETER_ERROR; } - asyncCallbackInfo->vibratorDeviceInfo.type = deviceInfo->type; - asyncCallbackInfo->vibratorDeviceInfo.deviceId = deviceInfo->deviceId; - MISC_HILOGD("asyncCallbackInfo->VibratorDeviceInfo : [ VibratorPlugState = %{public}d, deviceId = %{public}d]", - asyncCallbackInfo->vibratorDeviceInfo.type, asyncCallbackInfo->vibratorDeviceInfo.deviceId); + asyncCallbackInfo->deviceInfo.type = deviceInfo->type; + asyncCallbackInfo->deviceInfo.deviceId = deviceInfo->deviceId; + MISC_HILOGD("asyncCallbackInfo->deviceInfo : [ VibratorPlugState = %{public}d, deviceId = %{public}d]", + asyncCallbackInfo->deviceInfo.type, asyncCallbackInfo->deviceInfo.deviceId); return 0; } @@ -1009,7 +1005,7 @@ void DataCallbackImpl(VibratorDeviceInfo *deviceInfo) { CALL_LOG_ENTER; CHKPV(deviceInfo); - std::lock_guard subscribeLock(g_mutex); + std::lock_guard CallbackLock(g_plugCallbackMutex); std::vector> callBackArry; for (auto& allCallBack : g_onCallbackInfos) { callBackArry = allCallBack.second; @@ -1071,7 +1067,7 @@ static napi_value On(napi_env env, napi_callback_info info) { static int32_t RemoveAllCallback(const napi_env& env, int32_t eventType) { CALL_LOG_ENTER; - std::lock_guard onCallbackLock(g_onMutex); + std::lock_guard onCancelLock(g_Mutex); std::vector> callbackInfos = g_onCallbackInfos[eventType]; for (auto iter = callbackInfos.begin(); iter != callbackInfos.end();) { CHKPC(*iter); @@ -1123,10 +1119,10 @@ static napi_value Off(napi_env env, napi_callback_info info) { int32_t ret = UnSubscribeVibrator(user); if (ret != ERR_OK && ret != CALLBACK_UNSUBSCRIBED) { - ThrowErr(env, ret, "UnSubscribeVibrator fail"); + ThrowErr(env, ret, "User callback unsubscribe fail"); return nullptr; } else if (ret == CALLBACK_UNSUBSCRIBED) { - MISC_HILOGW("User callback has been unsubscribed"); + MISC_HILOGW("User callback has been canceled"); return nullptr; } return nullptr; @@ -1173,10 +1169,10 @@ static napi_value Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("isHdHapticSupported", IsHdHapticSupported), DECLARE_NAPI_FUNCTION("isSupportEffect", IsSupportEffect), DECLARE_NAPI_FUNCTION("isSupportEffectSync", IsSupportEffectSync), - DECLARE_NAPI_FUNCTION("GetVibratorList", GetVibratorListAsync), + DECLARE_NAPI_FUNCTION("GetVibratorList", GetVibratorList), DECLARE_NAPI_FUNCTION("GetVibratorListSync", GetVibratorListSync), - DECLARE_NAPI_FUNCTION("isSupportEffectInfo", isSupportEffectInfoAsync), - DECLARE_NAPI_FUNCTION("isSupportEffectInfoSync", isSupportEffectInfo), + DECLARE_NAPI_FUNCTION("isSupportEffectInfo", IsSupportEffectInfo), + DECLARE_NAPI_FUNCTION("isSupportEffectInfoSync", IsSupportEffectInfoSync), DECLARE_NAPI_FUNCTION("on", On), DECLARE_NAPI_FUNCTION("off", Off), }; diff --git a/frameworks/js/napi/vibrator/src/vibrator_napi_utils.cpp b/frameworks/js/napi/vibrator/src/vibrator_napi_utils.cpp index ab9ee07..a1daa6b 100644 --- a/frameworks/js/napi/vibrator/src/vibrator_napi_utils.cpp +++ b/frameworks/js/napi/vibrator/src/vibrator_napi_utils.cpp @@ -447,7 +447,7 @@ bool ConstructIsSupportEffectInfoResult(const napi_env &env, sptrvibratorEffectInfo); + jsEffectInfo = ConvertToJsEffectInfo(env, asyncCallbackInfo->effectInfo); CHKPF(jsEffectInfo); result[1] = jsEffectInfo; } @@ -465,7 +465,7 @@ bool ConstructVibratorPlugInfoResult(const napi_env &env, sptrvibratorDeviceInfo); + jsDevicePlugInfo = ConvertToJsVibratorPlungInfo(env, asyncCallbackInfo->deviceInfo); CHKPF(jsDevicePlugInfo); result[0] = jsDevicePlugInfo; CHKCF((napi_get_undefined(env, &result[1]) == napi_ok), "napi_get_undefined fail"); diff --git a/frameworks/native/vibrator/all/IMiscdeviceService.idl b/frameworks/native/vibrator/all/IMiscdeviceService.idl index 787c8de..4ff8ac6 100644 --- a/frameworks/native/vibrator/all/IMiscdeviceService.idl +++ b/frameworks/native/vibrator/all/IMiscdeviceService.idl @@ -21,25 +21,25 @@ sequenceable raw_file_descriptor..OHOS.Sensors.RawFileDescriptor; sequenceable vibrator_infos..OHOS.Sensors.VibrateParameter; sequenceable vibrator_infos..OHOS.Sensors.VibratePattern; sequenceable vibrator_infos..OHOS.Sensors.VibratorCapacity; -sequenceable vibrator_infos..OHOS.Sensors.VibratorParamsIPC; +sequenceable vibrator_infos..OHOS.Sensors.VibratorIdentifierIPC; sequenceable vibrator_infos..OHOS.Sensors.VibratorInfoIPC; sequenceable vibrator_infos..OHOS.Sensors.EffectInfoIPC; interface OHOS.Sensors.IMiscdeviceService { - void Vibrate([in] VibratorParamsIPC params, [in] int vibratorId, [in] int timeOut, [in] int usage, [in] boolean systemUsage); - void PlayVibratorEffect([in] VibratorParamsIPC params, [in] int vibratorId, [in] String effect, [in] int loopCount, [in] int usage, [in] boolean systemUsage); - void PlayVibratorCustom([in] VibratorParamsIPC params, [in] int vibratorId, [in] FileDescriptor fd, [in] long offset, [in] long length, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter); - void StopVibrator([in] VibratorParamsIPC params, [in] int vibratorId); - void StopVibratorByMode([in] VibratorParamsIPC params, [in] int vibratorId, [in] String mode); - void IsSupportEffect([in] VibratorParamsIPC params, [in] String effect, [out] boolean state); + void Vibrate([in] VibratorIdentifierIPC identifier, [in] int timeOut, [in] int usage, [in] boolean systemUsage); + void PlayVibratorEffect([in] VibratorIdentifierIPC identifier, [in] String effect, [in] int loopCount, [in] int usage, [in] boolean systemUsage); + void PlayVibratorCustom([in] VibratorIdentifierIPC identifier, [in] FileDescriptor fd, [in] long offset, [in] long length, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter); + void StopVibrator([in] VibratorIdentifierIPC identifier); + void StopVibratorByMode([in] VibratorIdentifierIPC identifier, [in] String mode); + void IsSupportEffect([in] VibratorIdentifierIPC identifier, [in] String effect, [out] boolean state); void GetLightList([out] LightInfoIPC[] lightInfoIpcList); void TurnOn([in] int lightId, [in] int singleColor, [in] LightAnimationIPC animation); void TurnOff([in] int lightId); - void GetDelayTime([in] VibratorParamsIPC params, [out] int delayTime); - void PlayPattern([in] VibratorParamsIPC params, [in] VibratePattern pattern, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter); + void GetDelayTime([in] VibratorIdentifierIPC identifier, [out] int delayTime); + void PlayPattern([in] VibratorIdentifierIPC identifier, [in] VibratePattern pattern, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter); void TransferClientRemoteObject([in] IRemoteObject vibratorClient); - void PlayPrimitiveEffect([in] VibratorParamsIPC params, [in] int vibratorId, [in] String effect, [in] int intensity, [in] int usage, [in] boolean systemUsage, [in] int count); - void GetVibratorCapacity([in] VibratorParamsIPC params, [out] VibratorCapacity capacity); - void GetVibratorIdList([in] VibratorParamsIPC params, [out] VibratorInfoIPC[] vibratorInfoIPC); - void GetEffectInfo([in] VibratorParamsIPC params, [in] String effectType, [out] EffectInfoIPC effectInfoIPC); + void PlayPrimitiveEffect([in] VibratorIdentifierIPC identifier, [in] String effect, [in] int intensity, [in] int usage, [in] boolean systemUsage, [in] int count); + void GetVibratorCapacity([in] VibratorIdentifierIPC identifier, [out] VibratorCapacity capacity); + void GetVibratorIdList([in] VibratorIdentifierIPC identifier, [out] VibratorInfoIPC[] vibratorInfoIPC); + void GetEffectInfo([in] VibratorIdentifierIPC identifier, [in] String effectType, [out] EffectInfoIPC effectInfoIPC); } \ No newline at end of file diff --git a/frameworks/native/vibrator/include/i_vibrator_client.h b/frameworks/native/vibrator/include/i_vibrator_client.h index 8aec78a..7278d63 100644 --- a/frameworks/native/vibrator/include/i_vibrator_client.h +++ b/frameworks/native/vibrator/include/i_vibrator_client.h @@ -22,11 +22,8 @@ namespace OHOS { namespace Sensors { class IVibratorClient : public IRemoteBroker { public: - enum VibratorClientInterFaceId { - GET_FOO_NAME = 0, - SEND_ASYNC_REPLY = 1, - SEND_WRONG_REPLY = 2, - TRANS_ID_PING_ABILITY = 5, + enum VibratorClientInterfaceId { + TRANS_ID_PLUG_ABILITY = 5, }; IVibratorClient() = default; virtual ~IVibratorClient() = default; diff --git a/frameworks/native/vibrator/include/vibrator_client_proxy.h b/frameworks/native/vibrator/include/vibrator_client_proxy.h index e0ef8e5..0ef859d 100644 --- a/frameworks/native/vibrator/include/vibrator_client_proxy.h +++ b/frameworks/native/vibrator/include/vibrator_client_proxy.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -48,7 +48,7 @@ public: MISC_HILOGE("Failed to write deviceId to parcelable"); return PARAMETER_ERROR; } - int error = Remote()->SendRequest(TRANS_ID_PING_ABILITY, dataParcel, replyParcel, option); + int error = Remote()->SendRequest(TRANS_ID_PLUG_ABILITY, dataParcel, replyParcel, option); if (error != ERR_NONE) { MISC_HILOGE("failed, error code is: %{public}d", error); return PARAMETER_ERROR; diff --git a/frameworks/native/vibrator/include/vibrator_service_client.h b/frameworks/native/vibrator/include/vibrator_service_client.h index fdb2cd4..31ecd60 100644 --- a/frameworks/native/vibrator/include/vibrator_service_client.h +++ b/frameworks/native/vibrator/include/vibrator_service_client.h @@ -57,47 +57,47 @@ struct VibratorDecodeHandle { class VibratorServiceClient : public Singleton { public: ~VibratorServiceClient() override; - int32_t Vibrate(const VibratorParams ¶ms, int32_t vibratorId, int32_t timeOut, + int32_t Vibrate(const VibratorIdentifier &identifier, int32_t timeOut, int32_t usage, bool systemUsage); - int32_t Vibrate(const VibratorParams ¶ms, int32_t vibratorId, const std::string &effect, + int32_t Vibrate(const VibratorIdentifier &identifier, const std::string &effect, int32_t loopCount, int32_t usage, bool systemUsage); #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - int32_t PlayVibratorCustom(const VibratorParams ¶ms, int32_t vibratorId, const RawFileDescriptor &rawFd, + int32_t PlayVibratorCustom(const VibratorIdentifier &identifier, const RawFileDescriptor &rawFd, int32_t usage, bool systemUsage, const VibratorParameter ¶meter); #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - int32_t StopVibrator(const VibratorParams ¶ms, int32_t vibratorId, const std::string &mode); - int32_t StopVibrator(const VibratorParams ¶ms, int32_t vibratorId); - bool IsHdHapticSupported(const VibratorParams ¶ms); - int32_t IsSupportEffect(const VibratorParams ¶ms, const std::string &effect, bool &state); + int32_t StopVibrator(const VibratorIdentifier &identifier, const std::string &mode); + int32_t StopVibrator(const VibratorIdentifier &identifier); + bool IsHdHapticSupported(const VibratorIdentifier &identifier); + int32_t IsSupportEffect(const VibratorIdentifier &identifier, const std::string &effect, bool &state); void ProcessDeathObserver(const wptr &object); int32_t PreProcess(const VibratorFileDescription &fd, VibratorPackage &package); - int32_t GetDelayTime(const VibratorParams ¶ms, int32_t &delayTime); - int32_t InitPlayPattern(const VibratorParams ¶ms, const VibratorPattern &pattern, int32_t usage, + int32_t GetDelayTime(const VibratorIdentifier &identifier, int32_t &delayTime); + int32_t InitPlayPattern(const VibratorIdentifier &identifier, const VibratorPattern &pattern, int32_t usage, bool systemUsage, const VibratorParameter ¶meter); - int32_t PlayPattern(const VibratorParams ¶ms, const VibratorPattern &pattern, int32_t usage, + int32_t PlayPattern(const VibratorIdentifier &identifier, const VibratorPattern &pattern, int32_t usage, bool systemUsage, const VibratorParameter ¶meter); int32_t FreeVibratorPackage(VibratorPackage &package); - int32_t PlayPrimitiveEffect(const VibratorParams ¶ms, int32_t vibratorId, const std::string &effect, + int32_t PlayPrimitiveEffect(const VibratorIdentifier &identifier, const std::string &effect, int32_t intensity, int32_t usage, bool systemUsage, int32_t count); - bool IsSupportVibratorCustom(const VibratorParams ¶ms); + bool IsSupportVibratorCustom(const VibratorIdentifier &identifier); int32_t SeekTimeOnPackage(int32_t seekTime, const VibratorPackage &completePackage, VibratorPackage &seekPackage); int32_t SubscribeVibratorPlugInfo(const VibratorUser *user); int32_t UnsubscribeVibratorPlugInfo(const VibratorUser *user); std::set GetSubscribeUserCallback(int32_t deviceId); bool HandleVibratorData(VibratorDeviceInfo info); - void SetUsage(const VibratorParams ¶ms, int32_t usage, bool systemUsage); - void SetLoopCount(const VibratorParams ¶ms, int32_t count); - void SetParameters(const VibratorParams ¶ms, const VibratorParameter ¶meter); - VibratorEffectParameter GetVibratorEffectParameter(const VibratorParams ¶ms); - int32_t GetVibratorIdList(const VibratorParams& params, std::vector& vibratorInfo); - int32_t GetEffectInfo(const VibratorParams& params,const std::string& effectType, EffectInfo& effectInfo); + void SetUsage(const VibratorIdentifier &identifier, int32_t usage, bool systemUsage); + void SetLoopCount(const VibratorIdentifier &identifier, int32_t count); + void SetParameters(const VibratorIdentifier &identifier, const VibratorParameter ¶meter); + VibratorEffectParameter GetVibratorEffectParameter(const VibratorIdentifier &identifier); + int32_t GetVibratorIdList(const VibratorIdentifier& identifier, std::vector& vibratorInfo); + int32_t GetEffectInfo(const VibratorIdentifier& identifier,const std::string& effectType, EffectInfo& effectInfo); private: int32_t InitServiceClient(); int32_t LoadDecoderLibrary(const std::string& path); int32_t ConvertVibratorPackage(const VibratePackage& inPkg, VibratorPackage &outPkg); int32_t TransferClientRemoteObject(); - int32_t GetVibratorCapacity(const VibratorParams ¶ms, VibratorCapacity &capacity); + int32_t GetVibratorCapacity(const VibratorIdentifier &identifier, VibratorCapacity &capacity); void ConvertSeekVibratorPackage(const VibratorPackage &completePackage, VibratePackage &convertPackage, int32_t seekTime); void ConvertVibratorPattern(const VibratorPattern &vibratorPattern, VibratePattern &vibratePattern); @@ -115,8 +115,8 @@ private: std::recursive_mutex subscribeMutex_; std::set subscribeSet_; - std::mutex VibratorEffectMutex_; - std::map VibratorEffectMap_; + std::mutex vibratorEffectMutex_; + std::map vibratorEffectMap_; }; } // namespace Sensors } // namespace OHOS diff --git a/frameworks/native/vibrator/part/IMiscdeviceService.idl b/frameworks/native/vibrator/part/IMiscdeviceService.idl index 20a1a4d..e8a100e 100644 --- a/frameworks/native/vibrator/part/IMiscdeviceService.idl +++ b/frameworks/native/vibrator/part/IMiscdeviceService.idl @@ -21,24 +21,24 @@ sequenceable raw_file_descriptor..OHOS.Sensors.RawFileDescriptor; sequenceable vibrator_infos..OHOS.Sensors.VibrateParameter; sequenceable vibrator_infos..OHOS.Sensors.VibratePattern; sequenceable vibrator_infos..OHOS.Sensors.VibratorCapacity; -sequenceable vibrator_infos..OHOS.Sensors.VibratorParamsIPC; +sequenceable vibrator_infos..OHOS.Sensors.VibratorIdentifierIPC; sequenceable vibrator_infos..OHOS.Sensors.VibratorInfoIPC; sequenceable vibrator_infos..OHOS.Sensors.EffectInfoIPC; interface OHOS.Sensors.IMiscdeviceService { - void Vibrate([in] VibratorParamsIPC params, [in] int vibratorId, [in] int timeOut, [in] int usage, [in] boolean systemUsage); - void PlayVibratorEffect([in] VibratorParamsIPC params, [in] int vibratorId, [in] String effect, [in] int loopCount, [in] int usage, [in] boolean systemUsage); - void StopVibrator([in] VibratorParamsIPC params, [in] int vibratorId); - void StopVibratorByMode([in] VibratorParamsIPC params, [in] int vibratorId, [in] String mode); - void IsSupportEffect([in] VibratorParamsIPC params, [in] String effect, [out] boolean state); + void Vibrate([in] VibratorIdentifierIPC identifier, [in] int timeOut, [in] int usage, [in] boolean systemUsage); + void PlayVibratorEffect([in] VibratorIdentifierIPC identifier, [in] String effect, [in] int loopCount, [in] int usage, [in] boolean systemUsage); + void StopVibrator([in] VibratorIdentifierIPC identifier); + void StopVibratorByMode([in] VibratorIdentifierIPC identifier, [in] String mode); + void IsSupportEffect([in] VibratorIdentifierIPC identifier, [in] String effect, [out] boolean state); void GetLightList([out] LightInfoIPC[] lightInfoIpcList); void TurnOn([in] int lightId, [in] int singleColor, [in] LightAnimationIPC animation); void TurnOff([in] int lightId); - void GetDelayTime([in] VibratorParamsIPC params, [out] int delayTime); - void PlayPattern([in] VibratorParamsIPC params, [in] VibratePattern pattern, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter); + void GetDelayTime([in] VibratorIdentifierIPC identifier, [out] int delayTime); + void PlayPattern([in] VibratorIdentifierIPC identifier, [in] VibratePattern pattern, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter); void TransferClientRemoteObject([in] IRemoteObject vibratorClient); - void PlayPrimitiveEffect([in] VibratorParamsIPC params, [in] int vibratorId, [in] String effect, [in] int intensity, [in] int usage, [in] boolean systemUsage, [in] int count); - void GetVibratorCapacity([in] VibratorParamsIPC params, [out] VibratorCapacity capacity); - void GetVibratorIdList([in] VibratorParamsIPC params, [out] VibratorInfoIPC[] vibratorInfoIPC); - void GetEffectInfo([in] VibratorParamsIPC params, [in] String effectType, [out] EffectInfoIPC effectInfoIPC); + void PlayPrimitiveEffect([in] VibratorIdentifierIPC identifier, [in] String effect, [in] int intensity, [in] int usage, [in] boolean systemUsage, [in] int count); + void GetVibratorCapacity([in] VibratorIdentifierIPC identifier, [out] VibratorCapacity capacity); + void GetVibratorIdList([in] VibratorIdentifierIPC identifier, [out] VibratorInfoIPC[] vibratorInfoIPC); + void GetEffectInfo([in] VibratorIdentifierIPC identifier, [in] String effectType, [out] EffectInfoIPC effectInfoIPC); } \ No newline at end of file diff --git a/frameworks/native/vibrator/src/vibrator_client_stub.cpp b/frameworks/native/vibrator/src/vibrator_client_stub.cpp index ad9fe72..62a755a 100644 --- a/frameworks/native/vibrator/src/vibrator_client_stub.cpp +++ b/frameworks/native/vibrator/src/vibrator_client_stub.cpp @@ -37,7 +37,7 @@ int32_t VibratorClientStub::OnRemoteRequest(uint32_t code, MessageParcel &data, } MISC_HILOGD("Begin, cmd:%{public}u", code); switch (code) { - case TRANS_ID_PING_ABILITY: { + case TRANS_ID_PLUG_ABILITY: { int32_t eventCode = 0; int32_t deviceId = -1; if (!data.ReadInt32(eventCode)) { diff --git a/frameworks/native/vibrator/src/vibrator_service_client.cpp b/frameworks/native/vibrator/src/vibrator_service_client.cpp index 3c96930..b5a0555 100644 --- a/frameworks/native/vibrator/src/vibrator_service_client.cpp +++ b/frameworks/native/vibrator/src/vibrator_service_client.cpp @@ -118,8 +118,8 @@ int32_t VibratorServiceClient::TransferClientRemoteObject() return ret; } -int32_t VibratorServiceClient::Vibrate(const VibratorParams ¶ms, int32_t vibratorId, int32_t timeOut, - int32_t usage, bool systemUsage) +int32_t VibratorServiceClient::Vibrate(const VibratorIdentifier &identifier, int32_t timeOut, int32_t usage, + bool systemUsage) { MISC_HILOGD("Vibrate begin, time:%{public}d, usage:%{public}d", timeOut, usage); int32_t ret = InitServiceClient(); @@ -132,10 +132,10 @@ int32_t VibratorServiceClient::Vibrate(const VibratorParams ¶ms, int32_t vib #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "VibrateTime"); #endif // HIVIEWDFX_HITRACE_ENABLE - VibratorParamsIPC vibrateParams; - vibrateParams.deviceId = params.deviceId; - vibrateParams.vibratorId = params.vibratorId; - ret = miscdeviceProxy_->Vibrate(vibrateParams, vibratorId, timeOut, usage, systemUsage); + VibratorIdentifierIPC vibrateIdentifier; + vibrateIdentifier.deviceId = identifier.deviceId; + vibrateIdentifier.vibratorId = identifier.vibratorId; + ret = miscdeviceProxy_->Vibrate(vibrateIdentifier, timeOut, usage, systemUsage); WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_VIBRATE, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -146,8 +146,8 @@ int32_t VibratorServiceClient::Vibrate(const VibratorParams ¶ms, int32_t vib return ret; } -int32_t VibratorServiceClient::Vibrate(const VibratorParams ¶ms, int32_t vibratorId, const std::string &effect, - int32_t loopCount, int32_t usage, bool systemUsage) +int32_t VibratorServiceClient::Vibrate(const VibratorIdentifier &identifier, const std::string &effect, + int32_t loopCount, int32_t usage, bool systemUsage) { MISC_HILOGD("Vibrate begin, effect:%{public}s, loopCount:%{public}d, usage:%{public}d", effect.c_str(), loopCount, usage); @@ -161,10 +161,10 @@ int32_t VibratorServiceClient::Vibrate(const VibratorParams ¶ms, int32_t vib #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "VibrateEffect"); #endif // HIVIEWDFX_HITRACE_ENABLE - VibratorParamsIPC vibrateParams; - vibrateParams.deviceId = params.deviceId; - vibrateParams.vibratorId = params.vibratorId; - ret = miscdeviceProxy_->PlayVibratorEffect(vibrateParams, vibratorId, effect, loopCount, usage, systemUsage); + VibratorIdentifierIPC vibrateIdentifier; + vibrateIdentifier.deviceId = identifier.deviceId; + vibrateIdentifier.vibratorId = identifier.vibratorId; + ret = miscdeviceProxy_->PlayVibratorEffect(vibrateIdentifier, effect, loopCount, usage, systemUsage); WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_PLAY_VIBRATOR_EFFECT, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -177,8 +177,8 @@ int32_t VibratorServiceClient::Vibrate(const VibratorParams ¶ms, int32_t vib } #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -int32_t VibratorServiceClient::PlayVibratorCustom(const VibratorParams ¶ms, int32_t vibratorId, const RawFileDescriptor &rawFd, int32_t usage, - bool systemUsage, const VibratorParameter ¶meter) +int32_t VibratorServiceClient::PlayVibratorCustom(const VibratorIdentifier &identifier, const RawFileDescriptor &rawFd, + int32_t usage, bool systemUsage, const VibratorParameter ¶meter) { MISC_HILOGD("Vibrate begin, fd:%{public}d, offset:%{public}lld, length:%{public}lld, usage:%{public}d", rawFd.fd, static_cast(rawFd.offset), static_cast(rawFd.length), usage); @@ -195,10 +195,10 @@ int32_t VibratorServiceClient::PlayVibratorCustom(const VibratorParams ¶ms, VibrateParameter vibateParameter; vibateParameter.intensity = parameter.intensity; vibateParameter.frequency = parameter.frequency; - VibratorParamsIPC vibrateParams; - vibrateParams.deviceId = params.deviceId; - vibrateParams.vibratorId = params.vibratorId; - ret = miscdeviceProxy_->PlayVibratorCustom(vibrateParams, vibratorId, rawFd.fd, rawFd.offset, + VibratorIdentifierIPC vibrateIdentifier; + vibrateIdentifier.deviceId = identifier.deviceId; + vibrateIdentifier.vibratorId = identifier.vibratorId; + ret = miscdeviceProxy_->PlayVibratorCustom(vibrateIdentifier, rawFd.fd, rawFd.offset, rawFd.length, usage, systemUsage, vibateParameter); WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_PLAY_VIBRATOR_CUSTOM, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE @@ -211,9 +211,10 @@ int32_t VibratorServiceClient::PlayVibratorCustom(const VibratorParams ¶ms, } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -int32_t VibratorServiceClient::StopVibrator(const VibratorParams ¶ms, int32_t vibratorId, const std::string &mode) +int32_t VibratorServiceClient::StopVibrator(const VibratorIdentifier &identifier, const std::string &mode) { - MISC_HILOGD("StopVibrator begin, vibratorId:%{public}d, mode:%{public}s", vibratorId, mode.c_str()); + MISC_HILOGD("StopVibrator begin, deviceId:%{public}d, vibratorId:%{public}d, mode:%{public}s", identifier.deviceId, + identifier.vibratorId, mode.c_str()); int32_t ret = InitServiceClient(); if (ret != ERR_OK) { MISC_HILOGE("InitServiceClient failed, ret:%{public}d", ret); @@ -224,10 +225,10 @@ int32_t VibratorServiceClient::StopVibrator(const VibratorParams ¶ms, int32_ #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "StopVibratorByMode"); #endif // HIVIEWDFX_HITRACE_ENABLE - VibratorParamsIPC vibrateParams; - vibrateParams.deviceId = params.deviceId; - vibrateParams.vibratorId = params.vibratorId; - ret = miscdeviceProxy_->StopVibratorByMode(vibrateParams, vibratorId, mode); + VibratorIdentifierIPC vibrateIdentifier; + vibrateIdentifier.deviceId = identifier.deviceId; + vibrateIdentifier.vibratorId = identifier.vibratorId; + ret = miscdeviceProxy_->StopVibratorByMode(vibrateIdentifier, mode); WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_STOP_VIBRATOR_BY_MODE, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -238,9 +239,10 @@ int32_t VibratorServiceClient::StopVibrator(const VibratorParams ¶ms, int32_ return ret; } -int32_t VibratorServiceClient::StopVibrator(const VibratorParams ¶ms, int32_t vibratorId) +int32_t VibratorServiceClient::StopVibrator(const VibratorIdentifier &identifier) { - MISC_HILOGD("StopVibrator begin, vibratorId:%{public}d", vibratorId); + MISC_HILOGD("StopVibrator begin, deviceId:%{public}d, vibratorId:%{public}d", identifier.deviceId, + identifier.vibratorId); int32_t ret = InitServiceClient(); if (ret != ERR_OK) { MISC_HILOGE("InitServiceClient failed, ret:%{public}d", ret); @@ -251,10 +253,10 @@ int32_t VibratorServiceClient::StopVibrator(const VibratorParams ¶ms, int32_ #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "StopVibratorAll"); #endif // HIVIEWDFX_HITRACE_ENABLE - VibratorParamsIPC vibrateParams; - vibrateParams.deviceId = params.deviceId; - vibrateParams.vibratorId = params.vibratorId; - ret = miscdeviceProxy_->StopVibrator(vibrateParams, vibratorId); + VibratorIdentifierIPC vibrateIdentifier; + vibrateIdentifier.deviceId = identifier.deviceId; + vibrateIdentifier.vibratorId = identifier.vibratorId; + ret = miscdeviceProxy_->StopVibrator(vibrateIdentifier); WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_STOP_VIBRATOR, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -265,7 +267,7 @@ int32_t VibratorServiceClient::StopVibrator(const VibratorParams ¶ms, int32_ return ret; } -bool VibratorServiceClient::IsHdHapticSupported(const VibratorParams ¶ms) +bool VibratorServiceClient::IsHdHapticSupported(const VibratorIdentifier &identifier) { CALL_LOG_ENTER; int32_t ret = InitServiceClient(); @@ -279,17 +281,18 @@ bool VibratorServiceClient::IsHdHapticSupported(const VibratorParams ¶ms) #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "IsHdHapticSupported"); #endif // HIVIEWDFX_HITRACE_ENABLE - ret = GetVibratorCapacity(params, capacity_); + ret = GetVibratorCapacity(identifier, capacity_); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE if (ret != ERR_OK) { - MISC_HILOGE("Is hd haptic supported, ret:%{public}d", ret); + MISC_HILOGE("IsHdHapticSupported failed, ret:%{public}d", ret); } return capacity_.isSupportHdHaptic; } -int32_t VibratorServiceClient::IsSupportEffect(const VibratorParams ¶ms, const std::string &effect, bool &state) +int32_t VibratorServiceClient::IsSupportEffect(const VibratorIdentifier &identifier, const std::string &effect, + bool &state) { MISC_HILOGD("IsSupportEffect begin, effect:%{public}s", effect.c_str()); int32_t ret = InitServiceClient(); @@ -302,10 +305,10 @@ int32_t VibratorServiceClient::IsSupportEffect(const VibratorParams ¶ms, con #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "VibrateEffect"); #endif // HIVIEWDFX_HITRACE_ENABLE - VibratorParamsIPC vibrateParams; - vibrateParams.deviceId = params.deviceId; - vibrateParams.vibratorId = params.vibratorId; - ret = miscdeviceProxy_->IsSupportEffect(vibrateParams, effect, state); + VibratorIdentifierIPC vibrateIdentifier; + vibrateIdentifier.deviceId = identifier.deviceId; + vibrateIdentifier.vibratorId = identifier.vibratorId; + ret = miscdeviceProxy_->IsSupportEffect(vibrateIdentifier, effect, state); WriteOtherHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_IS_SUPPORT_EFFECT, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -391,7 +394,7 @@ int32_t VibratorServiceClient::PreProcess(const VibratorFileDescription &fd, Vib return ConvertVibratorPackage(pkg, package); } -int32_t VibratorServiceClient::GetDelayTime(const VibratorParams ¶ms, int32_t &delayTime) +int32_t VibratorServiceClient::GetDelayTime(const VibratorIdentifier &identifier, int32_t &delayTime) { int32_t ret = InitServiceClient(); if (ret != ERR_OK) { @@ -403,10 +406,10 @@ int32_t VibratorServiceClient::GetDelayTime(const VibratorParams ¶ms, int32_ #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "GetDelayTime"); #endif // HIVIEWDFX_HITRACE_ENABLE - VibratorParamsIPC vibrateParams; - vibrateParams.deviceId = params.deviceId; - vibrateParams.vibratorId = params.vibratorId; - ret = miscdeviceProxy_->GetDelayTime(vibrateParams, delayTime); + VibratorIdentifierIPC vibrateIdentifier; + vibrateIdentifier.deviceId = identifier.deviceId; + vibrateIdentifier.vibratorId = identifier.vibratorId; + ret = miscdeviceProxy_->GetDelayTime(vibrateIdentifier, delayTime); WriteOtherHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_GET_DELAY_TIME, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -417,8 +420,8 @@ int32_t VibratorServiceClient::GetDelayTime(const VibratorParams ¶ms, int32_ return ret; } -int32_t VibratorServiceClient::InitPlayPattern(const VibratorParams ¶ms, const VibratorPattern &pattern, int32_t usage, - bool systemUsage, const VibratorParameter ¶meter) +int32_t VibratorServiceClient::InitPlayPattern(const VibratorIdentifier &identifier, const VibratorPattern &pattern, + int32_t usage, bool systemUsage, const VibratorParameter ¶meter) { VibratePattern vibratePattern = {}; vibratePattern.startTime = pattern.time; @@ -451,18 +454,18 @@ int32_t VibratorServiceClient::InitPlayPattern(const VibratorParams ¶ms, con VibrateParameter vibateParameter; vibateParameter.intensity = parameter.intensity; vibateParameter.frequency = parameter.frequency; - VibratorParamsIPC vibrateParams; - vibrateParams.deviceId = params.deviceId; - vibrateParams.vibratorId = params.vibratorId; + VibratorIdentifierIPC vibrateIdentifier; + vibrateIdentifier.deviceId = identifier.deviceId; + vibrateIdentifier.vibratorId = identifier.vibratorId; std::lock_guard clientLock(clientMutex_); CHKPR(miscdeviceProxy_, ERROR); - int32_t ret = miscdeviceProxy_->PlayPattern(vibrateParams, vibratePattern, usage, systemUsage, vibateParameter); + int32_t ret = miscdeviceProxy_->PlayPattern(vibrateIdentifier, vibratePattern, usage, systemUsage, vibateParameter); WriteOtherHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_PLAY_PATTERN, ret); return ret; } -int32_t VibratorServiceClient::PlayPattern(const VibratorParams ¶ms, const VibratorPattern &pattern, int32_t usage, - bool systemUsage, const VibratorParameter ¶meter) +int32_t VibratorServiceClient::PlayPattern(const VibratorIdentifier &identifier, const VibratorPattern &pattern, + int32_t usage, bool systemUsage, const VibratorParameter ¶meter) { MISC_HILOGD("Vibrate begin, usage:%{public}d", usage); int32_t ret = InitServiceClient(); @@ -473,7 +476,7 @@ int32_t VibratorServiceClient::PlayPattern(const VibratorParams ¶ms, const V #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "PlayPattern"); #endif // HIVIEWDFX_HITRACE_ENABLE - ret = InitPlayPattern(params, pattern, usage, systemUsage, parameter); + ret = InitPlayPattern(identifier, pattern, usage, systemUsage, parameter); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE @@ -565,8 +568,8 @@ int32_t VibratorServiceClient::FreeVibratorPackage(VibratorPackage &package) return ERR_OK; } -int32_t VibratorServiceClient::PlayPrimitiveEffect(const VibratorParams ¶ms, int32_t vibratorId, const std::string &effect, int32_t intensity, - int32_t usage, bool systemUsage, int32_t count) +int32_t VibratorServiceClient::PlayPrimitiveEffect(const VibratorIdentifier &identifier, const std::string &effect, + int32_t intensity, int32_t usage, bool systemUsage, int32_t count) { MISC_HILOGD("Vibrate begin, effect:%{public}s, intensity:%{public}d, usage:%{public}d, count:%{public}d", effect.c_str(), intensity, usage, count); @@ -580,10 +583,10 @@ int32_t VibratorServiceClient::PlayPrimitiveEffect(const VibratorParams ¶ms, #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "PlayPrimitiveEffect"); #endif // HIVIEWDFX_HITRACE_ENABLE - VibratorParamsIPC vibrateParams; - vibrateParams.deviceId = params.deviceId; - vibrateParams.vibratorId = params.vibratorId; - ret = miscdeviceProxy_->PlayPrimitiveEffect(vibrateParams, vibratorId, effect, intensity, usage, systemUsage, count); + VibratorIdentifierIPC vibrateIdentifier; + vibrateIdentifier.deviceId = identifier.deviceId; + vibrateIdentifier.vibratorId = identifier.vibratorId; + ret = miscdeviceProxy_->PlayPrimitiveEffect(vibrateIdentifier, effect, intensity, usage, systemUsage, count); WriteOtherHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_PLAY_PRIMITIVE_EFFECT, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -595,16 +598,16 @@ int32_t VibratorServiceClient::PlayPrimitiveEffect(const VibratorParams ¶ms, return ret; } -int32_t VibratorServiceClient::GetVibratorCapacity(const VibratorParams ¶ms, VibratorCapacity &capacity) +int32_t VibratorServiceClient::GetVibratorCapacity(const VibratorIdentifier &identifier, VibratorCapacity &capacity) { CHKPR(miscdeviceProxy_, ERROR); #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "GetVibratorCapacity"); #endif // HIVIEWDFX_HITRACE_ENABLE - VibratorParamsIPC vibrateParams; - vibrateParams.deviceId = params.deviceId; - vibrateParams.vibratorId = params.vibratorId; - int32_t ret = miscdeviceProxy_->GetVibratorCapacity(vibrateParams, capacity); + VibratorIdentifierIPC vibrateIdentifier; + vibrateIdentifier.deviceId = identifier.deviceId; + vibrateIdentifier.vibratorId = identifier.vibratorId; + int32_t ret = miscdeviceProxy_->GetVibratorCapacity(vibrateIdentifier, capacity); WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode::COMMAND_GET_VIBRATOR_CAPACITY, ret); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); @@ -613,7 +616,7 @@ int32_t VibratorServiceClient::GetVibratorCapacity(const VibratorParams ¶ms, return ret; } -bool VibratorServiceClient::IsSupportVibratorCustom(const VibratorParams ¶ms) +bool VibratorServiceClient::IsSupportVibratorCustom(const VibratorIdentifier &identifier) { MISC_HILOGD("Vibrate begin"); int32_t ret = InitServiceClient(); @@ -627,7 +630,7 @@ bool VibratorServiceClient::IsSupportVibratorCustom(const VibratorParams ¶ms #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "IsSupportVibratorCustom"); #endif // HIVIEWDFX_HITRACE_ENABLE - ret = GetVibratorCapacity(params, capacity_); + ret = GetVibratorCapacity(identifier, capacity_); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE @@ -697,11 +700,11 @@ std::set VibratorServiceClient::GetSubscribeUserCall bool VibratorServiceClient::HandleVibratorData(VibratorDeviceInfo info) __attribute__((no_sanitize("cfi"))) { CALL_LOG_ENTER; - if(info.type == 1) { - std::lock_guard VibratorEffectLock(VibratorEffectMutex_); - for (auto it = VibratorEffectMap_.begin(); it != VibratorEffectMap_.end(); ) { + if(info.type == PLUG_STATE_EVENT_PLUG_OUT) { + std::lock_guard VibratorEffectLock(vibratorEffectMutex_); + for (auto it = vibratorEffectMap_.begin(); it != vibratorEffectMap_.end(); ) { if (it->first.deviceId == info.deviceId) { - it = VibratorEffectMap_.erase(it); + it = vibratorEffectMap_.erase(it); } else { ++it; } @@ -719,54 +722,54 @@ bool VibratorServiceClient::HandleVibratorData(VibratorDeviceInfo info) __attrib return true; } -void VibratorServiceClient::SetUsage(const VibratorParams ¶ms, int32_t usage, bool systemUsage) +void VibratorServiceClient::SetUsage(const VibratorIdentifier &identifier, int32_t usage, bool systemUsage) { - std::lock_guard VibratorEffectLock(VibratorEffectMutex_); - auto it = VibratorEffectMap_.find(params); - if (it != VibratorEffectMap_.end()) { - it->second.g_usage = usage; - it->second.g_systemUsage = systemUsage; + std::lock_guard VibratorEffectLock(vibratorEffectMutex_); + auto it = vibratorEffectMap_.find(identifier); + if (it != vibratorEffectMap_.end()) { + it->second.usage = usage; + it->second.systemUsage = systemUsage; } else { VibratorEffectParameter param = { - .g_usage = usage, - .g_systemUsage = systemUsage, + .usage = usage, + .systemUsage = systemUsage, }; - VibratorEffectMap_[params] = param; + vibratorEffectMap_[identifier] = param; } } -void VibratorServiceClient::SetLoopCount(const VibratorParams ¶ms, int32_t count) +void VibratorServiceClient::SetLoopCount(const VibratorIdentifier &identifier, int32_t count) { - std::lock_guard VibratorEffectLock(VibratorEffectMutex_); - auto it = VibratorEffectMap_.find(params); - if (it != VibratorEffectMap_.end()) { - it->second.g_loopCount = count; + std::lock_guard VibratorEffectLock(vibratorEffectMutex_); + auto it = vibratorEffectMap_.find(identifier); + if (it != vibratorEffectMap_.end()) { + it->second.loopCount = count; } else { VibratorEffectParameter param = { - .g_loopCount = count, + .loopCount = count, }; - VibratorEffectMap_[params] = param; + vibratorEffectMap_[identifier] = param; } } -void VibratorServiceClient::SetParameters(const VibratorParams ¶ms, const VibratorParameter ¶meter) +void VibratorServiceClient::SetParameters(const VibratorIdentifier &identifier, const VibratorParameter ¶meter) { - std::lock_guard VibratorEffectLock(VibratorEffectMutex_); - auto it = VibratorEffectMap_.find(params); - if (it != VibratorEffectMap_.end()) { - it->second.g_vibratorParameter = parameter; + std::lock_guard VibratorEffectLock(vibratorEffectMutex_); + auto it = vibratorEffectMap_.find(identifier); + if (it != vibratorEffectMap_.end()) { + it->second.vibratorParameter = parameter; } else { VibratorEffectParameter param = { - .g_vibratorParameter = parameter, + .vibratorParameter = parameter, }; - VibratorEffectMap_[params] = param; + vibratorEffectMap_[identifier] = param; } } -VibratorEffectParameter VibratorServiceClient::GetVibratorEffectParameter(const VibratorParams ¶ms) { - std::lock_guard VibratorEffectLock(VibratorEffectMutex_); - auto it = VibratorEffectMap_.find(params); - if (it != VibratorEffectMap_.end()) { +VibratorEffectParameter VibratorServiceClient::GetVibratorEffectParameter(const VibratorIdentifier &identifier) { + std::lock_guard VibratorEffectLock(vibratorEffectMutex_); + auto it = vibratorEffectMap_.find(identifier); + if (it != vibratorEffectMap_.end()) { return it->second; } return VibratorEffectParameter(); @@ -862,10 +865,12 @@ bool VibratorServiceClient::SkipEventAndConvertVibratorEvent(const VibratorEvent return false; } -int32_t VibratorServiceClient::GetVibratorIdList(const VibratorParams& params, std::vector& vibratorInfo) +int32_t VibratorServiceClient::GetVibratorIdList(const VibratorIdentifier& identifier, + std::vector& vibratorInfo) { CALL_LOG_ENTER; - MISC_HILOGD("VibratorParams = [deviceId = %{public}d, vibratorId = %{public}d]", params.deviceId, params.vibratorId); + MISC_HILOGD("VibratorIdentifier = [deviceId = %{public}d, vibratorId = %{public}d]", identifier.deviceId, + identifier.vibratorId); int32_t ret = InitServiceClient(); if (ret != ERR_OK) { MISC_HILOGE("InitServiceClient failed, ret:%{public}d", ret); @@ -873,9 +878,9 @@ int32_t VibratorServiceClient::GetVibratorIdList(const VibratorParams& params, s } CHKPR(miscdeviceProxy_, OHOS::Sensors::ERROR); - VibratorParamsIPC param; - param.deviceId = params.deviceId; - param.vibratorId = params.vibratorId; + VibratorIdentifierIPC param; + param.deviceId = identifier.deviceId; + param.vibratorId = identifier.vibratorId; std::vector vibratorInfoList; #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "GetVibratorIdList"); @@ -887,7 +892,7 @@ int32_t VibratorServiceClient::GetVibratorIdList(const VibratorParams& params, s #endif // HIVIEWDFX_HITRACE_ENABLE if (ret != ERR_OK) { MISC_HILOGE("Get vibrator info list failed, [ret = %{public}d, deviceId = %{public}d,\ - vibratorId = %{public}d]", ret, params.deviceId, params.vibratorId); + vibratorId = %{public}d]", ret, identifier.deviceId, identifier.vibratorId); return ret; } VibratorInfos resInfo; @@ -902,22 +907,21 @@ int32_t VibratorServiceClient::GetVibratorIdList(const VibratorParams& params, s return OHOS::Sensors::SUCCESS; } -int32_t VibratorServiceClient::GetEffectInfo(const VibratorParams& params, +int32_t VibratorServiceClient::GetEffectInfo(const VibratorIdentifier& identifier, const std::string& effectType, EffectInfo& effectInfo) { CALL_LOG_ENTER; - MISC_HILOGD("VibratorParams = [deviceId = %{public}d, vibratorId = %{public}d]", - params.deviceId, params.vibratorId); - MISC_HILOGD("effectType = %{public}s", effectType.c_str()); + MISC_HILOGD("VibratorIdentifier = [deviceId = %{public}d, vibratorId = %{public}d, effectType = %{public}s]", + identifier.deviceId, identifier.vibratorId, effectType.c_str()); int32_t ret = InitServiceClient(); if (ret != OHOS::Sensors::SUCCESS) { MISC_HILOGE("InitServiceClient failed, ret:%{public}d", ret); return MISC_NATIVE_GET_SERVICE_ERR; } CHKPR(miscdeviceProxy_, OHOS::Sensors::ERROR); - VibratorParamsIPC param; - param.deviceId = params.deviceId; - param.vibratorId = params.vibratorId; + VibratorIdentifierIPC param; + param.deviceId = identifier.deviceId; + param.vibratorId = identifier.vibratorId; EffectInfoIPC resInfo; #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "GetEffectInfo"); @@ -929,7 +933,7 @@ int32_t VibratorServiceClient::GetEffectInfo(const VibratorParams& params, #endif // HIVIEWDFX_HITRACE_ENABLE if (ret != ERR_OK) { MISC_HILOGE("Get effect info list failed, [ret = %{public}d, deviceId = %{public}d, vibratorId = %{public}d,\ - effectType = %{public}s]", ret, params.deviceId, params.vibratorId, effectType.c_str()); + effectType = %{public}s]", ret, identifier.deviceId, identifier.vibratorId, effectType.c_str()); return ret; } effectInfo.isSupportEffect = resInfo.isSupportEffect; diff --git a/frameworks/native/vibrator/vibrator_agent.cpp b/frameworks/native/vibrator/vibrator_agent.cpp index 8c884db..b95d020 100644 --- a/frameworks/native/vibrator/vibrator_agent.cpp +++ b/frameworks/native/vibrator/vibrator_agent.cpp @@ -27,7 +27,6 @@ namespace Sensors { using OHOS::Sensors::VibratorServiceClient; namespace { -constexpr int32_t DEFAULT_VIBRATOR_ID = 123; const std::string PHONE_TYPE = "phone"; const int32_t INTENSITY_ADJUST_MIN = 0; const int32_t INTENSITY_ADJUST_MAX = 100; @@ -58,44 +57,44 @@ static int32_t NormalizeErrCode(int32_t code) bool SetLoopCount(int32_t count) { - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; - return SetLoopCountEnhanced(params, count); + return SetLoopCountEnhanced(identifier, count); } -bool SetLoopCountEnhanced(const VibratorParams params, int32_t count) +bool SetLoopCountEnhanced(const VibratorIdentifier identifier, int32_t count) { if (count <= 0) { MISC_HILOGE("Input invalid, count is %{public}d", count); return false; } auto &client = VibratorServiceClient::GetInstance(); - client.SetLoopCount(params, count); + client.SetLoopCount(identifier, count); return true; } int32_t StartVibrator(const char *effectId) { - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; - return StartVibratorEnhanced(params, effectId); + return StartVibratorEnhanced(identifier, effectId); } -int32_t StartVibratorEnhanced(const VibratorParams params, const char *effectId) +int32_t StartVibratorEnhanced(const VibratorIdentifier identifier, const char *effectId) { MISC_HILOGD("Time delay measurement:start time"); CHKPR(effectId, PARAMETER_ERROR); auto &client = VibratorServiceClient::GetInstance(); - VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(params); - int32_t ret = client.Vibrate(params, DEFAULT_VIBRATOR_ID, effectId, vibratorEffectParameter.g_loopCount, - vibratorEffectParameter.g_usage, vibratorEffectParameter.g_systemUsage); - client.SetUsage(params, USAGE_UNKNOWN, false); - client.SetLoopCount(params, 1); + VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(identifier); + int32_t ret = client.Vibrate(identifier, effectId, vibratorEffectParameter.loopCount, + vibratorEffectParameter.usage, vibratorEffectParameter.systemUsage); + client.SetUsage(identifier, USAGE_UNKNOWN, false); + client.SetLoopCount(identifier, 1); if (ret != ERR_OK) { MISC_HILOGD("Vibrate effectId failed, ret:%{public}d", ret); return NormalizeErrCode(ret); @@ -105,24 +104,23 @@ int32_t StartVibratorEnhanced(const VibratorParams params, const char *effectId) int32_t StartVibratorOnce(int32_t duration) { - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; - return StartVibratorOnceEnhanced(params, duration); + return StartVibratorOnceEnhanced(identifier, duration); } -int32_t StartVibratorOnceEnhanced(const VibratorParams params, int32_t duration) +int32_t StartVibratorOnceEnhanced(const VibratorIdentifier identifier, int32_t duration) { if (duration <= 0) { MISC_HILOGE("duration is invalid"); return PARAMETER_ERROR; } auto &client = VibratorServiceClient::GetInstance(); - VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(params); - int32_t ret = client.Vibrate(params, DEFAULT_VIBRATOR_ID, duration, vibratorEffectParameter.g_usage, - vibratorEffectParameter.g_systemUsage); - client.SetUsage(params, USAGE_UNKNOWN, false); + VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(identifier); + int32_t ret = client.Vibrate(identifier, duration, vibratorEffectParameter.usage, vibratorEffectParameter.systemUsage); + client.SetUsage(identifier, USAGE_UNKNOWN, false); if (ret != ERR_OK) { MISC_HILOGD("Vibrate duration failed, ret:%{public}d", ret); return NormalizeErrCode(ret); @@ -132,29 +130,29 @@ int32_t StartVibratorOnceEnhanced(const VibratorParams params, int32_t duration) bool IsSupportVibratorCustom() { - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; - return IsSupportVibratorCustomEnhanced(params); + return IsSupportVibratorCustomEnhanced(identifier); } -bool IsSupportVibratorCustomEnhanced(const VibratorParams params) +bool IsSupportVibratorCustomEnhanced(const VibratorIdentifier identifier) { auto &client = VibratorServiceClient::GetInstance(); - return client.IsSupportVibratorCustom(params); + return client.IsSupportVibratorCustom(identifier); } int32_t PlayVibratorCustom(int32_t fd, int64_t offset, int64_t length) { - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; - return PlayVibratorCustomEnhanced(params, fd, offset, length); + return PlayVibratorCustomEnhanced(identifier, fd, offset, length); } -int32_t PlayVibratorCustomEnhanced(const VibratorParams params, int32_t fd, int64_t offset, int64_t length) +int32_t PlayVibratorCustomEnhanced(const VibratorIdentifier identifier, int32_t fd, int64_t offset, int64_t length) { #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM MISC_HILOGD("Time delay measurement:start time"); @@ -169,13 +167,13 @@ int32_t PlayVibratorCustomEnhanced(const VibratorParams params, int32_t fd, int6 .offset = offset, .length = length }; - VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(params); - int32_t ret = client.PlayVibratorCustom(params, DEFAULT_VIBRATOR_ID, rawFd, vibratorEffectParameter.g_usage, - vibratorEffectParameter.g_systemUsage, vibratorEffectParameter.g_vibratorParameter); - vibratorEffectParameter.g_vibratorParameter.intensity = INTENSITY_ADJUST_MAX; - vibratorEffectParameter.g_vibratorParameter.frequency = 0; - client.SetUsage(params, USAGE_UNKNOWN, false); - client.SetParameters(params, vibratorEffectParameter.g_vibratorParameter); + VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(identifier); + int32_t ret = client.PlayVibratorCustom(identifier, rawFd, vibratorEffectParameter.usage, + vibratorEffectParameter.systemUsage, vibratorEffectParameter.vibratorParameter); + vibratorEffectParameter.vibratorParameter.intensity = INTENSITY_ADJUST_MAX; + vibratorEffectParameter.vibratorParameter.frequency = 0; + client.SetUsage(identifier, USAGE_UNKNOWN, false); + client.SetParameters(identifier, vibratorEffectParameter.vibratorParameter); if (ret != ERR_OK) { MISC_HILOGD("PlayVibratorCustom failed, ret:%{public}d", ret); return NormalizeErrCode(ret); @@ -189,14 +187,14 @@ int32_t PlayVibratorCustomEnhanced(const VibratorParams params, int32_t fd, int6 int32_t StopVibrator(const char *mode) { - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; - return StopVibratorEnhanced(params, mode); + return StopVibratorEnhanced(identifier, mode); } -int32_t StopVibratorEnhanced(const VibratorParams params, const char *mode) +int32_t StopVibratorEnhanced(const VibratorIdentifier identifier, const char *mode) { CHKPR(mode, PARAMETER_ERROR); if (strcmp(mode, "time") != 0 && strcmp(mode, "preset") != 0) { @@ -204,7 +202,7 @@ int32_t StopVibratorEnhanced(const VibratorParams params, const char *mode) return PARAMETER_ERROR; } auto &client = VibratorServiceClient::GetInstance(); - int32_t ret = client.StopVibrator(params, DEFAULT_VIBRATOR_ID, mode); + int32_t ret = client.StopVibrator(identifier, mode); if (ret != ERR_OK) { MISC_HILOGD("StopVibrator by mode failed, ret:%{public}d, mode:%{public}s", ret, mode); return NormalizeErrCode(ret); @@ -214,17 +212,17 @@ int32_t StopVibratorEnhanced(const VibratorParams params, const char *mode) int32_t Cancel() { - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; - return CancelEnhanced(params); + return CancelEnhanced(identifier); } -int32_t CancelEnhanced(const VibratorParams params) +int32_t CancelEnhanced(const VibratorIdentifier identifier) { auto &client = VibratorServiceClient::GetInstance(); - int32_t ret = client.StopVibrator(params, DEFAULT_VIBRATOR_ID); + int32_t ret = client.StopVibrator(identifier); if (ret != ERR_OK) { MISC_HILOGD("StopVibrator failed, ret:%{public}d", ret); return NormalizeErrCode(ret); @@ -234,53 +232,53 @@ int32_t CancelEnhanced(const VibratorParams params) bool SetUsage(int32_t usage, bool systemUsage) { - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; - return SetUsageEnhanced(params, usage, systemUsage); + return SetUsageEnhanced(identifier, usage, systemUsage); } -bool SetUsageEnhanced(const VibratorParams params, int32_t usage, bool systemUsage) +bool SetUsageEnhanced(const VibratorIdentifier identifier, int32_t usage, bool systemUsage) { if ((usage < 0) || (usage >= USAGE_MAX)) { MISC_HILOGE("Input invalid, usage is %{public}d", usage); return false; } auto &client = VibratorServiceClient::GetInstance(); - client.SetUsage(params, usage, systemUsage); + client.SetUsage(identifier, usage, systemUsage); return true; } bool IsHdHapticSupported() { - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; - return IsHdHapticSupportedEnhanced(params); + return IsHdHapticSupportedEnhanced(identifier); } -bool IsHdHapticSupportedEnhanced(const VibratorParams params) +bool IsHdHapticSupportedEnhanced(const VibratorIdentifier identifier) { auto &client = VibratorServiceClient::GetInstance(); - return client.IsHdHapticSupported(params); + return client.IsHdHapticSupported(identifier); } int32_t IsSupportEffect(const char *effectId, bool *state) { - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; - return IsSupportEffectEnhanced(params, effectId, state); + return IsSupportEffectEnhanced(identifier, effectId, state); } -int32_t IsSupportEffectEnhanced(const VibratorParams params, const char *effectId, bool *state) +int32_t IsSupportEffectEnhanced(const VibratorIdentifier identifier, const char *effectId, bool *state) { CHKPR(effectId, PARAMETER_ERROR); auto &client = VibratorServiceClient::GetInstance(); - int32_t ret = client.IsSupportEffect(params, effectId, *state); + int32_t ret = client.IsSupportEffect(identifier, effectId, *state); if (ret != ERR_OK) { MISC_HILOGD("Query effect support failed, ret:%{public}d, effectId:%{public}s", ret, effectId); return NormalizeErrCode(ret); @@ -301,17 +299,17 @@ int32_t PreProcess(const VibratorFileDescription &fd, VibratorPackage &package) int32_t GetDelayTime(int32_t &delayTime) { - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; - return GetDelayTimeEnhanced(params, delayTime); + return GetDelayTimeEnhanced(identifier, delayTime); } -int32_t GetDelayTimeEnhanced(const VibratorParams params, int32_t &delayTime) +int32_t GetDelayTimeEnhanced(const VibratorIdentifier identifier, int32_t &delayTime) { auto &client = VibratorServiceClient::GetInstance(); - int32_t ret = client.GetDelayTime(params, delayTime); + int32_t ret = client.GetDelayTime(identifier, delayTime); if (ret != ERR_OK) { MISC_HILOGD("GetDelayTime failed, ret:%{public}d", ret); return NormalizeErrCode(ret); @@ -321,23 +319,23 @@ int32_t GetDelayTimeEnhanced(const VibratorParams params, int32_t &delayTime) int32_t PlayPattern(const VibratorPattern &pattern) { - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; - return PlayPatternEnhanced(params, pattern); + return PlayPatternEnhanced(identifier, pattern); } -int32_t PlayPatternEnhanced(const VibratorParams params, const VibratorPattern &pattern) +int32_t PlayPatternEnhanced(const VibratorIdentifier identifier, const VibratorPattern &pattern) { auto &client = VibratorServiceClient::GetInstance(); - VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(params); - int32_t ret = client.PlayPattern(params, pattern, vibratorEffectParameter.g_usage, vibratorEffectParameter.g_systemUsage, - vibratorEffectParameter.g_vibratorParameter); - vibratorEffectParameter.g_vibratorParameter.intensity = INTENSITY_ADJUST_MAX; - vibratorEffectParameter.g_vibratorParameter.frequency = 0; - client.SetUsage(params, USAGE_UNKNOWN, false); - client.SetParameters(params, vibratorEffectParameter.g_vibratorParameter); + VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(identifier); + int32_t ret = client.PlayPattern(identifier, pattern, vibratorEffectParameter.usage, vibratorEffectParameter.systemUsage, + vibratorEffectParameter.vibratorParameter); + vibratorEffectParameter.vibratorParameter.intensity = INTENSITY_ADJUST_MAX; + vibratorEffectParameter.vibratorParameter.frequency = 0; + client.SetUsage(identifier, USAGE_UNKNOWN, false); + client.SetParameters(identifier, vibratorEffectParameter.vibratorParameter); if (ret != ERR_OK) { MISC_HILOGD("PlayPattern failed, ret:%{public}d", ret); return NormalizeErrCode(ret); @@ -369,14 +367,14 @@ int32_t FreeVibratorPackage(VibratorPackage &package) bool SetParameters(const VibratorParameter ¶meter) { - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; - return SetParametersEnhanced(params, parameter); + return SetParametersEnhanced(identifier, parameter); } -bool SetParametersEnhanced(const VibratorParams params, const VibratorParameter ¶meter) +bool SetParametersEnhanced(const VibratorIdentifier identifier, const VibratorParameter ¶meter) { if ((parameter.intensity < INTENSITY_ADJUST_MIN) || (parameter.intensity > INTENSITY_ADJUST_MAX) || (parameter.frequency < FREQUENCY_ADJUST_MIN) || (parameter.frequency > FREQUENCY_ADJUST_MAX)) { @@ -385,30 +383,30 @@ bool SetParametersEnhanced(const VibratorParams params, const VibratorParameter return false; } auto &client = VibratorServiceClient::GetInstance(); - client.SetParameters(params, parameter); + client.SetParameters(identifier, parameter); return true; } int32_t PlayPrimitiveEffect(const char *effectId, int32_t intensity) { - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1 }; - return PlayPrimitiveEffectEnhanced(params, effectId, intensity); + return PlayPrimitiveEffectEnhanced(identifier, effectId, intensity); } -int32_t PlayPrimitiveEffectEnhanced(const VibratorParams params, const char *effectId, int32_t intensity) +int32_t PlayPrimitiveEffectEnhanced(const VibratorIdentifier identifier, const char *effectId, int32_t intensity) { MISC_HILOGD("Time delay measurement:start time"); CHKPR(effectId, PARAMETER_ERROR); auto &client = VibratorServiceClient::GetInstance(); - VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(params); - int32_t ret = client.PlayPrimitiveEffect(params, DEFAULT_VIBRATOR_ID, effectId, intensity, - vibratorEffectParameter.g_usage, vibratorEffectParameter.g_systemUsage, - vibratorEffectParameter.g_loopCount); - client.SetUsage(params, USAGE_UNKNOWN, false); - client.SetLoopCount(params, 1); + VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(identifier); + int32_t ret = client.PlayPrimitiveEffect(identifier, effectId, intensity, + vibratorEffectParameter.usage, vibratorEffectParameter.systemUsage, + vibratorEffectParameter.loopCount); + client.SetUsage(identifier, USAGE_UNKNOWN, false); + client.SetLoopCount(identifier, 1); if (ret != ERR_OK) { MISC_HILOGD("Play primitive effect failed, ret:%{public}d", ret); return NormalizeErrCode(ret); @@ -416,11 +414,11 @@ int32_t PlayPrimitiveEffectEnhanced(const VibratorParams params, const char *eff return SUCCESS; } -int32_t GetVibratorIdList(const VibratorParams& param, std::vector& vibratorInfo) +int32_t GetVibratorIdList(const VibratorIdentifier& param, std::vector& vibratorInfo) { CALL_LOG_ENTER; CHKCR(¶m, PARAMETER_ERROR, "Invalid parameters"); - MISC_HILOGD("VibratorParams = [deviceId = %{public}d, vibratorId = %{public}d]", param.deviceId, param.vibratorId); + MISC_HILOGD("VibratorIdentifier = [deviceId = %{public}d, vibratorId = %{public}d]", param.deviceId, param.vibratorId); auto &client = VibratorServiceClient::GetInstance(); int32_t ret = client.GetVibratorIdList(param, vibratorInfo); if (ret != ERR_OK) { @@ -430,11 +428,11 @@ int32_t GetVibratorIdList(const VibratorParams& param, std::vector0 if the vibrator vibrates as expected; returns -1 otherwise, for example, the given * duration for the one-shot vibration is invalid. * * @since 18 */ -int32_t StartVibratorOnceEnhanced(const VibratorParams param, int32_t duration); +int32_t StartVibratorOnceEnhanced(const VibratorIdentifier identifier, int32_t duration); /** * @brief Query whether the device supports custom vibration. - * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in * {@link vibrator_agent_type.h}. * @return Returning true indicates support; otherwise, it indicates no support. * * @since 18 */ -bool IsSupportVibratorCustomEnhanced(const VibratorParams param); +bool IsSupportVibratorCustomEnhanced(const VibratorIdentifier identifier); /** * @brief Play a custom vibration sequence. * - * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in * {@link vibrator_agent_type.h}. * @param fd Indicates the file handle for custom vibration sequence. * @param offset Indicates the starting address (in bytes) of the custom vibration sequence. @@ -270,63 +270,63 @@ bool IsSupportVibratorCustomEnhanced(const VibratorParams param); * * @since 18 */ -int32_t PlayVibratorCustomEnhanced(const VibratorParams param, int32_t fd, int64_t offset, int64_t length); +int32_t PlayVibratorCustomEnhanced(const VibratorIdentifier identifier, int32_t fd, int64_t offset, int64_t length); /** * @brief Sets the number of cycles for vibration. - * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in * {@link vibrator_agent_type.h}. * @param count Indicates the number of cycles for vibration. * @since 18 */ -bool SetLoopCountEnhanced(const VibratorParams param, int32_t count); +bool SetLoopCountEnhanced(const VibratorIdentifier identifier, int32_t count); /** * @brief Stop the motor vibration according to the input mode. * - * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in * {@link vibrator_agent_type.h}. * @param mode Indicates the mode of the vibration to stop. The values can be time and preset, * respectively representing a one-shot vibration mode and a preset vibration mode. * @return Returns 0 if the vibration is stopped as expected; returns -1 otherwise. * @since 18 */ -int32_t StopVibratorEnhanced(const VibratorParams param, const char *mode); +int32_t StopVibratorEnhanced(const VibratorIdentifier identifier, const char *mode); /** * @brief Cancel the current motor vibration. - * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in * {@link vibrator_agent_type.h}. * @return Returning 0 indicates success; otherwise, it indicates failure. * @since 18 */ -int32_t CancelEnhanced(const VibratorParams param); +int32_t CancelEnhanced(const VibratorIdentifier identifier); /** * @brief Set the usage of vibration. * - * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in * {@link vibrator_agent_type.h}. * @param usage Indicates the vibration usage, which is described in {@link vibrator_agent_type.h},for * example:{@link USAGE_ALARM}: Describes the vibration is used for alarm. * @since 18 */ -bool SetUsageEnhanced(const VibratorParams param, int32_t usage, bool systemUsage = false); +bool SetUsageEnhanced(const VibratorIdentifier identifier, int32_t usage, bool systemUsage = false); /** * @brief Query whether the HdHaptic is supported. - * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in * {@link vibrator_agent_type.h}. * @return Returning true indicates support; otherwise, it indicates no support. * * @since 18 */ -bool IsHdHapticSupportedEnhanced(const VibratorParams param); +bool IsHdHapticSupportedEnhanced(const VibratorIdentifier identifier); /** * @brief Query whether a vibration effect is supported. * - * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in * {@link vibrator_agent_type.h}. * @param effectId Indicates the preset vibration effect, which is described in {@link vibrator_agent_type.h}, for * example:{@link VIBRATOR_TYPE_CLOCK_TIMER}: Describes the vibration effect of the vibrator when a user adjusts the @@ -336,45 +336,45 @@ bool IsHdHapticSupportedEnhanced(const VibratorParams param); * * @since 18 */ -int32_t IsSupportEffectEnhanced(const VibratorParams param, const char *effectId, bool *state); +int32_t IsSupportEffectEnhanced(const VibratorIdentifier identifier, const char *effectId, bool *state); /** * @brief Obtain the vibration delay, the time interval from the time the vibration is issued * to the time when the vibration is started, which can be used in the scene of sound * and vibration coordination. - * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in * {@link vibrator_agent_type.h}. * @param delayTime: Out of the parameter, return the vibration time delay, the time interval * from the time the vibration is issued to the start of the vibration, in milliseconds. * @return 0 indicates success, otherwise indicates failure. * @since 18 */ -int32_t GetDelayTimeEnhanced(const VibratorParams param, int32_t &delayTime); +int32_t GetDelayTimeEnhanced(const VibratorIdentifier identifier, int32_t &delayTime); /** * @brief Play the vibration sequence. - * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in * {@link vibrator_agent_type.h}. * @param pattern: Vibration sequences, such as {@link VibratorPattern}. * @return 0 indicates success, otherwise indicates failure. * @since 18 */ -int32_t PlayPatternEnhanced(const VibratorParams params, const VibratorPattern &pattern); +int32_t PlayPatternEnhanced(const VibratorIdentifier identifier, const VibratorPattern &pattern); /** * @brief Set the vibration effect adjustment parameters. - * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in * {@link vibrator_agent_type.h}. * @param parameter: Vibration adjustment parameter, such as {@link VibratorParameter}. * @return true indicates success, otherwise indicates failure. * @since 18 */ -bool SetParametersEnhanced(const VibratorParams param, const VibratorParameter ¶meter); +bool SetParametersEnhanced(const VibratorIdentifier identifier, const VibratorParameter ¶meter); /** * @brief Control the vibrator to perform vibration with a preset vibration effect at a certain intensity. * - * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in * {@link vibrator_agent_type.h}. * @param effectId Indicates the preset vibration effect, which is described in {@link vibrator_agent_type.h}, for * example:{@link VIBRATOR_TYPE_HARD}: Describes the hard vibration effect of the vibrator. @@ -383,14 +383,14 @@ bool SetParametersEnhanced(const VibratorParams param, const VibratorParameter & * * @since 18 */ -int32_t PlayPrimitiveEffectEnhanced(const VibratorParams param, const char *effectId, int32_t intensity); +int32_t PlayPrimitiveEffectEnhanced(const VibratorIdentifier identifier, const char *effectId, int32_t intensity); /** * @brief Retrieve a list of vibrator IDs available for the specified parameters. * * This function fetches the identifiers of all vibrators that match the given parameters. * - * @param param Indicate the device and vibrator information that needs to be controlled, which is described in + * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in * {@link vibrator_agent_type.h}. * @param vibratorInfo A reference to a vector that will be populated with available vibrator information, * each represented as a `VibratorInfos` structure. @@ -398,7 +398,7 @@ int32_t PlayPrimitiveEffectEnhanced(const VibratorParams param, const char *effe * * @since 18 */ -int32_t GetVibratorIdList(const VibratorParams& param, std::vector& vibratorInfo); +int32_t GetVibratorIdList(const VibratorIdentifier& identifier, std::vector& vibratorInfo); /** * @brief Retrieve information about a specific vibration effect type. @@ -406,7 +406,7 @@ int32_t GetVibratorIdList(const VibratorParams& param, std::vector wareInfo); + CustomVibrationMatcher(const VibratorIdentifierIPC& identifier, std::vector wareInfo); #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR int32_t TransformTime(const VibratePackage &package, std::vector &compositeEffects); int32_t TransformEffect(const VibratePackage &package, std::vector &compositeEffects); diff --git a/services/miscdevice_service/haptic_matcher/src/custom_vibration_matcher.cpp b/services/miscdevice_service/haptic_matcher/src/custom_vibration_matcher.cpp index e1ef862..43bfea8 100644 --- a/services/miscdevice_service/haptic_matcher/src/custom_vibration_matcher.cpp +++ b/services/miscdevice_service/haptic_matcher/src/custom_vibration_matcher.cpp @@ -54,10 +54,10 @@ CustomVibrationMatcher::CustomVibrationMatcher() { #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR auto &VibratorDevice = VibratorHdiConnection::GetInstance(); - VibratorParamsIPC params; - params.deviceId = -1; - params.vibratorId = -1; - int32_t ret = VibratorDevice.GetAllWaveInfo(params, hdfWaveInfos_); + VibratorIdentifierIPC identifier; + identifier.deviceId = -1; + identifier.vibratorId = -1; + int32_t ret = VibratorDevice.GetAllWaveInfo(identifier, hdfWaveInfos_); if (ret != ERR_OK) { MISC_HILOGE("GetAllWaveInfo failed infoSize:%{public}zu", hdfWaveInfos_.size()); return; @@ -71,9 +71,9 @@ CustomVibrationMatcher::CustomVibrationMatcher() } } -CustomVibrationMatcher::CustomVibrationMatcher(const VibratorParamsIPC& params, std::vector wareInfo) +CustomVibrationMatcher::CustomVibrationMatcher(const VibratorIdentifierIPC& identifier, std::vector waveInfo) { - hdfWaveInfos_ = wareInfo; + hdfWaveInfos_ = waveInfo; if (!hdfWaveInfos_.empty()) { for (auto it = hdfWaveInfos_.begin(); it != hdfWaveInfos_.end(); ++it) { MISC_HILOGI("waveId:%{public}d, intensity:%{public}f, frequency:%{public}f, duration:%{public}d", diff --git a/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h b/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h index 802b1e5..22faf7a 100644 --- a/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h +++ b/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h @@ -27,27 +27,27 @@ public: CompatibleConnection() = default; virtual ~CompatibleConnection() {}; int32_t ConnectHdi() override; - int32_t StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) override; - int32_t Start(const VibratorParamsIPC ¶ms, const std::string &effectType) override; + int32_t StartOnce(const VibratorIdentifierIPC &identifier, uint32_t duration) override; + int32_t Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - int32_t EnableCompositeEffect(const VibratorParamsIPC ¶ms, const HdfCompositeEffect &hdfCompositeEffect) override; - bool IsVibratorRunning(const VibratorParamsIPC ¶ms) override; + int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier, const HdfCompositeEffect &hdfCompositeEffect) override; + bool IsVibratorRunning(const VibratorIdentifierIPC &identifier) override; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - std::optional GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effect) override; - int32_t Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) override; + std::optional GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effect) override; + int32_t Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR - int32_t GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) override; - int32_t GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) override; - int32_t PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) override; + int32_t GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) override; + int32_t GetVibratorCapacity(const VibratorIdentifierIPC &identifier, VibratorCapacity &capacity) override; + int32_t PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) override; int32_t DestroyHdiConnection() override; - int32_t StartByIntensity(const VibratorParamsIPC ¶ms, const std::string &effect, int32_t intensity) override; + int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, int32_t intensity) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR int32_t GetVibratorInfo(std::vector &hdfVibratorInfo) override; - int32_t GetAllWaveInfo(const VibratorParamsIPC ¶ms, std::vector &waveInfos) override; - int32_t GetVibratorIdList(const VibratorParamsIPC ¶ms, std::vector &vibratorInfoIpc) override; - int32_t GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, - HdfEffectInfo &effectInfo) override; + int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier, std::vector &waveInfos) override; + int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier, std::vector &vibratorInfoIpc) override; + int32_t GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, + HdfEffectInfo &effectInfo) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR int32_t RegisterVibratorPlugCallback(DevicePlugCallback cb) override; DevicePlugCallback GetVibratorPlugCb() override; diff --git a/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h b/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h index a50007c..1e138dd 100644 --- a/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h +++ b/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h @@ -33,28 +33,28 @@ public: HdiConnection() = default; virtual ~HdiConnection() {}; int32_t ConnectHdi() override; - int32_t StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) override; - int32_t Start(const VibratorParamsIPC ¶ms, const std::string &effectType) override; + int32_t StartOnce(const VibratorIdentifierIPC &identifier, uint32_t duration) override; + int32_t Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - int32_t EnableCompositeEffect(const VibratorParamsIPC ¶ms, const HdfCompositeEffect &hdfCompositeEffect) override; - bool IsVibratorRunning(const VibratorParamsIPC ¶ms) override; + int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier, const HdfCompositeEffect &hdfCompositeEffect) override; + bool IsVibratorRunning(const VibratorIdentifierIPC &identifier) override; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - std::optional GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effect) override; - int32_t Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) override; + std::optional GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effect) override; + int32_t Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR - int32_t GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) override; - int32_t GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) override; - int32_t PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) override; + int32_t GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) override; + int32_t GetVibratorCapacity(const VibratorIdentifierIPC &identifier, VibratorCapacity &capacity) override; + int32_t PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) override; int32_t DestroyHdiConnection() override; void ProcessDeathObserver(const wptr &object); - int32_t StartByIntensity(const VibratorParamsIPC ¶ms, const std::string &effect, int32_t intensity) override; + int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, int32_t intensity) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR int32_t GetVibratorInfo(std::vector &hdfVibratorInfo) override; - int32_t GetAllWaveInfo(const VibratorParamsIPC ¶ms, std::vector &waveInfos) override; - int32_t GetVibratorIdList(const VibratorParamsIPC ¶ms, std::vector &vibratorInfoIpc) override; - int32_t GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, - HdfEffectInfo &effectInfo) override; + int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier, std::vector &waveInfos) override; + int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier, std::vector &vibratorInfoIpc) override; + int32_t GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, + HdfEffectInfo &effectInfo) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR int32_t RegisterVibratorPlugCallback(DevicePlugCallback cb) override; DevicePlugCallback GetVibratorPlugCb() override; diff --git a/services/miscdevice_service/hdi_connection/adapter/include/vibrator_plug_callback.h b/services/miscdevice_service/hdi_connection/adapter/include/vibrator_plug_callback.h index 461f273..463f4a3 100644 --- a/services/miscdevice_service/hdi_connection/adapter/include/vibrator_plug_callback.h +++ b/services/miscdevice_service/hdi_connection/adapter/include/vibrator_plug_callback.h @@ -16,10 +16,6 @@ #ifndef VIBRATOR_PLUG_CALLBACK_H #define VIBRATOR_PLUG_CALLBACK_H - #include - #include - #include - #include #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #include "v2_0/ivibrator_interface.h" diff --git a/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp b/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp index d9d85d0..377ebfb 100644 --- a/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp +++ b/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp @@ -56,7 +56,7 @@ int32_t CompatibleConnection::ConnectHdi() return ERR_OK; } -int32_t CompatibleConnection::StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) +int32_t CompatibleConnection::StartOnce(const VibratorIdentifierIPC &identifier, uint32_t duration) { CALL_LOG_ENTER; duration_ = static_cast(duration); @@ -71,7 +71,7 @@ int32_t CompatibleConnection::StartOnce(const VibratorParamsIPC ¶ms, uint32_ return ERR_OK; } -int32_t CompatibleConnection::Start(const VibratorParamsIPC ¶ms, const std::string &effectType) +int32_t CompatibleConnection::Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) { CALL_LOG_ENTER; if (g_vibratorEffect.find(effectType) == g_vibratorEffect.end()) { @@ -93,7 +93,7 @@ int32_t CompatibleConnection::Start(const VibratorParamsIPC ¶ms, const std:: #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -int32_t CompatibleConnection::EnableCompositeEffect(const VibratorParamsIPC ¶ms, +int32_t CompatibleConnection::EnableCompositeEffect(const VibratorIdentifierIPC &identifier, const HdfCompositeEffect &hdfCompositeEffect) { CALL_LOG_ENTER; @@ -119,14 +119,14 @@ int32_t CompatibleConnection::EnableCompositeEffect(const VibratorParamsIPC &par return ERR_OK; } -bool CompatibleConnection::IsVibratorRunning(const VibratorParamsIPC ¶ms) +bool CompatibleConnection::IsVibratorRunning(const VibratorIdentifierIPC &identifier) { CALL_LOG_ENTER; return (!isStop_); } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -std::optional CompatibleConnection::GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effect) +std::optional CompatibleConnection::GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effect) { CALL_LOG_ENTER; HdfEffectInfo effectInfo; @@ -141,7 +141,7 @@ std::optional CompatibleConnection::GetEffectInfo(const VibratorP return effectInfo; } -int32_t CompatibleConnection::Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) +int32_t CompatibleConnection::Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) { CALL_LOG_ENTER; if (mode < 0 || mode >= HDF_VIBRATOR_MODE_BUTT) { @@ -161,19 +161,19 @@ int32_t CompatibleConnection::Stop(const VibratorParamsIPC ¶ms, HdfVibratorM } #endif // HDF_DRIVERS_INTERFACE_VIBRATOR -int32_t CompatibleConnection::GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) +int32_t CompatibleConnection::GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) { CALL_LOG_ENTER; delayTime = VIBRATE_DELAY_TIME; return ERR_OK; } -int32_t CompatibleConnection::GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) +int32_t CompatibleConnection::GetVibratorCapacity(const VibratorIdentifierIPC &identifier, VibratorCapacity &capacity) { return ERR_OK; } -int32_t CompatibleConnection::PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) +int32_t CompatibleConnection::PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) { return ERR_OK; } @@ -199,7 +199,7 @@ void CompatibleConnection::VibrateProcess() return; } -int32_t CompatibleConnection::StartByIntensity(const VibratorParamsIPC ¶ms, const std::string &effect, int32_t intensity) +int32_t CompatibleConnection::StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, int32_t intensity) { CALL_LOG_ENTER; if (g_vibratorEffect.find(effect) == g_vibratorEffect.end()) { @@ -223,20 +223,20 @@ int32_t CompatibleConnection::GetVibratorInfo(std::vector &hdfV { return ERR_OK; } -int32_t CompatibleConnection::GetAllWaveInfo(const VibratorParamsIPC ¶ms, +int32_t CompatibleConnection::GetAllWaveInfo(const VibratorIdentifierIPC &identifier, std::vector &waveInfos) { return ERR_OK; } -int32_t CompatibleConnection::GetVibratorIdList(const VibratorParamsIPC ¶ms, +int32_t CompatibleConnection::GetVibratorIdList(const VibratorIdentifierIPC &identifier, std::vector &vibratorInfoIpc) { CALL_LOG_ENTER; return ERR_OK; } -int32_t CompatibleConnection::GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, +int32_t CompatibleConnection::GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, HdfEffectInfo &effectInfo) { CALL_LOG_ENTER; diff --git a/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp b/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp index 75030cd..b3d8cda 100644 --- a/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp +++ b/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp @@ -61,10 +61,10 @@ int32_t HdiConnection::ConnectHdi() return ERR_INVALID_VALUE; } -int32_t HdiConnection::StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) +int32_t HdiConnection::StartOnce(const VibratorIdentifierIPC &identifier, uint32_t duration) { CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->StartOnce(params.deviceId, params.vibratorId, duration); + int32_t ret = vibratorInterface_->StartOnce(identifier.deviceId, identifier.vibratorId, duration); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -76,7 +76,7 @@ int32_t HdiConnection::StartOnce(const VibratorParamsIPC ¶ms, uint32_t durat return ERR_OK; } -int32_t HdiConnection::Start(const VibratorParamsIPC ¶ms, const std::string &effectType) +int32_t HdiConnection::Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) { MISC_HILOGD("Time delay measurement:end time"); if (effectType.empty()) { @@ -84,7 +84,7 @@ int32_t HdiConnection::Start(const VibratorParamsIPC ¶ms, const std::string return VIBRATOR_ON_ERR; } CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->Start(params.deviceId, params.vibratorId, effectType); + int32_t ret = vibratorInterface_->Start(identifier.deviceId, identifier.vibratorId, effectType); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -97,7 +97,7 @@ int32_t HdiConnection::Start(const VibratorParamsIPC ¶ms, const std::string } #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -int32_t HdiConnection::EnableCompositeEffect(const VibratorParamsIPC ¶ms, const HdfCompositeEffect &hdfCompositeEffect) +int32_t HdiConnection::EnableCompositeEffect(const VibratorIdentifierIPC &identifier, const HdfCompositeEffect &hdfCompositeEffect) { MISC_HILOGD("Time delay measurement:end time"); if (hdfCompositeEffect.compositeEffects.empty()) { @@ -105,7 +105,7 @@ int32_t HdiConnection::EnableCompositeEffect(const VibratorParamsIPC ¶ms, co return VIBRATOR_ON_ERR; } CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->EnableCompositeEffect(params.deviceId, params.vibratorId, hdfCompositeEffect); + int32_t ret = vibratorInterface_->EnableCompositeEffect(identifier.deviceId, identifier.vibratorId, hdfCompositeEffect); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -117,23 +117,23 @@ int32_t HdiConnection::EnableCompositeEffect(const VibratorParamsIPC ¶ms, co return ERR_OK; } -bool HdiConnection::IsVibratorRunning(const VibratorParamsIPC ¶ms) +bool HdiConnection::IsVibratorRunning(const VibratorIdentifierIPC &identifier) { bool state = false; CHKPR(vibratorInterface_, false); - vibratorInterface_->IsVibratorRunning(params.deviceId, params.vibratorId, state); + vibratorInterface_->IsVibratorRunning(identifier.deviceId, identifier.vibratorId, state); return state; } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -std::optional HdiConnection::GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effect) +std::optional HdiConnection::GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effect) { if (vibratorInterface_ == nullptr) { MISC_HILOGE("Connect v1_1 hdi failed"); return std::nullopt; } HdfEffectInfo effectInfo; - int32_t ret = vibratorInterface_->GetEffectInfo(params.deviceId, params.vibratorId, effect, effectInfo); + int32_t ret = vibratorInterface_->GetEffectInfo(identifier.deviceId, identifier.vibratorId, effect, effectInfo); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -145,10 +145,10 @@ std::optional HdiConnection::GetEffectInfo(const VibratorParamsIP return effectInfo; } -int32_t HdiConnection::Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) +int32_t HdiConnection::Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) { CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->Stop(params.deviceId, params.vibratorId, mode); + int32_t ret = vibratorInterface_->Stop(identifier.deviceId, identifier.vibratorId, mode); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -160,10 +160,10 @@ int32_t HdiConnection::Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mod return ERR_OK; } -int32_t HdiConnection::GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) +int32_t HdiConnection::GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) { CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->GetHapticStartUpTime(params.deviceId, params.vibratorId, mode, delayTime); + int32_t ret = vibratorInterface_->GetHapticStartUpTime(identifier.deviceId, identifier.vibratorId, mode, delayTime); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -175,11 +175,11 @@ int32_t HdiConnection::GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mod return ERR_OK; } -int32_t HdiConnection::GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) +int32_t HdiConnection::GetVibratorCapacity(const VibratorIdentifierIPC &identifier, VibratorCapacity &capacity) { CHKPR(vibratorInterface_, ERR_INVALID_VALUE); HapticCapacity hapticCapacity; - int32_t ret = vibratorInterface_->GetHapticCapacity(params.deviceId, hapticCapacity); + int32_t ret = vibratorInterface_->GetHapticCapacity(identifier.deviceId, hapticCapacity); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -195,7 +195,7 @@ int32_t HdiConnection::GetVibratorCapacity(const VibratorParamsIPC ¶ms, Vibr return ERR_OK; } -int32_t HdiConnection::PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) +int32_t HdiConnection::PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) { CHKPR(vibratorInterface_, ERR_INVALID_VALUE); HapticPaket packet = {}; @@ -221,7 +221,7 @@ int32_t HdiConnection::PlayPattern(const VibratorParamsIPC ¶ms, const Vibrat } packet.events.emplace_back(hapticEvent); } - int32_t ret = vibratorInterface_->PlayHapticPattern(params.deviceId, packet); + int32_t ret = vibratorInterface_->PlayHapticPattern(identifier.deviceId, packet); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -299,7 +299,7 @@ void HdiConnection::Reconnect() } } -int32_t HdiConnection::StartByIntensity(const VibratorParamsIPC ¶ms, const std::string &effect, int32_t intensity) +int32_t HdiConnection::StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, int32_t intensity) { MISC_HILOGD("Time delay measurement:end time, effect:%{public}s, intensity:%{public}d", effect.c_str(), intensity); if (effect.empty()) { @@ -307,7 +307,7 @@ int32_t HdiConnection::StartByIntensity(const VibratorParamsIPC ¶ms, const s return VIBRATOR_ON_ERR; } CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->StartByIntensity(params.deviceId, params.vibratorId, effect, intensity); + int32_t ret = vibratorInterface_->StartByIntensity(identifier.deviceId, identifier.vibratorId, effect, intensity); if (ret < 0) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_HDF_SERVICE_EXCEPTION", @@ -329,32 +329,32 @@ int32_t HdiConnection::GetVibratorInfo(std::vector &hdfVibrator return ret; } -int32_t HdiConnection::GetAllWaveInfo(const VibratorParamsIPC ¶ms, std::vector &waveInfos) +int32_t HdiConnection::GetAllWaveInfo(const VibratorIdentifierIPC &identifier, std::vector &waveInfos) { CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->GetAllWaveInfo(params.deviceId, params.vibratorId, waveInfos); + int32_t ret = vibratorInterface_->GetAllWaveInfo(identifier.deviceId, identifier.vibratorId, waveInfos); if (ret != ERR_OK) { MISC_HILOGE("GetAllWaveInfo failed"); } return ret; } -int32_t HdiConnection::GetVibratorIdList(const VibratorParamsIPC ¶ms, +int32_t HdiConnection::GetVibratorIdList(const VibratorIdentifierIPC &identifier, std::vector &vibratorInfo) { CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->GetVibratorIdSingle(params.deviceId, vibratorInfo); + int32_t ret = vibratorInterface_->GetVibratorIdSingle(identifier.deviceId, vibratorInfo); if (ret != ERR_OK) { MISC_HILOGE("GetVibratorIdList failed"); } return ret; } -int32_t HdiConnection::GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, +int32_t HdiConnection::GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, HdfEffectInfo &effectInfo) { CHKPR(vibratorInterface_, ERR_INVALID_VALUE); - int32_t ret = vibratorInterface_->GetEffectInfo(params.deviceId, params.vibratorId, effectType, effectInfo); + int32_t ret = vibratorInterface_->GetEffectInfo(identifier.deviceId, identifier.vibratorId, effectType, effectInfo); if (ret != ERR_OK) { MISC_HILOGE("GetVibratorIdList failed"); } diff --git a/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h b/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h index ebacfd6..ed445cf 100644 --- a/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h +++ b/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h @@ -54,26 +54,26 @@ public: IVibratorHdiConnection() = default; virtual ~IVibratorHdiConnection() = default; virtual int32_t ConnectHdi() = 0; - virtual int32_t StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) = 0; - virtual int32_t Start(const VibratorParamsIPC ¶ms, const std::string &effectType) = 0; + virtual int32_t StartOnce(const VibratorIdentifierIPC &identifier, uint32_t duration) = 0; + virtual int32_t Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) = 0; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - virtual int32_t EnableCompositeEffect(const VibratorParamsIPC ¶ms, const HdfCompositeEffect &hdfCompositeEffect) = 0; - virtual bool IsVibratorRunning(const VibratorParamsIPC ¶ms) = 0; + virtual int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier, const HdfCompositeEffect &hdfCompositeEffect) = 0; + virtual bool IsVibratorRunning(const VibratorIdentifierIPC &identifier) = 0; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - virtual std::optional GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effect) = 0; - virtual int32_t Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) = 0; + virtual std::optional GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effect) = 0; + virtual int32_t Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) = 0; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR virtual int32_t DestroyHdiConnection() = 0; - virtual int32_t GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) = 0; - virtual int32_t GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) = 0; - virtual int32_t PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) = 0; - virtual int32_t StartByIntensity(const VibratorParamsIPC ¶ms, const std::string &effect, int32_t intensity) = 0; + virtual int32_t GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) = 0; + virtual int32_t GetVibratorCapacity(const VibratorIdentifierIPC &identifier, VibratorCapacity &capacity) = 0; + virtual int32_t PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) = 0; + virtual int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, int32_t intensity) = 0; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR virtual int32_t GetVibratorInfo(std::vector &hdfVibratorInfo) = 0; - virtual int32_t GetAllWaveInfo(const VibratorParamsIPC ¶ms, std::vector &waveInfos) = 0; - virtual int32_t GetVibratorIdList(const VibratorParamsIPC ¶ms, std::vector &hdfVibratorInfo) = 0; - virtual int32_t GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, HdfEffectInfo &effectInfo) = 0; + virtual int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier, std::vector &waveInfos) = 0; + virtual int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier, std::vector &hdfVibratorInfo) = 0; + virtual int32_t GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, HdfEffectInfo &effectInfo) = 0; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR virtual int32_t RegisterVibratorPlugCallback(DevicePlugCallback cb) = 0; virtual DevicePlugCallback GetVibratorPlugCb() = 0; diff --git a/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h b/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h index 7c2122b..ae1021a 100644 --- a/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h +++ b/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h @@ -27,26 +27,26 @@ public: VibratorHdiConnection() = default; virtual ~VibratorHdiConnection() {} int32_t ConnectHdi() override; - int32_t StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) override; - int32_t Start(const VibratorParamsIPC ¶ms, const std::string &effectType) override; + int32_t StartOnce(const VibratorIdentifierIPC &identifier, uint32_t duration) override; + int32_t Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - int32_t EnableCompositeEffect(const VibratorParamsIPC ¶ms, const HdfCompositeEffect &hdfCompositeEffect) override; - bool IsVibratorRunning(const VibratorParamsIPC ¶ms) override; + int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier, const HdfCompositeEffect &hdfCompositeEffect) override; + bool IsVibratorRunning(const VibratorIdentifierIPC &identifier) override; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - std::optional GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effect) override; - int32_t Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) override; + std::optional GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effect) override; + int32_t Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR int32_t DestroyHdiConnection() override; - int32_t GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) override; - int32_t GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) override; - int32_t PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) override; - int32_t StartByIntensity(const VibratorParamsIPC ¶ms, const std::string &effect, int32_t intensity) override; + int32_t GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) override; + int32_t GetVibratorCapacity(const VibratorIdentifierIPC &identifier, VibratorCapacity &capacity) override; + int32_t PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) override; + int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, int32_t intensity) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR int32_t GetVibratorInfo(std::vector &hdfVibratorInfo) override; - int32_t GetAllWaveInfo(const VibratorParamsIPC ¶ms, std::vector &waveInfos) override; - int32_t GetVibratorIdList(const VibratorParamsIPC ¶ms, std::vector &hdfVibratorInfo) override; - int32_t GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, HdfEffectInfo &effectInfo) override; + int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier, std::vector &waveInfos) override; + int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier, std::vector &hdfVibratorInfo) override; + int32_t GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, HdfEffectInfo &effectInfo) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR int32_t RegisterVibratorPlugCallback(DevicePlugCallback cb) override; DevicePlugCallback GetVibratorPlugCb() override; diff --git a/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp b/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp index 949b0ed..6cdf8f2 100644 --- a/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp +++ b/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp @@ -50,13 +50,13 @@ int32_t VibratorHdiConnection::ConnectHdi() return ret; } -int32_t VibratorHdiConnection::StartOnce(const VibratorParamsIPC ¶ms, uint32_t duration) +int32_t VibratorHdiConnection::StartOnce(const VibratorIdentifierIPC &identifier, uint32_t duration) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "StartOnce"); #endif // HIVIEWDFX_HITRACE_ENABLE - int32_t ret = iVibratorHdiConnection_->StartOnce(params, duration); + int32_t ret = iVibratorHdiConnection_->StartOnce(identifier, duration); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE @@ -67,13 +67,13 @@ int32_t VibratorHdiConnection::StartOnce(const VibratorParamsIPC ¶ms, uint32 return ERR_OK; } -int32_t VibratorHdiConnection::Start(const VibratorParamsIPC ¶ms, const std::string &effectType) +int32_t VibratorHdiConnection::Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "Start"); #endif // HIVIEWDFX_HITRACE_ENABLE - int32_t ret = iVibratorHdiConnection_->Start(params, effectType); + int32_t ret = iVibratorHdiConnection_->Start(identifier, effectType); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE @@ -86,14 +86,14 @@ int32_t VibratorHdiConnection::Start(const VibratorParamsIPC ¶ms, const std: #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -int32_t VibratorHdiConnection::EnableCompositeEffect(const VibratorParamsIPC ¶ms, +int32_t VibratorHdiConnection::EnableCompositeEffect(const VibratorIdentifierIPC &identifier, const HdfCompositeEffect &hdfCompositeEffect) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "EnableCompositeEffect"); #endif // HIVIEWDFX_HITRACE_ENABLE - int32_t ret = iVibratorHdiConnection_->EnableCompositeEffect(params, hdfCompositeEffect); + int32_t ret = iVibratorHdiConnection_->EnableCompositeEffect(identifier, hdfCompositeEffect); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE @@ -104,14 +104,14 @@ int32_t VibratorHdiConnection::EnableCompositeEffect(const VibratorParamsIPC &pa return ERR_OK; } -bool VibratorHdiConnection::IsVibratorRunning(const VibratorParamsIPC ¶ms) +bool VibratorHdiConnection::IsVibratorRunning(const VibratorIdentifierIPC &identifier) { CHKPR(iVibratorHdiConnection_, false); - return iVibratorHdiConnection_->IsVibratorRunning(params); + return iVibratorHdiConnection_->IsVibratorRunning(identifier); } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -std::optional VibratorHdiConnection::GetEffectInfo(const VibratorParamsIPC ¶ms, +std::optional VibratorHdiConnection::GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effect) { if (iVibratorHdiConnection_ == nullptr) { @@ -121,20 +121,20 @@ std::optional VibratorHdiConnection::GetEffectInfo(const Vibrator #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "GetEffectInfo"); #endif // HIVIEWDFX_HITRACE_ENABLE - std::optional ret = iVibratorHdiConnection_->GetEffectInfo(params, effect); + std::optional ret = iVibratorHdiConnection_->GetEffectInfo(identifier, effect); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE return ret; } -int32_t VibratorHdiConnection::Stop(const VibratorParamsIPC ¶ms, HdfVibratorMode mode) +int32_t VibratorHdiConnection::Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "Stop"); #endif // HIVIEWDFX_HITRACE_ENABLE - int32_t ret = iVibratorHdiConnection_->Stop(params, mode); + int32_t ret = iVibratorHdiConnection_->Stop(identifier, mode); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE @@ -146,22 +146,22 @@ int32_t VibratorHdiConnection::Stop(const VibratorParamsIPC ¶ms, HdfVibrator } #endif // HDF_DRIVERS_INTERFACE_VIBRATOR -int32_t VibratorHdiConnection::GetDelayTime(const VibratorParamsIPC ¶ms, int32_t mode, int32_t &delayTime) +int32_t VibratorHdiConnection::GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); - return iVibratorHdiConnection_->GetDelayTime(params, mode, delayTime); + return iVibratorHdiConnection_->GetDelayTime(identifier, mode, delayTime); } -int32_t VibratorHdiConnection::GetVibratorCapacity(const VibratorParamsIPC ¶ms, VibratorCapacity &capacity) +int32_t VibratorHdiConnection::GetVibratorCapacity(const VibratorIdentifierIPC &identifier, VibratorCapacity &capacity) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); - return iVibratorHdiConnection_->GetVibratorCapacity(params, capacity); + return iVibratorHdiConnection_->GetVibratorCapacity(identifier, capacity); } -int32_t VibratorHdiConnection::PlayPattern(const VibratorParamsIPC ¶ms, const VibratePattern &pattern) +int32_t VibratorHdiConnection::PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); - return iVibratorHdiConnection_->PlayPattern(params, pattern); + return iVibratorHdiConnection_->PlayPattern(identifier, pattern); } int32_t VibratorHdiConnection::DestroyHdiConnection() @@ -175,14 +175,14 @@ int32_t VibratorHdiConnection::DestroyHdiConnection() return ERR_OK; } -int32_t VibratorHdiConnection::StartByIntensity(const VibratorParamsIPC ¶ms, +int32_t VibratorHdiConnection::StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, int32_t intensity) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); #ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "StartByIntensity"); #endif // HIVIEWDFX_HITRACE_ENABLE - int32_t ret = iVibratorHdiConnection_->StartByIntensity(params, effect, intensity); + int32_t ret = iVibratorHdiConnection_->StartByIntensity(identifier, effect, intensity); #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE @@ -200,22 +200,22 @@ int32_t VibratorHdiConnection::GetVibratorInfo(std::vector &hdf return iVibratorHdiConnection_->GetVibratorInfo(hdfVibratorInfo); } -int32_t VibratorHdiConnection::GetAllWaveInfo(const VibratorParamsIPC ¶ms, std::vector &waveInfos) +int32_t VibratorHdiConnection::GetAllWaveInfo(const VibratorIdentifierIPC &identifier, std::vector &waveInfos) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); - return iVibratorHdiConnection_->GetAllWaveInfo(params, waveInfos); + return iVibratorHdiConnection_->GetAllWaveInfo(identifier, waveInfos); } -int32_t VibratorHdiConnection::GetVibratorIdList(const VibratorParamsIPC ¶ms, std::vector &vibratorInfo) +int32_t VibratorHdiConnection::GetVibratorIdList(const VibratorIdentifierIPC &identifier, std::vector &vibratorInfo) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); - return iVibratorHdiConnection_->GetVibratorIdList(params, vibratorInfo); + return iVibratorHdiConnection_->GetVibratorIdList(identifier, vibratorInfo); } -int32_t VibratorHdiConnection::GetEffectInfo(const VibratorParamsIPC ¶ms, const std::string &effectType, HdfEffectInfo &effectInfo) +int32_t VibratorHdiConnection::GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, HdfEffectInfo &effectInfo) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); - return iVibratorHdiConnection_->GetEffectInfo(params, effectType, effectInfo); + return iVibratorHdiConnection_->GetEffectInfo(identifier, effectType, effectInfo); } #endif // HDF_DRIVERS_INTERFACE_VIBRATOR diff --git a/services/miscdevice_service/include/miscdevice_service.h b/services/miscdevice_service/include/miscdevice_service.h index 6ebd336..75d3343 100644 --- a/services/miscdevice_service/include/miscdevice_service.h +++ b/services/miscdevice_service/include/miscdevice_service.h @@ -76,43 +76,45 @@ public: bool IsLightAnimationValid(const LightAnimationIPC &animation); int32_t Dump(int32_t fd, const std::vector &args) override; void ProcessDeathObserver(const wptr &object); - virtual int32_t Vibrate(const VibratorParamsIPC& params, int32_t vibratorId, int32_t timeOut, - int32_t usage, bool systemUsage) override; - virtual int32_t PlayVibratorEffect(const VibratorParamsIPC& params, int32_t vibratorId, const std::string &effect, - int32_t loopCount, int32_t usage, bool systemUsage) override; + virtual int32_t Vibrate(const VibratorIdentifierIPC& identifier, int32_t timeOut, + int32_t usage, bool systemUsage) override; + virtual int32_t PlayVibratorEffect(const VibratorIdentifierIPC& identifier, const std::string &effect, + int32_t loopCount, int32_t usage, bool systemUsage) override; #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - virtual int32_t PlayVibratorCustom(const VibratorParamsIPC& params, int32_t vibratorId, int32_t fd, int64_t offset, - int64_t length, int32_t usage, bool systemUsage, const VibrateParameter ¶meter) override; + virtual int32_t PlayVibratorCustom(const VibratorIdentifierIPC& identifier, int32_t fd, int64_t offset, + int64_t length, int32_t usage, bool systemUsage, const VibrateParameter ¶meter) override; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - virtual int32_t StopVibrator(const VibratorParamsIPC& params, int32_t vibratorId) override; - virtual int32_t StopVibratorByMode(const VibratorParamsIPC& params, int32_t vibratorId, - const std::string &mode) override; - virtual int32_t IsSupportEffect(const VibratorParamsIPC& params, const std::string &effect, bool &state) override; + virtual int32_t StopVibrator(const VibratorIdentifierIPC& identifier) override; + virtual int32_t StopVibratorByMode(const VibratorIdentifierIPC& identifier, const std::string &mode) override; + virtual int32_t IsSupportEffect(const VibratorIdentifierIPC& identifier, const std::string &effect, + bool &state) override; virtual int32_t GetLightList(std::vector &lightInfoIpcList) override; virtual int32_t TurnOn(int32_t lightId, int32_t singleColor, const LightAnimationIPC &animation) override; virtual int32_t TurnOff(int32_t lightId) override; - virtual int32_t PlayPattern(const VibratorParamsIPC& params, const VibratePattern &pattern, int32_t usage, + virtual int32_t PlayPattern(const VibratorIdentifierIPC& identifier, const VibratePattern &pattern, int32_t usage, bool systemUsage, const VibrateParameter ¶meter) override; - virtual int32_t GetDelayTime(const VibratorParamsIPC& params, int32_t &delayTime) override; + virtual int32_t GetDelayTime(const VibratorIdentifierIPC& identifier, int32_t &delayTime) override; virtual int32_t TransferClientRemoteObject(const sptr &vibratorServiceClient) override; - virtual int32_t PlayPrimitiveEffect(const VibratorParamsIPC& params, int32_t vibratorId, const std::string &effect, - int32_t intensity, int32_t usage, bool systemUsage, int32_t count) override; - virtual int32_t GetVibratorCapacity(const VibratorParamsIPC& params, VibratorCapacity &capacity) override; - virtual int32_t GetVibratorIdList(const VibratorParamsIPC& params, std::vector& vibratorInfoIPC) override; - virtual int32_t GetEffectInfo(const VibratorParamsIPC& params, const std::string& effectType, EffectInfoIPC& effectInfoIPC) override; + virtual int32_t PlayPrimitiveEffect(const VibratorIdentifierIPC& identifier, const std::string &effect, + int32_t intensity, int32_t usage, bool systemUsage, int32_t count) override; + virtual int32_t GetVibratorCapacity(const VibratorIdentifierIPC& identifier, VibratorCapacity &capacity) override; + virtual int32_t GetVibratorIdList(const VibratorIdentifierIPC& identifier, + std::vector& vibratorInfoIPC) override; + virtual int32_t GetEffectInfo(const VibratorIdentifierIPC& identifier, const std::string& effectType, + EffectInfoIPC& effectInfoIPC) override; private: DISALLOW_COPY_AND_MOVE(MiscdeviceService); bool InitInterface(); bool InitLightInterface(); std::string GetPackageName(AccessTokenID tokenId); - void StartVibrateThread(VibrateInfo info, const VibratorParamsIPC& params); - int32_t StopVibratorService(const VibratorParamsIPC& params, int32_t vibratorId); + void StartVibrateThread(VibrateInfo info, const VibratorIdentifierIPC& identifier); + int32_t StopVibratorService(const VibratorIdentifierIPC& identifier); void SendMsgToClient(HdfVibratorPlugInfo info); int32_t RegisterVibratorPlugCb(); - std::shared_ptr GetVibratorThread(const VibratorParamsIPC& params); + std::shared_ptr GetVibratorThread(const VibratorIdentifierIPC& identifier); void StopVibrateThread(std::shared_ptr vibratorThread); - bool ShouldIgnoreVibrate(const VibrateInfo &info, const VibratorParamsIPC& params, bool isLocalDevice); + bool ShouldIgnoreVibrate(const VibrateInfo &info, const VibratorIdentifierIPC& identifier, bool isLocalDevice); std::string GetCurrentTime(); void MergeVibratorParmeters(const VibrateParameter ¶meter, VibratePackage &package); bool CheckVibratorParmeters(const VibrateParameter ¶meter); @@ -124,20 +126,21 @@ private: void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; int32_t SubscribeCommonEvent(const std::string &eventName, EventReceiver receiver); void OnReceiveEvent(const EventFwk::CommonEventData &data); - #ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB void OnReceiveUserSwitchEvent(const EventFwk::CommonEventData &data); - #endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB - int32_t CheckAuthAndParam(int32_t usage, const VibrateParameter ¶meter, const VibratorParamsIPC& params); +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB + int32_t CheckAuthAndParam(int32_t usage, const VibrateParameter ¶meter, + const VibratorIdentifierIPC& identifier); int32_t PlayPatternCheckAuthAndParam(int32_t usage, const VibrateParameter ¶meter); int32_t PlayPrimitiveEffectCheckAuthAndParam(int32_t intensity, int32_t usage); int32_t PlayVibratorEffectCheckAuthAndParam(int32_t count, int32_t usage); - int32_t GetHapticCapacityInfo(const VibratorParamsIPC& params, VibratorCapacity& capacityInfo); - int32_t GetAllWaveInfo(const VibratorParamsIPC& params, std::vector& waveInfo); - int32_t GetHapticStartUpTime(const VibratorParamsIPC& params, int32_t mode, int32_t &startUpTime); + int32_t GetHapticCapacityInfo(const VibratorIdentifierIPC& identifier, VibratorCapacity& capacityInfo); + int32_t GetAllWaveInfo(const VibratorIdentifierIPC& identifier, std::vector& waveInfo); + int32_t GetHapticStartUpTime(const VibratorIdentifierIPC& identifier, int32_t mode, int32_t &startUpTime); void FirstGetLocalVibratorInfo(); - std::vector CheckDeviceIdIsValid(const VibratorParamsIPC& params); - int32_t StartVibrateThreadControl(const VibratorParamsIPC& params, VibrateInfo& info); - bool UpdateVibratorAllInfo(const VibratorParamsIPC ¶msIpc, const HdfVibratorPlugInfo &info, + std::vector CheckDeviceIdIsValid(const VibratorIdentifierIPC& identifier); + int32_t StartVibrateThreadControl(const VibratorIdentifierIPC& identifier, VibrateInfo& info); + bool UpdateVibratorAllInfo(const VibratorIdentifierIPC &identifier, const HdfVibratorPlugInfo &info, VibratorAllInfos &vibratorAllInfos); void ConvertToServerInfos(const std::vector &baseVibratorInfo, const VibratorCapacity &vibratorCapacity, const std::vector &waveInfomation, @@ -152,7 +155,6 @@ private: std::vector lightInfos_; std::map miscDeviceIdMap_; MiscdeviceServiceState state_; - //std::shared_ptr vibratorThread_ = nullptr; std::mutex vibratorThreadMutex_; sptr clientDeathObserver_ = nullptr; std::mutex clientDeathObserverMutex_; @@ -161,7 +163,6 @@ private: std::mutex miscDeviceIdMapMutex_; std::mutex lightInfosMutex_; std::mutex devicesManageMutex_; - // std::map devicesManageMap_; }; } // namespace Sensors } // namespace OHOS diff --git a/services/miscdevice_service/include/vibration_priority_manager.h b/services/miscdevice_service/include/vibration_priority_manager.h index acf1411..4dc2527 100644 --- a/services/miscdevice_service/include/vibration_priority_manager.h +++ b/services/miscdevice_service/include/vibration_priority_manager.h @@ -81,7 +81,7 @@ public: DISALLOW_COPY_AND_MOVE(VibrationPriorityManager); bool Init(); VibrateStatus ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo, - std::shared_ptr vibratorThread, const VibratorParamsIPC& params, bool isLocalDevice); + std::shared_ptr vibratorThread, const VibratorIdentifierIPC& identifier, bool isLocalDevice); #ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB void InitDoNotDisturbData(); void UpdateCurrentUserId(); @@ -94,7 +94,7 @@ public: #endif private: - bool IsCurrentVibrate(std::shared_ptr vibratorThread, const VibratorParamsIPC& params) const; + bool IsCurrentVibrate(std::shared_ptr vibratorThread, const VibratorIdentifierIPC& identifier) const; bool IsLoopVibrate(const VibrateInfo &vibrateInfo) const; VibrateStatus ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo, VibrateInfo currentVibrateInfo) const; #ifdef OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD diff --git a/services/miscdevice_service/include/vibrator_thread.h b/services/miscdevice_service/include/vibrator_thread.h index f4ddeb0..d87bdd2 100644 --- a/services/miscdevice_service/include/vibrator_thread.h +++ b/services/miscdevice_service/include/vibrator_thread.h @@ -26,10 +26,10 @@ namespace OHOS { namespace Sensors { class VibratorThread : public Thread { public: - void UpdateVibratorEffect(const VibrateInfo &vibrateInfo, const VibratorParamsIPC& params, + void UpdateVibratorEffect(const VibrateInfo &vibrateInfo, const VibratorIdentifierIPC& identifier, std::vector &waveInfos); VibrateInfo GetCurrentVibrateInfo(); - std::vector GetCurrentWareInfo(); + std::vector GetCurrentWaveInfo(); void SetExitStatus(bool status); void WakeUp(); void ResetVibrateInfo(); @@ -37,22 +37,22 @@ protected: virtual bool Run(); private: - VibratorParamsIPC GetCurrentVibrateParams(); - int32_t PlayOnce(const VibrateInfo &info, const VibratorParamsIPC& params); - int32_t PlayEffect(const VibrateInfo &info, const VibratorParamsIPC& params); - int32_t PlayCustomByHdHptic(const VibrateInfo &info, const VibratorParamsIPC& params); - void HandleMultipleVibrations(const VibratorParamsIPC& params); + VibratorIdentifierIPC GetCurrentVibrateParams(); + int32_t PlayOnce(const VibrateInfo &info, const VibratorIdentifierIPC& identifier); + int32_t PlayEffect(const VibrateInfo &info, const VibratorIdentifierIPC& identifier); + int32_t PlayCustomByHdHptic(const VibrateInfo &info, const VibratorIdentifierIPC& identifier); + void HandleMultipleVibrations(const VibratorIdentifierIPC& identifier); #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - int32_t PlayCustomByCompositeEffect(const VibrateInfo &info, const VibratorParamsIPC& params, - std::vector wareInfo); + int32_t PlayCustomByCompositeEffect(const VibrateInfo &info, const VibratorIdentifierIPC& identifier, + std::vector waveInfo); int32_t PlayCompositeEffect(const VibrateInfo &info, const HdfCompositeEffect &hdfCompositeEffect, - const VibratorParamsIPC& params); + const VibratorIdentifierIPC& identifier); #endif // HDF_DRIVERS_INTERFACE_VIBRATOR std::mutex currentVibrationMutex_; VibrateInfo currentVibration_; std::vector waveInfos_; std::mutex currentVibrateParamsMutex_; - VibratorParamsIPC currentVibrateParams_; + VibratorIdentifierIPC currentVibrateParams_; std::mutex vibrateMutex_; std::condition_variable cv_; std::atomic exitFlag_ = false; diff --git a/services/miscdevice_service/src/miscdevice_service.cpp b/services/miscdevice_service/src/miscdevice_service.cpp index 1eb00be..2edd2e9 100644 --- a/services/miscdevice_service/src/miscdevice_service.cpp +++ b/services/miscdevice_service/src/miscdevice_service.cpp @@ -65,7 +65,6 @@ constexpr int32_t INTENSITY_ADJUST_MAX = 100; constexpr int32_t FREQUENCY_ADJUST_MIN = -100; constexpr int32_t FREQUENCY_ADJUST_MAX = 100; constexpr int32_t INVALID_PID = -1; -constexpr int32_t VIBRATOR_ID = 0; constexpr int32_t BASE_YEAR = 1900; constexpr int32_t BASE_MON = 1; constexpr int32_t CONVERSION_RATE = 1000; @@ -95,10 +94,10 @@ MiscdeviceService::~MiscdeviceService() int deviceId = it->first; const VibratorControlInfo& vibratorControlInfo_ = it->second.controlInfo; MISC_HILOGI("Device ID:%d, Motor Count:%d", deviceId, vibratorControlInfo_.motorCount); - VibratorParamsIPC params; - params.deviceId = deviceId; - params.vibratorId = -1; - StopVibratorService(params, VIBRATOR_ID); + VibratorIdentifierIPC identifier; + identifier.deviceId = deviceId; + identifier.vibratorId = -1; + StopVibratorService(identifier); it = devicesManageMap_.erase(it); } } @@ -353,7 +352,7 @@ void MiscdeviceService::OnStop() #endif // MEMMGR_ENABLE } -bool MiscdeviceService::ShouldIgnoreVibrate(const VibrateInfo &info, const VibratorParamsIPC& params, +bool MiscdeviceService::ShouldIgnoreVibrate(const VibrateInfo &info, const VibratorIdentifierIPC& identifier, bool isLocalDevice) { std::lock_guard lock(isVibrationPriorityReadyMutex_); @@ -362,16 +361,15 @@ bool MiscdeviceService::ShouldIgnoreVibrate(const VibrateInfo &info, const Vibra return VIBRATION; } std::string curVibrateTime = GetCurrentTime(); - auto vibratorThread_ = GetVibratorThread(params); - int32_t ret = PriorityManager->ShouldIgnoreVibrate(info, vibratorThread_, params, isLocalDevice); + auto vibratorThread_ = GetVibratorThread(identifier); + int32_t ret = PriorityManager->ShouldIgnoreVibrate(info, vibratorThread_, identifier, isLocalDevice); if (ret != VIBRATION) { MISC_HILOGE("ShouldIgnoreVibrate currentTime:%{public}s, ret:%{public}d", curVibrateTime.c_str(), ret); } return (ret != VIBRATION); } -int32_t MiscdeviceService::Vibrate(const VibratorParamsIPC& params, int32_t vibratorId, int32_t timeOut, - int32_t usage, bool systemUsage) +int32_t MiscdeviceService::Vibrate(const VibratorIdentifierIPC& identifier, int32_t timeOut, int32_t usage, bool systemUsage) { PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); @@ -401,18 +399,18 @@ int32_t MiscdeviceService::Vibrate(const VibratorParamsIPC& params, int32_t vibr std::string curVibrateTime = GetCurrentTime(); { std::lock_guard lock(devicesManageMutex_); - if (StartVibrateThreadControl(params, info) != ERR_OK) { + if (StartVibrateThreadControl(identifier, info) != ERR_OK) { MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); return ERROR; } } MISC_HILOGI("Start vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, usage:%{public}d," "vibratorId:%{public}d, duration:%{public}d", curVibrateTime.c_str(), info.packageName.c_str(), info.pid, - info.usage, vibratorId, info.duration); + info.usage, identifier.vibratorId, info.duration); return NO_ERROR; } -int32_t MiscdeviceService::StopVibrator(const VibratorParamsIPC& params, int32_t vibratorId) +int32_t MiscdeviceService::StopVibrator(const VibratorIdentifierIPC& identifier) { PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); @@ -425,54 +423,54 @@ int32_t MiscdeviceService::StopVibrator(const VibratorParamsIPC& params, int32_t return PERMISSION_DENIED; } std::lock_guard lock(devicesManageMutex_); - return StopVibratorService(params, vibratorId); + return StopVibratorService(identifier); } -int32_t MiscdeviceService::StopVibratorService(const VibratorParamsIPC& params, int32_t vibratorId) +int32_t MiscdeviceService::StopVibratorService(const VibratorIdentifierIPC& identifier) { std::lock_guard lock(vibratorThreadMutex_); - std::vector result = CheckDeviceIdIsValid(params); + std::vector result = CheckDeviceIdIsValid(identifier); int ignoreVibrateNum = 0; if(result.empty()) { MISC_HILOGD("No vibration, no need to stop"); return ERROR; - }else { - for (const auto& paramIt : result) { - auto vibratorThread_ = GetVibratorThread(paramIt); - #if defined (OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM) && defined (HDF_DRIVERS_INTERFACE_VIBRATOR) - if ((vibratorThread_ == nullptr) || (!vibratorThread_->IsRunning() && - !vibratorHdiConnection_.IsVibratorRunning(paramIt))) { - MISC_HILOGD("No vibration, no need to stop"); - ignoreVibrateNum ++; - continue; - } - if (vibratorHdiConnection_.IsVibratorRunning(paramIt)) { - vibratorHdiConnection_.Stop(paramIt, HDF_VIBRATOR_MODE_PRESET); - vibratorHdiConnection_.Stop(paramIt, HDF_VIBRATOR_MODE_HDHAPTIC); - } - #else - if ((vibratorThread_ == nullptr) || (!vibratorThread_->IsRunning())) { - MISC_HILOGD("No vibration, no need to stop"); - ignoreVibrateNum ++; - continue; - } - #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM && HDF_DRIVERS_INTERFACE_VIBRATOR - StopVibrateThread(vibratorThread_); - } - if(ignoreVibrateNum == result.size()) - { - return ERROR; - } + } + for (const auto& paramIt : result) { + auto vibratorThread_ = GetVibratorThread(paramIt); + #if defined (OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM) && defined (HDF_DRIVERS_INTERFACE_VIBRATOR) + if ((vibratorThread_ == nullptr) || (!vibratorThread_->IsRunning() && + !vibratorHdiConnection_.IsVibratorRunning(paramIt))) { + MISC_HILOGD("No vibration, no need to stop"); + ignoreVibrateNum ++; + continue; + } + if (vibratorHdiConnection_.IsVibratorRunning(paramIt)) { + vibratorHdiConnection_.Stop(paramIt, HDF_VIBRATOR_MODE_PRESET); + vibratorHdiConnection_.Stop(paramIt, HDF_VIBRATOR_MODE_HDHAPTIC); + } + #else + if ((vibratorThread_ == nullptr) || (!vibratorThread_->IsRunning())) { + MISC_HILOGD("No vibration, no need to stop"); + ignoreVibrateNum ++; + continue; + } + #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM && HDF_DRIVERS_INTERFACE_VIBRATOR + StopVibrateThread(vibratorThread_); + } + if(ignoreVibrateNum == result.size()) { + MISC_HILOGD("No vibration, no need to stop"); + return ERROR; } std::string packageName = GetPackageName(GetCallingTokenID()); std::string curVibrateTime = GetCurrentTime(); - MISC_HILOGI("Stop vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, vibratorId:%{public}d", - curVibrateTime.c_str(), packageName.c_str(), GetCallingPid(), vibratorId); + MISC_HILOGI("Stop vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, deviceId:%{public}d," + "vibratorId:%{public}d", curVibrateTime.c_str(), packageName.c_str(), GetCallingPid(), identifier.deviceId, + identifier.vibratorId); return NO_ERROR; } -int32_t MiscdeviceService::PlayVibratorEffect(const VibratorParamsIPC& params, int32_t vibratorId, - const std::string &effect, int32_t count, int32_t usage, bool systemUsage) +int32_t MiscdeviceService::PlayVibratorEffect(const VibratorIdentifierIPC& identifier, const std::string &effect, + int32_t count, int32_t usage, bool systemUsage) { int32_t checkResult = PlayVibratorEffectCheckAuthAndParam(count, usage); if (checkResult != ERR_OK) { @@ -480,7 +478,7 @@ int32_t MiscdeviceService::PlayVibratorEffect(const VibratorParamsIPC& params, i return checkResult; } #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - std::optional effectInfo = vibratorHdiConnection_.GetEffectInfo(params, effect); + std::optional effectInfo = vibratorHdiConnection_.GetEffectInfo(identifier, effect); if (!effectInfo) { MISC_HILOGE("GetEffectInfo fail"); return ERROR; @@ -508,14 +506,14 @@ int32_t MiscdeviceService::PlayVibratorEffect(const VibratorParamsIPC& params, i std::string curVibrateTime = GetCurrentTime(); { std::lock_guard lock(devicesManageMutex_); - if (StartVibrateThreadControl(params, info) != ERR_OK) { + if (StartVibrateThreadControl(identifier, info) != ERR_OK) { MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); return ERROR; } } MISC_HILOGI("Start vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, usage:%{public}d," "vibratorId:%{public}d, duration:%{public}d, effect:%{public}s, count:%{public}d", curVibrateTime.c_str(), - info.packageName.c_str(), info.pid, info.usage, vibratorId, info.duration, info.effect.c_str(), info.count); + info.packageName.c_str(), info.pid, info.usage, identifier.vibratorId, info.duration, info.effect.c_str(), info.count); return NO_ERROR; } @@ -538,27 +536,27 @@ int32_t MiscdeviceService::PlayVibratorEffectCheckAuthAndParam(int32_t count, in return ERR_OK; } -void MiscdeviceService::StartVibrateThread(VibrateInfo info, const VibratorParamsIPC& params) +void MiscdeviceService::StartVibrateThread(VibrateInfo info, const VibratorIdentifierIPC& identifier) { - auto vibratorThread_ = GetVibratorThread(params); + auto vibratorThread_ = GetVibratorThread(identifier); if (vibratorThread_ == nullptr) { MISC_HILOGD("No effective vibrator thread"); return; } StopVibrateThread(vibratorThread_); #if defined (OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM) && defined (HDF_DRIVERS_INTERFACE_VIBRATOR) - if (vibratorHdiConnection_.IsVibratorRunning(params)) { - vibratorHdiConnection_.Stop(params, HDF_VIBRATOR_MODE_PRESET); - vibratorHdiConnection_.Stop(params, HDF_VIBRATOR_MODE_HDHAPTIC); + if (vibratorHdiConnection_.IsVibratorRunning(identifier)) { + vibratorHdiConnection_.Stop(identifier, HDF_VIBRATOR_MODE_PRESET); + vibratorHdiConnection_.Stop(identifier, HDF_VIBRATOR_MODE_HDHAPTIC); } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM && HDF_DRIVERS_INTERFACE_VIBRATOR std::vector waveInfo; - if(GetAllWaveInfo(params, waveInfo) != ERR_OK) + if(GetAllWaveInfo(identifier, waveInfo) != ERR_OK) { MISC_HILOGE("GetAllWaveInfo failed"); return; } - vibratorThread_->UpdateVibratorEffect(info, params, waveInfo); + vibratorThread_->UpdateVibratorEffect(info, identifier, waveInfo); vibratorThread_->Start("VibratorThread"); DumpHelper->SaveVibrateRecord(info); } @@ -574,8 +572,7 @@ void MiscdeviceService::StopVibrateThread(std::shared_ptr vibrat } } -int32_t MiscdeviceService::StopVibratorByMode(const VibratorParamsIPC& params, int32_t vibratorId, - const std::string &mode) +int32_t MiscdeviceService::StopVibratorByMode(const VibratorIdentifierIPC& identifier, const std::string &mode) { std::lock_guard lock(vibratorThreadMutex_); PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); @@ -588,50 +585,51 @@ int32_t MiscdeviceService::StopVibratorByMode(const VibratorParamsIPC& params, i MISC_HILOGE("CheckVibratePermission failed, ret:%{public}d", ret); return PERMISSION_DENIED; } - std::vector result = CheckDeviceIdIsValid(params); + std::vector result = CheckDeviceIdIsValid(identifier); int ignoreVibrateNum = 0; if(result.empty()) { MISC_HILOGD("No vibration, no need to stop"); return ERROR; - }else { - for (const auto& paramIt : result) { - auto vibratorThread_ = GetVibratorThread(paramIt); - if ((vibratorThread_ == nullptr) || (!vibratorThread_->IsRunning())) { + } + for (const auto& paramIt : result) { + auto vibratorThread_ = GetVibratorThread(paramIt); + if ((vibratorThread_ == nullptr) || (!vibratorThread_->IsRunning())) { #if defined (OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM) && defined (HDF_DRIVERS_INTERFACE_VIBRATOR) - if (vibratorHdiConnection_.IsVibratorRunning(paramIt)) { - vibratorHdiConnection_.Stop(paramIt, HDF_VIBRATOR_MODE_PRESET); - vibratorHdiConnection_.Stop(paramIt, HDF_VIBRATOR_MODE_HDHAPTIC); - MISC_HILOGD("StopVibratorByMode"); - return NO_ERROR; - } + if (vibratorHdiConnection_.IsVibratorRunning(paramIt)) { + vibratorHdiConnection_.Stop(paramIt, HDF_VIBRATOR_MODE_PRESET); + vibratorHdiConnection_.Stop(paramIt, HDF_VIBRATOR_MODE_HDHAPTIC); + MISC_HILOGD("StopVibratorByMode"); + return NO_ERROR; + } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM && HDF_DRIVERS_INTERFACE_VIBRATOR - MISC_HILOGD("No vibration, no need to stop"); - ignoreVibrateNum ++; - continue; - } - const VibrateInfo info = vibratorThread_->GetCurrentVibrateInfo(); - if (info.mode != mode) { - MISC_HILOGD("Stop vibration information mismatch"); - continue; - } - StopVibrateThread(vibratorThread_); + MISC_HILOGD("No vibration, no need to stop"); + ignoreVibrateNum ++; + continue; } - if(ignoreVibrateNum == result.size()) - { - return ERROR; + const VibrateInfo info = vibratorThread_->GetCurrentVibrateInfo(); + if (info.mode != mode) { + MISC_HILOGD("Stop vibration information mismatch"); + continue; } + StopVibrateThread(vibratorThread_); + } + if(ignoreVibrateNum == result.size()) { + MISC_HILOGD("No vibration, no need to stop"); + return ERROR; } std::string packageName = GetPackageName(GetCallingTokenID()); std::string curVibrateTime = GetCurrentTime(); - MISC_HILOGI("Stop vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, vibratorId:%{public}d," - "mode:%{public}s", curVibrateTime.c_str(), packageName.c_str(), GetCallingPid(), vibratorId, mode.c_str()); + MISC_HILOGI("Stop vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, vibratorId:%{public}d, \ + mode:%{public}s", curVibrateTime.c_str(), packageName.c_str(), GetCallingPid(), identifier.vibratorId, + mode.c_str()); return NO_ERROR; } -int32_t MiscdeviceService::IsSupportEffect(const VibratorParamsIPC& params, const std::string &effect, bool &state) +int32_t MiscdeviceService::IsSupportEffect(const VibratorIdentifierIPC& identifier, const std::string &effect, + bool &state) { #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - std::optional effectInfo = vibratorHdiConnection_.GetEffectInfo(params, effect); + std::optional effectInfo = vibratorHdiConnection_.GetEffectInfo(identifier, effect); if (!effectInfo) { MISC_HILOGE("GetEffectInfo fail"); return ERROR; @@ -664,10 +662,10 @@ std::string MiscdeviceService::GetCurrentTime() } #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -int32_t MiscdeviceService::PlayVibratorCustom(const VibratorParamsIPC& params, int32_t vibratorId, int32_t fd, +int32_t MiscdeviceService::PlayVibratorCustom(const VibratorIdentifierIPC& identifier, int32_t fd, int64_t offset, int64_t length, int32_t usage, bool systemUsage, const VibrateParameter ¶meter) { - int32_t checkResult = CheckAuthAndParam(usage, parameter, params); + int32_t checkResult = CheckAuthAndParam(usage, parameter, identifier); if (checkResult != ERR_OK) { MISC_HILOGE("CheckAuthAndParam failed, ret:%{public}d", checkResult); return checkResult; @@ -697,7 +695,7 @@ int32_t MiscdeviceService::PlayVibratorCustom(const VibratorParamsIPC& params, i .package = package, }; VibratorCapacity g_capacity; - if(GetHapticCapacityInfo(params, g_capacity) != ERR_OK) + if(GetHapticCapacityInfo(identifier, g_capacity) != ERR_OK) { MISC_HILOGE("GetVibratorCapacity failed"); return ERROR; @@ -713,20 +711,20 @@ int32_t MiscdeviceService::PlayVibratorCustom(const VibratorParamsIPC& params, i std::string curVibrateTime = GetCurrentTime(); { std::lock_guard lock(devicesManageMutex_); - if (StartVibrateThreadControl(params, info) != ERR_OK) { + if (StartVibrateThreadControl(identifier, info) != ERR_OK) { MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); return ERROR; } } MISC_HILOGI("Start vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, usage:%{public}d," "vibratorId:%{public}d, duration:%{public}d", curVibrateTime.c_str(), info.packageName.c_str(), info.pid, - info.usage, vibratorId, package.packageDuration); + info.usage, identifier.vibratorId, package.packageDuration); return NO_ERROR; } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM int32_t MiscdeviceService::CheckAuthAndParam(int32_t usage, const VibrateParameter ¶meter, - const VibratorParamsIPC& params) + const VibratorIdentifierIPC& identifier) { PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); @@ -739,8 +737,7 @@ int32_t MiscdeviceService::CheckAuthAndParam(int32_t usage, const VibrateParamet return PERMISSION_DENIED; } VibratorCapacity g_capacity; - if(GetHapticCapacityInfo(params, g_capacity) != ERR_OK) - { + if(GetHapticCapacityInfo(identifier, g_capacity) != ERR_OK) { MISC_HILOGE("GetVibratorCapacity failed"); return ERROR; } @@ -887,7 +884,7 @@ int32_t MiscdeviceService::Dump(int32_t fd, const std::vector &a return ERR_OK; } -int32_t MiscdeviceService::PlayPattern(const VibratorParamsIPC& params, const VibratePattern &pattern, +int32_t MiscdeviceService::PlayPattern(const VibratorIdentifierIPC& identifier, const VibratePattern &pattern, int32_t usage, bool systemUsage, const VibrateParameter ¶meter) { int32_t checkResult = PlayPatternCheckAuthAndParam(usage, parameter); @@ -913,7 +910,7 @@ int32_t MiscdeviceService::PlayPattern(const VibratorParamsIPC& params, const Vi .systemUsage = systemUsage }; VibratorCapacity g_capacity; - if(GetHapticCapacityInfo(params, g_capacity) != ERR_OK) + if(GetHapticCapacityInfo(identifier, g_capacity) != ERR_OK) { MISC_HILOGE("GetVibratorCapacity failed"); return ERROR; @@ -923,12 +920,12 @@ int32_t MiscdeviceService::PlayPattern(const VibratorParamsIPC& params, const Vi std::string curVibrateTime = GetCurrentTime(); { std::lock_guard lock(devicesManageMutex_); - if (StartVibrateThreadControl(params, info) != ERR_OK) { + if (StartVibrateThreadControl(identifier, info) != ERR_OK) { MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); return ERROR; } } - return vibratorHdiConnection_.PlayPattern(params, package.patterns.front()); + return vibratorHdiConnection_.PlayPattern(identifier, package.patterns.front()); } else if (g_capacity.isSupportPresetMapping) { info.mode = VIBRATE_CUSTOM_COMPOSITE_EFFECT; } else if (g_capacity.isSupportTimeDelay) { @@ -939,7 +936,7 @@ int32_t MiscdeviceService::PlayPattern(const VibratorParamsIPC& params, const Vi std::string curVibrateTime = GetCurrentTime(); { std::lock_guard lock(devicesManageMutex_); - if (StartVibrateThreadControl(params, info) != ERR_OK) { + if (StartVibrateThreadControl(identifier, info) != ERR_OK) { MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); return ERROR; } @@ -969,17 +966,17 @@ int32_t MiscdeviceService::PlayPatternCheckAuthAndParam(int32_t usage, const Vib return ERR_OK; } -int32_t MiscdeviceService::GetDelayTime(const VibratorParamsIPC& params, int32_t &delayTime) +int32_t MiscdeviceService::GetDelayTime(const VibratorIdentifierIPC& identifier, int32_t &delayTime) { std::string packageName = GetPackageName(GetCallingTokenID()); MISC_HILOGD("GetDelayTime, package:%{public}s", packageName.c_str()); VibratorCapacity g_capacity; - if(GetHapticCapacityInfo(params, g_capacity) != ERR_OK) + if(GetHapticCapacityInfo(identifier, g_capacity) != ERR_OK) { MISC_HILOGE("GetVibratorCapacity failed"); return ERROR; } - return vibratorHdiConnection_.GetDelayTime(params, g_capacity.GetVibrateMode(), delayTime); + return vibratorHdiConnection_.GetDelayTime(identifier, g_capacity.GetVibrateMode(), delayTime); } bool MiscdeviceService::CheckVibratorParmeters(const VibrateParameter ¶meter) @@ -1035,20 +1032,20 @@ void MiscdeviceService::SendMsgToClient(HdfVibratorPlugInfo info) if(info.status == 1) { auto it = devicesManageMap_.find(info.deviceId); if (it != devicesManageMap_.end()) { - VibratorParamsIPC params; - params.deviceId = info.deviceId; - params.vibratorId = -1; - StopVibratorService(params, VIBRATOR_ID); + VibratorIdentifierIPC identifier; + identifier.deviceId = info.deviceId; + identifier.vibratorId = -1; + StopVibratorService(identifier); devicesManageMap_.erase(it); MISC_HILOGI("Device %{public}d is offline and removed from the map.", info.deviceId); } else { MISC_HILOGI("Device %{public}d is not in the map, so no action taken.", info.deviceId); } }else { - VibratorParamsIPC params; - params.deviceId = info.deviceId; + VibratorIdentifierIPC identifier; + identifier.deviceId = info.deviceId; VibratorAllInfos newAllInfo({}); - if (!UpdateVibratorAllInfo(params, info, newAllInfo)) { + if (!UpdateVibratorAllInfo(identifier, info, newAllInfo)) { MISC_HILOGE("Update new vibrator info failed"); return; } @@ -1091,10 +1088,10 @@ void MiscdeviceService::ProcessDeathObserver(const wptr &object) int32_t vibratePid = info.pid; MISC_HILOGI("ClientPid:%{public}d, VibratePid:%{public}d", clientPid, vibratePid); if ((clientPid != INVALID_PID) && (clientPid == vibratePid)) { - VibratorParamsIPC params; - params.deviceId = deviceId; - params.vibratorId = motorId; - StopVibratorService(params, VIBRATOR_ID); + VibratorIdentifierIPC identifier; + identifier.deviceId = deviceId; + identifier.vibratorId = motorId; + StopVibratorService(identifier); } } } @@ -1175,7 +1172,7 @@ void MiscdeviceService::DestroyClientPid(const sptr &vibratorServ clientPidMap_.erase(it); } -int32_t MiscdeviceService::PlayPrimitiveEffect(const VibratorParamsIPC& params, int32_t vibratorId, +int32_t MiscdeviceService::PlayPrimitiveEffect(const VibratorIdentifierIPC& identifier, const std::string &effect, int32_t intensity, int32_t usage, bool systemUsage, int32_t count) { int32_t checkResult = PlayPrimitiveEffectCheckAuthAndParam(intensity, usage); @@ -1184,7 +1181,7 @@ int32_t MiscdeviceService::PlayPrimitiveEffect(const VibratorParamsIPC& params, return checkResult; } #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - std::optional effectInfo = vibratorHdiConnection_.GetEffectInfo(params, effect); + std::optional effectInfo = vibratorHdiConnection_.GetEffectInfo(identifier, effect); if (!effectInfo) { MISC_HILOGE("GetEffectInfo fail"); return ERROR; @@ -1212,14 +1209,14 @@ int32_t MiscdeviceService::PlayPrimitiveEffect(const VibratorParamsIPC& params, std::string curVibrateTime = GetCurrentTime(); { std::lock_guard lock(devicesManageMutex_); - if (StartVibrateThreadControl(params, info) != ERR_OK) { + if (StartVibrateThreadControl(identifier, info) != ERR_OK) { MISC_HILOGE("%{public}s:vibration is ignored and high priority is vibrating", curVibrateTime.c_str()); return ERROR; } } MISC_HILOGI("Start vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, usage:%{public}d," "vibratorId:%{public}d, duration:%{public}d, effect:%{public}s", curVibrateTime.c_str(), - info.packageName.c_str(), info.pid, info.usage, vibratorId, info.duration, info.effect.c_str()); + info.packageName.c_str(), info.pid, info.usage, identifier.vibratorId, info.duration, info.effect.c_str()); return NO_ERROR; } @@ -1242,7 +1239,7 @@ int32_t MiscdeviceService::PlayPrimitiveEffectCheckAuthAndParam(int32_t intensit return ERR_OK; } -int32_t MiscdeviceService::GetVibratorIdList(const VibratorParamsIPC& params, +int32_t MiscdeviceService::GetVibratorIdList(const VibratorIdentifierIPC& identifier, std::vector& vibratorInfoIPC) { CALL_LOG_ENTER; @@ -1256,20 +1253,20 @@ int32_t MiscdeviceService::GetVibratorIdList(const VibratorParamsIPC& params, MISC_HILOGE("CheckVibratePermission failed, ret:%{public}d", ret); return PERMISSION_DENIED; } - params.Dump(); + identifier.Dump(); if (devicesManageMap_.empty()) { MISC_HILOGI("No vibrator device online"); return NO_ERROR; } - if ((params.deviceId == -1 && params.vibratorId == -1) || - (params.deviceId == -1 && params.vibratorId != -1)) { + if ((identifier.deviceId == -1 && identifier.vibratorId == -1) || + (identifier.deviceId == -1 && identifier.vibratorId != -1)) { for (auto &value : devicesManageMap_) { vibratorInfoIPC.insert(vibratorInfoIPC.end(), value.second.baseInfo.begin(), value.second.baseInfo.end()); } return NO_ERROR; - } else if (params.deviceId != -1 && params.vibratorId == -1) { - auto it = devicesManageMap_.find(params.deviceId); + } else if (identifier.deviceId != -1 && identifier.vibratorId == -1) { + auto it = devicesManageMap_.find(identifier.deviceId); if (it == devicesManageMap_.end()) { MISC_HILOGD("Device manager map has no vibrator info"); return NO_ERROR; @@ -1277,13 +1274,13 @@ int32_t MiscdeviceService::GetVibratorIdList(const VibratorParamsIPC& params, vibratorInfoIPC = it->second.baseInfo; return NO_ERROR; } else { - auto it = devicesManageMap_.find(params.deviceId); + auto it = devicesManageMap_.find(identifier.deviceId); if (it == devicesManageMap_.end()) { MISC_HILOGD("Device manager map has no vibrator info"); return NO_ERROR; } for (auto &value : it->second.baseInfo) { - if (params.vibratorId == value.vibratorId) { + if (identifier.vibratorId == value.vibratorId) { vibratorInfoIPC.emplace_back(value); } } @@ -1292,7 +1289,7 @@ int32_t MiscdeviceService::GetVibratorIdList(const VibratorParamsIPC& params, return NO_ERROR; } -int32_t MiscdeviceService::GetEffectInfo(const VibratorParamsIPC& params, const std::string& effectType, +int32_t MiscdeviceService::GetEffectInfo(const VibratorIdentifierIPC& identifier, const std::string& effectType, EffectInfoIPC& effectInfoIPC) { CALL_LOG_ENTER; @@ -1306,9 +1303,9 @@ int32_t MiscdeviceService::GetEffectInfo(const VibratorParamsIPC& params, const MISC_HILOGE("CheckVibratePermission failed, ret:%{public}d", ret); return PERMISSION_DENIED; } - params.Dump(); + identifier.Dump(); HdfEffectInfo hdfEffectInfo; - auto ret = vibratorHdiConnection_.GetEffectInfo(params, effectType, hdfEffectInfo); + ret = vibratorHdiConnection_.GetEffectInfo(identifier, effectType, hdfEffectInfo); if (ret != NO_ERROR) { MISC_HILOGE("HDI::GetEffectInfo return error"); return ERROR; @@ -1319,11 +1316,11 @@ int32_t MiscdeviceService::GetEffectInfo(const VibratorParamsIPC& params, const return NO_ERROR; } -int32_t MiscdeviceService::GetVibratorCapacity(const VibratorParamsIPC& params, VibratorCapacity &capacity) +int32_t MiscdeviceService::GetVibratorCapacity(const VibratorIdentifierIPC& identifier, VibratorCapacity &capacity) { CALL_LOG_ENTER; VibratorCapacity g_capacity; - if(GetHapticCapacityInfo(params, g_capacity) != ERR_OK) + if(GetHapticCapacityInfo(identifier, g_capacity) != ERR_OK) { MISC_HILOGE("GetVibratorCapacity failed"); return ERROR; @@ -1332,12 +1329,12 @@ int32_t MiscdeviceService::GetVibratorCapacity(const VibratorParamsIPC& params, return ERR_OK; } -std::shared_ptr MiscdeviceService::GetVibratorThread(const VibratorParamsIPC& params) +std::shared_ptr MiscdeviceService::GetVibratorThread(const VibratorIdentifierIPC& identifier) { CALL_LOG_ENTER; - auto deviceIt = devicesManageMap_.find(params.deviceId); + auto deviceIt = devicesManageMap_.find(identifier.deviceId); if (deviceIt != devicesManageMap_.end()) { - auto thread = deviceIt->second.controlInfo.GetVibratorThread(params.vibratorId); + auto thread = deviceIt->second.controlInfo.GetVibratorThread(identifier.vibratorId); if (thread) { MISC_HILOGI("Success: Vibrate thread found."); return thread; @@ -1349,35 +1346,37 @@ std::shared_ptr MiscdeviceService::GetVibratorThread(const Vibra return nullptr; } -int32_t MiscdeviceService::GetHapticCapacityInfo(const VibratorParamsIPC& params, VibratorCapacity& capacityInfo) +int32_t MiscdeviceService::GetHapticCapacityInfo(const VibratorIdentifierIPC& identifier, VibratorCapacity& capacityInfo) { CALL_LOG_ENTER; std::lock_guard lock(devicesManageMutex_); - auto deviceIt = devicesManageMap_.find(params.deviceId); + auto deviceIt = devicesManageMap_.find(identifier.deviceId); if (deviceIt == devicesManageMap_.end()) { - MISC_HILOGE("No vibrator information found for device ID: %{public}d", params.deviceId); + MISC_HILOGE("No vibrator information found for device ID: %{public}d", identifier.deviceId); return PARAMETER_ERROR; } capacityInfo = deviceIt->second.capacityInfo; return ERR_OK; } -int32_t MiscdeviceService::GetAllWaveInfo(const VibratorParamsIPC& params, std::vector& waveInfo) +int32_t MiscdeviceService::GetAllWaveInfo(const VibratorIdentifierIPC& identifier, + std::vector& waveInfo) { CALL_LOG_ENTER; - auto deviceIt = devicesManageMap_.find(params.deviceId); + auto deviceIt = devicesManageMap_.find(identifier.deviceId); if (deviceIt == devicesManageMap_.end()) { - MISC_HILOGE("No vibrator information found for device ID: %{public}d", params.deviceId); + MISC_HILOGE("No vibrator information found for device ID: %{public}d", identifier.deviceId); return PARAMETER_ERROR; } waveInfo = deviceIt->second.waveInfo; return ERR_OK; } -int32_t MiscdeviceService::GetHapticStartUpTime(const VibratorParamsIPC& params, int32_t mode, int32_t &startUpTime) +int32_t MiscdeviceService::GetHapticStartUpTime(const VibratorIdentifierIPC& identifier, int32_t mode, + int32_t &startUpTime) { CALL_LOG_ENTER; - auto ret = vibratorHdiConnection_.GetDelayTime(params, mode, startUpTime); + auto ret = vibratorHdiConnection_.GetDelayTime(identifier, mode, startUpTime); if (ret != NO_ERROR) { MISC_HILOGE("HDI::GetHapticStartUpTime return error"); return ERROR; @@ -1385,17 +1384,17 @@ int32_t MiscdeviceService::GetHapticStartUpTime(const VibratorParamsIPC& params, return NO_ERROR; } -bool MiscdeviceService::UpdateVibratorAllInfo(const VibratorParamsIPC ¶ms, +bool MiscdeviceService::UpdateVibratorAllInfo(const VibratorIdentifierIPC &identifier, const HdfVibratorPlugInfo &info, VibratorAllInfos &vibratorAllInfos) { CALL_LOG_ENTER; std::vector baseInfo; std::vector vibratorIdList; int32_t ret = -1; - if (params.deviceId < 0 || (params.deviceId < 0 && params.vibratorId < 0)) { + if (identifier.deviceId < 0 || (identifier.deviceId < 0 && identifier.vibratorId < 0)) { ret = vibratorHdiConnection_.GetVibratorInfo(baseInfo); } else { - ret = vibratorHdiConnection_.GetVibratorIdList(params, baseInfo); + ret = vibratorHdiConnection_.GetVibratorIdList(identifier, baseInfo); } if (ret != NO_ERROR || baseInfo.empty()) { MISC_HILOGE("HDI::GetVibratorInfoList return error"); @@ -1407,19 +1406,19 @@ bool MiscdeviceService::UpdateVibratorAllInfo(const VibratorParamsIPC ¶ms, VibratorAllInfos tVibratorInfo(vibratorIdList); vibratorAllInfos = tVibratorInfo; VibratorCapacity vibratorCapacity; - ret = vibratorHdiConnection_.GetVibratorCapacity(params, vibratorCapacity); + ret = vibratorHdiConnection_.GetVibratorCapacity(identifier, vibratorCapacity); if (ret != NO_ERROR) { MISC_HILOGE("HDI::GetHapticCapacity return error"); return false; } std::vector waveInfo; - ret = vibratorHdiConnection_.GetAllWaveInfo(params, waveInfo); + ret = vibratorHdiConnection_.GetAllWaveInfo(identifier, waveInfo); if (ret != NO_ERROR || waveInfo.empty()) { MISC_HILOGE("HDI::GetAllWaveInfo return error"); return false; } (void)ConvertToServerInfos(baseInfo, vibratorCapacity, waveInfo, info, vibratorAllInfos); - devicesManageMap_.insert(std::make_pair(params.deviceId, vibratorAllInfos)); + devicesManageMap_.insert(std::make_pair(identifier.deviceId, vibratorAllInfos)); return true; } @@ -1455,7 +1454,7 @@ void MiscdeviceService::FirstGetLocalVibratorInfo() } std::vector localInfo; HdfVibratorPlugInfo mockInfo; - VibratorParamsIPC param; + VibratorIdentifierIPC param; for (auto &info : vibratorInfo) { if (info.isLocal == 1) { localInfo.emplace_back(info); @@ -1483,76 +1482,74 @@ void MiscdeviceService::FirstGetLocalVibratorInfo() devicesManageMap_.insert(std::make_pair(param.deviceId, localVibratorInfo)); } -int32_t MiscdeviceService::StartVibrateThreadControl(const VibratorParamsIPC& params, VibrateInfo& info) +int32_t MiscdeviceService::StartVibrateThreadControl(const VibratorIdentifierIPC& identifier, VibrateInfo& info) { std::string curVibrateTime = GetCurrentTime(); - std::vector result = CheckDeviceIdIsValid(params); + std::vector result = CheckDeviceIdIsValid(identifier); int ignoreVibrateNum = 0; if(result.empty()) { MISC_HILOGD("No vibration found"); return ERROR; - }else { - for (const auto& paramIt : result) { - if (ShouldIgnoreVibrate(info, paramIt, params.deviceId == -1)) { - ignoreVibrateNum ++; - continue; - } - StartVibrateThread(info, paramIt); + } + for (const auto& paramIt : result) { + if (ShouldIgnoreVibrate(info, paramIt, identifier.deviceId == -1)) { + ignoreVibrateNum ++; + continue; } + StartVibrateThread(info, paramIt); } - if(ignoreVibrateNum == result.size()) - { + if(ignoreVibrateNum == result.size()) { return ERROR; } return ERR_OK; } -std::vector MiscdeviceService::CheckDeviceIdIsValid(const VibratorParamsIPC& params) +std::vector MiscdeviceService::CheckDeviceIdIsValid(const VibratorIdentifierIPC& identifier) { CALL_LOG_ENTER; - std::vector result; - if(params.deviceId == -1 && params.vibratorId == -1) { + std::vector result; + if(identifier.deviceId == -1 && identifier.vibratorId == -1) { for (const auto& pair : devicesManageMap_) { for (const auto& info : pair.second.baseInfo) { if (info.isLocalVibrator) { - VibratorParamsIPC newParams; - newParams.deviceId = info.deviceId; - newParams.vibratorId = info.vibratorId; - result.push_back(newParams); + VibratorIdentifierIPC newIdentifier; + newIdentifier.deviceId = info.deviceId; + newIdentifier.vibratorId = info.vibratorId; + result.push_back(newIdentifier); } } } - }else if(params.deviceId != -1 && params.vibratorId == -1) { - auto deviceIt = devicesManageMap_.find(params.deviceId); + }else if(identifier.deviceId != -1 && identifier.vibratorId == -1) { + auto deviceIt = devicesManageMap_.find(identifier.deviceId); if (deviceIt != devicesManageMap_.end()) { for (const auto& info : deviceIt->second.baseInfo) { - VibratorParamsIPC newParams; - newParams.deviceId = params.deviceId; - newParams.vibratorId = info.vibratorId; - result.push_back(newParams); + VibratorIdentifierIPC newIdentifier; + newIdentifier.deviceId = identifier.deviceId; + newIdentifier.vibratorId = info.vibratorId; + result.push_back(newIdentifier); } } - } else if(params.deviceId != -1 && params.vibratorId != -1) { - auto deviceIt = devicesManageMap_.find(params.deviceId); + } else if(identifier.deviceId != -1 && identifier.vibratorId != -1) { + auto deviceIt = devicesManageMap_.find(identifier.deviceId); if (deviceIt != devicesManageMap_.end()) { for (const auto& info : deviceIt->second.baseInfo) { - if (info.vibratorId == params.vibratorId) { - VibratorParamsIPC newParams; - newParams.deviceId = params.deviceId; - newParams.vibratorId = info.vibratorId; - result.push_back(newParams); + if (info.vibratorId == identifier.vibratorId) { + VibratorIdentifierIPC newIdentifier; + newIdentifier.deviceId = identifier.deviceId; + newIdentifier.vibratorId = info.vibratorId; + result.push_back(newIdentifier); } } } - } else if(params.deviceId == -1 && params.vibratorId != -1) { + } else if(identifier.deviceId == -1 && identifier.vibratorId != -1) { for (const auto& pair : devicesManageMap_) { for (const auto& info : pair.second.baseInfo) { - if (info.isLocalVibrator && info.vibratorId == params.vibratorId) { - VibratorParamsIPC newParams; - newParams.deviceId = info.deviceId; - newParams.vibratorId = info.vibratorId; - result.push_back(newParams); + if (info.isLocalVibrator && info.vibratorId == identifier.vibratorId) { + VibratorIdentifierIPC newIdentifier; + newIdentifier.deviceId = info.deviceId; + newIdentifier.vibratorId = info.vibratorId; + result.push_back(newIdentifier); } } } diff --git a/services/miscdevice_service/src/vibration_priority_manager.cpp b/services/miscdevice_service/src/vibration_priority_manager.cpp index 471e0c4..99084b7 100644 --- a/services/miscdevice_service/src/vibration_priority_manager.cpp +++ b/services/miscdevice_service/src/vibration_priority_manager.cpp @@ -662,7 +662,7 @@ bool VibrationPriorityManager::ShouldIgnoreInputMethod(const VibrateInfo &vibrat #endif // OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD VibrateStatus VibrationPriorityManager::ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo, - std::shared_ptr vibratorThread, const VibratorParamsIPC& params, bool isLocalDevice) + std::shared_ptr vibratorThread, const VibratorIdentifierIPC& identifier, bool isLocalDevice) { UpdateStatus(); if(isLocalDevice) { //本机的优先级 @@ -702,7 +702,7 @@ VibrateStatus VibrationPriorityManager::ShouldIgnoreVibrate(const VibrateInfo &v MISC_HILOGD("There is no vibration, it can vibrate"); return VIBRATION; } - if (!IsCurrentVibrate(vibratorThread, params)) { + if (!IsCurrentVibrate(vibratorThread, identifier)) { MISC_HILOGD("There is no vibration at the moment, it can vibrate"); return VIBRATION; } @@ -714,10 +714,10 @@ VibrateStatus VibrationPriorityManager::ShouldIgnoreVibrate(const VibrateInfo &v } bool VibrationPriorityManager::IsCurrentVibrate(std::shared_ptr vibratorThread, - const VibratorParamsIPC& params) const + const VibratorIdentifierIPC& identifier) const { #if defined(OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM) && defined(HDF_DRIVERS_INTERFACE_VIBRATOR) - return ((vibratorThread != nullptr) && (vibratorThread->IsRunning() || VibratorDevice.IsVibratorRunning(params))); + return ((vibratorThread != nullptr) && (vibratorThread->IsRunning() || VibratorDevice.IsVibratorRunning(identifier))); #else return ((vibratorThread != nullptr) && (vibratorThread->IsRunning())); #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM && HDF_DRIVERS_INTERFACE_VIBRATOR diff --git a/services/miscdevice_service/src/vibrator_thread.cpp b/services/miscdevice_service/src/vibrator_thread.cpp index 09056e6..539308d 100644 --- a/services/miscdevice_service/src/vibrator_thread.cpp +++ b/services/miscdevice_service/src/vibrator_thread.cpp @@ -40,29 +40,29 @@ bool VibratorThread::Run() CALL_LOG_ENTER; prctl(PR_SET_NAME, VIBRATE_CONTROL_THREAD_NAME.c_str()); VibrateInfo info = GetCurrentVibrateInfo(); - VibratorParamsIPC params = GetCurrentVibrateParams(); - std::vector wareInfos = GetCurrentWareInfo(); + VibratorIdentifierIPC identifier = GetCurrentVibrateParams(); + std::vector waveInfos = GetCurrentWaveInfo(); if (info.mode == VIBRATE_TIME) { - int32_t ret = PlayOnce(info, params); + int32_t ret = PlayOnce(info, identifier); if (ret != SUCCESS) { MISC_HILOGE("Play once vibration fail, package:%{public}s", info.packageName.c_str()); return false; } } else if (info.mode == VIBRATE_PRESET) { - int32_t ret = PlayEffect(info, params); + int32_t ret = PlayEffect(info, identifier); if (ret != SUCCESS) { MISC_HILOGE("Play effect vibration fail, package:%{public}s", info.packageName.c_str()); return false; } } else if (info.mode == VIBRATE_CUSTOM_HD) { - int32_t ret = PlayCustomByHdHptic(info, params); + int32_t ret = PlayCustomByHdHptic(info, identifier); if (ret != SUCCESS) { MISC_HILOGE("Play custom vibration by hd haptic fail, package:%{public}s", info.packageName.c_str()); return false; } } else if (info.mode == VIBRATE_CUSTOM_COMPOSITE_EFFECT || info.mode == VIBRATE_CUSTOM_COMPOSITE_TIME) { #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - int32_t ret = PlayCustomByCompositeEffect(info, params, wareInfos); + int32_t ret = PlayCustomByCompositeEffect(info, identifier, waveInfos); if (ret != SUCCESS) { MISC_HILOGE("Play custom vibration by composite effect fail, package:%{public}s", info.packageName.c_str()); return false; @@ -72,10 +72,10 @@ bool VibratorThread::Run() return false; } -int32_t VibratorThread::PlayOnce(const VibrateInfo &info, const VibratorParamsIPC& params) +int32_t VibratorThread::PlayOnce(const VibrateInfo &info, const VibratorIdentifierIPC& identifier) { std::unique_lock vibrateLck(vibrateMutex_); - int32_t ret = VibratorDevice.StartOnce(params, static_cast(info.duration)); + int32_t ret = VibratorDevice.StartOnce(identifier, static_cast(info.duration)); if (ret != SUCCESS) { MISC_HILOGE("StartOnce fail, duration:%{public}d", info.duration); return ERROR; @@ -83,7 +83,7 @@ int32_t VibratorThread::PlayOnce(const VibrateInfo &info, const VibratorParamsIP cv_.wait_for(vibrateLck, std::chrono::milliseconds(info.duration), [this] { return exitFlag_.load(); }); if (exitFlag_) { #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - VibratorDevice.Stop(params, HDF_VIBRATOR_MODE_ONCE); + VibratorDevice.Stop(identifier, HDF_VIBRATOR_MODE_ONCE); #endif // HDF_DRIVERS_INTERFACE_VIBRATOR MISC_HILOGD("Stop duration:%{public}d, package:%{public}s", info.duration, info.packageName.c_str()); return SUCCESS; @@ -91,12 +91,12 @@ int32_t VibratorThread::PlayOnce(const VibrateInfo &info, const VibratorParamsIP return SUCCESS; } -void VibratorThread::HandleMultipleVibrations(const VibratorParamsIPC& params) +void VibratorThread::HandleMultipleVibrations(const VibratorIdentifierIPC& identifier) { - if (VibratorDevice.IsVibratorRunning(params)) { - VibratorDevice.Stop(params, HDF_VIBRATOR_MODE_PRESET); + if (VibratorDevice.IsVibratorRunning(identifier)) { + VibratorDevice.Stop(identifier, HDF_VIBRATOR_MODE_PRESET); for (size_t i = 0; i < RETRY_NUMBER; i++) { - if (!VibratorDevice.IsVibratorRunning(params)) { + if (!VibratorDevice.IsVibratorRunning(identifier)) { MISC_HILOGI("No running vibration"); return; } @@ -106,17 +106,17 @@ void VibratorThread::HandleMultipleVibrations(const VibratorParamsIPC& params) } } -int32_t VibratorThread::PlayEffect(const VibrateInfo &info, const VibratorParamsIPC& params) +int32_t VibratorThread::PlayEffect(const VibrateInfo &info, const VibratorIdentifierIPC& identifier) { std::unique_lock vibrateLck(vibrateMutex_); for (int32_t i = 0; i < info.count; ++i) { std::string effect = info.effect; int32_t duration = info.duration; if (i >= 1) { /**Multiple vibration treatment*/ - HandleMultipleVibrations(params); + HandleMultipleVibrations(identifier); duration += DELAY_TIME2; } - int32_t ret = VibratorDevice.StartByIntensity(params, effect, info.intensity); + int32_t ret = VibratorDevice.StartByIntensity(identifier, effect, info.intensity); if (ret != SUCCESS) { MISC_HILOGE("Vibrate effect %{public}s failed, ", effect.c_str()); return ERROR; @@ -124,7 +124,7 @@ int32_t VibratorThread::PlayEffect(const VibrateInfo &info, const VibratorParams cv_.wait_for(vibrateLck, std::chrono::milliseconds(duration), [this] { return exitFlag_.load(); }); if (exitFlag_) { #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - VibratorDevice.Stop(params, HDF_VIBRATOR_MODE_PRESET); + VibratorDevice.Stop(identifier, HDF_VIBRATOR_MODE_PRESET); #endif // HDF_DRIVERS_INTERFACE_VIBRATOR MISC_HILOGD("Stop effect:%{public}s, package:%{public}s", effect.c_str(), info.packageName.c_str()); return SUCCESS; @@ -133,7 +133,7 @@ int32_t VibratorThread::PlayEffect(const VibrateInfo &info, const VibratorParams return SUCCESS; } -int32_t VibratorThread::PlayCustomByHdHptic(const VibrateInfo &info, const VibratorParamsIPC& params) +int32_t VibratorThread::PlayCustomByHdHptic(const VibrateInfo &info, const VibratorIdentifierIPC& identifier) { std::unique_lock vibrateLck(vibrateMutex_); const std::vector &patterns = info.package.patterns; @@ -148,12 +148,12 @@ int32_t VibratorThread::PlayCustomByHdHptic(const VibrateInfo &info, const Vibra cv_.wait_for(vibrateLck, std::chrono::milliseconds(delayTime), [this] { return exitFlag_.load(); }); if (exitFlag_) { #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR - VibratorDevice.Stop(params, HDF_VIBRATOR_MODE_HDHAPTIC); + VibratorDevice.Stop(identifier, HDF_VIBRATOR_MODE_HDHAPTIC); #endif // HDF_DRIVERS_INTERFACE_VIBRATOR MISC_HILOGD("Stop hd haptic, package:%{public}s", info.packageName.c_str()); return SUCCESS; } - int32_t ret = VibratorDevice.PlayPattern(params, patterns[i]); + int32_t ret = VibratorDevice.PlayPattern(identifier, patterns[i]); if (ret != SUCCESS) { MISC_HILOGE("Vibrate hd haptic failed"); return ERROR; @@ -163,10 +163,10 @@ int32_t VibratorThread::PlayCustomByHdHptic(const VibrateInfo &info, const Vibra } #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR -int32_t VibratorThread::PlayCustomByCompositeEffect(const VibrateInfo &info, const VibratorParamsIPC& params, - std::vector wareInfo) +int32_t VibratorThread::PlayCustomByCompositeEffect(const VibrateInfo &info, const VibratorIdentifierIPC& identifier, + std::vector waveInfo) { - CustomVibrationMatcher matcher(params, wareInfo); + CustomVibrationMatcher matcher(identifier, waveInfo); HdfCompositeEffect hdfCompositeEffect; if (info.mode == VIBRATE_CUSTOM_COMPOSITE_EFFECT) { hdfCompositeEffect.type = HDF_EFFECT_TYPE_PRIMITIVE; @@ -183,11 +183,11 @@ int32_t VibratorThread::PlayCustomByCompositeEffect(const VibrateInfo &info, con return ERROR; } } - return PlayCompositeEffect(info, hdfCompositeEffect, params); + return PlayCompositeEffect(info, hdfCompositeEffect, identifier); } int32_t VibratorThread::PlayCompositeEffect(const VibrateInfo &info, const HdfCompositeEffect &hdfCompositeEffect, - const VibratorParamsIPC& params) + const VibratorIdentifierIPC& identifier) { std::unique_lock vibrateLck(vibrateMutex_); HdfCompositeEffect effectsPart; @@ -205,7 +205,7 @@ int32_t VibratorThread::PlayCompositeEffect(const VibrateInfo &info, const HdfCo return ERROR; } if ((effectsPart.compositeEffects.size() >= COMPOSITE_EFFECT_PART) || (i == (effectSize - 1))) { - int32_t ret = VibratorDevice.EnableCompositeEffect(params, effectsPart); + int32_t ret = VibratorDevice.EnableCompositeEffect(identifier, effectsPart); if (ret != SUCCESS) { MISC_HILOGE("EnableCompositeEffect failed"); return ERROR; @@ -215,7 +215,7 @@ int32_t VibratorThread::PlayCompositeEffect(const VibrateInfo &info, const HdfCo effectsPart.compositeEffects.clear(); } if (exitFlag_) { - VibratorDevice.Stop(params, HDF_VIBRATOR_MODE_PRESET); + VibratorDevice.Stop(identifier, HDF_VIBRATOR_MODE_PRESET); MISC_HILOGD("Stop composite effect part, package:%{public}s", info.packageName.c_str()); return SUCCESS; } @@ -224,12 +224,12 @@ int32_t VibratorThread::PlayCompositeEffect(const VibrateInfo &info, const HdfCo } #endif // HDF_DRIVERS_INTERFACE_VIBRATOR -void VibratorThread::UpdateVibratorEffect(const VibrateInfo &info, const VibratorParamsIPC& params, +void VibratorThread::UpdateVibratorEffect(const VibrateInfo &info, const VibratorIdentifierIPC& identifier, std::vector &waveInfos) { std::unique_lock lck(currentVibrationMutex_); currentVibration_ = info; - currentVibrateParams_ = params; + currentVibrateParams_ = identifier; waveInfos_ = waveInfos; } @@ -239,13 +239,13 @@ VibrateInfo VibratorThread::GetCurrentVibrateInfo() return currentVibration_; } -VibratorParamsIPC VibratorThread::GetCurrentVibrateParams() +VibratorIdentifierIPC VibratorThread::GetCurrentVibrateParams() { std::unique_lock lck(currentVibrateParamsMutex_); return currentVibrateParams_; } -std::vector VibratorThread::GetCurrentWareInfo() +std::vector VibratorThread::GetCurrentWaveInfo() { std::unique_lock lck(currentVibrateParamsMutex_); return waveInfos_; diff --git a/test/unittest/vibrator/native/vibrator_agent_test.cpp b/test/unittest/vibrator/native/vibrator_agent_test.cpp index acab482..e1c063a 100644 --- a/test/unittest/vibrator/native/vibrator_agent_test.cpp +++ b/test/unittest/vibrator/native/vibrator_agent_test.cpp @@ -1346,23 +1346,23 @@ HWTEST_F(VibratorAgentTest, IsHdHapticSupported_001, TestSize.Level1) Cancel(); } -bool IsSupportVibratorEffectEnhanced(const VibratorParams params, const char* effectId) +bool IsSupportVibratorEffectEnhanced(const VibratorIdentifier identifier, const char* effectId) { bool state { false }; - IsSupportEffectEnhanced(params, effectId, &state); + IsSupportEffectEnhanced(identifier, effectId, &state); return state; } HWTEST_F(VibratorAgentTest, StartVibratorEnhancedTest_001, TestSize.Level1) { MISC_HILOGI("StartVibratorEnhancedTest_001 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorEffectEnhanced(params, VIBRATOR_TYPE_CLOCK_TIMER); + bool isSupport = IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_CLOCK_TIMER); if (isSupport) { - int32_t ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_CLOCK_TIMER); + int32_t ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_CLOCK_TIMER); ASSERT_EQ(ret, 0); } else { ASSERT_EQ(isSupport, false); @@ -1372,518 +1372,518 @@ HWTEST_F(VibratorAgentTest, StartVibratorEnhancedTest_001, TestSize.Level1) HWTEST_F(VibratorAgentTest, StartVibratorEnhancedTest_002, TestSize.Level1) { MISC_HILOGI("StartVibratorEnhancedTest_002 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - int32_t ret = StartVibratorEnhanced(params, ""); + int32_t ret = StartVibratorEnhanced(identifier, ""); ASSERT_NE(ret, 0); } HWTEST_F(VibratorAgentTest, StartVibratorEnhancedTest_003, TestSize.Level1) { MISC_HILOGI("StartVibratorTest_003 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - int32_t ret = StartVibratorEnhanced(params, nullptr); + int32_t ret = StartVibratorEnhanced(identifier, nullptr); ASSERT_NE(ret, 0); } HWTEST_F(VibratorAgentTest, StartVibratorOnceEnhancedTest_001, TestSize.Level1) { MISC_HILOGI("StartVibratorOnceEnhancedTest_001 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - int32_t ret = StartVibratorOnceEnhanced(params, 300); + int32_t ret = StartVibratorOnceEnhanced(identifier, 300); ASSERT_EQ(ret, 0); } HWTEST_F(VibratorAgentTest, StartVibratorOnceEnhancedTest_002, TestSize.Level1) { MISC_HILOGI("StartVibratorOnceEnhancedTest_002 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - int32_t ret = StartVibratorOnceEnhanced(params, 0); + int32_t ret = StartVibratorOnceEnhanced(identifier, 0); ASSERT_NE(ret, 0); } HWTEST_F(VibratorAgentTest, StartVibratorOnceEnhancedTest_003, TestSize.Level1) { MISC_HILOGI("StartVibratorOnceEnhancedTest_003 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - int32_t ret = StartVibratorOnceEnhanced(params, 1800000); + int32_t ret = StartVibratorOnceEnhanced(identifier, 1800000); ASSERT_EQ(ret, 0); } HWTEST_F(VibratorAgentTest, StartVibratorOnceEnhancedTest_004, TestSize.Level1) { MISC_HILOGI("StartVibratorOnceEnhancedTest_004 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - int32_t ret = StartVibratorOnceEnhanced(params, 1800001); + int32_t ret = StartVibratorOnceEnhanced(identifier, 1800001); ASSERT_NE(ret, 0); } HWTEST_F(VibratorAgentTest, StopVibratorEnhancedTest_001, TestSize.Level1) { MISC_HILOGI("StopVibratorEnhancedTest_001 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - int32_t ret = StopVibratorEnhanced(params, "time"); + int32_t ret = StopVibratorEnhanced(identifier, "time"); ASSERT_EQ(ret, 0); } HWTEST_F(VibratorAgentTest, StopVibratorEnhancedTest_002, TestSize.Level1) { MISC_HILOGI("StopVibratorEnhancedTest_002 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - int32_t ret = StopVibratorEnhanced(params, "preset"); + int32_t ret = StopVibratorEnhanced(identifier, "preset"); ASSERT_NE(ret, 0); } HWTEST_F(VibratorAgentTest, StopVibratorEnhancedTest_003, TestSize.Level1) { MISC_HILOGI("StopVibratorEnhancedTest_003 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - int32_t ret = StopVibratorEnhanced(params, ""); + int32_t ret = StopVibratorEnhanced(identifier, ""); ASSERT_NE(ret, 0); } HWTEST_F(VibratorAgentTest, StopVibratorEnhancedTest_004, TestSize.Level1) { MISC_HILOGI("StopVibratorEnhancedTest_004 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - int32_t ret = StopVibratorEnhanced(params, nullptr); + int32_t ret = StopVibratorEnhanced(identifier, nullptr); ASSERT_NE(ret, 0); } HWTEST_F(VibratorAgentTest, StopVibratorEnhancedTest_005, TestSize.Level1) { MISC_HILOGI("StopVibratorEnhancedTest_005 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - int32_t ret = StartVibratorOnceEnhanced(params, 300); + int32_t ret = StartVibratorOnceEnhanced(identifier, 300); ASSERT_EQ(ret, 0); - ret = StopVibratorEnhanced(params, "time"); + ret = StopVibratorEnhanced(identifier, "time"); ASSERT_EQ(ret, 0); } HWTEST_F(VibratorAgentTest, SetLoopCountEnhanced_001, TestSize.Level1) { MISC_HILOGI("SetLoopCountEnhanced_001 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool ret = SetLoopCountEnhanced(params, 300); + bool ret = SetLoopCountEnhanced(identifier, 300); ASSERT_TRUE(ret); } HWTEST_F(VibratorAgentTest, SetLoopCountEnhanced_002, TestSize.Level1) { MISC_HILOGI("SetLoopCount_002 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool ret = SetLoopCountEnhanced(params, -1); + bool ret = SetLoopCountEnhanced(identifier, -1); ASSERT_FALSE(ret); } HWTEST_F(VibratorAgentTest, SetLoopCountEnhanced_003, TestSize.Level1) { MISC_HILOGI("SetLoopCountEnhanced_003 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool ret = SetLoopCountEnhanced(params, 0); + bool ret = SetLoopCountEnhanced(identifier, 0); ASSERT_FALSE(ret); } HWTEST_F(VibratorAgentTest, SetUsageEnhanced_001, TestSize.Level1) { MISC_HILOGI("SetUsageEnhanced_001 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool ret = SetUsageEnhanced(params, 0); + bool ret = SetUsageEnhanced(identifier, 0); ASSERT_TRUE(ret); } HWTEST_F(VibratorAgentTest, SetUsageEnhanced_002, TestSize.Level1) { MISC_HILOGI("SetUsageEnhanced_002 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool ret = SetUsageEnhanced(params, -1); + bool ret = SetUsageEnhanced(identifier, -1); ASSERT_FALSE(ret); } HWTEST_F(VibratorAgentTest, SetUsageEnhanced_003, TestSize.Level1) { MISC_HILOGI("SetUsage_003 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool ret = SetUsageEnhanced(params, USAGE_MAX); + bool ret = SetUsageEnhanced(identifier, USAGE_MAX); ASSERT_FALSE(ret); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_001, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_001 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/coin_drop.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_002, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_002 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_003, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_003 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = (IsSupportVibratorCustomEnhanced(params) && IsSupportVibratorEffectEnhanced(params, VIBRATOR_TYPE_FAIL)); + bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); if (isSupport) { - bool flag = SetLoopCountEnhanced(params, 2); + bool flag = SetLoopCountEnhanced(identifier, 2); ASSERT_TRUE(flag); - int32_t ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_FAIL); + int32_t ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_FAIL); ASSERT_EQ(ret, 0); FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_NE(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_004, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_004 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = (IsSupportVibratorCustomEnhanced(params) && IsSupportVibratorEffectEnhanced(params, VIBRATOR_TYPE_FAIL)); + bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); if (isSupport) { - bool flag = SetUsageEnhanced(params, USAGE_ALARM); + bool flag = SetUsageEnhanced(identifier, USAGE_ALARM); ASSERT_TRUE(flag); - int32_t ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_FAIL); + int32_t ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_FAIL); ASSERT_EQ(ret, 0); FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_NE(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_005, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_005 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = (IsSupportVibratorCustomEnhanced(params) && IsSupportVibratorEffectEnhanced(params, VIBRATOR_TYPE_FAIL)); + bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); if (isSupport) { - bool flag = SetUsageEnhanced(params, USAGE_UNKNOWN); + bool flag = SetUsageEnhanced(identifier, USAGE_UNKNOWN); ASSERT_TRUE(flag); - int32_t ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_FAIL); + int32_t ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_FAIL); ASSERT_EQ(ret, 0); FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_006, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_006 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = (IsSupportVibratorCustomEnhanced(params) && IsSupportVibratorEffectEnhanced(params, VIBRATOR_TYPE_FAIL)); + bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - bool flag = SetUsageEnhanced(params, USAGE_ALARM); + bool flag = SetUsageEnhanced(identifier, USAGE_ALARM); ASSERT_TRUE(flag); - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); - ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_FAIL); + ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_FAIL); ASSERT_NE(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_007, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_007 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = (IsSupportVibratorCustomEnhanced(params) && IsSupportVibratorEffectEnhanced(params, VIBRATOR_TYPE_FAIL)); + bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - bool flag = SetUsageEnhanced(params, USAGE_UNKNOWN); + bool flag = SetUsageEnhanced(identifier, USAGE_UNKNOWN); ASSERT_TRUE(flag); - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); - ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_FAIL); + ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_FAIL); ASSERT_EQ(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_008, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_008 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { - bool flag = SetUsageEnhanced(params, USAGE_ALARM); + bool flag = SetUsageEnhanced(identifier, USAGE_ALARM); ASSERT_TRUE(flag); - int32_t ret = StartVibratorOnceEnhanced(params, 500); + int32_t ret = StartVibratorOnceEnhanced(identifier, 500); ASSERT_EQ(ret, 0); FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_NE(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_009, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_009 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { bool flag = SetUsage(USAGE_UNKNOWN); ASSERT_TRUE(flag); - int32_t ret = StartVibratorOnceEnhanced(params, 500); + int32_t ret = StartVibratorOnceEnhanced(identifier, 500); ASSERT_EQ(ret, 0); FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_010, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_010 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - bool flag = SetUsageEnhanced(params, USAGE_ALARM); + bool flag = SetUsageEnhanced(identifier, USAGE_ALARM); ASSERT_TRUE(flag); - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); - ret = StartVibratorOnceEnhanced(params, 500); + ret = StartVibratorOnceEnhanced(identifier, 500); ASSERT_NE(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_011, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_011 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - bool flag = SetUsageEnhanced(params, USAGE_UNKNOWN); + bool flag = SetUsageEnhanced(identifier, USAGE_UNKNOWN); ASSERT_TRUE(flag); - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); - ret = StartVibratorOnceEnhanced(params, 500); + ret = StartVibratorOnceEnhanced(identifier, 500); ASSERT_EQ(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_012, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_012 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/test_128_event.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_013, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_013 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/test_invalid_type.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_NE(ret, 0); } } else { @@ -1894,17 +1894,17 @@ HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_013, TestSize.Level1) HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_014, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_014 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/test_invalid_startTime.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_NE(ret, 0); } } else { @@ -1915,17 +1915,17 @@ HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_014, TestSize.Level1) HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_015, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_015 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/test_invalid_duration.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_NE(ret, 0); } } else { @@ -1936,17 +1936,17 @@ HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_015, TestSize.Level1) HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_016, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_016 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/test_invalid_intensity.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_NE(ret, 0); } } else { @@ -1957,17 +1957,17 @@ HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_016, TestSize.Level1) HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_017, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_017 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/test_invalid_frequency.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_NE(ret, 0); } } else { @@ -1978,17 +1978,17 @@ HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_017, TestSize.Level1) HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_018, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_018 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/test_129_event.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_NE(ret, 0); } } else { @@ -1999,17 +1999,17 @@ HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_018, TestSize.Level1) HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_019, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_019 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/test_big_file_size.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_NE(ret, 0); } } else { @@ -2020,97 +2020,97 @@ HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_019, TestSize.Level1) HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_020, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_020 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/test_event_overlap_1.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); } } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_021, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_021 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/test_event_overlap_2.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); } } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_022, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_022 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/Jet_N2O.he"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_023, TestSize.Level1) { MISC_HILOGI("PlayVibratorCustomEnhanced_023 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/Racing_Start.he"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, SetParametersEnhanced_001, TestSize.Level1) { MISC_HILOGI("SetParametersEnhanced_001 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; @@ -2118,14 +2118,14 @@ HWTEST_F(VibratorAgentTest, SetParametersEnhanced_001, TestSize.Level1) .intensity = -1, .frequency = -15 }; - bool ret = SetParametersEnhanced(params, parameter); + bool ret = SetParametersEnhanced(identifier, parameter); ASSERT_FALSE(ret); } HWTEST_F(VibratorAgentTest, SetParametersEnhanced_002, TestSize.Level1) { MISC_HILOGI("SetParametersEnhanced_002 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; @@ -2133,18 +2133,18 @@ HWTEST_F(VibratorAgentTest, SetParametersEnhanced_002, TestSize.Level1) .intensity = 70, .frequency = 150 }; - bool ret = SetParametersEnhanced(params, parameter); + bool ret = SetParametersEnhanced(identifier, parameter); ASSERT_FALSE(ret); } HWTEST_F(VibratorAgentTest, SetParametersEnhanced_003, TestSize.Level1) { MISC_HILOGI("SetParametersEnhanced_003 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/coin_drop.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); @@ -2154,26 +2154,26 @@ HWTEST_F(VibratorAgentTest, SetParametersEnhanced_003, TestSize.Level1) .intensity = 50, .frequency = -15 }; - bool flag = SetParametersEnhanced(params, parameter); + bool flag = SetParametersEnhanced(identifier, parameter); ASSERT_TRUE(flag); - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, SetParametersEnhanced_004, TestSize.Level1) { MISC_HILOGI("SetParametersEnhanced_004 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); @@ -2183,45 +2183,45 @@ HWTEST_F(VibratorAgentTest, SetParametersEnhanced_004, TestSize.Level1) .intensity = 33, .frequency = 55 }; - bool flag = SetParametersEnhanced(params, parameter); + bool flag = SetParametersEnhanced(identifier, parameter); ASSERT_TRUE(flag); - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } HWTEST_F(VibratorAgentTest, CancelEnhanced_001, TestSize.Level1) { MISC_HILOGI("CancelEnhanced_001 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - int32_t ret = CancelEnhanced(params); + int32_t ret = CancelEnhanced(identifier); ASSERT_NE(ret, 0); } HWTEST_F(VibratorAgentTest, CancelEnhanced_002, TestSize.Level1) { MISC_HILOGI("CancelEnhanced_002 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/coin_drop.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); - ret = CancelEnhanced(params); + ret = CancelEnhanced(identifier); ASSERT_EQ(ret, 0); } } else { @@ -2232,27 +2232,27 @@ HWTEST_F(VibratorAgentTest, CancelEnhanced_002, TestSize.Level1) HWTEST_F(VibratorAgentTest, CancelEnhanced_003, TestSize.Level1) { MISC_HILOGI("CancelEnhanced_003 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - int32_t ret = StartVibratorOnceEnhanced(params, 500); + int32_t ret = StartVibratorOnceEnhanced(identifier, 500); ASSERT_EQ(ret, 0); - ret = CancelEnhanced(params); + ret = CancelEnhanced(identifier); ASSERT_EQ(ret, 0); } HWTEST_F(VibratorAgentTest, CancelEnhanced_004, TestSize.Level1) { MISC_HILOGI("CancelEnhanced_004 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - if (IsSupportVibratorEffectEnhanced(params, VIBRATOR_TYPE_FAIL)) { - int32_t ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_FAIL); + if (IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)) { + int32_t ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_FAIL); ASSERT_EQ(ret, 0); - ret = CancelEnhanced(params); + ret = CancelEnhanced(identifier); ASSERT_EQ(ret, 0); } ASSERT_TRUE(true); @@ -2261,17 +2261,17 @@ HWTEST_F(VibratorAgentTest, CancelEnhanced_004, TestSize.Level1) HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_001, TestSize.Level1) { MISC_HILOGI("IsSupportEffectEnhanced_001 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; bool state { false }; - int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_CLOCK_TIMER, &state); + int32_t ret = IsSupportEffectEnhanced(identifier, VIBRATOR_TYPE_CLOCK_TIMER, &state); ASSERT_EQ(ret, 0); if (state) { - ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_CLOCK_TIMER); + ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_CLOCK_TIMER); ASSERT_EQ(ret, 0); - CancelEnhanced(params); + CancelEnhanced(identifier); } else { MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_CLOCK_TIMER); } @@ -2280,12 +2280,12 @@ HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_001, TestSize.Level1) HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_002, TestSize.Level1) { MISC_HILOGI("IsSupportEffectEnhanced_002 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; bool state { false }; - int32_t ret = IsSupportEffectEnhanced(params, "haptic.xxx.yyy", &state); + int32_t ret = IsSupportEffectEnhanced(identifier, "haptic.xxx.yyy", &state); ASSERT_EQ(ret, 0); ASSERT_FALSE(state); } @@ -2293,12 +2293,12 @@ HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_002, TestSize.Level1) HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_003, TestSize.Level1) { MISC_HILOGI("IsSupportEffectEnhanced_003 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; bool state { false }; - int32_t ret = IsSupportEffectEnhanced(params, nullptr, &state); + int32_t ret = IsSupportEffectEnhanced(identifier, nullptr, &state); ASSERT_NE(ret, 0); ASSERT_FALSE(state); } @@ -2306,17 +2306,17 @@ HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_003, TestSize.Level1) HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_004, TestSize.Level1) { MISC_HILOGI("IsSupportEffectEnhanced_004 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; bool state { false }; - int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_FAIL, &state); + int32_t ret = IsSupportEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL, &state); ASSERT_EQ(ret, 0); if (state) { - ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_FAIL); + ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_FAIL); ASSERT_EQ(ret, 0); - CancelEnhanced(params); + CancelEnhanced(identifier); } else { MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_FAIL); } @@ -2325,17 +2325,17 @@ HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_004, TestSize.Level1) HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_005, TestSize.Level1) { MISC_HILOGI("IsSupportEffectEnhanced_005 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; bool state { false }; - int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_CHARGING, &state); + int32_t ret = IsSupportEffectEnhanced(identifier, VIBRATOR_TYPE_CHARGING, &state); ASSERT_EQ(ret, 0); if (state) { - ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_CHARGING); + ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_CHARGING); ASSERT_EQ(ret, 0); - CancelEnhanced(params); + CancelEnhanced(identifier); } else { MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_CHARGING); } @@ -2344,17 +2344,17 @@ HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_005, TestSize.Level1) HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_006, TestSize.Level1) { MISC_HILOGI("IsSupportEffectEnhanced_006 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; bool state { false }; - int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_LONG_PRESS_HEAVY, &state); + int32_t ret = IsSupportEffectEnhanced(identifier, VIBRATOR_TYPE_LONG_PRESS_HEAVY, &state); ASSERT_EQ(ret, 0); if (state) { - ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_LONG_PRESS_HEAVY); + ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_LONG_PRESS_HEAVY); ASSERT_EQ(ret, 0); - CancelEnhanced(params); + CancelEnhanced(identifier); } else { MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_LONG_PRESS_HEAVY); } @@ -2363,17 +2363,17 @@ HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_006, TestSize.Level1) HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_007, TestSize.Level1) { MISC_HILOGI("IsSupportEffectEnhanced_007 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; bool state { false }; - int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_LONG_PRESS_LIGHT, &state); + int32_t ret = IsSupportEffectEnhanced(identifier, VIBRATOR_TYPE_LONG_PRESS_LIGHT, &state); ASSERT_EQ(ret, 0); if (state) { - ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_LONG_PRESS_LIGHT); + ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_LONG_PRESS_LIGHT); ASSERT_EQ(ret, 0); - CancelEnhanced(params); + CancelEnhanced(identifier); } else { MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_LONG_PRESS_LIGHT); } @@ -2382,17 +2382,17 @@ HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_007, TestSize.Level1) HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_008, TestSize.Level1) { MISC_HILOGI("IsSupportEffectEnhanced_008 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; bool state { false }; - int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_LONG_PRESS_MEDIUM, &state); + int32_t ret = IsSupportEffectEnhanced(identifier, VIBRATOR_TYPE_LONG_PRESS_MEDIUM, &state); ASSERT_EQ(ret, 0); if (state) { - ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_LONG_PRESS_MEDIUM); + ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_LONG_PRESS_MEDIUM); ASSERT_EQ(ret, 0); - CancelEnhanced(params); + CancelEnhanced(identifier); } else { MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_LONG_PRESS_MEDIUM); } @@ -2401,17 +2401,17 @@ HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_008, TestSize.Level1) HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_009, TestSize.Level1) { MISC_HILOGI("IsSupportEffectEnhanced_009 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; bool state { false }; - int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_SLIDE_LIGHT, &state); + int32_t ret = IsSupportEffectEnhanced(identifier, VIBRATOR_TYPE_SLIDE_LIGHT, &state); ASSERT_EQ(ret, 0); if (state) { - ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_SLIDE_LIGHT); + ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_SLIDE_LIGHT); ASSERT_EQ(ret, 0); - CancelEnhanced(params); + CancelEnhanced(identifier); } else { MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_SLIDE_LIGHT); } @@ -2420,17 +2420,17 @@ HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_009, TestSize.Level1) HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_010, TestSize.Level1) { MISC_HILOGI("IsSupportEffectEnhanced_010 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; bool state { false }; - int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_THRESHOID, &state); + int32_t ret = IsSupportEffectEnhanced(identifier, VIBRATOR_TYPE_THRESHOID, &state); ASSERT_EQ(ret, 0); if (state) { - ret = StartVibratorEnhanced(params, VIBRATOR_TYPE_THRESHOID); + ret = StartVibratorEnhanced(identifier, VIBRATOR_TYPE_THRESHOID); ASSERT_EQ(ret, 0); - CancelEnhanced(params); + CancelEnhanced(identifier); } else { MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_THRESHOID); } @@ -2439,14 +2439,14 @@ HWTEST_F(VibratorAgentTest, IsSupportEffectEnhanced_010, TestSize.Level1) HWTEST_F(VibratorAgentTest, GetDelayTimeEnhanced_001, TestSize.Level1) { MISC_HILOGI("GetDelayTimeEnhanced_001 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { int32_t delayTime { -1 }; - int32_t ret = GetDelayTimeEnhanced(params, delayTime); + int32_t ret = GetDelayTimeEnhanced(identifier, delayTime); ASSERT_EQ(ret, 0); } else { ASSERT_EQ(isSupport, false); @@ -2456,14 +2456,14 @@ HWTEST_F(VibratorAgentTest, GetDelayTimeEnhanced_001, TestSize.Level1) HWTEST_F(VibratorAgentTest, PlayPatternEnhanced_001, TestSize.Level1) { MISC_HILOGI("PlayPatternEnhanced_001 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = IsSupportVibratorCustomEnhanced(params); + bool isSupport = IsSupportVibratorCustomEnhanced(identifier); if (isSupport) { int32_t delayTime { -1 }; - int32_t ret = GetDelayTimeEnhanced(params, delayTime); + int32_t ret = GetDelayTimeEnhanced(identifier, delayTime); ASSERT_EQ(ret, 0); MISC_HILOGD("delayTime:%{public}d", delayTime); FileDescriptor fileDescriptor("/data/test/vibrator/coin_drop.json"); @@ -2484,15 +2484,15 @@ HWTEST_F(VibratorAgentTest, PlayPatternEnhanced_001, TestSize.Level1) std::this_thread::sleep_for(std::chrono::milliseconds(package.patterns[i].time) - std::chrono::milliseconds(package.patterns[i - 1].time)); } - ASSERT_EQ(SetUsageEnhanced(params, USAGE_UNKNOWN), true); + ASSERT_EQ(SetUsageEnhanced(identifier, USAGE_UNKNOWN), true); MISC_HILOGD("pointNum:%{public}d", package.patterns[i].events[i].pointNum); - ret = PlayPatternEnhanced(params, package.patterns[i]); + ret = PlayPatternEnhanced(identifier, package.patterns[i]); ASSERT_EQ(ret, 0); } } ret = FreeVibratorPackage(package); ASSERT_EQ(ret, 0); - CancelEnhanced(params); + CancelEnhanced(identifier); } else { ASSERT_EQ(isSupport, false); } @@ -2501,26 +2501,26 @@ HWTEST_F(VibratorAgentTest, PlayPatternEnhanced_001, TestSize.Level1) HWTEST_F(VibratorAgentTest, PlayPrimitiveEffectEnhanced_001, TestSize.Level1) { MISC_HILOGI("PlayPrimitiveEffectEnhanced_001 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - int32_t ret = PlayPrimitiveEffectEnhanced(params, nullptr, INTENSITY_HIGH); + int32_t ret = PlayPrimitiveEffectEnhanced(identifier, nullptr, INTENSITY_HIGH); ASSERT_EQ(ret, PARAMETER_ERROR); } HWTEST_F(VibratorAgentTest, PlayPrimitiveEffectEnhanced_002, TestSize.Level1) { MISC_HILOGI("PlayPrimitiveEffectEnhanced_002 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; bool state { false }; - int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, &state); + int32_t ret = IsSupportEffectEnhanced(identifier, VIBRATOR_TYPE_SLIDE, &state); ASSERT_EQ(ret, 0); if (state) { - ret = PlayPrimitiveEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, INTENSITY_INVALID); + ret = PlayPrimitiveEffectEnhanced(identifier, VIBRATOR_TYPE_SLIDE, INTENSITY_INVALID); ASSERT_EQ(ret, PARAMETER_ERROR); } else { MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_SLIDE); @@ -2530,18 +2530,18 @@ HWTEST_F(VibratorAgentTest, PlayPrimitiveEffectEnhanced_002, TestSize.Level1) HWTEST_F(VibratorAgentTest, PlayPrimitiveEffectEnhanced_003, TestSize.Level1) { MISC_HILOGI("PlayPrimitiveEffectEnhanced_003 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; bool state { false }; - int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, &state); + int32_t ret = IsSupportEffectEnhanced(identifier, VIBRATOR_TYPE_SLIDE, &state); ASSERT_EQ(ret, 0); if (state) { - ret = PlayPrimitiveEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, INTENSITY_LOW); + ret = PlayPrimitiveEffectEnhanced(identifier, VIBRATOR_TYPE_SLIDE, INTENSITY_LOW); ASSERT_EQ(ret, 0); std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); - CancelEnhanced(params); + CancelEnhanced(identifier); } else { MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_SLIDE); } @@ -2550,18 +2550,18 @@ HWTEST_F(VibratorAgentTest, PlayPrimitiveEffectEnhanced_003, TestSize.Level1) HWTEST_F(VibratorAgentTest, PlayPrimitiveEffectEnhanced_004, TestSize.Level1) { MISC_HILOGI("PlayPrimitiveEffectEnhanced_004 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; bool state { false }; - int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, &state); + int32_t ret = IsSupportEffectEnhanced(identifier, VIBRATOR_TYPE_SLIDE, &state); ASSERT_EQ(ret, 0); if (state) { - ret = PlayPrimitiveEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, INTENSITY_MEDIUM); + ret = PlayPrimitiveEffectEnhanced(identifier, VIBRATOR_TYPE_SLIDE, INTENSITY_MEDIUM); ASSERT_EQ(ret, 0); std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); - CancelEnhanced(params); + CancelEnhanced(identifier); } else { MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_SLIDE); } @@ -2570,18 +2570,18 @@ HWTEST_F(VibratorAgentTest, PlayPrimitiveEffectEnhanced_004, TestSize.Level1) HWTEST_F(VibratorAgentTest, PlayPrimitiveEffectEnhanced_005, TestSize.Level1) { MISC_HILOGI("PlayPrimitiveEffectEnhanced_005 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; bool state { false }; - int32_t ret = IsSupportEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, &state); + int32_t ret = IsSupportEffectEnhanced(identifier, VIBRATOR_TYPE_SLIDE, &state); ASSERT_EQ(ret, 0); if (state) { - ret = PlayPrimitiveEffectEnhanced(params, VIBRATOR_TYPE_SLIDE, INTENSITY_HIGH); + ret = PlayPrimitiveEffectEnhanced(identifier, VIBRATOR_TYPE_SLIDE, INTENSITY_HIGH); ASSERT_EQ(ret, 0); std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); - CancelEnhanced(params); + CancelEnhanced(identifier); } else { MISC_HILOGI("Do not support %{public}s", VIBRATOR_TYPE_SLIDE); } @@ -2590,24 +2590,24 @@ HWTEST_F(VibratorAgentTest, PlayPrimitiveEffectEnhanced_005, TestSize.Level1) HWTEST_F(VibratorAgentTest, IsHdHapticSupportedEnhanced_001, TestSize.Level1) { MISC_HILOGI("IsHdHapticSupportedEnhanced_001 in"); - VibratorParams params = { + VibratorIdentifier identifier = { .deviceId = -1, .vibratorId = -1, }; - bool isSupport = (IsSupportVibratorCustomEnhanced(params) && IsHdHapticSupportedEnhanced(params)); + bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && IsHdHapticSupportedEnhanced(identifier)); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/coin_drop.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); struct stat64 statbuf = { 0 }; if (fstat64(fileDescriptor.fd, &statbuf) == 0) { - int32_t ret = PlayVibratorCustomEnhanced(params, fileDescriptor.fd, 0, statbuf.st_size); + int32_t ret = PlayVibratorCustomEnhanced(identifier, fileDescriptor.fd, 0, statbuf.st_size); ASSERT_EQ(ret, 0); } std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP)); } else { ASSERT_EQ(isSupport, false); } - CancelEnhanced(params); + CancelEnhanced(identifier); } } // namespace Sensors } // namespace OHOS diff --git a/utils/common/include/vibrator_infos.h b/utils/common/include/vibrator_infos.h index f547eb5..d562b41 100644 --- a/utils/common/include/vibrator_infos.h +++ b/utils/common/include/vibrator_infos.h @@ -148,12 +148,12 @@ struct VibratorInfoIPC : public Parcelable{ static VibratorInfoIPC* Unmarshalling(Parcel &data); }; -struct VibratorParamsIPC : public Parcelable { +struct VibratorIdentifierIPC : public Parcelable { int32_t deviceId = -1; int32_t vibratorId = -1; void Dump() const; bool Marshalling(Parcel &parcel) const; - static VibratorParamsIPC* Unmarshalling(Parcel &data); + static VibratorIdentifierIPC* Unmarshalling(Parcel &data); }; struct EffectInfoIPC : public Parcelable{ diff --git a/utils/common/src/vibrator_infos.cpp b/utils/common/src/vibrator_infos.cpp index cfdd731..bc4e63e 100644 --- a/utils/common/src/vibrator_infos.cpp +++ b/utils/common/src/vibrator_infos.cpp @@ -327,12 +327,12 @@ void VibratorInfoIPC::Dump() const MISC_HILOGI("VibratorInfoIPC: [%{public}s]", retStr.c_str()); } -void VibratorParamsIPC::Dump() const +void VibratorIdentifierIPC::Dump() const { MISC_HILOGI("deviceId:%{public}d, vibratorId:%{public}d", deviceId, vibratorId); } -bool VibratorParamsIPC::Marshalling(Parcel &parcel) const +bool VibratorIdentifierIPC::Marshalling(Parcel &parcel) const { if (!parcel.WriteInt32(deviceId)) { MISC_HILOGE("Write parameter's deviceId failed"); @@ -345,22 +345,22 @@ bool VibratorParamsIPC::Marshalling(Parcel &parcel) const return true; } -VibratorParamsIPC* VibratorParamsIPC::Unmarshalling(Parcel &data) +VibratorIdentifierIPC* VibratorIdentifierIPC::Unmarshalling(Parcel &data) { - auto params = new (std::nothrow) VibratorParamsIPC(); - if (params == nullptr) { + auto identifier = new (std::nothrow) VibratorIdentifierIPC(); + if (identifier == nullptr) { MISC_HILOGE("Read init parameter failed"); return nullptr; } - if (!(data.ReadInt32(params->deviceId))) { + if (!(data.ReadInt32(identifier->deviceId))) { MISC_HILOGE("Read parameter's deviceId or vibratorId failed"); - params = nullptr; + identifier = nullptr; } - if (!(data.ReadInt32(params->vibratorId))) { + if (!(data.ReadInt32(identifier->vibratorId))) { MISC_HILOGE("Read parameter's deviceId or vibratorId failed"); - params = nullptr; + identifier = nullptr; } - return params; + return identifier; } bool EffectInfoIPC::Marshalling(Parcel &parcel) const -- Gitee From 484c50d3d2e9f949c986c65af0a8b1ba756256f8 Mon Sep 17 00:00:00 2001 From: hero100 Date: Mon, 14 Apr 2025 17:17:22 +0800 Subject: [PATCH 4/6] =?UTF-8?q?=E5=A4=9A=E8=AE=BE=E5=A4=87=E5=A4=9A?= =?UTF-8?q?=E9=A9=AC=E8=BE=BE4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hero100 --- frameworks/js/napi/vibrator/src/vibrator_js.cpp | 3 ++- .../native/vibrator/src/vibrator_service_client.cpp | 3 ++- .../adapter/src/compatible_connection.cpp | 5 +++-- .../hdi_connection/adapter/src/hdi_connection.cpp | 3 ++- .../interface/src/vibrator_hdi_connection.cpp | 10 +++++----- .../include/vibration_priority_manager.h | 2 +- .../miscdevice_service/include/vibrator_thread.h | 6 +++--- .../miscdevice_service/src/miscdevice_service.cpp | 12 ++++++------ services/miscdevice_service/src/vibrator_thread.cpp | 6 +++--- 9 files changed, 27 insertions(+), 23 deletions(-) diff --git a/frameworks/js/napi/vibrator/src/vibrator_js.cpp b/frameworks/js/napi/vibrator/src/vibrator_js.cpp index 83010a1..a60aa92 100644 --- a/frameworks/js/napi/vibrator/src/vibrator_js.cpp +++ b/frameworks/js/napi/vibrator/src/vibrator_js.cpp @@ -490,7 +490,8 @@ static napi_value VibrateEffect(napi_env env, napi_value args[], size_t argc) return nullptr; } if (asyncCallbackInfo->info.type == "preset") { - if (!SetLoopCountEnhanced(identifier, asyncCallbackInfo->info.count) || CheckParameters(asyncCallbackInfo->info, identifier) != ERR_OK || + if (!SetLoopCountEnhanced(identifier, asyncCallbackInfo->info.count) || + CheckParameters(asyncCallbackInfo->info, identifier) != ERR_OK || asyncCallbackInfo->info.effectId.empty()) { MISC_HILOGE("SetLoopCount fail or parameter invalid"); ThrowErr(env, PARAMETER_ERROR, "SetLoopCount fail or parameter invalid"); diff --git a/frameworks/native/vibrator/src/vibrator_service_client.cpp b/frameworks/native/vibrator/src/vibrator_service_client.cpp index b5a0555..c592c7b 100644 --- a/frameworks/native/vibrator/src/vibrator_service_client.cpp +++ b/frameworks/native/vibrator/src/vibrator_service_client.cpp @@ -766,7 +766,8 @@ void VibratorServiceClient::SetParameters(const VibratorIdentifier &identifier, } } -VibratorEffectParameter VibratorServiceClient::GetVibratorEffectParameter(const VibratorIdentifier &identifier) { +VibratorEffectParameter VibratorServiceClient::GetVibratorEffectParameter(const VibratorIdentifier &identifier) +{ std::lock_guard VibratorEffectLock(vibratorEffectMutex_); auto it = vibratorEffectMap_.find(identifier); if (it != vibratorEffectMap_.end()) { diff --git a/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp b/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp index 377ebfb..0df15c8 100644 --- a/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp +++ b/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp @@ -94,7 +94,7 @@ int32_t CompatibleConnection::Start(const VibratorIdentifierIPC &identifier, con #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM int32_t CompatibleConnection::EnableCompositeEffect(const VibratorIdentifierIPC &identifier, - const HdfCompositeEffect &hdfCompositeEffect) + const HdfCompositeEffect &hdfCompositeEffect) { CALL_LOG_ENTER; if (hdfCompositeEffect.compositeEffects.empty()) { @@ -199,7 +199,8 @@ void CompatibleConnection::VibrateProcess() return; } -int32_t CompatibleConnection::StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, int32_t intensity) +int32_t CompatibleConnection::StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, + int32_t intensity) { CALL_LOG_ENTER; if (g_vibratorEffect.find(effect) == g_vibratorEffect.end()) { diff --git a/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp b/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp index b3d8cda..fd31a98 100644 --- a/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp +++ b/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp @@ -299,7 +299,8 @@ void HdiConnection::Reconnect() } } -int32_t HdiConnection::StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, int32_t intensity) +int32_t HdiConnection::StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, + int32_t intensity) { MISC_HILOGD("Time delay measurement:end time, effect:%{public}s, intensity:%{public}d", effect.c_str(), intensity); if (effect.empty()) { diff --git a/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp b/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp index 6cdf8f2..a1ca737 100644 --- a/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp +++ b/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp @@ -87,7 +87,7 @@ int32_t VibratorHdiConnection::Start(const VibratorIdentifierIPC &identifier, co #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM int32_t VibratorHdiConnection::EnableCompositeEffect(const VibratorIdentifierIPC &identifier, - const HdfCompositeEffect &hdfCompositeEffect) + const HdfCompositeEffect &hdfCompositeEffect) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); #ifdef HIVIEWDFX_HITRACE_ENABLE @@ -112,7 +112,7 @@ bool VibratorHdiConnection::IsVibratorRunning(const VibratorIdentifierIPC &ident #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM std::optional VibratorHdiConnection::GetEffectInfo(const VibratorIdentifierIPC &identifier, - const std::string &effect) + const std::string &effect) { if (iVibratorHdiConnection_ == nullptr) { MISC_HILOGE("Connect hdi failed"); @@ -175,8 +175,8 @@ int32_t VibratorHdiConnection::DestroyHdiConnection() return ERR_OK; } -int32_t VibratorHdiConnection::StartByIntensity(const VibratorIdentifierIPC &identifier, - const std::string &effect, int32_t intensity) +int32_t VibratorHdiConnection::StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, + int32_t intensity) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); #ifdef HIVIEWDFX_HITRACE_ENABLE @@ -222,7 +222,7 @@ int32_t VibratorHdiConnection::GetEffectInfo(const VibratorIdentifierIPC &identi int32_t VibratorHdiConnection::RegisterVibratorPlugCallback(DevicePlugCallback cb) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); - #ifdef HIVIEWDFX_HITRACE_ENABLE +#ifdef HIVIEWDFX_HITRACE_ENABLE StartTrace(HITRACE_TAG_SENSORS, "RegisterVibratorPlugCallback"); #endif // HIVIEWDFX_HITRACE_ENABLE int32_t ret = iVibratorHdiConnection_->RegisterVibratorPlugCallback(cb); diff --git a/services/miscdevice_service/include/vibration_priority_manager.h b/services/miscdevice_service/include/vibration_priority_manager.h index 4dc2527..64372b3 100644 --- a/services/miscdevice_service/include/vibration_priority_manager.h +++ b/services/miscdevice_service/include/vibration_priority_manager.h @@ -81,7 +81,7 @@ public: DISALLOW_COPY_AND_MOVE(VibrationPriorityManager); bool Init(); VibrateStatus ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo, - std::shared_ptr vibratorThread, const VibratorIdentifierIPC& identifier, bool isLocalDevice); + std::shared_ptr vibratorThread, const VibratorIdentifierIPC& identifier, bool isLocalDevice); #ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB void InitDoNotDisturbData(); void UpdateCurrentUserId(); diff --git a/services/miscdevice_service/include/vibrator_thread.h b/services/miscdevice_service/include/vibrator_thread.h index d87bdd2..e6656f6 100644 --- a/services/miscdevice_service/include/vibrator_thread.h +++ b/services/miscdevice_service/include/vibrator_thread.h @@ -27,7 +27,7 @@ namespace Sensors { class VibratorThread : public Thread { public: void UpdateVibratorEffect(const VibrateInfo &vibrateInfo, const VibratorIdentifierIPC& identifier, - std::vector &waveInfos); + std::vector &waveInfos); VibrateInfo GetCurrentVibrateInfo(); std::vector GetCurrentWaveInfo(); void SetExitStatus(bool status); @@ -44,9 +44,9 @@ private: void HandleMultipleVibrations(const VibratorIdentifierIPC& identifier); #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR int32_t PlayCustomByCompositeEffect(const VibrateInfo &info, const VibratorIdentifierIPC& identifier, - std::vector waveInfo); + std::vector waveInfo); int32_t PlayCompositeEffect(const VibrateInfo &info, const HdfCompositeEffect &hdfCompositeEffect, - const VibratorIdentifierIPC& identifier); + const VibratorIdentifierIPC& identifier); #endif // HDF_DRIVERS_INTERFACE_VIBRATOR std::mutex currentVibrationMutex_; VibrateInfo currentVibration_; diff --git a/services/miscdevice_service/src/miscdevice_service.cpp b/services/miscdevice_service/src/miscdevice_service.cpp index 2edd2e9..a85132c 100644 --- a/services/miscdevice_service/src/miscdevice_service.cpp +++ b/services/miscdevice_service/src/miscdevice_service.cpp @@ -353,7 +353,7 @@ void MiscdeviceService::OnStop() } bool MiscdeviceService::ShouldIgnoreVibrate(const VibrateInfo &info, const VibratorIdentifierIPC& identifier, - bool isLocalDevice) + bool isLocalDevice) { std::lock_guard lock(isVibrationPriorityReadyMutex_); if (!isVibrationPriorityReady_) { @@ -663,7 +663,7 @@ std::string MiscdeviceService::GetCurrentTime() #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM int32_t MiscdeviceService::PlayVibratorCustom(const VibratorIdentifierIPC& identifier, int32_t fd, - int64_t offset, int64_t length, int32_t usage, bool systemUsage, const VibrateParameter ¶meter) + int64_t offset, int64_t length, int32_t usage, bool systemUsage, const VibrateParameter ¶meter) { int32_t checkResult = CheckAuthAndParam(usage, parameter, identifier); if (checkResult != ERR_OK) { @@ -724,7 +724,7 @@ int32_t MiscdeviceService::PlayVibratorCustom(const VibratorIdentifierIPC& ident #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM int32_t MiscdeviceService::CheckAuthAndParam(int32_t usage, const VibrateParameter ¶meter, - const VibratorIdentifierIPC& identifier) + const VibratorIdentifierIPC& identifier) { PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); @@ -885,7 +885,7 @@ int32_t MiscdeviceService::Dump(int32_t fd, const std::vector &a } int32_t MiscdeviceService::PlayPattern(const VibratorIdentifierIPC& identifier, const VibratePattern &pattern, - int32_t usage, bool systemUsage, const VibrateParameter ¶meter) + int32_t usage, bool systemUsage, const VibrateParameter ¶meter) { int32_t checkResult = PlayPatternCheckAuthAndParam(usage, parameter); if (checkResult != ERR_OK) { @@ -1173,7 +1173,7 @@ void MiscdeviceService::DestroyClientPid(const sptr &vibratorServ } int32_t MiscdeviceService::PlayPrimitiveEffect(const VibratorIdentifierIPC& identifier, - const std::string &effect, int32_t intensity, int32_t usage, bool systemUsage, int32_t count) + const std::string &effect, int32_t intensity, int32_t usage, bool systemUsage, int32_t count) { int32_t checkResult = PlayPrimitiveEffectCheckAuthAndParam(intensity, usage); if (checkResult != ERR_OK) { @@ -1290,7 +1290,7 @@ int32_t MiscdeviceService::GetVibratorIdList(const VibratorIdentifierIPC& identi } int32_t MiscdeviceService::GetEffectInfo(const VibratorIdentifierIPC& identifier, const std::string& effectType, - EffectInfoIPC& effectInfoIPC) + EffectInfoIPC& effectInfoIPC) { CALL_LOG_ENTER; PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); diff --git a/services/miscdevice_service/src/vibrator_thread.cpp b/services/miscdevice_service/src/vibrator_thread.cpp index 539308d..31f89c3 100644 --- a/services/miscdevice_service/src/vibrator_thread.cpp +++ b/services/miscdevice_service/src/vibrator_thread.cpp @@ -164,7 +164,7 @@ int32_t VibratorThread::PlayCustomByHdHptic(const VibrateInfo &info, const Vibra #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR int32_t VibratorThread::PlayCustomByCompositeEffect(const VibrateInfo &info, const VibratorIdentifierIPC& identifier, - std::vector waveInfo) + std::vector waveInfo) { CustomVibrationMatcher matcher(identifier, waveInfo); HdfCompositeEffect hdfCompositeEffect; @@ -187,7 +187,7 @@ int32_t VibratorThread::PlayCustomByCompositeEffect(const VibrateInfo &info, con } int32_t VibratorThread::PlayCompositeEffect(const VibrateInfo &info, const HdfCompositeEffect &hdfCompositeEffect, - const VibratorIdentifierIPC& identifier) + const VibratorIdentifierIPC& identifier) { std::unique_lock vibrateLck(vibrateMutex_); HdfCompositeEffect effectsPart; @@ -225,7 +225,7 @@ int32_t VibratorThread::PlayCompositeEffect(const VibrateInfo &info, const HdfCo #endif // HDF_DRIVERS_INTERFACE_VIBRATOR void VibratorThread::UpdateVibratorEffect(const VibrateInfo &info, const VibratorIdentifierIPC& identifier, - std::vector &waveInfos) + std::vector &waveInfos) { std::unique_lock lck(currentVibrationMutex_); currentVibration_ = info; -- Gitee From 9c27e80e9624ee93172779b07d18fd53e679dc71 Mon Sep 17 00:00:00 2001 From: hero100 Date: Tue, 15 Apr 2025 16:33:43 +0800 Subject: [PATCH 5/6] =?UTF-8?q?=E5=A4=9A=E8=AE=BE=E5=A4=87=E5=A4=9A?= =?UTF-8?q?=E9=A9=AC=E8=BE=BE5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hero100 --- .../js/napi/vibrator/src/vibrator_js.cpp | 7 +- .../vibrator/src/vibrator_service_client.cpp | 12 +- frameworks/native/vibrator/vibrator_agent.cpp | 24 +-- .../src/custom_vibration_matcher.cpp | 3 +- .../adapter/include/compatible_connection.h | 15 +- .../adapter/include/hdi_connection.h | 15 +- .../adapter/src/compatible_connection.cpp | 9 +- .../adapter/src/hdi_connection.cpp | 6 +- .../include/i_vibrator_hdi_connection.h | 18 ++- .../include/vibrator_hdi_connection.h | 18 ++- .../interface/src/vibrator_hdi_connection.cpp | 9 +- .../include/vibration_priority_manager.h | 3 +- .../src/miscdevice_service.cpp | 67 ++++++--- .../src/vibration_priority_manager.cpp | 35 ++--- .../vibrator/js/VibratorPatternJsunit.test.js | 121 ++++++++++++++++ .../vibrator/native/vibrator_agent_test.cpp | 137 +++++++++++++++++- 16 files changed, 397 insertions(+), 102 deletions(-) diff --git a/frameworks/js/napi/vibrator/src/vibrator_js.cpp b/frameworks/js/napi/vibrator/src/vibrator_js.cpp index a60aa92..0c06549 100644 --- a/frameworks/js/napi/vibrator/src/vibrator_js.cpp +++ b/frameworks/js/napi/vibrator/src/vibrator_js.cpp @@ -610,7 +610,7 @@ static napi_value Stop(napi_env env, napi_callback_info info) ThrowErr(env, PARAMETER_ERROR, "Parameters invalid"); return nullptr; } - if (argc >= PARAMETER_TWO && (IsMatchType(env, args[1], napi_function))) { + if (argc >= PARAMETER_TWO && IsMatchType(env, args[1], napi_function)) { return EmitAsyncWork(args[1], asyncCallbackInfo); } return EmitAsyncWork(nullptr, asyncCallbackInfo); @@ -828,7 +828,6 @@ static napi_value GetVibratorListSync(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_create_array(env, &jsArray)); std::vector vibratorInfo; int32_t ret = GetVibratorIdList(identifier, vibratorInfo); - if (ret == SUCCESS) { int32_t length = 0; for (auto& info : vibratorInfo) { @@ -850,7 +849,7 @@ static napi_value GetVibratorList(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr)); VibratorIdentifier identifier; - if (argc > 0 && IsMatchType(env, args[0], napi_number)) { + if (argc > 0) { if (!ParseVibratorIdentifier(env, args[0], identifier)) { MISC_HILOGW("deviceId and vibratorId is undefined, set default value deviceId = -1 and vibratorId = -1"); } @@ -1123,7 +1122,7 @@ static napi_value Off(napi_env env, napi_callback_info info) { ThrowErr(env, ret, "User callback unsubscribe fail"); return nullptr; } else if (ret == CALLBACK_UNSUBSCRIBED) { - MISC_HILOGW("User callback has been canceled"); + ThrowErr(env, ret, "User callback deregistered repeatedly"); return nullptr; } return nullptr; diff --git a/frameworks/native/vibrator/src/vibrator_service_client.cpp b/frameworks/native/vibrator/src/vibrator_service_client.cpp index c592c7b..9d4ccec 100644 --- a/frameworks/native/vibrator/src/vibrator_service_client.cpp +++ b/frameworks/native/vibrator/src/vibrator_service_client.cpp @@ -622,7 +622,6 @@ bool VibratorServiceClient::IsSupportVibratorCustom(const VibratorIdentifier &id int32_t ret = InitServiceClient(); if (ret != ERR_OK) { MISC_HILOGE("InitServiceClient failed, ret:%{public}d", ret); - return MISC_NATIVE_GET_SERVICE_ERR; } VibratorCapacity capacity_; std::lock_guard clientLock(clientMutex_); @@ -932,16 +931,15 @@ int32_t VibratorServiceClient::GetEffectInfo(const VibratorIdentifier& identifie #ifdef HIVIEWDFX_HITRACE_ENABLE FinishTrace(HITRACE_TAG_SENSORS); #endif // HIVIEWDFX_HITRACE_ENABLE -if (ret != ERR_OK) { - MISC_HILOGE("Get effect info list failed, [ret = %{public}d, deviceId = %{public}d, vibratorId = %{public}d,\ - effectType = %{public}s]", ret, identifier.deviceId, identifier.vibratorId, effectType.c_str()); - return ret; -} + if (ret != ERR_OK) { + MISC_HILOGE("Get effect info failed, [ret = %{public}d, deviceId = %{public}d, vibratorId = %{public}d,\ + effectType = %{public}s]", ret, identifier.deviceId, identifier.vibratorId, effectType.c_str()); + return ret; + } effectInfo.isSupportEffect = resInfo.isSupportEffect; return OHOS::Sensors::SUCCESS; } - void VibratorServiceClient::WriteVibratorHiSysIPCEvent(IMiscdeviceServiceIpcCode code, int32_t ret) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE diff --git a/frameworks/native/vibrator/vibrator_agent.cpp b/frameworks/native/vibrator/vibrator_agent.cpp index b95d020..68a70b9 100644 --- a/frameworks/native/vibrator/vibrator_agent.cpp +++ b/frameworks/native/vibrator/vibrator_agent.cpp @@ -75,7 +75,6 @@ bool SetLoopCountEnhanced(const VibratorIdentifier identifier, int32_t count) return true; } - int32_t StartVibrator(const char *effectId) { VibratorIdentifier identifier = { @@ -402,9 +401,8 @@ int32_t PlayPrimitiveEffectEnhanced(const VibratorIdentifier identifier, const c CHKPR(effectId, PARAMETER_ERROR); auto &client = VibratorServiceClient::GetInstance(); VibratorEffectParameter vibratorEffectParameter = client.GetVibratorEffectParameter(identifier); - int32_t ret = client.PlayPrimitiveEffect(identifier, effectId, intensity, - vibratorEffectParameter.usage, vibratorEffectParameter.systemUsage, - vibratorEffectParameter.loopCount); + int32_t ret = client.PlayPrimitiveEffect(identifier, effectId, intensity, vibratorEffectParameter.usage, + vibratorEffectParameter.systemUsage, vibratorEffectParameter.loopCount); client.SetUsage(identifier, USAGE_UNKNOWN, false); client.SetLoopCount(identifier, 1); if (ret != ERR_OK) { @@ -414,13 +412,14 @@ int32_t PlayPrimitiveEffectEnhanced(const VibratorIdentifier identifier, const c return SUCCESS; } -int32_t GetVibratorIdList(const VibratorIdentifier& param, std::vector& vibratorInfo) +int32_t GetVibratorIdList(const VibratorIdentifier& identifier, std::vector& vibratorInfo) { CALL_LOG_ENTER; - CHKCR(¶m, PARAMETER_ERROR, "Invalid parameters"); - MISC_HILOGD("VibratorIdentifier = [deviceId = %{public}d, vibratorId = %{public}d]", param.deviceId, param.vibratorId); + CHKCR(&identifier, PARAMETER_ERROR, "Invalid parameters"); + MISC_HILOGD("VibratorIdentifier = [deviceId = %{public}d, vibratorId = %{public}d]", identifier.deviceId, + identifier.vibratorId); auto &client = VibratorServiceClient::GetInstance(); - int32_t ret = client.GetVibratorIdList(param, vibratorInfo); + int32_t ret = client.GetVibratorIdList(identifier, vibratorInfo); if (ret != ERR_OK) { MISC_HILOGE("Get vibrator list failed, ret:%{public}d", ret); return NormalizeErrCode(ret); @@ -428,13 +427,14 @@ int32_t GetVibratorIdList(const VibratorIdentifier& param, std::vector waveInfo) +CustomVibrationMatcher::CustomVibrationMatcher(const VibratorIdentifierIPC& identifier, + std::vector waveInfo) { hdfWaveInfos_ = waveInfo; if (!hdfWaveInfos_.empty()) { diff --git a/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h b/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h index 22faf7a..7550ee2 100644 --- a/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h +++ b/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h @@ -31,21 +31,26 @@ public: int32_t Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier, const HdfCompositeEffect &hdfCompositeEffect) override; + int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier, + const HdfCompositeEffect &hdfCompositeEffect) override; bool IsVibratorRunning(const VibratorIdentifierIPC &identifier) override; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - std::optional GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effect) override; + std::optional GetEffectInfo(const VibratorIdentifierIPC &identifier, + const std::string &effect) override; int32_t Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR int32_t GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) override; int32_t GetVibratorCapacity(const VibratorIdentifierIPC &identifier, VibratorCapacity &capacity) override; int32_t PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) override; int32_t DestroyHdiConnection() override; - int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, int32_t intensity) override; + int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, + int32_t intensity) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR int32_t GetVibratorInfo(std::vector &hdfVibratorInfo) override; - int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier, std::vector &waveInfos) override; - int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier, std::vector &vibratorInfoIpc) override; + int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier, + std::vector &waveInfos) override; + int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier, + std::vector &vibratorInfoIpc) override; int32_t GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, HdfEffectInfo &effectInfo) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR diff --git a/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h b/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h index 1e138dd..7941d2c 100644 --- a/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h +++ b/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h @@ -37,10 +37,12 @@ public: int32_t Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier, const HdfCompositeEffect &hdfCompositeEffect) override; + int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier, + const HdfCompositeEffect &hdfCompositeEffect) override; bool IsVibratorRunning(const VibratorIdentifierIPC &identifier) override; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - std::optional GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effect) override; + std::optional GetEffectInfo(const VibratorIdentifierIPC &identifier, + const std::string &effect) override; int32_t Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR int32_t GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) override; @@ -48,11 +50,14 @@ public: int32_t PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) override; int32_t DestroyHdiConnection() override; void ProcessDeathObserver(const wptr &object); - int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, int32_t intensity) override; + int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, + int32_t intensity) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR int32_t GetVibratorInfo(std::vector &hdfVibratorInfo) override; - int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier, std::vector &waveInfos) override; - int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier, std::vector &vibratorInfoIpc) override; + int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier, + std::vector &waveInfos) override; + int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier, + std::vector &vibratorInfoIpc) override; int32_t GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, HdfEffectInfo &effectInfo) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR diff --git a/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp b/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp index 0df15c8..dacc3f7 100644 --- a/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp +++ b/services/miscdevice_service/hdi_connection/adapter/src/compatible_connection.cpp @@ -126,7 +126,8 @@ bool CompatibleConnection::IsVibratorRunning(const VibratorIdentifierIPC &identi } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM -std::optional CompatibleConnection::GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effect) +std::optional CompatibleConnection::GetEffectInfo(const VibratorIdentifierIPC &identifier, + const std::string &effect) { CALL_LOG_ENTER; HdfEffectInfo effectInfo; @@ -225,20 +226,20 @@ int32_t CompatibleConnection::GetVibratorInfo(std::vector &hdfV return ERR_OK; } int32_t CompatibleConnection::GetAllWaveInfo(const VibratorIdentifierIPC &identifier, - std::vector &waveInfos) + std::vector &waveInfos) { return ERR_OK; } int32_t CompatibleConnection::GetVibratorIdList(const VibratorIdentifierIPC &identifier, - std::vector &vibratorInfoIpc) + std::vector &vibratorInfoIpc) { CALL_LOG_ENTER; return ERR_OK; } int32_t CompatibleConnection::GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, - HdfEffectInfo &effectInfo) + HdfEffectInfo &effectInfo) { CALL_LOG_ENTER; return ERR_OK; diff --git a/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp b/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp index fd31a98..9da80fb 100644 --- a/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp +++ b/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp @@ -341,7 +341,7 @@ int32_t HdiConnection::GetAllWaveInfo(const VibratorIdentifierIPC &identifier, s } int32_t HdiConnection::GetVibratorIdList(const VibratorIdentifierIPC &identifier, - std::vector &vibratorInfo) + std::vector &vibratorInfo) { CHKPR(vibratorInterface_, ERR_INVALID_VALUE); int32_t ret = vibratorInterface_->GetVibratorIdSingle(identifier.deviceId, vibratorInfo); @@ -352,7 +352,7 @@ int32_t HdiConnection::GetVibratorIdList(const VibratorIdentifierIPC &identifier } int32_t HdiConnection::GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, - HdfEffectInfo &effectInfo) + HdfEffectInfo &effectInfo) { CHKPR(vibratorInterface_, ERR_INVALID_VALUE); int32_t ret = vibratorInterface_->GetEffectInfo(identifier.deviceId, identifier.vibratorId, effectType, effectInfo); @@ -388,4 +388,4 @@ DevicePlugCallback HdiConnection::GetVibratorPlugCb() return devicePlugCb_; } } // namespace Sensors -} // namespace OHOS +} // namespace OHOS \ No newline at end of file diff --git a/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h b/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h index ed445cf..50fc46d 100644 --- a/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h +++ b/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h @@ -58,22 +58,28 @@ public: virtual int32_t Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) = 0; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - virtual int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier, const HdfCompositeEffect &hdfCompositeEffect) = 0; + virtual int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier, + const HdfCompositeEffect &hdfCompositeEffect) = 0; virtual bool IsVibratorRunning(const VibratorIdentifierIPC &identifier) = 0; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - virtual std::optional GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effect) = 0; + virtual std::optional GetEffectInfo(const VibratorIdentifierIPC &identifier, + const std::string &effect) = 0; virtual int32_t Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) = 0; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR virtual int32_t DestroyHdiConnection() = 0; virtual int32_t GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) = 0; virtual int32_t GetVibratorCapacity(const VibratorIdentifierIPC &identifier, VibratorCapacity &capacity) = 0; virtual int32_t PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) = 0; - virtual int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, int32_t intensity) = 0; + virtual int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, + int32_t intensity) = 0; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR virtual int32_t GetVibratorInfo(std::vector &hdfVibratorInfo) = 0; - virtual int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier, std::vector &waveInfos) = 0; - virtual int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier, std::vector &hdfVibratorInfo) = 0; - virtual int32_t GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, HdfEffectInfo &effectInfo) = 0; + virtual int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier, + std::vector &waveInfos) = 0; + virtual int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier, + std::vector &hdfVibratorInfo) = 0; + virtual int32_t GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, + HdfEffectInfo &effectInfo) = 0; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR virtual int32_t RegisterVibratorPlugCallback(DevicePlugCallback cb) = 0; virtual DevicePlugCallback GetVibratorPlugCb() = 0; diff --git a/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h b/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h index ae1021a..d1cb5fe 100644 --- a/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h +++ b/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h @@ -31,22 +31,28 @@ public: int32_t Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier, const HdfCompositeEffect &hdfCompositeEffect) override; + int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier, + const HdfCompositeEffect &hdfCompositeEffect) override; bool IsVibratorRunning(const VibratorIdentifierIPC &identifier) override; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM - std::optional GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effect) override; + std::optional GetEffectInfo(const VibratorIdentifierIPC &identifier, + const std::string &effect) override; int32_t Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR int32_t DestroyHdiConnection() override; int32_t GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) override; int32_t GetVibratorCapacity(const VibratorIdentifierIPC &identifier, VibratorCapacity &capacity) override; int32_t PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) override; - int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, int32_t intensity) override; + int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect, + int32_t intensity) override; #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR int32_t GetVibratorInfo(std::vector &hdfVibratorInfo) override; - int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier, std::vector &waveInfos) override; - int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier, std::vector &hdfVibratorInfo) override; - int32_t GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, HdfEffectInfo &effectInfo) override; + int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier, + std::vector &waveInfos) override; + int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier, + std::vector &hdfVibratorInfo) override; + int32_t GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, + HdfEffectInfo &effectInfo) override; #endif // HDF_DRIVERS_INTERFACE_VIBRATOR int32_t RegisterVibratorPlugCallback(DevicePlugCallback cb) override; DevicePlugCallback GetVibratorPlugCb() override; diff --git a/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp b/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp index a1ca737..97edd9d 100644 --- a/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp +++ b/services/miscdevice_service/hdi_connection/interface/src/vibrator_hdi_connection.cpp @@ -200,19 +200,22 @@ int32_t VibratorHdiConnection::GetVibratorInfo(std::vector &hdf return iVibratorHdiConnection_->GetVibratorInfo(hdfVibratorInfo); } -int32_t VibratorHdiConnection::GetAllWaveInfo(const VibratorIdentifierIPC &identifier, std::vector &waveInfos) +int32_t VibratorHdiConnection::GetAllWaveInfo(const VibratorIdentifierIPC &identifier, + std::vector &waveInfos) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); return iVibratorHdiConnection_->GetAllWaveInfo(identifier, waveInfos); } -int32_t VibratorHdiConnection::GetVibratorIdList(const VibratorIdentifierIPC &identifier, std::vector &vibratorInfo) +int32_t VibratorHdiConnection::GetVibratorIdList(const VibratorIdentifierIPC &identifier, + std::vector &vibratorInfo) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); return iVibratorHdiConnection_->GetVibratorIdList(identifier, vibratorInfo); } -int32_t VibratorHdiConnection::GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, HdfEffectInfo &effectInfo) +int32_t VibratorHdiConnection::GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, + HdfEffectInfo &effectInfo) { CHKPR(iVibratorHdiConnection_, VIBRATOR_HDF_CONNECT_ERR); return iVibratorHdiConnection_->GetEffectInfo(identifier, effectType, effectInfo); diff --git a/services/miscdevice_service/include/vibration_priority_manager.h b/services/miscdevice_service/include/vibration_priority_manager.h index 64372b3..f177d43 100644 --- a/services/miscdevice_service/include/vibration_priority_manager.h +++ b/services/miscdevice_service/include/vibration_priority_manager.h @@ -94,7 +94,8 @@ public: #endif private: - bool IsCurrentVibrate(std::shared_ptr vibratorThread, const VibratorIdentifierIPC& identifier) const; + bool IsCurrentVibrate(std::shared_ptr vibratorThread, + const VibratorIdentifierIPC& identifier) const; bool IsLoopVibrate(const VibrateInfo &vibrateInfo) const; VibrateStatus ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo, VibrateInfo currentVibrateInfo) const; #ifdef OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD diff --git a/services/miscdevice_service/src/miscdevice_service.cpp b/services/miscdevice_service/src/miscdevice_service.cpp index a85132c..c506c94 100644 --- a/services/miscdevice_service/src/miscdevice_service.cpp +++ b/services/miscdevice_service/src/miscdevice_service.cpp @@ -68,7 +68,6 @@ constexpr int32_t INVALID_PID = -1; constexpr int32_t BASE_YEAR = 1900; constexpr int32_t BASE_MON = 1; constexpr int32_t CONVERSION_RATE = 1000; -// VibratorCapacity g_capacity; #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM const std::string PHONE_TYPE = "phone"; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM @@ -369,7 +368,8 @@ bool MiscdeviceService::ShouldIgnoreVibrate(const VibrateInfo &info, const Vibra return (ret != VIBRATION); } -int32_t MiscdeviceService::Vibrate(const VibratorIdentifierIPC& identifier, int32_t timeOut, int32_t usage, bool systemUsage) +int32_t MiscdeviceService::Vibrate(const VibratorIdentifierIPC& identifier, int32_t timeOut, int32_t usage, + bool systemUsage) { PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); @@ -405,8 +405,8 @@ int32_t MiscdeviceService::Vibrate(const VibratorIdentifierIPC& identifier, int3 } } MISC_HILOGI("Start vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, usage:%{public}d," - "vibratorId:%{public}d, duration:%{public}d", curVibrateTime.c_str(), info.packageName.c_str(), info.pid, - info.usage, identifier.vibratorId, info.duration); + "deviceId:%{public}d, vibratorId:%{public}d, duration:%{public}d", curVibrateTime.c_str(), + info.packageName.c_str(), info.pid, info.usage, identifier.vibratorId, identifier.deviceId, info.duration); return NO_ERROR; } @@ -512,8 +512,9 @@ int32_t MiscdeviceService::PlayVibratorEffect(const VibratorIdentifierIPC& ident } } MISC_HILOGI("Start vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, usage:%{public}d," - "vibratorId:%{public}d, duration:%{public}d, effect:%{public}s, count:%{public}d", curVibrateTime.c_str(), - info.packageName.c_str(), info.pid, info.usage, identifier.vibratorId, info.duration, info.effect.c_str(), info.count); + "deviceId:%{public}d, vibratorId:%{public}d, duration:%{public}d, effect:%{public}s, count:%{public}d", + curVibrateTime.c_str(), info.packageName.c_str(), info.pid, info.usage, identifier.deviceId, + identifier.vibratorId, info.duration, info.effect.c_str(), info.count); return NO_ERROR; } @@ -551,8 +552,7 @@ void MiscdeviceService::StartVibrateThread(VibrateInfo info, const VibratorIdent } #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM && HDF_DRIVERS_INTERFACE_VIBRATOR std::vector waveInfo; - if(GetAllWaveInfo(identifier, waveInfo) != ERR_OK) - { + if(GetAllWaveInfo(identifier, waveInfo) != ERR_OK) { MISC_HILOGE("GetAllWaveInfo failed"); return; } @@ -619,9 +619,9 @@ int32_t MiscdeviceService::StopVibratorByMode(const VibratorIdentifierIPC& ident } std::string packageName = GetPackageName(GetCallingTokenID()); std::string curVibrateTime = GetCurrentTime(); - MISC_HILOGI("Stop vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, vibratorId:%{public}d, \ - mode:%{public}s", curVibrateTime.c_str(), packageName.c_str(), GetCallingPid(), identifier.vibratorId, - mode.c_str()); + MISC_HILOGI("Stop vibrator, currentTime:%{public}s, package:%{public}s, pid:%{public}d, deviceId:%{public}d," + "vibratorId:%{public}d, mode:%{public}s", curVibrateTime.c_str(), packageName.c_str(), GetCallingPid(), + identifier.deviceId, identifier.vibratorId, mode.c_str()); return NO_ERROR; } @@ -695,8 +695,7 @@ int32_t MiscdeviceService::PlayVibratorCustom(const VibratorIdentifierIPC& ident .package = package, }; VibratorCapacity g_capacity; - if(GetHapticCapacityInfo(identifier, g_capacity) != ERR_OK) - { + if(GetHapticCapacityInfo(identifier, g_capacity) != ERR_OK) { MISC_HILOGE("GetVibratorCapacity failed"); return ERROR; } @@ -910,8 +909,7 @@ int32_t MiscdeviceService::PlayPattern(const VibratorIdentifierIPC& identifier, .systemUsage = systemUsage }; VibratorCapacity g_capacity; - if(GetHapticCapacityInfo(identifier, g_capacity) != ERR_OK) - { + if(GetHapticCapacityInfo(identifier, g_capacity) != ERR_OK) { MISC_HILOGE("GetVibratorCapacity failed"); return ERROR; } @@ -971,8 +969,7 @@ int32_t MiscdeviceService::GetDelayTime(const VibratorIdentifierIPC& identifier, std::string packageName = GetPackageName(GetCallingTokenID()); MISC_HILOGD("GetDelayTime, package:%{public}s", packageName.c_str()); VibratorCapacity g_capacity; - if(GetHapticCapacityInfo(identifier, g_capacity) != ERR_OK) - { + if(GetHapticCapacityInfo(identifier, g_capacity) != ERR_OK) { MISC_HILOGE("GetVibratorCapacity failed"); return ERROR; } @@ -1114,6 +1111,17 @@ void MiscdeviceService::RegisterClientDeathRecipient(sptr vibrat } vibratorServiceClient->AddDeathRecipient(clientDeathObserver_); SaveClientPid(vibratorServiceClient, pid); + std::lock_guard lockManage(devicesManageMutex_); + if (devicesManageMap_.empty()) { + MISC_HILOGI("No vibrator device online"); + return; + } + for (auto &value : devicesManageMap_) { + sptr clientProxy = iface_cast(vibratorServiceClient); + if (clientProxy != nullptr) { + clientProxy->ProcessPlugEvent(1, value.first); + } + } } void MiscdeviceService::UnregisterClientDeathRecipient(sptr vibratorServiceClient) @@ -1248,7 +1256,7 @@ int32_t MiscdeviceService::GetVibratorIdList(const VibratorIdentifierIPC& identi if (ret != PERMISSION_GRANTED) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_PERMISSIONS_EXCEPTION", - HiSysEvent::EventType::SECURITY, "PKG_NAME", "PlayPrimitiveEffectStub", "ERROR_CODE", ret); + HiSysEvent::EventType::SECURITY, "PKG_NAME", "GetVibratorIdList", "ERROR_CODE", ret); #endif // HIVIEWDFX_HISYSEVENT_ENABLE MISC_HILOGE("CheckVibratePermission failed, ret:%{public}d", ret); return PERMISSION_DENIED; @@ -1298,14 +1306,27 @@ int32_t MiscdeviceService::GetEffectInfo(const VibratorIdentifierIPC& identifier if (ret != PERMISSION_GRANTED) { #ifdef HIVIEWDFX_HISYSEVENT_ENABLE HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_PERMISSIONS_EXCEPTION", - HiSysEvent::EventType::SECURITY, "PKG_NAME", "PlayPrimitiveEffectStub", "ERROR_CODE", ret); + HiSysEvent::EventType::SECURITY, "PKG_NAME", "GetEffectInfo", "ERROR_CODE", ret); #endif // HIVIEWDFX_HISYSEVENT_ENABLE MISC_HILOGE("CheckVibratePermission failed, ret:%{public}d", ret); return PERMISSION_DENIED; } identifier.Dump(); + if (devicesManageMap_.empty()) { + MISC_HILOGI("No vibrator device online"); + return NO_ERROR; + } + VibratorIdentifierIPC localIdentifier; + if (identifier.deviceId == -1) { + for (const auto& pair : devicesManageMap_) { + for (const auto& info : pair.second.baseInfo) { + info.isLocalVibrator ? (localIdentifier.deviceId = info.deviceId) : 0; + } + } + } HdfEffectInfo hdfEffectInfo; - ret = vibratorHdiConnection_.GetEffectInfo(identifier, effectType, hdfEffectInfo); + ret = vibratorHdiConnection_.GetEffectInfo((identifier.deviceId == -1) ? localIdentifier : identifier, + effectType, hdfEffectInfo); if (ret != NO_ERROR) { MISC_HILOGE("HDI::GetEffectInfo return error"); return ERROR; @@ -1320,8 +1341,7 @@ int32_t MiscdeviceService::GetVibratorCapacity(const VibratorIdentifierIPC& iden { CALL_LOG_ENTER; VibratorCapacity g_capacity; - if(GetHapticCapacityInfo(identifier, g_capacity) != ERR_OK) - { + if(GetHapticCapacityInfo(identifier, g_capacity) != ERR_OK) { MISC_HILOGE("GetVibratorCapacity failed"); return ERROR; } @@ -1346,7 +1366,8 @@ std::shared_ptr MiscdeviceService::GetVibratorThread(const Vibra return nullptr; } -int32_t MiscdeviceService::GetHapticCapacityInfo(const VibratorIdentifierIPC& identifier, VibratorCapacity& capacityInfo) +int32_t MiscdeviceService::GetHapticCapacityInfo(const VibratorIdentifierIPC& identifier, + VibratorCapacity& capacityInfo) { CALL_LOG_ENTER; std::lock_guard lock(devicesManageMutex_); diff --git a/services/miscdevice_service/src/vibration_priority_manager.cpp b/services/miscdevice_service/src/vibration_priority_manager.cpp index 99084b7..5d90305 100644 --- a/services/miscdevice_service/src/vibration_priority_manager.cpp +++ b/services/miscdevice_service/src/vibration_priority_manager.cpp @@ -673,22 +673,22 @@ VibrateStatus VibrationPriorityManager::ShouldIgnoreVibrate(const VibrateInfo &v return IGNORE_GLOBAL_SETTINGS; } #endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB - if ((vibrateInfo.usage == USAGE_ALARM || vibrateInfo.usage == USAGE_RING - || vibrateInfo.usage == USAGE_NOTIFICATION || vibrateInfo.usage == USAGE_COMMUNICATION) - && (miscAudioRingerMode_ == RINGER_MODE_SILENT)) { - MISC_HILOGD("Vibration is ignored for ringer mode:%{public}d", static_cast(miscAudioRingerMode_)); - return IGNORE_RINGER_MODE; - } - if (((vibrateInfo.usage == USAGE_TOUCH || vibrateInfo.usage == USAGE_MEDIA || vibrateInfo.usage == USAGE_UNKNOWN - || vibrateInfo.usage == USAGE_PHYSICAL_FEEDBACK || vibrateInfo.usage == USAGE_SIMULATE_REALITY) - && (miscFeedback_ == FEEDBACK_MODE_OFF)) - #ifdef OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD - && !ShouldIgnoreInputMethod(vibrateInfo)) { - #else // OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD - ) { - #endif // OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD - MISC_HILOGD("Vibration is ignored for feedback:%{public}d", static_cast(miscFeedback_)); - return IGNORE_FEEDBACK; + if ((vibrateInfo.usage == USAGE_ALARM || vibrateInfo.usage == USAGE_RING + || vibrateInfo.usage == USAGE_NOTIFICATION || vibrateInfo.usage == USAGE_COMMUNICATION) + && (miscAudioRingerMode_ == RINGER_MODE_SILENT)) { + MISC_HILOGD("Vibration is ignored for ringer mode:%{public}d", static_cast(miscAudioRingerMode_)); + return IGNORE_RINGER_MODE; + } + if (((vibrateInfo.usage == USAGE_TOUCH || vibrateInfo.usage == USAGE_MEDIA || vibrateInfo.usage == USAGE_UNKNOWN + || vibrateInfo.usage == USAGE_PHYSICAL_FEEDBACK || vibrateInfo.usage == USAGE_SIMULATE_REALITY) + && (miscFeedback_ == FEEDBACK_MODE_OFF)) +#ifdef OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD + && !ShouldIgnoreInputMethod(vibrateInfo)) { +#else // OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD + ) { +#endif // OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD + MISC_HILOGD("Vibration is ignored for feedback:%{public}d", static_cast(miscFeedback_)); + return IGNORE_FEEDBACK; } } } @@ -717,7 +717,8 @@ bool VibrationPriorityManager::IsCurrentVibrate(std::shared_ptr const VibratorIdentifierIPC& identifier) const { #if defined(OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM) && defined(HDF_DRIVERS_INTERFACE_VIBRATOR) - return ((vibratorThread != nullptr) && (vibratorThread->IsRunning() || VibratorDevice.IsVibratorRunning(identifier))); + return ((vibratorThread != nullptr) && (vibratorThread->IsRunning() || + VibratorDevice.IsVibratorRunning(identifier))); #else return ((vibratorThread != nullptr) && (vibratorThread->IsRunning())); #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM && HDF_DRIVERS_INTERFACE_VIBRATOR diff --git a/test/unittest/vibrator/js/VibratorPatternJsunit.test.js b/test/unittest/vibrator/js/VibratorPatternJsunit.test.js index 16e2472..2d058c5 100644 --- a/test/unittest/vibrator/js/VibratorPatternJsunit.test.js +++ b/test/unittest/vibrator/js/VibratorPatternJsunit.test.js @@ -1389,4 +1389,125 @@ describe("VibratorJsTest", function () { done(); } }) + + /* + * @tc.name: VibratorJsTest019 + * @tc.desc: Test for getting the vibrator list. + * @tc.number: SUB_SensorSystem_Vibrator_JsTest_0190 + */ + it("VibratorJsTest019", 0, async function (done) { + try { + const vibrators = await GetVibratorList(); + console.info('Vibrator List:', vibrators); + expect(vibrators).toBeDefined(); + expect(Array.isArray(vibrators)).toBe(true); + done(); + } catch (error) { + console.error('VibratorJsTest019 failed with error:', error); + expect(false).toBe(true); + done(); + } + }) + + /* + * @tc.name: VibratorJsTest020 + * @tc.desc: Test for getting the vibrator list synchronously. + * @tc.number: SUB_SensorSystem_Vibrator_JsTest_0200 + */ + it("VibratorJsTest020", 0, function (done) { + try { + const vibrators = GetVibratorListSync(); + expect(vibrators).toBeDefined(); + expect(Array.isArray(vibrators)).toBe(true); + expect(vibrators.length).toBeGreaterThan(0); + done(); + } catch (error) { + console.error('VibratorJsTest020 failed with error:', error); + expect(false).toBe(true); + done(); + } + }) + + /* + * @tc.name: VibratorJsTest021 + * @tc.desc: Test for checking support for effect types. + * @tc.number: SUB_SensorSystem_Vibrator_JsTest_0210 + */ + it("VibratorJsTest021", 0, async function (done) { + const effectType = "effect1"; + try { + const effectInfo = await isSupportEffectInfo(effectType, params); + expect(effectInfo).toBeUndefined(); + expect(typeof effectInfo).toBe('object'); + done(); + } catch (error) { + console.error('VibratorJsTest021 failed with error:', error); + expect(false).toBe(true); + done(); + } + }) + + /* + * @tc.name: VibratorJsTest022 + * @tc.desc: Test for checking support for effect types synchronously. + * @tc.number: SUB_SensorSystem_Vibrator_JsTest_0220 + */ + it("VibratorJsTest022", 0, function (done) { + const effectType = "effect1"; + try { + const effectInfo = isSupportEffectInfoSync(effectType); + expect(effectInfo).toBeDefined(); + expect(typeof effectInfo).toBe('object'); + done(); + } catch (error) { + console.error('VibratorJsTest022 failed with error:', error); + expect(false).toBe(true); + done(); + } + }) + + /* + * @tc.name: VibratorJsTest023 + * @tc.desc: Test the on function for VIBRATOR_DEVICE_STATE_CHANGE with valid and invalid parameters. + * @tc.number: SUB_SensorSystem_Vibrator_JsTest_0230 + */ + it("VibratorJsTest023", 0, function (done) { + try { + const validCallback = function (deviceInfo) { + console.info('Valid callback executed with deviceInfo:', deviceInfo); + expect(deviceInfo).toBeDefined(); + expect(typeof deviceInfo).toBe('object'); + }; + on(VibratorStateEventType.VIBRATOR_DEVICE_STATE_CHANGE, validCallback); + done(); + } catch (error) { + console.error('VibratorJsTest023 failed with error:', error); + expect(false).toBe(true); + done(); + } + }) + + /* + * @tc.name: VibratorJsTest023 + * @tc.desc: Test the off function for VIBRATOR_DEVICE_STATE_CHANGE events. + * @tc.number: SUB_SensorSystem_Vibrator_JsTest_0230 + */ + it("VibratorJsTest012", 0, function (done) { + const eventType = VibratorStateEventType.VIBRATOR_DEVICE_STATE_CHANG + const callback = jest.fn((info) => { + vibratorInfo = info; + }); + try { + on(eventType, callback); + off(eventType, callback); + expect(() => { + off(eventType, null); + }).not.toThrow(); + done(); + } catch (error) { + console.error('VibratorJsTest012 failed with error:', error); + expect(false).toBe(true); + done(); + } + }) }) \ No newline at end of file diff --git a/test/unittest/vibrator/native/vibrator_agent_test.cpp b/test/unittest/vibrator/native/vibrator_agent_test.cpp index e1c063a..4bf7cc5 100644 --- a/test/unittest/vibrator/native/vibrator_agent_test.cpp +++ b/test/unittest/vibrator/native/vibrator_agent_test.cpp @@ -64,6 +64,14 @@ HapInfoParams g_infoManagerTestInfoParms = { .instIndex = 0, .appIDDesc = "vibratorAgentTest" }; + +void TestCallBack(VibratorDeviceInfo *deviceInfo) { + return; +} + +constexpr VibratorUser testUser = { + .callback = TestCallBack; +} } // namespace class VibratorAgentTest : public testing::Test { @@ -1611,7 +1619,8 @@ HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_003, TestSize.Level1) .deviceId = -1, .vibratorId = -1, }; - bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); + bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && + IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); if (isSupport) { bool flag = SetLoopCountEnhanced(identifier, 2); ASSERT_TRUE(flag); @@ -1638,7 +1647,8 @@ HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_004, TestSize.Level1) .deviceId = -1, .vibratorId = -1, }; - bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); + bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && + IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); if (isSupport) { bool flag = SetUsageEnhanced(identifier, USAGE_ALARM); ASSERT_TRUE(flag); @@ -1665,7 +1675,8 @@ HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_005, TestSize.Level1) .deviceId = -1, .vibratorId = -1, }; - bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); + bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && + IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); if (isSupport) { bool flag = SetUsageEnhanced(identifier, USAGE_UNKNOWN); ASSERT_TRUE(flag); @@ -1692,7 +1703,8 @@ HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_006, TestSize.Level1) .deviceId = -1, .vibratorId = -1, }; - bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); + bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && + IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); @@ -1719,7 +1731,8 @@ HWTEST_F(VibratorAgentTest, PlayVibratorCustomEnhanced_007, TestSize.Level1) .deviceId = -1, .vibratorId = -1, }; - bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); + bool isSupport = (IsSupportVibratorCustomEnhanced(identifier) && + IsSupportVibratorEffectEnhanced(identifier, VIBRATOR_TYPE_FAIL)); if (isSupport) { FileDescriptor fileDescriptor("/data/test/vibrator/on_carpet.json"); MISC_HILOGD("Test fd:%{public}d", fileDescriptor.fd); @@ -2609,5 +2622,119 @@ HWTEST_F(VibratorAgentTest, IsHdHapticSupportedEnhanced_001, TestSize.Level1) } CancelEnhanced(identifier); } + +HWTEST_F(VibratorAgentTest, GetVibratorIdList_001, TestSize.Level1) +{ + MISC_HILOGI("GetVibratorIdList_001 in"); + VibratorIdentifier identifier = { + .deviceId = -1, + .vibratorId = -1, + }; + std::vector result; + int32_t ret = GetVibratorIdList(identifier, result); + ASSERT_EQ(ret, OHOS::Sensors::SUCCESS); +} + +HWTEST_F(VibratorAgentTest, GetVibratorIdList_002, TestSize.Level1) +{ + MISC_HILOGI("GetVibratorIdList_002 in"); + VibratorIdentifier identifier = { + .deviceId = -1, + .vibratorId = 1, + }; + std::vector result; + int32_t ret = GetVibratorIdList(identifier, result); + ASSERT_EQ(ret, OHOS::Sensors::SUCCESS); +} + +HWTEST_F(VibratorAgentTest, GetVibratorIdList_003, TestSize.Level1) +{ + MISC_HILOGI("GetVibratorIdList_003 in"); + VibratorIdentifier identifier = { + .deviceId = 1, + .vibratorId = -1, + }; + std::vector result; + int32_t ret = GetVibratorIdList(identifier, result); + ASSERT_EQ(ret, OHOS::Sensors::SUCCESS); +} + +HWTEST_F(VibratorAgentTest, GetVibratorIdList_004, TestSize.Level1) +{ + MISC_HILOGI("GetVibratorIdList_004 in"); + VibratorIdentifier identifier = { + .deviceId = 1, + .vibratorId = 1, + }; + std::vector result; + int32_t ret = GetVibratorIdList(identifier, result); + ASSERT_EQ(ret, OHOS::Sensors::SUCCESS); +} + +HWTEST_F(VibratorAgentTest, GetVibratorIdList_004, TestSize.Level1) +{ + MISC_HILOGI("GetVibratorIdList_004 in"); + VibratorIdentifier identifier = { + .deviceId = -9999, + .vibratorId = 1, + }; + std::vector result; + int32_t ret = GetVibratorIdList(identifier, result); + ASSERT_EQ(ret, OHOS::Sensors::SUCCESS); +} + +HWTEST_F(VibratorAgentTest, GetEffectInfo_001, TestSize.Level1) +{ + MISC_HILOGI("GetEffectInfo_001 in"); + VibratorIdentifier identifier = { + .deviceId = 1, + .vibratorId = -1, + }; + std::string effectType = ""; + EffectInfo result; + int32_t ret = GetEffectInfo(identifier, effectType, result); + ASSERT_EQ(ret, OHOS::Sensors::SUCCESS); +} + +HWTEST_F(VibratorAgentTest, GetEffectInfo_002, TestSize.Level1) +{ + MISC_HILOGI("GetEffectInfo_002 in"); + VibratorIdentifier identifier = { + .deviceId = -1, + .vibratorId = -1, + }; + std::string effectType = ""; + EffectInfo result; + int32_t ret = GetEffectInfo(identifier, effectType, result); + ASSERT_EQ(ret, OHOS::Sensors::SUCCESS); +} + +HWTEST_F(VibratorAgentTest, SubscribeVibrator_001, TestSize.Level1) +{ + MISC_HILOGI("SubscribeVibrator_001 in"); + int32_t ret = SubscribeVibrator(testUser); + ASSERT_EQ(ret, OHOS::Sensors::SUCCESS); +} + +HWTEST_F(VibratorAgentTest, SubscribeVibrator_002, TestSize.Level1) +{ + VibratorUser invalidUser = { + .callback = nullptr; + } + MISC_HILOGI("SubscribeVibrator_002 in"); + int32_t ret = SubscribeVibrator(invalidUser); + ASSERT_EQ(ret, OHOS::Sensors::ERROR); +} + +HWTEST_F(VibratorAgentTest, UnSubscribeVibrator_001, TestSize.Level1) +{ + MISC_HILOGI("UnSubscribeVibrator_001 in"); + int32_t ret = UnSubscribeVibrator(testUser); + ASSERT_EQ(ret, OHOS::Sensors::SUCCESS); + int32_t ret = UnSubscribeVibrator(testUser); + ASSERT_EQ(ret, OHOS::Sensors::CALLBACK_UNSUBSCRIBED); +} + + } // namespace Sensors } // namespace OHOS -- Gitee From dbbe89c48caf6ca62c67a13040c11aacb5f023d2 Mon Sep 17 00:00:00 2001 From: hero100 Date: Thu, 17 Apr 2025 09:30:06 +0800 Subject: [PATCH 6/6] =?UTF-8?q?=E5=A4=9A=E8=AE=BE=E5=A4=87=E5=A4=9A?= =?UTF-8?q?=E9=A9=AC=E8=BE=BE6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hero100 --- .../vibrator/src/vibrator_client_stub.cpp | 2 +- .../vibrator/src/vibrator_service_client.cpp | 3 +- .../adapter/src/hdi_connection.cpp | 4 +- .../include/miscdevice_service.h | 2 +- .../include/vibration_priority_manager.h | 2 +- .../src/miscdevice_service.cpp | 156 +++++++++++------- .../src/vibration_priority_manager.cpp | 40 +++-- .../vibrator/native/vibrator_agent_test.cpp | 4 +- utils/common/include/vibrator_infos.h | 3 + 9 files changed, 123 insertions(+), 93 deletions(-) diff --git a/frameworks/native/vibrator/src/vibrator_client_stub.cpp b/frameworks/native/vibrator/src/vibrator_client_stub.cpp index 62a755a..d276363 100644 --- a/frameworks/native/vibrator/src/vibrator_client_stub.cpp +++ b/frameworks/native/vibrator/src/vibrator_client_stub.cpp @@ -66,7 +66,7 @@ int VibratorClientStub::ProcessPlugEvent(int32_t eventCode, int32_t deviceId) auto &client = VibratorServiceClient::GetInstance(); bool ret = client.HandleVibratorData(info); if (!ret) { - MISC_HILOGD("Handle bibrator data failed, ret:%{public}d", ret); + MISC_HILOGE("Handle bibrator data failed, ret:%{public}d", ret); return PARAMETER_ERROR; } MISC_HILOGD("Success to process plug event"); diff --git a/frameworks/native/vibrator/src/vibrator_service_client.cpp b/frameworks/native/vibrator/src/vibrator_service_client.cpp index 9d4ccec..e9e5535 100644 --- a/frameworks/native/vibrator/src/vibrator_service_client.cpp +++ b/frameworks/native/vibrator/src/vibrator_service_client.cpp @@ -121,7 +121,8 @@ int32_t VibratorServiceClient::TransferClientRemoteObject() int32_t VibratorServiceClient::Vibrate(const VibratorIdentifier &identifier, int32_t timeOut, int32_t usage, bool systemUsage) { - MISC_HILOGD("Vibrate begin, time:%{public}d, usage:%{public}d", timeOut, usage); + MISC_HILOGD("Vibrate begin, time:%{public}d, usage:%{public}d, deviceId:%{public}d, vibratorId:%{public}d", + timeOut, usage, identifier.deviceId, identifier.vibratorId); int32_t ret = InitServiceClient(); if (ret != ERR_OK) { MISC_HILOGE("InitServiceClient failed, ret:%{public}d", ret); diff --git a/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp b/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp index 9da80fb..6977dc1 100644 --- a/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp +++ b/services/miscdevice_service/hdi_connection/adapter/src/hdi_connection.cpp @@ -341,7 +341,7 @@ int32_t HdiConnection::GetAllWaveInfo(const VibratorIdentifierIPC &identifier, s } int32_t HdiConnection::GetVibratorIdList(const VibratorIdentifierIPC &identifier, - std::vector &vibratorInfo) + std::vector &vibratorInfo) { CHKPR(vibratorInterface_, ERR_INVALID_VALUE); int32_t ret = vibratorInterface_->GetVibratorIdSingle(identifier.deviceId, vibratorInfo); @@ -352,7 +352,7 @@ int32_t HdiConnection::GetVibratorIdList(const VibratorIdentifierIPC &identifier } int32_t HdiConnection::GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, - HdfEffectInfo &effectInfo) + HdfEffectInfo &effectInfo) { CHKPR(vibratorInterface_, ERR_INVALID_VALUE); int32_t ret = vibratorInterface_->GetEffectInfo(identifier.deviceId, identifier.vibratorId, effectType, effectInfo); diff --git a/services/miscdevice_service/include/miscdevice_service.h b/services/miscdevice_service/include/miscdevice_service.h index 75d3343..0883a24 100644 --- a/services/miscdevice_service/include/miscdevice_service.h +++ b/services/miscdevice_service/include/miscdevice_service.h @@ -114,7 +114,7 @@ private: int32_t RegisterVibratorPlugCb(); std::shared_ptr GetVibratorThread(const VibratorIdentifierIPC& identifier); void StopVibrateThread(std::shared_ptr vibratorThread); - bool ShouldIgnoreVibrate(const VibrateInfo &info, const VibratorIdentifierIPC& identifier, bool isLocalDevice); + bool ShouldIgnoreVibrate(const VibrateInfo &info, const VibratorIdentifierIPC& identifier); std::string GetCurrentTime(); void MergeVibratorParmeters(const VibrateParameter ¶meter, VibratePackage &package); bool CheckVibratorParmeters(const VibrateParameter ¶meter); diff --git a/services/miscdevice_service/include/vibration_priority_manager.h b/services/miscdevice_service/include/vibration_priority_manager.h index f177d43..ca6c004 100644 --- a/services/miscdevice_service/include/vibration_priority_manager.h +++ b/services/miscdevice_service/include/vibration_priority_manager.h @@ -81,7 +81,7 @@ public: DISALLOW_COPY_AND_MOVE(VibrationPriorityManager); bool Init(); VibrateStatus ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo, - std::shared_ptr vibratorThread, const VibratorIdentifierIPC& identifier, bool isLocalDevice); + std::shared_ptr vibratorThread, const VibratorIdentifierIPC& identifier); #ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB void InitDoNotDisturbData(); void UpdateCurrentUserId(); diff --git a/services/miscdevice_service/src/miscdevice_service.cpp b/services/miscdevice_service/src/miscdevice_service.cpp index c506c94..db0f9fb 100644 --- a/services/miscdevice_service/src/miscdevice_service.cpp +++ b/services/miscdevice_service/src/miscdevice_service.cpp @@ -351,8 +351,7 @@ void MiscdeviceService::OnStop() #endif // MEMMGR_ENABLE } -bool MiscdeviceService::ShouldIgnoreVibrate(const VibrateInfo &info, const VibratorIdentifierIPC& identifier, - bool isLocalDevice) +bool MiscdeviceService::ShouldIgnoreVibrate(const VibrateInfo &info, const VibratorIdentifierIPC& identifier) { std::lock_guard lock(isVibrationPriorityReadyMutex_); if (!isVibrationPriorityReady_) { @@ -361,7 +360,7 @@ bool MiscdeviceService::ShouldIgnoreVibrate(const VibrateInfo &info, const Vibra } std::string curVibrateTime = GetCurrentTime(); auto vibratorThread_ = GetVibratorThread(identifier); - int32_t ret = PriorityManager->ShouldIgnoreVibrate(info, vibratorThread_, identifier, isLocalDevice); + int32_t ret = PriorityManager->ShouldIgnoreVibrate(info, vibratorThread_, identifier); if (ret != VIBRATION) { MISC_HILOGE("ShouldIgnoreVibrate currentTime:%{public}s, ret:%{public}d", curVibrateTime.c_str(), ret); } @@ -1056,7 +1055,6 @@ int32_t MiscdeviceService::TransferClientRemoteObject(const sptr MISC_HILOGE("ClientPid is invalid, clientPid:%{public}d", clientPid); return ERROR; } - RegisterClientDeathRecipient(vibratorServiceClient, clientPid); return ERR_OK; } @@ -1371,26 +1369,48 @@ int32_t MiscdeviceService::GetHapticCapacityInfo(const VibratorIdentifierIPC& id { CALL_LOG_ENTER; std::lock_guard lock(devicesManageMutex_); - auto deviceIt = devicesManageMap_.find(identifier.deviceId); - if (deviceIt == devicesManageMap_.end()) { - MISC_HILOGE("No vibrator information found for device ID: %{public}d", identifier.deviceId); - return PARAMETER_ERROR; + if (identifier.deviceId == -1) { + for (const auto& pair : devicesManageMap_) { + for (const auto& info : pair.second.baseInfo) { + if (info.isLocalVibrator) { + capacityInfo = pair.second.capacityInfo; + return ERR_OK; + } + } + } + }else { + auto deviceIt = devicesManageMap_.find(identifier.deviceId); + if (deviceIt != devicesManageMap_.end()) { + capacityInfo = deviceIt->second.capacityInfo; + return ERR_OK; + } } - capacityInfo = deviceIt->second.capacityInfo; - return ERR_OK; + MISC_HILOGE("No vibrator information found for device ID: %{public}d", identifier.deviceId); + return PARAMETER_ERROR; } int32_t MiscdeviceService::GetAllWaveInfo(const VibratorIdentifierIPC& identifier, std::vector& waveInfo) { CALL_LOG_ENTER; - auto deviceIt = devicesManageMap_.find(identifier.deviceId); - if (deviceIt == devicesManageMap_.end()) { - MISC_HILOGE("No vibrator information found for device ID: %{public}d", identifier.deviceId); - return PARAMETER_ERROR; + if (identifier.deviceId == -1) { + for (const auto& pair : devicesManageMap_) { + for (const auto& info : pair.second.baseInfo) { + if (info.isLocalVibrator) { + waveInfo = pair.second.waveInfo; + return ERR_OK; + } + } + } + }else { + auto deviceIt = devicesManageMap_.find(identifier.deviceId); + if (deviceIt != devicesManageMap_.end()) { + waveInfo = deviceIt->second.waveInfo; + return ERR_OK; + } } - waveInfo = deviceIt->second.waveInfo; - return ERR_OK; + MISC_HILOGE("No vibrator information found for device ID: %{public}d", identifier.deviceId); + return PARAMETER_ERROR; } int32_t MiscdeviceService::GetHapticStartUpTime(const VibratorIdentifierIPC& identifier, int32_t mode, @@ -1507,72 +1527,80 @@ int32_t MiscdeviceService::StartVibrateThreadControl(const VibratorIdentifierIPC { std::string curVibrateTime = GetCurrentTime(); std::vector result = CheckDeviceIdIsValid(identifier); - int ignoreVibrateNum = 0; - if(result.empty()) - { + if (result.empty()) { MISC_HILOGD("No vibration found"); return ERROR; } - for (const auto& paramIt : result) { - if (ShouldIgnoreVibrate(info, paramIt, identifier.deviceId == -1)) { - ignoreVibrateNum ++; - continue; + + int32_t vibratorIndex = 0; + int32_t ignoreVibrateNum = 0; + + const std::vector specialModes = { + VIBRATE_CUSTOM_HD, VIBRATE_CUSTOM_COMPOSITE_EFFECT, + VIBRATE_CUSTOM_COMPOSITE_TIME, VIBRATE_BUTT + }; + if (std::find(specialModes.begin(), specialModes.end(), info.mode) != specialModes.end()) { + if (!info.package.patterns.empty()) { + vibratorIndex = info.package.patterns[0].events[0].index; } - StartVibrateThread(info, paramIt); + MISC_HILOGD("Info mode:%{public}s, vibratorIndex:%{public}d", info.mode.c_str(), vibratorIndex); } - if(ignoreVibrateNum == result.size()) { - return ERROR; + + for (const auto& paramIt : result) { + bool shouldProcess = (vibratorIndex == 0) || (paramIt.position == vibratorIndex); + if (paramIt.isLocalVibrator && ShouldIgnoreVibrate(info, paramIt)) { + if (shouldProcess) { + ignoreVibrateNum++; + continue; + } + } + if (shouldProcess) { + StartVibrateThread(info, paramIt); + } } - return ERR_OK; -} + return (ignoreVibrateNum == result.size()) ? ERROR : ERR_OK; +} std::vector MiscdeviceService::CheckDeviceIdIsValid(const VibratorIdentifierIPC& identifier) { CALL_LOG_ENTER; std::vector result; - if(identifier.deviceId == -1 && identifier.vibratorId == -1) { - for (const auto& pair : devicesManageMap_) { - for (const auto& info : pair.second.baseInfo) { - if (info.isLocalVibrator) { - VibratorIdentifierIPC newIdentifier; - newIdentifier.deviceId = info.deviceId; - newIdentifier.vibratorId = info.vibratorId; - result.push_back(newIdentifier); - } + + auto addToResult = [&](const auto& info) { + VibratorIdentifierIPC newIdentifier; + newIdentifier.deviceId = identifier.deviceId == -1 ? info.deviceId : identifier.deviceId; + newIdentifier.vibratorId = info.vibratorId; + newIdentifier.position = info.position; + newIdentifier.isLocalVibrator = info.isLocalVibrator; + result.push_back(newIdentifier); + MISC_HILOGD("Push result in list,:%{public}d,:%{public}d", newIdentifier.deviceId, newIdentifier.vibratorId); + }; + + auto processDevice = [&](const auto& device) { + for (const auto& info : device.second.baseInfo) { + bool shouldAdd = true; + if (identifier.deviceId == -1 && identifier.vibratorId != -1) { + shouldAdd = info.isLocalVibrator && info.vibratorId == identifier.vibratorId; + } else if (identifier.deviceId != -1 && identifier.vibratorId != -1) { + shouldAdd = info.vibratorId == identifier.vibratorId; + } else if (identifier.deviceId == -1 && identifier.vibratorId == -1) { + shouldAdd = info.isLocalVibrator; } - } - }else if(identifier.deviceId != -1 && identifier.vibratorId == -1) { - auto deviceIt = devicesManageMap_.find(identifier.deviceId); - if (deviceIt != devicesManageMap_.end()) { - for (const auto& info : deviceIt->second.baseInfo) { - VibratorIdentifierIPC newIdentifier; - newIdentifier.deviceId = identifier.deviceId; - newIdentifier.vibratorId = info.vibratorId; - result.push_back(newIdentifier); + + if (shouldAdd) { + addToResult(info); } } - } else if(identifier.deviceId != -1 && identifier.vibratorId != -1) { + }; + + if (identifier.deviceId != -1) { auto deviceIt = devicesManageMap_.find(identifier.deviceId); if (deviceIt != devicesManageMap_.end()) { - for (const auto& info : deviceIt->second.baseInfo) { - if (info.vibratorId == identifier.vibratorId) { - VibratorIdentifierIPC newIdentifier; - newIdentifier.deviceId = identifier.deviceId; - newIdentifier.vibratorId = info.vibratorId; - result.push_back(newIdentifier); - } - } + processDevice(*deviceIt); } - } else if(identifier.deviceId == -1 && identifier.vibratorId != -1) { + } else { for (const auto& pair : devicesManageMap_) { - for (const auto& info : pair.second.baseInfo) { - if (info.isLocalVibrator && info.vibratorId == identifier.vibratorId) { - VibratorIdentifierIPC newIdentifier; - newIdentifier.deviceId = info.deviceId; - newIdentifier.vibratorId = info.vibratorId; - result.push_back(newIdentifier); - } - } + processDevice(pair); } } return result; diff --git a/services/miscdevice_service/src/vibration_priority_manager.cpp b/services/miscdevice_service/src/vibration_priority_manager.cpp index 5d90305..67f004e 100644 --- a/services/miscdevice_service/src/vibration_priority_manager.cpp +++ b/services/miscdevice_service/src/vibration_priority_manager.cpp @@ -662,34 +662,32 @@ bool VibrationPriorityManager::ShouldIgnoreInputMethod(const VibrateInfo &vibrat #endif // OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD VibrateStatus VibrationPriorityManager::ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo, - std::shared_ptr vibratorThread, const VibratorIdentifierIPC& identifier, bool isLocalDevice) + std::shared_ptr vibratorThread, const VibratorIdentifierIPC& identifier) { UpdateStatus(); - if(isLocalDevice) { //本机的优先级 - if (!IsSystemCalling() || vibrateInfo.systemUsage == false) { + if (!IsSystemCalling() || vibrateInfo.systemUsage == false) { #ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB - if (IgnoreAppVibrations(vibrateInfo)) { - MISC_HILOGD("Vibration is ignored for doNotDisturb, usage:%{public}d", vibrateInfo.usage); - return IGNORE_GLOBAL_SETTINGS; - } + if (IgnoreAppVibrations(vibrateInfo)) { + MISC_HILOGD("Vibration is ignored for doNotDisturb, usage:%{public}d", vibrateInfo.usage); + return IGNORE_GLOBAL_SETTINGS; + } #endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB - if ((vibrateInfo.usage == USAGE_ALARM || vibrateInfo.usage == USAGE_RING - || vibrateInfo.usage == USAGE_NOTIFICATION || vibrateInfo.usage == USAGE_COMMUNICATION) - && (miscAudioRingerMode_ == RINGER_MODE_SILENT)) { - MISC_HILOGD("Vibration is ignored for ringer mode:%{public}d", static_cast(miscAudioRingerMode_)); - return IGNORE_RINGER_MODE; - } - if (((vibrateInfo.usage == USAGE_TOUCH || vibrateInfo.usage == USAGE_MEDIA || vibrateInfo.usage == USAGE_UNKNOWN - || vibrateInfo.usage == USAGE_PHYSICAL_FEEDBACK || vibrateInfo.usage == USAGE_SIMULATE_REALITY) - && (miscFeedback_ == FEEDBACK_MODE_OFF)) + if ((vibrateInfo.usage == USAGE_ALARM || vibrateInfo.usage == USAGE_RING + || vibrateInfo.usage == USAGE_NOTIFICATION || vibrateInfo.usage == USAGE_COMMUNICATION) + && (miscAudioRingerMode_ == RINGER_MODE_SILENT)) { + MISC_HILOGD("Vibration is ignored for ringer mode:%{public}d", static_cast(miscAudioRingerMode_)); + return IGNORE_RINGER_MODE; + } + if (((vibrateInfo.usage == USAGE_TOUCH || vibrateInfo.usage == USAGE_MEDIA || vibrateInfo.usage == USAGE_UNKNOWN + || vibrateInfo.usage == USAGE_PHYSICAL_FEEDBACK || vibrateInfo.usage == USAGE_SIMULATE_REALITY) + && (miscFeedback_ == FEEDBACK_MODE_OFF)) #ifdef OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD - && !ShouldIgnoreInputMethod(vibrateInfo)) { + && !ShouldIgnoreInputMethod(vibrateInfo)) { #else // OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD - ) { + ) { #endif // OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD - MISC_HILOGD("Vibration is ignored for feedback:%{public}d", static_cast(miscFeedback_)); - return IGNORE_FEEDBACK; - } + MISC_HILOGD("Vibration is ignored for feedback:%{public}d", static_cast(miscFeedback_)); + return IGNORE_FEEDBACK; } } #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CROWN diff --git a/test/unittest/vibrator/native/vibrator_agent_test.cpp b/test/unittest/vibrator/native/vibrator_agent_test.cpp index 4bf7cc5..92c0a0b 100644 --- a/test/unittest/vibrator/native/vibrator_agent_test.cpp +++ b/test/unittest/vibrator/native/vibrator_agent_test.cpp @@ -70,8 +70,8 @@ void TestCallBack(VibratorDeviceInfo *deviceInfo) { } constexpr VibratorUser testUser = { - .callback = TestCallBack; -} + .callback = TestCallBack, +}; } // namespace class VibratorAgentTest : public testing::Test { diff --git a/utils/common/include/vibrator_infos.h b/utils/common/include/vibrator_infos.h index d562b41..0e68768 100644 --- a/utils/common/include/vibrator_infos.h +++ b/utils/common/include/vibrator_infos.h @@ -143,6 +143,7 @@ struct VibratorInfoIPC : public Parcelable{ std::string deviceName = ""; bool isSupportHdHaptic; bool isLocalVibrator; + int32_t position = 0; void Dump() const; bool Marshalling(Parcel &parcel) const; static VibratorInfoIPC* Unmarshalling(Parcel &data); @@ -151,6 +152,8 @@ struct VibratorInfoIPC : public Parcelable{ struct VibratorIdentifierIPC : public Parcelable { int32_t deviceId = -1; int32_t vibratorId = -1; + int32_t position = 0; + bool isLocalVibrator; void Dump() const; bool Marshalling(Parcel &parcel) const; static VibratorIdentifierIPC* Unmarshalling(Parcel &data); -- Gitee