1 /******************************************************************************
2 *
3 * Copyright (C) 2006-2012 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 /******************************************************************************
20 *
21 * This is the implementation of the JAVA API for Bluetooth Wireless
22 * Technology (JABWT) as specified by the JSR82 specificiation
23 *
24 ******************************************************************************/
25 #include "bta_api.h"
26 #include "bd.h"
27 #include "bta_sys.h"
28 #include "bta_jv_api.h"
29 #include "bta_jv_int.h"
30 #include "gki.h"
31 #include <string.h>
32 #include "port_api.h"
33 #include "sdp_api.h"
34 #include "utl.h"
35
36 /*****************************************************************************
37 ** Constants
38 *****************************************************************************/
39
40 static const tBTA_SYS_REG bta_jv_reg =
41 {
42 bta_jv_sm_execute,
43 NULL
44 };
45
46 /*******************************************************************************
47 **
48 ** Function BTA_JvEnable
49 **
50 ** Description Enable the Java I/F service. When the enable
51 ** operation is complete the callback function will be
52 ** called with a BTA_JV_ENABLE_EVT. This function must
53 ** be called before other function in the JV API are
54 ** called.
55 **
56 ** Returns BTA_JV_SUCCESS if successful.
57 ** BTA_JV_FAIL if internal failure.
58 **
59 *******************************************************************************/
BTA_JvEnable(tBTA_JV_DM_CBACK * p_cback)60 tBTA_JV_STATUS BTA_JvEnable(tBTA_JV_DM_CBACK *p_cback)
61 {
62 tBTA_JV_STATUS status = BTA_JV_FAILURE;
63 tBTA_JV_API_ENABLE *p_buf;
64 int i;
65
66 APPL_TRACE_API( "BTA_JvEnable");
67 if(p_cback && FALSE == bta_sys_is_register(BTA_ID_JV))
68 {
69 memset(&bta_jv_cb, 0, sizeof(tBTA_JV_CB));
70 /* set handle to invalid value by default */
71 for (i=0; i<BTA_JV_PM_MAX_NUM; i++)
72 {
73 bta_jv_cb.pm_cb[i].handle = BTA_JV_PM_HANDLE_CLEAR;
74 }
75
76 /* register with BTA system manager */
77 bta_sys_register(BTA_ID_JV, &bta_jv_reg);
78
79 if (p_cback && (p_buf = (tBTA_JV_API_ENABLE *) GKI_getbuf(sizeof(tBTA_JV_API_ENABLE))) != NULL)
80 {
81 p_buf->hdr.event = BTA_JV_API_ENABLE_EVT;
82 p_buf->p_cback = p_cback;
83 bta_sys_sendmsg(p_buf);
84 status = BTA_JV_SUCCESS;
85 }
86 }
87 else
88 {
89 APPL_TRACE_ERROR("JVenable fails");
90 }
91 return(status);
92 }
93
94 /*******************************************************************************
95 **
96 ** Function BTA_JvDisable
97 **
98 ** Description Disable the Java I/F
99 **
100 ** Returns void
101 **
102 *******************************************************************************/
BTA_JvDisable(void)103 void BTA_JvDisable(void)
104 {
105 BT_HDR *p_buf;
106
107 APPL_TRACE_API( "BTA_JvDisable");
108 bta_sys_deregister(BTA_ID_JV);
109 if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
110 {
111 p_buf->event = BTA_JV_API_DISABLE_EVT;
112 bta_sys_sendmsg(p_buf);
113 }
114 }
115
116 /*******************************************************************************
117 **
118 ** Function BTA_JvIsEnable
119 **
120 ** Description Get the JV registration status.
121 **
122 ** Returns TRUE, if registered
123 **
124 *******************************************************************************/
BTA_JvIsEnable(void)125 BOOLEAN BTA_JvIsEnable(void)
126 {
127 return bta_sys_is_register(BTA_ID_JV);
128 }
129
130 /*******************************************************************************
131 **
132 ** Function BTA_JvSetDiscoverability
133 **
134 ** Description This function sets the Bluetooth discoverable modes
135 ** of the local device. This controls whether other
136 ** Bluetooth devices can find the local device.
137 **
138 ** When the operation is complete the tBTA_JV_DM_CBACK callback
139 ** function will be called with a BTA_JV_SET_DISCOVER_EVT.
140 **
141 ** Returns BTA_JV_SUCCESS if successful.
142 ** BTA_JV_FAIL if internal failure.
143 **
144 *******************************************************************************/
BTA_JvSetDiscoverability(tBTA_JV_DISC disc_mode)145 tBTA_JV_STATUS BTA_JvSetDiscoverability(tBTA_JV_DISC disc_mode)
146 {
147 tBTA_JV_STATUS status = BTA_JV_FAILURE;
148 tBTA_JV_API_SET_DISCOVERABILITY *p_msg;
149
150 APPL_TRACE_API( "BTA_JvSetDiscoverability");
151 if ((p_msg = (tBTA_JV_API_SET_DISCOVERABILITY *)GKI_getbuf(sizeof(tBTA_JV_MSG))) != NULL)
152 {
153 p_msg->hdr.event = BTA_JV_API_SET_DISCOVERABILITY_EVT;
154 p_msg->disc_mode = disc_mode;
155 bta_sys_sendmsg(p_msg);
156 status = BTA_JV_SUCCESS;
157 }
158
159 return(status);
160 }
161
162 /*******************************************************************************
163 **
164 ** Function BTA_JvGetDiscoverability
165 **
166 ** Description This function gets the Bluetooth
167 ** discoverable modes of local device
168 **
169 ** Returns The current Bluetooth discoverable mode.
170 **
171 *******************************************************************************/
BTA_JvGetDiscoverability(void)172 tBTA_JV_DISC BTA_JvGetDiscoverability(void)
173 {
174 APPL_TRACE_API( "BTA_JvGetDiscoverability");
175 return BTM_ReadDiscoverability(0, 0);
176 }
177
178 /*******************************************************************************
179 **
180 ** Function BTA_JvGetLocalDeviceAddr
181 **
182 ** Description This function obtains the local Bluetooth device address.
183 ** The local Bluetooth device address is reported by the
184 ** tBTA_JV_DM_CBACK callback with a BTA_JV_LOCAL_ADDR_EVT.
185 **
186 ** Returns BTA_JV_SUCCESS if successful.
187 ** BTA_JV_FAIL if internal failure.
188 **
189 *******************************************************************************/
BTA_JvGetLocalDeviceAddr(void)190 tBTA_JV_STATUS BTA_JvGetLocalDeviceAddr(void)
191 {
192 tBTA_JV_STATUS ret = BTA_JV_FAILURE;
193 BT_HDR *p_msg;
194
195 APPL_TRACE_API( "BTA_JvGetLocalDeviceAddr");
196 if ((p_msg = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR))) != NULL)
197 {
198 p_msg->event = BTA_JV_API_GET_LOCAL_DEVICE_ADDR_EVT;
199 bta_sys_sendmsg(p_msg);
200 ret = BTA_JV_SUCCESS;
201 }
202
203 return(ret);
204 }
205
206 /*******************************************************************************
207 **
208 ** Function BTA_JvGetLocalDeviceName
209 **
210 ** Description This function obtains the name of the local device
211 ** The local Bluetooth device name is reported by the
212 ** tBTA_JV_DM_CBACK callback with a BTA_JV_LOCAL_NAME_EVT.
213 **
214 ** Returns BTA_JV_SUCCESS if successful.
215 ** BTA_JV_FAIL if internal failure.
216 **
217 *******************************************************************************/
BTA_JvGetLocalDeviceName(void)218 tBTA_JV_STATUS BTA_JvGetLocalDeviceName(void)
219 {
220 tBTA_JV_STATUS ret = BTA_JV_FAILURE;
221 BT_HDR *p_msg;
222
223 APPL_TRACE_API( "BTA_JvGetLocalDeviceName");
224 if ((p_msg = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR))) != NULL)
225 {
226 p_msg->event = BTA_JV_API_GET_LOCAL_DEVICE_NAME_EVT;
227 bta_sys_sendmsg(p_msg);
228 ret = BTA_JV_SUCCESS;
229 }
230
231 return(ret);
232 }
233
234 /*******************************************************************************
235 **
236 ** Function BTA_JvGetRemoteDeviceName
237 **
238 ** Description This function obtains the name of the specified device.
239 ** The Bluetooth device name is reported by the
240 ** tBTA_JV_DM_CBACK callback with a BTA_JV_REMOTE_NAME_EVT.
241 **
242 ** Returns BTA_JV_SUCCESS if successful.
243 ** BTA_JV_FAIL if internal failure.
244 **
245 *******************************************************************************/
BTA_JvGetRemoteDeviceName(BD_ADDR bd_addr)246 tBTA_JV_STATUS BTA_JvGetRemoteDeviceName(BD_ADDR bd_addr)
247 {
248 tBTA_JV_STATUS ret = BTA_JV_FAILURE;
249 tBTA_JV_API_GET_REMOTE_NAME *p_msg;
250
251 APPL_TRACE_API( "BTA_JvGetRemoteDeviceName");
252 if ((p_msg = (tBTA_JV_API_GET_REMOTE_NAME *)GKI_getbuf(sizeof(tBTA_JV_API_GET_REMOTE_NAME))) != NULL)
253 {
254 p_msg->hdr.event = BTA_JV_API_GET_REMOTE_DEVICE_NAME_EVT;
255 bdcpy(p_msg->bd_addr, bd_addr);
256 bta_sys_sendmsg(p_msg);
257 ret = BTA_JV_SUCCESS;
258 }
259
260 return(ret);
261 }
262
263 /*******************************************************************************
264 **
265 ** Function BTA_JvGetPreknownDevice
266 **
267 ** Description This function obtains the Bluetooth address in the inquiry
268 ** database collected via the previous call to BTA_DmSearch().
269 **
270 ** Returns The number of preknown devices if p_bd_addr is NULL
271 ** BTA_JV_SUCCESS if successful.
272 ** BTA_JV_INTERNAL_ERR(-1) if internal failure.
273 **
274 *******************************************************************************/
BTA_JvGetPreknownDevice(UINT8 * p_bd_addr,UINT32 index)275 INT32 BTA_JvGetPreknownDevice(UINT8 * p_bd_addr, UINT32 index)
276 {
277 tBTA_JV_STATUS status = BTA_JV_FAILURE;
278 tBTM_INQ_INFO *p_info;
279 UINT32 count = 0;
280 INT32 ret = BTA_JV_INTERNAL_ERR;
281
282 APPL_TRACE_API( "BTA_JvGetPreknownDevice");
283 p_info = BTM_InqFirstResult();
284 if(p_info)
285 {
286 status = BTA_JV_SUCCESS;
287 /* the database is valid */
288 if(NULL == p_bd_addr)
289 {
290 /* p_bd_addr is NULL: count the number of preknown devices */
291 /* set the index to an invalid size (too big) */
292 index = BTM_INQ_DB_SIZE;
293 }
294 else if(index >= BTM_INQ_DB_SIZE)
295 {
296 /* invalid index - error */
297 status = (tBTA_JV_STATUS)BTA_JV_INTERNAL_ERR;
298 }
299
300 if(BTA_JV_SUCCESS == status)
301 {
302 while(p_info && index > count)
303 {
304 count++;
305 p_info = BTM_InqNextResult(p_info);
306 }
307
308 if(p_bd_addr)
309 {
310 if(index == count && p_info)
311 {
312 count = BTA_JV_SUCCESS;
313 bdcpy(p_bd_addr, p_info->results.remote_bd_addr);
314 }
315 else
316 status = (tBTA_JV_STATUS)BTA_JV_INTERNAL_ERR;
317 }
318 /*
319 else report the count
320 */
321 }
322 /*
323 else error had happened.
324 */
325 }
326
327 if(BTA_JV_SUCCESS == status)
328 {
329 ret = count;
330 }
331 return ret;
332 }
333
334
335 /*******************************************************************************
336 **
337 ** Function BTA_JvGetDeviceClass
338 **
339 ** Description This function obtains the local Class of Device. This
340 ** function executes in place. The result is returned right away.
341 **
342 ** Returns DEV_CLASS, A three-byte array of UINT8 that contains the
343 ** Class of Device information. The definitions are in the
344 ** "Bluetooth Assigned Numbers".
345 **
346 *******************************************************************************/
BTA_JvGetDeviceClass(void)347 UINT8 * BTA_JvGetDeviceClass(void)
348 {
349 APPL_TRACE_API( "BTA_JvGetDeviceClass");
350 return BTM_ReadDeviceClass();
351 }
352
353 /*******************************************************************************
354 **
355 ** Function BTA_JvSetServiceClass
356 **
357 ** Description This function sets the service class of local Class of Device
358 **
359 ** Returns BTA_JV_SUCCESS if successful.
360 ** BTA_JV_FAIL if internal failure.
361 **
362 *******************************************************************************/
BTA_JvSetServiceClass(UINT32 service)363 tBTA_JV_STATUS BTA_JvSetServiceClass(UINT32 service)
364 {
365 tBTA_JV_STATUS status = BTA_JV_FAILURE;
366 tBTA_JV_API_SET_SERVICE_CLASS *p_msg;
367
368 APPL_TRACE_API( "BTA_JvSetServiceClass");
369 if ((p_msg = (tBTA_JV_API_SET_SERVICE_CLASS *)GKI_getbuf(sizeof(tBTA_JV_API_SET_SERVICE_CLASS))) != NULL)
370 {
371 p_msg->hdr.event = BTA_JV_API_SET_SERVICE_CLASS_EVT;
372 p_msg->service = service;
373 bta_sys_sendmsg(p_msg);
374 status = BTA_JV_SUCCESS;
375 }
376
377 return(status);
378 }
379
380 /*******************************************************************************
381 **
382 ** Function BTA_JvSetEncryption
383 **
384 ** Description This function ensures that the connection to the given device
385 ** is encrypted.
386 ** When the operation is complete the tBTA_JV_DM_CBACK callback
387 ** function will be called with a BTA_JV_SET_ENCRYPTION_EVT.
388 **
389 ** Returns BTA_JV_SUCCESS, if the request is being processed.
390 ** BTA_JV_FAILURE, otherwise.
391 **
392 *******************************************************************************/
BTA_JvSetEncryption(BD_ADDR bd_addr)393 tBTA_JV_STATUS BTA_JvSetEncryption(BD_ADDR bd_addr)
394 {
395 tBTA_JV_STATUS ret = BTA_JV_FAILURE;
396 tBTA_JV_API_SET_ENCRYPTION *p_msg;
397
398 APPL_TRACE_API( "BTA_JvSetEncryption");
399 if ((p_msg = (tBTA_JV_API_SET_ENCRYPTION *)GKI_getbuf(sizeof(tBTA_JV_API_SET_ENCRYPTION))) != NULL)
400 {
401 p_msg->hdr.event = BTA_JV_API_SET_ENCRYPTION_EVT;
402 bdcpy(p_msg->bd_addr, bd_addr);
403 bta_sys_sendmsg(p_msg);
404 ret = BTA_JV_SUCCESS;
405 }
406
407 return(ret);
408 }
409
410 /*******************************************************************************
411 **
412 ** Function BTA_JvIsAuthenticated
413 **
414 ** Description This function checks if the peer device is authenticated
415 **
416 ** Returns TRUE if authenticated.
417 ** FALSE if not.
418 **
419 *******************************************************************************/
BTA_JvIsAuthenticated(BD_ADDR bd_addr)420 BOOLEAN BTA_JvIsAuthenticated(BD_ADDR bd_addr)
421 {
422 BOOLEAN is_authenticated = FALSE;
423 UINT8 sec_flags;
424
425 if(BTM_GetSecurityFlags(bd_addr, &sec_flags))
426 {
427 if(sec_flags&BTM_SEC_FLAG_AUTHENTICATED)
428 is_authenticated = TRUE;
429 }
430 return is_authenticated;
431 }
432
433 /*******************************************************************************
434 **
435 ** Function BTA_JvIsTrusted
436 **
437 ** Description This function checks if the peer device is trusted
438 ** (previously paired)
439 **
440 ** Returns TRUE if trusted.
441 ** FALSE if not.
442 **
443 *******************************************************************************/
BTA_JvIsTrusted(BD_ADDR bd_addr)444 BOOLEAN BTA_JvIsTrusted(BD_ADDR bd_addr)
445 {
446 BOOLEAN is_trusted = FALSE;
447 UINT8 sec_flags;
448
449 if(BTM_GetSecurityFlags(bd_addr, &sec_flags))
450 {
451 if ((sec_flags&BTM_SEC_FLAG_AUTHENTICATED) ||
452 (sec_flags&BTM_SEC_FLAG_LKEY_KNOWN))
453 {
454 is_trusted = TRUE;
455 }
456 }
457 return is_trusted;
458 }
459
460 /*******************************************************************************
461 **
462 ** Function BTA_JvIsAuthorized
463 **
464 ** Description This function checks if the peer device is authorized
465 **
466 ** Returns TRUE if authorized.
467 ** FALSE if not.
468 **
469 *******************************************************************************/
BTA_JvIsAuthorized(BD_ADDR bd_addr)470 BOOLEAN BTA_JvIsAuthorized(BD_ADDR bd_addr)
471 {
472 BOOLEAN is_authorized = FALSE;
473 UINT8 sec_flags;
474
475 if(BTM_GetSecurityFlags(bd_addr, &sec_flags))
476 {
477 if(sec_flags&BTM_SEC_FLAG_AUTHORIZED)
478 is_authorized = TRUE;
479 }
480 return is_authorized;
481 }
482
483 /*******************************************************************************
484 **
485 ** Function BTA_JvIsEncrypted
486 **
487 ** Description This function checks if the link to peer device is encrypted
488 **
489 ** Returns TRUE if encrypted.
490 ** FALSE if not.
491 **
492 *******************************************************************************/
BTA_JvIsEncrypted(BD_ADDR bd_addr)493 BOOLEAN BTA_JvIsEncrypted(BD_ADDR bd_addr)
494 {
495 BOOLEAN is_encrypted = FALSE;
496 UINT8 sec_flags, le_flags;
497
498 if (BTM_GetSecurityFlags(bd_addr, &sec_flags) &&
499 BTM_GetSecurityFlagsByTransport(bd_addr, &le_flags, BT_TRANSPORT_LE))
500 {
501 if(sec_flags & BTM_SEC_FLAG_ENCRYPTED ||
502 le_flags & BTM_SEC_FLAG_ENCRYPTED)
503 is_encrypted = TRUE;
504 }
505 return is_encrypted;
506 }
507
508 /*******************************************************************************
509 **
510 ** Function BTA_JvGetSecurityMode
511 **
512 ** Description This function returns the current Bluetooth security mode
513 ** of the local device
514 **
515 ** Returns The current Bluetooth security mode.
516 **
517 *******************************************************************************/
BTA_JvGetSecurityMode(void)518 tBTA_JV_SEC_MODE BTA_JvGetSecurityMode(void)
519 {
520 return BTM_GetSecurityMode();
521 }
522
523 /*******************************************************************************
524 **
525 ** Function BTA_JvGetSCN
526 **
527 ** Description This function reserves a SCN (server channel number) for
528 ** applications running over RFCOMM. It is primarily called by
529 ** server profiles/applications to register their SCN into the
530 ** SDP database. The SCN is reported by the tBTA_JV_DM_CBACK
531 ** callback with a BTA_JV_GET_SCN_EVT.
532 ** If the SCN reported is 0, that means all SCN resources are
533 ** exhausted.
534 **
535 ** Returns BTA_JV_SUCCESS, if the request is being processed.
536 ** BTA_JV_FAILURE, otherwise.
537 **
538 *******************************************************************************/
BTA_JvGetSCN(void)539 tBTA_JV_STATUS BTA_JvGetSCN(void)
540 {
541 tBTA_JV_STATUS status = BTA_JV_FAILURE;
542 BT_HDR *p_msg;
543
544 APPL_TRACE_API( "BTA_JvGetSCN");
545 if ((p_msg = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR))) != NULL)
546 {
547 p_msg->event = BTA_JV_API_GET_SCN_EVT;
548 bta_sys_sendmsg(p_msg);
549 status = BTA_JV_SUCCESS;
550 }
551
552 return(status);
553 }
554
555 /*******************************************************************************
556 **
557 ** Function BTA_JvFreeSCN
558 **
559 ** Description This function frees a server channel number that was used
560 ** by an application running over RFCOMM.
561 **
562 ** Returns BTA_JV_SUCCESS, if the request is being processed.
563 ** BTA_JV_FAILURE, otherwise.
564 **
565 *******************************************************************************/
BTA_JvFreeSCN(UINT8 scn)566 tBTA_JV_STATUS BTA_JvFreeSCN(UINT8 scn)
567 {
568 tBTA_JV_STATUS status = BTA_JV_FAILURE;
569 tBTA_JV_API_FREE_SCN *p_msg;
570
571 APPL_TRACE_API( "BTA_JvFreeSCN");
572 if ((p_msg = (tBTA_JV_API_FREE_SCN *)GKI_getbuf(sizeof(tBTA_JV_API_FREE_SCN))) != NULL)
573 {
574 p_msg->hdr.event = BTA_JV_API_FREE_SCN_EVT;
575 p_msg->scn = scn;
576 bta_sys_sendmsg(p_msg);
577 status = BTA_JV_SUCCESS;
578 }
579
580 return(status);
581 }
582
583 /*******************************************************************************
584 **
585 ** Function BTA_JvGetPSM
586 **
587 ** Description This function reserves a PSM (Protocol Service Multiplexer)
588 ** applications running over L2CAP. It is primarily called by
589 ** server profiles/applications to register their PSM into the
590 ** SDP database.
591 **
592 ** Returns The next free PSM
593 **
594 *******************************************************************************/
BTA_JvGetPSM(void)595 UINT16 BTA_JvGetPSM(void)
596 {
597 #if 0
598 APPL_TRACE_API( "BTA_JvGetPSM");
599
600 return (L2CA_AllocatePSM());
601 #endif
602 return 0;
603 }
604
605
606 /*******************************************************************************
607 **
608 ** Function BTA_JvStartDiscovery
609 **
610 ** Description This function performs service discovery for the services
611 ** provided by the given peer device. When the operation is
612 ** complete the tBTA_JV_DM_CBACK callback function will be
613 ** called with a BTA_JV_DISCOVERY_COMP_EVT.
614 **
615 ** Returns BTA_JV_SUCCESS, if the request is being processed.
616 ** BTA_JV_FAILURE, otherwise.
617 **
618 *******************************************************************************/
BTA_JvStartDiscovery(BD_ADDR bd_addr,UINT16 num_uuid,tSDP_UUID * p_uuid_list,void * user_data)619 tBTA_JV_STATUS BTA_JvStartDiscovery(BD_ADDR bd_addr, UINT16 num_uuid,
620 tSDP_UUID *p_uuid_list, void * user_data)
621 {
622 tBTA_JV_STATUS status = BTA_JV_FAILURE;
623 tBTA_JV_API_START_DISCOVERY *p_msg;
624
625 APPL_TRACE_API( "BTA_JvStartDiscovery");
626 if ((p_msg = (tBTA_JV_API_START_DISCOVERY *)GKI_getbuf(sizeof(tBTA_JV_API_START_DISCOVERY))) != NULL)
627 {
628 p_msg->hdr.event = BTA_JV_API_START_DISCOVERY_EVT;
629 bdcpy(p_msg->bd_addr, bd_addr);
630 p_msg->num_uuid = num_uuid;
631 memcpy(p_msg->uuid_list, p_uuid_list, num_uuid * sizeof(tSDP_UUID));
632 p_msg->num_attr = 0;
633 p_msg->user_data = user_data;
634 bta_sys_sendmsg(p_msg);
635 status = BTA_JV_SUCCESS;
636 }
637
638 return(status);
639 }
640
641 /*******************************************************************************
642 **
643 ** Function BTA_JvCancelDiscovery
644 **
645 ** Description This function cancels an active service discovery.
646 ** When the operation is
647 ** complete the tBTA_JV_DM_CBACK callback function will be
648 ** called with a BTA_JV_CANCEL_DISCVRY_EVT.
649 **
650 ** Returns BTA_JV_SUCCESS, if the request is being processed.
651 ** BTA_JV_FAILURE, otherwise.
652 **
653 *******************************************************************************/
BTA_JvCancelDiscovery(void * user_data)654 tBTA_JV_STATUS BTA_JvCancelDiscovery(void * user_data)
655 {
656 tBTA_JV_STATUS status = BTA_JV_FAILURE;
657 tBTA_JV_API_CANCEL_DISCOVERY *p_msg;
658
659 APPL_TRACE_API( "BTA_JvCancelDiscovery");
660 if ((p_msg = (tBTA_JV_API_CANCEL_DISCOVERY *)GKI_getbuf(sizeof(tBTA_JV_API_CANCEL_DISCOVERY))) != NULL)
661 {
662 p_msg->hdr.event = BTA_JV_API_CANCEL_DISCOVERY_EVT;
663 p_msg->user_data = user_data;
664 bta_sys_sendmsg(p_msg);
665 status = BTA_JV_SUCCESS;
666 }
667
668 return(status);
669 }
670
671 /*******************************************************************************
672 **
673 ** Function BTA_JvGetServicesLength
674 **
675 ** Description This function obtains the number of services and the length
676 ** of each service found in the SDP database (result of last
677 ** BTA_JvStartDiscovery().When the operation is complete the
678 ** tBTA_JV_DM_CBACK callback function will be called with a
679 ** BTA_JV_SERVICES_LEN_EVT.
680 **
681 ** Returns BTA_JV_SUCCESS, if the request is being processed.
682 ** BTA_JV_FAILURE, otherwise.
683 **
684 *******************************************************************************/
BTA_JvGetServicesLength(BOOLEAN inc_hdr,UINT16 * p_services_len)685 tBTA_JV_STATUS BTA_JvGetServicesLength(BOOLEAN inc_hdr, UINT16 *p_services_len)
686 {
687 tBTA_JV_STATUS status = BTA_JV_FAILURE;
688 tBTA_JV_API_GET_SERVICES_LENGTH *p_msg;
689
690 APPL_TRACE_API( "BTA_JvGetServicesLength");
691 if ((p_msg = (tBTA_JV_API_GET_SERVICES_LENGTH *)GKI_getbuf(sizeof(tBTA_JV_API_GET_SERVICES_LENGTH))) != NULL)
692 {
693 p_msg->hdr.event = BTA_JV_API_GET_SERVICES_LENGTH_EVT;
694 p_msg->p_services_len = p_services_len;
695 p_msg->inc_hdr = inc_hdr;
696 bta_sys_sendmsg(p_msg);
697 status = BTA_JV_SUCCESS;
698 }
699
700 return(status);
701 }
702 /*******************************************************************************
703 **
704 ** Function BTA_JvGetServicesResult
705 **
706 ** Description This function returns a number of service records found
707 ** during current service search, equals to the number returned
708 ** by previous call to BTA_JvGetServicesLength.
709 ** The contents of each SDP record will be returned under a
710 ** TLV (type, len, value) representation in the data buffer
711 ** provided by the caller.
712 **
713 ** Returns -1, if error. Otherwise, the number of services
714 **
715 *******************************************************************************/
BTA_JvGetServicesResult(BOOLEAN inc_hdr,UINT8 ** TLVs)716 INT32 BTA_JvGetServicesResult(BOOLEAN inc_hdr, UINT8 **TLVs)
717 {
718 UNUSED(inc_hdr);
719 UNUSED(TLVs);
720 #if 0
721 INT32 num_services = -1;
722 UINT8 *p, *np, *op, type;
723 UINT32 raw_used, raw_cur;
724 UINT32 len;
725 UINT32 hdr_len;
726
727 APPL_TRACE_API( "BTA_JvGetServicesResult");
728 if(p_bta_jv_cfg->p_sdp_db->p_first_rec)
729 {
730 /* the database is valid */
731 num_services = 0;
732 p = p_bta_jv_cfg->p_sdp_db->raw_data;
733 raw_used = p_bta_jv_cfg->p_sdp_db->raw_used;
734 while(raw_used && p)
735 {
736 op = p;
737 type = *p++;
738 np = sdpu_get_len_from_type(p, type, &len);
739 p = np + len;
740 raw_cur = p - op;
741 if(raw_used >= raw_cur)
742 {
743 raw_used -= raw_cur;
744 }
745 else
746 {
747 /* error. can not continue */
748 break;
749 }
750 if(inc_hdr)
751 {
752 hdr_len = np - op;
753 memcpy(TLVs[num_services++], op, len+hdr_len);
754 }
755 else
756 {
757 memcpy(TLVs[num_services++], np, len);
758 }
759 } /* end of while */
760 }
761 return(num_services);
762 #endif
763 return 0;
764 }
765 /*******************************************************************************
766 **
767 ** Function BTA_JvServiceSelect
768 **
769 ** Description This function checks if the SDP database contains the given
770 ** service UUID. When the operation is complete the
771 ** tBTA_JV_DM_CBACK callback function will be called with a
772 ** BTA_JV_SERVICE_SEL_EVT with the length of the service record.
773 ** If the service is not found or error, -1 is reported.
774 **
775 ** Returns BTA_JV_SUCCESS, if the request is being processed.
776 ** BTA_JV_FAILURE, otherwise.
777 **
778 *******************************************************************************/
BTA_JvServiceSelect(UINT16 uuid)779 tBTA_JV_STATUS BTA_JvServiceSelect(UINT16 uuid)
780 {
781 tBTA_JV_STATUS status = BTA_JV_FAILURE;
782 tBTA_JV_API_SERVICE_SELECT *p_msg;
783
784 APPL_TRACE_API( "BTA_JvServiceSelect");
785 if ((p_msg = (tBTA_JV_API_SERVICE_SELECT *)GKI_getbuf(sizeof(tBTA_JV_API_SERVICE_SELECT))) != NULL)
786 {
787 p_msg->hdr.event = BTA_JV_API_SERVICE_SELECT_EVT;
788 p_msg->uuid = uuid;
789 bta_sys_sendmsg(p_msg);
790 status = BTA_JV_SUCCESS;
791 }
792 return(status);
793 }
794
795 /*******************************************************************************
796 **
797 ** Function BTA_JvServiceResult
798 **
799 ** Description This function returns the contents of the SDP record from
800 ** last BTA_JvServiceSelect. The contents will be returned under
801 ** a TLV (type, len, value) representation in the data buffer
802 ** provided by the caller.
803 **
804 ** Returns -1, if error. Otherwise, the length of service record.
805 **
806 *******************************************************************************/
BTA_JvServiceResult(UINT8 * TLV)807 INT32 BTA_JvServiceResult(UINT8 *TLV)
808 {
809 INT32 serv_sel = -1;
810
811 APPL_TRACE_API( "BTA_JvServiceResult");
812 if(bta_jv_cb.p_sel_raw_data)
813 {
814 serv_sel = bta_jv_cb.sel_len;
815 memcpy(TLV, bta_jv_cb.p_sel_raw_data, serv_sel);
816 }
817
818 return serv_sel;
819 }
820
821
822 /*******************************************************************************
823 **
824 ** Function BTA_JvCreateRecord
825 **
826 ** Description Create a service record in the local SDP database.
827 ** When the operation is complete the tBTA_JV_DM_CBACK callback
828 ** function will be called with a BTA_JV_CREATE_RECORD_EVT.
829 **
830 ** Returns BTA_JV_SUCCESS, if the request is being processed.
831 ** BTA_JV_FAILURE, otherwise.
832 **
833 *******************************************************************************/
BTA_JvCreateRecordByUser(void * user_data)834 tBTA_JV_STATUS BTA_JvCreateRecordByUser(void *user_data)
835 {
836 tBTA_JV_STATUS status = BTA_JV_FAILURE;
837 tBTA_JV_API_CREATE_RECORD *p_msg;
838
839 APPL_TRACE_API( "BTA_JvCreateRecordByUser");
840 if ((p_msg = (tBTA_JV_API_CREATE_RECORD *)GKI_getbuf(sizeof(tBTA_JV_API_CREATE_RECORD))) != NULL)
841 {
842 p_msg->hdr.event = BTA_JV_API_CREATE_RECORD_EVT;
843 p_msg->user_data = user_data;
844 bta_sys_sendmsg(p_msg);
845 status = BTA_JV_SUCCESS;
846 }
847
848 return(status);
849 }
850
851 /*******************************************************************************
852 **
853 ** Function BTA_JvUpdateRecord
854 **
855 ** Description Update a service record in the local SDP database.
856 ** When the operation is complete the tBTA_JV_DM_CBACK callback
857 ** function will be called with a BTA_JV_UPDATE_RECORD_EVT.
858 **
859 ** Returns BTA_JV_SUCCESS, if the request is being processed.
860 ** BTA_JV_FAILURE, otherwise.
861 **
862 *******************************************************************************/
BTA_JvUpdateRecord(UINT32 handle,UINT16 * p_ids,UINT8 ** p_values,INT32 * p_value_sizes,INT32 array_len)863 tBTA_JV_STATUS BTA_JvUpdateRecord(UINT32 handle, UINT16 *p_ids,
864 UINT8 **p_values, INT32 *p_value_sizes, INT32 array_len)
865 {
866 UNUSED(handle);
867 UNUSED(p_ids);
868 UNUSED(p_values);
869 UNUSED(p_value_sizes);
870 UNUSED(array_len);
871 #if 0
872 tBTA_JV_STATUS status = BTA_JV_FAILURE;
873 tBTA_JV_API_UPDATE_RECORD *p_msg;
874
875 APPL_TRACE_API( "BTA_JvUpdateRecord");
876 if ((p_msg = (tBTA_JV_API_UPDATE_RECORD *)GKI_getbuf(sizeof(tBTA_JV_API_UPDATE_RECORD))) != NULL)
877 {
878 p_msg->hdr.event = BTA_JV_API_UPDATE_RECORD_EVT;
879 p_msg->handle = handle;
880 p_msg->p_ids = p_ids;
881 p_msg->p_values = p_values;
882 p_msg->p_value_sizes = p_value_sizes;
883 p_msg->array_len = array_len;
884 bta_sys_sendmsg(p_msg);
885 status = BTA_JV_SUCCESS;
886 }
887 return(status);
888 #endif
889 return -1;
890 }
891
892 /*******************************************************************************
893 **
894 ** Function BTA_JvAddAttribute
895 **
896 ** Description Add an attribute to a service record in the local SDP database.
897 ** When the operation is complete the tBTA_JV_DM_CBACK callback
898 ** function will be called with a BTA_JV_ADD_ATTR_EVT.
899 **
900 ** Returns BTA_JV_SUCCESS, if the request is being processed.
901 ** BTA_JV_FAILURE, otherwise.
902 **
903 *******************************************************************************/
BTA_JvAddAttribute(UINT32 handle,UINT16 attr_id,UINT8 * p_value,INT32 value_size)904 tBTA_JV_STATUS BTA_JvAddAttribute(UINT32 handle, UINT16 attr_id,
905 UINT8 *p_value, INT32 value_size)
906 {
907 tBTA_JV_STATUS status = BTA_JV_FAILURE;
908 tBTA_JV_API_ADD_ATTRIBUTE *p_msg;
909
910 APPL_TRACE_API( "BTA_JvAddAttribute");
911 if ((p_msg = (tBTA_JV_API_ADD_ATTRIBUTE *)GKI_getbuf(sizeof(tBTA_JV_API_ADD_ATTRIBUTE))) != NULL)
912 {
913 p_msg->hdr.event = BTA_JV_API_ADD_ATTRIBUTE_EVT;
914 p_msg->handle = handle;
915 p_msg->attr_id = attr_id;
916 p_msg->p_value = p_value;
917 p_msg->value_size = value_size;
918 bta_sys_sendmsg(p_msg);
919 status = BTA_JV_SUCCESS;
920 }
921 return(status);
922 }
923
924 /*******************************************************************************
925 **
926 ** Function BTA_JvDeleteAttribute
927 **
928 ** Description Delete an attribute from a service record in the local SDP database.
929 ** When the operation is complete the tBTA_JV_DM_CBACK callback
930 ** function will be called with a BTA_JV_DELETE_ATTR_EVT.
931 **
932 ** Returns BTA_JV_SUCCESS, if the request is being processed.
933 ** BTA_JV_FAILURE, otherwise.
934 **
935 *******************************************************************************/
BTA_JvDeleteAttribute(UINT32 handle,UINT16 attr_id)936 tBTA_JV_STATUS BTA_JvDeleteAttribute(UINT32 handle, UINT16 attr_id)
937 {
938 tBTA_JV_STATUS status = BTA_JV_FAILURE;
939 tBTA_JV_API_ADD_ATTRIBUTE *p_msg;
940
941 APPL_TRACE_API( "BTA_JvDeleteAttribute");
942 if ((p_msg = (tBTA_JV_API_ADD_ATTRIBUTE *)GKI_getbuf(sizeof(tBTA_JV_API_ADD_ATTRIBUTE))) != NULL)
943 {
944 p_msg->hdr.event = BTA_JV_API_DELETE_ATTRIBUTE_EVT;
945 p_msg->handle = handle;
946 p_msg->attr_id = attr_id;
947 bta_sys_sendmsg(p_msg);
948 status = BTA_JV_SUCCESS;
949 }
950 return(status);
951 }
952
953 /*******************************************************************************
954 **
955 ** Function BTA_JvDeleteRecord
956 **
957 ** Description Delete a service record in the local SDP database.
958 **
959 ** Returns BTA_JV_SUCCESS, if the request is being processed.
960 ** BTA_JV_FAILURE, otherwise.
961 **
962 *******************************************************************************/
BTA_JvDeleteRecord(UINT32 handle)963 tBTA_JV_STATUS BTA_JvDeleteRecord(UINT32 handle)
964 {
965 tBTA_JV_STATUS status = BTA_JV_FAILURE;
966 tBTA_JV_API_ADD_ATTRIBUTE *p_msg;
967
968 APPL_TRACE_API( "BTA_JvDeleteRecord");
969 if ((p_msg = (tBTA_JV_API_ADD_ATTRIBUTE *)GKI_getbuf(sizeof(tBTA_JV_API_ADD_ATTRIBUTE))) != NULL)
970 {
971 p_msg->hdr.event = BTA_JV_API_DELETE_RECORD_EVT;
972 p_msg->handle = handle;
973 bta_sys_sendmsg(p_msg);
974 status = BTA_JV_SUCCESS;
975 }
976 return(status);
977 }
978
979 /*******************************************************************************
980 **
981 ** Function BTA_JvReadRecord
982 **
983 ** Description Read a service record in the local SDP database.
984 **
985 ** Returns -1, if the record is not found.
986 ** Otherwise, the offset (0 or 1) to start of data in p_data.
987 **
988 ** The size of data copied into p_data is in *p_data_len.
989 **
990 *******************************************************************************/
BTA_JvReadRecord(UINT32 handle,UINT8 * p_data,INT32 * p_data_len)991 INT32 BTA_JvReadRecord(UINT32 handle, UINT8 *p_data, INT32 *p_data_len)
992 {
993 UINT32 sdp_handle;
994
995 sdp_handle = bta_jv_get_sdp_handle(handle);
996
997 if(sdp_handle)
998 {
999 return SDP_ReadRecord(sdp_handle, p_data, p_data_len);
1000 }
1001
1002 return -1;
1003 }
1004
1005 /*******************************************************************************
1006 **
1007 ** Function BTA_JvL2capConnect
1008 **
1009 ** Description Initiate a connection as a L2CAP client to the given BD
1010 ** Address.
1011 ** When the connection is initiated or failed to initiate,
1012 ** tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_CL_INIT_EVT
1013 ** When the connection is established or failed,
1014 ** tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_OPEN_EVT
1015 **
1016 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1017 ** BTA_JV_FAILURE, otherwise.
1018 **
1019 *******************************************************************************/
BTA_JvL2capConnect(tBTA_SEC sec_mask,tBTA_JV_ROLE role,UINT16 remote_psm,UINT16 rx_mtu,BD_ADDR peer_bd_addr,tBTA_JV_L2CAP_CBACK * p_cback)1020 tBTA_JV_STATUS BTA_JvL2capConnect(tBTA_SEC sec_mask,
1021 tBTA_JV_ROLE role, UINT16 remote_psm, UINT16 rx_mtu,
1022 BD_ADDR peer_bd_addr, tBTA_JV_L2CAP_CBACK *p_cback)
1023 {
1024 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1025 tBTA_JV_API_L2CAP_CONNECT *p_msg;
1026
1027 APPL_TRACE_API( "BTA_JvL2capConnect");
1028 if (p_cback &&
1029 (p_msg = (tBTA_JV_API_L2CAP_CONNECT *)GKI_getbuf(sizeof(tBTA_JV_API_L2CAP_CONNECT))) != NULL)
1030 {
1031 p_msg->hdr.event = BTA_JV_API_L2CAP_CONNECT_EVT;
1032 p_msg->sec_mask = sec_mask;
1033 p_msg->role = role;
1034 p_msg->remote_psm = remote_psm;
1035 p_msg->rx_mtu = rx_mtu;
1036 memcpy(p_msg->peer_bd_addr, peer_bd_addr, sizeof(BD_ADDR));
1037 p_msg->p_cback = p_cback;
1038 bta_sys_sendmsg(p_msg);
1039 status = BTA_JV_SUCCESS;
1040 }
1041
1042 return(status);
1043 }
1044
1045 /*******************************************************************************
1046 **
1047 ** Function BTA_JvL2capClose
1048 **
1049 ** Description This function closes an L2CAP client connection
1050 **
1051 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1052 ** BTA_JV_FAILURE, otherwise.
1053 **
1054 *******************************************************************************/
BTA_JvL2capClose(UINT32 handle)1055 tBTA_JV_STATUS BTA_JvL2capClose(UINT32 handle)
1056 {
1057 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1058 tBTA_JV_API_L2CAP_CLOSE *p_msg;
1059
1060 APPL_TRACE_API( "BTA_JvL2capClose");
1061 if (handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback &&
1062 (p_msg = (tBTA_JV_API_L2CAP_CLOSE *)GKI_getbuf(sizeof(tBTA_JV_API_L2CAP_CLOSE))) != NULL)
1063 {
1064 p_msg->hdr.event = BTA_JV_API_L2CAP_CLOSE_EVT;
1065 p_msg->handle = handle;
1066 p_msg->p_cb = &bta_jv_cb.l2c_cb[handle];
1067 bta_sys_sendmsg(p_msg);
1068 status = BTA_JV_SUCCESS;
1069 }
1070
1071 return(status);
1072 }
1073
1074 /*******************************************************************************
1075 **
1076 ** Function BTA_JvL2capStartServer
1077 **
1078 ** Description This function starts an L2CAP server and listens for an L2CAP
1079 ** connection from a remote Bluetooth device. When the server
1080 ** is started successfully, tBTA_JV_L2CAP_CBACK is called with
1081 ** BTA_JV_L2CAP_START_EVT. When the connection is established,
1082 ** tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_OPEN_EVT.
1083 **
1084 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1085 ** BTA_JV_FAILURE, otherwise.
1086 **
1087 *******************************************************************************/
BTA_JvL2capStartServer(tBTA_SEC sec_mask,tBTA_JV_ROLE role,UINT16 local_psm,UINT16 rx_mtu,tBTA_JV_L2CAP_CBACK * p_cback)1088 tBTA_JV_STATUS BTA_JvL2capStartServer(tBTA_SEC sec_mask, tBTA_JV_ROLE role,
1089 UINT16 local_psm, UINT16 rx_mtu,
1090 tBTA_JV_L2CAP_CBACK *p_cback)
1091 {
1092 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1093 tBTA_JV_API_L2CAP_SERVER *p_msg;
1094
1095 APPL_TRACE_API( "BTA_JvL2capStartServer");
1096 if (p_cback &&
1097 (p_msg = (tBTA_JV_API_L2CAP_SERVER *)GKI_getbuf(sizeof(tBTA_JV_API_L2CAP_SERVER))) != NULL)
1098 {
1099 p_msg->hdr.event = BTA_JV_API_L2CAP_START_SERVER_EVT;
1100 p_msg->sec_mask = sec_mask;
1101 p_msg->role = role;
1102 p_msg->local_psm = local_psm;
1103 p_msg->rx_mtu = rx_mtu;
1104 p_msg->p_cback = p_cback;
1105 bta_sys_sendmsg(p_msg);
1106 status = BTA_JV_SUCCESS;
1107 }
1108
1109 return(status);
1110 }
1111
1112 /*******************************************************************************
1113 **
1114 ** Function BTA_JvL2capStopServer
1115 **
1116 ** Description This function stops the L2CAP server. If the server has an
1117 ** active connection, it would be closed.
1118 **
1119 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1120 ** BTA_JV_FAILURE, otherwise.
1121 **
1122 *******************************************************************************/
BTA_JvL2capStopServer(UINT16 local_psm)1123 tBTA_JV_STATUS BTA_JvL2capStopServer(UINT16 local_psm)
1124 {
1125 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1126 tBTA_JV_API_L2CAP_SERVER *p_msg;
1127
1128 APPL_TRACE_API( "BTA_JvL2capStopServer");
1129 if ((p_msg = (tBTA_JV_API_L2CAP_SERVER *)GKI_getbuf(sizeof(tBTA_JV_API_L2CAP_SERVER))) != NULL)
1130 {
1131 p_msg->hdr.event = BTA_JV_API_L2CAP_STOP_SERVER_EVT;
1132 p_msg->local_psm = local_psm;
1133 bta_sys_sendmsg(p_msg);
1134 status = BTA_JV_SUCCESS;
1135 }
1136
1137 return(status);
1138 }
1139
1140 /*******************************************************************************
1141 **
1142 ** Function BTA_JvL2capRead
1143 **
1144 ** Description This function reads data from an L2CAP connecti;
1145 tBTA_JV_RFC_CB *p_cb = rc->p_cb;
1146 on
1147 ** When the operation is complete, tBTA_JV_L2CAP_CBACK is
1148 ** called with BTA_JV_L2CAP_READ_EVT.
1149 **
1150 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1151 ** BTA_JV_FAILURE, otherwise.
1152 **
1153 *******************************************************************************/
BTA_JvL2capRead(UINT32 handle,UINT32 req_id,UINT8 * p_data,UINT16 len)1154 tBTA_JV_STATUS BTA_JvL2capRead(UINT32 handle, UINT32 req_id, UINT8 *p_data, UINT16 len)
1155 {
1156 UNUSED(handle);
1157 UNUSED(req_id);
1158 UNUSED(p_data);
1159 UNUSED(len);
1160
1161 #if 0
1162 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1163 #if SDP_FOR_JV_INCLUDED == TRUE
1164 tBTA_JV_API_L2CAP_READ *p_msg;
1165 #endif
1166 tBTA_JV_L2CAP_READ evt_data;
1167
1168 APPL_TRACE_API( "BTA_JvL2capRead");
1169
1170 #if SDP_FOR_JV_INCLUDED == TRUE
1171 if(BTA_JV_L2C_FOR_SDP_HDL == handle)
1172 {
1173 if (bta_jv_cb.l2c_cb[handle].p_cback &&
1174 (p_msg = (tBTA_JV_API_L2CAP_READ *)GKI_getbuf(sizeof(tBTA_JV_API_L2CAP_READ))) != NULL)
1175 {
1176 p_msg->hdr.event = BTA_JV_API_L2CAP_READ_EVT;
1177 p_msg->handle = handle;
1178 p_msg->req_id = req_id;
1179 p_msg->p_data = p_data;
1180 p_msg->len = len;
1181 p_msg->p_cback = bta_jv_cb.l2c_cb[handle].p_cback;
1182 bta_sys_sendmsg(p_msg);
1183 status = BTA_JV_SUCCESS;
1184 }
1185 }
1186 else
1187 #endif
1188 if (handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback)
1189 {
1190 status = BTA_JV_SUCCESS;
1191 evt_data.status = BTA_JV_FAILURE;
1192 evt_data.handle = handle;
1193 evt_data.req_id = req_id;
1194 evt_data.p_data = p_data;
1195 evt_data.len = 0;
1196
1197 if (BT_PASS == GAP_ConnReadData((UINT16)handle, p_data, len, &evt_data.len))
1198 {
1199 evt_data.status = BTA_JV_SUCCESS;
1200 }
1201 bta_jv_cb.l2c_cb[handle].p_cback(BTA_JV_L2CAP_READ_EVT, (tBTA_JV *)&evt_data);
1202 }
1203
1204 return(status);
1205 #endif
1206 return -1;
1207 }
1208
1209 /*******************************************************************************
1210 **
1211 ** Function BTA_JvL2capReceive
1212 **
1213 ** Description This function reads data from an L2CAP connection
1214 ** When the operation is complete, tBTA_JV_L2CAP_CBACK is
1215 ** called with BTA_JV_L2CAP_RECEIVE_EVT.
1216 ** If there are more data queued in L2CAP than len, the extra data will be discarded.
1217 **
1218 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1219 ** BTA_JV_FAILURE, otherwise.
1220 **
1221 *******************************************************************************/
BTA_JvL2capReceive(UINT32 handle,UINT32 req_id,UINT8 * p_data,UINT16 len)1222 tBTA_JV_STATUS BTA_JvL2capReceive(UINT32 handle, UINT32 req_id, UINT8 *p_data, UINT16 len)
1223 {
1224 UNUSED(handle);
1225 UNUSED(req_id);
1226 UNUSED(p_data);
1227 UNUSED(len);
1228 #if 0
1229 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1230 tBTA_JV_L2CAP_RECEIVE evt_data;
1231 UINT32 left_over = 0;
1232 UINT16 max_len, read_len;
1233
1234 APPL_TRACE_API( "BTA_JvL2capReceive");
1235
1236 if (handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback)
1237 {
1238 status = BTA_JV_SUCCESS;
1239 evt_data.status = BTA_JV_FAILURE;
1240 evt_data.handle = handle;
1241 evt_data.req_id = req_id;
1242 evt_data.p_data = p_data;
1243 evt_data.len = 0;
1244
1245 if (BT_PASS == GAP_ConnReadData((UINT16)handle, p_data, len, &evt_data.len))
1246 {
1247 evt_data.status = BTA_JV_SUCCESS;
1248 GAP_GetRxQueueCnt ((UINT16)handle, &left_over);
1249 while (left_over)
1250 {
1251 max_len = (left_over > 0xFFFF)?0xFFFF:left_over;
1252 GAP_ConnReadData ((UINT16)handle, NULL, max_len, &read_len);
1253 left_over -= read_len;
1254 }
1255 }
1256 bta_jv_cb.l2c_cb[handle].p_cback(BTA_JV_L2CAP_RECEIVE_EVT, (tBTA_JV *)&evt_data);
1257 }
1258
1259 return(status);
1260 #endif
1261 return -1;
1262 }
1263 /*******************************************************************************
1264 **
1265 ** Function BTA_JvL2capReady
1266 **
1267 ** Description This function determined if there is data to read from
1268 ** an L2CAP connection
1269 **
1270 ** Returns BTA_JV_SUCCESS, if data queue size is in *p_data_size.
1271 ** BTA_JV_FAILURE, if error.
1272 **
1273 *******************************************************************************/
BTA_JvL2capReady(UINT32 handle,UINT32 * p_data_size)1274 tBTA_JV_STATUS BTA_JvL2capReady(UINT32 handle, UINT32 *p_data_size)
1275 {
1276 UNUSED(handle);
1277 UNUSED(p_data_size);
1278 #if 0
1279 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1280
1281 APPL_TRACE_API( "BTA_JvL2capReady: %d", handle);
1282 if (p_data_size && handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback)
1283 {
1284 *p_data_size = 0;
1285 #if SDP_FOR_JV_INCLUDED == TRUE
1286 if(BTA_JV_L2C_FOR_SDP_HDL == handle)
1287 {
1288 *p_data_size = bta_jv_cb.sdp_data_size;
1289 status = BTA_JV_SUCCESS;
1290 }
1291 else
1292 #endif
1293 if(BT_PASS == GAP_GetRxQueueCnt((UINT16)handle, p_data_size) )
1294 {
1295 status = BTA_JV_SUCCESS;
1296 }
1297 }
1298
1299 return(status);
1300 #endif
1301 return -1;
1302 }
1303
1304
1305 /*******************************************************************************
1306 **
1307 ** Function BTA_JvL2capWrite
1308 **
1309 ** Description This function writes data to an L2CAP connection
1310 ** When the operation is complete, tBTA_JV_L2CAP_CBACK is
1311 ** called with BTA_JV_L2CAP_WRITE_EVT.
1312 **
1313 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1314 ** BTA_JV_FAILURE, otherwise.
1315 **
1316 *******************************************************************************/
BTA_JvL2capWrite(UINT32 handle,UINT32 req_id,UINT8 * p_data,UINT16 len)1317 tBTA_JV_STATUS BTA_JvL2capWrite(UINT32 handle, UINT32 req_id, UINT8 *p_data, UINT16 len)
1318 {
1319 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1320 tBTA_JV_API_L2CAP_WRITE *p_msg;
1321
1322 APPL_TRACE_API( "BTA_JvL2capWrite");
1323 if (handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback &&
1324 (p_msg = (tBTA_JV_API_L2CAP_WRITE *)GKI_getbuf(sizeof(tBTA_JV_API_L2CAP_WRITE))) != NULL)
1325 {
1326 p_msg->hdr.event = BTA_JV_API_L2CAP_WRITE_EVT;
1327 p_msg->handle = handle;
1328 p_msg->req_id = req_id;
1329 p_msg->p_data = p_data;
1330 p_msg->p_cb = &bta_jv_cb.l2c_cb[handle];
1331 p_msg->len = len;
1332 bta_sys_sendmsg(p_msg);
1333 status = BTA_JV_SUCCESS;
1334 }
1335
1336 return(status);
1337 }
1338
1339 /*******************************************************************************
1340 **
1341 ** Function BTA_JvRfcommConnect
1342 **
1343 ** Description This function makes an RFCOMM conection to a remote BD
1344 ** Address.
1345 ** When the connection is initiated or failed to initiate,
1346 ** tBTA_JV_RFCOMM_CBACK is called with BTA_JV_RFCOMM_CL_INIT_EVT
1347 ** When the connection is established or failed,
1348 ** tBTA_JV_RFCOMM_CBACK is called with BTA_JV_RFCOMM_OPEN_EVT
1349 **
1350 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1351 ** BTA_JV_FAILURE, otherwise.
1352 **
1353 *******************************************************************************/
BTA_JvRfcommConnect(tBTA_SEC sec_mask,tBTA_JV_ROLE role,UINT8 remote_scn,BD_ADDR peer_bd_addr,tBTA_JV_RFCOMM_CBACK * p_cback,void * user_data)1354 tBTA_JV_STATUS BTA_JvRfcommConnect(tBTA_SEC sec_mask,
1355 tBTA_JV_ROLE role, UINT8 remote_scn, BD_ADDR peer_bd_addr,
1356 tBTA_JV_RFCOMM_CBACK *p_cback, void* user_data)
1357 {
1358 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1359 tBTA_JV_API_RFCOMM_CONNECT *p_msg;
1360
1361 APPL_TRACE_API( "BTA_JvRfcommConnect");
1362 if (p_cback &&
1363 (p_msg = (tBTA_JV_API_RFCOMM_CONNECT *)GKI_getbuf(sizeof(tBTA_JV_API_RFCOMM_CONNECT))) != NULL)
1364 {
1365 p_msg->hdr.event = BTA_JV_API_RFCOMM_CONNECT_EVT;
1366 p_msg->sec_mask = sec_mask;
1367 p_msg->role = role;
1368 p_msg->remote_scn = remote_scn;
1369 memcpy(p_msg->peer_bd_addr, peer_bd_addr, sizeof(BD_ADDR));
1370 p_msg->p_cback = p_cback;
1371 p_msg->user_data = user_data;
1372 bta_sys_sendmsg(p_msg);
1373 status = BTA_JV_SUCCESS;
1374 }
1375
1376 return(status);
1377 }
1378
1379 /*******************************************************************************
1380 **
1381 ** Function BTA_JvRfcommClose
1382 **
1383 ** Description This function closes an RFCOMM connection
1384 **
1385 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1386 ** BTA_JV_FAILURE, otherwise.
1387 **
1388 *******************************************************************************/
BTA_JvRfcommClose(UINT32 handle,void * user_data)1389 tBTA_JV_STATUS BTA_JvRfcommClose(UINT32 handle, void *user_data)
1390 {
1391 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1392 tBTA_JV_API_RFCOMM_CLOSE *p_msg;
1393 UINT32 hi = ((handle & BTA_JV_RFC_HDL_MASK)&~BTA_JV_RFCOMM_MASK) - 1;
1394 UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
1395
1396 APPL_TRACE_API( "BTA_JvRfcommClose");
1397 if (hi < BTA_JV_MAX_RFC_CONN && bta_jv_cb.rfc_cb[hi].p_cback &&
1398 si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si] &&
1399 (p_msg = (tBTA_JV_API_RFCOMM_CLOSE *)GKI_getbuf(sizeof(tBTA_JV_API_RFCOMM_CLOSE))) != NULL)
1400 {
1401 p_msg->hdr.event = BTA_JV_API_RFCOMM_CLOSE_EVT;
1402 p_msg->handle = handle;
1403 p_msg->p_cb = &bta_jv_cb.rfc_cb[hi];
1404 p_msg->p_pcb = &bta_jv_cb.port_cb[p_msg->p_cb->rfc_hdl[si] - 1];
1405 p_msg->user_data = user_data;
1406 bta_sys_sendmsg(p_msg);
1407 status = BTA_JV_SUCCESS;
1408 }
1409
1410 return(status);
1411 }
1412
1413 /*******************************************************************************
1414 **
1415 ** Function BTA_JvRfcommStartServer
1416 **
1417 ** Description This function starts listening for an RFCOMM connection
1418 ** request from a remote Bluetooth device. When the server is
1419 ** started successfully, tBTA_JV_RFCOMM_CBACK is called
1420 ** with BTA_JV_RFCOMM_START_EVT.
1421 ** When the connection is established, tBTA_JV_RFCOMM_CBACK
1422 ** is called with BTA_JV_RFCOMM_OPEN_EVT.
1423 **
1424 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1425 ** BTA_JV_FAILURE, otherwise.
1426 **
1427 *******************************************************************************/
BTA_JvRfcommStartServer(tBTA_SEC sec_mask,tBTA_JV_ROLE role,UINT8 local_scn,UINT8 max_session,tBTA_JV_RFCOMM_CBACK * p_cback,void * user_data)1428 tBTA_JV_STATUS BTA_JvRfcommStartServer(tBTA_SEC sec_mask,
1429 tBTA_JV_ROLE role, UINT8 local_scn, UINT8 max_session,
1430 tBTA_JV_RFCOMM_CBACK *p_cback, void* user_data)
1431 {
1432 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1433 tBTA_JV_API_RFCOMM_SERVER *p_msg;
1434
1435 APPL_TRACE_API( "BTA_JvRfcommStartServer");
1436 if (p_cback &&
1437 (p_msg = (tBTA_JV_API_RFCOMM_SERVER *)GKI_getbuf(sizeof(tBTA_JV_API_RFCOMM_SERVER))) != NULL)
1438 {
1439 if (max_session == 0)
1440 max_session = 1;
1441 if (max_session > BTA_JV_MAX_RFC_SR_SESSION)
1442 {
1443 APPL_TRACE_DEBUG( "max_session is too big. use max (%d)", max_session, BTA_JV_MAX_RFC_SR_SESSION);
1444 max_session = BTA_JV_MAX_RFC_SR_SESSION;
1445 }
1446 p_msg->hdr.event = BTA_JV_API_RFCOMM_START_SERVER_EVT;
1447 p_msg->sec_mask = sec_mask;
1448 p_msg->role = role;
1449 p_msg->local_scn = local_scn;
1450 p_msg->max_session = max_session;
1451 p_msg->p_cback = p_cback;
1452 p_msg->user_data = user_data; //caller's private data
1453 bta_sys_sendmsg(p_msg);
1454 status = BTA_JV_SUCCESS;
1455 }
1456
1457 return(status);
1458 }
1459
1460 /*******************************************************************************
1461 **
1462 ** Function BTA_JvRfcommStopServer
1463 **
1464 ** Description This function stops the RFCOMM server. If the server has an
1465 ** active connection, it would be closed.
1466 **
1467 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1468 ** BTA_JV_FAILURE, otherwise.
1469 **
1470 *******************************************************************************/
BTA_JvRfcommStopServer(UINT32 handle,void * user_data)1471 tBTA_JV_STATUS BTA_JvRfcommStopServer(UINT32 handle, void * user_data)
1472 {
1473 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1474 tBTA_JV_API_RFCOMM_SERVER *p_msg;
1475 APPL_TRACE_API( "BTA_JvRfcommStopServer");
1476 if ((p_msg = (tBTA_JV_API_RFCOMM_SERVER *)GKI_getbuf(sizeof(tBTA_JV_API_RFCOMM_SERVER))) != NULL)
1477 {
1478 p_msg->hdr.event = BTA_JV_API_RFCOMM_STOP_SERVER_EVT;
1479 p_msg->handle = handle;
1480 p_msg->user_data = user_data; //caller's private data
1481 bta_sys_sendmsg(p_msg);
1482 status = BTA_JV_SUCCESS;
1483 }
1484
1485 return(status);
1486 }
1487
1488 /*******************************************************************************
1489 **
1490 ** Function BTA_JvRfcommRead
1491 **
1492 ** Description This function reads data from an RFCOMM connection
1493 ** The actual size of data read is returned in p_len.
1494 **
1495 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1496 ** BTA_JV_FAILURE, otherwise.
1497 **
1498 *******************************************************************************/
BTA_JvRfcommRead(UINT32 handle,UINT32 req_id,UINT8 * p_data,UINT16 len)1499 tBTA_JV_STATUS BTA_JvRfcommRead(UINT32 handle, UINT32 req_id, UINT8 *p_data, UINT16 len)
1500 {
1501 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1502 tBTA_JV_API_RFCOMM_READ *p_msg;
1503 UINT32 hi = ((handle & BTA_JV_RFC_HDL_MASK)&~BTA_JV_RFCOMM_MASK) - 1;
1504 UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
1505
1506 APPL_TRACE_API( "BTA_JvRfcommRead");
1507 if (hi < BTA_JV_MAX_RFC_CONN && bta_jv_cb.rfc_cb[hi].p_cback &&
1508 si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si] &&
1509 (p_msg = (tBTA_JV_API_RFCOMM_READ *)GKI_getbuf(sizeof(tBTA_JV_API_RFCOMM_READ))) != NULL)
1510 {
1511 p_msg->hdr.event = BTA_JV_API_RFCOMM_READ_EVT;
1512 p_msg->handle = handle;
1513 p_msg->req_id = req_id;
1514 p_msg->p_data = p_data;
1515 p_msg->len = len;
1516 p_msg->p_cb = &bta_jv_cb.rfc_cb[hi];
1517 p_msg->p_pcb = &bta_jv_cb.port_cb[p_msg->p_cb->rfc_hdl[si] - 1];
1518 bta_sys_sendmsg(p_msg);
1519 status = BTA_JV_SUCCESS;
1520 }
1521
1522 return(status);
1523 }
1524
1525 /*******************************************************************************
1526 **
1527 ** Function BTA_JvRfcommGetPortHdl
1528 **
1529 ** Description This function fetches the rfcomm port handle
1530 **
1531 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1532 ** BTA_JV_FAILURE, otherwise.
1533 **
1534 *******************************************************************************/
BTA_JvRfcommGetPortHdl(UINT32 handle)1535 UINT16 BTA_JvRfcommGetPortHdl(UINT32 handle)
1536 {
1537 UINT32 hi = ((handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
1538 UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
1539
1540 if (hi < BTA_JV_MAX_RFC_CONN &&
1541 si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si])
1542 return bta_jv_cb.port_cb[bta_jv_cb.rfc_cb[hi].rfc_hdl[si] - 1].port_handle;
1543 else
1544 return 0xffff;
1545 }
1546
1547
1548 /*******************************************************************************
1549 **
1550 ** Function BTA_JvRfcommReady
1551 **
1552 ** Description This function determined if there is data to read from
1553 ** an RFCOMM connection
1554 **
1555 ** Returns BTA_JV_SUCCESS, if data queue size is in *p_data_size.
1556 ** BTA_JV_FAILURE, if error.
1557 **
1558 *******************************************************************************/
BTA_JvRfcommReady(UINT32 handle,UINT32 * p_data_size)1559 tBTA_JV_STATUS BTA_JvRfcommReady(UINT32 handle, UINT32 *p_data_size)
1560 {
1561 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1562 UINT16 size = 0;
1563 UINT32 hi = ((handle & BTA_JV_RFC_HDL_MASK)&~BTA_JV_RFCOMM_MASK) - 1;
1564 UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
1565
1566 APPL_TRACE_API( "BTA_JvRfcommReady");
1567 if (hi < BTA_JV_MAX_RFC_CONN && bta_jv_cb.rfc_cb[hi].p_cback &&
1568 si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si])
1569 {
1570 if(PORT_GetRxQueueCnt(bta_jv_cb.rfc_cb[hi].rfc_hdl[si], &size) == PORT_SUCCESS)
1571 {
1572 status = BTA_JV_SUCCESS;
1573 }
1574 }
1575 *p_data_size = size;
1576 return(status);
1577 }
1578
1579 /*******************************************************************************
1580 **
1581 ** Function BTA_JvRfcommWrite
1582 **
1583 ** Description This function writes data to an RFCOMM connection
1584 **
1585 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1586 ** BTA_JV_FAILURE, otherwise.
1587 **
1588 *******************************************************************************/
BTA_JvRfcommWrite(UINT32 handle,UINT32 req_id)1589 tBTA_JV_STATUS BTA_JvRfcommWrite(UINT32 handle, UINT32 req_id)
1590 {
1591 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1592 tBTA_JV_API_RFCOMM_WRITE *p_msg;
1593 UINT32 hi = ((handle & BTA_JV_RFC_HDL_MASK)&~BTA_JV_RFCOMM_MASK) - 1;
1594 UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
1595
1596 APPL_TRACE_API( "BTA_JvRfcommWrite");
1597 APPL_TRACE_DEBUG( "handle:0x%x, hi:%d, si:%d", handle, hi, si);
1598 if (hi < BTA_JV_MAX_RFC_CONN && bta_jv_cb.rfc_cb[hi].p_cback &&
1599 si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si] &&
1600 (p_msg = (tBTA_JV_API_RFCOMM_WRITE *)GKI_getbuf(sizeof(tBTA_JV_API_RFCOMM_WRITE))) != NULL)
1601 {
1602 p_msg->hdr.event = BTA_JV_API_RFCOMM_WRITE_EVT;
1603 p_msg->handle = handle;
1604 p_msg->req_id = req_id;
1605 p_msg->p_cb = &bta_jv_cb.rfc_cb[hi];
1606 p_msg->p_pcb = &bta_jv_cb.port_cb[p_msg->p_cb->rfc_hdl[si] - 1];
1607 APPL_TRACE_API( "write ok");
1608 bta_sys_sendmsg(p_msg);
1609 status = BTA_JV_SUCCESS;
1610 }
1611
1612 return(status);
1613 }
1614
1615
1616 /*******************************************************************************
1617 **
1618 ** Function BTA_JVSetPmProfile
1619 **
1620 ** Description This function set or free power mode profile for different JV application
1621 **
1622 ** Parameters: handle, JV handle from RFCOMM or L2CAP
1623 ** app_id: app specific pm ID, can be BTA_JV_PM_ALL, see bta_dm_cfg.c for details
1624 ** BTA_JV_PM_ID_CLEAR: removes pm management on the handle. init_st is ignored and
1625 ** BTA_JV_CONN_CLOSE is called implicitely
1626 ** init_st: state after calling this API. typically it should be BTA_JV_CONN_OPEN
1627 **
1628 ** Returns BTA_JV_SUCCESS, if the request is being processed.
1629 ** BTA_JV_FAILURE, otherwise.
1630 **
1631 ** NOTE: BTA_JV_PM_ID_CLEAR: In general no need to be called as jv pm calls automatically
1632 ** BTA_JV_CONN_CLOSE to remove in case of connection close!
1633 **
1634 *******************************************************************************/
BTA_JvSetPmProfile(UINT32 handle,tBTA_JV_PM_ID app_id,tBTA_JV_CONN_STATE init_st)1635 tBTA_JV_STATUS BTA_JvSetPmProfile(UINT32 handle, tBTA_JV_PM_ID app_id, tBTA_JV_CONN_STATE init_st)
1636 {
1637 tBTA_JV_STATUS status = BTA_JV_FAILURE;
1638 tBTA_JV_API_SET_PM_PROFILE *p_msg;
1639
1640 APPL_TRACE_API("BTA_JVSetPmProfile handle:0x%x, app_id:%d", handle, app_id);
1641 if ((p_msg = (tBTA_JV_API_SET_PM_PROFILE *)GKI_getbuf(sizeof(tBTA_JV_API_SET_PM_PROFILE)))
1642 != NULL)
1643 {
1644 p_msg->hdr.event = BTA_JV_API_SET_PM_PROFILE_EVT;
1645 p_msg->handle = handle;
1646 p_msg->app_id = app_id;
1647 p_msg->init_st = init_st;
1648 bta_sys_sendmsg(p_msg);
1649 status = BTA_JV_SUCCESS;
1650 }
1651
1652 return (status);
1653 }
1654