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 <string> 27 28 // Original included files, if any 29 #include "hci/class_of_device.h" 30 #include "stack/acl/acl.h" 31 #include "stack/btm/security_device_record.h" 32 #include "stack/include/acl_client_callbacks.h" 33 #include "stack/include/bt_hdr.h" 34 #include "types/raw_address.h" 35 36 // Mocked compile conditionals, if any 37 namespace test { 38 namespace mock { 39 namespace stack_acl { 40 41 // Name: BTM_BLE_IS_RESOLVE_BDA 42 // Params: const RawAddress& x 43 // Returns: bool 44 struct BTM_BLE_IS_RESOLVE_BDA { 45 std::function<bool(const RawAddress& x)> body{ 46 [](const RawAddress& /* x */) { return false; }}; operatorBTM_BLE_IS_RESOLVE_BDA47 bool operator()(const RawAddress& x) { return body(x); }; 48 }; 49 extern struct BTM_BLE_IS_RESOLVE_BDA BTM_BLE_IS_RESOLVE_BDA; 50 // Name: BTM_IsAclConnectionUp 51 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 52 // Returns: bool 53 struct BTM_IsAclConnectionUp { 54 std::function<bool(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 55 body{[](const RawAddress& /* remote_bda */, 56 tBT_TRANSPORT /* transport */) { return false; }}; operatorBTM_IsAclConnectionUp57 bool operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 58 return body(remote_bda, transport); 59 }; 60 }; 61 extern struct BTM_IsAclConnectionUp BTM_IsAclConnectionUp; 62 // Name: BTM_IsAclConnectionUpAndHandleValid 63 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 64 // Returns: bool 65 struct BTM_IsAclConnectionUpAndHandleValid { 66 std::function<bool(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 67 body{[](const RawAddress& /* remote_bda */, 68 tBT_TRANSPORT /* transport */) { return false; }}; operatorBTM_IsAclConnectionUpAndHandleValid69 bool operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 70 return body(remote_bda, transport); 71 }; 72 }; 73 extern struct BTM_IsAclConnectionUpAndHandleValid 74 BTM_IsAclConnectionUpAndHandleValid; 75 // Name: BTM_IsBleConnection 76 // Params: uint16_t hci_handle 77 // Returns: bool 78 struct BTM_IsBleConnection { 79 std::function<bool(uint16_t hci_handle)> body{ 80 [](uint16_t /* hci_handle */) { return false; }}; operatorBTM_IsBleConnection81 bool operator()(uint16_t hci_handle) { return body(hci_handle); }; 82 }; 83 extern struct BTM_IsBleConnection BTM_IsBleConnection; 84 // Name: BTM_IsPhy2mSupported 85 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 86 // Returns: bool 87 struct BTM_IsPhy2mSupported { 88 std::function<bool(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 89 body{[](const RawAddress& /* remote_bda */, 90 tBT_TRANSPORT /* transport */) { return false; }}; operatorBTM_IsPhy2mSupported91 bool operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 92 return body(remote_bda, transport); 93 }; 94 }; 95 extern struct BTM_IsPhy2mSupported BTM_IsPhy2mSupported; 96 // Name: BTM_ReadRemoteConnectionAddr 97 // Params: const RawAddress& pseudo_addr, RawAddress& conn_addr, bool 98 // ota_address tBLE_ADDR_TYPE* p_addr_type Returns: bool 99 struct BTM_ReadRemoteConnectionAddr { 100 std::function<bool(const RawAddress& pseudo_addr, RawAddress& conn_addr, 101 tBLE_ADDR_TYPE* p_addr_type, bool ota_address)> 102 body{[](const RawAddress& /* pseudo_addr */, RawAddress& /* conn_addr */, 103 tBLE_ADDR_TYPE* /* p_addr_type */, 104 bool /* ota_address */) { return false; }}; operatorBTM_ReadRemoteConnectionAddr105 bool operator()(const RawAddress& pseudo_addr, RawAddress& conn_addr, 106 tBLE_ADDR_TYPE* p_addr_type, bool ota_address) { 107 return body(pseudo_addr, conn_addr, p_addr_type, ota_address); 108 }; 109 }; 110 extern struct BTM_ReadRemoteConnectionAddr BTM_ReadRemoteConnectionAddr; 111 // Name: BTM_IsRemoteVersionReceived 112 // Params: const RawAddress& addr 113 // Returns: bool 114 struct BTM_IsRemoteVersionReceived { 115 std::function<bool(const RawAddress& addr)> body{ 116 [](const RawAddress& /* addr */) { return false; }}; operatorBTM_IsRemoteVersionReceived117 bool operator()(const RawAddress& addr) { return body(addr); }; 118 }; 119 extern struct BTM_IsRemoteVersionReceived BTM_IsRemoteVersionReceived; 120 // Name: BTM_ReadRemoteVersion 121 // Params: const RawAddress& addr, uint8_t* lmp_version, uint16_t* 122 // manufacturer, uint16_t* lmp_sub_version 123 // Returns: bool 124 struct BTM_ReadRemoteVersion { 125 std::function<bool(const RawAddress& addr, uint8_t* lmp_version, 126 uint16_t* manufacturer, uint16_t* lmp_sub_version)> 127 body{[](const RawAddress& /* addr */, uint8_t* /* lmp_version */, 128 uint16_t* /* manufacturer */, 129 uint16_t* /* lmp_sub_version */) { return false; }}; operatorBTM_ReadRemoteVersion130 bool operator()(const RawAddress& addr, uint8_t* lmp_version, 131 uint16_t* manufacturer, uint16_t* lmp_sub_version) { 132 return body(addr, lmp_version, manufacturer, lmp_sub_version); 133 }; 134 }; 135 extern struct BTM_ReadRemoteVersion BTM_ReadRemoteVersion; 136 // Name: BTM_is_sniff_allowed_for 137 // Params: const RawAddress& peer_addr 138 // Returns: bool 139 struct BTM_is_sniff_allowed_for { 140 std::function<bool(const RawAddress& peer_addr)> body{ 141 [](const RawAddress& /* peer_addr */) { return false; }}; operatorBTM_is_sniff_allowed_for142 bool operator()(const RawAddress& peer_addr) { return body(peer_addr); }; 143 }; 144 extern struct BTM_is_sniff_allowed_for BTM_is_sniff_allowed_for; 145 // Name: acl_send_data_packet_br_edr 146 // Params: const RawAddress& bd_addr, BT_HDR* p_buf 147 // Returns: void 148 struct acl_send_data_packet_br_edr { 149 std::function<void(const RawAddress& bd_addr, BT_HDR* p_buf)> body{ 150 [](const RawAddress& /* bd_addr */, BT_HDR* /* p_buf */) {}}; operatoracl_send_data_packet_br_edr151 void operator()(const RawAddress& bd_addr, BT_HDR* p_buf) { 152 return body(bd_addr, p_buf); 153 }; 154 }; 155 extern struct acl_send_data_packet_br_edr acl_send_data_packet_br_edr; 156 // Name: acl_create_le_connection 157 // Params: const RawAddress& bd_addr 158 // Returns: bool 159 struct acl_create_le_connection { 160 std::function<bool(const RawAddress& bd_addr)> body{ 161 [](const RawAddress& /* bd_addr */) { return false; }}; operatoracl_create_le_connection162 bool operator()(const RawAddress& bd_addr) { return body(bd_addr); }; 163 }; 164 extern struct acl_create_le_connection acl_create_le_connection; 165 // Name: acl_create_le_connection_with_id 166 // Params: uint8_t id, const RawAddress& bd_addr 167 // Returns: bool 168 struct acl_create_le_connection_with_id { 169 std::function<bool(uint8_t id, const RawAddress& bd_addr, 170 tBLE_ADDR_TYPE addr_type)> 171 body{[](uint8_t /* id */, const RawAddress& /* bd_addr */, 172 tBLE_ADDR_TYPE /* addr_type */) { return false; }}; operatoracl_create_le_connection_with_id173 bool operator()(uint8_t id, const RawAddress& bd_addr, 174 tBLE_ADDR_TYPE addr_type) { 175 return body(id, bd_addr, addr_type); 176 }; 177 }; 178 extern struct acl_create_le_connection_with_id acl_create_le_connection_with_id; 179 // Name: acl_is_role_switch_allowed 180 // Params: 181 // Returns: bool 182 struct acl_is_role_switch_allowed { 183 std::function<bool()> body{[]() { return false; }}; operatoracl_is_role_switch_allowed184 bool operator()() { return body(); }; 185 }; 186 extern struct acl_is_role_switch_allowed acl_is_role_switch_allowed; 187 // Name: acl_is_switch_role_idle 188 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 189 // Returns: bool 190 struct acl_is_switch_role_idle { 191 std::function<bool(const RawAddress& bd_addr, tBT_TRANSPORT transport)> body{ 192 [](const RawAddress& /* bd_addr */, tBT_TRANSPORT /* transport */) { 193 return false; 194 }}; operatoracl_is_switch_role_idle195 bool operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 196 return body(bd_addr, transport); 197 }; 198 }; 199 extern struct acl_is_switch_role_idle acl_is_switch_role_idle; 200 // Name: acl_peer_supports_ble_2m_phy 201 // Params: uint16_t hci_handle 202 // Returns: bool 203 struct acl_peer_supports_ble_2m_phy { 204 std::function<bool(uint16_t hci_handle)> body{ 205 [](uint16_t /* hci_handle */) { return false; }}; operatoracl_peer_supports_ble_2m_phy206 bool operator()(uint16_t hci_handle) { return body(hci_handle); }; 207 }; 208 extern struct acl_peer_supports_ble_2m_phy acl_peer_supports_ble_2m_phy; 209 // Name: acl_peer_supports_ble_coded_phy 210 // Params: uint16_t hci_handle 211 // Returns: bool 212 struct acl_peer_supports_ble_coded_phy { 213 std::function<bool(uint16_t hci_handle)> body{ 214 [](uint16_t /* hci_handle */) { return false; }}; operatoracl_peer_supports_ble_coded_phy215 bool operator()(uint16_t hci_handle) { return body(hci_handle); }; 216 }; 217 extern struct acl_peer_supports_ble_coded_phy acl_peer_supports_ble_coded_phy; 218 // Name: acl_peer_supports_ble_connection_parameters_request 219 // Params: const RawAddress& remote_bda 220 // Returns: bool 221 struct acl_peer_supports_ble_connection_parameters_request { 222 std::function<bool(const RawAddress& remote_bda)> body{ 223 [](const RawAddress& /* remote_bda */) { return false; }}; operatoracl_peer_supports_ble_connection_parameters_request224 bool operator()(const RawAddress& remote_bda) { return body(remote_bda); }; 225 }; 226 extern struct acl_peer_supports_ble_connection_parameters_request 227 acl_peer_supports_ble_connection_parameters_request; 228 // Name: acl_peer_supports_ble_connection_parameters_request 229 // Params: const RawAddress& remote_bda 230 // Returns: bool 231 struct acl_ble_connection_parameters_request { 232 std::function<void(uint16_t handle, uint16_t conn_int_min, 233 uint16_t conn_int_max, uint16_t conn_latency, 234 uint16_t conn_timeout, uint16_t min_ce_len, 235 uint16_t max_ce_len)> 236 body{[](uint16_t /* handle */, uint16_t /* conn_int_min */, 237 uint16_t /* conn_int_max */, uint16_t /* conn_latency */, 238 uint16_t /* conn_timeout */, uint16_t /* min_ce_len */, 239 uint16_t /* max_ce_len */) {}}; operatoracl_ble_connection_parameters_request240 void operator()(uint16_t handle, uint16_t conn_int_min, uint16_t conn_int_max, 241 uint16_t conn_latency, uint16_t conn_timeout, 242 uint16_t min_ce_len, uint16_t max_ce_len) { 243 body(handle, conn_int_min, conn_int_max, conn_latency, conn_timeout, 244 min_ce_len, max_ce_len); 245 }; 246 }; 247 extern struct acl_ble_connection_parameters_request 248 acl_ble_connection_parameters_request; 249 // Name: acl_peer_supports_ble_packet_extension 250 // Params: uint16_t hci_handle 251 // Returns: bool 252 struct acl_peer_supports_ble_packet_extension { 253 std::function<bool(uint16_t hci_handle)> body{ 254 [](uint16_t /* hci_handle */) { return false; }}; operatoracl_peer_supports_ble_packet_extension255 bool operator()(uint16_t hci_handle) { return body(hci_handle); }; 256 }; 257 extern struct acl_peer_supports_ble_packet_extension 258 acl_peer_supports_ble_packet_extension; 259 // Name: acl_peer_supports_sniff_subrating 260 // Params: const RawAddress& remote_bda 261 // Returns: bool 262 struct acl_peer_supports_sniff_subrating { 263 std::function<bool(const RawAddress& remote_bda)> body{ 264 [](const RawAddress& /* remote_bda */) { return false; }}; operatoracl_peer_supports_sniff_subrating265 bool operator()(const RawAddress& remote_bda) { return body(remote_bda); }; 266 }; 267 extern struct acl_peer_supports_sniff_subrating 268 acl_peer_supports_sniff_subrating; 269 // Name: acl_peer_supports_ble_connection_subrating 270 // Params: const RawAddress& remote_bda 271 // Returns: bool 272 struct acl_peer_supports_ble_connection_subrating { 273 std::function<bool(const RawAddress& remote_bda)> body{ 274 [](const RawAddress& /* remote_bda */) { return false; }}; operatoracl_peer_supports_ble_connection_subrating275 bool operator()(const RawAddress& remote_bda) { return body(remote_bda); }; 276 }; 277 extern struct acl_peer_supports_ble_connection_subrating 278 acl_peer_supports_ble_connection_subrating; 279 // Name: acl_peer_supports_ble_connection_subrating_host 280 // Params: const RawAddress& remote_bda 281 // Returns: bool 282 struct acl_peer_supports_ble_connection_subrating_host { 283 std::function<bool(const RawAddress& remote_bda)> body{ 284 [](const RawAddress& /* remote_bda */) { return false; }}; operatoracl_peer_supports_ble_connection_subrating_host285 bool operator()(const RawAddress& remote_bda) { return body(remote_bda); }; 286 }; 287 extern struct acl_peer_supports_ble_connection_subrating_host 288 acl_peer_supports_ble_connection_subrating_host; 289 // Name: acl_refresh_remote_address 290 // Params: const RawAddress& identity_address, tBLE_ADDR_TYPE 291 // identity_address_type, const RawAddress& bda, tBLE_ADDR_TYPE rra_type, 292 // const RawAddress& rpa Returns: bool 293 struct acl_refresh_remote_address { 294 std::function<bool(const RawAddress& identity_address, 295 tBLE_ADDR_TYPE identity_address_type, 296 const RawAddress& bda, tBLE_RAND_ADDR_TYPE rra_type, 297 const RawAddress& rpa)> 298 body{[](const RawAddress& /* identity_address */, 299 tBLE_ADDR_TYPE /* identity_address_type */, 300 const RawAddress& /* bda */, tBLE_RAND_ADDR_TYPE /* rra_type */, 301 const RawAddress& /* rpa */) { return false; }}; operatoracl_refresh_remote_address302 bool operator()(const RawAddress& identity_address, 303 tBLE_ADDR_TYPE identity_address_type, const RawAddress& bda, 304 tBLE_RAND_ADDR_TYPE rra_type, const RawAddress& rpa) { 305 return body(identity_address, identity_address_type, bda, rra_type, rpa); 306 }; 307 }; 308 extern struct acl_refresh_remote_address acl_refresh_remote_address; 309 // Name: acl_set_peer_le_features_from_handle 310 // Params: uint16_t hci_handle, const uint8_t* p 311 // Returns: bool 312 struct acl_set_peer_le_features_from_handle { 313 std::function<bool(uint16_t hci_handle, const uint8_t* p)> body{ 314 [](uint16_t /* hci_handle */, const uint8_t* /* p */) { return false; }}; operatoracl_set_peer_le_features_from_handle315 bool operator()(uint16_t hci_handle, const uint8_t* p) { 316 return body(hci_handle, p); 317 }; 318 }; 319 extern struct acl_set_peer_le_features_from_handle 320 acl_set_peer_le_features_from_handle; 321 // Name: acl_get_connection_from_address 322 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 323 // Returns: tACL_CONN* 324 struct acl_get_connection_from_address { 325 std::function<tACL_CONN*(const RawAddress& bd_addr, tBT_TRANSPORT transport)> 326 body{[](const RawAddress& /* bd_addr */, tBT_TRANSPORT /* transport */) { 327 return nullptr; 328 }}; operatoracl_get_connection_from_address329 tACL_CONN* operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 330 return body(bd_addr, transport); 331 }; 332 }; 333 extern struct acl_get_connection_from_address acl_get_connection_from_address; 334 // Name: btm_acl_for_bda 335 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 336 // Returns: tACL_CONN* 337 struct btm_acl_for_bda { 338 std::function<tACL_CONN*(const RawAddress& bd_addr, tBT_TRANSPORT transport)> 339 body{[](const RawAddress& /* bd_addr */, tBT_TRANSPORT /* transport */) { 340 return nullptr; 341 }}; operatorbtm_acl_for_bda342 tACL_CONN* operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 343 return body(bd_addr, transport); 344 }; 345 }; 346 extern struct btm_acl_for_bda btm_acl_for_bda; 347 // Name: acl_get_connection_from_handle 348 // Params: uint16_t handle 349 // Returns: tACL_CONN* 350 struct acl_get_connection_from_handle { 351 std::function<tACL_CONN*(uint16_t handle)> body{ 352 [](uint16_t /* handle */) { return nullptr; }}; operatoracl_get_connection_from_handle353 tACL_CONN* operator()(uint16_t handle) { return body(handle); }; 354 }; 355 extern struct acl_get_connection_from_handle acl_get_connection_from_handle; 356 // Name: BTM_GetLinkSuperTout 357 // Params: const RawAddress& remote_bda, uint16_t* p_timeout 358 // Returns: tBTM_STATUS 359 struct BTM_GetLinkSuperTout { 360 std::function<tBTM_STATUS(const RawAddress& remote_bda, uint16_t* p_timeout)> 361 body{[](const RawAddress& /* remote_bda */, uint16_t* /* p_timeout */) { 362 return 0; 363 }}; operatorBTM_GetLinkSuperTout364 tBTM_STATUS operator()(const RawAddress& remote_bda, uint16_t* p_timeout) { 365 return body(remote_bda, p_timeout); 366 }; 367 }; 368 extern struct BTM_GetLinkSuperTout BTM_GetLinkSuperTout; 369 // Name: BTM_GetRole 370 // Params: const RawAddress& remote_bd_addr, tHCI_ROLE* p_role 371 // Returns: tBTM_STATUS 372 struct BTM_GetRole { 373 std::function<tBTM_STATUS(const RawAddress& remote_bd_addr, 374 tHCI_ROLE* p_role)> 375 body{[](const RawAddress& /* remote_bd_addr */, tHCI_ROLE* /* p_role */) { 376 return 0; 377 }}; operatorBTM_GetRole378 tBTM_STATUS operator()(const RawAddress& remote_bd_addr, tHCI_ROLE* p_role) { 379 return body(remote_bd_addr, p_role); 380 }; 381 }; 382 extern struct BTM_GetRole BTM_GetRole; 383 // Name: BTM_ReadFailedContactCounter 384 // Params: const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb 385 // Returns: tBTM_STATUS 386 struct BTM_ReadFailedContactCounter { 387 std::function<tBTM_STATUS(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb)> 388 body{[](const RawAddress& /* remote_bda */, tBTM_CMPL_CB* /* p_cb */) { 389 return 0; 390 }}; operatorBTM_ReadFailedContactCounter391 tBTM_STATUS operator()(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb) { 392 return body(remote_bda, p_cb); 393 }; 394 }; 395 extern struct BTM_ReadFailedContactCounter BTM_ReadFailedContactCounter; 396 // Name: BTM_ReadRSSI 397 // Params: const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb 398 // Returns: tBTM_STATUS 399 struct BTM_ReadRSSI { 400 std::function<tBTM_STATUS(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb)> 401 body{[](const RawAddress& /* remote_bda */, tBTM_CMPL_CB* /* p_cb */) { 402 return 0; 403 }}; operatorBTM_ReadRSSI404 tBTM_STATUS operator()(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb) { 405 return body(remote_bda, p_cb); 406 }; 407 }; 408 extern struct BTM_ReadRSSI BTM_ReadRSSI; 409 // Name: BTM_ReadTxPower 410 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport, 411 // tBTM_CMPL_CB* p_cb Returns: tBTM_STATUS 412 struct BTM_ReadTxPower { 413 std::function<tBTM_STATUS(const RawAddress& remote_bda, 414 tBT_TRANSPORT transport, tBTM_CMPL_CB* p_cb)> 415 body{[](const RawAddress& /* remote_bda */, tBT_TRANSPORT /* transport */, 416 tBTM_CMPL_CB* /* p_cb */) { return BT_TRANSPORT_BR_EDR; }}; operatorBTM_ReadTxPower417 tBTM_STATUS operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport, 418 tBTM_CMPL_CB* p_cb) { 419 return body(remote_bda, transport, p_cb); 420 }; 421 }; 422 extern struct BTM_ReadTxPower BTM_ReadTxPower; 423 // Name: BTM_SetLinkSuperTout 424 // Params: const RawAddress& remote_bda, uint16_t timeout 425 // Returns: tBTM_STATUS 426 struct BTM_SetLinkSuperTout { 427 std::function<tBTM_STATUS(const RawAddress& remote_bda, uint16_t timeout)> 428 body{[](const RawAddress& /* remote_bda */, uint16_t /* timeout */) { 429 return 0; 430 }}; operatorBTM_SetLinkSuperTout431 tBTM_STATUS operator()(const RawAddress& remote_bda, uint16_t timeout) { 432 return body(remote_bda, timeout); 433 }; 434 }; 435 extern struct BTM_SetLinkSuperTout BTM_SetLinkSuperTout; 436 // Name: BTM_SwitchRoleToCentral 437 // Params: const RawAddress& remote_bd_addr 438 // Returns: tBTM_STATUS 439 struct BTM_SwitchRoleToCentral { 440 std::function<tBTM_STATUS(const RawAddress& remote_bd_addr)> body{ 441 [](const RawAddress& /* remote_bd_addr */) { return 0; }}; operatorBTM_SwitchRoleToCentral442 tBTM_STATUS operator()(const RawAddress& remote_bd_addr) { 443 return body(remote_bd_addr); 444 }; 445 }; 446 extern struct BTM_SwitchRoleToCentral BTM_SwitchRoleToCentral; 447 // Name: btm_remove_acl 448 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport 449 // Returns: tBTM_STATUS 450 struct btm_remove_acl { 451 std::function<tBTM_STATUS(const RawAddress& bd_addr, tBT_TRANSPORT transport)> 452 body{[](const RawAddress& /* bd_addr */, tBT_TRANSPORT /* transport */) { 453 return BT_TRANSPORT_BR_EDR; 454 }}; operatorbtm_remove_acl455 tBTM_STATUS operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) { 456 return body(bd_addr, transport); 457 }; 458 }; 459 extern struct btm_remove_acl btm_remove_acl; 460 // Name: btm_get_acl_disc_reason_code 461 // Params: void 462 // Returns: tHCI_REASON 463 struct btm_get_acl_disc_reason_code { 464 std::function<tHCI_REASON(void)> body{[](void) { return HCI_SUCCESS; }}; operatorbtm_get_acl_disc_reason_code465 tHCI_REASON operator()(void) { return body(); }; 466 }; 467 extern struct btm_get_acl_disc_reason_code btm_get_acl_disc_reason_code; 468 // Name: btm_is_acl_locally_initiated 469 // Params: void 470 // Returns: bool 471 struct btm_is_acl_locally_initiated { 472 std::function<bool(void)> body{[](void) { return true; }}; operatorbtm_is_acl_locally_initiated473 bool operator()(void) { return body(); }; 474 }; 475 extern struct btm_is_acl_locally_initiated btm_is_acl_locally_initiated; 476 // Name: BTM_GetHCIConnHandle 477 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 478 // Returns: uint16_t 479 struct BTM_GetHCIConnHandle { 480 std::function<uint16_t(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 481 body{[](const RawAddress& /* remote_bda */, 482 tBT_TRANSPORT /* transport */) { return BT_TRANSPORT_BR_EDR; }}; operatorBTM_GetHCIConnHandle483 uint16_t operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 484 return body(remote_bda, transport); 485 }; 486 }; 487 extern struct BTM_GetHCIConnHandle BTM_GetHCIConnHandle; 488 // Name: BTM_GetMaxPacketSize 489 // Params: const RawAddress& addr 490 // Returns: uint16_t 491 struct BTM_GetMaxPacketSize { 492 std::function<uint16_t(const RawAddress& addr)> body{ 493 [](const RawAddress& /* addr */) { return 0; }}; operatorBTM_GetMaxPacketSize494 uint16_t operator()(const RawAddress& addr) { return body(addr); }; 495 }; 496 extern struct BTM_GetMaxPacketSize BTM_GetMaxPacketSize; 497 // Name: BTM_GetNumAclLinks 498 // Params: void 499 // Returns: uint16_t 500 struct BTM_GetNumAclLinks { 501 std::function<uint16_t(void)> body{[](void) { return 0; }}; operatorBTM_GetNumAclLinks502 uint16_t operator()(void) { return body(); }; 503 }; 504 extern struct BTM_GetNumAclLinks BTM_GetNumAclLinks; 505 // Name: acl_get_supported_packet_types 506 // Params: 507 // Returns: uint16_t 508 struct acl_get_supported_packet_types { 509 std::function<uint16_t()> body{[]() { return 0; }}; operatoracl_get_supported_packet_types510 uint16_t operator()() { return body(); }; 511 }; 512 extern struct acl_get_supported_packet_types acl_get_supported_packet_types; 513 // Name: BTM_GetPeerSCA 514 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 515 // Returns: uint8_t 516 struct BTM_GetPeerSCA { 517 std::function<uint8_t(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 518 body{[](const RawAddress& /* remote_bda */, 519 tBT_TRANSPORT /* transport */) { return BT_TRANSPORT_BR_EDR; }}; operatorBTM_GetPeerSCA520 uint8_t operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 521 return body(remote_bda, transport); 522 }; 523 }; 524 extern struct BTM_GetPeerSCA BTM_GetPeerSCA; 525 // Name: acl_link_role_from_handle 526 // Params: uint16_t handle 527 // Returns: uint8_t 528 struct acl_link_role_from_handle { 529 std::function<uint8_t(uint16_t handle)> body{ 530 [](uint16_t /* handle */) { return 0; }}; operatoracl_link_role_from_handle531 uint8_t operator()(uint16_t handle) { return body(handle); }; 532 }; 533 extern struct acl_link_role_from_handle acl_link_role_from_handle; 534 // Name: btm_handle_to_acl_index 535 // Params: uint16_t hci_handle 536 // Returns: uint8_t 537 struct btm_handle_to_acl_index { 538 std::function<uint8_t(uint16_t hci_handle)> body{ 539 [](uint16_t /* hci_handle */) { return 0; }}; operatorbtm_handle_to_acl_index540 uint8_t operator()(uint16_t hci_handle) { return body(hci_handle); }; 541 }; 542 extern struct btm_handle_to_acl_index btm_handle_to_acl_index; 543 // Name: BTM_ReadRemoteFeatures 544 // Params: const RawAddress& addr 545 // Returns: uint8_t* 546 struct BTM_ReadRemoteFeatures { 547 std::function<uint8_t*(const RawAddress& addr)> body{ 548 [](const RawAddress& /* addr */) { return nullptr; }}; operatorBTM_ReadRemoteFeatures549 uint8_t* operator()(const RawAddress& addr) { return body(addr); }; 550 }; 551 extern struct BTM_ReadRemoteFeatures BTM_ReadRemoteFeatures; 552 // Name: ACL_RegisterClient 553 // Params: struct acl_client_callback_s* callbacks 554 // Returns: void 555 struct ACL_RegisterClient { 556 std::function<void(struct acl_client_callback_s* callbacks)> body{ 557 [](struct acl_client_callback_s* /* callbacks */) { ; }}; operatorACL_RegisterClient558 void operator()(struct acl_client_callback_s* callbacks) { body(callbacks); }; 559 }; 560 extern struct ACL_RegisterClient ACL_RegisterClient; 561 // Name: ACL_UnregisterClient 562 // Params: struct acl_client_callback_s* callbacks 563 // Returns: void 564 struct ACL_UnregisterClient { 565 std::function<void(struct acl_client_callback_s* callbacks)> body{ 566 [](struct acl_client_callback_s* /* callbacks */) { ; }}; operatorACL_UnregisterClient567 void operator()(struct acl_client_callback_s* callbacks) { body(callbacks); }; 568 }; 569 extern struct ACL_UnregisterClient ACL_UnregisterClient; 570 // Name: BTM_ReadConnectionAddr 571 // Params: const RawAddress& remote_bda, RawAddress& local_conn_addr, bool 572 // ota_address tBLE_ADDR_TYPE* p_addr_type Returns: void 573 struct BTM_ReadConnectionAddr { 574 std::function<void(const RawAddress& remote_bda, RawAddress& local_conn_addr, 575 tBLE_ADDR_TYPE* p_addr_type, bool ota_address)> 576 body{[](const RawAddress& /* remote_bda */, 577 RawAddress& /* local_conn_addr */, 578 tBLE_ADDR_TYPE* /* p_addr_type */, bool /* ota_address */) { ; }}; operatorBTM_ReadConnectionAddr579 void operator()(const RawAddress& remote_bda, RawAddress& local_conn_addr, 580 tBLE_ADDR_TYPE* p_addr_type, bool ota_address) { 581 body(remote_bda, local_conn_addr, p_addr_type, ota_address); 582 }; 583 }; 584 extern struct BTM_ReadConnectionAddr BTM_ReadConnectionAddr; 585 // Name: BTM_RequestPeerSCA 586 // Params: const RawAddress& remote_bda, tBT_TRANSPORT transport 587 // Returns: void 588 struct BTM_RequestPeerSCA { 589 std::function<void(const RawAddress& remote_bda, tBT_TRANSPORT transport)> 590 body{[](const RawAddress& /* remote_bda */, 591 tBT_TRANSPORT /* transport */) { ; }}; operatorBTM_RequestPeerSCA592 void operator()(const RawAddress& remote_bda, tBT_TRANSPORT transport) { 593 body(remote_bda, transport); 594 }; 595 }; 596 extern struct BTM_RequestPeerSCA BTM_RequestPeerSCA; 597 // Name: BTM_acl_after_controller_started 598 // Returns: void 599 struct BTM_acl_after_controller_started { 600 std::function<void()> body{[]() { ; }}; operatorBTM_acl_after_controller_started601 void operator()() { body(); }; 602 }; 603 extern struct BTM_acl_after_controller_started BTM_acl_after_controller_started; 604 // Name: BTM_block_role_switch_for 605 // Params: const RawAddress& peer_addr 606 // Returns: void 607 struct BTM_block_role_switch_for { 608 std::function<void(const RawAddress& peer_addr)> body{ 609 [](const RawAddress& /* peer_addr */) { ; }}; operatorBTM_block_role_switch_for610 void operator()(const RawAddress& peer_addr) { body(peer_addr); }; 611 }; 612 extern struct BTM_block_role_switch_for BTM_block_role_switch_for; 613 // Name: BTM_block_sniff_mode_for 614 // Params: const RawAddress& peer_addr 615 // Returns: void 616 struct BTM_block_sniff_mode_for { 617 std::function<void(const RawAddress& peer_addr)> body{ 618 [](const RawAddress& /* peer_addr */) { ; }}; operatorBTM_block_sniff_mode_for619 void operator()(const RawAddress& peer_addr) { body(peer_addr); }; 620 }; 621 extern struct BTM_block_sniff_mode_for BTM_block_sniff_mode_for; 622 // Name: BTM_default_unblock_role_switch 623 // Params: 624 // Returns: void 625 struct BTM_default_unblock_role_switch { 626 std::function<void()> body{[]() { ; }}; operatorBTM_default_unblock_role_switch627 void operator()() { body(); }; 628 }; 629 extern struct BTM_default_unblock_role_switch BTM_default_unblock_role_switch; 630 // Name: BTM_unblock_role_switch_for 631 // Params: const RawAddress& peer_addr 632 // Returns: void 633 struct BTM_unblock_role_switch_for { 634 std::function<void(const RawAddress& peer_addr)> body{ 635 [](const RawAddress& /* peer_addr */) { ; }}; operatorBTM_unblock_role_switch_for636 void operator()(const RawAddress& peer_addr) { body(peer_addr); }; 637 }; 638 extern struct BTM_unblock_role_switch_for BTM_unblock_role_switch_for; 639 // Name: BTM_unblock_sniff_mode_for 640 // Params: const RawAddress& peer_addr 641 // Returns: void 642 struct BTM_unblock_sniff_mode_for { 643 std::function<void(const RawAddress& peer_addr)> body{ 644 [](const RawAddress& /* peer_addr */) { ; }}; operatorBTM_unblock_sniff_mode_for645 void operator()(const RawAddress& peer_addr) { body(peer_addr); }; 646 }; 647 extern struct BTM_unblock_sniff_mode_for BTM_unblock_sniff_mode_for; 648 // Name: acl_disconnect_after_role_switch 649 // Params: uint16_t conn_handle, tHCI_STATUS reason 650 // Returns: void 651 struct acl_disconnect_after_role_switch { 652 std::function<void(uint16_t conn_handle, tHCI_STATUS reason, 653 std::string comment)> 654 body{[](uint16_t /* conn_handle */, tHCI_STATUS /* reason */, 655 std::string /* comment */) { ; }}; operatoracl_disconnect_after_role_switch656 void operator()(uint16_t conn_handle, tHCI_STATUS reason, 657 std::string comment) { 658 body(conn_handle, reason, comment); 659 }; 660 }; 661 extern struct acl_disconnect_after_role_switch acl_disconnect_after_role_switch; 662 // Name: acl_disconnect_from_handle 663 // Params: uint16_t handle, tHCI_STATUS reason 664 // Returns: void 665 struct acl_disconnect_from_handle { 666 std::function<void(uint16_t handle, tHCI_STATUS reason, std::string comment)> 667 body{[](uint16_t /* handle */, tHCI_STATUS /* reason */, 668 std::string /* comment */) { ; }}; operatoracl_disconnect_from_handle669 void operator()(uint16_t handle, tHCI_STATUS reason, std::string comment) { 670 body(handle, reason, comment); 671 }; 672 }; 673 extern struct acl_disconnect_from_handle acl_disconnect_from_handle; 674 // Name: acl_packets_completed 675 // Params: uint16_t handle, uint16_t credits 676 // Returns: void 677 struct acl_packets_completed { 678 std::function<void(uint16_t handle, uint16_t credits)> body{ 679 [](uint16_t /* handle */, uint16_t /* credits */) { ; }}; operatoracl_packets_completed680 void operator()(uint16_t handle, uint16_t credits) { body(handle, credits); }; 681 }; 682 extern struct acl_packets_completed acl_packets_completed; 683 // Name: acl_process_extended_features 684 // Params: uint16_t handle, uint8_t current_page_number, uint8_t 685 // max_page_number, uint64_t features Returns: void 686 struct acl_process_extended_features { 687 std::function<void(uint16_t handle, uint8_t current_page_number, 688 uint8_t max_page_number, uint64_t features)> 689 body{[](uint16_t /* handle */, uint8_t /* current_page_number */, 690 uint8_t /* max_page_number */, uint64_t /* features */) { ; }}; operatoracl_process_extended_features691 void operator()(uint16_t handle, uint8_t current_page_number, 692 uint8_t max_page_number, uint64_t features) { 693 body(handle, current_page_number, max_page_number, features); 694 }; 695 }; 696 extern struct acl_process_extended_features acl_process_extended_features; 697 // Name: acl_process_supported_features 698 // Params: uint16_t handle, uint64_t features 699 // Returns: void 700 struct acl_process_supported_features { 701 std::function<void(uint16_t handle, uint64_t features)> body{ 702 [](uint16_t /* handle */, uint64_t /* features */) { ; }}; operatoracl_process_supported_features703 void operator()(uint16_t handle, uint64_t features) { 704 body(handle, features); 705 }; 706 }; 707 extern struct acl_process_supported_features acl_process_supported_features; 708 // Name: acl_rcv_acl_data 709 // Params: BT_HDR* p_msg 710 // Returns: void 711 struct acl_rcv_acl_data { 712 std::function<void(BT_HDR* p_msg)> body{[](BT_HDR* /* p_msg */) { ; }}; operatoracl_rcv_acl_data713 void operator()(BT_HDR* p_msg) { body(p_msg); }; 714 }; 715 extern struct acl_rcv_acl_data acl_rcv_acl_data; 716 // Name: acl_send_data_packet_ble 717 // Params: const RawAddress& bd_addr, BT_HDR* p_buf 718 // Returns: void 719 struct acl_send_data_packet_ble { 720 std::function<void(const RawAddress& bd_addr, BT_HDR* p_buf)> body{ 721 [](const RawAddress& /* bd_addr */, BT_HDR* /* p_buf */) { ; }}; operatoracl_send_data_packet_ble722 void operator()(const RawAddress& bd_addr, BT_HDR* p_buf) { 723 body(bd_addr, p_buf); 724 }; 725 }; 726 extern struct acl_send_data_packet_ble acl_send_data_packet_ble; 727 // Name: acl_set_disconnect_reason 728 // Params: tHCI_STATUS acl_disc_reason 729 // Returns: void 730 struct acl_set_disconnect_reason { 731 std::function<void(tHCI_STATUS acl_disc_reason)> body{ 732 [](tHCI_STATUS /* acl_disc_reason */) { ; }}; operatoracl_set_disconnect_reason733 void operator()(tHCI_STATUS acl_disc_reason) { body(acl_disc_reason); }; 734 }; 735 extern struct acl_set_disconnect_reason acl_set_disconnect_reason; 736 // Name: acl_write_automatic_flush_timeout 737 // Params: const RawAddress& bd_addr, uint16_t flush_timeout_in_ticks 738 // Returns: void 739 struct acl_write_automatic_flush_timeout { 740 std::function<void(const RawAddress& bd_addr, 741 uint16_t flush_timeout_in_ticks)> 742 body{[](const RawAddress& /* bd_addr */, 743 uint16_t /* flush_timeout_in_ticks */) { ; }}; operatoracl_write_automatic_flush_timeout744 void operator()(const RawAddress& bd_addr, uint16_t flush_timeout_in_ticks) { 745 body(bd_addr, flush_timeout_in_ticks); 746 }; 747 }; 748 extern struct acl_write_automatic_flush_timeout 749 acl_write_automatic_flush_timeout; 750 // Name: btm_acl_connected 751 // Params: const RawAddress& bda, uint16_t handle, tHCI_STATUS status, uint8_t 752 // enc_mode Returns: void 753 struct btm_acl_connected { 754 std::function<void(const RawAddress& bda, uint16_t handle, tHCI_STATUS status, 755 uint8_t enc_mode)> 756 body{[](const RawAddress& /* bda */, uint16_t /* handle */, 757 tHCI_STATUS /* status */, uint8_t /* enc_mode */) { ; }}; operatorbtm_acl_connected758 void operator()(const RawAddress& bda, uint16_t handle, tHCI_STATUS status, 759 uint8_t enc_mode) { 760 body(bda, handle, status, enc_mode); 761 }; 762 }; 763 extern struct btm_acl_connected btm_acl_connected; 764 // Name: btm_connection_request 765 // Params: const RawAddress& bda, const bluetooth::hci::ClassOfDevice& cod 766 // Returns: void 767 struct btm_connection_request { 768 std::function<void(const RawAddress& bda, 769 const bluetooth::hci::ClassOfDevice& cod)> 770 body{[](const RawAddress& /* bda */, 771 const bluetooth::hci::ClassOfDevice& /* cod */) { ; }}; operatorbtm_connection_request772 void operator()(const RawAddress& bda, 773 const bluetooth::hci::ClassOfDevice& cod) { 774 body(bda, cod); 775 }; 776 }; 777 extern struct btm_connection_request btm_connection_request; 778 // Name: btm_acl_created 779 // Params: const RawAddress& bda, uint16_t hci_handle, tHCI_ROLE link_role, 780 // tBT_TRANSPORT transport Returns: void 781 struct btm_acl_created { 782 std::function<void(const RawAddress& bda, uint16_t hci_handle, 783 tHCI_ROLE link_role, tBT_TRANSPORT transport)> 784 body{[](const RawAddress& /* bda */, uint16_t /* hci_handle */, 785 tHCI_ROLE /* link_role */, tBT_TRANSPORT /* transport */) { ; }}; operatorbtm_acl_created786 void operator()(const RawAddress& bda, uint16_t hci_handle, 787 tHCI_ROLE link_role, tBT_TRANSPORT transport) { 788 body(bda, hci_handle, link_role, transport); 789 }; 790 }; 791 extern struct btm_acl_created btm_acl_created; 792 // Name: btm_acl_device_down 793 // Params: void 794 // Returns: void 795 struct btm_acl_device_down { 796 std::function<void(void)> body{[](void) { ; }}; operatorbtm_acl_device_down797 void operator()(void) { body(); }; 798 }; 799 extern struct btm_acl_device_down btm_acl_device_down; 800 // Name: btm_acl_disconnected 801 // Params: tHCI_STATUS status, uint16_t handle, tHCI_REASON reason 802 // Returns: void 803 struct btm_acl_disconnected { 804 std::function<void(tHCI_STATUS status, uint16_t handle, tHCI_REASON reason)> 805 body{[](tHCI_STATUS /* status */, uint16_t /* handle */, 806 tHCI_REASON /* reason */) { ; }}; operatorbtm_acl_disconnected807 void operator()(tHCI_STATUS status, uint16_t handle, tHCI_REASON reason) { 808 body(status, handle, reason); 809 }; 810 }; 811 extern struct btm_acl_disconnected btm_acl_disconnected; 812 // Name: btm_acl_encrypt_change 813 // Params: uint16_t handle, uint8_t status, uint8_t encr_enable 814 // Returns: void 815 struct btm_acl_encrypt_change { 816 std::function<void(uint16_t handle, uint8_t status, uint8_t encr_enable)> 817 body{[](uint16_t /* handle */, uint8_t /* status */, 818 uint8_t /* encr_enable */) { ; }}; operatorbtm_acl_encrypt_change819 void operator()(uint16_t handle, uint8_t status, uint8_t encr_enable) { 820 body(handle, status, encr_enable); 821 }; 822 }; 823 extern struct btm_acl_encrypt_change btm_acl_encrypt_change; 824 // Name: btm_acl_notif_conn_collision 825 // Params: const RawAddress& bda 826 // Returns: void 827 struct btm_acl_notif_conn_collision { 828 std::function<void(const RawAddress& bda)> body{ 829 [](const RawAddress& /* bda */) { ; }}; operatorbtm_acl_notif_conn_collision830 void operator()(const RawAddress& bda) { body(bda); }; 831 }; 832 extern struct btm_acl_notif_conn_collision btm_acl_notif_conn_collision; 833 // Name: btm_acl_process_sca_cmpl_pkt 834 // Params: uint8_t len, uint8_t* data 835 // Returns: void 836 struct btm_acl_process_sca_cmpl_pkt { 837 std::function<void(uint8_t len, uint8_t* data)> body{ 838 [](uint8_t /* len */, uint8_t* /* data */) { ; }}; operatorbtm_acl_process_sca_cmpl_pkt839 void operator()(uint8_t len, uint8_t* data) { body(len, data); }; 840 }; 841 extern struct btm_acl_process_sca_cmpl_pkt btm_acl_process_sca_cmpl_pkt; 842 // Name: btm_acl_removed 843 // Params: uint16_t handle 844 // Returns: void 845 struct btm_acl_removed { 846 std::function<void(uint16_t handle)> body{[](uint16_t /* handle */) { ; }}; operatorbtm_acl_removed847 void operator()(uint16_t handle) { body(handle); }; 848 }; 849 extern struct btm_acl_removed btm_acl_removed; 850 // Name: btm_acl_flush 851 // Params: uint16_t handle 852 // Returns: void 853 struct btm_acl_flush { 854 std::function<void(uint16_t handle)> body{[](uint16_t /* handle */) { ; }}; operatorbtm_acl_flush855 void operator()(uint16_t handle) { body(handle); }; 856 }; 857 extern struct btm_acl_flush btm_acl_flush; 858 // Name: btm_acl_role_changed 859 // Params: tHCI_STATUS hci_status, const RawAddress& bd_addr, tHCI_ROLE 860 // new_role Returns: void 861 struct btm_acl_role_changed { 862 std::function<void(tHCI_STATUS hci_status, const RawAddress& bd_addr, 863 tHCI_ROLE new_role)> 864 body{[](tHCI_STATUS /* hci_status */, const RawAddress& /* bd_addr */, 865 tHCI_ROLE /* new_role */) { ; }}; operatorbtm_acl_role_changed866 void operator()(tHCI_STATUS hci_status, const RawAddress& bd_addr, 867 tHCI_ROLE new_role) { 868 body(hci_status, bd_addr, new_role); 869 }; 870 }; 871 extern struct btm_acl_role_changed btm_acl_role_changed; 872 // Name: btm_acl_update_conn_addr 873 // Params: uint16_t handle, const RawAddress& address 874 // Returns: void 875 struct btm_acl_update_conn_addr { 876 std::function<void(uint16_t handle, const RawAddress& address)> body{ 877 [](uint16_t /* handle */, const RawAddress& /* address */) { ; }}; operatorbtm_acl_update_conn_addr878 void operator()(uint16_t handle, const RawAddress& address) { 879 body(handle, address); 880 }; 881 }; 882 extern struct btm_acl_update_conn_addr btm_acl_update_conn_addr; 883 // Name: btm_ble_refresh_local_resolvable_private_addr 884 // Params: const RawAddress& pseudo_addr, const RawAddress& local_rpa 885 // Returns: void 886 struct btm_ble_refresh_local_resolvable_private_addr { 887 std::function<void(const RawAddress& pseudo_addr, 888 const RawAddress& local_rpa)> 889 body{[](const RawAddress& /* pseudo_addr */, 890 const RawAddress& /* local_rpa */) { ; }}; operatorbtm_ble_refresh_local_resolvable_private_addr891 void operator()(const RawAddress& pseudo_addr, const RawAddress& local_rpa) { 892 body(pseudo_addr, local_rpa); 893 }; 894 }; 895 extern struct btm_ble_refresh_local_resolvable_private_addr 896 btm_ble_refresh_local_resolvable_private_addr; 897 // Name: btm_cont_rswitch_from_handle 898 // Params: uint16_t hci_handle 899 // Returns: void 900 struct btm_cont_rswitch_from_handle { 901 std::function<void(uint16_t hci_handle)> body{ 902 [](uint16_t /* hci_handle */) { ; }}; operatorbtm_cont_rswitch_from_handle903 void operator()(uint16_t hci_handle) { body(hci_handle); }; 904 }; 905 extern struct btm_cont_rswitch_from_handle btm_cont_rswitch_from_handle; 906 // Name: btm_establish_continue_from_address 907 // Params: const RawAddress& bda, tBT_TRANSPORT transport 908 // Returns: void 909 struct btm_establish_continue_from_address { 910 std::function<void(const RawAddress& bda, tBT_TRANSPORT transport)> body{ 911 [](const RawAddress& /* bda */, tBT_TRANSPORT /* transport */) { ; }}; operatorbtm_establish_continue_from_address912 void operator()(const RawAddress& bda, tBT_TRANSPORT transport) { 913 body(bda, transport); 914 }; 915 }; 916 extern struct btm_establish_continue_from_address 917 btm_establish_continue_from_address; 918 // Name: btm_process_remote_ext_features 919 // Params: tACL_CONN* p_acl_cb, uint8_t max_page_number 920 // Returns: void 921 struct btm_process_remote_ext_features { 922 std::function<void(tACL_CONN* p_acl_cb, uint8_t max_page_number)> body{ 923 [](tACL_CONN* /* p_acl_cb */, uint8_t /* max_page_number */) { ; }}; operatorbtm_process_remote_ext_features924 void operator()(tACL_CONN* p_acl_cb, uint8_t max_page_number) { 925 body(p_acl_cb, max_page_number); 926 }; 927 }; 928 extern struct btm_process_remote_ext_features btm_process_remote_ext_features; 929 // Name: btm_process_remote_version_complete 930 // Params: uint8_t status, uint16_t handle, uint8_t lmp_version, uint16_t 931 // manufacturer, uint16_t lmp_subversion Returns: void 932 struct btm_process_remote_version_complete { 933 std::function<void(uint8_t status, uint16_t handle, uint8_t lmp_version, 934 uint16_t manufacturer, uint16_t lmp_subversion)> 935 body{[](uint8_t /* status */, uint16_t /* handle */, 936 uint8_t /* lmp_version */, uint16_t /* manufacturer */, 937 uint16_t /* lmp_subversion */) { ; }}; operatorbtm_process_remote_version_complete938 void operator()(uint8_t status, uint16_t handle, uint8_t lmp_version, 939 uint16_t manufacturer, uint16_t lmp_subversion) { 940 body(status, handle, lmp_version, manufacturer, lmp_subversion); 941 }; 942 }; 943 extern struct btm_process_remote_version_complete 944 btm_process_remote_version_complete; 945 // Name: btm_read_automatic_flush_timeout_complete 946 // Params: uint8_t* p 947 // Returns: void 948 struct btm_read_automatic_flush_timeout_complete { 949 std::function<void(uint8_t* p)> body{[](uint8_t* /* p */) { ; }}; operatorbtm_read_automatic_flush_timeout_complete950 void operator()(uint8_t* p) { body(p); }; 951 }; 952 extern struct btm_read_automatic_flush_timeout_complete 953 btm_read_automatic_flush_timeout_complete; 954 // Name: btm_read_failed_contact_counter_complete 955 // Params: uint8_t* p 956 // Returns: void 957 struct btm_read_failed_contact_counter_complete { 958 std::function<void(uint8_t* p)> body{[](uint8_t* /* p */) { ; }}; operatorbtm_read_failed_contact_counter_complete959 void operator()(uint8_t* p) { body(p); }; 960 }; 961 extern struct btm_read_failed_contact_counter_complete 962 btm_read_failed_contact_counter_complete; 963 // Name: btm_read_failed_contact_counter_timeout 964 // Params: void* data 965 // Returns: void 966 struct btm_read_failed_contact_counter_timeout { 967 std::function<void(void* data)> body{[](void* /* data */) { ; }}; operatorbtm_read_failed_contact_counter_timeout968 void operator()(void* data) { body(data); }; 969 }; 970 extern struct btm_read_failed_contact_counter_timeout 971 btm_read_failed_contact_counter_timeout; 972 // Name: btm_read_remote_ext_features 973 // Params: uint16_t handle, uint8_t page_number 974 // Returns: void 975 struct btm_read_remote_ext_features { 976 std::function<void(uint16_t handle, uint8_t page_number)> body{ 977 [](uint16_t /* handle */, uint8_t /* page_number */) { ; }}; operatorbtm_read_remote_ext_features978 void operator()(uint16_t handle, uint8_t page_number) { 979 body(handle, page_number); 980 }; 981 }; 982 extern struct btm_read_remote_ext_features btm_read_remote_ext_features; 983 // Name: btm_read_remote_ext_features_complete 984 // Params: uint16_t handle, uint8_t page_num, uint8_t max_page, uint8_t* 985 // features Returns: void 986 struct btm_read_remote_ext_features_complete { 987 std::function<void(uint16_t handle, uint8_t page_num, uint8_t max_page, 988 uint8_t* features)> 989 body{[](uint16_t /* handle */, uint8_t /* page_num */, 990 uint8_t /* max_page */, uint8_t* /* features */) { ; }}; operatorbtm_read_remote_ext_features_complete991 void operator()(uint16_t handle, uint8_t page_num, uint8_t max_page, 992 uint8_t* features) { 993 body(handle, page_num, max_page, features); 994 }; 995 }; 996 extern struct btm_read_remote_ext_features_complete 997 btm_read_remote_ext_features_complete; 998 // Name: btm_read_remote_ext_features_complete_raw 999 // Params: uint8_t* p, uint8_t evt_len 1000 // Returns: void 1001 struct btm_read_remote_ext_features_complete_raw { 1002 std::function<void(uint8_t* p, uint8_t evt_len)> body{ 1003 [](uint8_t* /* p */, uint8_t /* evt_len */) { ; }}; operatorbtm_read_remote_ext_features_complete_raw1004 void operator()(uint8_t* p, uint8_t evt_len) { body(p, evt_len); }; 1005 }; 1006 extern struct btm_read_remote_ext_features_complete_raw 1007 btm_read_remote_ext_features_complete_raw; 1008 // Name: btm_read_remote_ext_features_failed 1009 // Params: uint8_t status, uint16_t handle 1010 // Returns: void 1011 struct btm_read_remote_ext_features_failed { 1012 std::function<void(uint8_t status, uint16_t handle)> body{ 1013 [](uint8_t /* status */, uint16_t /* handle */) { ; }}; operatorbtm_read_remote_ext_features_failed1014 void operator()(uint8_t status, uint16_t handle) { body(status, handle); }; 1015 }; 1016 extern struct btm_read_remote_ext_features_failed 1017 btm_read_remote_ext_features_failed; 1018 // Name: btm_read_remote_version_complete 1019 // Params: tHCI_STATUS status, uint16_t handle, uint8_t lmp_version, uint16_t 1020 // manufacturer, uint16_t lmp_subversion Returns: void 1021 struct btm_read_remote_version_complete { 1022 std::function<void(tHCI_STATUS status, uint16_t handle, uint8_t lmp_version, 1023 uint16_t manufacturer, uint16_t lmp_subversion)> 1024 body{[](tHCI_STATUS /* status */, uint16_t /* handle */, 1025 uint8_t /* lmp_version */, uint16_t /* manufacturer */, 1026 uint16_t /* lmp_subversion */) { ; }}; operatorbtm_read_remote_version_complete1027 void operator()(tHCI_STATUS status, uint16_t handle, uint8_t lmp_version, 1028 uint16_t manufacturer, uint16_t lmp_subversion) { 1029 body(status, handle, lmp_version, manufacturer, lmp_subversion); 1030 }; 1031 }; 1032 extern struct btm_read_remote_version_complete btm_read_remote_version_complete; 1033 // Name: btm_read_rssi_complete 1034 // Params: uint8_t* p 1035 // Returns: void 1036 struct btm_read_rssi_complete { 1037 std::function<void(uint8_t* p, uint16_t evt_len)> body{ 1038 [](uint8_t* /* pm */, uint16_t /* evt_len */) { ; }}; operatorbtm_read_rssi_complete1039 void operator()(uint8_t* p, uint16_t evt_len) { body(p, evt_len); }; 1040 }; 1041 extern struct btm_read_rssi_complete btm_read_rssi_complete; 1042 // Name: btm_read_rssi_timeout 1043 // Params: void* data 1044 // Returns: void 1045 struct btm_read_rssi_timeout { 1046 std::function<void(void* data)> body{[](void* /* data */) { ; }}; operatorbtm_read_rssi_timeout1047 void operator()(void* data) { body(data); }; 1048 }; 1049 extern struct btm_read_rssi_timeout btm_read_rssi_timeout; 1050 // Name: btm_read_tx_power_complete 1051 // Params: uint8_t* p, bool is_ble 1052 // Returns: void 1053 struct btm_read_tx_power_complete { 1054 std::function<void(uint8_t* p, uint16_t evt_len, bool is_ble)> body{ 1055 [](uint8_t* /* p */, uint16_t /* evt_len */, bool /* is_ble */) { ; }}; operatorbtm_read_tx_power_complete1056 void operator()(uint8_t* p, uint16_t evt_len, bool is_ble) { 1057 body(p, evt_len, is_ble); 1058 }; 1059 }; 1060 extern struct btm_read_tx_power_complete btm_read_tx_power_complete; 1061 // Name: btm_read_tx_power_timeout 1062 // Params: void* data 1063 // Returns: void 1064 struct btm_read_tx_power_timeout { 1065 std::function<void(void* data)> body{[](void* /* data */) { ; }}; operatorbtm_read_tx_power_timeout1066 void operator()(void* data) { body(data); }; 1067 }; 1068 extern struct btm_read_tx_power_timeout btm_read_tx_power_timeout; 1069 // Name: btm_rejectlist_role_change_device 1070 // Params: const RawAddress& bd_addr, uint8_t hci_status 1071 // Returns: void 1072 struct btm_rejectlist_role_change_device { 1073 std::function<void(const RawAddress& bd_addr, uint8_t hci_status)> body{ 1074 [](const RawAddress& /* bd_addr */, uint8_t /* hci_status */) { ; }}; operatorbtm_rejectlist_role_change_device1075 void operator()(const RawAddress& bd_addr, uint8_t hci_status) { 1076 body(bd_addr, hci_status); 1077 }; 1078 }; 1079 extern struct btm_rejectlist_role_change_device 1080 btm_rejectlist_role_change_device; 1081 // Name: btm_set_link_policy 1082 // Params: tACL_CONN* conn, tLINK_POLICY policy 1083 // Returns: void 1084 struct btm_set_link_policy { 1085 std::function<void(tACL_CONN* conn, tLINK_POLICY policy)> body{ 1086 [](tACL_CONN* /* conn */, tLINK_POLICY /* policy */) { ; }}; operatorbtm_set_link_policy1087 void operator()(tACL_CONN* conn, tLINK_POLICY policy) { body(conn, policy); }; 1088 }; 1089 extern struct btm_set_link_policy btm_set_link_policy; 1090 // Name: btm_set_packet_types_from_address 1091 // Params: const RawAddress& bd_addr, uint16_t pkt_types 1092 // Returns: void 1093 struct btm_set_packet_types_from_address { 1094 std::function<void(const RawAddress& bd_addr, uint16_t pkt_types)> body{ 1095 [](const RawAddress& /* bd_addr */, uint16_t /* pkt_types */) { ; }}; operatorbtm_set_packet_types_from_address1096 void operator()(const RawAddress& bd_addr, uint16_t pkt_types) { 1097 body(bd_addr, pkt_types); 1098 }; 1099 }; 1100 extern struct btm_set_packet_types_from_address 1101 btm_set_packet_types_from_address; 1102 // Name: hci_btm_set_link_supervision_timeout 1103 // Params: tACL_CONN& link, uint16_t timeout 1104 // Returns: void 1105 struct hci_btm_set_link_supervision_timeout { 1106 std::function<void(tACL_CONN& link, uint16_t timeout)> body{ 1107 [](tACL_CONN& /* link */, uint16_t /* timeout */) { ; }}; operatorhci_btm_set_link_supervision_timeout1108 void operator()(tACL_CONN& link, uint16_t timeout) { body(link, timeout); }; 1109 }; 1110 extern struct hci_btm_set_link_supervision_timeout 1111 hci_btm_set_link_supervision_timeout; 1112 // Name: on_acl_br_edr_connected 1113 // Params: const RawAddress& bda, uint16_t handle, uint8_t enc_mode, bool 1114 // locally_initiated Returns: void 1115 struct on_acl_br_edr_connected { 1116 std::function<void(const RawAddress& bda, uint16_t handle, uint8_t enc_mode, 1117 bool locally_initiated)> 1118 body{[](const RawAddress& /* bda */, uint16_t /* handle */, 1119 uint8_t /* enc_mode */, bool /* locally_initiated */) { ; }}; operatoron_acl_br_edr_connected1120 void operator()(const RawAddress& bda, uint16_t handle, uint8_t enc_mode, 1121 bool locally_initiated) { 1122 body(bda, handle, enc_mode, locally_initiated); 1123 }; 1124 }; 1125 extern struct on_acl_br_edr_connected on_acl_br_edr_connected; 1126 // Name: on_acl_br_edr_failed 1127 // Params: const RawAddress& bda, tHCI_STATUS status, bool locally_initiated 1128 // Returns: void 1129 struct on_acl_br_edr_failed { 1130 std::function<void(const RawAddress& bda, tHCI_STATUS status, 1131 bool locally_initiated)> 1132 body{[](const RawAddress& /* bda */, tHCI_STATUS /* status */, 1133 bool /* locally_initiated */) { ; }}; operatoron_acl_br_edr_failed1134 void operator()(const RawAddress& bda, tHCI_STATUS status, 1135 bool locally_initiated) { 1136 body(bda, status, locally_initiated); 1137 }; 1138 }; 1139 extern struct on_acl_br_edr_failed on_acl_br_edr_failed; 1140 1141 // Manually added 1142 struct BTM_unblock_role_switch_and_sniff_mode_for { 1143 std::function<void(const RawAddress& peer_addr)> body{ 1144 [](const RawAddress& /* peer_addr */) {}}; operatorBTM_unblock_role_switch_and_sniff_mode_for1145 void operator()(const RawAddress& peer_addr) { body(peer_addr); }; 1146 }; 1147 extern struct BTM_unblock_role_switch_and_sniff_mode_for 1148 BTM_unblock_role_switch_and_sniff_mode_for; 1149 1150 } // namespace stack_acl 1151 } // namespace mock 1152 } // namespace test 1153 1154 // END mockcify generation 1155