1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "vibrator_if_service.h"
17 #include <hdf_base.h>
18 #include "vibrator_uhdf_log.h"
19 #include "hitrace_meter.h"
20
21 #define HDF_LOG_TAG "uhdf_vibrator_service"
22
23 namespace OHOS {
24 namespace HDI {
25 namespace Vibrator {
26 namespace V1_3 {
VibratorIfService()27 VibratorIfService::VibratorIfService()
28 {
29 int32_t ret = GetVibratorVdiImpl();
30 if (ret != HDF_SUCCESS) {
31 HDF_LOGE("%{public}s: get vibrator vdi instance failed", __func__);
32 }
33 }
34
~VibratorIfService()35 VibratorIfService::~VibratorIfService()
36 {
37 if (vdi_ != nullptr) {
38 HdfCloseVdi(vdi_);
39 }
40 }
41
GetVibratorVdiImpl()42 int32_t VibratorIfService::GetVibratorVdiImpl()
43 {
44 struct VdiWrapperVibrator *vdiWrapperVibrator = nullptr;
45 uint32_t version = 0;
46 vdi_ = HdfLoadVdi(HDI_VIBRATOR_VDI_LIBNAME);
47 if (vdi_ == nullptr || vdi_->vdiBase == nullptr) {
48 HDF_LOGE("%{public}s: load vibrator vdi failed", __func__);
49 return HDF_FAILURE;
50 }
51
52 version = HdfGetVdiVersion(vdi_);
53 if (version != 1) {
54 HDF_LOGE("%{public}s: get vibrator vdi version failed", __func__);
55 return HDF_FAILURE;
56 }
57
58 vdiWrapperVibrator = reinterpret_cast<struct VdiWrapperVibrator *>(vdi_->vdiBase);
59 vibratorVdiImpl_ = vdiWrapperVibrator->vibratorModule;
60 if (vibratorVdiImpl_ == nullptr) {
61 HDF_LOGE("%{public}s: get vibrator impl failed", __func__);
62 return HDF_FAILURE;
63 }
64
65 return HDF_SUCCESS;
66 }
67
Init()68 int32_t VibratorIfService::Init()
69 {
70 if (vibratorVdiImpl_ == nullptr) {
71 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
72 return HDF_FAILURE;
73 }
74
75 int32_t ret = vibratorVdiImpl_->Init();
76 if (ret != HDF_SUCCESS) {
77 HDF_LOGE("%{public}s Init failed, error code is %{public}d", __func__, ret);
78 }
79
80 return ret;
81 }
82
StartOnce(uint32_t duration)83 int32_t VibratorIfService::StartOnce(uint32_t duration)
84 {
85 HDF_LOGD("%{public}s: Enter the StartOnce function, duration is %{public}u", __func__, duration);
86 if (vibratorVdiImpl_ == nullptr) {
87 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
88 return HDF_FAILURE;
89 }
90
91 StartTrace(HITRACE_TAG_HDF, "StartOnce");
92 int32_t ret = vibratorVdiImpl_->StartOnce(duration);
93 if (ret != HDF_SUCCESS) {
94 HDF_LOGE("%{public}s StartOnce failed, error code is %{public}d", __func__, ret);
95 }
96 FinishTrace(HITRACE_TAG_HDF);
97
98 return ret;
99 }
100
Start(const std::string & effectType)101 int32_t VibratorIfService::Start(const std::string &effectType)
102 {
103 HDF_LOGD("%{public}s: Enter the Start function", __func__);
104 if (vibratorVdiImpl_ == nullptr) {
105 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
106 return HDF_FAILURE;
107 }
108
109 StartTrace(HITRACE_TAG_HDF, "Start");
110 int32_t ret = vibratorVdiImpl_->Start(effectType);
111 if (ret != HDF_SUCCESS) {
112 HDF_LOGE("%{public}s Start failed, error code is %{public}d", __func__, ret);
113 }
114 FinishTrace(HITRACE_TAG_HDF);
115
116 return ret;
117 }
118
Stop(HdfVibratorMode mode)119 int32_t VibratorIfService::Stop(HdfVibratorMode mode)
120 {
121 HDF_LOGD("%{public}s: Enter the Stop function, mode: %{public}d", __func__, mode);
122 if (vibratorVdiImpl_ == nullptr) {
123 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
124 return HDF_FAILURE;
125 }
126
127 HdfVibratorModeVdi vibratorMode;
128 if (mode == HdfVibratorMode::HDF_VIBRATOR_MODE_ONCE) {
129 vibratorMode = VDI_VIBRATOR_MODE_ONCE;
130 } else if (mode == HdfVibratorMode::HDF_VIBRATOR_MODE_PRESET) {
131 vibratorMode = VDI_VIBRATOR_MODE_PRESET;
132 } else if (mode == HdfVibratorMode::HDF_VIBRATOR_MODE_BUTT) {
133 vibratorMode = VDI_VIBRATOR_MODE_BUTT;
134 } else {
135 HDF_LOGE("%{public}s: invalid param", __func__);
136 return HDF_FAILURE;
137 }
138
139 StartTrace(HITRACE_TAG_HDF, "Stop");
140 int32_t ret = vibratorVdiImpl_->Stop(vibratorMode);
141 if (ret != HDF_SUCCESS) {
142 HDF_LOGE("%{public}s Stop failed, error code is %{public}d", __func__, ret);
143 }
144 FinishTrace(HITRACE_TAG_HDF);
145
146 return ret;
147 }
148
StopV1_2(int32_t mode)149 int32_t VibratorIfService::StopV1_2(int32_t mode)
150 {
151 HDF_LOGD("%{public}s: Enter the Stop function, mode: %{public}d", __func__, mode);
152 if (vibratorVdiImpl_ == nullptr) {
153 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
154 return HDF_FAILURE;
155 }
156
157 HdfVibratorModeVdi vibratorMode;
158 if (mode == HdfVibratorModeV1_2::HDF_VIBRATOR_MODE_ONCE) {
159 vibratorMode = VDI_VIBRATOR_MODE_ONCE;
160 } else if (mode == HdfVibratorModeV1_2::HDF_VIBRATOR_MODE_PRESET) {
161 vibratorMode = VDI_VIBRATOR_MODE_PRESET;
162 } else if (mode == HdfVibratorModeV1_2::HDF_VIBRATOR_MODE_HDHAPTIC) {
163 vibratorMode = VDI_VIBRATOR_MODE_HDHAPTIC;
164 } else if (mode == HdfVibratorModeV1_2::HDF_VIBRATOR_MODE_BUTT) {
165 vibratorMode = VDI_VIBRATOR_MODE_BUTT;
166 } else {
167 HDF_LOGE("%{public}s: invalid param", __func__);
168 return HDF_FAILURE;
169 }
170
171 StartTrace(HITRACE_TAG_HDF, "Stop");
172 int32_t ret = vibratorVdiImpl_->Stop(vibratorMode);
173 if (ret != HDF_SUCCESS) {
174 HDF_LOGE("%{public}s Stop failed, error code is %{public}d", __func__, ret);
175 }
176 FinishTrace(HITRACE_TAG_HDF);
177
178 return ret;
179 }
180
GetVibratorInfo(std::vector<HdfVibratorInfo> & vibratorInfo)181 int32_t VibratorIfService::GetVibratorInfo(std::vector<HdfVibratorInfo> &vibratorInfo)
182 {
183 HDF_LOGD("%{public}s: Enter the GetVibratorInfo function.", __func__);
184 if (vibratorVdiImpl_ == nullptr) {
185 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
186 return HDF_FAILURE;
187 }
188
189 std::vector<HdfVibratorInfoVdi> vibratorInfoVdi;
190 StartTrace(HITRACE_TAG_HDF, "GetVibratorInfo");
191 int32_t ret = vibratorVdiImpl_->GetVibratorInfo(vibratorInfoVdi);
192 if (ret != HDF_SUCCESS) {
193 HDF_LOGE("%{public}s GetVibratorInfo failed, error code is %{public}d", __func__, ret);
194 return ret;
195 }
196 FinishTrace(HITRACE_TAG_HDF);
197
198 if (vibratorInfoVdi.empty()) {
199 HDF_LOGE("%{public}s no vibrator info in list", __func__);
200 return HDF_FAILURE;
201 }
202 for (const auto &iter : vibratorInfoVdi) {
203 HdfVibratorInfo hdfVibratorInfo;
204 hdfVibratorInfo.isSupportIntensity = iter.isSupportIntensity;
205 hdfVibratorInfo.isSupportFrequency = iter.isSupportFrequency;
206 hdfVibratorInfo.intensityMaxValue = iter.intensityMaxValue;
207 hdfVibratorInfo.intensityMinValue = iter.intensityMinValue;
208 hdfVibratorInfo.frequencyMaxValue = iter.frequencyMaxValue;
209 hdfVibratorInfo.frequencyMinValue = iter.frequencyMinValue;
210 vibratorInfo.push_back(std::move(hdfVibratorInfo));
211 }
212
213 return HDF_SUCCESS;
214 }
215
EnableVibratorModulation(uint32_t duration,uint16_t intensity,int16_t frequency)216 int32_t VibratorIfService::EnableVibratorModulation(uint32_t duration, uint16_t intensity, int16_t frequency)
217 {
218 HDF_LOGD("%{public}s: duration is %{public}u, intensity is %{public}u, frequency is %{public}d.",
219 __func__, duration, intensity, frequency);
220 if (vibratorVdiImpl_ == nullptr) {
221 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
222 return HDF_FAILURE;
223 }
224
225 StartTrace(HITRACE_TAG_HDF, "EnableVibratorModulation");
226 int32_t ret = vibratorVdiImpl_->EnableVibratorModulation(duration, intensity, frequency);
227 if (ret != HDF_SUCCESS) {
228 HDF_LOGE("%{public}s EnableVibratorModulation failed, error code is %{public}d", __func__, ret);
229 }
230 FinishTrace(HITRACE_TAG_HDF);
231
232 return ret;
233 }
234
EnableCompositeEffect(const HdfCompositeEffect & effect)235 int32_t VibratorIfService::EnableCompositeEffect(const HdfCompositeEffect &effect)
236 {
237 HDF_LOGD("%{public}s: Enter the EnableCompositeEffect function.", __func__);
238 if (vibratorVdiImpl_ == nullptr) {
239 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
240 return HDF_FAILURE;
241 }
242
243 std::vector<HdfEffectVdi> effectVdi;
244 for (const auto &compositeEffects : effect.compositeEffects) {
245 HdfEffectVdi hdfEffectVdi;
246 if (effect.type == HDF_EFFECT_TYPE_TIME) {
247 hdfEffectVdi.timeEffect.delay = compositeEffects.timeEffect.delay;
248 hdfEffectVdi.timeEffect.time = compositeEffects.timeEffect.time;
249 hdfEffectVdi.timeEffect.intensity = compositeEffects.timeEffect.intensity;
250 hdfEffectVdi.timeEffect.frequency = compositeEffects.timeEffect.frequency;
251 } else if (effect.type == HDF_EFFECT_TYPE_PRIMITIVE) {
252 hdfEffectVdi.primitiveEffect.delay = compositeEffects.primitiveEffect.delay;
253 hdfEffectVdi.primitiveEffect.effectId = compositeEffects.primitiveEffect.effectId;
254 hdfEffectVdi.primitiveEffect.intensity = compositeEffects.primitiveEffect.intensity;
255 }
256 effectVdi.push_back(std::move(hdfEffectVdi));
257 }
258
259 HdfCompositeEffectVdi compositeEffectVdi;
260 compositeEffectVdi.type = effect.type;
261 compositeEffectVdi.effects = effectVdi;
262 StartTrace(HITRACE_TAG_HDF, "EnableCompositeEffect");
263 int32_t ret = vibratorVdiImpl_->EnableCompositeEffect(compositeEffectVdi);
264 if (ret != HDF_SUCCESS) {
265 HDF_LOGE("%{public}s EnableCompositeEffect failed, error code is %{public}d", __func__, ret);
266 }
267 FinishTrace(HITRACE_TAG_HDF);
268
269 return ret;
270 }
271
GetEffectInfo(const std::string & effectType,HdfEffectInfo & effectInfo)272 int32_t VibratorIfService::GetEffectInfo(const std::string &effectType, HdfEffectInfo &effectInfo)
273 {
274 HDF_LOGD("%{public}s: Enter the GetEffectInfo function.", __func__);
275 if (vibratorVdiImpl_ == nullptr) {
276 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
277 return HDF_FAILURE;
278 }
279
280 HdfEffectInfoVdi effectInfoVdi;
281 StartTrace(HITRACE_TAG_HDF, "GetEffectInfo");
282 int32_t ret = vibratorVdiImpl_->GetEffectInfo(effectType, effectInfoVdi);
283 if (ret != HDF_SUCCESS) {
284 HDF_LOGE("%{public}s GetEffectInfo failed, error code is %{public}d", __func__, ret);
285 }
286 FinishTrace(HITRACE_TAG_HDF);
287
288 effectInfo.isSupportEffect = effectInfoVdi.isSupportEffect;
289 effectInfo.duration = effectInfoVdi.duration;
290
291 return ret;
292 }
293
IsVibratorRunning(bool & state)294 int32_t VibratorIfService::IsVibratorRunning(bool& state)
295 {
296 HDF_LOGD("%{public}s: Enter the IsVibratorRunning function", __func__);
297 if (vibratorVdiImpl_ == nullptr) {
298 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
299 return HDF_FAILURE;
300 }
301
302 StartTrace(HITRACE_TAG_HDF, "IsVibratorRunning");
303 int32_t ret = vibratorVdiImpl_->IsVibratorRunning(state);
304 if (ret != HDF_SUCCESS) {
305 HDF_LOGE("%{public}s IsVibratorRunning failed, error code is %{public}d", __func__, ret);
306 }
307 FinishTrace(HITRACE_TAG_HDF);
308 HDF_LOGD("%{public}s: state %{public}d", __func__, state);
309
310 return ret;
311 }
312
PlayHapticPattern(const HapticPaket & pkg)313 int32_t VibratorIfService::PlayHapticPattern(const HapticPaket& pkg)
314 {
315 HDF_LOGD("%{public}s: Enter the PlayHapticPattern function", __func__);
316 if (vibratorVdiImpl_ == nullptr) {
317 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
318 return HDF_FAILURE;
319 }
320
321 HapticPaketVdi hapticPaketVdi;
322 hapticPaketVdi.time = pkg.time;
323 hapticPaketVdi.eventNum = pkg.eventNum;
324 for (const auto &event : pkg.events) {
325 HapticEventVdi hapticEventVdi;
326 if (event.type == CONTINUOUS) {
327 hapticEventVdi.type = VDI_CONTINUOUS;
328 } else if (event.type == TRANSIENT) {
329 hapticEventVdi.type = VDI_TRANSIENT;
330 }
331 hapticEventVdi.time = event.time;
332 hapticEventVdi.duration = event.duration;
333 hapticEventVdi.intensity = event.intensity;
334 hapticEventVdi.frequency = event.frequency;
335 hapticEventVdi.index = event.index;
336 hapticEventVdi.pointNum = event.pointNum;
337 for (const auto &point : event.points) {
338 CurvePointVdi curvePointVdip;
339 curvePointVdip.time = point.time;
340 curvePointVdip.intensity = point.intensity;
341 curvePointVdip.frequency = point.frequency;
342 hapticEventVdi.points.push_back(std::move(curvePointVdip));
343 }
344 hapticPaketVdi.events.push_back(std::move(hapticEventVdi));
345 }
346 StartTrace(HITRACE_TAG_HDF, "PlayHapticPattern");
347 int32_t ret = vibratorVdiImpl_->PlayHapticPattern(hapticPaketVdi);
348 if (ret != HDF_SUCCESS) {
349 HDF_LOGE("%{public}s PlayHapticPattern failed, error code is %{public}d", __func__, ret);
350 }
351 FinishTrace(HITRACE_TAG_HDF);
352
353 return ret;
354 }
355
GetHapticCapacity(HapticCapacity & hapticCapacity)356 int32_t VibratorIfService::GetHapticCapacity(HapticCapacity& hapticCapacity)
357 {
358 HDF_LOGD("%{public}s: Enter the GetHapticCapacity function", __func__);
359 if (vibratorVdiImpl_ == nullptr) {
360 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
361 return HDF_FAILURE;
362 }
363
364 HapticCapacityVdi hapticCapacityVdi;
365 StartTrace(HITRACE_TAG_HDF, "GetHapticCapacity");
366 int32_t ret = vibratorVdiImpl_->GetHapticCapacity(hapticCapacityVdi);
367 if (ret != HDF_SUCCESS) {
368 HDF_LOGE("%{public}s GetHapticCapacity failed, error code is %{public}d", __func__, ret);
369 }
370 FinishTrace(HITRACE_TAG_HDF);
371 hapticCapacity.isSupportHdHaptic = hapticCapacityVdi.isSupportHdHaptic;
372 hapticCapacity.isSupportPresetMapping = hapticCapacityVdi.isSupportPresetMapping;
373 hapticCapacity.isSupportTimeDelay = hapticCapacityVdi.isSupportTimeDelay;
374
375 return ret;
376 }
377
GetHapticStartUpTime(int32_t mode,int32_t & startUpTime)378 int32_t VibratorIfService::GetHapticStartUpTime(int32_t mode, int32_t& startUpTime)
379 {
380 HDF_LOGD("%{public}s: Enter the GetHapticStartUpTime function", __func__);
381 if (vibratorVdiImpl_ == nullptr) {
382 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
383 return HDF_FAILURE;
384 }
385
386 StartTrace(HITRACE_TAG_HDF, "GetHapticStartUpTime");
387 int32_t ret = vibratorVdiImpl_->GetHapticStartUpTime(mode, startUpTime);
388 if (ret != HDF_SUCCESS) {
389 HDF_LOGE("%{public}s GetHapticStartUpTime failed, error code is %{public}d", __func__, ret);
390 }
391 FinishTrace(HITRACE_TAG_HDF);
392
393 return ret;
394 }
395
StartByIntensity(const std::string & effectType,uint16_t intensity)396 int32_t VibratorIfService::StartByIntensity(const std::string& effectType, uint16_t intensity)
397 {
398 HDF_LOGD("%{public}s: Enter the StartByIntensity function", __func__);
399 if (vibratorVdiImpl_ == nullptr) {
400 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
401 return HDF_FAILURE;
402 }
403
404 StartTrace(HITRACE_TAG_HDF, "StartByIntensity");
405 int32_t ret = vibratorVdiImpl_->StartByIntensity(effectType, intensity);
406 if (ret != HDF_SUCCESS) {
407 HDF_LOGE("%{public}s StartByIntensity failed, error code is %{public}d", __func__, ret);
408 }
409 FinishTrace(HITRACE_TAG_HDF);
410
411 return ret;
412 }
413
GetAllWaveInfo(int32_t vibratorId,std::vector<HdfWaveInformation> & info)414 int32_t VibratorIfService::GetAllWaveInfo(int32_t vibratorId, std::vector<HdfWaveInformation> &info)
415 {
416 HDF_LOGD("%{public}s: Enter the GetAllWaveInfo function", __func__);
417 if (vibratorVdiImpl_ == nullptr) {
418 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
419 return HDF_FAILURE;
420 }
421
422 StartTrace(HITRACE_TAG_HDF, "GetAllWaveInfo");
423 int32_t ret = vibratorVdiImpl_->GetAllWaveInfo(vibratorId, info);
424 FinishTrace(HITRACE_TAG_HDF);
425 if (ret != HDF_SUCCESS) {
426 HDF_LOGE("%{public}s GetAllWaveInfo failed, error code is %{public}d", __func__, ret);
427 }
428
429 return ret;
430 }
431
VibratorInterfaceImplGetInstance(void)432 extern "C" IVibratorInterface *VibratorInterfaceImplGetInstance(void)
433 {
434 VibratorIfService *impl = new (std::nothrow) VibratorIfService();
435 if (impl == nullptr) {
436 return nullptr;
437 }
438
439 int32_t ret = impl->Init();
440 if (ret != HDF_SUCCESS) {
441 HDF_LOGE("%{public}s: service init failed, error code is %{public}d", __func__, ret);
442 delete impl;
443 return nullptr;
444 }
445
446 return impl;
447 }
448 } // V1_3
449 } // Vibrator
450 } // HDI
451 } // OHOS
452