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 
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.time = event.time;
331         hapticEventVdi.duration = event.duration;
332         hapticEventVdi.intensity = event.intensity;
333         hapticEventVdi.frequency = event.frequency;
334         hapticEventVdi.index = event.index;
335         hapticEventVdi.pointNum = event.pointNum;
336         for (const auto &point : event.points) {
337             CurvePointVdi curvePointVdip;
338             curvePointVdip.time = point.time;
339             curvePointVdip.intensity = point.intensity;
340             curvePointVdip.frequency = point.frequency;
341             hapticEventVdi.points.push_back(std::move(curvePointVdip));
342         }
343         hapticPaketVdi.events.push_back(std::move(hapticEventVdi));
344     }
345     StartTrace(HITRACE_TAG_HDF, "PlayHapticPattern");
346     int32_t ret = vibratorVdiImpl_->PlayHapticPattern(hapticPaketVdi);
347     if (ret != HDF_SUCCESS) {
348         HDF_LOGE("%{public}s PlayHapticPattern failed, error code is %{public}d", __func__, ret);
349     }
350     FinishTrace(HITRACE_TAG_HDF);
351 
352     return ret;
353 }
354 
GetHapticCapacity(HapticCapacity & hapticCapacity)355 int32_t VibratorIfService::GetHapticCapacity(HapticCapacity& hapticCapacity)
356 {
357     HDF_LOGD("%{public}s: Enter the GetHapticCapacity function", __func__);
358     if (vibratorVdiImpl_ == nullptr) {
359         HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
360         return HDF_FAILURE;
361     }
362 
363     HapticCapacityVdi hapticCapacityVdi;
364     StartTrace(HITRACE_TAG_HDF, "GetHapticCapacity");
365     int32_t ret = vibratorVdiImpl_->GetHapticCapacity(hapticCapacityVdi);
366     if (ret != HDF_SUCCESS) {
367         HDF_LOGE("%{public}s GetHapticCapacity failed, error code is %{public}d", __func__, ret);
368     }
369     FinishTrace(HITRACE_TAG_HDF);
370     hapticCapacity.isSupportHdHaptic = hapticCapacityVdi.isSupportHdHaptic;
371     hapticCapacity.isSupportPresetMapping = hapticCapacityVdi.isSupportPresetMapping;
372     hapticCapacity.isSupportTimeDelay = hapticCapacityVdi.isSupportTimeDelay;
373 
374     return ret;
375 }
376 
GetHapticStartUpTime(int32_t mode,int32_t & startUpTime)377 int32_t VibratorIfService::GetHapticStartUpTime(int32_t mode, int32_t& startUpTime)
378 {
379     HDF_LOGD("%{public}s: Enter the GetHapticStartUpTime function", __func__);
380     if (vibratorVdiImpl_ == nullptr) {
381         HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
382         return HDF_FAILURE;
383     }
384 
385     StartTrace(HITRACE_TAG_HDF, "GetHapticStartUpTime");
386     int32_t ret = vibratorVdiImpl_->GetHapticStartUpTime(mode, startUpTime);
387     if (ret != HDF_SUCCESS) {
388         HDF_LOGE("%{public}s GetHapticStartUpTime failed, error code is %{public}d", __func__, ret);
389     }
390     FinishTrace(HITRACE_TAG_HDF);
391 
392     return ret;
393 }
394 
StartByIntensity(const std::string & effectType,uint16_t intensity)395 int32_t VibratorIfService::StartByIntensity(const std::string& effectType, uint16_t intensity)
396 {
397     HDF_LOGD("%{public}s: Enter the StartByIntensity function", __func__);
398     if (vibratorVdiImpl_ == nullptr) {
399         HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
400         return HDF_FAILURE;
401     }
402 
403     StartTrace(HITRACE_TAG_HDF, "StartByIntensity");
404     int32_t ret = vibratorVdiImpl_->StartByIntensity(effectType, intensity);
405     if (ret != HDF_SUCCESS) {
406         HDF_LOGE("%{public}s StartByIntensity failed, error code is %{public}d", __func__, ret);
407     }
408     FinishTrace(HITRACE_TAG_HDF);
409 
410     return ret;
411 }
412 
GetAllWaveInfo(int32_t vibratorId,std::vector<HdfWaveInformation> & info)413 int32_t VibratorIfService::GetAllWaveInfo(int32_t vibratorId, std::vector<HdfWaveInformation> &info)
414 {
415     HDF_LOGD("%{public}s: Enter the GetAllWaveInfo function", __func__);
416     if (vibratorVdiImpl_ == nullptr) {
417         HDF_LOGE("%{public}s: vibratorVdiImpl_ is nullptr", __func__);
418         return HDF_FAILURE;
419     }
420 
421     StartTrace(HITRACE_TAG_HDF, "GetAllWaveInfo");
422     int32_t ret = vibratorVdiImpl_->GetAllWaveInfo(vibratorId, info);
423     FinishTrace(HITRACE_TAG_HDF);
424     if (ret != HDF_SUCCESS) {
425         HDF_LOGE("%{public}s GetAllWaveInfo failed, error code is %{public}d", __func__, ret);
426     }
427 
428     return ret;
429 }
430 
VibratorInterfaceImplGetInstance(void)431 extern "C" IVibratorInterface *VibratorInterfaceImplGetInstance(void)
432 {
433     VibratorIfService *impl = new (std::nothrow) VibratorIfService();
434     if (impl == nullptr) {
435         return nullptr;
436     }
437 
438     int32_t ret = impl->Init();
439     if (ret != HDF_SUCCESS) {
440         HDF_LOGE("%{public}s: service init failed, error code is %{public}d", __func__, ret);
441         delete impl;
442         return nullptr;
443     }
444 
445     return impl;
446 }
447 } // V1_3
448 } // Vibrator
449 } // HDI
450 } // OHOS
451