1 /*
2 * Copyright (c) 2021 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_manager.h"
17 #include <fcntl.h>
18 #include "hdf_dlist.h"
19 #include "hdf_io_service_if.h"
20 #include "osal_mem.h"
21 #include "sensor_channel.h"
22 #include "sensor_common.h"
23 #include "sensor_controller.h"
24 #include "sensor_if.h"
25
26 #define HDF_LOG_TAG hdf_sensor_dal
27
GetSensorDevManager(void)28 struct SensorDevManager *GetSensorDevManager(void)
29 {
30 static struct SensorDevManager devManager = {
31 .initState = false,
32 .hasSensorListener = false,
33 .sensorSum = 0,
34 .sensorInfoEntry = NULL,
35 .serviceGroup = NULL,
36 };
37
38 return &devManager;
39 }
40
GetSensorServiceList(void)41 static int32_t GetSensorServiceList(void)
42 {
43 struct SensorManagerNode *managerNode = NULL;
44 struct SensorDevManager *manager = GetSensorDevManager();
45 struct HdfSBuf *data = HdfSbufObtainDefaultSize();
46 const char *svcName = NULL;
47
48 CHECK_NULL_PTR_RETURN_VALUE(data, SENSOR_NULL_PTR);
49 int32_t ret = HdfGetServiceNameByDeviceClass(DEVICE_CLASS_SENSOR, data);
50 if (ret != SENSOR_SUCCESS) {
51 HDF_LOGE("%{public}s :sensor manager get service class failed", __func__);
52 HdfSbufRecycle(data);
53 return SENSOR_INVALID_SERVICE;
54 }
55
56 (void)OsalMutexLock(&manager->mutex);
57 while (true) {
58 svcName = HdfSbufReadString(data);
59 if (svcName == NULL) {
60 break;
61 }
62
63 managerNode = (struct SensorManagerNode*)OsalMemCalloc(sizeof(*managerNode));
64 if (managerNode == NULL) {
65 break;
66 }
67
68 managerNode->sensorCount = 0;
69 managerNode->ioService = HdfIoServiceBind(svcName);
70 if (managerNode->ioService == NULL) {
71 HDF_LOGE("%{public}s: Sensor manager get manager service name[%{public}s] failed", __func__, svcName);
72 OsalMemFree(managerNode);
73 managerNode = NULL;
74 continue;
75 }
76
77 DListInsertTail(&managerNode->node, &manager->managerHead);
78 }
79 (void)OsalMutexUnlock(&manager->mutex);
80
81 HdfSbufRecycle(data);
82 data = NULL;
83
84 if (DListIsEmpty(&manager->managerHead)) {
85 HDF_LOGE("%{public}s: Sensor get service failed", __func__);
86 return SENSOR_INVALID_SERVICE;
87 }
88
89 return SENSOR_SUCCESS;
90 }
91
ReleaseSensorServiceList()92 static void ReleaseSensorServiceList()
93 {
94 struct SensorManagerNode *pos = NULL;
95 struct SensorManagerNode *tmp = NULL;
96 struct SensorDevManager *manager = GetSensorDevManager();
97
98 HDF_LOGI("%{public}s: Sensor host release service group", __func__);
99 (void)OsalMutexLock(&manager->mutex);
100 DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->managerHead, struct SensorManagerNode, node) {
101 if (pos->ioService != NULL) {
102 HdfIoServiceRecycle(pos->ioService);
103 pos->ioService = NULL;
104 };
105
106 DListRemove(&(pos->node));
107 OsalMemFree(pos);
108 pos = NULL;
109 }
110
111 (void)OsalMutexLock(&manager->eventMutex);
112 if (manager->serviceGroup != NULL) {
113 if (manager->hasSensorListener) {
114 struct HdfDevEventlistener *listener = GetSensorListener();
115 if (listener != NULL) {
116 HdfIoServiceGroupUnregisterListener(manager->serviceGroup, listener);
117 manager->hasSensorListener = false;
118 }
119 }
120 HdfIoServiceGroupRecycle(manager->serviceGroup);
121 manager->serviceGroup = NULL;
122 }
123 (void)OsalMutexUnlock(&manager->eventMutex);
124 (void)OsalMutexUnlock(&manager->mutex);
125 }
126
InitSensorManager(void)127 static int32_t InitSensorManager(void)
128 {
129 struct SensorDevManager *manager = GetSensorDevManager();
130 manager->recordDataCb[TRADITIONAL_SENSOR_TYPE] = NULL;
131 manager->recordDataCb[MEDICAL_SENSOR_TYPE] = NULL;
132 DListHeadInit(&manager->managerHead);
133 DListHeadInit(&manager->sensorIdListHead);
134 OsalMutexInit(&manager->mutex);
135 OsalMutexInit(&manager->eventMutex);
136
137 int32_t ret = GetSensorServiceList();
138 if (ret != SENSOR_SUCCESS) {
139 HDF_LOGE("%{public}s: Sensor get service failed", __func__);
140 ReleaseSensorServiceList();
141 OsalMutexDestroy(&manager->mutex);
142 OsalMutexDestroy(&manager->eventMutex);
143 return SENSOR_INVALID_SERVICE;
144 }
145
146 return SENSOR_SUCCESS;
147 }
148
NewSensorInterfaceInstance(void)149 const struct SensorInterface *NewSensorInterfaceInstance(void)
150 {
151 static struct SensorInterface sensorDevInstance;
152 struct SensorDevManager *manager = GetSensorDevManager();
153
154 if (manager->initState) {
155 return &sensorDevInstance;
156 }
157
158 // Construct device interface instance
159 GetSensorDeviceMethods(&sensorDevInstance);
160
161 if (InitSensorManager() != SENSOR_SUCCESS) {
162 HDF_LOGE("%{public}s: Sensor init manager failed", __func__);
163 return NULL;
164 }
165 manager->initState = true;
166 HDF_LOGD("%{public}s: Get sensor device instance success", __func__);
167 return &sensorDevInstance;
168 }
169
FreeSensorInterfaceInstance(void)170 int32_t FreeSensorInterfaceInstance(void)
171 {
172 struct SensorDevManager *manager = GetSensorDevManager();
173
174 if (!manager->initState) {
175 return SENSOR_SUCCESS;
176 }
177
178 ReleaseAllSensorInfo();
179 ReleaseSensorServiceList();
180 manager->recordDataCb[TRADITIONAL_SENSOR_TYPE] = NULL;
181 manager->recordDataCb[MEDICAL_SENSOR_TYPE] = NULL;
182
183 OsalMutexDestroy(&manager->mutex);
184 OsalMutexDestroy(&manager->eventMutex);
185
186 manager->initState = false;
187
188 return SENSOR_SUCCESS;
189 }
190