1 /*
2  * Copyright (c) 2021-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 #ifndef SENSORS_ERRORS_H
17 #define SENSORS_ERRORS_H
18 
19 #include <errors.h>
20 
21 #include "hilog/log.h"
22 
23 #include "miscdevice_log.h"
24 
25 namespace OHOS {
26 namespace Sensors {
27 // Error code for user
28 enum ErrorCode : int32_t {
29     PERMISSION_DENIED = 201, // Use this error code when permission is denied.
30     PARAMETER_ERROR = 401, // Use this error code when the input parameter type or range does not match.
31     IS_NOT_SUPPORTED = 801, // Use this error code when capability not supported.
32     DEVICE_OPERATION_FAILED = 14600101, // Use this error code when operating the device fail.
33 };
34 
35 enum {
36     MODULE_COMMON = 0x00,
37     MODULE_MISCDEVICE_DEVICE = 0x01,
38     MODULE_MISCDEVICE_UTILS = 0x02,
39     MODULE_MISCDEVICE_SERVICE = 0x03,
40     MODULE_MISCDEVICE_NATIVE = 0X04,
41 };
42 
43 // Error code for common
44 constexpr ErrCode COMMON_ERR_OFFSET = ErrCodeOffset(SUBSYS_SENSORS, MODULE_COMMON);
45 
46 enum {
47     ERROR = -1,
48     SUCCESS = 0,
49     COMMON_ERR = COMMON_ERR_OFFSET,
50 };
51 
52 // Error code for adapter
53 constexpr ErrCode DEVICE_ERR_OFFSET = ErrCodeOffset(SUBSYS_SENSORS, MODULE_MISCDEVICE_DEVICE);
54 
55 enum {
56     DEVICE_ERR = DEVICE_ERR_OFFSET,
57     DEVICE_ENABLE_SENSOR_ERR = DEVICE_ERR_OFFSET + 1,
58     DEVICE_DISABLE_SENSOR_ERR = DEVICE_ENABLE_SENSOR_ERR + 1,
59     DEVICE_RUN_COMMAND_ERR = DEVICE_DISABLE_SENSOR_ERR + 1,
60     DEVICE_SET_SENSOR_CONFIG_ERR = DEVICE_RUN_COMMAND_ERR + 1,
61     DEVICE_NOT_SUPPORT_CMD_ERR = DEVICE_SET_SENSOR_CONFIG_ERR + 1,
62 };
63 
64 // Error code for miscdevice service
65 constexpr ErrCode MISCDEVICE_SERVICE_ERR_OFFSET = ErrCodeOffset(SUBSYS_SENSORS, MODULE_MISCDEVICE_SERVICE);
66 
67 enum {
68     LIGHT_HDF_CONNECT_ERR = MISCDEVICE_SERVICE_ERR_OFFSET,
69     LIGHT_ID_NOT_SUPPORT = LIGHT_HDF_CONNECT_ERR + 1,
70     LIGHT_ERR = LIGHT_ID_NOT_SUPPORT + 1,
71     LIGHT_PLAY_EFFECT_ERROR = LIGHT_ERR + 1,
72     LIGHT_STOP_EFFECT_ERROR = LIGHT_PLAY_EFFECT_ERROR + 1,
73     LIGHT_END_ERROR = LIGHT_STOP_EFFECT_ERROR,
74     VIBRATOR_HDF_CONNECT_ERR = LIGHT_END_ERROR + 1,
75     VIBRATOR_ON_ERR = VIBRATOR_HDF_CONNECT_ERR + 1,
76     VIBRATOR_OFF_ERR = VIBRATOR_ON_ERR + 1,
77     VIBRATOR_PLAY_EFFECT_ERR = VIBRATOR_OFF_ERR + 1,
78     VIBRATOR_STOP_EFFECT_ERR = VIBRATOR_PLAY_EFFECT_ERR + 1,
79     VIBRATOR_SET_PARA_ERR = VIBRATOR_STOP_EFFECT_ERR + 1,
80     DUMP_PARAM_ERR = VIBRATOR_SET_PARA_ERR + 1,
81     WRITE_MSG_ERR = DUMP_PARAM_ERR + 1,
82     READ_MSG_ERR = WRITE_MSG_ERR + 1,
83 };
84 
85 // Error code for Sensor native
86 constexpr ErrCode MISCDEVICE_NATIVE_ERR_OFFSET = ErrCodeOffset(SUBSYS_SENSORS, MODULE_MISCDEVICE_NATIVE);
87 
88 enum {
89     MISCDEVICE_NATIVE_SAM_ERR = MISCDEVICE_NATIVE_ERR_OFFSET,
90     MISC_NATIVE_GET_SERVICE_ERR = MISCDEVICE_NATIVE_SAM_ERR + 1,
91     MISC_NATIVE_SAM_ERR = MISC_NATIVE_GET_SERVICE_ERR + 1,
92     MISC_NO_INIT_ERR = MISC_NATIVE_SAM_ERR + 1,
93     MISC_INVALID_OPERATION_ERR = MISC_NO_INIT_ERR + 1,
94     MISC_NAME_NOT_FOUND_ERR = MISC_INVALID_OPERATION_ERR + 1,
95 };
96 
97 class InnerFunctionTracer {
98 public:
InnerFunctionTracer(const char * func,const char * tag)99     InnerFunctionTracer(const char *func, const char *tag)
100         : func_ { func }, tag_ { tag }
101     {
102         if (HiLogIsLoggable(LOG_DOMAIN, tag_, LOG_DEBUG)) {
103             if (func_ != nullptr && tag_ != nullptr) {
104                 HILOG_IMPL(LOG_CORE, LOG_DEBUG, LOG_DOMAIN, tag_, "in %{public}s, enter", func_);
105             }
106         }
107     }
~InnerFunctionTracer()108     ~InnerFunctionTracer()
109     {
110         if (HiLogIsLoggable(LOG_DOMAIN, tag_, LOG_DEBUG)) {
111             if (func_ != nullptr && tag_ != nullptr) {
112                 HILOG_IMPL(LOG_CORE, LOG_DEBUG, LOG_DOMAIN, tag_, "in %{public}s, leave", func_);
113             }
114         }
115     }
116 private:
117     const char *func_ { nullptr };
118     const char *tag_ { nullptr };
119 };
120 
121 #define CALL_LOG_ENTER   InnerFunctionTracer ___innerFuncTracer___ { __FUNCTION__, LOG_TAG }
122 
123 #ifdef DEBUG_CODE_TEST
124 #define CHKPL(cond, ...) \
125     do { \
126         if ((cond) == nullptr) { \
127             MISC_HILOGW("%{public}s, (%{public}d), CHKPL(%{public}s) is null, do nothing", \
128                 __FILE__, __LINE__, #cond); \
129         } \
130     } while (0)
131 
132 #define CHKPV(cond) \
133     do { \
134         if ((cond) == nullptr) { \
135             MISC_HILOGE("%{public}s, (%{public}d), CHKPV(%{public}s) is null", \
136                 __FILE__, __LINE__, #cond); \
137             return; \
138         } \
139     } while (0)
140 
141 #define CHKPF(cond) \
142     do { \
143         if ((cond) == nullptr) { \
144             MISC_HILOGE("%{public}s, (%{public}d), CHKPF(%{public}s) is null", \
145                 __FILE__, __LINE__, #cond); \
146             return false; \
147         } \
148     } while (0)
149 
150 #define CHKPC(cond) \
151     { \
152         if ((cond) == nullptr) { \
153             MISC_HILOGW("%{public}s, (%{public}d), CHKPC(%{public}s) is null, skip then continue", \
154                 __FILE__, __LINE__, #cond); \
155             continue; \
156         } \
157     }
158 
159 #define CHKPB(cond) \
160     { \
161         if ((cond) == nullptr) { \
162             MISC_HILOGW("%{public}s, (%{public}d), CHKPC(%{public}s) is null, skip then break", \
163                 __FILE__, __LINE__, #cond); \
164             break; \
165         } \
166     }
167 
168 #define CHKPR(cond, r) \
169     do { \
170         if ((cond) == nullptr) { \
171             MISC_HILOGE("%{public}s, (%{public}d), CHKPR(%{public}s) is null, return value is %{public}d", \
172                 __FILE__, __LINE__, #cond, r); \
173             return r; \
174         } \
175     } while (0)
176 
177 #define CHKPP(cond) \
178     do { \
179         if ((cond) == nullptr) { \
180             MISC_HILOGE("%{public}s, (%{public}d), CHKPP(%{public}s) is null, return value is null", \
181                 __FILE__, __LINE__, #cond); \
182             return nullptr; \
183         } \
184     } while (0)
185 
186 #define CK(cond, ec) \
187     do { \
188         if (!(cond)) { \
189             MISC_HILOGE("%{public}s, (%{public}d), CK(%{public}s), errCode:%{public}d", \
190                 __FILE__, __LINE__, #cond, ec); \
191         } \
192     } while (0)
193 
194 #else // DEBUG_CODE_TEST
195 #define CHKPL(cond) \
196     do { \
197         if ((cond) == nullptr) { \
198             MISC_HILOGW("CHKPL(%{public}s) is null, do nothing", #cond); \
199         } \
200     } while (0)
201 
202 #define CHKPV(cond) \
203     do { \
204         if ((cond) == nullptr) { \
205             MISC_HILOGE("CHKPV(%{public}s) is null", #cond); \
206             return; \
207         } \
208     } while (0)
209 
210 #define CHKPF(cond) \
211     do { \
212         if ((cond) == nullptr) { \
213             MISC_HILOGE("CHKPF(%{public}s) is null", #cond); \
214             return false; \
215         } \
216     } while (0)
217 
218 #define CHKPC(cond) \
219     { \
220         if ((cond) == nullptr) { \
221             MISC_HILOGW("CHKPC(%{public}s) is null, skip then continue", #cond); \
222             continue; \
223         } \
224     }
225 
226 #define CHKPB(cond) \
227     { \
228         if ((cond) == nullptr) { \
229             MISC_HILOGW("CHKPC(%{public}s) is null, skip then break", #cond); \
230             break; \
231         } \
232     }
233 
234 #define CHKPR(cond, r) \
235     do { \
236         if ((cond) == nullptr) { \
237             MISC_HILOGE("CHKPR(%{public}s) is null, return value is %{public}d", #cond, r); \
238             return r; \
239         } \
240     } while (0)
241 
242 #define CHKPS(cond) \
243     do { \
244         if ((cond) == nullptr) { \
245             MISC_HILOGW("CHKPS(%{public}s) is null, skip then break", #cond); \
246             return ""; \
247         } \
248     } while (0)
249 
250 #define CHKPP(cond) \
251     do { \
252         if ((cond) == nullptr) { \
253             MISC_HILOGE("CHKPP(%{public}s) is null, return value is null", #cond); \
254             return nullptr; \
255         } \
256     } while (0)
257 
258 #define CK(cond, ec) \
259     do { \
260         if (!(cond)) { \
261             MISC_HILOGE("CK(%{public}s), errCode:%{public}d", #cond, ec); \
262         } \
263     } while (0)
264 
265 #define CHKCR(cond, r, errDesc) \
266     do { \
267         if (!(cond)) { \
268             MISC_HILOGE("%{public}s, errCode:%{public}d", #errDesc, r); \
269             return r; \
270         } \
271     } while (0)
272 
273 #define CHKCP(cond, errDesc) \
274     do { \
275         if (!(cond)) { \
276             MISC_HILOGE("%{public}s", #errDesc); \
277             return nullptr; \
278         } \
279     } while (0)
280 
281 #define CHKCF(cond, errDesc) \
282     do { \
283         if (!(cond)) { \
284             MISC_HILOGE("%{public}s", #errDesc); \
285             return false; \
286         } \
287     } while (0)
288 
289 #define CHKCV(cond, errDesc) \
290     do { \
291         if (!(cond)) { \
292             MISC_HILOGE("%{public}s", #errDesc); \
293             return; \
294         } \
295     } while (0)
296 #endif
297 }  // namespace Sensors
298 }  // namespace OHOS
299 #endif  // SENSORS_ERRORS_H
300