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 #ifndef SENSORS_ERRORS_H 17 #define SENSORS_ERRORS_H 18 19 #include <errors.h> 20 #include <sensor_log.h> 21 22 #include "hilog/log.h" 23 24 namespace OHOS { 25 namespace Sensors { 26 enum { 27 MODULE_COMMON = 0x00, 28 MODULE_SENSORS_DEVICE = 0x01, 29 MODULE_SENSOR_SERVICE = 0x02, 30 MODULE_SENSORS_UTILS = 0x03, 31 MODULE_SENSORS_NATIVE = 0X04, 32 }; 33 34 // Error code for common 35 constexpr ErrCode COMMON_ERR_OFFSET = ErrCodeOffset(SUBSYS_SENSORS, MODULE_COMMON); 36 37 enum { 38 ERROR = -1, 39 SUCCESS = 0, 40 COMMON_ERR = COMMON_ERR_OFFSET, 41 }; 42 43 // Error code for device 44 constexpr ErrCode DEVICE_ERR_OFFSET = ErrCodeOffset(SUBSYS_SENSORS, MODULE_SENSORS_DEVICE); 45 46 enum { 47 DEVICE_ERR = DEVICE_ERR_OFFSET, 48 DEVICE_ENABLE_SENSOR_ERR = DEVICE_ERR_OFFSET + 1, 49 DEVICE_DISABLE_SENSOR_ERR = DEVICE_ENABLE_SENSOR_ERR + 1, 50 DEVICE_RUN_COMMAND_ERR = DEVICE_DISABLE_SENSOR_ERR + 1, 51 DEVICE_SET_SENSOR_CONFIG_ERR = DEVICE_RUN_COMMAND_ERR + 1, 52 DEVICE_NOT_SUPPORT_CMD_ERR = DEVICE_SET_SENSOR_CONFIG_ERR + 1, 53 }; 54 55 // Error code for sensor service 56 constexpr ErrCode SENSOR_SERVICE_ERR_OFFSET = ErrCodeOffset(SUBSYS_SENSORS, MODULE_SENSOR_SERVICE); 57 58 enum { 59 SENSOR_SERVICE_ERR = SENSOR_SERVICE_ERR_OFFSET, 60 CMD_TYPE_ERR = SENSOR_SERVICE_ERR + 1, 61 SENSOR_DEVICE_INIT_ERR = CMD_TYPE_ERR + 1, 62 CONNECT_SENSOR_HDF_ERR = SENSOR_DEVICE_INIT_ERR + 1, 63 SET_SENSOR_CONFIG_ERR = CONNECT_SENSOR_HDF_ERR + 1, 64 ENABLE_SENSOR_ERR = SET_SENSOR_CONFIG_ERR + 1, 65 DISABLE_SENSOR_ERR = ENABLE_SENSOR_ERR + 1, 66 RUN_COMMAND_ERR = DISABLE_SENSOR_ERR + 1, 67 GET_SENSOR_LIST_ERR = RUN_COMMAND_ERR + 1, 68 SENSOR_ENABLED_ERR = GET_SENSOR_LIST_ERR + 1, 69 UPDATE_SENSOR_CHANNEL_ERR = SENSOR_ENABLED_ERR + 1, 70 CLEAR_SENSOR_CHANNEL_ERR = UPDATE_SENSOR_CHANNEL_ERR + 1, 71 CLEAR_SENSOR_INFO_ERR = CLEAR_SENSOR_CHANNEL_ERR + 1, 72 UPDATE_SENSOR_INFO_ERR = CLEAR_SENSOR_INFO_ERR + 1, 73 CLIENT_PID_INVALID_ERR = UPDATE_SENSOR_INFO_ERR + 1, 74 DESTROY_SENSOR_CHANNEL_ERR = CLIENT_PID_INVALID_ERR + 1, 75 UPDATE_UID_ERR = DESTROY_SENSOR_CHANNEL_ERR + 1, 76 INVALID_POINTER = UPDATE_UID_ERR + 1, 77 NO_EVENT = INVALID_POINTER + 1, 78 COPY_ERR = NO_EVENT + 1, 79 REGIST_PERMISSION_CHANGED_ERR = COPY_ERR + 1, 80 DUMP_PARAM_ERR = REGIST_PERMISSION_CHANGED_ERR + 1, 81 WRITE_MSG_ERR = DUMP_PARAM_ERR + 1, 82 SET_SENSOR_MODE_ERR = WRITE_MSG_ERR + 1, 83 SET_SENSOR_OPTION_ERR = SET_SENSOR_MODE_ERR + 1, 84 REGIST_CALLBACK_ERR = SET_SENSOR_OPTION_ERR + 1, 85 }; 86 87 // Error code for Sensor uitls 88 constexpr ErrCode SENSOR_UTILS_ERR_OFFSET = ErrCodeOffset(SUBSYS_SENSORS, MODULE_SENSORS_UTILS); 89 enum { 90 SENSOR_CHANNEL_SOCKET_CREATE_ERR = SENSOR_UTILS_ERR_OFFSET, 91 SENSOR_CHANNEL_SENDFD_ERR = SENSOR_CHANNEL_SOCKET_CREATE_ERR + 1, 92 SENSOR_CHANNEL_WRITE_DESCRIPTOR_ERR = SENSOR_CHANNEL_SENDFD_ERR + 1, 93 SENSOR_CHANNEL_DUP_ERR = SENSOR_CHANNEL_WRITE_DESCRIPTOR_ERR + 1, 94 SENSOR_CHANNEL_BASIC_CHANNEL_NOT_INIT = SENSOR_CHANNEL_DUP_ERR + 1, 95 SENSOR_CHANNEL_SEND_ADDR_ERR = SENSOR_CHANNEL_BASIC_CHANNEL_NOT_INIT + 1, 96 SENSOR_CHANNEL_SEND_DATA_ERR = SENSOR_CHANNEL_SEND_ADDR_ERR + 1, 97 SENSOR_CHANNEL_RECEIVE_DATA_ERR = SENSOR_CHANNEL_SEND_DATA_ERR + 1, 98 SENSOR_CHANNEL_RECEIVE_ADDR_ERR = SENSOR_CHANNEL_RECEIVE_DATA_ERR + 1, 99 SENSOR_CHANNEL_RESTORE_CB_ERR = SENSOR_CHANNEL_RECEIVE_ADDR_ERR + 1, 100 SENSOR_CHANNEL_RESTORE_FD_ERR = SENSOR_CHANNEL_RESTORE_CB_ERR + 1, 101 SENSOR_CHANNEL_RESTORE_THREAD_ERR = SENSOR_CHANNEL_RESTORE_FD_ERR + 1, 102 }; 103 // Error code for Sensor native 104 constexpr ErrCode SENSOR_NATIVE_ERR_OFFSET = ErrCodeOffset(SUBSYS_SENSORS, MODULE_SENSORS_NATIVE); 105 106 enum { 107 SENSOR_NATIVE_SAM_ERR = SENSOR_NATIVE_ERR_OFFSET, 108 SENSOR_NATIVE_GET_SERVICE_ERR = SENSOR_NATIVE_SAM_ERR + 1, 109 SENSOR_NATIVE_REGSITER_CB_ERR = SENSOR_NATIVE_GET_SERVICE_ERR + 1, 110 }; 111 112 class InnerFunctionTracer { 113 public: InnerFunctionTracer(const OHOS::HiviewDFX::HiLogLabel & label,const char * func)114 InnerFunctionTracer(const OHOS::HiviewDFX::HiLogLabel& label, const char *func) 115 : label_ { label }, func_ { func } 116 { 117 OHOS::HiviewDFX::HiLog::Debug(label_, "in %{public}s, enter", func_); 118 } ~InnerFunctionTracer()119 ~InnerFunctionTracer() 120 { 121 OHOS::HiviewDFX::HiLog::Debug(label_, "in %{public}s, leave", func_); 122 } 123 private: 124 const OHOS::HiviewDFX::HiLogLabel& label_; 125 const char* func_ { nullptr }; 126 }; 127 128 #define CALL_LOG_ENTER InnerFunctionTracer ___innerFuncTracer___ { LABEL, __FUNCTION__ } 129 130 #ifdef DEBUG_CODE_TEST 131 #define CHKPL(cond, ...) \ 132 do { \ 133 if ((cond) == nullptr) { \ 134 SEN_HILOGW("%{public}s, (%{public}d), CHKPL(%{public}s) is null, do nothing", \ 135 __FILE__, __LINE__, #cond); \ 136 } \ 137 } while (0) 138 139 #define CHKPV(cond) \ 140 do { \ 141 if ((cond) == nullptr) { \ 142 SEN_HILOGE("%{public}s, (%{public}d), CHKPV(%{public}s) is null", \ 143 __FILE__, __LINE__, #cond); \ 144 return; \ 145 } \ 146 } while (0) 147 148 #define CHKPF(cond) \ 149 do { \ 150 if ((cond) == nullptr) { \ 151 SEN_HILOGE("%{public}s, (%{public}d), CHKPF(%{public}s) is null", \ 152 __FILE__, __LINE__, #cond); \ 153 return false; \ 154 } \ 155 } while (0) 156 157 #define CHKPC(cond) \ 158 { \ 159 if ((cond) == nullptr) { \ 160 SEN_HILOGW("%{public}s, (%{public}d), CHKPC(%{public}s) is null, skip then continue", \ 161 __FILE__, __LINE__, #cond); \ 162 continue; \ 163 } \ 164 } 165 166 #define CHKPB(cond) \ 167 { \ 168 if ((cond) == nullptr) { \ 169 SEN_HILOGW("%{public}s, (%{public}d), CHKPC(%{public}s) is null, skip then break", \ 170 __FILE__, __LINE__, #cond); \ 171 break; \ 172 } \ 173 } 174 175 #define CHKPR(cond, r) \ 176 do { \ 177 if ((cond) == nullptr) { \ 178 SEN_HILOGE("%{public}s, (%{public}d), CHKPR(%{public}s) is null, return value is %{public}d", \ 179 __FILE__, __LINE__, #cond, r); \ 180 return r; \ 181 } \ 182 } while (0) 183 184 #define CHKPP(cond) \ 185 do { \ 186 if ((cond) == nullptr) { \ 187 SEN_HILOGE("%{public}s, (%{public}d), CHKPP(%{public}s) is null, return value is null", \ 188 __FILE__, __LINE__, #cond); \ 189 return nullptr; \ 190 } \ 191 } while (0) 192 193 #define CK(cond, ec) \ 194 do { \ 195 if (!(cond)) { \ 196 SEN_HILOGE("%{public}s, (%{public}d), CK(%{public}s), errCode:%{public}d", \ 197 __FILE__, __LINE__, #cond, ec); \ 198 } \ 199 } while (0) 200 201 #else // DEBUG_CODE_TEST 202 #define CHKPL(cond) \ 203 do { \ 204 if ((cond) == nullptr) { \ 205 SEN_HILOGW("CHKPL(%{public}s) is null, do nothing", #cond); \ 206 } \ 207 } while (0) 208 209 #define CHKPV(cond) \ 210 do { \ 211 if ((cond) == nullptr) { \ 212 SEN_HILOGE("CHKPV(%{public}s) is null", #cond); \ 213 return; \ 214 } \ 215 } while (0) 216 217 #define CHKPF(cond) \ 218 do { \ 219 if ((cond) == nullptr) { \ 220 SEN_HILOGE("CHKPF(%{public}s) is null", #cond); \ 221 return false; \ 222 } \ 223 } while (0) 224 225 #define CHKPC(cond) \ 226 { \ 227 if ((cond) == nullptr) { \ 228 SEN_HILOGW("CHKPC(%{public}s) is null, skip then continue", #cond); \ 229 continue; \ 230 } \ 231 } 232 233 #define CHKPB(cond) \ 234 { \ 235 if ((cond) == nullptr) { \ 236 SEN_HILOGW("CHKPC(%{public}s) is null, skip then break", #cond); \ 237 break; \ 238 } \ 239 } 240 241 #define CHKPR(cond, r) \ 242 do { \ 243 if ((cond) == nullptr) { \ 244 SEN_HILOGE("CHKPR(%{public}s) is null, return value is %{public}d", #cond, r); \ 245 return r; \ 246 } \ 247 } while (0) 248 249 #define CHKCF(cond, message) \ 250 do { \ 251 if (!(cond)) { \ 252 SEN_HILOGE("CK(%{public}s), %{public}s", #cond, message); \ 253 return false; \ 254 } \ 255 } while (0) 256 257 #define CHKCV(cond, message) \ 258 do { \ 259 if (!(cond)) { \ 260 SEN_HILOGE("CK(%{public}s), %{public}s", #cond, message); \ 261 return; \ 262 } \ 263 } while (0) 264 265 #define CHKPP(cond) \ 266 do { \ 267 if ((cond) == nullptr) { \ 268 SEN_HILOGE("CHKPP(%{public}s) is null, return value is null", #cond); \ 269 return nullptr; \ 270 } \ 271 } while (0) 272 273 #define CK(cond, ec) \ 274 do { \ 275 if (!(cond)) { \ 276 SEN_HILOGE("CK(%{public}s), errCode:%{public}d", #cond, ec); \ 277 } \ 278 } while (0) 279 280 #endif 281 } // namespace Sensors 282 } // namespace OHOS 283 #endif // SENSORS_ERRORS_H 284