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)99 InnerFunctionTracer(const char *func) 100 : func_ { func } 101 { 102 HILOG_DEBUG(LOG_CORE, "in %{public}s, enter", func_); 103 } ~InnerFunctionTracer()104 ~InnerFunctionTracer() 105 { 106 HILOG_DEBUG(LOG_CORE, "in %{public}s, leave", func_); 107 } 108 private: 109 const char *func_ { nullptr }; 110 }; 111 112 #define CALL_LOG_ENTER InnerFunctionTracer ___innerFuncTracer___ { __FUNCTION__ } 113 114 #ifdef DEBUG_CODE_TEST 115 #define CHKPL(cond, ...) \ 116 do { \ 117 if ((cond) == nullptr) { \ 118 MISC_HILOGW("%{public}s, (%{public}d), CHKPL(%{public}s) is null, do nothing", \ 119 __FILE__, __LINE__, #cond); \ 120 } \ 121 } while (0) 122 123 #define CHKPV(cond) \ 124 do { \ 125 if ((cond) == nullptr) { \ 126 MISC_HILOGE("%{public}s, (%{public}d), CHKPV(%{public}s) is null", \ 127 __FILE__, __LINE__, #cond); \ 128 return; \ 129 } \ 130 } while (0) 131 132 #define CHKPF(cond) \ 133 do { \ 134 if ((cond) == nullptr) { \ 135 MISC_HILOGE("%{public}s, (%{public}d), CHKPF(%{public}s) is null", \ 136 __FILE__, __LINE__, #cond); \ 137 return false; \ 138 } \ 139 } while (0) 140 141 #define CHKPC(cond) \ 142 { \ 143 if ((cond) == nullptr) { \ 144 MISC_HILOGW("%{public}s, (%{public}d), CHKPC(%{public}s) is null, skip then continue", \ 145 __FILE__, __LINE__, #cond); \ 146 continue; \ 147 } \ 148 } 149 150 #define CHKPB(cond) \ 151 { \ 152 if ((cond) == nullptr) { \ 153 MISC_HILOGW("%{public}s, (%{public}d), CHKPC(%{public}s) is null, skip then break", \ 154 __FILE__, __LINE__, #cond); \ 155 break; \ 156 } \ 157 } 158 159 #define CHKPR(cond, r) \ 160 do { \ 161 if ((cond) == nullptr) { \ 162 MISC_HILOGE("%{public}s, (%{public}d), CHKPR(%{public}s) is null, return value is %{public}d", \ 163 __FILE__, __LINE__, #cond, r); \ 164 return r; \ 165 } \ 166 } while (0) 167 168 #define CHKPP(cond) \ 169 do { \ 170 if ((cond) == nullptr) { \ 171 MISC_HILOGE("%{public}s, (%{public}d), CHKPP(%{public}s) is null, return value is null", \ 172 __FILE__, __LINE__, #cond); \ 173 return nullptr; \ 174 } \ 175 } while (0) 176 177 #define CK(cond, ec) \ 178 do { \ 179 if (!(cond)) { \ 180 MISC_HILOGE("%{public}s, (%{public}d), CK(%{public}s), errCode:%{public}d", \ 181 __FILE__, __LINE__, #cond, ec); \ 182 } \ 183 } while (0) 184 185 #else // DEBUG_CODE_TEST 186 #define CHKPL(cond) \ 187 do { \ 188 if ((cond) == nullptr) { \ 189 MISC_HILOGW("CHKPL(%{public}s) is null, do nothing", #cond); \ 190 } \ 191 } while (0) 192 193 #define CHKPV(cond) \ 194 do { \ 195 if ((cond) == nullptr) { \ 196 MISC_HILOGE("CHKPV(%{public}s) is null", #cond); \ 197 return; \ 198 } \ 199 } while (0) 200 201 #define CHKPF(cond) \ 202 do { \ 203 if ((cond) == nullptr) { \ 204 MISC_HILOGE("CHKPF(%{public}s) is null", #cond); \ 205 return false; \ 206 } \ 207 } while (0) 208 209 #define CHKPC(cond) \ 210 { \ 211 if ((cond) == nullptr) { \ 212 MISC_HILOGW("CHKPC(%{public}s) is null, skip then continue", #cond); \ 213 continue; \ 214 } \ 215 } 216 217 #define CHKPB(cond) \ 218 { \ 219 if ((cond) == nullptr) { \ 220 MISC_HILOGW("CHKPC(%{public}s) is null, skip then break", #cond); \ 221 break; \ 222 } \ 223 } 224 225 #define CHKPR(cond, r) \ 226 do { \ 227 if ((cond) == nullptr) { \ 228 MISC_HILOGE("CHKPR(%{public}s) is null, return value is %{public}d", #cond, r); \ 229 return r; \ 230 } \ 231 } while (0) 232 233 #define CHKPS(cond) \ 234 do { \ 235 if ((cond) == nullptr) { \ 236 MISC_HILOGW("CHKPS(%{public}s) is null, skip then break", #cond); \ 237 return ""; \ 238 } \ 239 } while (0) 240 241 #define CHKPP(cond) \ 242 do { \ 243 if ((cond) == nullptr) { \ 244 MISC_HILOGE("CHKPP(%{public}s) is null, return value is null", #cond); \ 245 return nullptr; \ 246 } \ 247 } while (0) 248 249 #define CK(cond, ec) \ 250 do { \ 251 if (!(cond)) { \ 252 MISC_HILOGE("CK(%{public}s), errCode:%{public}d", #cond, ec); \ 253 } \ 254 } while (0) 255 256 #define CHKCR(cond, r, errDesc) \ 257 do { \ 258 if (!(cond)) { \ 259 MISC_HILOGE("%{public}s, errCode:%{public}d", #errDesc, r); \ 260 return r; \ 261 } \ 262 } while (0) 263 264 #define CHKCP(cond, errDesc) \ 265 do { \ 266 if (!(cond)) { \ 267 MISC_HILOGE("%{public}s", #errDesc); \ 268 return nullptr; \ 269 } \ 270 } while (0) 271 272 #define CHKCF(cond, errDesc) \ 273 do { \ 274 if (!(cond)) { \ 275 MISC_HILOGE("%{public}s", #errDesc); \ 276 return false; \ 277 } \ 278 } while (0) 279 280 #define CHKCV(cond, errDesc) \ 281 do { \ 282 if (!(cond)) { \ 283 MISC_HILOGE("%{public}s", #errDesc); \ 284 return; \ 285 } \ 286 } while (0) 287 #endif 288 } // namespace Sensors 289 } // namespace OHOS 290 #endif // SENSORS_ERRORS_H 291