1 /*
2 * Copyright (c) 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 "sensor_if_service.h"
17 #include <refbase.h>
18 #include <cinttypes>
19 #include "sensor_uhdf_log.h"
20 #include "sensor_type.h"
21 #include "sensor_callback_vdi.h"
22 #include "callback_death_recipient.h"
23 #include "sensor_hdi_dump.h"
24 #include "devhost_dump_reg.h"
25
26 constexpr int DISABLE_SENSOR = 0;
27 constexpr int REPORT_INTERVAL = 0;
28 constexpr int UNREGISTER_SENSOR = 0;
29 constexpr int REGISTER_SENSOR = 1;
30 constexpr int ENABLE_SENSOR = 1;
31 constexpr int COMMON_REPORT_FREQUENCY = 1000000000;
32 constexpr int COPY_SENSORINFO = 1;
33
34 enum BatchSeniorMode {
35 SA = 0,
36 SDC = 1
37 };
38
39 #define HDF_LOG_TAG hdi
40
41 namespace OHOS {
42 namespace HDI {
43 namespace Sensor {
44 namespace V3_0 {
45
46 namespace {
47 constexpr int32_t CALLBACK_CTOUNT_THRESHOLD = 1;
48 using CallBackDeathRecipientMap = std::unordered_map<IRemoteObject *, sptr<CallBackDeathRecipient>>;
49 CallBackDeathRecipientMap g_callBackDeathRecipientMap;
50 }
51
SensorIfService()52 SensorIfService::SensorIfService()
53 {
54 int32_t ret = GetSensorVdiImpl();
55 if (ret != HDF_SUCCESS) {
56 HDF_LOGE("%{public}s: get sensor vdi instance failed", __func__);
57 }
58 }
59
~SensorIfService()60 SensorIfService::~SensorIfService()
61 {
62 if (vdi_ != nullptr) {
63 HdfCloseVdi(vdi_);
64 }
65 RemoveDeathNotice(TRADITIONAL_SENSOR_TYPE);
66 RemoveDeathNotice(MEDICAL_SENSOR_TYPE);
67 }
68
RegisteDumpHost()69 void SensorIfService::RegisteDumpHost()
70 {
71 int32_t ret = DevHostRegisterDumpHost(GetSensorDump);
72 if (ret != HDF_SUCCESS) {
73 HDF_LOGE("%{public}s: DevHostRegisterDumpHost error", __func__);
74 }
75 return;
76 }
77
GetSensorVdiImpl()78 int32_t SensorIfService::GetSensorVdiImpl()
79 {
80 struct OHOS::HDI::Sensor::V1_1::WrapperSensorVdi *wrapperSensorVdi = nullptr;
81 uint32_t version = 0;
82 vdi_ = HdfLoadVdi(HDI_SENSOR_VDI_LIBNAME);
83 if (vdi_ == nullptr || vdi_->vdiBase == nullptr) {
84 HDF_LOGE("%{public}s: load sensor vdi failed", __func__);
85 return HDF_FAILURE;
86 }
87
88 version = HdfGetVdiVersion(vdi_);
89 if (version != 1) {
90 HDF_LOGE("%{public}s: get sensor vdi version failed", __func__);
91 return HDF_FAILURE;
92 }
93
94 wrapperSensorVdi = reinterpret_cast<struct OHOS::HDI::Sensor::V1_1::WrapperSensorVdi *>(vdi_->vdiBase);
95 sensorVdiImplV1_1_ = wrapperSensorVdi->sensorModule;
96 if (sensorVdiImplV1_1_ == nullptr) {
97 HDF_LOGE("%{public}s: get sensor impl failed", __func__);
98 return HDF_FAILURE;
99 }
100 return HDF_SUCCESS;
101 }
102
Init()103 int32_t SensorIfService::Init()
104 {
105 if (sensorVdiImplV1_1_ == nullptr) {
106 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
107 return HDF_FAILURE;
108 }
109 int32_t ret = sensorVdiImplV1_1_->Init();
110 if (ret != SENSOR_SUCCESS) {
111 HDF_LOGE("%{public}s Init failed, error code is %{public}d", __func__, ret);
112 } else {
113 ret = GetAllSensorInfo(hdfSensorInformations);
114 if (ret != SENSOR_SUCCESS) {
115 HDF_LOGE("%{public}s GetAllSensorInfo failed, error code is %{public}d", __func__, ret);
116 }
117 }
118 #ifdef SENSOR_DEBUG
119 RegisteDumpHost();
120 #endif
121 return ret;
122 }
123
GetSensorCb(int32_t groupId,const sptr<V3_0::ISensorCallback> & callbackObj,bool cbFlag)124 sptr<SensorCallbackVdi> SensorIfService::GetSensorCb(int32_t groupId, const sptr<V3_0::ISensorCallback> &callbackObj,
125 bool cbFlag)
126 {
127 SENSOR_TRACE_PID;
128 if (groupId == TRADITIONAL_SENSOR_TYPE) {
129 if (cbFlag) {
130 traditionalCb = new SensorCallbackVdi(callbackObj);
131 }
132 return traditionalCb;
133 }
134 if (cbFlag) {
135 medicalCb = new SensorCallbackVdi(callbackObj);
136 }
137 return medicalCb;
138 }
139
SetBatchSenior(int32_t serviceId,const SensorHandle sensorHandle,int32_t mode,int64_t samplingInterval,int64_t reportInterval)140 int32_t SensorIfService::SetBatchSenior(int32_t serviceId, const SensorHandle sensorHandle, int32_t mode,
141 int64_t samplingInterval, int64_t reportInterval)
142 {
143 SENSOR_TRACE_PID_MSG("sensorHandle " + SENSOR_HANDLE_TO_STRING(sensorHandle) + "mode " +
144 std::to_string(mode) + "samplingInterval " + std::to_string(samplingInterval) + "reportInterval " +
145 std::to_string(reportInterval));
146 HDF_LOGI("%{public}s:%{public}s pid %{public}d mode %{public}d interval (%{public}s,%{public}s)",
147 __func__, SENSOR_HANDLE_TO_C_STR(sensorHandle), serviceId, mode,
148 std::to_string(samplingInterval / ONE_MILLION).c_str(),
149 std::to_string(reportInterval / ONE_MILLION).c_str());
150
151 if (sensorVdiImplV1_1_ == nullptr) {
152 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
153 return HDF_FAILURE;
154 }
155
156 SensorClientsManager::GetInstance()->SetClientSenSorConfig(sensorHandle, serviceId, samplingInterval,
157 reportInterval);
158
159 SensorInterval sensorInterval = {samplingInterval, reportInterval};
160 SensorInterval saSensorInterval = {samplingInterval, reportInterval};
161 SensorInterval sdcSensorInterval = {samplingInterval, reportInterval};
162 AdjustSensorConfig(sensorHandle, sensorInterval, saSensorInterval, sdcSensorInterval);
163
164 int32_t ret = SetBatchConfig(sensorHandle, sensorInterval.samplingInterval, sensorInterval.reportInterval);
165 if (ret != SENSOR_SUCCESS) {
166 return ret;
167 }
168
169 UpdateSensorModeConfig(sensorHandle, mode, saSensorInterval, sdcSensorInterval);
170
171 return ret;
172 }
173
AdjustSensorConfig(const SensorHandle & sensorHandle,SensorInterval & sensorInterval,SensorInterval & saSensorInterval,SensorInterval & sdcSensorInterval)174 void SensorIfService::AdjustSensorConfig(const SensorHandle &sensorHandle, SensorInterval &sensorInterval,
175 SensorInterval &saSensorInterval, SensorInterval &sdcSensorInterval)
176 {
177 SensorClientsManager::GetInstance()->SetSensorBestConfig(sensorHandle, saSensorInterval.samplingInterval,
178 saSensorInterval.reportInterval);
179 SensorClientsManager::GetInstance()->SetSdcSensorBestConfig(sensorHandle, sdcSensorInterval.samplingInterval,
180 sdcSensorInterval.reportInterval);
181
182 sensorInterval.samplingInterval = std::min(saSensorInterval.samplingInterval, sdcSensorInterval.samplingInterval);
183 sensorInterval.reportInterval = std::min(saSensorInterval.reportInterval, sdcSensorInterval.reportInterval);
184 }
185
SetBatchConfig(const SensorHandle & sensorHandle,int64_t samplingInterval,int64_t reportInterval)186 int32_t SensorIfService::SetBatchConfig(const SensorHandle &sensorHandle, int64_t samplingInterval,
187 int64_t reportInterval)
188 {
189 SENSOR_TRACE_START("sensorVdiImplV1_1_->SetBatch");
190 #ifdef TV_FLAG
191 int32_t ret = sensorVdiImplV1_1_->SetBatch(sensorHandle, samplingInterval, reportInterval);
192 #else
193 int32_t ret = sensorVdiImplV1_1_->SetBatch(sensorHandle.sensorType, samplingInterval, reportInterval);
194 #endif
195 SENSOR_TRACE_FINISH;
196
197 if (ret != SENSOR_SUCCESS) {
198 HDF_LOGE("%{public}s SetBatch failed, error code is %{public}d", __func__, ret);
199 }
200
201 return ret;
202 }
203
UpdateSensorModeConfig(const SensorHandle & sensorHandle,int32_t mode,SensorInterval & saSensorInterval,SensorInterval & sdcSensorInterval)204 void SensorIfService::UpdateSensorModeConfig(const SensorHandle &sensorHandle, int32_t mode,
205 SensorInterval &saSensorInterval, SensorInterval &sdcSensorInterval)
206 {
207 if (mode == SA) {
208 SetDelay(sensorHandle, saSensorInterval.samplingInterval, saSensorInterval.reportInterval);
209 SensorClientsManager::GetInstance()->UpdateSensorConfig(sensorHandle, saSensorInterval.samplingInterval,
210 saSensorInterval.reportInterval);
211 SensorClientsManager::GetInstance()->UpdateClientPeriodCount(sensorHandle, saSensorInterval.samplingInterval,
212 saSensorInterval.reportInterval);
213 }
214 if (mode == SDC) {
215 SensorClientsManager::GetInstance()->UpdateSdcSensorConfig(sensorHandle, sdcSensorInterval.samplingInterval,
216 sdcSensorInterval.reportInterval);
217 }
218
219 SensorClientsManager::GetInstance()->GetSensorBestConfig(sensorHandle, saSensorInterval.samplingInterval,
220 saSensorInterval.reportInterval);
221
222 SENSOR_TRACE_START("sensorVdiImplV1_1_->SetSaBatch");
223 #ifdef TV_FLAG
224 int32_t ret = sensorVdiImplV1_1_->SetSaBatch(sensorHandle, saSensorInterval.samplingInterval,
225 saSensorInterval.reportInterval);
226 #else
227 int32_t ret = sensorVdiImplV1_1_->SetSaBatch(sensorHandle.sensorType, saSensorInterval.samplingInterval,
228 saSensorInterval.reportInterval);
229 #endif
230 SENSOR_TRACE_FINISH;
231
232 if (ret != SENSOR_SUCCESS) {
233 HDF_LOGE("%{public}s SetSaBatch failed, error code is %{public}d", __func__, ret);
234 }
235 }
236
SetDelay(SensorHandle sensorHandle,int64_t & samplingInterval,int64_t & reportInterval)237 int32_t SensorIfService::SetDelay(SensorHandle sensorHandle, int64_t &samplingInterval, int64_t &reportInterval)
238 {
239 SENSOR_TRACE_PID_MSG("sensorHandle " + SENSOR_HANDLE_TO_STRING(sensorHandle) + "samplingInterval " +
240 std::to_string(samplingInterval) + "reportInterval " + std::to_string(reportInterval));
241 HDF_LOGD("%{public}s: sensorHandle is %{public}s, samplingInterval is [%{public}" PRId64 "], reportInterval is "
242 "[%{public}" PRId64 "].", __func__, SENSOR_HANDLE_TO_C_STR(sensorHandle), samplingInterval,
243 reportInterval);
244 for (auto it = hdfSensorInformations.begin(); it != hdfSensorInformations.end(); ++it) {
245 if (it->deviceSensorInfo.deviceId == sensorHandle.deviceId &&
246 it->deviceSensorInfo.sensorType == sensorHandle.sensorType &&
247 it->deviceSensorInfo.sensorId == sensorHandle.sensorId &&
248 it->deviceSensorInfo.location == sensorHandle.location) {
249 if (samplingInterval < it->minDelay) {
250 samplingInterval = it->minDelay;
251 HDF_LOGD("%{public}s samplingInterval has been set minDelay %{public}s", __func__,
252 std::to_string(samplingInterval).c_str());
253 return SENSOR_SUCCESS;
254 }
255 if (samplingInterval > it->maxDelay && it->maxDelay != REPORT_INTERVAL) {
256 samplingInterval = it->maxDelay;
257 HDF_LOGD("%{public}s samplingInterval has been set maxDelay %{public}s", __func__,
258 std::to_string(samplingInterval).c_str());
259 return SENSOR_SUCCESS;
260 }
261 }
262 }
263 HDF_LOGD("%{public}s samplingInterval not change", __func__);
264 return SENSOR_SUCCESS;
265 }
266
AddCallbackMap(int32_t groupId,const sptr<IRemoteObject> & iRemoteObject)267 int32_t SensorIfService::AddCallbackMap(int32_t groupId, const sptr<IRemoteObject> &iRemoteObject)
268 {
269 SENSOR_TRACE_PID;
270 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
271 HDF_LOGI("%{public}s:pid %{public}d", __func__, serviceId);
272 auto groupCallBackIter = callbackMap.find(groupId);
273 if (groupCallBackIter != callbackMap.end()) {
274 auto iRemoteObjectIter =
275 find_if(callbackMap[groupId].begin(), callbackMap[groupId].end(),
276 [&iRemoteObject](const sptr<IRemoteObject> &iRemoteObjectRegistered) {
277 return iRemoteObject == iRemoteObjectRegistered;
278 });
279 if (iRemoteObjectIter == callbackMap[groupId].end()) {
280 int32_t addResult = AddSensorDeathRecipient(iRemoteObject);
281 if (addResult != SENSOR_SUCCESS) {
282 return HDF_FAILURE;
283 }
284 callbackMap[groupId].push_back(iRemoteObject);
285 }
286 } else {
287 int32_t addResult = AddSensorDeathRecipient(iRemoteObject);
288 if (addResult != SENSOR_SUCCESS) {
289 return HDF_FAILURE;
290 }
291 std::vector<sptr<IRemoteObject>> remoteVec;
292 remoteVec.push_back(iRemoteObject);
293 callbackMap[groupId] = remoteVec;
294 }
295 return SENSOR_SUCCESS;
296 }
297
RemoveCallbackMap(int32_t groupId,int serviceId,const sptr<IRemoteObject> & iRemoteObject)298 int32_t SensorIfService::RemoveCallbackMap(int32_t groupId, int serviceId,
299 const sptr<IRemoteObject> &iRemoteObject)
300 {
301 SENSOR_TRACE_PID;
302 HDF_LOGI("%{public}s:pid %{public}d", __func__, serviceId);
303
304 if (!ValidateCallbackMap(groupId, iRemoteObject)) {
305 return HDF_FAILURE;
306 }
307
308 if (!RemoveCallbackFromMap(groupId, iRemoteObject)) {
309 return HDF_FAILURE;
310 }
311
312 DisableUnusedSensors(serviceId);
313
314 return SENSOR_SUCCESS;
315 }
316
ValidateCallbackMap(int32_t groupId,const sptr<IRemoteObject> & iRemoteObject)317 bool SensorIfService::ValidateCallbackMap(int32_t groupId, const sptr<IRemoteObject> &iRemoteObject)
318 {
319 auto groupIdCallBackIter = callbackMap.find(groupId);
320 if (groupIdCallBackIter == callbackMap.end()) {
321 HDF_LOGE("%{public}s: groupId [%{public}d] callbackObj not registered", __func__, groupId);
322 return false;
323 }
324
325 auto iRemoteObjectIter =
326 find_if(callbackMap[groupId].begin(), callbackMap[groupId].end(),
327 [&iRemoteObject](const sptr<IRemoteObject> &iRemoteObjectRegistered) {
328 return iRemoteObject == iRemoteObjectRegistered;
329 });
330 if (iRemoteObjectIter == callbackMap[groupId].end()) {
331 HDF_LOGE("%{public}s: groupId [%{public}d] callbackObj not registered", __func__, groupId);
332 return false;
333 }
334
335 return true;
336 }
337
RemoveCallbackFromMap(int32_t groupId,const sptr<IRemoteObject> & iRemoteObject)338 bool SensorIfService::RemoveCallbackFromMap(int32_t groupId, const sptr<IRemoteObject> &iRemoteObject)
339 {
340 auto iRemoteObjectIter =
341 find_if(callbackMap[groupId].begin(), callbackMap[groupId].end(),
342 [&iRemoteObject](const sptr<IRemoteObject> &iRemoteObjectRegistered) {
343 return iRemoteObject == iRemoteObjectRegistered;
344 });
345
346 int32_t removeResult = RemoveSensorDeathRecipient(*iRemoteObjectIter);
347 if (removeResult != SENSOR_SUCCESS) {
348 HDF_LOGE("%{public}s: last callback RemoveSensorDeathRecipient fail, groupId[%{public}d]", __func__, groupId);
349 }
350
351 if (callbackMap[groupId].size() > CALLBACK_CTOUNT_THRESHOLD) {
352 callbackMap[groupId].erase(iRemoteObjectIter);
353 } else {
354 callbackMap.erase(groupId);
355 }
356
357 return true;
358 }
359
DisableUnusedSensors(int serviceId)360 void SensorIfService::DisableUnusedSensors(int serviceId)
361 {
362 std::unordered_map<SensorHandle, std::set<int32_t>> sensorEnabled =
363 SensorClientsManager::GetInstance()->GetSensorUsed();
364
365 for (auto iter : sensorEnabled) {
366 if (iter.second.find(serviceId) == iter.second.end()) {
367 continue;
368 }
369
370 if (!SensorClientsManager::GetInstance()->IsUpadateSensorState(iter.first, serviceId, DISABLE_SENSOR)) {
371 continue;
372 }
373
374 std::unordered_map<SensorHandle, std::set<int32_t>> sensorUsed =
375 SensorClientsManager::GetInstance()->GetSensorUsed();
376 if (sensorUsed.find(iter.first) == sensorUsed.end()) {
377 DisableSensorHandle(iter.first);
378 }
379 }
380 }
381
DisableSensorHandle(const SensorHandle & sensorHandle)382 void SensorIfService::DisableSensorHandle(const SensorHandle &sensorHandle)
383 {
384 SENSOR_TRACE_START("sensorVdiImplV1_1_->Disable");
385 #ifdef TV_FLAG
386 int32_t ret = sensorVdiImplV1_1_->Disable(sensorHandle);
387 #else
388 int32_t ret = sensorVdiImplV1_1_->Disable(sensorHandle.sensorType);
389 #endif
390 SENSOR_TRACE_FINISH;
391
392 if (ret != SENSOR_SUCCESS) {
393 HDF_LOGE("%{public}s Disable failed, error code is %{public}d", __func__, ret);
394 }
395 }
396
AddSensorDeathRecipient(const sptr<IRemoteObject> & iRemoteObject)397 int32_t SensorIfService::AddSensorDeathRecipient(const sptr<IRemoteObject> &iRemoteObject)
398 {
399 SENSOR_TRACE_PID;
400 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
401 HDF_LOGI("%{public}s:pid %{public}d", __func__, serviceId);
402 if (iRemoteObject == nullptr) {
403 HDF_LOGE("%{public}s: iRemoteObject is null", __func__);
404 return HDF_FAILURE;
405 }
406 sptr<CallBackDeathRecipient> callBackDeathRecipient = new CallBackDeathRecipient(this);
407 if (callBackDeathRecipient == nullptr) {
408 HDF_LOGE("%{public}s: new CallBackDeathRecipient fail", __func__);
409 return HDF_FAILURE;
410 }
411 bool result = iRemoteObject->AddDeathRecipient(callBackDeathRecipient);
412 if (!result) {
413 HDF_LOGE("%{public}s: AddDeathRecipient fail", __func__);
414 return HDF_FAILURE;
415 }
416 g_callBackDeathRecipientMap[iRemoteObject.GetRefPtr()] = callBackDeathRecipient;
417 return SENSOR_SUCCESS;
418 }
419
RemoveSensorDeathRecipient(const sptr<IRemoteObject> & iRemoteObject)420 int32_t SensorIfService::RemoveSensorDeathRecipient(const sptr<IRemoteObject> &iRemoteObject)
421 {
422 SENSOR_TRACE_PID;
423 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
424 HDF_LOGI("%{public}s:pid %{public}d", __func__, serviceId);
425 auto callBackDeathRecipientIter = g_callBackDeathRecipientMap.find(iRemoteObject.GetRefPtr());
426 if (callBackDeathRecipientIter == g_callBackDeathRecipientMap.end()) {
427 HDF_LOGE("%{public}s: not find recipient", __func__);
428 return HDF_FAILURE;
429 }
430 bool result = iRemoteObject->RemoveDeathRecipient(callBackDeathRecipientIter->second);
431 g_callBackDeathRecipientMap.erase(callBackDeathRecipientIter);
432 if (!result) {
433 HDF_LOGE("%{public}s: RemoveDeathRecipient fail", __func__);
434 return HDF_FAILURE;
435 }
436 return SENSOR_SUCCESS;
437 }
438
OnRemoteDied(const wptr<IRemoteObject> & object)439 void SensorIfService::OnRemoteDied(const wptr<IRemoteObject> &object)
440 {
441 SENSOR_TRACE_PID;
442 HDF_LOGI("%{public}s:pid %{public}d", __func__, static_cast<uint32_t>(HdfRemoteGetCallingPid()));
443 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
444 sptr<IRemoteObject> iRemoteObject = object.promote();
445 if (iRemoteObject == nullptr) {
446 return;
447 }
448
449 for (int32_t groupId = TRADITIONAL_SENSOR_TYPE; groupId < SENSOR_GROUP_TYPE_MAX; groupId++) {
450 auto groupIdIter = callbackMap.find(groupId);
451 if (groupIdIter == callbackMap.end()) {
452 continue;
453 }
454 auto callBackIter =
455 find_if(callbackMap[groupId].begin(), callbackMap[groupId].end(),
456 [&iRemoteObject](const sptr<IRemoteObject> &iRemoteObjectRegistered) {
457 return iRemoteObject.GetRefPtr() == iRemoteObjectRegistered.GetRefPtr();
458 });
459 if (callBackIter != callbackMap[groupId].end()) {
460 int32_t serviceId = SensorClientsManager::GetInstance()->GetServiceId(groupId, iRemoteObject);
461 int32_t ret = RemoveCallbackMap(groupId, serviceId, iRemoteObject);
462 if (ret != SENSOR_SUCCESS) {
463 HDF_LOGE("%{public}s: Unregister failed groupId[%{public}d]", __func__, groupId);
464 }
465 if (!SensorClientsManager::GetInstance()->IsClientsEmpty(groupId)) {
466 HDF_LOGD("%{public}s: clients is not empty, do not unregister", __func__);
467 continue;
468 }
469 const sptr<V3_0::ISensorCallback> &cb = OHOS::HDI::hdi_facecast<V3_0::ISensorCallback>(*callBackIter);
470 sptr<SensorCallbackVdi> sensorCb = GetSensorCb(groupId, cb, UNREGISTER_SENSOR);
471 if (sensorCb == nullptr) {
472 HDF_LOGE("%{public}s: get sensorcb fail, groupId[%{public}d]", __func__, groupId);
473 continue;
474 }
475 SENSOR_TRACE_START("sensorVdiImplV1_1_->Unregister");
476 #ifdef TV_FLAG
477 ret = sensorVdiImplV1_1_->Unregister(groupId, sensorCb);
478 #else
479 ret = sensorVdiImplV1_1_->Unregister(groupId, sensorCb);
480 #endif
481 SENSOR_TRACE_FINISH;
482 if (ret != SENSOR_SUCCESS) {
483 HDF_LOGE("%{public}s: Unregister failed, error code is %{public}d", __func__, ret);
484 }
485 }
486 }
487 }
488
RemoveDeathNotice(int32_t groupId)489 void SensorIfService::RemoveDeathNotice(int32_t groupId)
490 {
491 SENSOR_TRACE_PID_MSG("sensorType " + std::to_string(groupId));
492 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
493 HDF_LOGI("%{public}s:pid %{public}d groupId %{public}d", __func__, serviceId, groupId);
494 auto iter = callbackMap.find(groupId);
495 if (iter != callbackMap.end()) {
496 return;
497 }
498 for (const auto &iRemoteObject : callbackMap[groupId]) {
499 auto recipientIter = g_callBackDeathRecipientMap.find(iRemoteObject.GetRefPtr());
500 if (recipientIter != g_callBackDeathRecipientMap.end()) {
501 bool removeResult = iRemoteObject->RemoveDeathRecipient(recipientIter->second);
502 if (!removeResult) {
503 HDF_LOGE("%{public}s: sensor destroyed, callback RemoveSensorDeathRecipient fail", __func__);
504 }
505 }
506 }
507 }
508
DisableSensor(const SensorHandle sensorHandle,uint32_t serviceId)509 int32_t SensorIfService::DisableSensor(const SensorHandle sensorHandle, uint32_t serviceId)
510 {
511 SENSOR_TRACE_PID_MSG("sensorHandle " + SENSOR_HANDLE_TO_STRING(sensorHandle));
512 if (!SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorHandle, serviceId, DISABLE_SENSOR)) {
513 HDF_LOGD("%{public}s There are still some services enable", __func__);
514 return HDF_SUCCESS;
515 }
516
517 if (sensorVdiImplV1_1_ == nullptr) {
518 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
519 return HDF_FAILURE;
520 }
521
522 int32_t ret = SENSOR_SUCCESS;
523 if (SensorClientsManager::GetInstance()->IsExistSdcSensorEnable(sensorHandle)) {
524 SENSOR_TRACE_START("sensorVdiImplV1_1_->SetSaBatch");
525 #ifdef TV_FLAG
526 ret = sensorVdiImplV1_1_->SetSaBatch(sensorHandle, REPORT_INTERVAL, REPORT_INTERVAL);
527 #else
528 ret = sensorVdiImplV1_1_->SetSaBatch(sensorHandle.sensorType, REPORT_INTERVAL, REPORT_INTERVAL);
529 #endif
530 SENSOR_TRACE_FINISH;
531 if (ret != SENSOR_SUCCESS) {
532 HDF_LOGE("%{public}s SetSaBatch failed, error code is %{public}d, sensorHandle = %{public}s, serviceId = "
533 "%{public}d", __func__, ret, SENSOR_HANDLE_TO_C_STR(sensorHandle), serviceId);
534 return ret;
535 }
536 return HDF_SUCCESS;
537 }
538
539 ret = HDF_FAILURE;
540 SENSOR_TRACE_START("sensorVdiImplV1_1_->Disable");
541 #ifdef TV_FLAG
542 ret = sensorVdiImplV1_1_->Disable(sensorHandle);
543 #else
544 ret = sensorVdiImplV1_1_->Disable(sensorHandle.sensorType);
545 #endif
546 SENSOR_TRACE_FINISH;
547 if (ret != SENSOR_SUCCESS) {
548 HDF_LOGE("%{public}s failed, error code is %{public}d, sensorHandle = %{public}s, serviceId = %{public}d",
549 __func__, ret, SENSOR_HANDLE_TO_C_STR(sensorHandle), serviceId);
550 }
551
552 return ret;
553 }
554
SensorInterfaceImplGetInstance(void)555 extern "C" ISensorInterface *SensorInterfaceImplGetInstance(void)
556 {
557 SensorIfService *impl = new (std::nothrow) SensorIfService();
558 if (impl == nullptr) {
559 return nullptr;
560 }
561
562 int32_t ret = impl->Init();
563 if (ret != HDF_SUCCESS) {
564 HDF_LOGE("%{public}s: service init failed, error code is %{public}d", __func__, ret);
565 delete impl;
566 return nullptr;
567 }
568
569 return impl;
570 }
571
572 //V3_0 interface
GetAllSensorInfo(std::vector<V3_0::HdfSensorInformation> & info)573 int32_t SensorIfService::GetAllSensorInfo(std::vector<V3_0::HdfSensorInformation> &info)
574 {
575 SENSOR_TRACE_PID;
576 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
577 HDF_LOGI("%{public}s:pid %{public}d", __func__, serviceId);
578 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
579 if (sensorVdiImplV1_1_ == nullptr) {
580 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
581 return HDF_FAILURE;
582 }
583
584 std::vector<OHOS::HDI::Sensor::V3_0::HdfSensorInformationVdi> sensorInfoVdi = {};
585 SENSOR_TRACE_START("sensorVdiImplV1_1_->GetAllSensorInfo");
586 int32_t ret = sensorVdiImplV1_1_->GetAllSensorInfo(sensorInfoVdi);
587 SENSOR_TRACE_FINISH;
588 if (ret != SENSOR_SUCCESS) {
589 HDF_LOGE("%{public}s GetAllSensors failed, error code is %{public}d", __func__, ret);
590 return ret;
591 }
592
593 if (sensorInfoVdi.empty()) {
594 HDF_LOGI("%{public}s:empty", __func__);
595 }
596
597 for (const auto &it : sensorInfoVdi) {
598 struct V3_0::HdfSensorInformation sensorInfo = {};
599 sensorInfo.sensorName = it.sensorName;
600 sensorInfo.vendorName = it.vendorName;
601 sensorInfo.firmwareVersion = it.firmwareVersion;
602 sensorInfo.hardwareVersion = it.hardwareVersion;
603 sensorInfo.maxRange = it.maxRange;
604 #ifdef TV_FLAG
605 sensorInfo.deviceSensorInfo = {it.sensorHandle.deviceId, it.sensorHandle.sensorType, it.sensorHandle.sensorId,
606 it.sensorHandle.location};
607 #else
608 sensorInfo.deviceSensorInfo = {DEFAULT_DEVICE_ID, it.sensorId, DEFAULT_SENSOR_ID, DEFAULT_LOCATION};
609 #endif
610 sensorInfo.accuracy = it.accuracy;
611 sensorInfo.power = it.power;
612 sensorInfo.minDelay = it.minDelay;
613 sensorInfo.maxDelay = it.maxDelay;
614 sensorInfo.fifoMaxEventCount = it.fifoMaxEventCount;
615 info.push_back(std::move(sensorInfo));
616 }
617
618 SensorClientsManager::GetInstance()->CopySensorInfo(info, COPY_SENSORINFO);
619
620 return HDF_SUCCESS;
621 }
622
Enable(const OHOS::HDI::Sensor::V3_0::DeviceSensorInfo & deviceSensorInfo)623 int32_t SensorIfService::Enable(const OHOS::HDI::Sensor::V3_0::DeviceSensorInfo& deviceSensorInfo)
624 {
625 SensorHandle sensorHandle = {deviceSensorInfo.deviceId, deviceSensorInfo.sensorType, deviceSensorInfo.sensorId,
626 deviceSensorInfo.location};
627 SENSOR_TRACE_PID_MSG("sensorHandle " + SENSOR_HANDLE_TO_STRING(sensorHandle));
628 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
629 HDF_LOGI("%{public}s:%{public}s pid %{public}d", __func__,
630 SENSOR_HANDLE_TO_C_STR(sensorHandle), serviceId);
631 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
632 SensorClientsManager::GetInstance()->ReSetSensorPrintTime(sensorHandle);
633 if (!SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorHandle, serviceId, ENABLE_SENSOR)) {
634 return HDF_SUCCESS;
635 }
636
637 if (sensorVdiImplV1_1_ == nullptr) {
638 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
639 return HDF_FAILURE;
640 }
641
642 SensorClientsManager::GetInstance()->OpenSensor(sensorHandle, serviceId);
643 int32_t ret = HDF_FAILURE;
644 SENSOR_TRACE_START("sensorVdiImplV1_1_->Enable");
645 #ifdef TV_FLAG
646 ret = sensorVdiImplV1_1_->Enable(sensorHandle);
647 #else
648 ret = sensorVdiImplV1_1_->Enable(sensorHandle.sensorType);
649 #endif
650 SENSOR_TRACE_FINISH;
651 if (ret != SENSOR_SUCCESS) {
652 HDF_LOGE("%{public}s failed, error code is %{public}d, sensorHandle = %{public}s, serviceId = %{public}d",
653 __func__, ret, SENSOR_HANDLE_TO_C_STR(sensorHandle), serviceId);
654 SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorHandle, serviceId, DISABLE_SENSOR);
655 }
656
657 return ret;
658 }
659
Disable(const OHOS::HDI::Sensor::V3_0::DeviceSensorInfo & deviceSensorInfo)660 int32_t SensorIfService::Disable(const OHOS::HDI::Sensor::V3_0::DeviceSensorInfo& deviceSensorInfo)
661 {
662 SensorHandle sensorHandle = {deviceSensorInfo.deviceId, deviceSensorInfo.sensorType, deviceSensorInfo.sensorId,
663 deviceSensorInfo.location};
664 SENSOR_TRACE_PID_MSG("sensorHandle " + SENSOR_HANDLE_TO_STRING(sensorHandle));
665 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
666 HDF_LOGI("%{public}s:%{public}s pid %{public}d", __func__,
667 SENSOR_HANDLE_TO_C_STR(sensorHandle), serviceId);
668 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
669 return DisableSensor(sensorHandle, serviceId);
670 }
671
SetBatch(const OHOS::HDI::Sensor::V3_0::DeviceSensorInfo & deviceSensorInfo,int64_t samplingInterval,int64_t reportInterval)672 int32_t SensorIfService::SetBatch(const OHOS::HDI::Sensor::V3_0::DeviceSensorInfo& deviceSensorInfo,
673 int64_t samplingInterval, int64_t reportInterval)
674 {
675 SensorHandle sensorHandle = {deviceSensorInfo.deviceId, deviceSensorInfo.sensorType, deviceSensorInfo.sensorId,
676 deviceSensorInfo.location};
677 SENSOR_TRACE;
678 HDF_LOGD("%{public}s: sensorHandle is %{public}s, samplingInterval is [%{public}" PRId64 "], \
679 reportInterval is [%{public}" PRId64 "].", __func__, SENSOR_HANDLE_TO_C_STR(sensorHandle),
680 samplingInterval, reportInterval);
681 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
682 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
683
684 int32_t ret = SetBatchSenior(serviceId, sensorHandle, SA, samplingInterval, reportInterval);
685 if (ret != SENSOR_SUCCESS) {
686 HDF_LOGE("%{public}s SetBatch failed, error code is %{public}d", __func__, ret);
687 }
688
689 return ret;
690 }
691
SetMode(const OHOS::HDI::Sensor::V3_0::DeviceSensorInfo & deviceSensorInfo,int32_t mode)692 int32_t SensorIfService::SetMode(const OHOS::HDI::Sensor::V3_0::DeviceSensorInfo& deviceSensorInfo, int32_t mode)
693 {
694 SensorHandle sensorHandle = {deviceSensorInfo.deviceId, deviceSensorInfo.sensorType, deviceSensorInfo.sensorId,
695 deviceSensorInfo.location};
696 SENSOR_TRACE_PID_MSG("sensorHandle " + SENSOR_HANDLE_TO_STRING(sensorHandle) + "mode " + std::to_string(mode));
697 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
698 HDF_LOGI("%{public}s:%{public}s mode%{public}d pid %{public}d", __func__,
699 SENSOR_HANDLE_TO_C_STR(sensorHandle), mode,
700 serviceId);
701 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
702 if (sensorVdiImplV1_1_ == nullptr) {
703 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
704 return HDF_FAILURE;
705 }
706
707 int32_t ret = HDF_FAILURE;
708 SENSOR_TRACE_START("sensorVdiImplV1_1_->SetMode");
709 #ifdef TV_FLAG
710 ret = sensorVdiImplV1_1_->SetMode(sensorHandle, mode);
711 #else
712 ret = sensorVdiImplV1_1_->SetMode(sensorHandle.sensorType, mode);
713 #endif
714 SENSOR_TRACE_FINISH;
715 if (ret != SENSOR_SUCCESS) {
716 HDF_LOGE("%{public}s SetMode failed, error code is %{public}d", __func__, ret);
717 }
718
719 return ret;
720 }
721
SetOption(const OHOS::HDI::Sensor::V3_0::DeviceSensorInfo & deviceSensorInfo,uint32_t option)722 int32_t SensorIfService::SetOption(const OHOS::HDI::Sensor::V3_0::DeviceSensorInfo& deviceSensorInfo, uint32_t option)
723 {
724 SensorHandle sensorHandle = {deviceSensorInfo.deviceId, deviceSensorInfo.sensorType, deviceSensorInfo.sensorId,
725 deviceSensorInfo.location};
726 SENSOR_TRACE_PID_MSG("sensorHandle " + SENSOR_HANDLE_TO_STRING(sensorHandle) + "option " + std::to_string(option));
727 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
728 HDF_LOGI("%{public}s:%{public}s option %{public}d pid %{public}d", __func__,
729 SENSOR_HANDLE_TO_C_STR(sensorHandle),
730 option, serviceId);
731 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
732 if (sensorVdiImplV1_1_ == nullptr) {
733 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
734 return HDF_FAILURE;
735 }
736
737 SENSOR_TRACE_START("sensorVdiImplV1_1_->SetOption");
738 #ifdef TV_FLAG
739 int32_t ret = sensorVdiImplV1_1_->SetOption(sensorHandle, option);
740 #else
741 int32_t ret = sensorVdiImplV1_1_->SetOption(sensorHandle.sensorType, option);
742 #endif
743 SENSOR_TRACE_FINISH;
744 if (ret != SENSOR_SUCCESS) {
745 HDF_LOGE("%{public}s SetOption failed, error code is %{public}d", __func__, ret);
746 }
747
748 return ret;
749 }
750
Register(int32_t groupId,const sptr<V3_0::ISensorCallback> & callbackObj)751 int32_t SensorIfService::Register(int32_t groupId, const sptr<V3_0::ISensorCallback> &callbackObj)
752 {
753 SENSOR_TRACE_PID;
754 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
755 HDF_LOGI("%{public}s:groupId %{public}d pid %{public}d", __func__, groupId, serviceId);
756 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
757 int32_t ret = HDF_SUCCESS;
758 const sptr<IRemoteObject> &iRemoteObject = OHOS::HDI::hdi_objcast<V3_0::ISensorCallback>(callbackObj);
759 int32_t result = AddCallbackMap(groupId, iRemoteObject);
760 if (result != SENSOR_SUCCESS) {
761 HDF_LOGE("%{public}s: AddCallbackMap failed groupId[%{public}d]", __func__, groupId);
762 }
763 if (SensorClientsManager::GetInstance()->IsClientsEmpty(groupId)) {
764 if (sensorVdiImplV1_1_ == nullptr) {
765 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
766 return HDF_FAILURE;
767 }
768 sptr<SensorCallbackVdi> sensorCb = GetSensorCb(groupId, callbackObj, REGISTER_SENSOR);
769 if (sensorCb == nullptr) {
770 HDF_LOGE("%{public}s: get sensorcb fail, groupId[%{public}d]", __func__, groupId);
771 return HDF_FAILURE;
772 }
773 SENSOR_TRACE_START("sensorVdiImplV1_1_->Register");
774 ret = sensorVdiImplV1_1_->Register(groupId, sensorCb);
775 SENSOR_TRACE_FINISH;
776 if (ret != SENSOR_SUCCESS) {
777 HDF_LOGE("%{public}s Register failed, error code is %{public}d", __func__, ret);
778 int32_t removeResult = RemoveSensorDeathRecipient(iRemoteObject);
779 if (removeResult != SENSOR_SUCCESS) {
780 HDF_LOGE("%{public}s: callback RemoveSensorDeathRecipient fail, groupId[%{public}d]",
781 __func__, groupId);
782 }
783 } else {
784 SensorClientsManager::GetInstance()->ReportDataCbRegister(groupId, serviceId, callbackObj, false);
785 }
786 } else {
787 SensorClientsManager::GetInstance()->ReportDataCbRegister(groupId, serviceId, callbackObj, false);
788 }
789 return ret;
790 }
791
Unregister(int32_t groupId,const sptr<V3_0::ISensorCallback> & callbackObj)792 int32_t SensorIfService::Unregister(int32_t groupId, const sptr<V3_0::ISensorCallback> &callbackObj)
793 {
794 SENSOR_TRACE_PID;
795 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
796 HDF_LOGI("%{public}s:groupId %{public}d pid %{public}d", __func__, groupId, serviceId);
797 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
798 if (groupId < TRADITIONAL_SENSOR_TYPE || groupId >= SENSOR_GROUP_TYPE_MAX) {
799 HDF_LOGE("%{public}s: groupId %{public}d is error", __func__, groupId);
800 return SENSOR_INVALID_PARAM;
801 }
802 const sptr<IRemoteObject> &iRemoteObject = OHOS::HDI::hdi_objcast<V3_0::ISensorCallback>(callbackObj);
803 int32_t result = RemoveCallbackMap(groupId, serviceId, iRemoteObject);
804 if (result !=SENSOR_SUCCESS) {
805 HDF_LOGE("%{public}s: RemoveCallbackMap failed groupId[%{public}d]", __func__, groupId);
806 }
807 SensorClientsManager::GetInstance()->ReportDataCbUnRegister(groupId, serviceId, callbackObj);
808 if (!SensorClientsManager::GetInstance()->IsClientsEmpty(groupId)) {
809 HDF_LOGD("%{public}s: clients is not empty, do not unregister", __func__);
810 return HDF_SUCCESS;
811 }
812 if (!SensorClientsManager::GetInstance()->IsNoSensorUsed()) {
813 HDF_LOGD("%{public}s: sensorUsed is not empty, do not unregister", __func__);
814 return HDF_SUCCESS;
815 }
816
817 if (sensorVdiImplV1_1_ == nullptr) {
818 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
819 return HDF_FAILURE;
820 }
821
822 sptr<SensorCallbackVdi> sensorCb = GetSensorCb(groupId, callbackObj, UNREGISTER_SENSOR);
823 if (sensorCb == nullptr) {
824 HDF_LOGE("%{public}s: get sensorcb fail, groupId[%{public}d]", __func__, groupId);
825 return HDF_FAILURE;
826 }
827 SENSOR_TRACE_START("sensorVdiImplV1_1_->Unregister");
828 int32_t ret = sensorVdiImplV1_1_->Unregister(groupId, sensorCb);
829 SENSOR_TRACE_FINISH;
830 if (ret != SENSOR_SUCCESS) {
831 HDF_LOGE("%{public}s: Unregister failed, error code is %{public}d", __func__, ret);
832 }
833
834 return ret;
835 }
836
ReadData(const OHOS::HDI::Sensor::V3_0::DeviceSensorInfo & deviceSensorInfo,std::vector<V3_0::HdfSensorEvents> & event)837 int32_t SensorIfService::ReadData(const OHOS::HDI::Sensor::V3_0::DeviceSensorInfo& deviceSensorInfo,
838 std::vector<V3_0::HdfSensorEvents> &event)
839 {
840 SensorHandle sensorHandle = {deviceSensorInfo.deviceId, deviceSensorInfo.sensorType, deviceSensorInfo.sensorId,
841 deviceSensorInfo.location};
842 SENSOR_TRACE_PID_MSG("sensorHandle " + SENSOR_HANDLE_TO_STRING(sensorHandle));
843 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
844 HDF_LOGI("%{public}s:pid %{public}d", __func__, serviceId);
845 if (sensorVdiImplV1_1_ == nullptr) {
846 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
847 return HDF_FAILURE;
848 }
849
850 return HDF_SUCCESS;
851 }
852
VoteEnable(const SensorHandle sensorHandle,uint32_t serviceId,bool & enabled)853 void SensorIfService::VoteEnable(const SensorHandle sensorHandle, uint32_t serviceId, bool& enabled)
854 {
855 static std::map<SensorHandle, std::map<uint32_t, bool>> sdcEnableMap;
856 if (enabled) {
857 sdcEnableMap[sensorHandle][serviceId] = enabled;
858 } else {
859 sdcEnableMap[sensorHandle].erase(serviceId);
860 }
861 for (auto it = sdcEnableMap[sensorHandle].begin(); it != sdcEnableMap[sensorHandle].end(); ++it) {
862 if (it->second == true) {
863 enabled = true;
864 }
865 }
866 }
867
VoteInterval(const SensorHandle sensorHandle,uint32_t serviceId,int64_t & samplingInterval,bool & enabled)868 void SensorIfService::VoteInterval(const SensorHandle sensorHandle, uint32_t serviceId,
869 int64_t &samplingInterval, bool &enabled)
870 {
871 static std::map<SensorHandle, std::map<uint32_t, int64_t>> sdcIntervalMap;
872 if (enabled) {
873 sdcIntervalMap[sensorHandle][serviceId] = samplingInterval;
874 } else {
875 samplingInterval = 0;
876 sdcIntervalMap[sensorHandle].erase(serviceId);
877 }
878 for (auto it = sdcIntervalMap[sensorHandle].begin(); it != sdcIntervalMap[sensorHandle].end(); ++it) {
879 if (samplingInterval == 0) {
880 samplingInterval = it->second;
881 }
882 samplingInterval = samplingInterval < it->second ? samplingInterval : it->second;
883 }
884 HDF_LOGI("%{public}s:interval %{public}s", __func__, std::to_string(samplingInterval / ONE_MILLION).c_str());
885 }
886
SetSdcSensor(const OHOS::HDI::Sensor::V3_0::DeviceSensorInfo & deviceSensorInfo,bool enabled,int32_t rateLevel)887 int32_t SensorIfService::SetSdcSensor(const OHOS::HDI::Sensor::V3_0::DeviceSensorInfo& deviceSensorInfo, bool enabled,
888 int32_t rateLevel)
889 {
890 SensorHandle sensorHandle = {deviceSensorInfo.deviceId, deviceSensorInfo.sensorType, deviceSensorInfo.sensorId,
891 deviceSensorInfo.location};
892 SENSOR_TRACE_PID_MSG("sensorHandle " + SENSOR_HANDLE_TO_STRING(sensorHandle) + "enabled " +
893 std::to_string(enabled) + "rateLevel " + std::to_string(rateLevel));
894 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
895 HDF_LOGI("%{public}s:%{public}s enabled %{public}u rateLevel %{public}u pid %{public}d",
896 __func__, SENSOR_HANDLE_TO_C_STR(sensorHandle), enabled, rateLevel, serviceId);
897
898 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
899 if (sensorVdiImplV1_1_ == nullptr) {
900 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
901 return HDF_FAILURE;
902 }
903
904 if (rateLevel < REPORT_INTERVAL) {
905 HDF_LOGE("%{public}s: rateLevel cannot be less than zero", __func__);
906 return HDF_FAILURE;
907 }
908
909 int64_t samplingInterval = CalculateSamplingInterval(rateLevel);
910 int64_t reportInterval = REPORT_INTERVAL;
911
912 VoteInterval(sensorHandle, serviceId, samplingInterval, enabled);
913 VoteEnable(sensorHandle, serviceId, enabled);
914
915 return enabled ? EnableSdcSensor(serviceId, sensorHandle, samplingInterval, reportInterval)
916 : DisableSdcSensor(serviceId, sensorHandle, samplingInterval, reportInterval);
917 }
918
CalculateSamplingInterval(int32_t rateLevel)919 int64_t SensorIfService::CalculateSamplingInterval(int32_t rateLevel)
920 {
921 if (rateLevel == 0) {
922 return REPORT_INTERVAL;
923 }
924 return COMMON_REPORT_FREQUENCY / rateLevel;
925 }
926
EnableSdcSensor(uint32_t serviceId,const SensorHandle & sensorHandle,int64_t samplingInterval,int64_t reportInterval)927 int32_t SensorIfService::EnableSdcSensor(uint32_t serviceId, const SensorHandle& sensorHandle,
928 int64_t samplingInterval, int64_t reportInterval)
929 {
930 int32_t ret = SetBatchSenior(serviceId, sensorHandle, SDC, samplingInterval, reportInterval);
931 if (ret != SENSOR_SUCCESS) {
932 HDF_LOGE("%{public}s SetBatchSenior SDC failed, error code is %{public}d", __func__, ret);
933 return ret;
934 }
935
936 SENSOR_TRACE_START("sensorVdiImplV1_1_->Enable");
937 #ifdef TV_FLAG
938 ret = sensorVdiImplV1_1_->Enable(sensorHandle);
939 #else
940 ret = sensorVdiImplV1_1_->Enable(sensorHandle.sensorType);
941 #endif
942 SENSOR_TRACE_FINISH;
943
944 if (ret != SENSOR_SUCCESS) {
945 HDF_LOGE("%{public}s Enable failed, error code is %{public}d", __func__, ret);
946 }
947
948 return ret;
949 }
950
DisableSdcSensor(uint32_t serviceId,const SensorHandle & sensorHandle,int64_t samplingInterval,int64_t reportInterval)951 int32_t SensorIfService::DisableSdcSensor(uint32_t serviceId, const SensorHandle& sensorHandle,
952 int64_t samplingInterval, int64_t reportInterval)
953 {
954 SensorClientsManager::GetInstance()->EraseSdcSensorBestConfig(sensorHandle);
955
956 int32_t ret = DisableSensor(sensorHandle, serviceId);
957 if (ret != SENSOR_SUCCESS) {
958 HDF_LOGE("%{public}s Disable failed, error code is %{public}d", __func__, ret);
959 return ret;
960 }
961
962 SensorClientsManager::GetInstance()->GetSensorBestConfig(sensorHandle, samplingInterval, reportInterval);
963
964 SENSOR_TRACE_START("sensorVdiImplV1_1_->SetSaBatch");
965 #ifdef TV_FLAG
966 ret = sensorVdiImplV1_1_->SetSaBatch(sensorHandle, samplingInterval, reportInterval);
967 #else
968 ret = sensorVdiImplV1_1_->SetSaBatch(sensorHandle.sensorType, samplingInterval, reportInterval);
969 #endif
970 SENSOR_TRACE_FINISH;
971
972 if (ret != SENSOR_SUCCESS) {
973 HDF_LOGE("%{public}s SetSaBatch failed, error code is %{public}d", __func__, ret);
974 }
975
976 return ret;
977 }
978
GetSdcSensorInfo(std::vector<V3_0::SdcSensorInfo> & sdcSensorInfo)979 int32_t SensorIfService::GetSdcSensorInfo(std::vector<V3_0::SdcSensorInfo>& sdcSensorInfo)
980 {
981 SENSOR_TRACE_PID;
982 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
983 HDF_LOGI("%{public}s:pid %{public}d", __func__, serviceId);
984 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
985 if (sensorVdiImplV1_1_ == nullptr) {
986 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
987 return HDF_FAILURE;
988 }
989
990 SENSOR_TRACE_START("sensorVdiImplV1_1_->GetSdcSensorInfo");
991 std::vector<OHOS::HDI::Sensor::V1_1::SdcSensorInfoVdi> sdcSensorInfoVdi1_1;
992 int32_t ret = sensorVdiImplV1_1_->GetSdcSensorInfo(sdcSensorInfoVdi1_1);
993 SENSOR_TRACE_FINISH;
994 if (ret != SENSOR_SUCCESS) {
995 HDF_LOGE("%{public}s GetSdcSensorInfo failed, error code is %{public}d", __func__, ret);
996 }
997
998 for (auto infoVdi : sdcSensorInfoVdi1_1) {
999 V3_0::SdcSensorInfo info;
1000 info.offset = infoVdi.offset;
1001 #ifdef TV_FLAG
1002 info.deviceSensorInfo = {infoVdi.sensorHandle.deviceId, infoVdi.sensorHandle.sensorType,
1003 infoVdi.sensorHandle.sensorId,
1004 infoVdi.sensorHandle.location};
1005 #else
1006 info.deviceSensorInfo = {DEFAULT_DEVICE_ID, infoVdi.sensorId, DEFAULT_SENSOR_ID,
1007 DEFAULT_LOCATION};
1008 #endif
1009 info.ddrSize = infoVdi.ddrSize;
1010 info.minRateLevel = infoVdi.minRateLevel;
1011 info.maxRateLevel = infoVdi.maxRateLevel;
1012 info.memAddr = infoVdi.memAddr;
1013 info.reserved = infoVdi.reserved;
1014 sdcSensorInfo.push_back(std::move(info));
1015 }
1016
1017 return ret;
1018 }
1019
RegisterAsync(int32_t groupId,const sptr<V3_0::ISensorCallback> & callbackObj)1020 int32_t SensorIfService::RegisterAsync(int32_t groupId, const sptr<V3_0::ISensorCallback> &callbackObj)
1021 {
1022 SENSOR_TRACE_PID;
1023 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
1024 HDF_LOGI("%{public}s:groupId %{public}d pid %{public}d", __func__, groupId, serviceId);
1025 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
1026 int32_t ret = HDF_SUCCESS;
1027 const sptr<IRemoteObject> &iRemoteObject = OHOS::HDI::hdi_objcast<V3_0::ISensorCallback>(callbackObj);
1028 int32_t result = AddCallbackMap(groupId, iRemoteObject);
1029 if (result != SENSOR_SUCCESS) {
1030 HDF_LOGE("%{public}s: AddCallbackMap failed groupId[%{public}d]", __func__, groupId);
1031 }
1032 if (SensorClientsManager::GetInstance()->IsClientsEmpty(groupId)) {
1033 if (sensorVdiImplV1_1_ == nullptr) {
1034 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
1035 return HDF_FAILURE;
1036 }
1037 sptr<SensorCallbackVdi> sensorCb = GetSensorCb(groupId, callbackObj, REGISTER_SENSOR);
1038 if (sensorCb == nullptr) {
1039 HDF_LOGE("%{public}s: get sensorcb fail, groupId[%{public}d]", __func__, groupId);
1040 return HDF_FAILURE;
1041 }
1042 SENSOR_TRACE_START("sensorVdiImplV1_1_->Register");
1043 #ifdef TV_FLAG
1044 ret = sensorVdiImplV1_1_->Register(groupId, sensorCb);
1045 #else
1046 ret = sensorVdiImplV1_1_->Register(groupId, sensorCb);
1047 #endif
1048 SENSOR_TRACE_FINISH;
1049 if (ret != SENSOR_SUCCESS) {
1050 HDF_LOGE("%{public}s Register failed, error code is %{public}d", __func__, ret);
1051 int32_t removeResult = RemoveSensorDeathRecipient(iRemoteObject);
1052 if (removeResult != SENSOR_SUCCESS) {
1053 HDF_LOGE("%{public}s: callback RemoveSensorDeathRecipient fail, groupId[%{public}d]",
1054 __func__, groupId);
1055 }
1056 } else {
1057 SensorClientsManager::GetInstance()->ReportDataCbRegister(groupId, serviceId, callbackObj, true);
1058 }
1059 } else {
1060 SensorClientsManager::GetInstance()->ReportDataCbRegister(groupId, serviceId, callbackObj, true);
1061 }
1062 return ret;
1063 }
1064
UnregisterAsync(int32_t groupId,const sptr<V3_0::ISensorCallback> & callbackObj)1065 int32_t SensorIfService::UnregisterAsync(int32_t groupId, const sptr<V3_0::ISensorCallback> &callbackObj)
1066 {
1067 return Unregister(groupId, callbackObj);
1068 }
1069
GetDeviceSensorInfo(int32_t deviceId,std::vector<V3_0::HdfSensorInformation> & info)1070 int32_t SensorIfService::GetDeviceSensorInfo(int32_t deviceId, std::vector<V3_0::HdfSensorInformation> &info)
1071 {
1072 SENSOR_TRACE_PID;
1073 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
1074 HDF_LOGI("%{public}s:pid %{public}d", __func__, serviceId);
1075 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
1076
1077 std::vector<OHOS::HDI::Sensor::V3_0::HdfSensorInformationVdi> sensorInfoVdi = {};
1078
1079 int32_t ret = SENSOR_FAILURE;
1080 SENSOR_TRACE_START("sensorVdiImplV1_1_->GetAllSensorInfo");
1081 #ifdef TV_FLAG
1082 ret = sensorVdiImplV1_1_->GetDeviceSensorInfo(deviceId, sensorInfoVdi);
1083 #else
1084 HDF_LOGI("%{public}s:not support", __func__);
1085 ret = SENSOR_SUCCESS;
1086 #endif
1087 SENSOR_TRACE_FINISH;
1088
1089 if (sensorInfoVdi.empty()) {
1090 HDF_LOGI("%{public}s:empty", __func__);
1091 }
1092
1093 for (const auto &it : sensorInfoVdi) {
1094 struct V3_0::HdfSensorInformation sensorInfo = {};
1095 sensorInfo.sensorName = it.sensorName;
1096 sensorInfo.vendorName = it.vendorName;
1097 sensorInfo.firmwareVersion = it.firmwareVersion;
1098 sensorInfo.hardwareVersion = it.hardwareVersion;
1099 sensorInfo.maxRange = it.maxRange;
1100 #ifdef TV_FLAG
1101 sensorInfo.deviceSensorInfo = {it.sensorHandle.deviceId, it.sensorHandle.sensorType, it.sensorHandle.sensorId,
1102 it.sensorHandle.location};
1103 #else
1104 sensorInfo.deviceSensorInfo = {DEFAULT_DEVICE_ID, it.sensorId, DEFAULT_SENSOR_ID, DEFAULT_LOCATION};
1105 #endif
1106 sensorInfo.accuracy = it.accuracy;
1107 sensorInfo.power = it.power;
1108 sensorInfo.minDelay = it.minDelay;
1109 sensorInfo.maxDelay = it.maxDelay;
1110 sensorInfo.fifoMaxEventCount = it.fifoMaxEventCount;
1111 info.push_back(std::move(sensorInfo));
1112 }
1113
1114 return ret;
1115 }
1116
RegSensorPlugCallBack(const sptr<V3_0::ISensorPlugCallback> & callbackObj)1117 int32_t SensorIfService::RegSensorPlugCallBack(const sptr<V3_0::ISensorPlugCallback> &callbackObj)
1118 {
1119 SENSOR_TRACE_PID;
1120 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
1121 HDF_LOGI("%{public}s:pid %{public}d", __func__, serviceId);
1122 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
1123
1124 int32_t ret = SENSOR_FAILURE;
1125 SENSOR_TRACE_START("sensorVdiImplV1_1_->RegSensorPlugCallBack");
1126 #ifdef TV_FLAG
1127 ret = sensorVdiImplV1_1_->RegSensorPlugCallBack(callbackObj);
1128 #else
1129 HDF_LOGI("%{public}s:not support", __func__);
1130 ret = SENSOR_SUCCESS;
1131 #endif
1132 SENSOR_TRACE_FINISH;
1133
1134 if (ret != SENSOR_SUCCESS) {
1135 HDF_LOGE("%{public}s SetOption failed, error code is %{public}d", __func__, ret);
1136 }
1137
1138 return ret;
1139 }
1140
UnRegSensorPlugCallBack(const sptr<V3_0::ISensorPlugCallback> & callbackObj)1141 int32_t SensorIfService::UnRegSensorPlugCallBack(const sptr<V3_0::ISensorPlugCallback> &callbackObj)
1142 {
1143 SENSOR_TRACE_PID;
1144 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
1145 HDF_LOGI("%{public}s:pid %{public}d", __func__, serviceId);
1146 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
1147
1148 int32_t ret = SENSOR_FAILURE;
1149 SENSOR_TRACE_START("sensorVdiImplV1_1_->UnRegSensorPlugCallBack");
1150 #ifdef TV_FLAG
1151 ret = sensorVdiImplV1_1_->UnRegSensorPlugCallBack(callbackObj);
1152 #else
1153 HDF_LOGI("%{public}s:not support", __func__);
1154 ret = SENSOR_SUCCESS;
1155 #endif
1156 SENSOR_TRACE_FINISH;
1157
1158 if (ret != SENSOR_SUCCESS) {
1159 HDF_LOGE("%{public}s SetOption failed, error code is %{public}d", __func__, ret);
1160 }
1161
1162 return ret;
1163 }
1164
1165 } // namespace V3_0
1166 } // namespace Sensor
1167 } // namespace HDI
1168 } // namespace OHOS