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