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:47
21  *
22  *  mockcify.pl ver 0.6.1
23  */
24 
25 #include <cstdint>
26 #include <functional>
27 
28 // Original included files, if any
29 #include <base/functional/bind.h>
30 
31 #include <vector>
32 
33 #include "bta/include/bta_api.h"
34 #include "bta/include/bta_sec_api.h"
35 #include "hci/le_rand_callback.h"
36 #include "stack/include/bt_device_type.h"
37 #include "stack/include/bt_octets.h"
38 #include "types/ble_address_with_type.h"
39 #include "types/raw_address.h"
40 
41 // Original usings
42 
43 // Mocked compile conditionals, if any
44 
45 namespace test {
46 namespace mock {
47 namespace bta_dm_api {
48 
49 // Shared state between mocked functions and tests
50 // Name: BTA_DmAddBleDevice
51 // Params: const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, tBT_DEVICE_TYPE
52 // dev_type Return: void
53 struct BTA_DmAddBleDevice {
54   std::function<void(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
55                      tBT_DEVICE_TYPE dev_type)>
56       body{[](const RawAddress& /* bd_addr */, tBLE_ADDR_TYPE /* addr_type */,
57               tBT_DEVICE_TYPE /* dev_type */) {}};
operatorBTA_DmAddBleDevice58   void operator()(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
59                   tBT_DEVICE_TYPE dev_type) {
60     body(bd_addr, addr_type, dev_type);
61   };
62 };
63 extern struct BTA_DmAddBleDevice BTA_DmAddBleDevice;
64 
65 // Name: BTA_DmAddBleKey
66 // Params: const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key,
67 // tBTM_LE_KEY_TYPE key_type Return: void
68 struct BTA_DmAddBleKey {
69   std::function<void(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key,
70                      tBTM_LE_KEY_TYPE key_type)>
71       body{[](const RawAddress& /* bd_addr */,
72               tBTA_LE_KEY_VALUE* /* p_le_key */,
73               tBTM_LE_KEY_TYPE /* key_type */) {}};
operatorBTA_DmAddBleKey74   void operator()(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key,
75                   tBTM_LE_KEY_TYPE key_type) {
76     body(bd_addr, p_le_key, key_type);
77   };
78 };
79 extern struct BTA_DmAddBleKey BTA_DmAddBleKey;
80 
81 // Name: BTA_DmAddDevice
82 // Params: const RawAddress& bd_addr, DEV_CLASS dev_class, const LinkKey&
83 // link_key, uint8_t key_type, uint8_t pin_length Return: void
84 struct BTA_DmAddDevice {
85   std::function<void(const RawAddress& bd_addr, DEV_CLASS dev_class,
86                      const LinkKey& link_key, uint8_t key_type,
87                      uint8_t pin_length)>
88       body{[](const RawAddress& /* bd_addr */, DEV_CLASS /* dev_class */,
89               const LinkKey& /* link_key */, uint8_t /* key_type */,
90               uint8_t /* pin_length */) {}};
operatorBTA_DmAddDevice91   void operator()(const RawAddress& bd_addr, DEV_CLASS dev_class,
92                   const LinkKey& link_key, uint8_t key_type,
93                   uint8_t pin_length) {
94     body(bd_addr, dev_class, link_key, key_type, pin_length);
95   };
96 };
97 extern struct BTA_DmAddDevice BTA_DmAddDevice;
98 
99 // Name: BTA_DmAllowWakeByHid
100 // Params:  std::vector<RawAddress> classic_hid_devices,
101 // std::vector<std::pair<RawAddress, uint8_t>> le_hid_devices Return: void
102 struct BTA_DmAllowWakeByHid {
103   std::function<void(
104       std::vector<RawAddress> classic_hid_devices,
105       std::vector<std::pair<RawAddress, uint8_t>> le_hid_devices)>
106       body{
107           [](std::vector<RawAddress> /* classic_hid_devices */,
108              std::vector<std::pair<RawAddress, uint8_t>> /* le_hid_devices */) {
109           }};
operatorBTA_DmAllowWakeByHid110   void operator()(std::vector<RawAddress> classic_hid_devices,
111                   std::vector<std::pair<RawAddress, uint8_t>> le_hid_devices) {
112     body(classic_hid_devices, le_hid_devices);
113   };
114 };
115 extern struct BTA_DmAllowWakeByHid BTA_DmAllowWakeByHid;
116 
117 // Name: BTA_DmBleConfigLocalPrivacy
118 // Params: bool privacy_enable
119 // Return: void
120 struct BTA_DmBleConfigLocalPrivacy {
121   std::function<void(bool privacy_enable)> body{
122       [](bool /* privacy_enable */) {}};
operatorBTA_DmBleConfigLocalPrivacy123   void operator()(bool privacy_enable) { body(privacy_enable); };
124 };
125 extern struct BTA_DmBleConfigLocalPrivacy BTA_DmBleConfigLocalPrivacy;
126 
127 // Name: BTA_DmBleConfirmReply
128 // Params: const RawAddress& bd_addr, bool accept
129 // Return: void
130 struct BTA_DmBleConfirmReply {
131   std::function<void(const RawAddress& bd_addr, bool accept)> body{
132       [](const RawAddress& /* bd_addr */, bool /* accept */) {}};
operatorBTA_DmBleConfirmReply133   void operator()(const RawAddress& bd_addr, bool accept) {
134     body(bd_addr, accept);
135   };
136 };
137 extern struct BTA_DmBleConfirmReply BTA_DmBleConfirmReply;
138 
139 // Name: BTA_DmBleCsisObserve
140 // Params: bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb
141 // Return: void
142 struct BTA_DmBleCsisObserve {
143   std::function<void(bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb)> body{
144       [](bool /* observe */, tBTA_DM_SEARCH_CBACK* /* p_results_cb */) {}};
operatorBTA_DmBleCsisObserve145   void operator()(bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb) {
146     body(observe, p_results_cb);
147   };
148 };
149 extern struct BTA_DmBleCsisObserve BTA_DmBleCsisObserve;
150 
151 // Name: BTA_DmBleGetEnergyInfo
152 // Params: tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback
153 // Return: void
154 struct BTA_DmBleGetEnergyInfo {
155   std::function<void(tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback)> body{
156       [](tBTA_BLE_ENERGY_INFO_CBACK* /* p_cmpl_cback */) {}};
operatorBTA_DmBleGetEnergyInfo157   void operator()(tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback) {
158     body(p_cmpl_cback);
159   };
160 };
161 extern struct BTA_DmBleGetEnergyInfo BTA_DmBleGetEnergyInfo;
162 
163 // Name: BTA_DmBlePasskeyReply
164 // Params: const RawAddress& bd_addr, bool accept, uint32_t passkey
165 // Return: void
166 struct BTA_DmBlePasskeyReply {
167   std::function<void(const RawAddress& bd_addr, bool accept, uint32_t passkey)>
168       body{[](const RawAddress& /* bd_addr */, bool /* accept */,
169               uint32_t /* passkey */) {}};
operatorBTA_DmBlePasskeyReply170   void operator()(const RawAddress& bd_addr, bool accept, uint32_t passkey) {
171     body(bd_addr, accept, passkey);
172   };
173 };
174 extern struct BTA_DmBlePasskeyReply BTA_DmBlePasskeyReply;
175 
176 // Name: BTA_DmBleRequestMaxTxDataLength
177 // Params: const RawAddress& remote_device
178 // Return: void
179 struct BTA_DmBleRequestMaxTxDataLength {
180   std::function<void(const RawAddress& remote_device)> body{
181       [](const RawAddress& /* remote_device */) {}};
operatorBTA_DmBleRequestMaxTxDataLength182   void operator()(const RawAddress& remote_device) { body(remote_device); };
183 };
184 extern struct BTA_DmBleRequestMaxTxDataLength BTA_DmBleRequestMaxTxDataLength;
185 
186 // Name: BTA_DmBleResetId
187 // Params: void
188 // Return: void
189 struct BTA_DmBleResetId {
190   std::function<void(void)> body{[](void) {}};
operatorBTA_DmBleResetId191   void operator()(void) { body(); };
192 };
193 extern struct BTA_DmBleResetId BTA_DmBleResetId;
194 
195 // Name: BTA_DmBleScan
196 // Params: bool start, uint8_t duration_sec, bool low_latency_scan
197 // Return: void
198 struct BTA_DmBleScan {
199   std::function<void(bool start, uint8_t duration_sec, bool low_latency_scan)>
200       body{[](bool /* start */, uint8_t /* duration_sec */,
201               bool /* low_latency_scan */) {}};
operatorBTA_DmBleScan202   void operator()(bool start, uint8_t duration_sec, bool low_latency_scan) {
203     body(start, duration_sec, low_latency_scan);
204   };
205 };
206 extern struct BTA_DmBleScan BTA_DmBleScan;
207 
208 // Name: BTA_DmBleSecurityGrant
209 // Params: const RawAddress& bd_addr, tBTA_DM_BLE_SEC_GRANT res
210 // Return: void
211 struct BTA_DmBleSecurityGrant {
212   std::function<void(const RawAddress& bd_addr, tBTA_DM_BLE_SEC_GRANT res)>
213       body{[](const RawAddress& /* bd_addr */,
214               tBTA_DM_BLE_SEC_GRANT /* res */) {}};
operatorBTA_DmBleSecurityGrant215   void operator()(const RawAddress& bd_addr, tBTA_DM_BLE_SEC_GRANT res) {
216     body(bd_addr, res);
217   };
218 };
219 extern struct BTA_DmBleSecurityGrant BTA_DmBleSecurityGrant;
220 
221 // Name: BTA_DmBleSubrateRequest
222 // Params: const RawAddress& bd_addr, uint16_t subrate_min, uint16_t
223 // subrate_max, uint16_t max_latency, uint16_t cont_num, uint16_t timeout
224 // Return: void
225 struct BTA_DmBleSubrateRequest {
226   std::function<void(const RawAddress& bd_addr, uint16_t subrate_min,
227                      uint16_t subrate_max, uint16_t max_latency,
228                      uint16_t cont_num, uint16_t timeout)>
229       body{[](const RawAddress& /* bd_addr */, uint16_t /* subrate_min */,
230               uint16_t /* subrate_max */, uint16_t /* max_latency */,
231               uint16_t /* cont_num */, uint16_t /* timeout */) {}};
operatorBTA_DmBleSubrateRequest232   void operator()(const RawAddress& bd_addr, uint16_t subrate_min,
233                   uint16_t subrate_max, uint16_t max_latency, uint16_t cont_num,
234                   uint16_t timeout) {
235     body(bd_addr, subrate_min, subrate_max, max_latency, cont_num, timeout);
236   };
237 };
238 extern struct BTA_DmBleSubrateRequest BTA_DmBleSubrateRequest;
239 
240 // Name: BTA_DmBleUpdateConnectionParams
241 // Params: const RawAddress& bd_addr, uint16_t min_int, uint16_t max_int,
242 // uint16_t latency, uint16_t timeout, uint16_t min_ce_len, uint16_t max_ce_len
243 // Return: void
244 struct BTA_DmBleUpdateConnectionParams {
245   std::function<void(const RawAddress& bd_addr, uint16_t min_int,
246                      uint16_t max_int, uint16_t latency, uint16_t timeout,
247                      uint16_t min_ce_len, uint16_t max_ce_len)>
248       body{[](const RawAddress& /* bd_addr */, uint16_t /* min_int */,
249               uint16_t /* max_int */, uint16_t /* latency */,
250               uint16_t /* timeout */, uint16_t /* min_ce_len */,
251               uint16_t /* max_ce_len */) {}};
operatorBTA_DmBleUpdateConnectionParams252   void operator()(const RawAddress& bd_addr, uint16_t min_int, uint16_t max_int,
253                   uint16_t latency, uint16_t timeout, uint16_t min_ce_len,
254                   uint16_t max_ce_len) {
255     body(bd_addr, min_int, max_int, latency, timeout, min_ce_len, max_ce_len);
256   };
257 };
258 extern struct BTA_DmBleUpdateConnectionParams BTA_DmBleUpdateConnectionParams;
259 
260 // Name: BTA_DmBond
261 // Params: const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, tBT_TRANSPORT
262 // transport, tBT_DEVICE_TYPE device_type Return: void
263 struct BTA_DmBond {
264   std::function<void(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
265                      tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type)>
266       body{[](const RawAddress& /* bd_addr */, tBLE_ADDR_TYPE /* addr_type */,
267               tBT_TRANSPORT /* transport */,
268               tBT_DEVICE_TYPE /* device_type */) {}};
operatorBTA_DmBond269   void operator()(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
270                   tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type) {
271     body(bd_addr, addr_type, transport, device_type);
272   };
273 };
274 extern struct BTA_DmBond BTA_DmBond;
275 
276 // Name: BTA_DmBondCancel
277 // Params: const RawAddress& bd_addr
278 // Return: void
279 struct BTA_DmBondCancel {
280   std::function<void(const RawAddress& bd_addr)> body{
281       [](const RawAddress& /* bd_addr */) {}};
operatorBTA_DmBondCancel282   void operator()(const RawAddress& bd_addr) { body(bd_addr); };
283 };
284 extern struct BTA_DmBondCancel BTA_DmBondCancel;
285 
286 // Name: BTA_DmCheckLeAudioCapable
287 // Params: const RawAddress& address
288 // Return: bool
289 struct BTA_DmCheckLeAudioCapable {
290   static bool return_value;
291   std::function<bool(const RawAddress& address)> body{
292       [](const RawAddress& /* address */) { return return_value; }};
operatorBTA_DmCheckLeAudioCapable293   bool operator()(const RawAddress& address) { return body(address); };
294 };
295 extern struct BTA_DmCheckLeAudioCapable BTA_DmCheckLeAudioCapable;
296 
297 // Name: BTA_DmClearEventFilter
298 // Params: void
299 // Return: void
300 struct BTA_DmClearEventFilter {
301   std::function<void(void)> body{[](void) {}};
operatorBTA_DmClearEventFilter302   void operator()(void) { body(); };
303 };
304 extern struct BTA_DmClearEventFilter BTA_DmClearEventFilter;
305 
306 // Name: BTA_DmClearEventMask
307 // Params: void
308 // Return: void
309 struct BTA_DmClearEventMask {
310   std::function<void(void)> body{[](void) {}};
operatorBTA_DmClearEventMask311   void operator()(void) { body(); };
312 };
313 extern struct BTA_DmClearEventMask BTA_DmClearEventMask;
314 
315 // Name: BTA_DmClearFilterAcceptList
316 // Params: void
317 // Return: void
318 struct BTA_DmClearFilterAcceptList {
319   std::function<void(void)> body{[](void) {}};
operatorBTA_DmClearFilterAcceptList320   void operator()(void) { body(); };
321 };
322 extern struct BTA_DmClearFilterAcceptList BTA_DmClearFilterAcceptList;
323 
324 // Name: BTA_DmConfirm
325 // Params: const RawAddress& bd_addr, bool accept
326 // Return: void
327 struct BTA_DmConfirm {
328   std::function<void(const RawAddress& bd_addr, bool accept)> body{
329       [](const RawAddress& /* bd_addr */, bool /* accept */) {}};
operatorBTA_DmConfirm330   void operator()(const RawAddress& bd_addr, bool accept) {
331     body(bd_addr, accept);
332   };
333 };
334 extern struct BTA_DmConfirm BTA_DmConfirm;
335 
336 // Name: BTA_DmDisconnectAllAcls
337 // Params:
338 // Return: void
339 struct BTA_DmDisconnectAllAcls {
340   std::function<void()> body{[]() {}};
operatorBTA_DmDisconnectAllAcls341   void operator()() { body(); };
342 };
343 extern struct BTA_DmDisconnectAllAcls BTA_DmDisconnectAllAcls;
344 
345 // Name: BTA_DmDiscover
346 // Params: const RawAddress& bd_addr, tBTA_DM_SEARCH_CBACK* p_cback,
347 // tBT_TRANSPORT transport Return: void
348 struct BTA_DmDiscover {
349   std::function<void(const RawAddress& bd_addr, tBTA_DM_SEARCH_CBACK* p_cback,
350                      tBT_TRANSPORT transport)>
351       body{[](const RawAddress& /* bd_addr */,
352               tBTA_DM_SEARCH_CBACK* /* p_cback */,
353               tBT_TRANSPORT /* transport */) {}};
operatorBTA_DmDiscover354   void operator()(const RawAddress& bd_addr, tBTA_DM_SEARCH_CBACK* p_cback,
355                   tBT_TRANSPORT transport) {
356     body(bd_addr, p_cback, transport);
357   };
358 };
359 extern struct BTA_DmDiscover BTA_DmDiscover;
360 
361 // Name: BTA_DmGetConnectionState
362 // Params: const RawAddress& bd_addr
363 // Return: bool
364 struct BTA_DmGetConnectionState {
365   static bool return_value;
366   std::function<bool(const RawAddress& bd_addr)> body{
367       [](const RawAddress& /* bd_addr */) { return return_value; }};
operatorBTA_DmGetConnectionState368   bool operator()(const RawAddress& bd_addr) { return body(bd_addr); };
369 };
370 extern struct BTA_DmGetConnectionState BTA_DmGetConnectionState;
371 
372 // Name: BTA_DmLeRand
373 // Params: bluetooth::hci::LeRandCallback cb
374 // Return: void
375 struct BTA_DmLeRand {
376   std::function<void(bluetooth::hci::LeRandCallback cb)> body{
377       [](bluetooth::hci::LeRandCallback /* cb */) {}};
operatorBTA_DmLeRand378   void operator()(bluetooth::hci::LeRandCallback cb) { body(std::move(cb)); };
379 };
380 extern struct BTA_DmLeRand BTA_DmLeRand;
381 
382 // Name: BTA_DmLocalOob
383 // Params: void
384 // Return: void
385 struct BTA_DmLocalOob {
386   std::function<void(void)> body{[](void) {}};
operatorBTA_DmLocalOob387   void operator()(void) { body(); };
388 };
389 extern struct BTA_DmLocalOob BTA_DmLocalOob;
390 
391 // Name: BTA_DmPinReply
392 // Params: const RawAddress& bd_addr, bool accept, uint8_t pin_len, uint8_t*
393 // p_pin Return: void
394 struct BTA_DmPinReply {
395   std::function<void(const RawAddress& bd_addr, bool accept, uint8_t pin_len,
396                      uint8_t* p_pin)>
397       body{[](const RawAddress& /* bd_addr */, bool /* accept */,
398               uint8_t /* pin_len */, uint8_t* /* p_pin */) {}};
operatorBTA_DmPinReply399   void operator()(const RawAddress& bd_addr, bool accept, uint8_t pin_len,
400                   uint8_t* p_pin) {
401     body(bd_addr, accept, pin_len, p_pin);
402   };
403 };
404 extern struct BTA_DmPinReply BTA_DmPinReply;
405 
406 // Name: BTA_DmRemoveDevice
407 // Params: const RawAddress& bd_addr
408 // Return: tBTA_STATUS
409 struct BTA_DmRemoveDevice {
410   static tBTA_STATUS return_value;
411   std::function<tBTA_STATUS(const RawAddress& bd_addr)> body{
412       [](const RawAddress& /* bd_addr */) { return return_value; }};
operatorBTA_DmRemoveDevice413   tBTA_STATUS operator()(const RawAddress& bd_addr) { return body(bd_addr); };
414 };
415 extern struct BTA_DmRemoveDevice BTA_DmRemoveDevice;
416 
417 // Name: BTA_DmRestoreFilterAcceptList
418 // Params:  std::vector<std::pair<RawAddress, uint8_t>> le_devices
419 // Return: void
420 struct BTA_DmRestoreFilterAcceptList {
421   std::function<void(std::vector<std::pair<RawAddress, uint8_t>> le_devices)>
422       body{[](std::vector<std::pair<RawAddress, uint8_t>> /* le_devices */) {}};
operatorBTA_DmRestoreFilterAcceptList423   void operator()(std::vector<std::pair<RawAddress, uint8_t>> le_devices) {
424     body(le_devices);
425   };
426 };
427 extern struct BTA_DmRestoreFilterAcceptList BTA_DmRestoreFilterAcceptList;
428 
429 // Name: BTA_DmSearch
430 // Params: tBTA_DM_SEARCH_CBACK* p_cback
431 // Return: void
432 struct BTA_DmSearch {
433   std::function<void(tBTA_DM_SEARCH_CBACK* p_cback)> body{
434       [](tBTA_DM_SEARCH_CBACK* /* p_cback */) {}};
operatorBTA_DmSearch435   void operator()(tBTA_DM_SEARCH_CBACK* p_cback) { body(p_cback); };
436 };
437 extern struct BTA_DmSearch BTA_DmSearch;
438 
439 // Name: BTA_DmSearchCancel
440 // Params: void
441 // Return: void
442 struct BTA_DmSearchCancel {
443   std::function<void(void)> body{[](void) {}};
operatorBTA_DmSearchCancel444   void operator()(void) { body(); };
445 };
446 extern struct BTA_DmSearchCancel BTA_DmSearchCancel;
447 
448 // Name: BTA_DmSetBlePrefConnParams
449 // Params: const RawAddress& bd_addr, uint16_t min_conn_int, uint16_t
450 // max_conn_int, uint16_t peripheral_latency, uint16_t supervision_tout Return:
451 // void
452 struct BTA_DmSetBlePrefConnParams {
453   std::function<void(const RawAddress& bd_addr, uint16_t min_conn_int,
454                      uint16_t max_conn_int, uint16_t peripheral_latency,
455                      uint16_t supervision_tout)>
456       body{[](const RawAddress& /* bd_addr */, uint16_t /* min_conn_int */,
457               uint16_t /* max_conn_int */, uint16_t /* peripheral_latency */,
458               uint16_t /* supervision_tout */) {}};
operatorBTA_DmSetBlePrefConnParams459   void operator()(const RawAddress& bd_addr, uint16_t min_conn_int,
460                   uint16_t max_conn_int, uint16_t peripheral_latency,
461                   uint16_t supervision_tout) {
462     body(bd_addr, min_conn_int, max_conn_int, peripheral_latency,
463          supervision_tout);
464   };
465 };
466 extern struct BTA_DmSetBlePrefConnParams BTA_DmSetBlePrefConnParams;
467 
468 // Name: BTA_DmSetDefaultEventMaskExcept
469 // Params: uint64_t mask, uint64_t le_mask
470 // Return: void
471 struct BTA_DmSetDefaultEventMaskExcept {
472   std::function<void(uint64_t mask, uint64_t le_mask)> body{
473       [](uint64_t /* mask */, uint64_t /* le_mask */) {}};
operatorBTA_DmSetDefaultEventMaskExcept474   void operator()(uint64_t mask, uint64_t le_mask) { body(mask, le_mask); };
475 };
476 extern struct BTA_DmSetDefaultEventMaskExcept BTA_DmSetDefaultEventMaskExcept;
477 
478 // Name: BTA_DmSetDeviceName
479 // Params: const char* p_name
480 // Return: void
481 struct BTA_DmSetDeviceName {
482   std::function<void(const char* p_name)> body{[](const char* /* p_name */) {}};
operatorBTA_DmSetDeviceName483   void operator()(const char* p_name) { body(p_name); };
484 };
485 extern struct BTA_DmSetDeviceName BTA_DmSetDeviceName;
486 
487 // Name: BTA_DmSetEncryption
488 // Params: const RawAddress& bd_addr, tBT_TRANSPORT transport,
489 // tBTA_DM_ENCRYPT_CBACK* p_callback, tBTM_BLE_SEC_ACT sec_act Return: void
490 struct BTA_DmSetEncryption {
491   std::function<void(const RawAddress& bd_addr, tBT_TRANSPORT transport,
492                      tBTA_DM_ENCRYPT_CBACK* p_callback,
493                      tBTM_BLE_SEC_ACT sec_act)>
494       body{[](const RawAddress& /* bd_addr */, tBT_TRANSPORT /* transport */,
495               tBTA_DM_ENCRYPT_CBACK* /* p_callback */,
496               tBTM_BLE_SEC_ACT /* sec_act */) {}};
operatorBTA_DmSetEncryption497   void operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport,
498                   tBTA_DM_ENCRYPT_CBACK* p_callback, tBTM_BLE_SEC_ACT sec_act) {
499     body(bd_addr, transport, p_callback, sec_act);
500   };
501 };
502 extern struct BTA_DmSetEncryption BTA_DmSetEncryption;
503 
504 // Name: BTA_DmSetEventFilterConnectionSetupAllDevices
505 // Params:
506 // Return: void
507 struct BTA_DmSetEventFilterConnectionSetupAllDevices {
508   std::function<void()> body{[]() {}};
operatorBTA_DmSetEventFilterConnectionSetupAllDevices509   void operator()() { body(); };
510 };
511 extern struct BTA_DmSetEventFilterConnectionSetupAllDevices
512     BTA_DmSetEventFilterConnectionSetupAllDevices;
513 
514 // Name: BTA_DmSetEventFilterInquiryResultAllDevices
515 // Params:
516 // Return: void
517 struct BTA_DmSetEventFilterInquiryResultAllDevices {
518   std::function<void()> body{[]() {}};
operatorBTA_DmSetEventFilterInquiryResultAllDevices519   void operator()() { body(); };
520 };
521 extern struct BTA_DmSetEventFilterInquiryResultAllDevices
522     BTA_DmSetEventFilterInquiryResultAllDevices;
523 
524 // Name: BTA_DmSetLocalDiRecord
525 // Params: tSDP_DI_RECORD* p_device_info, uint32_t* p_handle
526 // Return: tBTA_STATUS
527 struct BTA_DmSetLocalDiRecord {
528   static tBTA_STATUS return_value;
529   std::function<tBTA_STATUS(tSDP_DI_RECORD* p_device_info, uint32_t* p_handle)>
530       body{[](tSDP_DI_RECORD* /* p_device_info */, uint32_t* /* p_handle */) {
531         return return_value;
532       }};
operatorBTA_DmSetLocalDiRecord533   tBTA_STATUS operator()(tSDP_DI_RECORD* p_device_info, uint32_t* p_handle) {
534     return body(p_device_info, p_handle);
535   };
536 };
537 extern struct BTA_DmSetLocalDiRecord BTA_DmSetLocalDiRecord;
538 
539 // Name: BTA_DmSirkConfirmDeviceReply
540 // Params: const RawAddress& bd_addr, bool accept
541 // Return: void
542 struct BTA_DmSirkConfirmDeviceReply {
543   std::function<void(const RawAddress& bd_addr, bool accept)> body{
544       [](const RawAddress& /* bd_addr */, bool /* accept */) {}};
operatorBTA_DmSirkConfirmDeviceReply545   void operator()(const RawAddress& bd_addr, bool accept) {
546     body(bd_addr, accept);
547   };
548 };
549 extern struct BTA_DmSirkConfirmDeviceReply BTA_DmSirkConfirmDeviceReply;
550 
551 // Name: BTA_DmSirkSecCbRegister
552 // Params: tBTA_DM_SEC_CBACK* p_cback
553 // Return: void
554 struct BTA_DmSirkSecCbRegister {
555   std::function<void(tBTA_DM_SEC_CBACK* p_cback)> body{
556       [](tBTA_DM_SEC_CBACK* /* p_cback */) {}};
operatorBTA_DmSirkSecCbRegister557   void operator()(tBTA_DM_SEC_CBACK* p_cback) { body(p_cback); };
558 };
559 extern struct BTA_DmSirkSecCbRegister BTA_DmSirkSecCbRegister;
560 
561 // Name: BTA_EnableTestMode
562 // Params: void
563 // Return: void
564 struct BTA_EnableTestMode {
565   std::function<void(void)> body{[](void) {}};
operatorBTA_EnableTestMode566   void operator()(void) { body(); };
567 };
568 extern struct BTA_EnableTestMode BTA_EnableTestMode;
569 
570 // Name: BTA_dm_init
571 // Params:
572 // Return: void
573 struct BTA_dm_init {
574   std::function<void()> body{[]() {}};
operatorBTA_dm_init575   void operator()() { body(); };
576 };
577 extern struct BTA_dm_init BTA_dm_init;
578 
579 }  // namespace bta_dm_api
580 }  // namespace mock
581 }  // namespace test
582 
583 // END mockcify generation
584