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