1 /* 2 * Copyright 2021 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 17 /* 18 * Generated mock file from original source file 19 * Functions generated:125 20 * 21 * mockcify.pl ver 0.2.1 22 */ 23 24 #include <cstdint> 25 #include <functional> 26 #include <map> 27 #include <string> 28 29 // Original included files, if any 30 // NOTE: Since this is a mock file with mock definitions some number of 31 // include files may not be required. The include-what-you-use 32 // still applies, but crafting proper inclusion is out of scope 33 // for this effort. This compilation unit may compile as-is, or 34 // may need attention to prune the inclusion set. 35 #include <cstdint> 36 37 #include "device/include/controller.h" 38 #include "stack/acl/acl.h" 39 #include "stack/btm/security_device_record.h" 40 #include "stack/include/bt_hdr.h" 41 #include "stack/include/btm_client_interface.h" 42 #include "test/common/mock_functions.h" 43 #include "types/class_of_device.h" 44 #include "types/raw_address.h" 45 46 // Mocked compile conditionals, if any 47 #ifndef UNUSED_ATTR 48 #define UNUSED_ATTR 49 #endif 50 51 namespace test { 52 namespace mock { 53 namespace stack_acl { 54 55 // Shared state between mocked functions and tests 56 // Name: ACL_SupportTransparentSynchronousData 57 // Params: const RawAddress& bd_addr 58 // Returns: bool 59 struct ACL_SupportTransparentSynchronousData { 60 std::function<bool(const RawAddress& bd_addr)> body{ 61 [](const RawAddress& bd_addr) { return false; }}; operatorACL_SupportTransparentSynchronousData62 bool operator()(const RawAddress& bd_addr) { return body(bd_addr); }; 63 }; 64 extern struct ACL_SupportTransparentSynchronousData 65 ACL_SupportTransparentSynchronousData; 66 // Name: BTM_BLE_IS_RESOLVE_BDA 67 // Params: const RawAddress& x 68 // Returns: bool 69 struct BTM_BLE_IS_RESOLVE_BDA { 70 std::function<bool(const RawAddress& x)> body{ 71 [](const RawAddress& x) { return false; }}; operatorBTM_BLE_IS_RESOLVE_BDA72 bool operator()(const RawAddress& x) { return body(x); }; 73 }; 74 extern struct BTM_BLE_IS_RESOLVE_BDA BTM_BLE_IS_RESOLVE_BDA; 75 // Name: BTM_IsAclConnectionUp 76 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 77 // Returns: bool 78 struct BTM_IsAclConnectionUp { 79 std::function<bool(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 80 body{[](const RawAddress& remote_bda, tBT_TRANSPORT transport) { 81 return false; 82 }}; operatorBTM_IsAclConnectionUp83 bool operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 84 return body(remote_bda, transport); 85 }; 86 }; 87 extern struct BTM_IsAclConnectionUp BTM_IsAclConnectionUp; 88 // Name: BTM_IsAclConnectionUpAndHandleValid 89 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 90 // Returns: bool 91 struct BTM_IsAclConnectionUpAndHandleValid { 92 std::function<bool(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 93 body{[](const RawAddress& remote_bda, tBT_TRANSPORT transport) { 94 return false; 95 }}; operatorBTM_IsAclConnectionUpAndHandleValid96 bool operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 97 return body(remote_bda, transport); 98 }; 99 }; 100 extern struct BTM_IsAclConnectionUpAndHandleValid 101 BTM_IsAclConnectionUpAndHandleValid; 102 // Name: BTM_IsAclConnectionUpFromHandle 103 // Params: uint16_t hci_handle 104 // Returns: bool 105 struct BTM_IsAclConnectionUpFromHandle { 106 std::function<bool(uint16_t hci_handle)> body{ 107 [](uint16_t hci_handle) { return false; }}; operatorBTM_IsAclConnectionUpFromHandle108 bool operator()(uint16_t hci_handle) { return body(hci_handle); }; 109 }; 110 extern struct BTM_IsAclConnectionUpFromHandle BTM_IsAclConnectionUpFromHandle; 111 // Name: BTM_IsBleConnection 112 // Params: uint16_t hci_handle 113 // Returns: bool 114 struct BTM_IsBleConnection { 115 std::function<bool(uint16_t hci_handle)> body{ 116 [](uint16_t hci_handle) { return false; }}; operatorBTM_IsBleConnection117 bool operator()(uint16_t hci_handle) { return body(hci_handle); }; 118 }; 119 extern struct BTM_IsBleConnection BTM_IsBleConnection; 120 // Name: BTM_IsPhy2mSupported 121 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 122 // Returns: bool 123 struct BTM_IsPhy2mSupported { 124 std::function<bool(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 125 body{[](const RawAddress& remote_bda, tBT_TRANSPORT transport) { 126 return false; 127 }}; operatorBTM_IsPhy2mSupported128 bool operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 129 return body(remote_bda, transport); 130 }; 131 }; 132 extern struct BTM_IsPhy2mSupported BTM_IsPhy2mSupported; 133 // Name: BTM_ReadRemoteConnectionAddr 134 // Params: const RawAddress& pseudo_addr, RawAddress& conn_addr, 135 // tBLE_ADDR_TYPE* p_addr_type 136 // Returns: bool 137 struct BTM_ReadRemoteConnectionAddr { 138 std::function<bool(const RawAddress& pseudo_addr, RawAddress& conn_addr, 139 tBLE_ADDR_TYPE* p_addr_type)> 140 body{[](const RawAddress& pseudo_addr, RawAddress& conn_addr, 141 tBLE_ADDR_TYPE* p_addr_type) { return false; }}; operatorBTM_ReadRemoteConnectionAddr142 bool operator()(const RawAddress& pseudo_addr, RawAddress& conn_addr, 143 tBLE_ADDR_TYPE* p_addr_type) { 144 return body(pseudo_addr, conn_addr, p_addr_type); 145 }; 146 }; 147 extern struct BTM_ReadRemoteConnectionAddr BTM_ReadRemoteConnectionAddr; 148 // Name: BTM_ReadRemoteVersion 149 // Params: const RawAddress& addr, uint8_t* lmp_version, uint16_t* 150 // manufacturer, uint16_t* lmp_sub_version 151 // Returns: bool 152 struct BTM_ReadRemoteVersion { 153 std::function<bool(const RawAddress& addr, uint8_t* lmp_version, 154 uint16_t* manufacturer, uint16_t* lmp_sub_version)> 155 body{[](const RawAddress& addr, uint8_t* lmp_version, 156 uint16_t* manufacturer, 157 uint16_t* lmp_sub_version) { return false; }}; operatorBTM_ReadRemoteVersion158 bool operator()(const RawAddress& addr, uint8_t* lmp_version, 159 uint16_t* manufacturer, uint16_t* lmp_sub_version) { 160 return body(addr, lmp_version, manufacturer, lmp_sub_version); 161 }; 162 }; 163 extern struct BTM_ReadRemoteVersion BTM_ReadRemoteVersion; 164 // Name: BTM_is_sniff_allowed_for 165 // Params: const RawAddress& peer_addr 166 // Returns: bool 167 struct BTM_is_sniff_allowed_for { 168 std::function<bool(const RawAddress& peer_addr)> body{ 169 [](const RawAddress& peer_addr) { return false; }}; operatorBTM_is_sniff_allowed_for170 bool operator()(const RawAddress& peer_addr) { return body(peer_addr); }; 171 }; 172 extern struct BTM_is_sniff_allowed_for BTM_is_sniff_allowed_for; 173 // Name: acl_send_data_packet_br_edr 174 // Params: const RawAddress& bd_addr, BT_HDR* p_buf 175 // Returns: void 176 struct acl_send_data_packet_br_edr { 177 std::function<void(const RawAddress& bd_addr, BT_HDR* p_buf)> body{ 178 [](const RawAddress& bd_addr, BT_HDR* p_buf) {}}; operatoracl_send_data_packet_br_edr179 void operator()(const RawAddress& bd_addr, BT_HDR* p_buf) { 180 return body(bd_addr, p_buf); 181 }; 182 }; 183 extern struct acl_send_data_packet_br_edr acl_send_data_packet_br_edr; 184 // Name: acl_create_le_connection 185 // Params: const RawAddress& bd_addr 186 // Returns: bool 187 struct acl_create_le_connection { 188 std::function<bool(const RawAddress& bd_addr)> body{ 189 [](const RawAddress& bd_addr) { return false; }}; operatoracl_create_le_connection190 bool operator()(const RawAddress& bd_addr) { return body(bd_addr); }; 191 }; 192 extern struct acl_create_le_connection acl_create_le_connection; 193 // Name: acl_create_le_connection_with_id 194 // Params: uint8_t id, const RawAddress& bd_addr 195 // Returns: bool 196 struct acl_create_le_connection_with_id { 197 std::function<bool(uint8_t id, const RawAddress& bd_addr, 198 tBLE_ADDR_TYPE addr_type)> 199 body{[](uint8_t id, const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type) { 200 return false; 201 }}; operatoracl_create_le_connection_with_id202 bool operator()(uint8_t id, const RawAddress& bd_addr, 203 tBLE_ADDR_TYPE addr_type) { 204 return body(id, bd_addr, addr_type); 205 }; 206 }; 207 extern struct acl_create_le_connection_with_id acl_create_le_connection_with_id; 208 // Name: acl_is_role_switch_allowed 209 // Params: 210 // Returns: bool 211 struct acl_is_role_switch_allowed { 212 std::function<bool()> body{[]() { return false; }}; operatoracl_is_role_switch_allowed213 bool operator()() { return body(); }; 214 }; 215 extern struct acl_is_role_switch_allowed acl_is_role_switch_allowed; 216 // Name: acl_is_switch_role_idle 217 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 218 // Returns: bool 219 struct acl_is_switch_role_idle { 220 std::function<bool(const RawAddress& bd_addr, tBT_TRANSPORT transport)> body{ 221 [](const RawAddress& bd_addr, tBT_TRANSPORT transport) { return false; }}; operatoracl_is_switch_role_idle222 bool operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 223 return body(bd_addr, transport); 224 }; 225 }; 226 extern struct acl_is_switch_role_idle acl_is_switch_role_idle; 227 // Name: acl_peer_supports_ble_2m_phy 228 // Params: uint16_t hci_handle 229 // Returns: bool 230 struct acl_peer_supports_ble_2m_phy { 231 std::function<bool(uint16_t hci_handle)> body{ 232 [](uint16_t hci_handle) { return false; }}; operatoracl_peer_supports_ble_2m_phy233 bool operator()(uint16_t hci_handle) { return body(hci_handle); }; 234 }; 235 extern struct acl_peer_supports_ble_2m_phy acl_peer_supports_ble_2m_phy; 236 // Name: acl_peer_supports_ble_coded_phy 237 // Params: uint16_t hci_handle 238 // Returns: bool 239 struct acl_peer_supports_ble_coded_phy { 240 std::function<bool(uint16_t hci_handle)> body{ 241 [](uint16_t hci_handle) { return false; }}; operatoracl_peer_supports_ble_coded_phy242 bool operator()(uint16_t hci_handle) { return body(hci_handle); }; 243 }; 244 extern struct acl_peer_supports_ble_coded_phy acl_peer_supports_ble_coded_phy; 245 // Name: acl_peer_supports_ble_connection_parameters_request 246 // Params: const RawAddress& remote_bda 247 // Returns: bool 248 struct acl_peer_supports_ble_connection_parameters_request { 249 std::function<bool(const RawAddress& remote_bda)> body{ 250 [](const RawAddress& remote_bda) { return false; }}; operatoracl_peer_supports_ble_connection_parameters_request251 bool operator()(const RawAddress& remote_bda) { return body(remote_bda); }; 252 }; 253 extern struct acl_peer_supports_ble_connection_parameters_request 254 acl_peer_supports_ble_connection_parameters_request; 255 // Name: acl_peer_supports_ble_packet_extension 256 // Params: uint16_t hci_handle 257 // Returns: bool 258 struct acl_peer_supports_ble_packet_extension { 259 std::function<bool(uint16_t hci_handle)> body{ 260 [](uint16_t hci_handle) { return false; }}; operatoracl_peer_supports_ble_packet_extension261 bool operator()(uint16_t hci_handle) { return body(hci_handle); }; 262 }; 263 extern struct acl_peer_supports_ble_packet_extension 264 acl_peer_supports_ble_packet_extension; 265 // Name: acl_peer_supports_sniff_subrating 266 // Params: const RawAddress& remote_bda 267 // Returns: bool 268 struct acl_peer_supports_sniff_subrating { 269 std::function<bool(const RawAddress& remote_bda)> body{ 270 [](const RawAddress& remote_bda) { return false; }}; operatoracl_peer_supports_sniff_subrating271 bool operator()(const RawAddress& remote_bda) { return body(remote_bda); }; 272 }; 273 extern struct acl_peer_supports_sniff_subrating 274 acl_peer_supports_sniff_subrating; 275 // Name: acl_peer_supports_ble_connection_subrating 276 // Params: const RawAddress& remote_bda 277 // Returns: bool 278 struct acl_peer_supports_ble_connection_subrating { 279 std::function<bool(const RawAddress& remote_bda)> body{ 280 [](const RawAddress& remote_bda) { return false; }}; operatoracl_peer_supports_ble_connection_subrating281 bool operator()(const RawAddress& remote_bda) { return body(remote_bda); }; 282 }; 283 extern struct acl_peer_supports_ble_connection_subrating 284 acl_peer_supports_ble_connection_subrating; 285 // Name: acl_peer_supports_ble_connection_subrating_host 286 // Params: const RawAddress& remote_bda 287 // Returns: bool 288 struct acl_peer_supports_ble_connection_subrating_host { 289 std::function<bool(const RawAddress& remote_bda)> body{ 290 [](const RawAddress& remote_bda) { return false; }}; operatoracl_peer_supports_ble_connection_subrating_host291 bool operator()(const RawAddress& remote_bda) { return body(remote_bda); }; 292 }; 293 extern struct acl_peer_supports_ble_connection_subrating_host 294 acl_peer_supports_ble_connection_subrating_host; 295 // Name: acl_refresh_remote_address 296 // Params: const RawAddress& identity_address, tBLE_ADDR_TYPE 297 // identity_address_type, const RawAddress& bda, tBLE_ADDR_TYPE rra_type, 298 // const RawAddress& rpa Returns: bool 299 struct acl_refresh_remote_address { 300 std::function<bool( 301 const RawAddress& identity_address, tBLE_ADDR_TYPE identity_address_type, 302 const RawAddress& bda, tBTM_SEC_BLE::tADDRESS_TYPE rra_type, 303 const RawAddress& rpa)> 304 body{[](const RawAddress& identity_address, 305 tBLE_ADDR_TYPE identity_address_type, const RawAddress& bda, 306 tBTM_SEC_BLE::tADDRESS_TYPE rra_type, 307 const RawAddress& rpa) { return false; }}; operatoracl_refresh_remote_address308 bool operator()(const RawAddress& identity_address, 309 tBLE_ADDR_TYPE identity_address_type, const RawAddress& bda, 310 tBTM_SEC_BLE::tADDRESS_TYPE rra_type, const RawAddress& rpa) { 311 return body(identity_address, identity_address_type, bda, rra_type, rpa); 312 }; 313 }; 314 extern struct acl_refresh_remote_address acl_refresh_remote_address; 315 // Name: acl_set_peer_le_features_from_handle 316 // Params: uint16_t hci_handle, const uint8_t* p 317 // Returns: bool 318 struct acl_set_peer_le_features_from_handle { 319 std::function<bool(uint16_t hci_handle, const uint8_t* p)> body{ 320 [](uint16_t hci_handle, const uint8_t* p) { return false; }}; operatoracl_set_peer_le_features_from_handle321 bool operator()(uint16_t hci_handle, const uint8_t* p) { 322 return body(hci_handle, p); 323 }; 324 }; 325 extern struct acl_set_peer_le_features_from_handle 326 acl_set_peer_le_features_from_handle; 327 // Name: sco_peer_supports_esco_2m_phy 328 // Params: const RawAddress& remote_bda 329 // Returns: bool 330 struct sco_peer_supports_esco_2m_phy { 331 std::function<bool(const RawAddress& remote_bda)> body{ 332 [](const RawAddress& remote_bda) { return false; }}; operatorsco_peer_supports_esco_2m_phy333 bool operator()(const RawAddress& remote_bda) { return body(remote_bda); }; 334 }; 335 extern struct sco_peer_supports_esco_2m_phy sco_peer_supports_esco_2m_phy; 336 // Name: sco_peer_supports_esco_3m_phy 337 // Params: const RawAddress& remote_bda 338 // Returns: bool 339 struct sco_peer_supports_esco_3m_phy { 340 std::function<bool(const RawAddress& remote_bda)> body{ 341 [](const RawAddress& remote_bda) { return false; }}; operatorsco_peer_supports_esco_3m_phy342 bool operator()(const RawAddress& remote_bda) { return body(remote_bda); }; 343 }; 344 extern struct sco_peer_supports_esco_3m_phy sco_peer_supports_esco_3m_phy; 345 // Name: acl_create_classic_connection 346 // Params: const RawAddress& bd_addr, bool there_are_high_priority_channels, 347 // bool is_bonding Returns: constexpr uint16_t kDefaultPacketTypes = 348 // HCI_PKT_TYPES_MASK_DM1 | HCI_PKT_TYPES_MASK_DH1 | HCI_PKT_TYPES_MASK_DM3 | 349 // HCI_PKT_TYPES_MASK_DH3 | HCI_PKT_TYPES_MASK_DM5 | HCI_PKT_TYPES_MASK_DH5; 350 // void 351 struct acl_create_classic_connection { 352 std::function<void(const RawAddress& bd_addr, 353 bool there_are_high_priority_channels, bool is_bonding)> 354 body{[](const RawAddress& bd_addr, bool there_are_high_priority_channels, 355 bool is_bonding) { return 0; }}; operatoracl_create_classic_connection356 void operator()(const RawAddress& bd_addr, 357 bool there_are_high_priority_channels, bool is_bonding) { 358 return body(bd_addr, there_are_high_priority_channels, is_bonding); 359 }; 360 }; 361 extern struct acl_create_classic_connection acl_create_classic_connection; 362 // Name: IsEprAvailable 363 // Params: const tACL_CONN& p_acl 364 // Returns: inline bool 365 struct IsEprAvailable { 366 std::function<bool(const tACL_CONN& p_acl)> body{ 367 [](const tACL_CONN& p_acl) { return 0; }}; operatorIsEprAvailable368 inline bool operator()(const tACL_CONN& p_acl) { return body(p_acl); }; 369 }; 370 extern struct IsEprAvailable IsEprAvailable; 371 // Name: acl_get_connection_from_address 372 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 373 // Returns: tACL_CONN* 374 struct acl_get_connection_from_address { 375 std::function<tACL_CONN*(const RawAddress& bd_addr, tBT_TRANSPORT transport)> 376 body{[](const RawAddress& bd_addr, tBT_TRANSPORT transport) { 377 return nullptr; 378 }}; operatoracl_get_connection_from_address379 tACL_CONN* operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 380 return body(bd_addr, transport); 381 }; 382 }; 383 extern struct acl_get_connection_from_address acl_get_connection_from_address; 384 // Name: btm_acl_for_bda 385 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 386 // Returns: tACL_CONN* 387 struct btm_acl_for_bda { 388 std::function<tACL_CONN*(const RawAddress& bd_addr, tBT_TRANSPORT transport)> 389 body{[](const RawAddress& bd_addr, tBT_TRANSPORT transport) { 390 return nullptr; 391 }}; operatorbtm_acl_for_bda392 tACL_CONN* operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 393 return body(bd_addr, transport); 394 }; 395 }; 396 extern struct btm_acl_for_bda btm_acl_for_bda; 397 // Name: acl_get_connection_from_handle 398 // Params: uint16_t handle 399 // Returns: tACL_CONN* 400 struct acl_get_connection_from_handle { 401 std::function<tACL_CONN*(uint16_t handle)> body{ 402 [](uint16_t handle) { return nullptr; }}; operatoracl_get_connection_from_handle403 tACL_CONN* operator()(uint16_t handle) { return body(handle); }; 404 }; 405 extern struct acl_get_connection_from_handle acl_get_connection_from_handle; 406 // Name: BTM_GetLinkSuperTout 407 // Params: const RawAddress& remote_bda, uint16_t* p_timeout 408 // Returns: tBTM_STATUS 409 struct BTM_GetLinkSuperTout { 410 std::function<tBTM_STATUS(const RawAddress& remote_bda, uint16_t* p_timeout)> 411 body{[](const RawAddress& remote_bda, uint16_t* p_timeout) { return 0; }}; operatorBTM_GetLinkSuperTout412 tBTM_STATUS operator()(const RawAddress& remote_bda, uint16_t* p_timeout) { 413 return body(remote_bda, p_timeout); 414 }; 415 }; 416 extern struct BTM_GetLinkSuperTout BTM_GetLinkSuperTout; 417 // Name: BTM_GetRole 418 // Params: const RawAddress& remote_bd_addr, tHCI_ROLE* p_role 419 // Returns: tBTM_STATUS 420 struct BTM_GetRole { 421 std::function<tBTM_STATUS(const RawAddress& remote_bd_addr, 422 tHCI_ROLE* p_role)> 423 body{[](const RawAddress& remote_bd_addr, tHCI_ROLE* p_role) { 424 return 0; 425 }}; operatorBTM_GetRole426 tBTM_STATUS operator()(const RawAddress& remote_bd_addr, tHCI_ROLE* p_role) { 427 return body(remote_bd_addr, p_role); 428 }; 429 }; 430 extern struct BTM_GetRole BTM_GetRole; 431 // Name: BTM_ReadFailedContactCounter 432 // Params: const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb 433 // Returns: tBTM_STATUS 434 struct BTM_ReadFailedContactCounter { 435 std::function<tBTM_STATUS(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb)> 436 body{[](const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb) { return 0; }}; operatorBTM_ReadFailedContactCounter437 tBTM_STATUS operator()(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb) { 438 return body(remote_bda, p_cb); 439 }; 440 }; 441 extern struct BTM_ReadFailedContactCounter BTM_ReadFailedContactCounter; 442 // Name: BTM_ReadRSSI 443 // Params: const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb 444 // Returns: tBTM_STATUS 445 struct BTM_ReadRSSI { 446 std::function<tBTM_STATUS(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb)> 447 body{[](const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb) { return 0; }}; operatorBTM_ReadRSSI448 tBTM_STATUS operator()(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb) { 449 return body(remote_bda, p_cb); 450 }; 451 }; 452 extern struct BTM_ReadRSSI BTM_ReadRSSI; 453 // Name: BTM_ReadTxPower 454 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport, 455 // tBTM_CMPL_CB* p_cb Returns: tBTM_STATUS 456 struct BTM_ReadTxPower { 457 std::function<tBTM_STATUS(const RawAddress& remote_bda, 458 tBT_TRANSPORT transport, tBTM_CMPL_CB* p_cb)> 459 body{[](const RawAddress& remote_bda, tBT_TRANSPORT transport, 460 tBTM_CMPL_CB* p_cb) { return BT_TRANSPORT_BR_EDR; }}; operatorBTM_ReadTxPower461 tBTM_STATUS operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport, 462 tBTM_CMPL_CB* p_cb) { 463 return body(remote_bda, transport, p_cb); 464 }; 465 }; 466 extern struct BTM_ReadTxPower BTM_ReadTxPower; 467 // Name: BTM_SetLinkSuperTout 468 // Params: const RawAddress& remote_bda, uint16_t timeout 469 // Returns: tBTM_STATUS 470 struct BTM_SetLinkSuperTout { 471 std::function<tBTM_STATUS(const RawAddress& remote_bda, uint16_t timeout)> 472 body{[](const RawAddress& remote_bda, uint16_t timeout) { return 0; }}; operatorBTM_SetLinkSuperTout473 tBTM_STATUS operator()(const RawAddress& remote_bda, uint16_t timeout) { 474 return body(remote_bda, timeout); 475 }; 476 }; 477 extern struct BTM_SetLinkSuperTout BTM_SetLinkSuperTout; 478 // Name: BTM_SwitchRoleToCentral 479 // Params: const RawAddress& remote_bd_addr 480 // Returns: tBTM_STATUS 481 struct BTM_SwitchRoleToCentral { 482 std::function<tBTM_STATUS(const RawAddress& remote_bd_addr)> body{ 483 [](const RawAddress& remote_bd_addr) { return 0; }}; operatorBTM_SwitchRoleToCentral484 tBTM_STATUS operator()(const RawAddress& remote_bd_addr) { 485 return body(remote_bd_addr); 486 }; 487 }; 488 extern struct BTM_SwitchRoleToCentral BTM_SwitchRoleToCentral; 489 // Name: btm_remove_acl 490 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 491 // Returns: tBTM_STATUS 492 struct btm_remove_acl { 493 std::function<tBTM_STATUS(const RawAddress& bd_addr, tBT_TRANSPORT transport)> 494 body{[](const RawAddress& bd_addr, tBT_TRANSPORT transport) { 495 return BT_TRANSPORT_BR_EDR; 496 }}; operatorbtm_remove_acl497 tBTM_STATUS operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 498 return body(bd_addr, transport); 499 }; 500 }; 501 extern struct btm_remove_acl btm_remove_acl; 502 // Name: btm_get_acl_disc_reason_code 503 // Params: void 504 // Returns: tHCI_REASON 505 struct btm_get_acl_disc_reason_code { 506 std::function<tHCI_REASON(void)> body{[](void) { return HCI_SUCCESS; }}; operatorbtm_get_acl_disc_reason_code507 tHCI_REASON operator()(void) { return body(); }; 508 }; 509 extern struct btm_get_acl_disc_reason_code btm_get_acl_disc_reason_code; 510 // Name: btm_is_acl_locally_initiated 511 // Params: void 512 // Returns: bool 513 struct btm_is_acl_locally_initiated { 514 std::function<bool(void)> body{[](void) { return true; }}; operatorbtm_is_acl_locally_initiated515 bool operator()(void) { return body(); }; 516 }; 517 extern struct btm_is_acl_locally_initiated btm_is_acl_locally_initiated; 518 // Name: BTM_GetHCIConnHandle 519 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 520 // Returns: uint16_t 521 struct BTM_GetHCIConnHandle { 522 std::function<uint16_t(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 523 body{[](const RawAddress& remote_bda, tBT_TRANSPORT transport) { 524 return BT_TRANSPORT_BR_EDR; 525 }}; operatorBTM_GetHCIConnHandle526 uint16_t operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 527 return body(remote_bda, transport); 528 }; 529 }; 530 extern struct BTM_GetHCIConnHandle BTM_GetHCIConnHandle; 531 // Name: BTM_GetMaxPacketSize 532 // Params: const RawAddress& addr 533 // Returns: uint16_t 534 struct BTM_GetMaxPacketSize { 535 std::function<uint16_t(const RawAddress& addr)> body{ 536 [](const RawAddress& addr) { return 0; }}; operatorBTM_GetMaxPacketSize537 uint16_t operator()(const RawAddress& addr) { return body(addr); }; 538 }; 539 extern struct BTM_GetMaxPacketSize BTM_GetMaxPacketSize; 540 // Name: BTM_GetNumAclLinks 541 // Params: void 542 // Returns: uint16_t 543 struct BTM_GetNumAclLinks { 544 std::function<uint16_t(void)> body{[](void) { return 0; }}; operatorBTM_GetNumAclLinks545 uint16_t operator()(void) { return body(); }; 546 }; 547 extern struct BTM_GetNumAclLinks BTM_GetNumAclLinks; 548 // Name: acl_get_supported_packet_types 549 // Params: 550 // Returns: uint16_t 551 struct acl_get_supported_packet_types { 552 std::function<uint16_t()> body{[]() { return 0; }}; operatoracl_get_supported_packet_types553 uint16_t operator()() { return body(); }; 554 }; 555 extern struct acl_get_supported_packet_types acl_get_supported_packet_types; 556 // Name: BTM_GetPeerSCA 557 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 558 // Returns: uint8_t 559 struct BTM_GetPeerSCA { 560 std::function<uint8_t(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 561 body{[](const RawAddress& remote_bda, tBT_TRANSPORT transport) { 562 return BT_TRANSPORT_BR_EDR; 563 }}; operatorBTM_GetPeerSCA564 uint8_t operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 565 return body(remote_bda, transport); 566 }; 567 }; 568 extern struct BTM_GetPeerSCA BTM_GetPeerSCA; 569 // Name: BTM_SetTraceLevel 570 // Params: uint8_t new_level 571 // Returns: uint8_t 572 struct BTM_SetTraceLevel { 573 std::function<uint8_t(uint8_t new_level)> body{ 574 [](uint8_t new_level) { return 0; }}; operatorBTM_SetTraceLevel575 uint8_t operator()(uint8_t new_level) { return body(new_level); }; 576 }; 577 extern struct BTM_SetTraceLevel BTM_SetTraceLevel; 578 // Name: acl_link_role_from_handle 579 // Params: uint16_t handle 580 // Returns: uint8_t 581 struct acl_link_role_from_handle { 582 std::function<uint8_t(uint16_t handle)> body{ 583 [](uint16_t handle) { return 0; }}; operatoracl_link_role_from_handle584 uint8_t operator()(uint16_t handle) { return body(handle); }; 585 }; 586 extern struct acl_link_role_from_handle acl_link_role_from_handle; 587 // Name: btm_handle_to_acl_index 588 // Params: uint16_t hci_handle 589 // Returns: uint8_t 590 struct btm_handle_to_acl_index { 591 std::function<uint8_t(uint16_t hci_handle)> body{ 592 [](uint16_t hci_handle) { return 0; }}; operatorbtm_handle_to_acl_index593 uint8_t operator()(uint16_t hci_handle) { return body(hci_handle); }; 594 }; 595 extern struct btm_handle_to_acl_index btm_handle_to_acl_index; 596 // Name: BTM_ReadRemoteFeatures 597 // Params: const RawAddress& addr 598 // Returns: uint8_t* 599 struct BTM_ReadRemoteFeatures { 600 std::function<uint8_t*(const RawAddress& addr)> body{ 601 [](const RawAddress& addr) { return nullptr; }}; operatorBTM_ReadRemoteFeatures602 uint8_t* operator()(const RawAddress& addr) { return body(addr); }; 603 }; 604 extern struct BTM_ReadRemoteFeatures BTM_ReadRemoteFeatures; 605 // Name: ACL_RegisterClient 606 // Params: struct acl_client_callback_s* callbacks 607 // Returns: void 608 struct ACL_RegisterClient { 609 std::function<void(struct acl_client_callback_s* callbacks)> body{ 610 [](struct acl_client_callback_s* callbacks) { ; }}; operatorACL_RegisterClient611 void operator()(struct acl_client_callback_s* callbacks) { body(callbacks); }; 612 }; 613 extern struct ACL_RegisterClient ACL_RegisterClient; 614 // Name: ACL_UnregisterClient 615 // Params: struct acl_client_callback_s* callbacks 616 // Returns: void 617 struct ACL_UnregisterClient { 618 std::function<void(struct acl_client_callback_s* callbacks)> body{ 619 [](struct acl_client_callback_s* callbacks) { ; }}; operatorACL_UnregisterClient620 void operator()(struct acl_client_callback_s* callbacks) { body(callbacks); }; 621 }; 622 extern struct ACL_UnregisterClient ACL_UnregisterClient; 623 // Name: BTM_ReadConnectionAddr 624 // Params: const RawAddress& remote_bda, RawAddress& local_conn_addr, 625 // tBLE_ADDR_TYPE* p_addr_type Returns: void 626 struct BTM_ReadConnectionAddr { 627 std::function<void(const RawAddress& remote_bda, RawAddress& local_conn_addr, 628 tBLE_ADDR_TYPE* p_addr_type)> 629 body{[](const RawAddress& remote_bda, RawAddress& local_conn_addr, 630 tBLE_ADDR_TYPE* p_addr_type) { ; }}; operatorBTM_ReadConnectionAddr631 void operator()(const RawAddress& remote_bda, RawAddress& local_conn_addr, 632 tBLE_ADDR_TYPE* p_addr_type) { 633 body(remote_bda, local_conn_addr, p_addr_type); 634 }; 635 }; 636 extern struct BTM_ReadConnectionAddr BTM_ReadConnectionAddr; 637 // Name: BTM_RequestPeerSCA 638 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 639 // Returns: void 640 struct BTM_RequestPeerSCA { 641 std::function<void(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 642 body{[](const RawAddress& remote_bda, tBT_TRANSPORT transport) { ; }}; operatorBTM_RequestPeerSCA643 void operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 644 body(remote_bda, transport); 645 }; 646 }; 647 extern struct BTM_RequestPeerSCA BTM_RequestPeerSCA; 648 // Name: BTM_acl_after_controller_started 649 // Params: const controller_t* controller 650 // Returns: void 651 struct BTM_acl_after_controller_started { 652 std::function<void(const controller_t* controller)> body{ 653 [](const controller_t* controller) { ; }}; operatorBTM_acl_after_controller_started654 void operator()(const controller_t* controller) { body(controller); }; 655 }; 656 extern struct BTM_acl_after_controller_started BTM_acl_after_controller_started; 657 // Name: BTM_block_role_switch_for 658 // Params: const RawAddress& peer_addr 659 // Returns: void 660 struct BTM_block_role_switch_for { 661 std::function<void(const RawAddress& peer_addr)> body{ 662 [](const RawAddress& peer_addr) { ; }}; operatorBTM_block_role_switch_for663 void operator()(const RawAddress& peer_addr) { body(peer_addr); }; 664 }; 665 extern struct BTM_block_role_switch_for BTM_block_role_switch_for; 666 // Name: BTM_block_sniff_mode_for 667 // Params: const RawAddress& peer_addr 668 // Returns: void 669 struct BTM_block_sniff_mode_for { 670 std::function<void(const RawAddress& peer_addr)> body{ 671 [](const RawAddress& peer_addr) { ; }}; operatorBTM_block_sniff_mode_for672 void operator()(const RawAddress& peer_addr) { body(peer_addr); }; 673 }; 674 extern struct BTM_block_sniff_mode_for BTM_block_sniff_mode_for; 675 // Name: BTM_default_block_role_switch 676 // Params: 677 // Returns: void 678 struct BTM_default_block_role_switch { 679 std::function<void()> body{[]() { ; }}; operatorBTM_default_block_role_switch680 void operator()() { body(); }; 681 }; 682 extern struct BTM_default_block_role_switch BTM_default_block_role_switch; 683 // Name: BTM_default_unblock_role_switch 684 // Params: 685 // Returns: void 686 struct BTM_default_unblock_role_switch { 687 std::function<void()> body{[]() { ; }}; operatorBTM_default_unblock_role_switch688 void operator()() { body(); }; 689 }; 690 extern struct BTM_default_unblock_role_switch BTM_default_unblock_role_switch; 691 // Name: BTM_unblock_role_switch_for 692 // Params: const RawAddress& peer_addr 693 // Returns: void 694 struct BTM_unblock_role_switch_for { 695 std::function<void(const RawAddress& peer_addr)> body{ 696 [](const RawAddress& peer_addr) { ; }}; operatorBTM_unblock_role_switch_for697 void operator()(const RawAddress& peer_addr) { body(peer_addr); }; 698 }; 699 extern struct BTM_unblock_role_switch_for BTM_unblock_role_switch_for; 700 // Name: BTM_unblock_sniff_mode_for 701 // Params: const RawAddress& peer_addr 702 // Returns: void 703 struct BTM_unblock_sniff_mode_for { 704 std::function<void(const RawAddress& peer_addr)> body{ 705 [](const RawAddress& peer_addr) { ; }}; operatorBTM_unblock_sniff_mode_for706 void operator()(const RawAddress& peer_addr) { body(peer_addr); }; 707 }; 708 extern struct BTM_unblock_sniff_mode_for BTM_unblock_sniff_mode_for; 709 // Name: HACK_acl_check_sm4 710 // Params: tBTM_SEC_DEV_REC& record 711 // Returns: void 712 struct HACK_acl_check_sm4 { 713 std::function<void(tBTM_SEC_DEV_REC& record)> body{ 714 [](tBTM_SEC_DEV_REC& record) { ; }}; operatorHACK_acl_check_sm4715 void operator()(tBTM_SEC_DEV_REC& record) { body(record); }; 716 }; 717 extern struct HACK_acl_check_sm4 HACK_acl_check_sm4; 718 // Name: acl_accept_connection_request 719 // Params: const RawAddress& bd_addr, uint8_t role 720 // Returns: void 721 struct acl_accept_connection_request { 722 std::function<void(const RawAddress& bd_addr, uint8_t role)> body{ 723 [](const RawAddress& bd_addr, uint8_t role) { ; }}; operatoracl_accept_connection_request724 void operator()(const RawAddress& bd_addr, uint8_t role) { 725 body(bd_addr, role); 726 }; 727 }; 728 extern struct acl_accept_connection_request acl_accept_connection_request; 729 // Name: acl_disconnect_after_role_switch 730 // Params: uint16_t conn_handle, tHCI_STATUS reason 731 // Returns: void 732 struct acl_disconnect_after_role_switch { 733 std::function<void(uint16_t conn_handle, tHCI_STATUS reason, 734 std::string comment)> 735 body{[](uint16_t conn_handle, tHCI_STATUS reason, std::string comment) { 736 ; 737 }}; operatoracl_disconnect_after_role_switch738 void operator()(uint16_t conn_handle, tHCI_STATUS reason, 739 std::string comment) { 740 body(conn_handle, reason, comment); 741 }; 742 }; 743 extern struct acl_disconnect_after_role_switch acl_disconnect_after_role_switch; 744 // Name: acl_disconnect_from_handle 745 // Params: uint16_t handle, tHCI_STATUS reason 746 // Returns: void 747 struct acl_disconnect_from_handle { 748 std::function<void(uint16_t handle, tHCI_STATUS reason, std::string comment)> 749 body{[](uint16_t handle, tHCI_STATUS reason, std::string comment) { ; }}; operatoracl_disconnect_from_handle750 void operator()(uint16_t handle, tHCI_STATUS reason, std::string comment) { 751 body(handle, reason, comment); 752 }; 753 }; 754 extern struct acl_disconnect_from_handle acl_disconnect_from_handle; 755 // Name: acl_link_segments_xmitted 756 // Params: BT_HDR* p_msg 757 // Returns: void 758 struct acl_link_segments_xmitted { 759 std::function<void(BT_HDR* p_msg)> body{[](BT_HDR* p_msg) { ; }}; operatoracl_link_segments_xmitted760 void operator()(BT_HDR* p_msg) { body(p_msg); }; 761 }; 762 extern struct acl_link_segments_xmitted acl_link_segments_xmitted; 763 // Name: acl_packets_completed 764 // Params: uint16_t handle, uint16_t credits 765 // Returns: void 766 struct acl_packets_completed { 767 std::function<void(uint16_t handle, uint16_t credits)> body{ 768 [](uint16_t handle, uint16_t credits) { ; }}; operatoracl_packets_completed769 void operator()(uint16_t handle, uint16_t credits) { body(handle, credits); }; 770 }; 771 extern struct acl_packets_completed acl_packets_completed; 772 // Name: acl_process_extended_features 773 // Params: uint16_t handle, uint8_t current_page_number, uint8_t 774 // max_page_number, uint64_t features Returns: void 775 struct acl_process_extended_features { 776 std::function<void(uint16_t handle, uint8_t current_page_number, 777 uint8_t max_page_number, uint64_t features)> 778 body{[](uint16_t handle, uint8_t current_page_number, 779 uint8_t max_page_number, uint64_t features) { ; }}; operatoracl_process_extended_features780 void operator()(uint16_t handle, uint8_t current_page_number, 781 uint8_t max_page_number, uint64_t features) { 782 body(handle, current_page_number, max_page_number, features); 783 }; 784 }; 785 extern struct acl_process_extended_features acl_process_extended_features; 786 // Name: acl_process_supported_features 787 // Params: uint16_t handle, uint64_t features 788 // Returns: void 789 struct acl_process_supported_features { 790 std::function<void(uint16_t handle, uint64_t features)> body{ 791 [](uint16_t handle, uint64_t features) { ; }}; operatoracl_process_supported_features792 void operator()(uint16_t handle, uint64_t features) { 793 body(handle, features); 794 }; 795 }; 796 extern struct acl_process_supported_features acl_process_supported_features; 797 // Name: acl_rcv_acl_data 798 // Params: BT_HDR* p_msg 799 // Returns: void 800 struct acl_rcv_acl_data { 801 std::function<void(BT_HDR* p_msg)> body{[](BT_HDR* p_msg) { ; }}; operatoracl_rcv_acl_data802 void operator()(BT_HDR* p_msg) { body(p_msg); }; 803 }; 804 extern struct acl_rcv_acl_data acl_rcv_acl_data; 805 // Name: acl_reject_connection_request 806 // Params: const RawAddress& bd_addr, uint8_t reason 807 // Returns: void 808 struct acl_reject_connection_request { 809 std::function<void(const RawAddress& bd_addr, uint8_t reason)> body{ 810 [](const RawAddress& bd_addr, uint8_t reason) { ; }}; operatoracl_reject_connection_request811 void operator()(const RawAddress& bd_addr, uint8_t reason) { 812 body(bd_addr, reason); 813 }; 814 }; 815 extern struct acl_reject_connection_request acl_reject_connection_request; 816 // Name: acl_send_data_packet_ble 817 // Params: const RawAddress& bd_addr, BT_HDR* p_buf 818 // Returns: void 819 struct acl_send_data_packet_ble { 820 std::function<void(const RawAddress& bd_addr, BT_HDR* p_buf)> body{ 821 [](const RawAddress& bd_addr, BT_HDR* p_buf) { ; }}; operatoracl_send_data_packet_ble822 void operator()(const RawAddress& bd_addr, BT_HDR* p_buf) { 823 body(bd_addr, p_buf); 824 }; 825 }; 826 extern struct acl_send_data_packet_ble acl_send_data_packet_ble; 827 // Name: acl_set_disconnect_reason 828 // Params: tHCI_STATUS acl_disc_reason 829 // Returns: void 830 struct acl_set_disconnect_reason { 831 std::function<void(tHCI_STATUS acl_disc_reason)> body{ 832 [](tHCI_STATUS acl_disc_reason) { ; }}; operatoracl_set_disconnect_reason833 void operator()(tHCI_STATUS acl_disc_reason) { body(acl_disc_reason); }; 834 }; 835 extern struct acl_set_disconnect_reason acl_set_disconnect_reason; 836 // Name: acl_write_automatic_flush_timeout 837 // Params: const RawAddress& bd_addr, uint16_t flush_timeout_in_ticks 838 // Returns: void 839 struct acl_write_automatic_flush_timeout { 840 std::function<void(const RawAddress& bd_addr, 841 uint16_t flush_timeout_in_ticks)> 842 body{ 843 [](const RawAddress& bd_addr, uint16_t flush_timeout_in_ticks) { ; }}; operatoracl_write_automatic_flush_timeout844 void operator()(const RawAddress& bd_addr, uint16_t flush_timeout_in_ticks) { 845 body(bd_addr, flush_timeout_in_ticks); 846 }; 847 }; 848 extern struct acl_write_automatic_flush_timeout 849 acl_write_automatic_flush_timeout; 850 // Name: btm_acl_connected 851 // Params: const RawAddress& bda, uint16_t handle, tHCI_STATUS status, uint8_t 852 // enc_mode Returns: void 853 struct btm_acl_connected { 854 std::function<void(const RawAddress& bda, uint16_t handle, tHCI_STATUS status, 855 uint8_t enc_mode)> 856 body{[](const RawAddress& bda, uint16_t handle, tHCI_STATUS status, 857 uint8_t enc_mode) { ; }}; operatorbtm_acl_connected858 void operator()(const RawAddress& bda, uint16_t handle, tHCI_STATUS status, 859 uint8_t enc_mode) { 860 body(bda, handle, status, enc_mode); 861 }; 862 }; 863 extern struct btm_acl_connected btm_acl_connected; 864 // Name: btm_connection_request 865 // Params: const RawAddress& bda, const bluetooth::types::ClassOfDevice& cod 866 // Returns: void 867 struct btm_connection_request { 868 std::function<void(const RawAddress& bda, 869 const bluetooth::types::ClassOfDevice& cod)> 870 body{[](const RawAddress& bda, 871 const bluetooth::types::ClassOfDevice& cod) { ; }}; operatorbtm_connection_request872 void operator()(const RawAddress& bda, 873 const bluetooth::types::ClassOfDevice& cod) { 874 body(bda, cod); 875 }; 876 }; 877 extern struct btm_acl_connection_request btm_acl_connection_request; 878 // Name: btm_acl_connection_request 879 // Params: const RawAddress& bda, uint8_t* dc 880 // Returns: void 881 struct btm_acl_connection_request { 882 std::function<void(const RawAddress& bda, uint8_t* dc)> body{ 883 [](const RawAddress& bda, uint8_t* dc) { ; }}; operatorbtm_acl_connection_request884 void operator()(const RawAddress& bda, uint8_t* dc) { body(bda, dc); }; 885 }; 886 extern struct btm_acl_connection_request btm_acl_connection_request; 887 // Name: btm_acl_created 888 // Params: const RawAddress& bda, uint16_t hci_handle, tHCI_ROLE link_role, 889 // tBT_TRANSPORT transport Returns: void 890 struct btm_acl_created { 891 std::function<void(const RawAddress& bda, uint16_t hci_handle, 892 tHCI_ROLE link_role, tBT_TRANSPORT transport)> 893 body{[](const RawAddress& bda, uint16_t hci_handle, tHCI_ROLE link_role, 894 tBT_TRANSPORT transport) { ; }}; operatorbtm_acl_created895 void operator()(const RawAddress& bda, uint16_t hci_handle, 896 tHCI_ROLE link_role, tBT_TRANSPORT transport) { 897 body(bda, hci_handle, link_role, transport); 898 }; 899 }; 900 extern struct btm_acl_created btm_acl_created; 901 // Name: btm_acl_device_down 902 // Params: void 903 // Returns: void 904 struct btm_acl_device_down { 905 std::function<void(void)> body{[](void) { ; }}; operatorbtm_acl_device_down906 void operator()(void) { body(); }; 907 }; 908 extern struct btm_acl_device_down btm_acl_device_down; 909 // Name: btm_acl_disconnected 910 // Params: tHCI_STATUS status, uint16_t handle, tHCI_REASON reason 911 // Returns: void 912 struct btm_acl_disconnected { 913 std::function<void(tHCI_STATUS status, uint16_t handle, tHCI_REASON reason)> 914 body{[](tHCI_STATUS status, uint16_t handle, tHCI_REASON reason) { ; }}; operatorbtm_acl_disconnected915 void operator()(tHCI_STATUS status, uint16_t handle, tHCI_REASON reason) { 916 body(status, handle, reason); 917 }; 918 }; 919 extern struct btm_acl_disconnected btm_acl_disconnected; 920 // Name: btm_acl_iso_disconnected 921 // Params: uint16_t handle, tHCI_REASON reason 922 // Returns: void 923 struct btm_acl_iso_disconnected { 924 std::function<void(uint16_t handle, tHCI_REASON reason)> body{ 925 [](uint16_t handle, tHCI_REASON reason) { ; }}; operatorbtm_acl_iso_disconnected926 void operator()(uint16_t handle, tHCI_REASON reason) { 927 body(handle, reason); 928 }; 929 }; 930 extern struct btm_acl_iso_disconnected btm_acl_iso_disconnected; 931 // Name: btm_acl_encrypt_change 932 // Params: uint16_t handle, uint8_t status, uint8_t encr_enable 933 // Returns: void 934 struct btm_acl_encrypt_change { 935 std::function<void(uint16_t handle, uint8_t status, uint8_t encr_enable)> 936 body{[](uint16_t handle, uint8_t status, uint8_t encr_enable) { ; }}; operatorbtm_acl_encrypt_change937 void operator()(uint16_t handle, uint8_t status, uint8_t encr_enable) { 938 body(handle, status, encr_enable); 939 }; 940 }; 941 extern struct btm_acl_encrypt_change btm_acl_encrypt_change; 942 // Name: btm_acl_notif_conn_collision 943 // Params: const RawAddress& bda 944 // Returns: void 945 struct btm_acl_notif_conn_collision { 946 std::function<void(const RawAddress& bda)> body{ 947 [](const RawAddress& bda) { ; }}; operatorbtm_acl_notif_conn_collision948 void operator()(const RawAddress& bda) { body(bda); }; 949 }; 950 extern struct btm_acl_notif_conn_collision btm_acl_notif_conn_collision; 951 // Name: btm_acl_paging 952 // Params: BT_HDR* p, const RawAddress& bda 953 // Returns: void 954 struct btm_acl_paging { 955 std::function<void(BT_HDR* p, const RawAddress& bda)> body{ 956 [](BT_HDR* p, const RawAddress& bda) { ; }}; operatorbtm_acl_paging957 void operator()(BT_HDR* p, const RawAddress& bda) { body(p, bda); }; 958 }; 959 extern struct btm_acl_paging btm_acl_paging; 960 // Name: btm_acl_process_sca_cmpl_pkt 961 // Params: uint8_t len, uint8_t* data 962 // Returns: void 963 struct btm_acl_process_sca_cmpl_pkt { 964 std::function<void(uint8_t len, uint8_t* data)> body{ 965 [](uint8_t len, uint8_t* data) { ; }}; operatorbtm_acl_process_sca_cmpl_pkt966 void operator()(uint8_t len, uint8_t* data) { body(len, data); }; 967 }; 968 extern struct btm_acl_process_sca_cmpl_pkt btm_acl_process_sca_cmpl_pkt; 969 // Name: btm_acl_removed 970 // Params: uint16_t handle 971 // Returns: void 972 struct btm_acl_removed { 973 std::function<void(uint16_t handle)> body{[](uint16_t handle) { ; }}; operatorbtm_acl_removed974 void operator()(uint16_t handle) { body(handle); }; 975 }; 976 extern struct btm_acl_removed btm_acl_removed; 977 // Name: btm_acl_reset_paging 978 // Params: void 979 // Returns: void 980 struct btm_acl_reset_paging { 981 std::function<void(void)> body{[](void) { ; }}; operatorbtm_acl_reset_paging982 void operator()(void) { body(); }; 983 }; 984 extern struct btm_acl_reset_paging btm_acl_reset_paging; 985 // Name: btm_acl_resubmit_page 986 // Params: void 987 // Returns: void 988 struct btm_acl_resubmit_page { 989 std::function<void(void)> body{[](void) { ; }}; operatorbtm_acl_resubmit_page990 void operator()(void) { body(); }; 991 }; 992 extern struct btm_acl_resubmit_page btm_acl_resubmit_page; 993 // Name: btm_acl_role_changed 994 // Params: tHCI_STATUS hci_status, const RawAddress& bd_addr, tHCI_ROLE 995 // new_role Returns: void 996 struct btm_acl_role_changed { 997 std::function<void(tHCI_STATUS hci_status, const RawAddress& bd_addr, 998 tHCI_ROLE new_role)> 999 body{[](tHCI_STATUS hci_status, const RawAddress& bd_addr, 1000 tHCI_ROLE new_role) { ; }}; operatorbtm_acl_role_changed1001 void operator()(tHCI_STATUS hci_status, const RawAddress& bd_addr, 1002 tHCI_ROLE new_role) { 1003 body(hci_status, bd_addr, new_role); 1004 }; 1005 }; 1006 extern struct btm_acl_role_changed btm_acl_role_changed; 1007 // Name: btm_acl_set_paging 1008 // Params: bool value 1009 // Returns: void 1010 struct btm_acl_set_paging { 1011 std::function<void(bool value)> body{[](bool value) { ; }}; operatorbtm_acl_set_paging1012 void operator()(bool value) { body(value); }; 1013 }; 1014 extern struct btm_acl_set_paging btm_acl_set_paging; 1015 // Name: btm_acl_update_conn_addr 1016 // Params: uint16_t handle, const RawAddress& address 1017 // Returns: void 1018 struct btm_acl_update_conn_addr { 1019 std::function<void(uint16_t handle, const RawAddress& address)> body{ 1020 [](uint16_t handle, const RawAddress& address) { ; }}; operatorbtm_acl_update_conn_addr1021 void operator()(uint16_t handle, const RawAddress& address) { 1022 body(handle, address); 1023 }; 1024 }; 1025 extern struct btm_acl_update_conn_addr btm_acl_update_conn_addr; 1026 // Name: btm_configure_data_path 1027 // Params: uint8_t direction, uint8_t path_id, std::vector<uint8_t> 1028 // vendor_config Returns: void 1029 struct btm_configure_data_path { 1030 std::function<void(uint8_t direction, uint8_t path_id, 1031 std::vector<uint8_t> vendor_config)> 1032 body{[](uint8_t direction, uint8_t path_id, 1033 std::vector<uint8_t> vendor_config) { ; }}; operatorbtm_configure_data_path1034 void operator()(uint8_t direction, uint8_t path_id, 1035 std::vector<uint8_t> vendor_config) { 1036 body(direction, path_id, vendor_config); 1037 }; 1038 }; 1039 extern struct btm_configure_data_path btm_configure_data_path; 1040 // Name: btm_acl_update_inquiry_status 1041 // Params: uint8_t status 1042 // Returns: void 1043 struct btm_acl_update_inquiry_status { 1044 std::function<void(uint8_t status)> body{[](uint8_t status) { ; }}; operatorbtm_acl_update_inquiry_status1045 void operator()(uint8_t status) { body(status); }; 1046 }; 1047 extern struct btm_acl_update_inquiry_status btm_acl_update_inquiry_status; 1048 // Name: btm_ble_refresh_local_resolvable_private_addr 1049 // Params: const RawAddress& pseudo_addr, const RawAddress& local_rpa 1050 // Returns: void 1051 struct btm_ble_refresh_local_resolvable_private_addr { 1052 std::function<void(const RawAddress& pseudo_addr, 1053 const RawAddress& local_rpa)> 1054 body{ 1055 [](const RawAddress& pseudo_addr, const RawAddress& local_rpa) { ; }}; operatorbtm_ble_refresh_local_resolvable_private_addr1056 void operator()(const RawAddress& pseudo_addr, const RawAddress& local_rpa) { 1057 body(pseudo_addr, local_rpa); 1058 }; 1059 }; 1060 extern struct btm_ble_refresh_local_resolvable_private_addr 1061 btm_ble_refresh_local_resolvable_private_addr; 1062 // Name: btm_cont_rswitch_from_handle 1063 // Params: uint16_t hci_handle 1064 // Returns: void 1065 struct btm_cont_rswitch_from_handle { 1066 std::function<void(uint16_t hci_handle)> body{[](uint16_t hci_handle) { ; }}; operatorbtm_cont_rswitch_from_handle1067 void operator()(uint16_t hci_handle) { body(hci_handle); }; 1068 }; 1069 extern struct btm_cont_rswitch_from_handle btm_cont_rswitch_from_handle; 1070 // Name: btm_establish_continue_from_address 1071 // Params: const RawAddress& bda, tBT_TRANSPORT transport 1072 // Returns: void 1073 struct btm_establish_continue_from_address { 1074 std::function<void(const RawAddress& bda, tBT_TRANSPORT transport)> body{ 1075 [](const RawAddress& bda, tBT_TRANSPORT transport) { ; }}; operatorbtm_establish_continue_from_address1076 void operator()(const RawAddress& bda, tBT_TRANSPORT transport) { 1077 body(bda, transport); 1078 }; 1079 }; 1080 extern struct btm_establish_continue_from_address 1081 btm_establish_continue_from_address; 1082 // Name: btm_process_remote_ext_features 1083 // Params: tACL_CONN* p_acl_cb, uint8_t max_page_number 1084 // Returns: void 1085 struct btm_process_remote_ext_features { 1086 std::function<void(tACL_CONN* p_acl_cb, uint8_t max_page_number)> body{ 1087 [](tACL_CONN* p_acl_cb, uint8_t max_page_number) { ; }}; operatorbtm_process_remote_ext_features1088 void operator()(tACL_CONN* p_acl_cb, uint8_t max_page_number) { 1089 body(p_acl_cb, max_page_number); 1090 }; 1091 }; 1092 extern struct btm_process_remote_ext_features btm_process_remote_ext_features; 1093 // Name: btm_process_remote_version_complete 1094 // Params: uint8_t status, uint16_t handle, uint8_t lmp_version, uint16_t 1095 // manufacturer, uint16_t lmp_subversion Returns: void 1096 struct btm_process_remote_version_complete { 1097 std::function<void(uint8_t status, uint16_t handle, uint8_t lmp_version, 1098 uint16_t manufacturer, uint16_t lmp_subversion)> 1099 body{[](uint8_t status, uint16_t handle, uint8_t lmp_version, 1100 uint16_t manufacturer, uint16_t lmp_subversion) { ; }}; operatorbtm_process_remote_version_complete1101 void operator()(uint8_t status, uint16_t handle, uint8_t lmp_version, 1102 uint16_t manufacturer, uint16_t lmp_subversion) { 1103 body(status, handle, lmp_version, manufacturer, lmp_subversion); 1104 }; 1105 }; 1106 extern struct btm_process_remote_version_complete 1107 btm_process_remote_version_complete; 1108 // Name: btm_read_automatic_flush_timeout_complete 1109 // Params: uint8_t* p 1110 // Returns: void 1111 struct btm_read_automatic_flush_timeout_complete { 1112 std::function<void(uint8_t* p)> body{[](uint8_t* p) { ; }}; operatorbtm_read_automatic_flush_timeout_complete1113 void operator()(uint8_t* p) { body(p); }; 1114 }; 1115 extern struct btm_read_automatic_flush_timeout_complete 1116 btm_read_automatic_flush_timeout_complete; 1117 // Name: btm_read_failed_contact_counter_complete 1118 // Params: uint8_t* p 1119 // Returns: void 1120 struct btm_read_failed_contact_counter_complete { 1121 std::function<void(uint8_t* p)> body{[](uint8_t* p) { ; }}; operatorbtm_read_failed_contact_counter_complete1122 void operator()(uint8_t* p) { body(p); }; 1123 }; 1124 extern struct btm_read_failed_contact_counter_complete 1125 btm_read_failed_contact_counter_complete; 1126 // Name: btm_read_failed_contact_counter_timeout 1127 // Params: UNUSED_ATTR void* data 1128 // Returns: void 1129 struct btm_read_failed_contact_counter_timeout { 1130 std::function<void(UNUSED_ATTR void* data)> body{ 1131 [](UNUSED_ATTR void* data) { ; }}; operatorbtm_read_failed_contact_counter_timeout1132 void operator()(UNUSED_ATTR void* data) { body(data); }; 1133 }; 1134 extern struct btm_read_failed_contact_counter_timeout 1135 btm_read_failed_contact_counter_timeout; 1136 // Name: btm_read_link_quality_complete 1137 // Params: uint8_t* p 1138 // Returns: void 1139 struct btm_read_link_quality_complete { 1140 std::function<void(uint8_t* p, uint16_t evt_len)> body{[](uint8_t* p, uint16_t evt_len) { ; }}; operatorbtm_read_link_quality_complete1141 void operator()(uint8_t* p, uint16_t evt_len) { body(p, evt_len); }; 1142 }; 1143 extern struct btm_read_link_quality_complete btm_read_link_quality_complete; 1144 // Name: btm_read_link_quality_timeout 1145 // Params: UNUSED_ATTR void* data 1146 // Returns: void 1147 struct btm_read_link_quality_timeout { 1148 std::function<void(UNUSED_ATTR void* data)> body{ 1149 [](UNUSED_ATTR void* data) { ; }}; operatorbtm_read_link_quality_timeout1150 void operator()(UNUSED_ATTR void* data) { body(data); }; 1151 }; 1152 extern struct btm_read_link_quality_timeout btm_read_link_quality_timeout; 1153 // Name: btm_read_remote_ext_features 1154 // Params: uint16_t handle, uint8_t page_number 1155 // Returns: void 1156 struct btm_read_remote_ext_features { 1157 std::function<void(uint16_t handle, uint8_t page_number)> body{ 1158 [](uint16_t handle, uint8_t page_number) { ; }}; operatorbtm_read_remote_ext_features1159 void operator()(uint16_t handle, uint8_t page_number) { 1160 body(handle, page_number); 1161 }; 1162 }; 1163 extern struct btm_read_remote_ext_features btm_read_remote_ext_features; 1164 // Name: btm_read_remote_ext_features_complete 1165 // Params: uint16_t handle, uint8_t page_num, uint8_t max_page, uint8_t* 1166 // features Returns: void 1167 struct btm_read_remote_ext_features_complete { 1168 std::function<void(uint16_t handle, uint8_t page_num, uint8_t max_page, 1169 uint8_t* features)> 1170 body{[](uint16_t handle, uint8_t page_num, uint8_t max_page, 1171 uint8_t* features) { ; }}; operatorbtm_read_remote_ext_features_complete1172 void operator()(uint16_t handle, uint8_t page_num, uint8_t max_page, 1173 uint8_t* features) { 1174 body(handle, page_num, max_page, features); 1175 }; 1176 }; 1177 extern struct btm_read_remote_ext_features_complete 1178 btm_read_remote_ext_features_complete; 1179 // Name: btm_read_remote_ext_features_complete_raw 1180 // Params: uint8_t* p, uint8_t evt_len 1181 // Returns: void 1182 struct btm_read_remote_ext_features_complete_raw { 1183 std::function<void(uint8_t* p, uint8_t evt_len)> body{ 1184 [](uint8_t* p, uint8_t evt_len) { ; }}; operatorbtm_read_remote_ext_features_complete_raw1185 void operator()(uint8_t* p, uint8_t evt_len) { body(p, evt_len); }; 1186 }; 1187 extern struct btm_read_remote_ext_features_complete_raw 1188 btm_read_remote_ext_features_complete_raw; 1189 // Name: btm_read_remote_ext_features_failed 1190 // Params: uint8_t status, uint16_t handle 1191 // Returns: void 1192 struct btm_read_remote_ext_features_failed { 1193 std::function<void(uint8_t status, uint16_t handle)> body{ 1194 [](uint8_t status, uint16_t handle) { ; }}; operatorbtm_read_remote_ext_features_failed1195 void operator()(uint8_t status, uint16_t handle) { body(status, handle); }; 1196 }; 1197 extern struct btm_read_remote_ext_features_failed 1198 btm_read_remote_ext_features_failed; 1199 // Name: btm_read_remote_features_complete 1200 // Params: uint16_t handle, uint8_t* features 1201 // Returns: void 1202 struct btm_read_remote_features_complete { 1203 std::function<void(uint16_t handle, uint8_t* features)> body{ 1204 [](uint16_t handle, uint8_t* features) { ; }}; operatorbtm_read_remote_features_complete1205 void operator()(uint16_t handle, uint8_t* features) { 1206 body(handle, features); 1207 }; 1208 }; 1209 extern struct btm_read_remote_features_complete 1210 btm_read_remote_features_complete; 1211 // Name: btm_read_remote_version_complete 1212 // Params: tHCI_STATUS status, uint16_t handle, uint8_t lmp_version, uint16_t 1213 // manufacturer, uint16_t lmp_subversion Returns: void 1214 struct btm_read_remote_version_complete { 1215 std::function<void(tHCI_STATUS status, uint16_t handle, uint8_t lmp_version, 1216 uint16_t manufacturer, uint16_t lmp_subversion)> 1217 body{[](tHCI_STATUS status, uint16_t handle, uint8_t lmp_version, 1218 uint16_t manufacturer, uint16_t lmp_subversion) { ; }}; operatorbtm_read_remote_version_complete1219 void operator()(tHCI_STATUS status, uint16_t handle, uint8_t lmp_version, 1220 uint16_t manufacturer, uint16_t lmp_subversion) { 1221 body(status, handle, lmp_version, manufacturer, lmp_subversion); 1222 }; 1223 }; 1224 extern struct btm_read_remote_version_complete btm_read_remote_version_complete; 1225 // Name: btm_read_rssi_complete 1226 // Params: uint8_t* p 1227 // Returns: void 1228 struct btm_read_rssi_complete { 1229 std::function<void(uint8_t* p, uint16_t evt_len)> body{ 1230 [](uint8_t* pm, uint16_t evt_len) { ; }}; operatorbtm_read_rssi_complete1231 void operator()(uint8_t* p, uint16_t evt_len) { body(p, evt_len); }; 1232 }; 1233 extern struct btm_read_rssi_complete btm_read_rssi_complete; 1234 // Name: btm_read_rssi_timeout 1235 // Params: UNUSED_ATTR void* data 1236 // Returns: void 1237 struct btm_read_rssi_timeout { 1238 std::function<void(UNUSED_ATTR void* data)> body{ 1239 [](UNUSED_ATTR void* data) { ; }}; operatorbtm_read_rssi_timeout1240 void operator()(UNUSED_ATTR void* data) { body(data); }; 1241 }; 1242 extern struct btm_read_rssi_timeout btm_read_rssi_timeout; 1243 // Name: btm_read_tx_power_complete 1244 // Params: uint8_t* p, bool is_ble 1245 // Returns: void 1246 struct btm_read_tx_power_complete { 1247 std::function<void(uint8_t* p, uint16_t evt_len, bool is_ble)> body{ 1248 [](uint8_t* p, uint16_t evt_len, bool is_ble) { ; }}; operatorbtm_read_tx_power_complete1249 void operator()(uint8_t* p, uint16_t evt_len, bool is_ble) { 1250 body(p, evt_len, is_ble); 1251 }; 1252 }; 1253 extern struct btm_read_tx_power_complete btm_read_tx_power_complete; 1254 // Name: btm_read_tx_power_timeout 1255 // Params: UNUSED_ATTR void* data 1256 // Returns: void 1257 struct btm_read_tx_power_timeout { 1258 std::function<void(UNUSED_ATTR void* data)> body{ 1259 [](UNUSED_ATTR void* data) { ; }}; operatorbtm_read_tx_power_timeout1260 void operator()(UNUSED_ATTR void* data) { body(data); }; 1261 }; 1262 extern struct btm_read_tx_power_timeout btm_read_tx_power_timeout; 1263 // Name: btm_rejectlist_role_change_device 1264 // Params: const RawAddress& bd_addr, uint8_t hci_status 1265 // Returns: void 1266 struct btm_rejectlist_role_change_device { 1267 std::function<void(const RawAddress& bd_addr, uint8_t hci_status)> body{ 1268 [](const RawAddress& bd_addr, uint8_t hci_status) { ; }}; operatorbtm_rejectlist_role_change_device1269 void operator()(const RawAddress& bd_addr, uint8_t hci_status) { 1270 body(bd_addr, hci_status); 1271 }; 1272 }; 1273 extern struct btm_rejectlist_role_change_device 1274 btm_rejectlist_role_change_device; 1275 // Name: btm_set_link_policy 1276 // Params: tACL_CONN* conn, tLINK_POLICY policy 1277 // Returns: void 1278 struct btm_set_link_policy { 1279 std::function<void(tACL_CONN* conn, tLINK_POLICY policy)> body{ 1280 [](tACL_CONN* conn, tLINK_POLICY policy) { ; }}; operatorbtm_set_link_policy1281 void operator()(tACL_CONN* conn, tLINK_POLICY policy) { body(conn, policy); }; 1282 }; 1283 extern struct btm_set_link_policy btm_set_link_policy; 1284 // Name: btm_set_packet_types_from_address 1285 // Params: const RawAddress& bd_addr, uint16_t pkt_types 1286 // Returns: void 1287 struct btm_set_packet_types_from_address { 1288 std::function<void(const RawAddress& bd_addr, uint16_t pkt_types)> body{ 1289 [](const RawAddress& bd_addr, uint16_t pkt_types) { ; }}; operatorbtm_set_packet_types_from_address1290 void operator()(const RawAddress& bd_addr, uint16_t pkt_types) { 1291 body(bd_addr, pkt_types); 1292 }; 1293 }; 1294 extern struct btm_set_packet_types_from_address 1295 btm_set_packet_types_from_address; 1296 // Name: hci_btm_set_link_supervision_timeout 1297 // Params: tACL_CONN& link, uint16_t timeout 1298 // Returns: void 1299 struct hci_btm_set_link_supervision_timeout { 1300 std::function<void(tACL_CONN& link, uint16_t timeout)> body{ 1301 [](tACL_CONN& link, uint16_t timeout) { ; }}; operatorhci_btm_set_link_supervision_timeout1302 void operator()(tACL_CONN& link, uint16_t timeout) { body(link, timeout); }; 1303 }; 1304 extern struct hci_btm_set_link_supervision_timeout 1305 hci_btm_set_link_supervision_timeout; 1306 // Name: on_acl_br_edr_connected 1307 // Params: const RawAddress& bda, uint16_t handle, uint8_t enc_mode, bool 1308 // locally_initiated Returns: void 1309 struct on_acl_br_edr_connected { 1310 std::function<void(const RawAddress& bda, uint16_t handle, uint8_t enc_mode, 1311 bool locally_initiated)> 1312 body{[](const RawAddress& bda, uint16_t handle, uint8_t enc_mode, 1313 bool locally_initiated) { ; }}; operatoron_acl_br_edr_connected1314 void operator()(const RawAddress& bda, uint16_t handle, uint8_t enc_mode, 1315 bool locally_initiated) { 1316 body(bda, handle, enc_mode, locally_initiated); 1317 }; 1318 }; 1319 extern struct on_acl_br_edr_connected on_acl_br_edr_connected; 1320 // Name: on_acl_br_edr_failed 1321 // Params: const RawAddress& bda, tHCI_STATUS status, bool locally_initiated 1322 // Returns: void 1323 struct on_acl_br_edr_failed { 1324 std::function<void(const RawAddress& bda, tHCI_STATUS status, 1325 bool locally_initiated)> 1326 body{[](const RawAddress& bda, tHCI_STATUS status, 1327 bool locally_initiated) { ; }}; operatoron_acl_br_edr_failed1328 void operator()(const RawAddress& bda, tHCI_STATUS status, 1329 bool locally_initiated) { 1330 body(bda, status, locally_initiated); 1331 }; 1332 }; 1333 extern struct on_acl_br_edr_failed on_acl_br_edr_failed; 1334 1335 // Manually added 1336 struct BTM_unblock_role_switch_and_sniff_mode_for { 1337 std::function<void(const RawAddress& peer_addr)> body{ 1338 [](const RawAddress& peer_addr) {}}; operatorBTM_unblock_role_switch_and_sniff_mode_for1339 void operator()(const RawAddress& peer_addr) { body(peer_addr); }; 1340 }; 1341 extern struct BTM_unblock_role_switch_and_sniff_mode_for 1342 BTM_unblock_role_switch_and_sniff_mode_for; 1343 1344 } // namespace stack_acl 1345 } // namespace mock 1346 } // namespace test 1347 1348 // END mockcify generation 1349