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_2 {
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
309 return ret;
310 }
311
PlayHapticPattern(const HapticPaket & pkg)312 int32_t VibratorIfService::PlayHapticPattern(const HapticPaket& pkg)
313 {
314 HDF_LOGD("%{public}s: Enter the PlayHapticPattern function", __func__);
315 if (vibratorVdiImpl_ == nullptr) {
316 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
317 return HDF_FAILURE;
318 }
319
320 HapticPaketVdi hapticPaketVdi;
321 hapticPaketVdi.time = pkg.time;
322 hapticPaketVdi.eventNum = pkg.eventNum;
323 for (const auto &event : pkg.events) {
324 HapticEventVdi hapticEventVdi;
325 if (event.type == CONTINUOUS) {
326 hapticEventVdi.type = VDI_CONTINUOUS;
327 } else if (event.type == TRANSIENT) {
328 hapticEventVdi.type = VDI_TRANSIENT;
329 }
330 hapticEventVdi.duration = event.duration;
331 hapticEventVdi.intensity = event.intensity;
332 hapticEventVdi.frequency = event.frequency;
333 hapticEventVdi.index = event.index;
334 hapticEventVdi.pointNum = event.pointNum;
335 for (const auto &point : event.points) {
336 CurvePointVdi curvePointVdip;
337 curvePointVdip.time = point.time;
338 curvePointVdip.intensity = point.intensity;
339 curvePointVdip.frequency = point.frequency;
340 hapticEventVdi.points.push_back(std::move(curvePointVdip));
341 }
342 hapticPaketVdi.events.push_back(std::move(hapticEventVdi));
343 }
344 StartTrace(HITRACE_TAG_HDF, "PlayHapticPattern");
345 int32_t ret = vibratorVdiImpl_->PlayHapticPattern(hapticPaketVdi);
346 if (ret != HDF_SUCCESS) {
347 HDF_LOGE("%{public}s PlayHapticPattern failed, error code is %{public}d", __func__, ret);
348 }
349 FinishTrace(HITRACE_TAG_HDF);
350
351 return ret;
352 }
353
GetHapticCapacity(HapticCapacity & hapticCapacity)354 int32_t VibratorIfService::GetHapticCapacity(HapticCapacity& hapticCapacity)
355 {
356 HDF_LOGD("%{public}s: Enter the GetHapticCapacity function", __func__);
357 if (vibratorVdiImpl_ == nullptr) {
358 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
359 return HDF_FAILURE;
360 }
361
362 HapticCapacityVdi hapticCapacityVdi;
363 StartTrace(HITRACE_TAG_HDF, "GetHapticCapacity");
364 int32_t ret = vibratorVdiImpl_->GetHapticCapacity(hapticCapacityVdi);
365 if (ret != HDF_SUCCESS) {
366 HDF_LOGE("%{public}s GetHapticCapacity failed, error code is %{public}d", __func__, ret);
367 }
368 FinishTrace(HITRACE_TAG_HDF);
369 hapticCapacity.isSupportHdHaptic = hapticCapacityVdi.isSupportHdHaptic;
370 hapticCapacity.isSupportPresetMapping = hapticCapacityVdi.isSupportPresetMapping;
371 hapticCapacity.isSupportTimeDelay = hapticCapacityVdi.isSupportTimeDelay;
372
373 return ret;
374 }
375
GetHapticStartUpTime(int32_t mode,int32_t & startUpTime)376 int32_t VibratorIfService::GetHapticStartUpTime(int32_t mode, int32_t& startUpTime)
377 {
378 HDF_LOGD("%{public}s: Enter the GetHapticStartUpTime function", __func__);
379 if (vibratorVdiImpl_ == nullptr) {
380 HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
381 return HDF_FAILURE;
382 }
383
384 StartTrace(HITRACE_TAG_HDF, "GetHapticStartUpTime");
385 int32_t ret = vibratorVdiImpl_->GetHapticStartUpTime(mode, startUpTime);
386 if (ret != HDF_SUCCESS) {
387 HDF_LOGE("%{public}s GetHapticStartUpTime failed, error code is %{public}d", __func__, ret);
388 }
389 FinishTrace(HITRACE_TAG_HDF);
390
391 return ret;
392 }
393
VibratorInterfaceImplGetInstance(void)394 extern "C" IVibratorInterface *VibratorInterfaceImplGetInstance(void)
395 {
396 VibratorIfService *impl = new (std::nothrow) VibratorIfService();
397 if (impl == nullptr) {
398 return nullptr;
399 }
400
401 int32_t ret = impl->Init();
402 if (ret != HDF_SUCCESS) {
403 HDF_LOGE("%{public}s: service init failed, error code is %{public}d", __func__, ret);
404 delete impl;
405 return nullptr;
406 }
407
408 return impl;
409 }
410 } // V1_2
411 } // Vibrator
412 } // HDI
413 } // OHOS
414