1 /* 2 * Copyright 2023 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #pragma once 17 18 /* 19 * Generated mock file from original source file 20 * Functions generated:43 21 * 22 * mockcify.pl ver 0.6.0 23 */ 24 25 #include <cstdint> 26 #include <functional> 27 28 // Original included files, if any 29 30 #include "bta/include/bta_av_api.h" 31 #include "btif/include/btif_av.h" 32 #include "include/hardware/bt_av.h" 33 #include "types/raw_address.h" 34 35 // Original usings 36 typedef enum { 37 /* Reuse BTA_AV_XXX_EVT - No need to redefine them here */ 38 BTIF_AV_CONNECT_REQ_EVT = BTA_AV_MAX_EVT, 39 BTIF_AV_DISCONNECT_REQ_EVT, 40 BTIF_AV_START_STREAM_REQ_EVT, 41 BTIF_AV_STOP_STREAM_REQ_EVT, 42 BTIF_AV_SUSPEND_STREAM_REQ_EVT, 43 BTIF_AV_SINK_CONFIG_REQ_EVT, 44 BTIF_AV_ACL_DISCONNECTED, 45 BTIF_AV_OFFLOAD_START_REQ_EVT, 46 BTIF_AV_AVRCP_OPEN_EVT, 47 BTIF_AV_AVRCP_CLOSE_EVT, 48 BTIF_AV_AVRCP_REMOTE_PLAY_EVT, 49 BTIF_AV_SET_LATENCY_REQ_EVT, 50 } btif_av_sm_event_t; 51 52 // Mocked compile conditionals, if any 53 54 namespace test { 55 namespace mock { 56 namespace btif_av { 57 58 // Shared state between mocked functions and tests 59 // Name: btif_av_acl_disconnected 60 // Params: const RawAddress& peer_address 61 // Params: const A2dpType local_a2dp_type. 62 // Return: void 63 struct btif_av_acl_disconnected { 64 std::function<void(const RawAddress& peer_address, const A2dpType local_a2dp_type)> body{ 65 [](const RawAddress& /* peer_address */, const A2dpType /* local_a2dp_type */) {}}; operatorbtif_av_acl_disconnected66 void operator()(const RawAddress& peer_address, const A2dpType local_a2dp_type) { 67 body(peer_address, local_a2dp_type); 68 } 69 }; 70 extern struct btif_av_acl_disconnected btif_av_acl_disconnected; 71 72 // Name: btif_av_clear_remote_suspend_flag 73 // Params: const A2dpType local_a2dp_type. 74 // Return: void 75 struct btif_av_clear_remote_suspend_flag { 76 std::function<void(const A2dpType local_a2dp_type)> body{ 77 [](const A2dpType /* local_a2dp_type */) {}}; operatorbtif_av_clear_remote_suspend_flag78 void operator()(const A2dpType local_a2dp_type) { body(local_a2dp_type); } 79 }; 80 extern struct btif_av_clear_remote_suspend_flag btif_av_clear_remote_suspend_flag; 81 82 // Name: btif_av_find_by_handle 83 // Params: tBTA_AV_HNDL bta_handle 84 // Return: const RawAddress& 85 struct btif_av_find_by_handle { 86 static const RawAddress& return_value; 87 std::function<const RawAddress&(tBTA_AV_HNDL bta_handle)> body{ 88 [](tBTA_AV_HNDL /* bta_handle */) { return return_value; }}; operatorbtif_av_find_by_handle89 const RawAddress& operator()(tBTA_AV_HNDL bta_handle) { return body(bta_handle); } 90 }; 91 extern struct btif_av_find_by_handle btif_av_find_by_handle; 92 93 // Name: btif_av_get_audio_delay 94 // Params: const A2dpType local_a2dp_type. 95 // Return: uint16_t 96 struct btif_av_get_audio_delay { 97 static uint16_t return_value; 98 std::function<uint16_t(const A2dpType local_a2dp_type)> body{ 99 [](const A2dpType /* local_a2dp_type */) { return return_value; }}; operatorbtif_av_get_audio_delay100 uint16_t operator()(const A2dpType local_a2dp_type) { return body(local_a2dp_type); } 101 }; 102 extern struct btif_av_get_audio_delay btif_av_get_audio_delay; 103 104 // Name: btif_av_get_peer_sep 105 // Params: const A2dpType local_a2dp_type. 106 // Return: uint8_t 107 struct btif_av_get_peer_sep { 108 static uint8_t return_value; 109 std::function<uint8_t(const A2dpType local_a2dp_type)> body{ 110 [](const A2dpType /* local_a2dp_type */) { return return_value; }}; operatorbtif_av_get_peer_sep111 uint8_t operator()(const A2dpType local_a2dp_type) { return body(local_a2dp_type); } 112 }; 113 extern struct btif_av_get_peer_sep btif_av_get_peer_sep; 114 115 // Name: btif_av_is_a2dp_offload_enabled 116 // Params: 117 // Return: bool 118 struct btif_av_is_a2dp_offload_enabled { 119 static bool return_value; 120 std::function<bool()> body{[]() { return return_value; }}; operatorbtif_av_is_a2dp_offload_enabled121 bool operator()() { return body(); } 122 }; 123 extern struct btif_av_is_a2dp_offload_enabled btif_av_is_a2dp_offload_enabled; 124 125 // Name: btif_av_is_a2dp_offload_running 126 // Params: 127 // Return: bool 128 struct btif_av_is_a2dp_offload_running { 129 static bool return_value; 130 std::function<bool()> body{[]() { return return_value; }}; operatorbtif_av_is_a2dp_offload_running131 bool operator()() { return body(); } 132 }; 133 extern struct btif_av_is_a2dp_offload_running btif_av_is_a2dp_offload_running; 134 135 // Name: btif_av_is_connected 136 // Params: const A2dpType local_a2dp_type. 137 // Return: bool 138 struct btif_av_is_connected { 139 static bool return_value; 140 std::function<bool(const A2dpType local_a2dp_type)> body{ 141 [](const A2dpType /* local_a2dp_type */) { return return_value; }}; operatorbtif_av_is_connected142 bool operator()(const A2dpType local_a2dp_type) { return body(local_a2dp_type); } 143 }; 144 extern struct btif_av_is_connected btif_av_is_connected; 145 146 // Name: btif_av_is_connected_addr 147 // Params: const RawAddress& peer_address, const A2dpType local_a2dp_type 148 // Return: bool 149 struct btif_av_is_connected_addr { 150 static bool return_value; 151 std::function<bool(const RawAddress& peer_address, const A2dpType local_a2dp_type)> body{ 152 [](const RawAddress& /* peer_address */, const A2dpType /* local_a2dp_type */) { 153 return return_value; 154 }}; operatorbtif_av_is_connected_addr155 bool operator()(const RawAddress& peer_address, const A2dpType local_a2dp_type) { 156 return body(peer_address, local_a2dp_type); 157 } 158 }; 159 extern struct btif_av_is_connected_addr btif_av_is_connected_addr; 160 161 // Name: btif_av_is_peer_edr 162 // Params: const RawAddress& peer_address, const A2dpType local_a2dp_type 163 // Return: bool 164 struct btif_av_is_peer_edr { 165 static bool return_value; 166 std::function<bool(const RawAddress& peer_address, const A2dpType local_a2dp_type)> body{ 167 [](const RawAddress& /* peer_address */, const A2dpType /* local_a2dp_type */) { 168 return return_value; 169 }}; operatorbtif_av_is_peer_edr170 bool operator()(const RawAddress& peer_address, const A2dpType local_a2dp_type) { 171 return body(peer_address, local_a2dp_type); 172 } 173 }; 174 extern struct btif_av_is_peer_edr btif_av_is_peer_edr; 175 176 // Name: btif_av_is_peer_silenced 177 // Params: const RawAddress& peer_address 178 // Return: bool 179 struct btif_av_is_peer_silenced { 180 static bool return_value; 181 std::function<bool(const RawAddress& peer_address)> body{ 182 [](const RawAddress& /* peer_address */) { return return_value; }}; operatorbtif_av_is_peer_silenced183 bool operator()(const RawAddress& peer_address) { return body(peer_address); } 184 }; 185 extern struct btif_av_is_peer_silenced btif_av_is_peer_silenced; 186 187 // Name: btif_av_is_sink_enabled 188 // Params: void 189 // Return: bool 190 struct btif_av_is_sink_enabled { 191 static bool return_value; 192 std::function<bool(void)> body{[](void) { return return_value; }}; operatorbtif_av_is_sink_enabled193 bool operator()(void) { return body(); } 194 }; 195 extern struct btif_av_is_sink_enabled btif_av_is_sink_enabled; 196 197 // Name: btif_av_is_source_enabled 198 // Params: void 199 // Return: bool 200 struct btif_av_is_source_enabled { 201 static bool return_value; 202 std::function<bool(void)> body{[](void) { return return_value; }}; operatorbtif_av_is_source_enabled203 bool operator()(void) { return body(); } 204 }; 205 extern struct btif_av_is_source_enabled btif_av_is_source_enabled; 206 207 // Name: btif_av_peer_is_connected_sink 208 // Params: const RawAddress& peer_address 209 // Return: bool 210 struct btif_av_peer_is_connected_sink { 211 static bool return_value; 212 std::function<bool(const RawAddress& peer_address)> body{ 213 [](const RawAddress& /* peer_address */) { return return_value; }}; operatorbtif_av_peer_is_connected_sink214 bool operator()(const RawAddress& peer_address) { return body(peer_address); } 215 }; 216 extern struct btif_av_peer_is_connected_sink btif_av_peer_is_connected_sink; 217 218 // Name: btif_av_peer_is_connected_source 219 // Params: const RawAddress& peer_address 220 // Return: bool 221 struct btif_av_peer_is_connected_source { 222 static bool return_value; 223 std::function<bool(const RawAddress& peer_address)> body{ 224 [](const RawAddress& /* peer_address */) { return return_value; }}; operatorbtif_av_peer_is_connected_source225 bool operator()(const RawAddress& peer_address) { return body(peer_address); } 226 }; 227 extern struct btif_av_peer_is_connected_source btif_av_peer_is_connected_source; 228 229 // Name: btif_av_peer_is_sink 230 // Params: const RawAddress& peer_address 231 // Return: bool 232 struct btif_av_peer_is_sink { 233 static bool return_value; 234 std::function<bool(const RawAddress& peer_address)> body{ 235 [](const RawAddress& /* peer_address */) { return return_value; }}; operatorbtif_av_peer_is_sink236 bool operator()(const RawAddress& peer_address) { return body(peer_address); } 237 }; 238 extern struct btif_av_peer_is_sink btif_av_peer_is_sink; 239 240 // Name: btif_av_peer_is_source 241 // Params: const RawAddress& peer_address 242 // Return: bool 243 struct btif_av_peer_is_source { 244 static bool return_value; 245 std::function<bool(const RawAddress& peer_address)> body{ 246 [](const RawAddress& /* peer_address */) { return return_value; }}; operatorbtif_av_peer_is_source247 bool operator()(const RawAddress& peer_address) { return body(peer_address); } 248 }; 249 extern struct btif_av_peer_is_source btif_av_peer_is_source; 250 251 // Name: btif_av_peer_prefers_mandatory_codec 252 // Params: const RawAddress& peer_address, const A2dpType local_a2dp_type 253 // Return: bool 254 struct btif_av_peer_prefers_mandatory_codec { 255 static bool return_value; 256 std::function<bool(const RawAddress& peer_address, const A2dpType local_a2dp_type)> body{ 257 [](const RawAddress& /* peer_address */, const A2dpType /* local_a2dp_type */) { 258 ; 259 return return_value; 260 }}; operatorbtif_av_peer_prefers_mandatory_codec261 bool operator()(const RawAddress& peer_address, const A2dpType local_a2dp_type) { 262 return body(peer_address, local_a2dp_type); 263 } 264 }; 265 extern struct btif_av_peer_prefers_mandatory_codec btif_av_peer_prefers_mandatory_codec; 266 267 // Name: btif_av_peer_supports_3mbps 268 // Params: const RawAddress& peer_address, const A2dpType local_a2dp_type 269 // Return: bool 270 struct btif_av_peer_supports_3mbps { 271 static bool return_value; 272 std::function<bool(const RawAddress& peer_address, const A2dpType local_a2dp_type)> body{ 273 [](const RawAddress& /* peer_address */, const A2dpType /* local_a2dp_type */) { 274 ; 275 return return_value; 276 }}; operatorbtif_av_peer_supports_3mbps277 bool operator()(const RawAddress& peer_address, const A2dpType local_a2dp_type) { 278 return body(peer_address, local_a2dp_type); 279 } 280 }; 281 extern struct btif_av_peer_supports_3mbps btif_av_peer_supports_3mbps; 282 283 // Name: btif_av_report_source_codec_state 284 // Params: const RawAddress& peer_address, const btav_a2dp_codec_config_t& 285 // codec_config, const std::vector<btav_a2dp_codec_config_t>& 286 // codecs_local_capabilities, const std::vector<btav_a2dp_codec_config_t>& 287 // codecs_selectable_capabilities Return: void 288 struct btif_av_report_source_codec_state { 289 std::function<void(const RawAddress& peer_address, const btav_a2dp_codec_config_t& codec_config, 290 const std::vector<btav_a2dp_codec_config_t>& codecs_local_capabilities, 291 const std::vector<btav_a2dp_codec_config_t>& codecs_selectable_capabilities)> 292 body{[](const RawAddress& /* peer_address */, 293 const btav_a2dp_codec_config_t& /* codec_config */, 294 const std::vector<btav_a2dp_codec_config_t>& 295 /* codecs_local_capabilities */, 296 const std::vector<btav_a2dp_codec_config_t>& 297 /* codecs_selectable_capabilities */) {}}; operatorbtif_av_report_source_codec_state298 void operator()(const RawAddress& peer_address, const btav_a2dp_codec_config_t& codec_config, 299 const std::vector<btav_a2dp_codec_config_t>& codecs_local_capabilities, 300 const std::vector<btav_a2dp_codec_config_t>& codecs_selectable_capabilities) { 301 body(peer_address, codec_config, codecs_local_capabilities, codecs_selectable_capabilities); 302 } 303 }; 304 extern struct btif_av_report_source_codec_state btif_av_report_source_codec_state; 305 306 // Name: btif_av_set_audio_delay 307 // Params: const RawAddress& peer_address, uint16_t delay, const A2dpType 308 // local_a2dp_type Return: void 309 struct btif_av_set_audio_delay { 310 std::function<void(const RawAddress& peer_address, uint16_t delay, 311 const A2dpType local_a2dp_type)> 312 body{[](const RawAddress& /* peer_address */, uint16_t /* delay */, 313 const A2dpType /* local_a2dp_type */) {}}; operatorbtif_av_set_audio_delay314 void operator()(const RawAddress& peer_address, uint16_t delay, const A2dpType local_a2dp_type) { 315 body(peer_address, delay, local_a2dp_type); 316 } 317 }; 318 extern struct btif_av_set_audio_delay btif_av_set_audio_delay; 319 320 // Name: btif_av_set_dynamic_audio_buffer_size 321 // Params: uint8_t dynamic_audio_buffer_size 322 // Return: void 323 struct btif_av_set_dynamic_audio_buffer_size { 324 std::function<void(uint8_t dynamic_audio_buffer_size)> body{ 325 [](uint8_t /* dynamic_audio_buffer_size */) {}}; operatorbtif_av_set_dynamic_audio_buffer_size326 void operator()(uint8_t dynamic_audio_buffer_size) { body(dynamic_audio_buffer_size); } 327 }; 328 extern struct btif_av_set_dynamic_audio_buffer_size btif_av_set_dynamic_audio_buffer_size; 329 330 // Name: btif_av_set_low_latency 331 // Params: bool is_low_latency 332 // Return: void 333 struct btif_av_set_low_latency { 334 std::function<void(bool is_low_latency)> body{[](bool /* is_low_latency */) {}}; operatorbtif_av_set_low_latency335 void operator()(bool is_low_latency) { body(is_low_latency); } 336 }; 337 extern struct btif_av_set_low_latency btif_av_set_low_latency; 338 339 // Name: btif_av_sink_active_peer 340 // Params: void 341 // Return: RawAddress 342 struct btif_av_sink_active_peer { 343 static RawAddress return_value; 344 std::function<RawAddress(void)> body{[](void) { return return_value; }}; operatorbtif_av_sink_active_peer345 RawAddress operator()(void) { return body(); } 346 }; 347 extern struct btif_av_sink_active_peer btif_av_sink_active_peer; 348 349 // Name: btif_av_sink_execute_service 350 // Params: bool enable 351 // Return: bt_status_t 352 struct btif_av_sink_execute_service { 353 static bt_status_t return_value; 354 std::function<bt_status_t(bool enable)> body{[](bool /* enable */) { return return_value; }}; operatorbtif_av_sink_execute_service355 bt_status_t operator()(bool enable) { return body(enable); } 356 }; 357 extern struct btif_av_sink_execute_service btif_av_sink_execute_service; 358 359 // Name: btif_av_source_active_peer 360 // Params: void 361 // Return: RawAddress 362 struct btif_av_source_active_peer { 363 static RawAddress return_value; 364 std::function<RawAddress(void)> body{[](void) { return return_value; }}; operatorbtif_av_source_active_peer365 RawAddress operator()(void) { return body(); } 366 }; 367 extern struct btif_av_source_active_peer btif_av_source_active_peer; 368 369 // Name: btif_av_source_execute_service 370 // Params: bool enable 371 // Return: bt_status_t 372 struct btif_av_source_execute_service { 373 static bt_status_t return_value; 374 std::function<bt_status_t(bool enable)> body{[](bool /* enable */) { return return_value; }}; operatorbtif_av_source_execute_service375 bt_status_t operator()(bool enable) { return body(enable); } 376 }; 377 extern struct btif_av_source_execute_service btif_av_source_execute_service; 378 379 // Name: btif_av_src_sink_coexist_enabled 380 // Params: void 381 // Return: bool 382 struct btif_av_src_sink_coexist_enabled { 383 static bool return_value; 384 std::function<bool(void)> body{[](void) { return return_value; }}; operatorbtif_av_src_sink_coexist_enabled385 bool operator()(void) { return body(); } 386 }; 387 extern struct btif_av_src_sink_coexist_enabled btif_av_src_sink_coexist_enabled; 388 389 // Name: btif_av_stream_ready 390 // Params: const A2dpType local_a2dp_type 391 // Return: bool 392 struct btif_av_stream_ready { 393 static bool return_value; 394 std::function<bool(const A2dpType local_a2dp_type)> body{ 395 [](const A2dpType /* local_a2dp_type */) { return return_value; }}; operatorbtif_av_stream_ready396 bool operator()(const A2dpType local_a2dp_type) { return body(local_a2dp_type); } 397 }; 398 extern struct btif_av_stream_ready btif_av_stream_ready; 399 400 // Name: btif_av_stream_start 401 // Params: const A2dpType local_a2dp_type 402 // Return: void 403 struct btif_av_stream_start { 404 std::function<void(const A2dpType local_a2dp_type)> body{ 405 [](const A2dpType /* local_a2dp_type */) {}}; operatorbtif_av_stream_start406 void operator()(const A2dpType local_a2dp_type) { body(local_a2dp_type); } 407 }; 408 extern struct btif_av_stream_start btif_av_stream_start; 409 410 // Name: btif_av_stream_start_offload 411 // Params: void 412 // Return: void 413 struct btif_av_stream_start_offload { 414 std::function<void(void)> body{[](void) {}}; operatorbtif_av_stream_start_offload415 void operator()(void) { body(); } 416 }; 417 extern struct btif_av_stream_start_offload btif_av_stream_start_offload; 418 419 // Name: btif_av_stream_start_with_latency 420 // Params: bool use_latency_mode 421 // Return: void 422 struct btif_av_stream_start_with_latency { 423 std::function<void(bool use_latency_mode)> body{[](bool /* use_latency_mode */) {}}; operatorbtif_av_stream_start_with_latency424 void operator()(bool use_latency_mode) { body(use_latency_mode); } 425 }; 426 extern struct btif_av_stream_start_with_latency btif_av_stream_start_with_latency; 427 428 // Name: btif_av_stream_started_ready 429 // Params: const A2dpType local_a2dp_type 430 // Return: bool 431 struct btif_av_stream_started_ready { 432 static bool return_value; 433 std::function<bool(const A2dpType local_a2dp_type)> body{ 434 [](const A2dpType /* local_a2dp_type */) { return return_value; }}; operatorbtif_av_stream_started_ready435 bool operator()(const A2dpType local_a2dp_type) { return body(local_a2dp_type); } 436 }; 437 extern struct btif_av_stream_started_ready btif_av_stream_started_ready; 438 439 // Name: btif_av_stream_stop 440 // Params: const RawAddress& peer_address 441 // Return: void 442 struct btif_av_stream_stop { 443 std::function<void(const RawAddress& peer_address)> body{ 444 [](const RawAddress& /* peer_address */) {}}; operatorbtif_av_stream_stop445 void operator()(const RawAddress& peer_address) { body(peer_address); } 446 }; 447 extern struct btif_av_stream_stop btif_av_stream_stop; 448 449 // Name: btif_av_stream_suspend 450 // Params: void 451 // Return: void 452 struct btif_av_stream_suspend { 453 std::function<void(void)> body{[](void) {}}; operatorbtif_av_stream_suspend454 void operator()(void) { body(); } 455 }; 456 extern struct btif_av_stream_suspend btif_av_stream_suspend; 457 458 // Name: btif_debug_av_dump 459 // Params: int fd 460 // Return: void 461 struct btif_debug_av_dump { 462 std::function<void(int fd)> body{[](int /* fd */) {}}; operatorbtif_debug_av_dump463 void operator()(int fd) { body(fd); } 464 }; 465 extern struct btif_debug_av_dump btif_debug_av_dump; 466 467 } // namespace btif_av 468 } // namespace mock 469 } // namespace test 470 471 // END mockcify generation 472