1 /* 2 * Copyright 2023 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #pragma once 17 18 /* 19 * Generated mock file from original source file 20 * Functions generated:66 21 * 22 * mockcify.pl ver 0.6.0 23 */ 24 25 #include <cstdint> 26 #include <functional> 27 #include <string> 28 29 // Original included files, if any 30 #include "stack/btm/security_device_record.h" 31 #include "stack/include/bt_dev_class.h" 32 #include "stack/include/bt_device_type.h" 33 #include "stack/include/btm_status.h" 34 #include "stack/include/hci_error_code.h" 35 #include "stack/include/security_client_callbacks.h" 36 #include "types/bt_transport.h" 37 #include "types/hci_role.h" 38 #include "types/raw_address.h" 39 40 // Original usings 41 42 // Mocked compile conditionals, if any 43 44 namespace test { 45 namespace mock { 46 namespace stack_btm_sec { 47 48 // Name: BTM_CanReadDiscoverableCharacteristics 49 // Params: const RawAddress& bd_addr 50 // Return: bool 51 struct BTM_CanReadDiscoverableCharacteristics { 52 static bool return_value; 53 std::function<bool(const RawAddress& bd_addr)> body{ 54 [](const RawAddress& /* bd_addr */) { return return_value; }}; operatorBTM_CanReadDiscoverableCharacteristics55 bool operator()(const RawAddress& bd_addr) { return body(bd_addr); } 56 }; 57 extern struct BTM_CanReadDiscoverableCharacteristics BTM_CanReadDiscoverableCharacteristics; 58 59 // Name: BTM_ConfirmReqReply 60 // Params: tBTM_STATUS res, const RawAddress& bd_addr 61 // Return: void 62 struct BTM_ConfirmReqReply { 63 std::function<void(tBTM_STATUS res, const RawAddress& bd_addr)> body{ 64 [](tBTM_STATUS /* res */, const RawAddress& /* bd_addr */) {}}; operatorBTM_ConfirmReqReply65 void operator()(tBTM_STATUS res, const RawAddress& bd_addr) { body(res, bd_addr); } 66 }; 67 extern struct BTM_ConfirmReqReply BTM_ConfirmReqReply; 68 69 // Name: BTM_IsAuthenticated 70 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 71 // Return: bool 72 struct BTM_IsAuthenticated { 73 static bool return_value; 74 std::function<bool(const RawAddress& bd_addr, tBT_TRANSPORT transport)> body{ 75 [](const RawAddress& /* bd_addr */, tBT_TRANSPORT /* transport */) { 76 return return_value; 77 }}; operatorBTM_IsAuthenticated78 bool operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 79 return body(bd_addr, transport); 80 } 81 }; 82 extern struct BTM_IsAuthenticated BTM_IsAuthenticated; 83 84 // Name: BTM_IsEncrypted 85 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 86 // Return: bool 87 struct BTM_IsEncrypted { 88 static bool return_value; 89 std::function<bool(const RawAddress& bd_addr, tBT_TRANSPORT transport)> body{ 90 [](const RawAddress& /* bd_addr */, tBT_TRANSPORT /* transport */) { 91 return return_value; 92 }}; operatorBTM_IsEncrypted93 bool operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 94 return body(bd_addr, transport); 95 } 96 }; 97 extern struct BTM_IsEncrypted BTM_IsEncrypted; 98 99 // Name: BTM_IsLinkKeyAuthed 100 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 101 // Return: bool 102 struct BTM_IsLinkKeyAuthed { 103 static bool return_value; 104 std::function<bool(const RawAddress& bd_addr, tBT_TRANSPORT transport)> body{ 105 [](const RawAddress& /* bd_addr */, tBT_TRANSPORT /* transport */) { 106 return return_value; 107 }}; operatorBTM_IsLinkKeyAuthed108 bool operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 109 return body(bd_addr, transport); 110 } 111 }; 112 extern struct BTM_IsLinkKeyAuthed BTM_IsLinkKeyAuthed; 113 114 // Name: BTM_IsLinkKeyKnown 115 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 116 // Return: bool 117 struct BTM_IsLinkKeyKnown { 118 static bool return_value; 119 std::function<bool(const RawAddress& bd_addr, tBT_TRANSPORT transport)> body{ 120 [](const RawAddress& /* bd_addr */, tBT_TRANSPORT /* transport */) { 121 return return_value; 122 }}; operatorBTM_IsLinkKeyKnown123 bool operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 124 return body(bd_addr, transport); 125 } 126 }; 127 extern struct BTM_IsLinkKeyKnown BTM_IsLinkKeyKnown; 128 129 // Name: BTM_PINCodeReply 130 // Params: const RawAddress& bd_addr, tBTM_STATUS res, uint8_t pin_len, uint8_t* 131 // p_pin Return: void 132 struct BTM_PINCodeReply { 133 std::function<void(const RawAddress& bd_addr, tBTM_STATUS res, uint8_t pin_len, uint8_t* p_pin)> 134 body{[](const RawAddress& /* bd_addr */, tBTM_STATUS /* res */, uint8_t /* pin_len */, 135 uint8_t* /* p_pin */) {}}; operatorBTM_PINCodeReply136 void operator()(const RawAddress& bd_addr, tBTM_STATUS res, uint8_t pin_len, uint8_t* p_pin) { 137 body(bd_addr, res, pin_len, p_pin); 138 } 139 }; 140 extern struct BTM_PINCodeReply BTM_PINCodeReply; 141 142 // Name: BTM_PasskeyReqReply 143 // Params: tBTM_STATUS res, const RawAddress& bd_addr, uint32_t passkey 144 // Return: void 145 struct BTM_PasskeyReqReply { 146 std::function<void(tBTM_STATUS res, const RawAddress& bd_addr, uint32_t passkey)> body{ 147 [](tBTM_STATUS /* res */, const RawAddress& /* bd_addr */, uint32_t /* passkey */) {}}; operatorBTM_PasskeyReqReply148 void operator()(tBTM_STATUS res, const RawAddress& bd_addr, uint32_t passkey) { 149 body(res, bd_addr, passkey); 150 } 151 }; 152 extern struct BTM_PasskeyReqReply BTM_PasskeyReqReply; 153 154 // Name: BTM_PeerSupportsSecureConnections 155 // Params: const RawAddress& bd_addr 156 // Return: bool 157 struct BTM_PeerSupportsSecureConnections { 158 static bool return_value; 159 std::function<bool(const RawAddress& bd_addr)> body{ 160 [](const RawAddress& /* bd_addr */) { return return_value; }}; operatorBTM_PeerSupportsSecureConnections161 bool operator()(const RawAddress& bd_addr) { return body(bd_addr); } 162 }; 163 extern struct BTM_PeerSupportsSecureConnections BTM_PeerSupportsSecureConnections; 164 165 // Name: BTM_ReadLocalOobData 166 // Params: void 167 // Return: void 168 struct BTM_ReadLocalOobData { 169 std::function<void(void)> body{[](void) {}}; operatorBTM_ReadLocalOobData170 void operator()(void) { body(); } 171 }; 172 extern struct BTM_ReadLocalOobData BTM_ReadLocalOobData; 173 174 // Name: BTM_RemoteOobDataReply 175 // Params: tBTM_STATUS res, const RawAddress& bd_addr, const Octet16& c, const 176 // Octet16& r Return: void 177 struct BTM_RemoteOobDataReply { 178 std::function<void(tBTM_STATUS res, const RawAddress& bd_addr, const Octet16& c, 179 const Octet16& r)> 180 body{[](tBTM_STATUS /* res */, const RawAddress& /* bd_addr */, const Octet16& /* c */, 181 const Octet16& /* r */) {}}; operatorBTM_RemoteOobDataReply182 void operator()(tBTM_STATUS res, const RawAddress& bd_addr, const Octet16& c, const Octet16& r) { 183 body(res, bd_addr, c, r); 184 } 185 }; 186 extern struct BTM_RemoteOobDataReply BTM_RemoteOobDataReply; 187 188 // Name: BTM_SecBond 189 // Params: const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, tBT_TRANSPORT 190 // transport, tBT_DEVICE_TYPE device_type, uint8_t pin_len, uint8_t* p_pin 191 // Return: tBTM_STATUS 192 struct BTM_SecBond { 193 static tBTM_STATUS return_value; 194 std::function<tBTM_STATUS(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, 195 tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type)> 196 body{[](const RawAddress& /* bd_addr */, tBLE_ADDR_TYPE /* addr_type */, 197 tBT_TRANSPORT /* transport */, 198 tBT_DEVICE_TYPE /* device_type */) { return return_value; }}; operatorBTM_SecBond199 tBTM_STATUS operator()(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, 200 tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type) { 201 return body(bd_addr, addr_type, transport, device_type); 202 } 203 }; 204 extern struct BTM_SecBond BTM_SecBond; 205 206 // Name: BTM_SecBondCancel 207 // Params: const RawAddress& bd_addr 208 // Return: tBTM_STATUS 209 struct BTM_SecBondCancel { 210 static tBTM_STATUS return_value; 211 std::function<tBTM_STATUS(const RawAddress& bd_addr)> body{ 212 [](const RawAddress& /* bd_addr */) { return return_value; }}; operatorBTM_SecBondCancel213 tBTM_STATUS operator()(const RawAddress& bd_addr) { return body(bd_addr); } 214 }; 215 extern struct BTM_SecBondCancel BTM_SecBondCancel; 216 217 // Name: BTM_SecClrService 218 // Params: uint8_t service_id 219 // Return: uint8_t 220 struct BTM_SecClrService { 221 static uint8_t return_value; 222 std::function<uint8_t(uint8_t service_id)> body{ 223 [](uint8_t /* service_id */) { return return_value; }}; operatorBTM_SecClrService224 uint8_t operator()(uint8_t service_id) { return body(service_id); } 225 }; 226 extern struct BTM_SecClrService BTM_SecClrService; 227 228 // Name: BTM_SecClrServiceByPsm 229 // Params: uint16_t psm 230 // Return: uint8_t 231 struct BTM_SecClrServiceByPsm { 232 static uint8_t return_value; 233 std::function<uint8_t(uint16_t psm)> body{[](uint16_t /* psm */) { return return_value; }}; operatorBTM_SecClrServiceByPsm234 uint8_t operator()(uint16_t psm) { return body(psm); } 235 }; 236 extern struct BTM_SecClrServiceByPsm BTM_SecClrServiceByPsm; 237 238 // Name: BTM_SecGetDeviceLinkKeyType 239 // Params: const RawAddress& bd_addr 240 // Return: tBTM_LINK_KEY_TYPE 241 struct BTM_SecGetDeviceLinkKeyType { 242 static tBTM_LINK_KEY_TYPE return_value; 243 std::function<tBTM_LINK_KEY_TYPE(const RawAddress& bd_addr)> body{ 244 [](const RawAddress& /* bd_addr */) { return return_value; }}; operatorBTM_SecGetDeviceLinkKeyType245 tBTM_LINK_KEY_TYPE operator()(const RawAddress& bd_addr) { return body(bd_addr); } 246 }; 247 extern struct BTM_SecGetDeviceLinkKeyType BTM_SecGetDeviceLinkKeyType; 248 249 // Name: BTM_SecIsSecurityPending 250 // Params: const RawAddress& bd_addr 251 // Return: bool 252 struct BTM_SecIsSecurityPending { 253 static bool return_value; 254 std::function<bool(const RawAddress& bd_addr)> body{ 255 [](const RawAddress& /* bd_addr */) { return return_value; }}; operatorBTM_SecIsSecurityPending256 bool operator()(const RawAddress& bd_addr) { return body(bd_addr); } 257 }; 258 extern struct BTM_SecIsSecurityPending BTM_SecIsSecurityPending; 259 260 // Name: BTM_SecRegister 261 // Params: const tBTM_APPL_INFO* p_cb_info 262 // Return: bool 263 struct BTM_SecRegister { 264 static bool return_value; 265 std::function<bool(const tBTM_APPL_INFO* p_cb_info)> body{ 266 [](const tBTM_APPL_INFO* /* p_cb_info */) { return return_value; }}; operatorBTM_SecRegister267 bool operator()(const tBTM_APPL_INFO* p_cb_info) { return body(p_cb_info); } 268 }; 269 extern struct BTM_SecRegister BTM_SecRegister; 270 271 // Name: BTM_SetEncryption 272 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport, 273 // tBTM_SEC_CALLBACK* p_callback, void* p_ref_data, tBTM_BLE_SEC_ACT sec_act 274 // Return: tBTM_STATUS 275 struct BTM_SetEncryption { 276 static tBTM_STATUS return_value; 277 std::function<tBTM_STATUS(const RawAddress& bd_addr, tBT_TRANSPORT transport, 278 tBTM_SEC_CALLBACK* p_callback, void* p_ref_data, 279 tBTM_BLE_SEC_ACT sec_act)> 280 body{[](const RawAddress& /* bd_addr */, tBT_TRANSPORT /* transport */, 281 tBTM_SEC_CALLBACK* /* p_callback */, void* /* p_ref_data */, 282 tBTM_BLE_SEC_ACT /* sec_act */) { return return_value; }}; operatorBTM_SetEncryption283 tBTM_STATUS operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport, 284 tBTM_SEC_CALLBACK* p_callback, void* p_ref_data, 285 tBTM_BLE_SEC_ACT sec_act) { 286 return body(bd_addr, transport, p_callback, p_ref_data, sec_act); 287 } 288 }; 289 extern struct BTM_SetEncryption BTM_SetEncryption; 290 291 // Name: BTM_SetPinType 292 // Params: uint8_t pin_type, PIN_CODE pin_code, uint8_t pin_code_len 293 // Return: void 294 struct BTM_SetPinType { 295 std::function<void(uint8_t pin_type, PIN_CODE pin_code, uint8_t pin_code_len)> body{ 296 [](uint8_t /* pin_type */, PIN_CODE /* pin_code */, uint8_t /* pin_code_len */) {}}; operatorBTM_SetPinType297 void operator()(uint8_t pin_type, PIN_CODE pin_code, uint8_t pin_code_len) { 298 body(pin_type, pin_code, pin_code_len); 299 } 300 }; 301 extern struct BTM_SetPinType BTM_SetPinType; 302 303 // Name: BTM_SetSecurityLevel 304 // Params: bool is_originator, const char* p_name, uint8_t service_id, uint16_t 305 // sec_level, uint16_t psm, uint32_t mx_proto_id, uint32_t mx_chan_id Return: 306 // bool 307 struct BTM_SetSecurityLevel { 308 static bool return_value; 309 std::function<bool(bool is_originator, const char* p_name, uint8_t service_id, uint16_t sec_level, 310 uint16_t psm, uint32_t mx_proto_id, uint32_t mx_chan_id)> 311 body{[](bool /* is_originator */, const char* /* p_name */, uint8_t /* service_id */, 312 uint16_t /* sec_level */, uint16_t /* psm */, uint32_t /* mx_proto_id */, 313 uint32_t /* mx_chan_id */) { return return_value; }}; operatorBTM_SetSecurityLevel314 bool operator()(bool is_originator, const char* p_name, uint8_t service_id, uint16_t sec_level, 315 uint16_t psm, uint32_t mx_proto_id, uint32_t mx_chan_id) { 316 return body(is_originator, p_name, service_id, sec_level, psm, mx_proto_id, mx_chan_id); 317 } 318 }; 319 extern struct BTM_SetSecurityLevel BTM_SetSecurityLevel; 320 321 // Name: BTM_update_version_info 322 // Params: const RawAddress& bd_addr, const remote_version_info& 323 // remote_version_info Return: void 324 struct BTM_update_version_info { 325 std::function<void(const RawAddress& bd_addr, const remote_version_info& remote_version_info)> 326 body{[](const RawAddress& /* bd_addr */, 327 const remote_version_info& /* remote_version_info */) {}}; operatorBTM_update_version_info328 void operator()(const RawAddress& bd_addr, const remote_version_info& remote_version_info) { 329 body(bd_addr, remote_version_info); 330 } 331 }; 332 extern struct BTM_update_version_info BTM_update_version_info; 333 334 // Name: NotifyBondingCanceled 335 // Params: tBTM_STATUS btm_status 336 // Return: void 337 struct NotifyBondingCanceled { 338 std::function<void(tBTM_STATUS btm_status)> body{[](tBTM_STATUS /* btm_status */) {}}; operatorNotifyBondingCanceled339 void operator()(tBTM_STATUS btm_status) { body(btm_status); } 340 }; 341 extern struct NotifyBondingCanceled NotifyBondingCanceled; 342 343 // Name: btm_create_conn_cancel_complete 344 // Params: uint8_t status, RawAddress bd_addr 345 // Return: void 346 struct btm_create_conn_cancel_complete { 347 std::function<void(uint8_t status, const RawAddress bd_addr)> body{ 348 [](uint8_t /* status */, const RawAddress /* bd_addr */) {}}; operatorbtm_create_conn_cancel_complete349 void operator()(uint8_t status, const RawAddress bd_addr) { body(status, bd_addr); } 350 }; 351 extern struct btm_create_conn_cancel_complete btm_create_conn_cancel_complete; 352 353 // Name: btm_get_dev_class 354 // Params: const RawAddress& bda 355 // Return: DEV_CLASS 356 struct btm_get_dev_class { 357 static const DEV_CLASS return_value; 358 std::function<const DEV_CLASS(const RawAddress& bda)> body{ 359 [](const RawAddress& /* bda */) { return return_value; }}; operatorbtm_get_dev_class360 const DEV_CLASS operator()(const RawAddress& bda) { return body(bda); } 361 }; 362 extern struct btm_get_dev_class btm_get_dev_class; 363 364 // Name: btm_io_capabilities_req 365 // Params: RawAddress p 366 // Return: void 367 struct btm_io_capabilities_req { 368 std::function<void(RawAddress p)> body{[](RawAddress /* p */) {}}; operatorbtm_io_capabilities_req369 void operator()(RawAddress p) { body(p); } 370 }; 371 extern struct btm_io_capabilities_req btm_io_capabilities_req; 372 373 // Name: btm_io_capabilities_rsp 374 // Params: tBTM_SP_IO_RSP evt_data 375 // Return: void 376 struct btm_io_capabilities_rsp { 377 std::function<void(const tBTM_SP_IO_RSP evt_data)> body{ 378 [](const tBTM_SP_IO_RSP /* evt_data */) {}}; operatorbtm_io_capabilities_rsp379 void operator()(const tBTM_SP_IO_RSP evt_data) { body(evt_data); } 380 }; 381 extern struct btm_io_capabilities_rsp btm_io_capabilities_rsp; 382 383 // Name: btm_proc_sp_req_evt 384 // Params: tBTM_SP_EVT event, const uint8_t* p 385 // Return: void 386 struct btm_proc_sp_req_evt { 387 std::function<void(tBTM_SP_EVT event, const RawAddress bda, uint32_t value)> body{ 388 [](tBTM_SP_EVT /* event */, const RawAddress /* bda */, uint32_t /* value */) {}}; operatorbtm_proc_sp_req_evt389 void operator()(tBTM_SP_EVT event, const RawAddress bda, uint32_t value) { 390 body(event, bda, value); 391 } 392 }; 393 extern struct btm_proc_sp_req_evt btm_proc_sp_req_evt; 394 395 // Name: btm_read_local_oob_complete 396 // Params: 397 // tBTM_SP_LOC_OOB evt_data; 398 // uint8_t status; 399 // Return: void 400 struct btm_read_local_oob_complete { 401 std::function<void(const tBTM_SP_LOC_OOB evt_data)> body{ 402 [](const tBTM_SP_LOC_OOB /* evt_data */) {}}; operatorbtm_read_local_oob_complete403 void operator()(const tBTM_SP_LOC_OOB evt_data) { body(evt_data); } 404 }; 405 extern struct btm_read_local_oob_complete btm_read_local_oob_complete; 406 407 // Name: btm_rem_oob_req 408 // Params: RawAddress bda 409 // Return: void 410 struct btm_rem_oob_req { 411 std::function<void(const RawAddress bda)> body{[](const RawAddress /* bda */) {}}; operatorbtm_rem_oob_req412 void operator()(const RawAddress bda) { body(bda); } 413 }; 414 extern struct btm_rem_oob_req btm_rem_oob_req; 415 416 // Name: btm_sec_abort_access_req 417 // Params: const RawAddress& bd_addr 418 // Return: void 419 struct btm_sec_abort_access_req { 420 std::function<void(const RawAddress& bd_addr)> body{[](const RawAddress& /* bd_addr */) {}}; operatorbtm_sec_abort_access_req421 void operator()(const RawAddress& bd_addr) { body(bd_addr); } 422 }; 423 extern struct btm_sec_abort_access_req btm_sec_abort_access_req; 424 425 // Name: btm_sec_auth_complete 426 // Params: uint16_t handle, tHCI_STATUS status 427 // Return: void 428 struct btm_sec_auth_complete { 429 std::function<void(uint16_t handle, tHCI_STATUS status)> body{ 430 [](uint16_t /* handle */, tHCI_STATUS /* status */) {}}; operatorbtm_sec_auth_complete431 void operator()(uint16_t handle, tHCI_STATUS status) { body(handle, status); } 432 }; 433 extern struct btm_sec_auth_complete btm_sec_auth_complete; 434 435 // Name: btm_sec_bond_by_transport 436 // Params: const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, tBT_TRANSPORT 437 // transport, uint8_t pin_len, uint8_t* p_pin Return: tBTM_STATUS 438 struct btm_sec_bond_by_transport { 439 static tBTM_STATUS return_value; 440 std::function<tBTM_STATUS(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, 441 tBT_TRANSPORT transport)> 442 body{[](const RawAddress& /* bd_addr */, tBLE_ADDR_TYPE /* addr_type */, 443 tBT_TRANSPORT /* transport */) { return return_value; }}; operatorbtm_sec_bond_by_transport444 tBTM_STATUS operator()(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, 445 tBT_TRANSPORT transport) { 446 return body(bd_addr, addr_type, transport); 447 } 448 }; 449 extern struct btm_sec_bond_by_transport btm_sec_bond_by_transport; 450 451 // Name: btm_sec_check_pending_reqs 452 // Params: void 453 // Return: void 454 struct btm_sec_check_pending_reqs { 455 std::function<void(void)> body{[](void) {}}; operatorbtm_sec_check_pending_reqs456 void operator()(void) { body(); } 457 }; 458 extern struct btm_sec_check_pending_reqs btm_sec_check_pending_reqs; 459 460 // Name: btm_sec_clear_ble_keys 461 // Params: tBTM_SEC_DEV_REC* p_dev_rec 462 // Return: void 463 struct btm_sec_clear_ble_keys { 464 std::function<void(tBTM_SEC_DEV_REC* p_dev_rec)> body{[](tBTM_SEC_DEV_REC* /* p_dev_rec */) {}}; operatorbtm_sec_clear_ble_keys465 void operator()(tBTM_SEC_DEV_REC* p_dev_rec) { body(p_dev_rec); } 466 }; 467 extern struct btm_sec_clear_ble_keys btm_sec_clear_ble_keys; 468 469 // Name: btm_sec_conn_req 470 // Params: const RawAddress& bda, const DEV_CLASS dc 471 // Return: void 472 struct btm_sec_conn_req { 473 std::function<void(const RawAddress& bda, const DEV_CLASS dc)> body{ 474 [](const RawAddress& /* bda */, const DEV_CLASS /* dc */) {}}; operatorbtm_sec_conn_req475 void operator()(const RawAddress& bda, const DEV_CLASS dc) { body(bda, dc); } 476 }; 477 extern struct btm_sec_conn_req btm_sec_conn_req; 478 479 // Name: btm_sec_connected 480 // Params: const RawAddress& bda, uint16_t handle, tHCI_STATUS status, uint8_t 481 // enc_mode, tHCI_ROLE assigned_role Return: void 482 struct btm_sec_connected { 483 std::function<void(const RawAddress& bda, uint16_t handle, tHCI_STATUS status, uint8_t enc_mode, 484 tHCI_ROLE assigned_role)> 485 body{[](const RawAddress& /* bda */, uint16_t /* handle */, tHCI_STATUS /* status */, 486 uint8_t /* enc_mode */, tHCI_ROLE /* assigned_role */) {}}; operatorbtm_sec_connected487 void operator()(const RawAddress& bda, uint16_t handle, tHCI_STATUS status, uint8_t enc_mode, 488 tHCI_ROLE assigned_role) { 489 body(bda, handle, status, enc_mode, assigned_role); 490 } 491 }; 492 extern struct btm_sec_connected btm_sec_connected; 493 494 // Name: btm_sec_cr_loc_oob_data_cback_event 495 // Params: const RawAddress& address, tSMP_LOC_OOB_DATA loc_oob_data 496 // Return: void 497 struct btm_sec_cr_loc_oob_data_cback_event { 498 std::function<void(const RawAddress& address, tSMP_LOC_OOB_DATA loc_oob_data)> body{ 499 [](const RawAddress& /* address */, tSMP_LOC_OOB_DATA /* loc_oob_data */) {}}; operatorbtm_sec_cr_loc_oob_data_cback_event500 void operator()(const RawAddress& address, tSMP_LOC_OOB_DATA loc_oob_data) { 501 body(address, loc_oob_data); 502 } 503 }; 504 extern struct btm_sec_cr_loc_oob_data_cback_event btm_sec_cr_loc_oob_data_cback_event; 505 506 // Name: btm_sec_dev_rec_cback_event 507 // Params: tBTM_SEC_DEV_REC* p_dev_rec, tBTM_STATUS btm_status, bool 508 // is_le_transport Return: void 509 struct btm_sec_dev_rec_cback_event { 510 std::function<void(tBTM_SEC_DEV_REC* p_dev_rec, tBTM_STATUS btm_status, bool is_le_transport)> 511 body{[](tBTM_SEC_DEV_REC* /* p_dev_rec */, tBTM_STATUS /* btm_status */, 512 bool /* is_le_transport */) {}}; operatorbtm_sec_dev_rec_cback_event513 void operator()(tBTM_SEC_DEV_REC* p_dev_rec, tBTM_STATUS btm_status, bool is_le_transport) { 514 body(p_dev_rec, btm_status, is_le_transport); 515 } 516 }; 517 extern struct btm_sec_dev_rec_cback_event btm_sec_dev_rec_cback_event; 518 519 // Name: btm_sec_dev_reset 520 // Params: void 521 // Return: void 522 struct btm_sec_dev_reset { 523 std::function<void(void)> body{[](void) {}}; operatorbtm_sec_dev_reset524 void operator()(void) { body(); } 525 }; 526 extern struct btm_sec_dev_reset btm_sec_dev_reset; 527 528 // Name: btm_sec_disconnect 529 // Params: uint16_t handle, tHCI_STATUS reason, std::string comment 530 // Return: tBTM_STATUS 531 struct btm_sec_disconnect { 532 static tBTM_STATUS return_value; 533 std::function<tBTM_STATUS(uint16_t handle, tHCI_STATUS reason, std::string comment)> body{ 534 [](uint16_t /* handle */, tHCI_STATUS /* reason */, std::string /* comment */) { 535 return return_value; 536 }}; operatorbtm_sec_disconnect537 tBTM_STATUS operator()(uint16_t handle, tHCI_STATUS reason, std::string comment) { 538 return body(handle, reason, comment); 539 } 540 }; 541 extern struct btm_sec_disconnect btm_sec_disconnect; 542 543 // Name: btm_sec_disconnected 544 // Params: uint16_t handle, tHCI_REASON reason, std::string comment 545 // Return: void 546 struct btm_sec_disconnected { 547 std::function<void(uint16_t handle, tHCI_REASON reason, std::string comment)> body{ 548 [](uint16_t /* handle */, tHCI_REASON /* reason */, std::string /* comment */) {}}; operatorbtm_sec_disconnected549 void operator()(uint16_t handle, tHCI_REASON reason, std::string comment) { 550 body(handle, reason, comment); 551 } 552 }; 553 extern struct btm_sec_disconnected btm_sec_disconnected; 554 555 // Name: btm_sec_encrypt_change 556 // Params: uint16_t handle, tHCI_STATUS status, uint8_t encr_enable, uint8_t key_size, bool 557 // from_key_refresh Return: void 558 struct btm_sec_encrypt_change { 559 std::function<void(uint16_t handle, tHCI_STATUS status, uint8_t encr_enable, uint8_t key_size, 560 bool from_key_refresh)> 561 body{[](uint16_t /* handle */, tHCI_STATUS /* status */, uint8_t /* encr_enable */, 562 uint8_t /* key_size */, bool /* from_key_refresh */) {}}; operatorbtm_sec_encrypt_change563 void operator()(uint16_t handle, tHCI_STATUS status, uint8_t encr_enable, uint8_t key_size, 564 bool from_key_refresh) { 565 body(handle, status, encr_enable, key_size, from_key_refresh); 566 } 567 }; 568 extern struct btm_sec_encrypt_change btm_sec_encrypt_change; 569 570 // Name: btm_sec_encryption_change_evt 571 // Params: uint16_t handle, tHCI_STATUS status, uint8_t encr_enable, uint8_t key_size 572 // Return: void 573 struct btm_sec_encryption_change_evt { 574 std::function<void(uint16_t handle, tHCI_STATUS status, uint8_t encr_enable, uint8_t key_size)> 575 body{[](uint16_t /* handle */, tHCI_STATUS /* status */, uint8_t /* encr_enable */, 576 uint8_t /* key_size */) {}}; operatorbtm_sec_encryption_change_evt577 void operator()(uint16_t handle, tHCI_STATUS status, uint8_t encr_enable, uint8_t key_size) { 578 body(handle, status, encr_enable, key_size); 579 } 580 }; 581 extern struct btm_sec_encryption_change_evt btm_sec_encryption_change_evt; 582 583 // Name: btm_sec_is_a_bonded_dev 584 // Params: const RawAddress& bda 585 // Return: bool 586 struct btm_sec_is_a_bonded_dev { 587 static bool return_value; 588 std::function<bool(const RawAddress& bda)> body{ 589 [](const RawAddress& /* bda */) { return return_value; }}; operatorbtm_sec_is_a_bonded_dev590 bool operator()(const RawAddress& bda) { return body(bda); } 591 }; 592 extern struct btm_sec_is_a_bonded_dev btm_sec_is_a_bonded_dev; 593 594 // Name: btm_sec_l2cap_access_req 595 // Params: const RawAddress& bd_addr, uint16_t psm, bool is_originator, 596 // tBTM_SEC_CALLBACK* p_callback, void* p_ref_data Return: tBTM_STATUS 597 struct btm_sec_l2cap_access_req { 598 static tBTM_STATUS return_value; 599 std::function<tBTM_STATUS(const RawAddress& bd_addr, uint16_t psm, bool is_originator, 600 tBTM_SEC_CALLBACK* p_callback, void* p_ref_data)> 601 body{[](const RawAddress& /* bd_addr */, uint16_t /* psm */, bool /* is_originator */, 602 tBTM_SEC_CALLBACK* /* p_callback */, 603 void* /* p_ref_data */) { return return_value; }}; operatorbtm_sec_l2cap_access_req604 tBTM_STATUS operator()(const RawAddress& bd_addr, uint16_t psm, bool is_originator, 605 tBTM_SEC_CALLBACK* p_callback, void* p_ref_data) { 606 return body(bd_addr, psm, is_originator, p_callback, p_ref_data); 607 } 608 }; 609 extern struct btm_sec_l2cap_access_req btm_sec_l2cap_access_req; 610 611 // Name: btm_sec_l2cap_access_req_by_requirement 612 // Params: const RawAddress& bd_addr, uint16_t security_required, bool 613 // is_originator, tBTM_SEC_CALLBACK* p_callback, void* p_ref_data Return: 614 // tBTM_STATUS 615 struct btm_sec_l2cap_access_req_by_requirement { 616 static tBTM_STATUS return_value; 617 std::function<tBTM_STATUS(const RawAddress& bd_addr, uint16_t security_required, 618 bool is_originator, tBTM_SEC_CALLBACK* p_callback, void* p_ref_data)> 619 body{[](const RawAddress& /* bd_addr */, uint16_t /* security_required */, 620 bool /* is_originator */, tBTM_SEC_CALLBACK* /* p_callback */, 621 void* /* p_ref_data */) { return return_value; }}; operatorbtm_sec_l2cap_access_req_by_requirement622 tBTM_STATUS operator()(const RawAddress& bd_addr, uint16_t security_required, bool is_originator, 623 tBTM_SEC_CALLBACK* p_callback, void* p_ref_data) { 624 return body(bd_addr, security_required, is_originator, p_callback, p_ref_data); 625 } 626 }; 627 extern struct btm_sec_l2cap_access_req_by_requirement btm_sec_l2cap_access_req_by_requirement; 628 629 // Name: btm_sec_link_key_notification 630 // Params: const RawAddress& p_bda, const Octet16& link_key, uint8_t key_type 631 // Return: void 632 struct btm_sec_link_key_notification { 633 std::function<void(const RawAddress& p_bda, const Octet16& link_key, uint8_t key_type)> body{ 634 [](const RawAddress& /* p_bda */, const Octet16& /* link_key */, uint8_t /* key_type */) { 635 }}; operatorbtm_sec_link_key_notification636 void operator()(const RawAddress& p_bda, const Octet16& link_key, uint8_t key_type) { 637 body(p_bda, link_key, key_type); 638 } 639 }; 640 extern struct btm_sec_link_key_notification btm_sec_link_key_notification; 641 642 // Name: btm_sec_encryption_key_refresh_complete 643 // Params: uint16_t handle, tHCI_STATUS status 644 // Return: void 645 struct btm_sec_encryption_key_refresh_complete { 646 std::function<void(uint16_t handle, tHCI_STATUS status)> body{ 647 [](uint16_t /* handle */, tHCI_STATUS /* status */) -> void {}}; operatorbtm_sec_encryption_key_refresh_complete648 void operator()(uint16_t handle, tHCI_STATUS status) { body(handle, status); } 649 }; 650 extern struct btm_sec_encryption_key_refresh_complete btm_sec_encryption_key_refresh_complete; 651 652 // Name: btm_sec_link_key_request 653 // Params: const uint8_t* p_event 654 // Return: void 655 struct btm_sec_link_key_request { 656 std::function<void(const RawAddress bda)> body{[](const RawAddress /* bda */) {}}; operatorbtm_sec_link_key_request657 void operator()(const RawAddress bda) { body(bda); } 658 }; 659 extern struct btm_sec_link_key_request btm_sec_link_key_request; 660 661 // Name: btm_sec_mx_access_request 662 // Params: const RawAddress& bd_addr, bool is_originator, uint16_t 663 // security_required, tBTM_SEC_CALLBACK* p_callback, void* p_ref_data Return: 664 // tBTM_STATUS 665 struct btm_sec_mx_access_request { 666 static tBTM_STATUS return_value; 667 std::function<tBTM_STATUS(const RawAddress& bd_addr, bool is_originator, 668 uint16_t security_required, tBTM_SEC_CALLBACK* p_callback, 669 void* p_ref_data)> 670 body{[](const RawAddress& /* bd_addr */, bool /* is_originator */, 671 uint16_t /* security_required */, tBTM_SEC_CALLBACK* /* p_callback */, 672 void* /* p_ref_data */) { return return_value; }}; operatorbtm_sec_mx_access_request673 tBTM_STATUS operator()(const RawAddress& bd_addr, bool is_originator, uint16_t security_required, 674 tBTM_SEC_CALLBACK* p_callback, void* p_ref_data) { 675 return body(bd_addr, is_originator, security_required, p_callback, p_ref_data); 676 } 677 }; 678 extern struct btm_sec_mx_access_request btm_sec_mx_access_request; 679 680 // Name: btm_sec_pin_code_request 681 // Params: const uint8_t* p_event 682 // Return: void 683 struct btm_sec_pin_code_request { 684 std::function<void(const RawAddress bda)> body{[](const RawAddress /* bda */) {}}; operatorbtm_sec_pin_code_request685 void operator()(const RawAddress bda) { body(bda); } 686 }; 687 extern struct btm_sec_pin_code_request btm_sec_pin_code_request; 688 689 // Name: btm_sec_rmt_host_support_feat_evt 690 // Params: const uint8_t* p 691 // Return: void 692 struct btm_sec_rmt_host_support_feat_evt { 693 std::function<void(const RawAddress bd_addr, uint8_t features_0)> body{ 694 [](const RawAddress /* bd_addr */, uint8_t /* features_0 */) {}}; operatorbtm_sec_rmt_host_support_feat_evt695 void operator()(const RawAddress bd_addr, uint8_t features_0) { body(bd_addr, features_0); } 696 }; 697 extern struct btm_sec_rmt_host_support_feat_evt btm_sec_rmt_host_support_feat_evt; 698 699 // Name: btm_sec_rmt_name_request_complete 700 // Params: const RawAddress* p_bd_addr, const uint8_t* p_bd_name, tHCI_STATUS 701 // status Return: void 702 struct btm_sec_rmt_name_request_complete { 703 std::function<void(const RawAddress* p_bd_addr, const uint8_t* p_bd_name, tHCI_STATUS status)> 704 body{[](const RawAddress* /* p_bd_addr */, const uint8_t* /* p_bd_name */, 705 tHCI_STATUS /* status */) {}}; operatorbtm_sec_rmt_name_request_complete706 void operator()(const RawAddress* p_bd_addr, const uint8_t* p_bd_name, tHCI_STATUS status) { 707 body(p_bd_addr, p_bd_name, status); 708 } 709 }; 710 extern struct btm_sec_rmt_name_request_complete btm_sec_rmt_name_request_complete; 711 712 // Name: btm_sec_role_changed 713 // Params: tHCI_STATUS hci_status, const RawAddress& bd_addr, tHCI_ROLE new_role 714 // Return: void 715 struct btm_sec_role_changed { 716 std::function<void(tHCI_STATUS hci_status, const RawAddress& bd_addr, tHCI_ROLE new_role)> body{ 717 [](tHCI_STATUS /* hci_status */, const RawAddress& /* bd_addr */, 718 tHCI_ROLE /* new_role */) {}}; operatorbtm_sec_role_changed719 void operator()(tHCI_STATUS hci_status, const RawAddress& bd_addr, tHCI_ROLE new_role) { 720 body(hci_status, bd_addr, new_role); 721 } 722 }; 723 extern struct btm_sec_role_changed btm_sec_role_changed; 724 725 // Name: btm_sec_set_peer_sec_caps 726 // Params: uint16_t hci_handle, bool ssp_supported, bool sc_supported, bool 727 // hci_role_switch_supported, bool br_edr_supported, bool le_supported Return: 728 // void 729 struct btm_sec_set_peer_sec_caps { 730 std::function<void(uint16_t hci_handle, bool ssp_supported, bool sc_supported, 731 bool hci_role_switch_supported, bool br_edr_supported, bool le_supported)> 732 body{[](uint16_t /* hci_handle */, bool /* ssp_supported */, bool /* sc_supported */, 733 bool /* hci_role_switch_supported */, bool /* br_edr_supported */, 734 bool /* le_supported */) {}}; operatorbtm_sec_set_peer_sec_caps735 void operator()(uint16_t hci_handle, bool ssp_supported, bool sc_supported, 736 bool hci_role_switch_supported, bool br_edr_supported, bool le_supported) { 737 body(hci_handle, ssp_supported, sc_supported, hci_role_switch_supported, br_edr_supported, 738 le_supported); 739 } 740 }; 741 extern struct btm_sec_set_peer_sec_caps btm_sec_set_peer_sec_caps; 742 743 // Name: btm_sec_update_clock_offset 744 // Params: uint16_t handle, uint16_t clock_offset 745 // Return: void 746 struct btm_sec_update_clock_offset { 747 std::function<void(uint16_t handle, uint16_t clock_offset)> body{ 748 [](uint16_t /* handle */, uint16_t /* clock_offset */) {}}; operatorbtm_sec_update_clock_offset749 void operator()(uint16_t handle, uint16_t clock_offset) { body(handle, clock_offset); } 750 }; 751 extern struct btm_sec_update_clock_offset btm_sec_update_clock_offset; 752 753 // Name: btm_simple_pair_complete 754 // Params: RawAddress bd_addr, uint8_t status 755 // Return: void 756 struct btm_simple_pair_complete { 757 std::function<void(const RawAddress bd_addr, uint8_t status)> body{ 758 [](const RawAddress /* bd_addr */, uint8_t /* status */) {}}; operatorbtm_simple_pair_complete759 void operator()(const RawAddress bd_addr, uint8_t status) { body(bd_addr, status); } 760 }; 761 extern struct btm_simple_pair_complete btm_simple_pair_complete; 762 763 // Name: BTM_IsRemoteNameKnown 764 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 765 // Return: bool 766 struct BTM_IsRemoteNameKnown { 767 static bool return_value; 768 std::function<bool(const RawAddress& bd_addr, tBT_TRANSPORT transport)> body{ 769 [](const RawAddress& /* bd_addr */, tBT_TRANSPORT /* transport */) { 770 return return_value; 771 }}; operatorBTM_IsRemoteNameKnown772 bool operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 773 return body(bd_addr, transport); 774 } 775 }; 776 extern struct BTM_IsRemoteNameKnown BTM_IsRemoteNameKnown; 777 778 } // namespace stack_btm_sec 779 } // namespace mock 780 } // namespace test 781 782 // END mockcify generation 783