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 uhdf_sensor_service
40
41 namespace OHOS {
42 namespace HDI {
43 namespace Sensor {
44 namespace V2_1 {
45 namespace {
46 constexpr int32_t CALLBACK_CTOUNT_THRESHOLD = 1;
47 using CallBackDeathRecipientMap = std::unordered_map<IRemoteObject *, sptr<CallBackDeathRecipient>>;
48 CallBackDeathRecipientMap g_callBackDeathRecipientMap;
49 }
50
SensorIfService()51 SensorIfService::SensorIfService()
52 {
53 int32_t ret = GetSensorVdiImpl();
54 if (ret != HDF_SUCCESS) {
55 HDF_LOGE("%{public}s: get sensor vdi instance failed", __func__);
56 }
57 }
58
~SensorIfService()59 SensorIfService::~SensorIfService()
60 {
61 if (vdi_ != nullptr) {
62 HdfCloseVdi(vdi_);
63 }
64 RemoveDeathNotice(TRADITIONAL_SENSOR_TYPE);
65 RemoveDeathNotice(MEDICAL_SENSOR_TYPE);
66 }
67
RegisteDumpHost()68 void SensorIfService::RegisteDumpHost()
69 {
70 int32_t ret = DevHostRegisterDumpHost(GetSensorDump);
71 if (ret != HDF_SUCCESS) {
72 HDF_LOGE("%{public}s: DevHostRegisterDumpHost error", __func__);
73 }
74 return;
75 }
76
GetSensorVdiImpl()77 int32_t SensorIfService::GetSensorVdiImpl()
78 {
79 struct OHOS::HDI::Sensor::V1_1::WrapperSensorVdi *wrapperSensorVdi = nullptr;
80 uint32_t version = 0;
81 vdi_ = HdfLoadVdi(HDI_SENSOR_VDI_LIBNAME);
82 if (vdi_ == nullptr || vdi_->vdiBase == nullptr) {
83 HDF_LOGE("%{public}s: load sensor vdi failed", __func__);
84 return HDF_FAILURE;
85 }
86
87 version = HdfGetVdiVersion(vdi_);
88 if (version != 1) {
89 HDF_LOGE("%{public}s: get sensor vdi version failed", __func__);
90 return HDF_FAILURE;
91 }
92
93 wrapperSensorVdi = reinterpret_cast<struct OHOS::HDI::Sensor::V1_1::WrapperSensorVdi *>(vdi_->vdiBase);
94 sensorVdiImpl_ = wrapperSensorVdi->sensorModule;
95 if (sensorVdiImpl_ == nullptr) {
96 HDF_LOGE("%{public}s: get sensor impl failed", __func__);
97 return HDF_FAILURE;
98 }
99
100 return HDF_SUCCESS;
101 }
102
Init()103 int32_t SensorIfService::Init()
104 {
105 if (sensorVdiImpl_ == nullptr) {
106 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
107 return HDF_FAILURE;
108 }
109 int32_t ret = sensorVdiImpl_->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<V2_0::ISensorCallback> & callbackObj,bool cbFlag)124 sptr<SensorCallbackVdi> SensorIfService::GetSensorCb(int32_t groupId, const sptr<V2_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
GetAllSensorInfo(std::vector<HdfSensorInformation> & info)140 int32_t SensorIfService::GetAllSensorInfo(std::vector<HdfSensorInformation> &info)
141 {
142 SENSOR_TRACE_PID;
143 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
144 HDF_LOGI("%{public}s: serviceId = %{public}d", __func__, serviceId);
145 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
146 if (sensorVdiImpl_ == nullptr) {
147 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
148 return HDF_FAILURE;
149 }
150
151 std::vector<OHOS::HDI::Sensor::V1_1::HdfSensorInformationVdi> sensorInfoVdi = {};
152 SENSOR_TRACE_START("sensorVdiImpl_->GetAllSensorInfo");
153 int32_t ret = sensorVdiImpl_->GetAllSensorInfo(sensorInfoVdi);
154 SENSOR_TRACE_FINISH;
155 if (ret != SENSOR_SUCCESS) {
156 HDF_LOGE("%{public}s GetAllSensors failed, error code is %{public}d", __func__, ret);
157 return ret;
158 }
159
160 if (sensorInfoVdi.empty()) {
161 HDF_LOGE("%{public}s no sensor info in list", __func__);
162 return HDF_FAILURE;
163 }
164
165 for (const auto &it : sensorInfoVdi) {
166 struct HdfSensorInformation sensorInfo = {};
167 sensorInfo.sensorName = it.sensorName;
168 sensorInfo.vendorName = it.vendorName;
169 sensorInfo.firmwareVersion = it.firmwareVersion;
170 sensorInfo.hardwareVersion = it.hardwareVersion;
171 sensorInfo.sensorTypeId = it.sensorTypeId;
172 sensorInfo.sensorId = it.sensorId;
173 sensorInfo.maxRange = it.maxRange;
174 sensorInfo.accuracy = it.accuracy;
175 sensorInfo.power = it.power;
176 sensorInfo.minDelay = it.minDelay;
177 sensorInfo.maxDelay = it.maxDelay;
178 sensorInfo.fifoMaxEventCount = it.fifoMaxEventCount;
179 info.push_back(std::move(sensorInfo));
180
181 SensorClientsManager::GetInstance()->CopySensorInfo(info, COPY_SENSORINFO);
182 }
183
184 return HDF_SUCCESS;
185 }
186
Enable(int32_t sensorId)187 int32_t SensorIfService::Enable(int32_t sensorId)
188 {
189 SENSOR_TRACE_PID_MSG("sensorId " + std::to_string(sensorId));
190 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
191 HDF_LOGI("%{public}s: sensorId %{public}d, serviceId = %{public}d", __func__, sensorId, serviceId);
192 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
193 SensorClientsManager::GetInstance()->ReSetSensorPrintTime(sensorId);
194 if (!SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, serviceId, ENABLE_SENSOR)) {
195 return HDF_SUCCESS;
196 }
197
198 if (sensorVdiImpl_ == nullptr) {
199 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
200 return HDF_FAILURE;
201 }
202
203 SENSOR_TRACE_START("sensorVdiImpl_->Enable");
204 SensorClientsManager::GetInstance()->OpenSensor(sensorId, serviceId);
205 int32_t ret = sensorVdiImpl_->Enable(sensorId);
206 SENSOR_TRACE_FINISH;
207 if (ret != SENSOR_SUCCESS) {
208 HDF_LOGE("%{public}s failed, error code is %{public}d, sensorId = %{public}d, serviceId = %{public}d", __func__,
209 ret, sensorId, serviceId);
210 SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, serviceId, DISABLE_SENSOR);
211 }
212
213 return ret;
214 }
215
Disable(int32_t sensorId)216 int32_t SensorIfService::Disable(int32_t sensorId)
217 {
218 SENSOR_TRACE_PID_MSG("sensorId " + std::to_string(sensorId));
219 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
220 HDF_LOGI("%{public}s: sensorId %{public}d, serviceId = %{public}d", __func__, sensorId, serviceId);
221 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
222 return DisableSensor(sensorId, serviceId);
223 }
224
SetBatch(int32_t sensorId,int64_t samplingInterval,int64_t reportInterval)225 int32_t SensorIfService::SetBatch(int32_t sensorId, int64_t samplingInterval, int64_t reportInterval)
226 {
227 SENSOR_TRACE;
228 HDF_LOGD("%{public}s: sensorId is %{public}d, samplingInterval is [%{public}" PRId64 "], \
229 reportInterval is [%{public}" PRId64 "].", __func__, sensorId, samplingInterval, reportInterval);
230 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
231 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
232
233 int32_t ret = SetBatchSenior(serviceId, sensorId, SA, samplingInterval, reportInterval);
234 if (ret != SENSOR_SUCCESS) {
235 HDF_LOGE("%{public}s SetBatch failed, error code is %{public}d", __func__, ret);
236 }
237
238 return ret;
239 }
240
SetBatchSenior(int32_t serviceId,int32_t sensorId,int32_t mode,int64_t samplingInterval,int64_t reportInterval)241 int32_t SensorIfService::SetBatchSenior(int32_t serviceId, int32_t sensorId, int32_t mode, int64_t samplingInterval,
242 int64_t reportInterval)
243 {
244 SENSOR_TRACE_PID_MSG("sensorId " + std::to_string(sensorId) + "mode " +
245 std::to_string(mode) + "samplingInterval " + std::to_string(samplingInterval) + "reportInterval " +
246 std::to_string(reportInterval));
247 HDF_LOGI("%{public}s: serviceId is %{public}d, sensorId is %{public}d, mode is %{public}d, samplingInterval is "
248 "[%{public}" PRId64 "], reportInterval is [%{public}" PRId64 "].", __func__, serviceId, sensorId, mode,
249 samplingInterval, reportInterval);
250 if (sensorVdiImpl_ == nullptr) {
251 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
252 return HDF_FAILURE;
253 }
254 SensorClientsManager::GetInstance()->SetClientSenSorConfig(sensorId, serviceId, samplingInterval, reportInterval);
255
256 int64_t saSamplingInterval = samplingInterval;
257 int64_t saReportInterval = reportInterval;
258 int64_t sdcSamplingInterval = samplingInterval;
259 int64_t sdcReportInterval = reportInterval;
260
261 SensorClientsManager::GetInstance()->SetSensorBestConfig(sensorId, saSamplingInterval, saReportInterval);
262 SensorClientsManager::GetInstance()->SetSdcSensorBestConfig(sensorId, sdcSamplingInterval, sdcReportInterval);
263
264 samplingInterval = saSamplingInterval < sdcSamplingInterval ? saSamplingInterval : sdcSamplingInterval;
265 reportInterval = saReportInterval < sdcReportInterval ? saReportInterval : sdcReportInterval;
266
267 SENSOR_TRACE_START("sensorVdiImpl_->SetBatch");
268 int32_t ret = sensorVdiImpl_->SetBatch(sensorId, samplingInterval, reportInterval);
269 SENSOR_TRACE_FINISH;
270 if (ret != SENSOR_SUCCESS) {
271 HDF_LOGE("%{public}s SetBatch failed, error code is %{public}d", __func__, ret);
272 return ret;
273 }
274 if (mode == SA) {
275 SetDelay(sensorId, saSamplingInterval, saReportInterval);
276 SensorClientsManager::GetInstance()->UpdateSensorConfig(sensorId, saSamplingInterval, saReportInterval);
277 SensorClientsManager::GetInstance()->UpdateClientPeriodCount(sensorId, saSamplingInterval, saReportInterval);
278 }
279 if (mode == SDC) {
280 SensorClientsManager::GetInstance()->UpdateSdcSensorConfig(sensorId, sdcSamplingInterval, sdcReportInterval);
281 }
282 SensorClientsManager::GetInstance()->GetSensorBestConfig(sensorId, samplingInterval, reportInterval);
283 SENSOR_TRACE_START("sensorVdiImpl_->SetSaBatch");
284 ret = sensorVdiImpl_->SetSaBatch(sensorId, samplingInterval, samplingInterval);
285 SENSOR_TRACE_FINISH;
286 if (ret != SENSOR_SUCCESS) {
287 HDF_LOGE("%{public}s SetSaBatch failed, error code is %{public}d", __func__, ret);
288 }
289
290 return ret;
291 }
292
SetDelay(int32_t sensorId,int64_t & samplingInterval,int64_t & reportInterval)293 int32_t SensorIfService::SetDelay(int32_t sensorId, int64_t &samplingInterval, int64_t &reportInterval)
294 {
295 SENSOR_TRACE_PID_MSG("sensorId " + std::to_string(sensorId) + "samplingInterval " +
296 std::to_string(samplingInterval) + "reportInterval " + std::to_string(reportInterval));
297 HDF_LOGD("%{public}s: sensorId is %{public}d, samplingInterval is [%{public}" PRId64 "], reportInterval is "
298 "[%{public}" PRId64 "].", __func__, sensorId, samplingInterval, reportInterval);
299 for (auto it = hdfSensorInformations.begin(); it != hdfSensorInformations.end(); ++it) {
300 if (it->sensorId == sensorId) {
301 if (samplingInterval < it->minDelay) {
302 samplingInterval = it->minDelay;
303 HDF_LOGI("%{public}s samplingInterval has been set minDelay %{public}s", __func__,
304 std::to_string(samplingInterval).c_str());
305 return SENSOR_SUCCESS;
306 }
307 if (samplingInterval > it->maxDelay && it->maxDelay != REPORT_INTERVAL) {
308 samplingInterval = it->maxDelay;
309 HDF_LOGI("%{public}s samplingInterval has been set maxDelay %{public}s", __func__,
310 std::to_string(samplingInterval).c_str());
311 return SENSOR_SUCCESS;
312 }
313 }
314 }
315 HDF_LOGD("%{public}s samplingInterval not change", __func__);
316 return SENSOR_SUCCESS;
317 }
318
SetMode(int32_t sensorId,int32_t mode)319 int32_t SensorIfService::SetMode(int32_t sensorId, int32_t mode)
320 {
321 SENSOR_TRACE_PID_MSG("sensorId " + std::to_string(sensorId) + "mode " + std::to_string(mode));
322 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
323 HDF_LOGI("%{public}s: sensorId is %{public}d, mode is %{public}d, serviceId = %{public}d", __func__, sensorId, mode,
324 serviceId);
325 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
326 if (sensorVdiImpl_ == nullptr) {
327 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
328 return HDF_FAILURE;
329 }
330
331 SENSOR_TRACE_START("sensorVdiImpl_->SetMode");
332 int32_t ret = sensorVdiImpl_->SetMode(sensorId, mode);
333 SENSOR_TRACE_FINISH;
334 if (ret != SENSOR_SUCCESS) {
335 HDF_LOGE("%{public}s SetMode failed, error code is %{public}d", __func__, ret);
336 }
337
338 return ret;
339 }
340
SetOption(int32_t sensorId,uint32_t option)341 int32_t SensorIfService::SetOption(int32_t sensorId, uint32_t option)
342 {
343 SENSOR_TRACE_PID_MSG("sensorId " + std::to_string(sensorId) + "option " + std::to_string(option));
344 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
345 HDF_LOGI("%{public}s: sensorId is %{public}d, option is %{public}d, serviceId = %{public}d", __func__, sensorId,
346 option, serviceId);
347 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
348 if (sensorVdiImpl_ == nullptr) {
349 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
350 return HDF_FAILURE;
351 }
352
353 SENSOR_TRACE_START("sensorVdiImpl_->SetOption");
354 int32_t ret = sensorVdiImpl_->SetOption(sensorId, option);
355 SENSOR_TRACE_FINISH;
356 if (ret != SENSOR_SUCCESS) {
357 HDF_LOGE("%{public}s SetOption failed, error code is %{public}d", __func__, ret);
358 }
359
360 return ret;
361 }
362
Register(int32_t groupId,const sptr<V2_0::ISensorCallback> & callbackObj)363 int32_t SensorIfService::Register(int32_t groupId, const sptr<V2_0::ISensorCallback> &callbackObj)
364 {
365 SENSOR_TRACE_PID;
366 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
367 HDF_LOGI("%{public}s: groupId %{public}d, service %{public}d", __func__, groupId, serviceId);
368 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
369 int32_t ret = HDF_SUCCESS;
370 int32_t result = AddCallbackMap(groupId, callbackObj);
371 if (result !=SENSOR_SUCCESS) {
372 HDF_LOGE("%{public}s: AddCallbackMap failed groupId[%{public}d]", __func__, groupId);
373 }
374 if (SensorClientsManager::GetInstance()->IsClientsEmpty(groupId)) {
375 if (sensorVdiImpl_ == nullptr) {
376 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
377 return HDF_FAILURE;
378 }
379 sptr<SensorCallbackVdi> sensorCb = GetSensorCb(groupId, callbackObj, REGISTER_SENSOR);
380 if (sensorCb == nullptr) {
381 HDF_LOGE("%{public}s: get sensorcb fail, groupId[%{public}d]", __func__, groupId);
382 return HDF_FAILURE;
383 }
384 SENSOR_TRACE_START("sensorVdiImpl_->Register");
385 ret = sensorVdiImpl_->Register(groupId, sensorCb);
386 SENSOR_TRACE_FINISH;
387 if (ret != SENSOR_SUCCESS) {
388 HDF_LOGE("%{public}s Register failed, error code is %{public}d", __func__, ret);
389 int32_t removeResult = RemoveSensorDeathRecipient(callbackObj);
390 if (removeResult != SENSOR_SUCCESS) {
391 HDF_LOGE("%{public}s: callback RemoveSensorDeathRecipient fail, groupId[%{public}d]",
392 __func__, groupId);
393 }
394 } else {
395 SensorClientsManager::GetInstance()->ReportDataCbRegister(groupId, serviceId, callbackObj);
396 }
397 } else {
398 SensorClientsManager::GetInstance()->ReportDataCbRegister(groupId, serviceId, callbackObj);
399 }
400 return ret;
401 }
402
Unregister(int32_t groupId,const sptr<V2_0::ISensorCallback> & callbackObj)403 int32_t SensorIfService::Unregister(int32_t groupId, const sptr<V2_0::ISensorCallback> &callbackObj)
404 {
405 SENSOR_TRACE_PID;
406 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
407 HDF_LOGI("%{public}s: groupId %{public}d, service %{public}d", __func__, groupId, serviceId);
408 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
409 if (groupId < TRADITIONAL_SENSOR_TYPE || groupId >= SENSOR_GROUP_TYPE_MAX) {
410 HDF_LOGE("%{public}s: groupId %{public}d is error", __func__, groupId);
411 return SENSOR_INVALID_PARAM;
412 }
413 int32_t result = RemoveCallbackMap(groupId, serviceId, callbackObj);
414 if (result !=SENSOR_SUCCESS) {
415 HDF_LOGE("%{public}s: RemoveCallbackMap failed groupId[%{public}d]", __func__, groupId);
416 }
417 SensorClientsManager::GetInstance()->ReportDataCbUnRegister(groupId, serviceId, callbackObj);
418 if (!SensorClientsManager::GetInstance()->IsClientsEmpty(groupId)) {
419 HDF_LOGD("%{public}s: clients is not empty, do not unregister", __func__);
420 return HDF_SUCCESS;
421 }
422 if (!SensorClientsManager::GetInstance()->IsNoSensorUsed()) {
423 HDF_LOGD("%{public}s: sensorUsed is not empty, do not unregister", __func__);
424 return HDF_SUCCESS;
425 }
426
427 if (sensorVdiImpl_ == nullptr) {
428 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
429 return HDF_FAILURE;
430 }
431
432 sptr<SensorCallbackVdi> sensorCb = GetSensorCb(groupId, callbackObj, UNREGISTER_SENSOR);
433 if (sensorCb == nullptr) {
434 HDF_LOGE("%{public}s: get sensorcb fail, groupId[%{public}d]", __func__, groupId);
435 return HDF_FAILURE;
436 }
437 SENSOR_TRACE_START("sensorVdiImpl_->Unregister");
438 int32_t ret = sensorVdiImpl_->Unregister(groupId, sensorCb);
439 SENSOR_TRACE_FINISH;
440 if (ret != SENSOR_SUCCESS) {
441 HDF_LOGE("%{public}s: Unregister failed, error code is %{public}d", __func__, ret);
442 }
443
444 return ret;
445 }
446
RegisterAsync(int32_t groupId,const sptr<V2_1::ISensorCallback> & callbackObj)447 int32_t SensorIfService::RegisterAsync(int32_t groupId, const sptr<V2_1::ISensorCallback> &callbackObj)
448 {
449 SENSOR_TRACE_PID;
450 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
451 HDF_LOGI("%{public}s: groupId %{public}d, service %{public}d", __func__, groupId, serviceId);
452 int32_t ret = Register(groupId, static_cast<sptr<V2_0::ISensorCallback>>(callbackObj));
453
454 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
455 SensorClientsManager::GetInstance()->ReportDataCbOneWay(groupId, serviceId);
456 return ret;
457 }
458
UnregisterAsync(int32_t groupId,const sptr<V2_1::ISensorCallback> & callbackObj)459 int32_t SensorIfService::UnregisterAsync(int32_t groupId, const sptr<V2_1::ISensorCallback> &callbackObj)
460 {
461 SENSOR_TRACE_PID;
462 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
463 HDF_LOGI("%{public}s: groupId %{public}d, service %{public}d", __func__, groupId, serviceId);
464 return Unregister(groupId, static_cast<sptr<V2_0::ISensorCallback>>(callbackObj));
465 }
466
AddCallbackMap(int32_t groupId,const sptr<V2_0::ISensorCallback> & callbackObj)467 int32_t SensorIfService::AddCallbackMap(int32_t groupId, const sptr<V2_0::ISensorCallback> &callbackObj)
468 {
469 SENSOR_TRACE_PID;
470 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
471 HDF_LOGI("%{public}s: service %{public}d", __func__, serviceId);
472 auto groupCallBackIter = callbackMap.find(groupId);
473 if (groupCallBackIter != callbackMap.end()) {
474 auto callBackIter =
475 find_if(callbackMap[groupId].begin(), callbackMap[groupId].end(),
476 [&callbackObj](const sptr<V2_0::ISensorCallback> &callbackRegistered) {
477 const sptr<IRemoteObject> &lhs = OHOS::HDI::hdi_objcast<V2_0::ISensorCallback>(callbackObj);
478 const sptr<IRemoteObject> &rhs = OHOS::HDI::hdi_objcast<V2_0::ISensorCallback>(callbackRegistered);
479 return lhs == rhs;
480 });
481 if (callBackIter == callbackMap[groupId].end()) {
482 int32_t addResult = AddSensorDeathRecipient(callbackObj);
483 if (addResult != SENSOR_SUCCESS) {
484 return HDF_FAILURE;
485 }
486 callbackMap[groupId].push_back(callbackObj);
487 }
488 } else {
489 int32_t addResult = AddSensorDeathRecipient(callbackObj);
490 if (addResult != SENSOR_SUCCESS) {
491 return HDF_FAILURE;
492 }
493 std::vector<sptr<V2_0::ISensorCallback>> remoteVec;
494 remoteVec.push_back(callbackObj);
495 callbackMap[groupId] = remoteVec;
496 }
497 return SENSOR_SUCCESS;
498 }
499
RemoveCallbackMap(int32_t groupId,int serviceId,const sptr<V2_0::ISensorCallback> & callbackObj)500 int32_t SensorIfService::RemoveCallbackMap(int32_t groupId, int serviceId,
501 const sptr<V2_0::ISensorCallback> &callbackObj)
502 {
503 SENSOR_TRACE_PID;
504 HDF_LOGI("%{public}s: service %{public}d", __func__, serviceId);
505 auto groupIdCallBackIter = callbackMap.find(groupId);
506 if (groupIdCallBackIter == callbackMap.end()) {
507 HDF_LOGE("%{public}s: groupId [%{public}d] callbackObj not registered", __func__, groupId);
508 return HDF_FAILURE;
509 }
510 auto callBackIter =
511 find_if(callbackMap[groupId].begin(), callbackMap[groupId].end(),
512 [&callbackObj](const sptr<V2_0::ISensorCallback> &callbackRegistered) {
513 const sptr<IRemoteObject> &lhs = OHOS::HDI::hdi_objcast<V2_0::ISensorCallback>(callbackObj);
514 const sptr<IRemoteObject> &rhs = OHOS::HDI::hdi_objcast<V2_0::ISensorCallback>(callbackRegistered);
515 return lhs == rhs;
516 });
517 if (callBackIter == callbackMap[groupId].end()) {
518 HDF_LOGE("%{public}s: groupId [%{public}d] callbackObj not registered", __func__, groupId);
519 return HDF_FAILURE;
520 }
521 int32_t removeResult = RemoveSensorDeathRecipient(*callBackIter);
522 if (removeResult != SENSOR_SUCCESS) {
523 HDF_LOGE("%{public}s: last callback RemoveSensorDeathRecipient fail, groupId[%{public}d]", __func__, groupId);
524 }
525 if (callbackMap[groupId].size() > CALLBACK_CTOUNT_THRESHOLD) {
526 callbackMap[groupId].erase(callBackIter);
527 } else {
528 callbackMap.erase(groupId);
529 }
530 std::unordered_map<int, std::set<int>> sensorEnabled = SensorClientsManager::GetInstance()->GetSensorUsed();
531 for (auto iter : sensorEnabled) {
532 if (iter.second.find(serviceId) == iter.second.end()) {
533 continue;
534 }
535 if (!SensorClientsManager::GetInstance()->IsUpadateSensorState(iter.first, serviceId, DISABLE_SENSOR)) {
536 continue;
537 }
538 std::unordered_map<int, std::set<int>> sensorUsed = SensorClientsManager::GetInstance()->GetSensorUsed();
539 if (sensorUsed.find(iter.first) == sensorUsed.end()) {
540 SENSOR_TRACE_START("sensorVdiImpl_->Disable");
541 int32_t ret = sensorVdiImpl_->Disable(iter.first);
542 SENSOR_TRACE_FINISH;
543 if (ret != SENSOR_SUCCESS) {
544 HDF_LOGE("%{public}s Disable failed, error code is %{public}d", __func__, ret);
545 }
546 }
547 }
548 return SENSOR_SUCCESS;
549 }
550
AddSensorDeathRecipient(const sptr<V2_0::ISensorCallback> & callbackObj)551 int32_t SensorIfService::AddSensorDeathRecipient(const sptr<V2_0::ISensorCallback> &callbackObj)
552 {
553 SENSOR_TRACE_PID;
554 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
555 HDF_LOGI("%{public}s: service %{public}d", __func__, serviceId);
556 sptr<CallBackDeathRecipient> callBackDeathRecipient = new CallBackDeathRecipient(this);
557 if (callBackDeathRecipient == nullptr) {
558 HDF_LOGE("%{public}s: new CallBackDeathRecipient fail", __func__);
559 return HDF_FAILURE;
560 }
561 const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<V2_0::ISensorCallback>(callbackObj);
562 bool result = remote->AddDeathRecipient(callBackDeathRecipient);
563 if (!result) {
564 HDF_LOGE("%{public}s: AddDeathRecipient fail", __func__);
565 return HDF_FAILURE;
566 }
567 g_callBackDeathRecipientMap[remote.GetRefPtr()] = callBackDeathRecipient;
568 return SENSOR_SUCCESS;
569 }
570
RemoveSensorDeathRecipient(const sptr<V2_0::ISensorCallback> & callbackObj)571 int32_t SensorIfService::RemoveSensorDeathRecipient(const sptr<V2_0::ISensorCallback> &callbackObj)
572 {
573 SENSOR_TRACE_PID;
574 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
575 HDF_LOGI("%{public}s: service %{public}d", __func__, serviceId);
576 const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<V2_0::ISensorCallback>(callbackObj);
577 auto callBackDeathRecipientIter = g_callBackDeathRecipientMap.find(remote.GetRefPtr());
578 if (callBackDeathRecipientIter == g_callBackDeathRecipientMap.end()) {
579 HDF_LOGE("%{public}s: not find recipient", __func__);
580 return HDF_FAILURE;
581 }
582 bool result = remote->RemoveDeathRecipient(callBackDeathRecipientIter->second);
583 g_callBackDeathRecipientMap.erase(callBackDeathRecipientIter);
584 if (!result) {
585 HDF_LOGE("%{public}s: RemoveDeathRecipient fail", __func__);
586 return HDF_FAILURE;
587 }
588 return SENSOR_SUCCESS;
589 }
590
OnRemoteDied(const wptr<IRemoteObject> & object)591 void SensorIfService::OnRemoteDied(const wptr<IRemoteObject> &object)
592 {
593 SENSOR_TRACE_PID;
594 HDF_LOGI("%{public}s: service %{public}d", __func__, static_cast<uint32_t>(HdfRemoteGetCallingPid()));
595 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
596 sptr<IRemoteObject> callbackObject = object.promote();
597 if (callbackObject == nullptr) {
598 return;
599 }
600
601 for (int32_t groupId = TRADITIONAL_SENSOR_TYPE; groupId < SENSOR_GROUP_TYPE_MAX; groupId++) {
602 auto groupIdIter = callbackMap.find(groupId);
603 if (groupIdIter == callbackMap.end()) {
604 continue;
605 }
606 auto callBackIter =
607 find_if(callbackMap[groupId].begin(), callbackMap[groupId].end(),
608 [&callbackObject](const sptr<V2_0::ISensorCallback> &callbackRegistered) {
609 return callbackObject.GetRefPtr() ==
610 (OHOS::HDI::hdi_objcast<V2_0::ISensorCallback>(callbackRegistered)).GetRefPtr();
611 });
612 if (callBackIter != callbackMap[groupId].end()) {
613 int32_t serviceId = SensorClientsManager::GetInstance()->GetServiceId(groupId, *callBackIter);
614 if (sensorVdiImpl_ == nullptr) {
615 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
616 continue;
617 }
618 int32_t ret = RemoveCallbackMap(groupId, serviceId, *callBackIter);
619 if (ret != SENSOR_SUCCESS) {
620 HDF_LOGE("%{public}s: Unregister failed groupId[%{public}d]", __func__, groupId);
621 }
622 if (!SensorClientsManager::GetInstance()->IsClientsEmpty(groupId)) {
623 HDF_LOGD("%{public}s: clients is not empty, do not unregister", __func__);
624 continue;
625 }
626 sptr<SensorCallbackVdi> sensorCb = GetSensorCb(groupId, *callBackIter, UNREGISTER_SENSOR);
627 if (sensorCb == nullptr) {
628 HDF_LOGE("%{public}s: get sensorcb fail, groupId[%{public}d]", __func__, groupId);
629 continue;
630 }
631 SENSOR_TRACE_START("sensorVdiImpl_->Unregister");
632 ret = sensorVdiImpl_->Unregister(groupId, sensorCb);
633 SENSOR_TRACE_FINISH;
634 if (ret != SENSOR_SUCCESS) {
635 HDF_LOGE("%{public}s: Unregister failed, error code is %{public}d", __func__, ret);
636 }
637 }
638 }
639 }
640
RemoveDeathNotice(int32_t sensorType)641 void SensorIfService::RemoveDeathNotice(int32_t sensorType)
642 {
643 SENSOR_TRACE_PID_MSG("sensorType " + std::to_string(sensorType));
644 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
645 HDF_LOGI("%{public}s: service %{public}d, sensorType %{public}d", __func__, serviceId, sensorType);
646 auto iter = callbackMap.find(sensorType);
647 if (iter != callbackMap.end()) {
648 return;
649 }
650 for (auto callback : callbackMap[sensorType]) {
651 const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<V2_0::ISensorCallback>(callback);
652 auto recipientIter = g_callBackDeathRecipientMap.find(remote.GetRefPtr());
653 if (recipientIter != g_callBackDeathRecipientMap.end()) {
654 bool removeResult = remote->RemoveDeathRecipient(recipientIter->second);
655 if (!removeResult) {
656 HDF_LOGE("%{public}s: sensor destroyed, callback RemoveSensorDeathRecipient fail", __func__);
657 }
658 }
659 }
660 }
661
ReadData(int32_t sensorId,std::vector<HdfSensorEvents> & event)662 int32_t SensorIfService::ReadData(int32_t sensorId, std::vector<HdfSensorEvents> &event)
663 {
664 SENSOR_TRACE_PID_MSG("sensorId " + std::to_string(sensorId));
665 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
666 HDF_LOGI("%{public}s: service %{public}d", __func__, serviceId);
667 if (sensorVdiImpl_ == nullptr) {
668 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
669 return HDF_FAILURE;
670 }
671
672 return HDF_SUCCESS;
673 }
674
DisableSensor(int32_t sensorId,uint32_t serviceId)675 int32_t SensorIfService::DisableSensor(int32_t sensorId, uint32_t serviceId)
676 {
677 SENSOR_TRACE_PID_MSG("sensorId " + std::to_string(sensorId));
678 if (!SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, serviceId, DISABLE_SENSOR)) {
679 HDF_LOGD("%{public}s There are still some services enable", __func__);
680 return HDF_SUCCESS;
681 }
682
683 if (sensorVdiImpl_ == nullptr) {
684 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
685 return HDF_FAILURE;
686 }
687
688 int32_t ret = SENSOR_SUCCESS;
689 if (SensorClientsManager::GetInstance()->IsExistSdcSensorEnable(sensorId)) {
690 SENSOR_TRACE_START("sensorVdiImpl_->SetSaBatch");
691 ret = sensorVdiImpl_->SetSaBatch(sensorId, REPORT_INTERVAL, REPORT_INTERVAL);
692 SENSOR_TRACE_FINISH;
693 if (ret != SENSOR_SUCCESS) {
694 HDF_LOGE("%{public}s SetSaBatch failed, error code is %{public}d, sensorId = %{public}d, serviceId = "
695 "%{public}d", __func__, ret, sensorId, serviceId);
696 return ret;
697 }
698 return HDF_SUCCESS;
699 }
700
701 SENSOR_TRACE_START("sensorVdiImpl_->Disable");
702 ret = sensorVdiImpl_->Disable(sensorId);
703 SENSOR_TRACE_FINISH;
704 if (ret != SENSOR_SUCCESS) {
705 HDF_LOGE("%{public}s failed, error code is %{public}d, sensorId = %{public}d, serviceId = %{public}d", __func__,
706 ret, sensorId, serviceId);
707 }
708
709 return ret;
710 }
711
SetSdcSensor(int32_t sensorId,bool enabled,int32_t rateLevel)712 int32_t SensorIfService::SetSdcSensor(int32_t sensorId, bool enabled, int32_t rateLevel)
713 {
714 SENSOR_TRACE_PID_MSG("sensorId " + std::to_string(sensorId) + "enabled " + std::to_string(enabled) + "rateLevel " +
715 std::to_string(rateLevel));
716 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
717 HDF_LOGI("%{public}s: sensorId %{public}d, enabled %{public}u, rateLevel %{public}u, serviceId %{public}d",
718 __func__, sensorId, enabled, rateLevel, serviceId);
719 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
720 if (sensorVdiImpl_ == nullptr) {
721 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
722 return HDF_FAILURE;
723 }
724 int32_t ret = SENSOR_SUCCESS;
725 if (rateLevel < REPORT_INTERVAL) {
726 HDF_LOGE("%{public}s: rateLevel cannot less than zero", __func__);
727 return HDF_FAILURE;
728 }
729 int64_t samplingInterval = rateLevel == REPORT_INTERVAL ? REPORT_INTERVAL : COMMON_REPORT_FREQUENCY / rateLevel;
730 int64_t reportInterval = REPORT_INTERVAL;
731 if (enabled) {
732 ret = SetBatchSenior(serviceId, sensorId, SDC, samplingInterval, reportInterval);
733 if (ret != SENSOR_SUCCESS) {
734 HDF_LOGE("%{public}s SetBatchSenior SDC failed, error code is %{public}d", __func__, ret);
735 return ret;
736 }
737 SENSOR_TRACE_START("sensorVdiImpl_->Enable");
738 ret = sensorVdiImpl_->Enable(sensorId);
739 SENSOR_TRACE_FINISH;
740 if (ret != SENSOR_SUCCESS) {
741 HDF_LOGE("%{public}s Enable failed, error code is %{public}d", __func__, ret);
742 return ret;
743 }
744 } else {
745 SensorClientsManager::GetInstance()->EraseSdcSensorBestConfig(sensorId);
746 ret = DisableSensor(sensorId, serviceId);
747 if (ret != SENSOR_SUCCESS) {
748 HDF_LOGE("%{public}s Disable failed, error code is %{public}d", __func__, ret);
749 return ret;
750 }
751 SensorClientsManager::GetInstance()->GetSensorBestConfig(sensorId, samplingInterval, reportInterval);
752 SENSOR_TRACE_START("sensorVdiImpl_->SetSaBatch");
753 ret = sensorVdiImpl_->SetSaBatch(sensorId, samplingInterval, samplingInterval);
754 SENSOR_TRACE_FINISH;
755 if (ret != SENSOR_SUCCESS) {
756 HDF_LOGE("%{public}s SetSaBatch failed, error code is %{public}d", __func__, ret);
757 return ret;
758 }
759 }
760 return ret;
761 }
762
GetSdcSensorInfo(std::vector<SdcSensorInfo> & sdcSensorInfo)763 int32_t SensorIfService::GetSdcSensorInfo(std::vector<SdcSensorInfo>& sdcSensorInfo)
764 {
765 SENSOR_TRACE_PID;
766 uint32_t serviceId = static_cast<uint32_t>(HdfRemoteGetCallingPid());
767 HDF_LOGI("%{public}s: serviceId %{public}d", __func__, serviceId);
768 std::unique_lock<std::mutex> lock(sensorServiceMutex_);
769 if (sensorVdiImpl_ == nullptr) {
770 HDF_LOGE("%{public}s: get sensor vdi impl failed", __func__);
771 return HDF_FAILURE;
772 }
773
774 std::vector<OHOS::HDI::Sensor::V1_1::SdcSensorInfoVdi> sdcSensorInfoVdi;
775 SENSOR_TRACE_START("sensorVdiImpl_->GetSdcSensorInfo");
776 int32_t ret = sensorVdiImpl_->GetSdcSensorInfo(sdcSensorInfoVdi);
777 SENSOR_TRACE_FINISH;
778 if (ret != SENSOR_SUCCESS) {
779 HDF_LOGE("%{public}s GetSdcSensorInfo failed, error code is %{public}d", __func__, ret);
780 }
781
782 for (auto infoVdi : sdcSensorInfoVdi) {
783 SdcSensorInfo info;
784 info.offset = infoVdi.offset;
785 info.sensorId = infoVdi.sensorId;
786 info.ddrSize = infoVdi.ddrSize;
787 info.minRateLevel = infoVdi.minRateLevel;
788 info.maxRateLevel = infoVdi.maxRateLevel;
789 info.memAddr = infoVdi.memAddr;
790 info.reserved = infoVdi.reserved;
791 sdcSensorInfo.push_back(std::move(info));
792 }
793
794 return ret;
795 }
796
SensorInterfaceImplGetInstance(void)797 extern "C" ISensorInterface *SensorInterfaceImplGetInstance(void)
798 {
799 SensorIfService *impl = new (std::nothrow) SensorIfService();
800 if (impl == nullptr) {
801 return nullptr;
802 }
803
804 int32_t ret = impl->Init();
805 if (ret != HDF_SUCCESS) {
806 HDF_LOGE("%{public}s: service init failed, error code is %{public}d", __func__, ret);
807 delete impl;
808 return nullptr;
809 }
810
811 return impl;
812 }
813 } // namespace V2_1
814 } // namespace Sensor
815 } // namespace HDI
816 } // namespace OHOS