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 extern std::map<std::string, int> mock_function_count_map; 30 31 // Original included files, if any 32 // NOTE: Since this is a mock file with mock definitions some number of 33 // include files may not be required. The include-what-you-use 34 // still applies, but crafting proper inclusion is out of scope 35 // for this effort. This compilation unit may compile as-is, or 36 // may need attention to prune the inclusion set. 37 #include <cstdint> 38 39 #include "device/include/controller.h" 40 #include "stack/acl/acl.h" 41 #include "stack/btm/security_device_record.h" 42 #include "stack/include/bt_hdr.h" 43 #include "stack/include/btm_client_interface.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)> body{ 198 [](uint8_t id, const RawAddress& bd_addr) { return false; }}; operatoracl_create_le_connection_with_id199 bool operator()(uint8_t id, const RawAddress& bd_addr) { 200 return body(id, bd_addr); 201 }; 202 }; 203 extern struct acl_create_le_connection_with_id acl_create_le_connection_with_id; 204 // Name: acl_is_role_switch_allowed 205 // Params: 206 // Returns: bool 207 struct acl_is_role_switch_allowed { 208 std::function<bool()> body{[]() { return false; }}; operatoracl_is_role_switch_allowed209 bool operator()() { return body(); }; 210 }; 211 extern struct acl_is_role_switch_allowed acl_is_role_switch_allowed; 212 // Name: acl_is_switch_role_idle 213 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 214 // Returns: bool 215 struct acl_is_switch_role_idle { 216 std::function<bool(const RawAddress& bd_addr, tBT_TRANSPORT transport)> body{ 217 [](const RawAddress& bd_addr, tBT_TRANSPORT transport) { return false; }}; operatoracl_is_switch_role_idle218 bool operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 219 return body(bd_addr, transport); 220 }; 221 }; 222 extern struct acl_is_switch_role_idle acl_is_switch_role_idle; 223 // Name: acl_peer_supports_ble_2m_phy 224 // Params: uint16_t hci_handle 225 // Returns: bool 226 struct acl_peer_supports_ble_2m_phy { 227 std::function<bool(uint16_t hci_handle)> body{ 228 [](uint16_t hci_handle) { return false; }}; operatoracl_peer_supports_ble_2m_phy229 bool operator()(uint16_t hci_handle) { return body(hci_handle); }; 230 }; 231 extern struct acl_peer_supports_ble_2m_phy acl_peer_supports_ble_2m_phy; 232 // Name: acl_peer_supports_ble_coded_phy 233 // Params: uint16_t hci_handle 234 // Returns: bool 235 struct acl_peer_supports_ble_coded_phy { 236 std::function<bool(uint16_t hci_handle)> body{ 237 [](uint16_t hci_handle) { return false; }}; operatoracl_peer_supports_ble_coded_phy238 bool operator()(uint16_t hci_handle) { return body(hci_handle); }; 239 }; 240 extern struct acl_peer_supports_ble_coded_phy acl_peer_supports_ble_coded_phy; 241 // Name: acl_peer_supports_ble_connection_parameters_request 242 // Params: const RawAddress& remote_bda 243 // Returns: bool 244 struct acl_peer_supports_ble_connection_parameters_request { 245 std::function<bool(const RawAddress& remote_bda)> body{ 246 [](const RawAddress& remote_bda) { return false; }}; operatoracl_peer_supports_ble_connection_parameters_request247 bool operator()(const RawAddress& remote_bda) { return body(remote_bda); }; 248 }; 249 extern struct acl_peer_supports_ble_connection_parameters_request 250 acl_peer_supports_ble_connection_parameters_request; 251 // Name: acl_peer_supports_ble_packet_extension 252 // Params: uint16_t hci_handle 253 // Returns: bool 254 struct acl_peer_supports_ble_packet_extension { 255 std::function<bool(uint16_t hci_handle)> body{ 256 [](uint16_t hci_handle) { return false; }}; operatoracl_peer_supports_ble_packet_extension257 bool operator()(uint16_t hci_handle) { return body(hci_handle); }; 258 }; 259 extern struct acl_peer_supports_ble_packet_extension 260 acl_peer_supports_ble_packet_extension; 261 // Name: acl_peer_supports_sniff_subrating 262 // Params: const RawAddress& remote_bda 263 // Returns: bool 264 struct acl_peer_supports_sniff_subrating { 265 std::function<bool(const RawAddress& remote_bda)> body{ 266 [](const RawAddress& remote_bda) { return false; }}; operatoracl_peer_supports_sniff_subrating267 bool operator()(const RawAddress& remote_bda) { return body(remote_bda); }; 268 }; 269 extern struct acl_peer_supports_sniff_subrating 270 acl_peer_supports_sniff_subrating; 271 // Name: acl_refresh_remote_address 272 // Params: const RawAddress& identity_address, tBLE_ADDR_TYPE 273 // identity_address_type, const RawAddress& bda, tBLE_ADDR_TYPE rra_type, 274 // const RawAddress& rpa Returns: bool 275 struct acl_refresh_remote_address { 276 std::function<bool( 277 const RawAddress& identity_address, tBLE_ADDR_TYPE identity_address_type, 278 const RawAddress& bda, tBTM_SEC_BLE::tADDRESS_TYPE rra_type, 279 const RawAddress& rpa)> 280 body{[](const RawAddress& identity_address, 281 tBLE_ADDR_TYPE identity_address_type, const RawAddress& bda, 282 tBTM_SEC_BLE::tADDRESS_TYPE rra_type, 283 const RawAddress& rpa) { return false; }}; operatoracl_refresh_remote_address284 bool operator()(const RawAddress& identity_address, 285 tBLE_ADDR_TYPE identity_address_type, const RawAddress& bda, 286 tBTM_SEC_BLE::tADDRESS_TYPE rra_type, const RawAddress& rpa) { 287 return body(identity_address, identity_address_type, bda, rra_type, rpa); 288 }; 289 }; 290 extern struct acl_refresh_remote_address acl_refresh_remote_address; 291 // Name: acl_set_peer_le_features_from_handle 292 // Params: uint16_t hci_handle, const uint8_t* p 293 // Returns: bool 294 struct acl_set_peer_le_features_from_handle { 295 std::function<bool(uint16_t hci_handle, const uint8_t* p)> body{ 296 [](uint16_t hci_handle, const uint8_t* p) { return false; }}; operatoracl_set_peer_le_features_from_handle297 bool operator()(uint16_t hci_handle, const uint8_t* p) { 298 return body(hci_handle, p); 299 }; 300 }; 301 extern struct acl_set_peer_le_features_from_handle 302 acl_set_peer_le_features_from_handle; 303 // Name: sco_peer_supports_esco_2m_phy 304 // Params: const RawAddress& remote_bda 305 // Returns: bool 306 struct sco_peer_supports_esco_2m_phy { 307 std::function<bool(const RawAddress& remote_bda)> body{ 308 [](const RawAddress& remote_bda) { return false; }}; operatorsco_peer_supports_esco_2m_phy309 bool operator()(const RawAddress& remote_bda) { return body(remote_bda); }; 310 }; 311 extern struct sco_peer_supports_esco_2m_phy sco_peer_supports_esco_2m_phy; 312 // Name: sco_peer_supports_esco_3m_phy 313 // Params: const RawAddress& remote_bda 314 // Returns: bool 315 struct sco_peer_supports_esco_3m_phy { 316 std::function<bool(const RawAddress& remote_bda)> body{ 317 [](const RawAddress& remote_bda) { return false; }}; operatorsco_peer_supports_esco_3m_phy318 bool operator()(const RawAddress& remote_bda) { return body(remote_bda); }; 319 }; 320 extern struct sco_peer_supports_esco_3m_phy sco_peer_supports_esco_3m_phy; 321 // Name: acl_create_classic_connection 322 // Params: const RawAddress& bd_addr, bool there_are_high_priority_channels, 323 // bool is_bonding Returns: constexpr uint16_t kDefaultPacketTypes = 324 // HCI_PKT_TYPES_MASK_DM1 | HCI_PKT_TYPES_MASK_DH1 | HCI_PKT_TYPES_MASK_DM3 | 325 // HCI_PKT_TYPES_MASK_DH3 | HCI_PKT_TYPES_MASK_DM5 | HCI_PKT_TYPES_MASK_DH5; 326 // void 327 struct acl_create_classic_connection { 328 std::function<void(const RawAddress& bd_addr, 329 bool there_are_high_priority_channels, bool is_bonding)> 330 body{[](const RawAddress& bd_addr, bool there_are_high_priority_channels, 331 bool is_bonding) { return 0; }}; operatoracl_create_classic_connection332 void operator()(const RawAddress& bd_addr, 333 bool there_are_high_priority_channels, bool is_bonding) { 334 return body(bd_addr, there_are_high_priority_channels, is_bonding); 335 }; 336 }; 337 extern struct acl_create_classic_connection acl_create_classic_connection; 338 // Name: IsEprAvailable 339 // Params: const tACL_CONN& p_acl 340 // Returns: inline bool 341 struct IsEprAvailable { 342 std::function<bool(const tACL_CONN& p_acl)> body{ 343 [](const tACL_CONN& p_acl) { return 0; }}; operatorIsEprAvailable344 inline bool operator()(const tACL_CONN& p_acl) { return body(p_acl); }; 345 }; 346 extern struct IsEprAvailable IsEprAvailable; 347 // Name: acl_get_connection_from_address 348 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 349 // Returns: tACL_CONN* 350 struct acl_get_connection_from_address { 351 std::function<tACL_CONN*(const RawAddress& bd_addr, tBT_TRANSPORT transport)> 352 body{[](const RawAddress& bd_addr, tBT_TRANSPORT transport) { 353 return nullptr; 354 }}; operatoracl_get_connection_from_address355 tACL_CONN* operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 356 return body(bd_addr, transport); 357 }; 358 }; 359 extern struct acl_get_connection_from_address acl_get_connection_from_address; 360 // Name: btm_acl_for_bda 361 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 362 // Returns: tACL_CONN* 363 struct btm_acl_for_bda { 364 std::function<tACL_CONN*(const RawAddress& bd_addr, tBT_TRANSPORT transport)> 365 body{[](const RawAddress& bd_addr, tBT_TRANSPORT transport) { 366 return nullptr; 367 }}; operatorbtm_acl_for_bda368 tACL_CONN* operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 369 return body(bd_addr, transport); 370 }; 371 }; 372 extern struct btm_acl_for_bda btm_acl_for_bda; 373 // Name: acl_get_connection_from_handle 374 // Params: uint16_t handle 375 // Returns: tACL_CONN* 376 struct acl_get_connection_from_handle { 377 std::function<tACL_CONN*(uint16_t handle)> body{ 378 [](uint16_t handle) { return nullptr; }}; operatoracl_get_connection_from_handle379 tACL_CONN* operator()(uint16_t handle) { return body(handle); }; 380 }; 381 extern struct acl_get_connection_from_handle acl_get_connection_from_handle; 382 // Name: BTM_GetLinkSuperTout 383 // Params: const RawAddress& remote_bda, uint16_t* p_timeout 384 // Returns: tBTM_STATUS 385 struct BTM_GetLinkSuperTout { 386 std::function<tBTM_STATUS(const RawAddress& remote_bda, uint16_t* p_timeout)> 387 body{[](const RawAddress& remote_bda, uint16_t* p_timeout) { return 0; }}; operatorBTM_GetLinkSuperTout388 tBTM_STATUS operator()(const RawAddress& remote_bda, uint16_t* p_timeout) { 389 return body(remote_bda, p_timeout); 390 }; 391 }; 392 extern struct BTM_GetLinkSuperTout BTM_GetLinkSuperTout; 393 // Name: BTM_GetRole 394 // Params: const RawAddress& remote_bd_addr, tHCI_ROLE* p_role 395 // Returns: tBTM_STATUS 396 struct BTM_GetRole { 397 std::function<tBTM_STATUS(const RawAddress& remote_bd_addr, 398 tHCI_ROLE* p_role)> 399 body{[](const RawAddress& remote_bd_addr, tHCI_ROLE* p_role) { 400 return 0; 401 }}; operatorBTM_GetRole402 tBTM_STATUS operator()(const RawAddress& remote_bd_addr, tHCI_ROLE* p_role) { 403 return body(remote_bd_addr, p_role); 404 }; 405 }; 406 extern struct BTM_GetRole BTM_GetRole; 407 // Name: BTM_ReadFailedContactCounter 408 // Params: const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb 409 // Returns: tBTM_STATUS 410 struct BTM_ReadFailedContactCounter { 411 std::function<tBTM_STATUS(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb)> 412 body{[](const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb) { return 0; }}; operatorBTM_ReadFailedContactCounter413 tBTM_STATUS operator()(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb) { 414 return body(remote_bda, p_cb); 415 }; 416 }; 417 extern struct BTM_ReadFailedContactCounter BTM_ReadFailedContactCounter; 418 // Name: BTM_ReadRSSI 419 // Params: const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb 420 // Returns: tBTM_STATUS 421 struct BTM_ReadRSSI { 422 std::function<tBTM_STATUS(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb)> 423 body{[](const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb) { return 0; }}; operatorBTM_ReadRSSI424 tBTM_STATUS operator()(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb) { 425 return body(remote_bda, p_cb); 426 }; 427 }; 428 extern struct BTM_ReadRSSI BTM_ReadRSSI; 429 // Name: BTM_ReadTxPower 430 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport, 431 // tBTM_CMPL_CB* p_cb Returns: tBTM_STATUS 432 struct BTM_ReadTxPower { 433 std::function<tBTM_STATUS(const RawAddress& remote_bda, 434 tBT_TRANSPORT transport, tBTM_CMPL_CB* p_cb)> 435 body{[](const RawAddress& remote_bda, tBT_TRANSPORT transport, 436 tBTM_CMPL_CB* p_cb) { return BT_TRANSPORT_BR_EDR; }}; operatorBTM_ReadTxPower437 tBTM_STATUS operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport, 438 tBTM_CMPL_CB* p_cb) { 439 return body(remote_bda, transport, p_cb); 440 }; 441 }; 442 extern struct BTM_ReadTxPower BTM_ReadTxPower; 443 // Name: BTM_SetLinkSuperTout 444 // Params: const RawAddress& remote_bda, uint16_t timeout 445 // Returns: tBTM_STATUS 446 struct BTM_SetLinkSuperTout { 447 std::function<tBTM_STATUS(const RawAddress& remote_bda, uint16_t timeout)> 448 body{[](const RawAddress& remote_bda, uint16_t timeout) { return 0; }}; operatorBTM_SetLinkSuperTout449 tBTM_STATUS operator()(const RawAddress& remote_bda, uint16_t timeout) { 450 return body(remote_bda, timeout); 451 }; 452 }; 453 extern struct BTM_SetLinkSuperTout BTM_SetLinkSuperTout; 454 // Name: BTM_SwitchRoleToCentral 455 // Params: const RawAddress& remote_bd_addr 456 // Returns: tBTM_STATUS 457 struct BTM_SwitchRoleToCentral { 458 std::function<tBTM_STATUS(const RawAddress& remote_bd_addr)> body{ 459 [](const RawAddress& remote_bd_addr) { return 0; }}; operatorBTM_SwitchRoleToCentral460 tBTM_STATUS operator()(const RawAddress& remote_bd_addr) { 461 return body(remote_bd_addr); 462 }; 463 }; 464 extern struct BTM_SwitchRoleToCentral BTM_SwitchRoleToCentral; 465 // Name: btm_remove_acl 466 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 467 // Returns: tBTM_STATUS 468 struct btm_remove_acl { 469 std::function<tBTM_STATUS(const RawAddress& bd_addr, tBT_TRANSPORT transport)> 470 body{[](const RawAddress& bd_addr, tBT_TRANSPORT transport) { 471 return BT_TRANSPORT_BR_EDR; 472 }}; operatorbtm_remove_acl473 tBTM_STATUS operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 474 return body(bd_addr, transport); 475 }; 476 }; 477 extern struct btm_remove_acl btm_remove_acl; 478 // Name: btm_get_acl_disc_reason_code 479 // Params: void 480 // Returns: tHCI_REASON 481 struct btm_get_acl_disc_reason_code { 482 std::function<tHCI_REASON(void)> body{[](void) { return HCI_SUCCESS; }}; operatorbtm_get_acl_disc_reason_code483 tHCI_REASON operator()(void) { return body(); }; 484 }; 485 extern struct btm_get_acl_disc_reason_code btm_get_acl_disc_reason_code; 486 // Name: BTM_GetHCIConnHandle 487 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 488 // Returns: uint16_t 489 struct BTM_GetHCIConnHandle { 490 std::function<uint16_t(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 491 body{[](const RawAddress& remote_bda, tBT_TRANSPORT transport) { 492 return BT_TRANSPORT_BR_EDR; 493 }}; operatorBTM_GetHCIConnHandle494 uint16_t operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 495 return body(remote_bda, transport); 496 }; 497 }; 498 extern struct BTM_GetHCIConnHandle BTM_GetHCIConnHandle; 499 // Name: BTM_GetMaxPacketSize 500 // Params: const RawAddress& addr 501 // Returns: uint16_t 502 struct BTM_GetMaxPacketSize { 503 std::function<uint16_t(const RawAddress& addr)> body{ 504 [](const RawAddress& addr) { return 0; }}; operatorBTM_GetMaxPacketSize505 uint16_t operator()(const RawAddress& addr) { return body(addr); }; 506 }; 507 extern struct BTM_GetMaxPacketSize BTM_GetMaxPacketSize; 508 // Name: BTM_GetNumAclLinks 509 // Params: void 510 // Returns: uint16_t 511 struct BTM_GetNumAclLinks { 512 std::function<uint16_t(void)> body{[](void) { return 0; }}; operatorBTM_GetNumAclLinks513 uint16_t operator()(void) { return body(); }; 514 }; 515 extern struct BTM_GetNumAclLinks BTM_GetNumAclLinks; 516 // Name: acl_get_supported_packet_types 517 // Params: 518 // Returns: uint16_t 519 struct acl_get_supported_packet_types { 520 std::function<uint16_t()> body{[]() { return 0; }}; operatoracl_get_supported_packet_types521 uint16_t operator()() { return body(); }; 522 }; 523 extern struct acl_get_supported_packet_types acl_get_supported_packet_types; 524 // Name: BTM_GetPeerSCA 525 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 526 // Returns: uint8_t 527 struct BTM_GetPeerSCA { 528 std::function<uint8_t(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 529 body{[](const RawAddress& remote_bda, tBT_TRANSPORT transport) { 530 return BT_TRANSPORT_BR_EDR; 531 }}; operatorBTM_GetPeerSCA532 uint8_t operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 533 return body(remote_bda, transport); 534 }; 535 }; 536 extern struct BTM_GetPeerSCA BTM_GetPeerSCA; 537 // Name: BTM_SetTraceLevel 538 // Params: uint8_t new_level 539 // Returns: uint8_t 540 struct BTM_SetTraceLevel { 541 std::function<uint8_t(uint8_t new_level)> body{ 542 [](uint8_t new_level) { return 0; }}; operatorBTM_SetTraceLevel543 uint8_t operator()(uint8_t new_level) { return body(new_level); }; 544 }; 545 extern struct BTM_SetTraceLevel BTM_SetTraceLevel; 546 // Name: acl_link_role_from_handle 547 // Params: uint16_t handle 548 // Returns: uint8_t 549 struct acl_link_role_from_handle { 550 std::function<uint8_t(uint16_t handle)> body{ 551 [](uint16_t handle) { return 0; }}; operatoracl_link_role_from_handle552 uint8_t operator()(uint16_t handle) { return body(handle); }; 553 }; 554 extern struct acl_link_role_from_handle acl_link_role_from_handle; 555 // Name: btm_handle_to_acl_index 556 // Params: uint16_t hci_handle 557 // Returns: uint8_t 558 struct btm_handle_to_acl_index { 559 std::function<uint8_t(uint16_t hci_handle)> body{ 560 [](uint16_t hci_handle) { return 0; }}; operatorbtm_handle_to_acl_index561 uint8_t operator()(uint16_t hci_handle) { return body(hci_handle); }; 562 }; 563 extern struct btm_handle_to_acl_index btm_handle_to_acl_index; 564 // Name: BTM_ReadRemoteFeatures 565 // Params: const RawAddress& addr 566 // Returns: uint8_t* 567 struct BTM_ReadRemoteFeatures { 568 std::function<uint8_t*(const RawAddress& addr)> body{ 569 [](const RawAddress& addr) { return nullptr; }}; operatorBTM_ReadRemoteFeatures570 uint8_t* operator()(const RawAddress& addr) { return body(addr); }; 571 }; 572 extern struct BTM_ReadRemoteFeatures BTM_ReadRemoteFeatures; 573 // Name: ACL_RegisterClient 574 // Params: struct acl_client_callback_s* callbacks 575 // Returns: void 576 struct ACL_RegisterClient { 577 std::function<void(struct acl_client_callback_s* callbacks)> body{ 578 [](struct acl_client_callback_s* callbacks) { ; }}; operatorACL_RegisterClient579 void operator()(struct acl_client_callback_s* callbacks) { body(callbacks); }; 580 }; 581 extern struct ACL_RegisterClient ACL_RegisterClient; 582 // Name: ACL_UnregisterClient 583 // Params: struct acl_client_callback_s* callbacks 584 // Returns: void 585 struct ACL_UnregisterClient { 586 std::function<void(struct acl_client_callback_s* callbacks)> body{ 587 [](struct acl_client_callback_s* callbacks) { ; }}; operatorACL_UnregisterClient588 void operator()(struct acl_client_callback_s* callbacks) { body(callbacks); }; 589 }; 590 extern struct ACL_UnregisterClient ACL_UnregisterClient; 591 // Name: BTM_ReadConnectionAddr 592 // Params: const RawAddress& remote_bda, RawAddress& local_conn_addr, 593 // tBLE_ADDR_TYPE* p_addr_type Returns: void 594 struct BTM_ReadConnectionAddr { 595 std::function<void(const RawAddress& remote_bda, RawAddress& local_conn_addr, 596 tBLE_ADDR_TYPE* p_addr_type)> 597 body{[](const RawAddress& remote_bda, RawAddress& local_conn_addr, 598 tBLE_ADDR_TYPE* p_addr_type) { ; }}; operatorBTM_ReadConnectionAddr599 void operator()(const RawAddress& remote_bda, RawAddress& local_conn_addr, 600 tBLE_ADDR_TYPE* p_addr_type) { 601 body(remote_bda, local_conn_addr, p_addr_type); 602 }; 603 }; 604 extern struct BTM_ReadConnectionAddr BTM_ReadConnectionAddr; 605 // Name: BTM_RequestPeerSCA 606 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 607 // Returns: void 608 struct BTM_RequestPeerSCA { 609 std::function<void(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 610 body{[](const RawAddress& remote_bda, tBT_TRANSPORT transport) { ; }}; operatorBTM_RequestPeerSCA611 void operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 612 body(remote_bda, transport); 613 }; 614 }; 615 extern struct BTM_RequestPeerSCA BTM_RequestPeerSCA; 616 // Name: BTM_acl_after_controller_started 617 // Params: const controller_t* controller 618 // Returns: void 619 struct BTM_acl_after_controller_started { 620 std::function<void(const controller_t* controller)> body{ 621 [](const controller_t* controller) { ; }}; operatorBTM_acl_after_controller_started622 void operator()(const controller_t* controller) { body(controller); }; 623 }; 624 extern struct BTM_acl_after_controller_started BTM_acl_after_controller_started; 625 // Name: BTM_block_role_switch_for 626 // Params: const RawAddress& peer_addr 627 // Returns: void 628 struct BTM_block_role_switch_for { 629 std::function<void(const RawAddress& peer_addr)> body{ 630 [](const RawAddress& peer_addr) { ; }}; operatorBTM_block_role_switch_for631 void operator()(const RawAddress& peer_addr) { body(peer_addr); }; 632 }; 633 extern struct BTM_block_role_switch_for BTM_block_role_switch_for; 634 // Name: BTM_block_sniff_mode_for 635 // Params: const RawAddress& peer_addr 636 // Returns: void 637 struct BTM_block_sniff_mode_for { 638 std::function<void(const RawAddress& peer_addr)> body{ 639 [](const RawAddress& peer_addr) { ; }}; operatorBTM_block_sniff_mode_for640 void operator()(const RawAddress& peer_addr) { body(peer_addr); }; 641 }; 642 extern struct BTM_block_sniff_mode_for BTM_block_sniff_mode_for; 643 // Name: BTM_default_block_role_switch 644 // Params: 645 // Returns: void 646 struct BTM_default_block_role_switch { 647 std::function<void()> body{[]() { ; }}; operatorBTM_default_block_role_switch648 void operator()() { body(); }; 649 }; 650 extern struct BTM_default_block_role_switch BTM_default_block_role_switch; 651 // Name: BTM_default_unblock_role_switch 652 // Params: 653 // Returns: void 654 struct BTM_default_unblock_role_switch { 655 std::function<void()> body{[]() { ; }}; operatorBTM_default_unblock_role_switch656 void operator()() { body(); }; 657 }; 658 extern struct BTM_default_unblock_role_switch BTM_default_unblock_role_switch; 659 // Name: BTM_unblock_role_switch_for 660 // Params: const RawAddress& peer_addr 661 // Returns: void 662 struct BTM_unblock_role_switch_for { 663 std::function<void(const RawAddress& peer_addr)> body{ 664 [](const RawAddress& peer_addr) { ; }}; operatorBTM_unblock_role_switch_for665 void operator()(const RawAddress& peer_addr) { body(peer_addr); }; 666 }; 667 extern struct BTM_unblock_role_switch_for BTM_unblock_role_switch_for; 668 // Name: BTM_unblock_sniff_mode_for 669 // Params: const RawAddress& peer_addr 670 // Returns: void 671 struct BTM_unblock_sniff_mode_for { 672 std::function<void(const RawAddress& peer_addr)> body{ 673 [](const RawAddress& peer_addr) { ; }}; operatorBTM_unblock_sniff_mode_for674 void operator()(const RawAddress& peer_addr) { body(peer_addr); }; 675 }; 676 extern struct BTM_unblock_sniff_mode_for BTM_unblock_sniff_mode_for; 677 // Name: HACK_acl_check_sm4 678 // Params: tBTM_SEC_DEV_REC& record 679 // Returns: void 680 struct HACK_acl_check_sm4 { 681 std::function<void(tBTM_SEC_DEV_REC& record)> body{ 682 [](tBTM_SEC_DEV_REC& record) { ; }}; operatorHACK_acl_check_sm4683 void operator()(tBTM_SEC_DEV_REC& record) { body(record); }; 684 }; 685 extern struct HACK_acl_check_sm4 HACK_acl_check_sm4; 686 // Name: acl_accept_connection_request 687 // Params: const RawAddress& bd_addr, uint8_t role 688 // Returns: void 689 struct acl_accept_connection_request { 690 std::function<void(const RawAddress& bd_addr, uint8_t role)> body{ 691 [](const RawAddress& bd_addr, uint8_t role) { ; }}; operatoracl_accept_connection_request692 void operator()(const RawAddress& bd_addr, uint8_t role) { 693 body(bd_addr, role); 694 }; 695 }; 696 extern struct acl_accept_connection_request acl_accept_connection_request; 697 // Name: acl_disconnect_after_role_switch 698 // Params: uint16_t conn_handle, tHCI_STATUS reason 699 // Returns: void 700 struct acl_disconnect_after_role_switch { 701 std::function<void(uint16_t conn_handle, tHCI_STATUS reason, 702 std::string comment)> 703 body{[](uint16_t conn_handle, tHCI_STATUS reason, std::string comment) { 704 ; 705 }}; operatoracl_disconnect_after_role_switch706 void operator()(uint16_t conn_handle, tHCI_STATUS reason, 707 std::string comment) { 708 body(conn_handle, reason, comment); 709 }; 710 }; 711 extern struct acl_disconnect_after_role_switch acl_disconnect_after_role_switch; 712 // Name: acl_disconnect_from_handle 713 // Params: uint16_t handle, tHCI_STATUS reason 714 // Returns: void 715 struct acl_disconnect_from_handle { 716 std::function<void(uint16_t handle, tHCI_STATUS reason, std::string comment)> 717 body{[](uint16_t handle, tHCI_STATUS reason, std::string comment) { ; }}; operatoracl_disconnect_from_handle718 void operator()(uint16_t handle, tHCI_STATUS reason, std::string comment) { 719 body(handle, reason, comment); 720 }; 721 }; 722 extern struct acl_disconnect_from_handle acl_disconnect_from_handle; 723 // Name: acl_link_segments_xmitted 724 // Params: BT_HDR* p_msg 725 // Returns: void 726 struct acl_link_segments_xmitted { 727 std::function<void(BT_HDR* p_msg)> body{[](BT_HDR* p_msg) { ; }}; operatoracl_link_segments_xmitted728 void operator()(BT_HDR* p_msg) { body(p_msg); }; 729 }; 730 extern struct acl_link_segments_xmitted acl_link_segments_xmitted; 731 // Name: acl_packets_completed 732 // Params: uint16_t handle, uint16_t credits 733 // Returns: void 734 struct acl_packets_completed { 735 std::function<void(uint16_t handle, uint16_t credits)> body{ 736 [](uint16_t handle, uint16_t credits) { ; }}; operatoracl_packets_completed737 void operator()(uint16_t handle, uint16_t credits) { body(handle, credits); }; 738 }; 739 extern struct acl_packets_completed acl_packets_completed; 740 // Name: acl_process_extended_features 741 // Params: uint16_t handle, uint8_t current_page_number, uint8_t 742 // max_page_number, uint64_t features Returns: void 743 struct acl_process_extended_features { 744 std::function<void(uint16_t handle, uint8_t current_page_number, 745 uint8_t max_page_number, uint64_t features)> 746 body{[](uint16_t handle, uint8_t current_page_number, 747 uint8_t max_page_number, uint64_t features) { ; }}; operatoracl_process_extended_features748 void operator()(uint16_t handle, uint8_t current_page_number, 749 uint8_t max_page_number, uint64_t features) { 750 body(handle, current_page_number, max_page_number, features); 751 }; 752 }; 753 extern struct acl_process_extended_features acl_process_extended_features; 754 // Name: acl_process_supported_features 755 // Params: uint16_t handle, uint64_t features 756 // Returns: void 757 struct acl_process_supported_features { 758 std::function<void(uint16_t handle, uint64_t features)> body{ 759 [](uint16_t handle, uint64_t features) { ; }}; operatoracl_process_supported_features760 void operator()(uint16_t handle, uint64_t features) { 761 body(handle, features); 762 }; 763 }; 764 extern struct acl_process_supported_features acl_process_supported_features; 765 // Name: acl_rcv_acl_data 766 // Params: BT_HDR* p_msg 767 // Returns: void 768 struct acl_rcv_acl_data { 769 std::function<void(BT_HDR* p_msg)> body{[](BT_HDR* p_msg) { ; }}; operatoracl_rcv_acl_data770 void operator()(BT_HDR* p_msg) { body(p_msg); }; 771 }; 772 extern struct acl_rcv_acl_data acl_rcv_acl_data; 773 // Name: acl_reject_connection_request 774 // Params: const RawAddress& bd_addr, uint8_t reason 775 // Returns: void 776 struct acl_reject_connection_request { 777 std::function<void(const RawAddress& bd_addr, uint8_t reason)> body{ 778 [](const RawAddress& bd_addr, uint8_t reason) { ; }}; operatoracl_reject_connection_request779 void operator()(const RawAddress& bd_addr, uint8_t reason) { 780 body(bd_addr, reason); 781 }; 782 }; 783 extern struct acl_reject_connection_request acl_reject_connection_request; 784 // Name: acl_send_data_packet_ble 785 // Params: const RawAddress& bd_addr, BT_HDR* p_buf 786 // Returns: void 787 struct acl_send_data_packet_ble { 788 std::function<void(const RawAddress& bd_addr, BT_HDR* p_buf)> body{ 789 [](const RawAddress& bd_addr, BT_HDR* p_buf) { ; }}; operatoracl_send_data_packet_ble790 void operator()(const RawAddress& bd_addr, BT_HDR* p_buf) { 791 body(bd_addr, p_buf); 792 }; 793 }; 794 extern struct acl_send_data_packet_ble acl_send_data_packet_ble; 795 // Name: acl_set_disconnect_reason 796 // Params: tHCI_STATUS acl_disc_reason 797 // Returns: void 798 struct acl_set_disconnect_reason { 799 std::function<void(tHCI_STATUS acl_disc_reason)> body{ 800 [](tHCI_STATUS acl_disc_reason) { ; }}; operatoracl_set_disconnect_reason801 void operator()(tHCI_STATUS acl_disc_reason) { body(acl_disc_reason); }; 802 }; 803 extern struct acl_set_disconnect_reason acl_set_disconnect_reason; 804 // Name: acl_write_automatic_flush_timeout 805 // Params: const RawAddress& bd_addr, uint16_t flush_timeout_in_ticks 806 // Returns: void 807 struct acl_write_automatic_flush_timeout { 808 std::function<void(const RawAddress& bd_addr, 809 uint16_t flush_timeout_in_ticks)> 810 body{ 811 [](const RawAddress& bd_addr, uint16_t flush_timeout_in_ticks) { ; }}; operatoracl_write_automatic_flush_timeout812 void operator()(const RawAddress& bd_addr, uint16_t flush_timeout_in_ticks) { 813 body(bd_addr, flush_timeout_in_ticks); 814 }; 815 }; 816 extern struct acl_write_automatic_flush_timeout 817 acl_write_automatic_flush_timeout; 818 // Name: btm_acl_connected 819 // Params: const RawAddress& bda, uint16_t handle, tHCI_STATUS status, uint8_t 820 // enc_mode Returns: void 821 struct btm_acl_connected { 822 std::function<void(const RawAddress& bda, uint16_t handle, tHCI_STATUS status, 823 uint8_t enc_mode)> 824 body{[](const RawAddress& bda, uint16_t handle, tHCI_STATUS status, 825 uint8_t enc_mode) { ; }}; operatorbtm_acl_connected826 void operator()(const RawAddress& bda, uint16_t handle, tHCI_STATUS status, 827 uint8_t enc_mode) { 828 body(bda, handle, status, enc_mode); 829 }; 830 }; 831 extern struct btm_acl_connected btm_acl_connected; 832 // Name: btm_acl_connection_request 833 // Params: const RawAddress& bda, uint8_t* dc 834 // Returns: void 835 struct btm_acl_connection_request { 836 std::function<void(const RawAddress& bda, uint8_t* dc)> body{ 837 [](const RawAddress& bda, uint8_t* dc) { ; }}; operatorbtm_acl_connection_request838 void operator()(const RawAddress& bda, uint8_t* dc) { body(bda, dc); }; 839 }; 840 extern struct btm_acl_connection_request btm_acl_connection_request; 841 // Name: btm_acl_created 842 // Params: const RawAddress& bda, uint16_t hci_handle, tHCI_ROLE link_role, 843 // tBT_TRANSPORT transport Returns: void 844 struct btm_acl_created { 845 std::function<void(const RawAddress& bda, uint16_t hci_handle, 846 tHCI_ROLE link_role, tBT_TRANSPORT transport)> 847 body{[](const RawAddress& bda, uint16_t hci_handle, tHCI_ROLE link_role, 848 tBT_TRANSPORT transport) { ; }}; operatorbtm_acl_created849 void operator()(const RawAddress& bda, uint16_t hci_handle, 850 tHCI_ROLE link_role, tBT_TRANSPORT transport) { 851 body(bda, hci_handle, link_role, transport); 852 }; 853 }; 854 extern struct btm_acl_created btm_acl_created; 855 // Name: btm_acl_device_down 856 // Params: void 857 // Returns: void 858 struct btm_acl_device_down { 859 std::function<void(void)> body{[](void) { ; }}; operatorbtm_acl_device_down860 void operator()(void) { body(); }; 861 }; 862 extern struct btm_acl_device_down btm_acl_device_down; 863 // Name: btm_acl_disconnected 864 // Params: tHCI_STATUS status, uint16_t handle, tHCI_REASON reason 865 // Returns: void 866 struct btm_acl_disconnected { 867 std::function<void(tHCI_STATUS status, uint16_t handle, tHCI_REASON reason)> 868 body{[](tHCI_STATUS status, uint16_t handle, tHCI_REASON reason) { ; }}; operatorbtm_acl_disconnected869 void operator()(tHCI_STATUS status, uint16_t handle, tHCI_REASON reason) { 870 body(status, handle, reason); 871 }; 872 }; 873 extern struct btm_acl_disconnected btm_acl_disconnected; 874 // Name: btm_acl_iso_disconnected 875 // Params: uint16_t handle, tHCI_REASON reason 876 // Returns: void 877 struct btm_acl_iso_disconnected { 878 std::function<void(uint16_t handle, tHCI_REASON reason)> body{ 879 [](uint16_t handle, tHCI_REASON reason) { ; }}; operatorbtm_acl_iso_disconnected880 void operator()(uint16_t handle, tHCI_REASON reason) { 881 body(handle, reason); 882 }; 883 }; 884 extern struct btm_acl_iso_disconnected btm_acl_iso_disconnected; 885 // Name: btm_acl_encrypt_change 886 // Params: uint16_t handle, uint8_t status, uint8_t encr_enable 887 // Returns: void 888 struct btm_acl_encrypt_change { 889 std::function<void(uint16_t handle, uint8_t status, uint8_t encr_enable)> 890 body{[](uint16_t handle, uint8_t status, uint8_t encr_enable) { ; }}; operatorbtm_acl_encrypt_change891 void operator()(uint16_t handle, uint8_t status, uint8_t encr_enable) { 892 body(handle, status, encr_enable); 893 }; 894 }; 895 extern struct btm_acl_encrypt_change btm_acl_encrypt_change; 896 // Name: btm_acl_notif_conn_collision 897 // Params: const RawAddress& bda 898 // Returns: void 899 struct btm_acl_notif_conn_collision { 900 std::function<void(const RawAddress& bda)> body{ 901 [](const RawAddress& bda) { ; }}; operatorbtm_acl_notif_conn_collision902 void operator()(const RawAddress& bda) { body(bda); }; 903 }; 904 extern struct btm_acl_notif_conn_collision btm_acl_notif_conn_collision; 905 // Name: btm_acl_paging 906 // Params: BT_HDR* p, const RawAddress& bda 907 // Returns: void 908 struct btm_acl_paging { 909 std::function<void(BT_HDR* p, const RawAddress& bda)> body{ 910 [](BT_HDR* p, const RawAddress& bda) { ; }}; operatorbtm_acl_paging911 void operator()(BT_HDR* p, const RawAddress& bda) { body(p, bda); }; 912 }; 913 extern struct btm_acl_paging btm_acl_paging; 914 // Name: btm_acl_process_sca_cmpl_pkt 915 // Params: uint8_t len, uint8_t* data 916 // Returns: void 917 struct btm_acl_process_sca_cmpl_pkt { 918 std::function<void(uint8_t len, uint8_t* data)> body{ 919 [](uint8_t len, uint8_t* data) { ; }}; operatorbtm_acl_process_sca_cmpl_pkt920 void operator()(uint8_t len, uint8_t* data) { body(len, data); }; 921 }; 922 extern struct btm_acl_process_sca_cmpl_pkt btm_acl_process_sca_cmpl_pkt; 923 // Name: btm_acl_removed 924 // Params: uint16_t handle 925 // Returns: void 926 struct btm_acl_removed { 927 std::function<void(uint16_t handle)> body{[](uint16_t handle) { ; }}; operatorbtm_acl_removed928 void operator()(uint16_t handle) { body(handle); }; 929 }; 930 extern struct btm_acl_removed btm_acl_removed; 931 // Name: btm_acl_reset_paging 932 // Params: void 933 // Returns: void 934 struct btm_acl_reset_paging { 935 std::function<void(void)> body{[](void) { ; }}; operatorbtm_acl_reset_paging936 void operator()(void) { body(); }; 937 }; 938 extern struct btm_acl_reset_paging btm_acl_reset_paging; 939 // Name: btm_acl_resubmit_page 940 // Params: void 941 // Returns: void 942 struct btm_acl_resubmit_page { 943 std::function<void(void)> body{[](void) { ; }}; operatorbtm_acl_resubmit_page944 void operator()(void) { body(); }; 945 }; 946 extern struct btm_acl_resubmit_page btm_acl_resubmit_page; 947 // Name: btm_acl_role_changed 948 // Params: tHCI_STATUS hci_status, const RawAddress& bd_addr, tHCI_ROLE 949 // new_role Returns: void 950 struct btm_acl_role_changed { 951 std::function<void(tHCI_STATUS hci_status, const RawAddress& bd_addr, 952 tHCI_ROLE new_role)> 953 body{[](tHCI_STATUS hci_status, const RawAddress& bd_addr, 954 tHCI_ROLE new_role) { ; }}; operatorbtm_acl_role_changed955 void operator()(tHCI_STATUS hci_status, const RawAddress& bd_addr, 956 tHCI_ROLE new_role) { 957 body(hci_status, bd_addr, new_role); 958 }; 959 }; 960 extern struct btm_acl_role_changed btm_acl_role_changed; 961 // Name: btm_acl_set_paging 962 // Params: bool value 963 // Returns: void 964 struct btm_acl_set_paging { 965 std::function<void(bool value)> body{[](bool value) { ; }}; operatorbtm_acl_set_paging966 void operator()(bool value) { body(value); }; 967 }; 968 extern struct btm_acl_set_paging btm_acl_set_paging; 969 // Name: btm_acl_update_conn_addr 970 // Params: uint16_t handle, const RawAddress& address 971 // Returns: void 972 struct btm_acl_update_conn_addr { 973 std::function<void(uint16_t handle, const RawAddress& address)> body{ 974 [](uint16_t handle, const RawAddress& address) { ; }}; operatorbtm_acl_update_conn_addr975 void operator()(uint16_t handle, const RawAddress& address) { 976 body(handle, address); 977 }; 978 }; 979 extern struct btm_acl_update_conn_addr btm_acl_update_conn_addr; 980 // Name: btm_configure_data_path 981 // Params: uint8_t direction, uint8_t path_id, std::vector<uint8_t> 982 // vendor_config Returns: void 983 struct btm_configure_data_path { 984 std::function<void(uint8_t direction, uint8_t path_id, 985 std::vector<uint8_t> vendor_config)> 986 body{[](uint8_t direction, uint8_t path_id, 987 std::vector<uint8_t> vendor_config) { ; }}; operatorbtm_configure_data_path988 void operator()(uint8_t direction, uint8_t path_id, 989 std::vector<uint8_t> vendor_config) { 990 body(direction, path_id, vendor_config); 991 }; 992 }; 993 extern struct btm_configure_data_path btm_configure_data_path; 994 // Name: btm_acl_update_inquiry_status 995 // Params: uint8_t status 996 // Returns: void 997 struct btm_acl_update_inquiry_status { 998 std::function<void(uint8_t status)> body{[](uint8_t status) { ; }}; operatorbtm_acl_update_inquiry_status999 void operator()(uint8_t status) { body(status); }; 1000 }; 1001 extern struct btm_acl_update_inquiry_status btm_acl_update_inquiry_status; 1002 // Name: btm_ble_refresh_local_resolvable_private_addr 1003 // Params: const RawAddress& pseudo_addr, const RawAddress& local_rpa 1004 // Returns: void 1005 struct btm_ble_refresh_local_resolvable_private_addr { 1006 std::function<void(const RawAddress& pseudo_addr, 1007 const RawAddress& local_rpa)> 1008 body{ 1009 [](const RawAddress& pseudo_addr, const RawAddress& local_rpa) { ; }}; operatorbtm_ble_refresh_local_resolvable_private_addr1010 void operator()(const RawAddress& pseudo_addr, const RawAddress& local_rpa) { 1011 body(pseudo_addr, local_rpa); 1012 }; 1013 }; 1014 extern struct btm_ble_refresh_local_resolvable_private_addr 1015 btm_ble_refresh_local_resolvable_private_addr; 1016 // Name: btm_cont_rswitch_from_handle 1017 // Params: uint16_t hci_handle 1018 // Returns: void 1019 struct btm_cont_rswitch_from_handle { 1020 std::function<void(uint16_t hci_handle)> body{[](uint16_t hci_handle) { ; }}; operatorbtm_cont_rswitch_from_handle1021 void operator()(uint16_t hci_handle) { body(hci_handle); }; 1022 }; 1023 extern struct btm_cont_rswitch_from_handle btm_cont_rswitch_from_handle; 1024 // Name: btm_establish_continue_from_address 1025 // Params: const RawAddress& bda, tBT_TRANSPORT transport 1026 // Returns: void 1027 struct btm_establish_continue_from_address { 1028 std::function<void(const RawAddress& bda, tBT_TRANSPORT transport)> body{ 1029 [](const RawAddress& bda, tBT_TRANSPORT transport) { ; }}; operatorbtm_establish_continue_from_address1030 void operator()(const RawAddress& bda, tBT_TRANSPORT transport) { 1031 body(bda, transport); 1032 }; 1033 }; 1034 extern struct btm_establish_continue_from_address 1035 btm_establish_continue_from_address; 1036 // Name: btm_process_remote_ext_features 1037 // Params: tACL_CONN* p_acl_cb, uint8_t max_page_number 1038 // Returns: void 1039 struct btm_process_remote_ext_features { 1040 std::function<void(tACL_CONN* p_acl_cb, uint8_t max_page_number)> body{ 1041 [](tACL_CONN* p_acl_cb, uint8_t max_page_number) { ; }}; operatorbtm_process_remote_ext_features1042 void operator()(tACL_CONN* p_acl_cb, uint8_t max_page_number) { 1043 body(p_acl_cb, max_page_number); 1044 }; 1045 }; 1046 extern struct btm_process_remote_ext_features btm_process_remote_ext_features; 1047 // Name: btm_process_remote_version_complete 1048 // Params: uint8_t status, uint16_t handle, uint8_t lmp_version, uint16_t 1049 // manufacturer, uint16_t lmp_subversion Returns: void 1050 struct btm_process_remote_version_complete { 1051 std::function<void(uint8_t status, uint16_t handle, uint8_t lmp_version, 1052 uint16_t manufacturer, uint16_t lmp_subversion)> 1053 body{[](uint8_t status, uint16_t handle, uint8_t lmp_version, 1054 uint16_t manufacturer, uint16_t lmp_subversion) { ; }}; operatorbtm_process_remote_version_complete1055 void operator()(uint8_t status, uint16_t handle, uint8_t lmp_version, 1056 uint16_t manufacturer, uint16_t lmp_subversion) { 1057 body(status, handle, lmp_version, manufacturer, lmp_subversion); 1058 }; 1059 }; 1060 extern struct btm_process_remote_version_complete 1061 btm_process_remote_version_complete; 1062 // Name: btm_read_automatic_flush_timeout_complete 1063 // Params: uint8_t* p 1064 // Returns: void 1065 struct btm_read_automatic_flush_timeout_complete { 1066 std::function<void(uint8_t* p)> body{[](uint8_t* p) { ; }}; operatorbtm_read_automatic_flush_timeout_complete1067 void operator()(uint8_t* p) { body(p); }; 1068 }; 1069 extern struct btm_read_automatic_flush_timeout_complete 1070 btm_read_automatic_flush_timeout_complete; 1071 // Name: btm_read_failed_contact_counter_complete 1072 // Params: uint8_t* p 1073 // Returns: void 1074 struct btm_read_failed_contact_counter_complete { 1075 std::function<void(uint8_t* p)> body{[](uint8_t* p) { ; }}; operatorbtm_read_failed_contact_counter_complete1076 void operator()(uint8_t* p) { body(p); }; 1077 }; 1078 extern struct btm_read_failed_contact_counter_complete 1079 btm_read_failed_contact_counter_complete; 1080 // Name: btm_read_failed_contact_counter_timeout 1081 // Params: UNUSED_ATTR void* data 1082 // Returns: void 1083 struct btm_read_failed_contact_counter_timeout { 1084 std::function<void(UNUSED_ATTR void* data)> body{ 1085 [](UNUSED_ATTR void* data) { ; }}; operatorbtm_read_failed_contact_counter_timeout1086 void operator()(UNUSED_ATTR void* data) { body(data); }; 1087 }; 1088 extern struct btm_read_failed_contact_counter_timeout 1089 btm_read_failed_contact_counter_timeout; 1090 // Name: btm_read_link_quality_complete 1091 // Params: uint8_t* p 1092 // Returns: void 1093 struct btm_read_link_quality_complete { 1094 std::function<void(uint8_t* p, uint16_t evt_len)> body{[](uint8_t* p, uint16_t evt_len) { ; }}; operatorbtm_read_link_quality_complete1095 void operator()(uint8_t* p, uint16_t evt_len) { body(p, evt_len); }; 1096 }; 1097 extern struct btm_read_link_quality_complete btm_read_link_quality_complete; 1098 // Name: btm_read_link_quality_timeout 1099 // Params: UNUSED_ATTR void* data 1100 // Returns: void 1101 struct btm_read_link_quality_timeout { 1102 std::function<void(UNUSED_ATTR void* data)> body{ 1103 [](UNUSED_ATTR void* data) { ; }}; operatorbtm_read_link_quality_timeout1104 void operator()(UNUSED_ATTR void* data) { body(data); }; 1105 }; 1106 extern struct btm_read_link_quality_timeout btm_read_link_quality_timeout; 1107 // Name: btm_read_remote_ext_features 1108 // Params: uint16_t handle, uint8_t page_number 1109 // Returns: void 1110 struct btm_read_remote_ext_features { 1111 std::function<void(uint16_t handle, uint8_t page_number)> body{ 1112 [](uint16_t handle, uint8_t page_number) { ; }}; operatorbtm_read_remote_ext_features1113 void operator()(uint16_t handle, uint8_t page_number) { 1114 body(handle, page_number); 1115 }; 1116 }; 1117 extern struct btm_read_remote_ext_features btm_read_remote_ext_features; 1118 // Name: btm_read_remote_ext_features_complete 1119 // Params: uint16_t handle, uint8_t page_num, uint8_t max_page, uint8_t* 1120 // features Returns: void 1121 struct btm_read_remote_ext_features_complete { 1122 std::function<void(uint16_t handle, uint8_t page_num, uint8_t max_page, 1123 uint8_t* features)> 1124 body{[](uint16_t handle, uint8_t page_num, uint8_t max_page, 1125 uint8_t* features) { ; }}; operatorbtm_read_remote_ext_features_complete1126 void operator()(uint16_t handle, uint8_t page_num, uint8_t max_page, 1127 uint8_t* features) { 1128 body(handle, page_num, max_page, features); 1129 }; 1130 }; 1131 extern struct btm_read_remote_ext_features_complete 1132 btm_read_remote_ext_features_complete; 1133 // Name: btm_read_remote_ext_features_complete_raw 1134 // Params: uint8_t* p, uint8_t evt_len 1135 // Returns: void 1136 struct btm_read_remote_ext_features_complete_raw { 1137 std::function<void(uint8_t* p, uint8_t evt_len)> body{ 1138 [](uint8_t* p, uint8_t evt_len) { ; }}; operatorbtm_read_remote_ext_features_complete_raw1139 void operator()(uint8_t* p, uint8_t evt_len) { body(p, evt_len); }; 1140 }; 1141 extern struct btm_read_remote_ext_features_complete_raw 1142 btm_read_remote_ext_features_complete_raw; 1143 // Name: btm_read_remote_ext_features_failed 1144 // Params: uint8_t status, uint16_t handle 1145 // Returns: void 1146 struct btm_read_remote_ext_features_failed { 1147 std::function<void(uint8_t status, uint16_t handle)> body{ 1148 [](uint8_t status, uint16_t handle) { ; }}; operatorbtm_read_remote_ext_features_failed1149 void operator()(uint8_t status, uint16_t handle) { body(status, handle); }; 1150 }; 1151 extern struct btm_read_remote_ext_features_failed 1152 btm_read_remote_ext_features_failed; 1153 // Name: btm_read_remote_features_complete 1154 // Params: uint16_t handle, uint8_t* features 1155 // Returns: void 1156 struct btm_read_remote_features_complete { 1157 std::function<void(uint16_t handle, uint8_t* features)> body{ 1158 [](uint16_t handle, uint8_t* features) { ; }}; operatorbtm_read_remote_features_complete1159 void operator()(uint16_t handle, uint8_t* features) { 1160 body(handle, features); 1161 }; 1162 }; 1163 extern struct btm_read_remote_features_complete 1164 btm_read_remote_features_complete; 1165 // Name: btm_read_remote_version_complete 1166 // Params: tHCI_STATUS status, uint16_t handle, uint8_t lmp_version, uint16_t 1167 // manufacturer, uint16_t lmp_subversion Returns: void 1168 struct btm_read_remote_version_complete { 1169 std::function<void(tHCI_STATUS status, uint16_t handle, uint8_t lmp_version, 1170 uint16_t manufacturer, uint16_t lmp_subversion)> 1171 body{[](tHCI_STATUS status, uint16_t handle, uint8_t lmp_version, 1172 uint16_t manufacturer, uint16_t lmp_subversion) { ; }}; operatorbtm_read_remote_version_complete1173 void operator()(tHCI_STATUS status, uint16_t handle, uint8_t lmp_version, 1174 uint16_t manufacturer, uint16_t lmp_subversion) { 1175 body(status, handle, lmp_version, manufacturer, lmp_subversion); 1176 }; 1177 }; 1178 extern struct btm_read_remote_version_complete btm_read_remote_version_complete; 1179 // Name: btm_read_rssi_complete 1180 // Params: uint8_t* p 1181 // Returns: void 1182 struct btm_read_rssi_complete { 1183 std::function<void(uint8_t* p, uint16_t evt_len)> body{ 1184 [](uint8_t* pm, uint16_t evt_len) { ; }}; operatorbtm_read_rssi_complete1185 void operator()(uint8_t* p, uint16_t evt_len) { body(p, evt_len); }; 1186 }; 1187 extern struct btm_read_rssi_complete btm_read_rssi_complete; 1188 // Name: btm_read_rssi_timeout 1189 // Params: UNUSED_ATTR void* data 1190 // Returns: void 1191 struct btm_read_rssi_timeout { 1192 std::function<void(UNUSED_ATTR void* data)> body{ 1193 [](UNUSED_ATTR void* data) { ; }}; operatorbtm_read_rssi_timeout1194 void operator()(UNUSED_ATTR void* data) { body(data); }; 1195 }; 1196 extern struct btm_read_rssi_timeout btm_read_rssi_timeout; 1197 // Name: btm_read_tx_power_complete 1198 // Params: uint8_t* p, bool is_ble 1199 // Returns: void 1200 struct btm_read_tx_power_complete { 1201 std::function<void(uint8_t* p, uint16_t evt_len, bool is_ble)> body{ 1202 [](uint8_t* p, uint16_t evt_len, bool is_ble) { ; }}; operatorbtm_read_tx_power_complete1203 void operator()(uint8_t* p, uint16_t evt_len, bool is_ble) { 1204 body(p, evt_len, is_ble); 1205 }; 1206 }; 1207 extern struct btm_read_tx_power_complete btm_read_tx_power_complete; 1208 // Name: btm_read_tx_power_timeout 1209 // Params: UNUSED_ATTR void* data 1210 // Returns: void 1211 struct btm_read_tx_power_timeout { 1212 std::function<void(UNUSED_ATTR void* data)> body{ 1213 [](UNUSED_ATTR void* data) { ; }}; operatorbtm_read_tx_power_timeout1214 void operator()(UNUSED_ATTR void* data) { body(data); }; 1215 }; 1216 extern struct btm_read_tx_power_timeout btm_read_tx_power_timeout; 1217 // Name: btm_rejectlist_role_change_device 1218 // Params: const RawAddress& bd_addr, uint8_t hci_status 1219 // Returns: void 1220 struct btm_rejectlist_role_change_device { 1221 std::function<void(const RawAddress& bd_addr, uint8_t hci_status)> body{ 1222 [](const RawAddress& bd_addr, uint8_t hci_status) { ; }}; operatorbtm_rejectlist_role_change_device1223 void operator()(const RawAddress& bd_addr, uint8_t hci_status) { 1224 body(bd_addr, hci_status); 1225 }; 1226 }; 1227 extern struct btm_rejectlist_role_change_device 1228 btm_rejectlist_role_change_device; 1229 // Name: btm_set_link_policy 1230 // Params: tACL_CONN* conn, tLINK_POLICY policy 1231 // Returns: void 1232 struct btm_set_link_policy { 1233 std::function<void(tACL_CONN* conn, tLINK_POLICY policy)> body{ 1234 [](tACL_CONN* conn, tLINK_POLICY policy) { ; }}; operatorbtm_set_link_policy1235 void operator()(tACL_CONN* conn, tLINK_POLICY policy) { body(conn, policy); }; 1236 }; 1237 extern struct btm_set_link_policy btm_set_link_policy; 1238 // Name: btm_set_packet_types_from_address 1239 // Params: const RawAddress& bd_addr, uint16_t pkt_types 1240 // Returns: void 1241 struct btm_set_packet_types_from_address { 1242 std::function<void(const RawAddress& bd_addr, uint16_t pkt_types)> body{ 1243 [](const RawAddress& bd_addr, uint16_t pkt_types) { ; }}; operatorbtm_set_packet_types_from_address1244 void operator()(const RawAddress& bd_addr, uint16_t pkt_types) { 1245 body(bd_addr, pkt_types); 1246 }; 1247 }; 1248 extern struct btm_set_packet_types_from_address 1249 btm_set_packet_types_from_address; 1250 // Name: hci_btm_set_link_supervision_timeout 1251 // Params: tACL_CONN& link, uint16_t timeout 1252 // Returns: void 1253 struct hci_btm_set_link_supervision_timeout { 1254 std::function<void(tACL_CONN& link, uint16_t timeout)> body{ 1255 [](tACL_CONN& link, uint16_t timeout) { ; }}; operatorhci_btm_set_link_supervision_timeout1256 void operator()(tACL_CONN& link, uint16_t timeout) { body(link, timeout); }; 1257 }; 1258 extern struct hci_btm_set_link_supervision_timeout 1259 hci_btm_set_link_supervision_timeout; 1260 // Name: on_acl_br_edr_connected 1261 // Params: const RawAddress& bda, uint16_t handle, uint8_t enc_mode 1262 // Returns: void 1263 struct on_acl_br_edr_connected { 1264 std::function<void(const RawAddress& bda, uint16_t handle, uint8_t enc_mode)> 1265 body{[](const RawAddress& bda, uint16_t handle, uint8_t enc_mode) { ; }}; operatoron_acl_br_edr_connected1266 void operator()(const RawAddress& bda, uint16_t handle, uint8_t enc_mode) { 1267 body(bda, handle, enc_mode); 1268 }; 1269 }; 1270 extern struct on_acl_br_edr_connected on_acl_br_edr_connected; 1271 // Name: on_acl_br_edr_failed 1272 // Params: const RawAddress& bda, tHCI_STATUS status 1273 // Returns: void 1274 struct on_acl_br_edr_failed { 1275 std::function<void(const RawAddress& bda, tHCI_STATUS status)> body{ 1276 [](const RawAddress& bda, tHCI_STATUS status) { ; }}; operatoron_acl_br_edr_failed1277 void operator()(const RawAddress& bda, tHCI_STATUS status) { 1278 body(bda, status); 1279 }; 1280 }; 1281 extern struct on_acl_br_edr_failed on_acl_br_edr_failed; 1282 1283 } // namespace stack_acl 1284 } // namespace mock 1285 } // namespace test 1286 1287 // END mockcify generation 1288