Snapshot cdeccf6fdd8c2d494ea2867cb37a025bf8879baf
Change-Id: Ia2de32ccb97a9641462c72363b0a8c4288f4f36d
diff --git a/bta/jv/bta_jv_api.c b/bta/jv/bta_jv_api.c
new file mode 100644
index 0000000..8953886
--- /dev/null
+++ b/bta/jv/bta_jv_api.c
@@ -0,0 +1,1584 @@
+/******************************************************************************
+ *
+ * Copyright (C) 2006-2012 Broadcom Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ******************************************************************************/
+
+/******************************************************************************
+ *
+ * This is the implementation of the JAVA API for Bluetooth Wireless
+ * Technology (JABWT) as specified by the JSR82 specificiation
+ *
+ ******************************************************************************/
+
+#include "bta_api.h"
+#include "bd.h"
+#include "bta_sys.h"
+#include "bta_jv_api.h"
+#include "bta_jv_int.h"
+#include "gki.h"
+#include <string.h>
+#include "port_api.h"
+#include "sdp_api.h"
+
+/*****************************************************************************
+** Constants
+*****************************************************************************/
+
+static const tBTA_SYS_REG bta_jv_reg =
+{
+ bta_jv_sm_execute,
+ NULL
+};
+
+/*******************************************************************************
+**
+** Function BTA_JvEnable
+**
+** Description Enable the Java I/F service. When the enable
+** operation is complete the callback function will be
+** called with a BTA_JV_ENABLE_EVT. This function must
+** be called before other function in the JV API are
+** called.
+**
+** Returns BTA_JV_SUCCESS if successful.
+** BTA_JV_FAIL if internal failure.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvEnable(tBTA_JV_DM_CBACK *p_cback)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_ENABLE *p_buf;
+
+ APPL_TRACE_API0( "BTA_JvEnable");
+ if(p_cback && FALSE == bta_sys_is_register(BTA_ID_JV))
+ {
+ memset(&bta_jv_cb, 0, sizeof(tBTA_JV_CB));
+
+ /* register with BTA system manager */
+ GKI_sched_lock();
+ bta_sys_register(BTA_ID_JV, &bta_jv_reg);
+ GKI_sched_unlock();
+
+ if (p_cback && (p_buf = (tBTA_JV_API_ENABLE *) GKI_getbuf(sizeof(tBTA_JV_API_ENABLE))) != NULL)
+ {
+ p_buf->hdr.event = BTA_JV_API_ENABLE_EVT;
+ p_buf->p_cback = p_cback;
+ bta_sys_sendmsg(p_buf);
+ status = BTA_JV_SUCCESS;
+ }
+ }
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvDisable
+**
+** Description Disable the Java I/F
+**
+** Returns void
+**
+*******************************************************************************/
+void BTA_JvDisable(void)
+{
+ BT_HDR *p_buf;
+
+ APPL_TRACE_API0( "BTA_JvDisable");
+ bta_sys_deregister(BTA_ID_JV);
+ if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
+ {
+ p_buf->event = BTA_JV_API_DISABLE_EVT;
+ bta_sys_sendmsg(p_buf);
+ }
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvIsEnable
+**
+** Description Get the JV registration status.
+**
+** Returns TRUE, if registered
+**
+*******************************************************************************/
+BOOLEAN BTA_JvIsEnable(void)
+{
+ return bta_sys_is_register(BTA_ID_JV);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvSetDiscoverability
+**
+** Description This function sets the Bluetooth discoverable modes
+** of the local device. This controls whether other
+** Bluetooth devices can find the local device.
+**
+** When the operation is complete the tBTA_JV_DM_CBACK callback
+** function will be called with a BTA_JV_SET_DISCOVER_EVT.
+**
+** Returns BTA_JV_SUCCESS if successful.
+** BTA_JV_FAIL if internal failure.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvSetDiscoverability(tBTA_JV_DISC disc_mode)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_SET_DISCOVERABILITY *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvSetDiscoverability");
+ if ((p_msg = (tBTA_JV_API_SET_DISCOVERABILITY *)GKI_getbuf(sizeof(tBTA_JV_MSG))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_SET_DISCOVERABILITY_EVT;
+ p_msg->disc_mode = disc_mode;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvGetDiscoverability
+**
+** Description This function gets the Bluetooth
+** discoverable modes of local device
+**
+** Returns The current Bluetooth discoverable mode.
+**
+*******************************************************************************/
+tBTA_JV_DISC BTA_JvGetDiscoverability(void)
+{
+ APPL_TRACE_API0( "BTA_JvGetDiscoverability");
+ return BTM_ReadDiscoverability(0, 0);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvGetLocalDeviceAddr
+**
+** Description This function obtains the local Bluetooth device address.
+** The local Bluetooth device address is reported by the
+** tBTA_JV_DM_CBACK callback with a BTA_JV_LOCAL_ADDR_EVT.
+**
+** Returns BTA_JV_SUCCESS if successful.
+** BTA_JV_FAIL if internal failure.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvGetLocalDeviceAddr(void)
+{
+ tBTA_JV_STATUS ret = BTA_JV_FAILURE;
+ BT_HDR *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvGetLocalDeviceAddr");
+ if ((p_msg = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR))) != NULL)
+ {
+ p_msg->event = BTA_JV_API_GET_LOCAL_DEVICE_ADDR_EVT;
+ bta_sys_sendmsg(p_msg);
+ ret = BTA_JV_SUCCESS;
+ }
+
+ return(ret);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvGetLocalDeviceName
+**
+** Description This function obtains the name of the local device
+** The local Bluetooth device name is reported by the
+** tBTA_JV_DM_CBACK callback with a BTA_JV_LOCAL_NAME_EVT.
+**
+** Returns BTA_JV_SUCCESS if successful.
+** BTA_JV_FAIL if internal failure.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvGetLocalDeviceName(void)
+{
+ tBTA_JV_STATUS ret = BTA_JV_FAILURE;
+ BT_HDR *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvGetLocalDeviceName");
+ if ((p_msg = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR))) != NULL)
+ {
+ p_msg->event = BTA_JV_API_GET_LOCAL_DEVICE_NAME_EVT;
+ bta_sys_sendmsg(p_msg);
+ ret = BTA_JV_SUCCESS;
+ }
+
+ return(ret);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvGetRemoteDeviceName
+**
+** Description This function obtains the name of the specified device.
+** The Bluetooth device name is reported by the
+** tBTA_JV_DM_CBACK callback with a BTA_JV_REMOTE_NAME_EVT.
+**
+** Returns BTA_JV_SUCCESS if successful.
+** BTA_JV_FAIL if internal failure.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvGetRemoteDeviceName(BD_ADDR bd_addr)
+{
+ tBTA_JV_STATUS ret = BTA_JV_FAILURE;
+ tBTA_JV_API_GET_REMOTE_NAME *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvGetRemoteDeviceName");
+ if ((p_msg = (tBTA_JV_API_GET_REMOTE_NAME *)GKI_getbuf(sizeof(tBTA_JV_API_GET_REMOTE_NAME))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_GET_REMOTE_DEVICE_NAME_EVT;
+ bdcpy(p_msg->bd_addr, bd_addr);
+ bta_sys_sendmsg(p_msg);
+ ret = BTA_JV_SUCCESS;
+ }
+
+ return(ret);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvGetPreknownDevice
+**
+** Description This function obtains the Bluetooth address in the inquiry
+** database collected via the previous call to BTA_DmSearch().
+**
+** Returns The number of preknown devices if p_bd_addr is NULL
+** BTA_JV_SUCCESS if successful.
+** BTA_JV_INTERNAL_ERR(-1) if internal failure.
+**
+*******************************************************************************/
+INT32 BTA_JvGetPreknownDevice(UINT8 * p_bd_addr, UINT32 index)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTM_INQ_INFO *p_info;
+ UINT32 count = 0;
+ INT32 ret = BTA_JV_INTERNAL_ERR;
+
+ APPL_TRACE_API0( "BTA_JvGetPreknownDevice");
+ p_info = BTM_InqFirstResult();
+ if(p_info)
+ {
+ status = BTA_JV_SUCCESS;
+ /* the database is valid */
+ if(NULL == p_bd_addr)
+ {
+ /* p_bd_addr is NULL: count the number of preknown devices */
+ /* set the index to an invalid size (too big) */
+ index = BTM_INQ_DB_SIZE;
+ }
+ else if(index >= BTM_INQ_DB_SIZE)
+ {
+ /* invalid index - error */
+ status = (tBTA_JV_STATUS)BTA_JV_INTERNAL_ERR;
+ }
+
+ if(BTA_JV_SUCCESS == status)
+ {
+ while(p_info && index > count)
+ {
+ count++;
+ p_info = BTM_InqNextResult(p_info);
+ }
+
+ if(p_bd_addr)
+ {
+ if(index == count && p_info)
+ {
+ count = BTA_JV_SUCCESS;
+ bdcpy(p_bd_addr, p_info->results.remote_bd_addr);
+ }
+ else
+ status = (tBTA_JV_STATUS)BTA_JV_INTERNAL_ERR;
+ }
+ /*
+ else report the count
+ */
+ }
+ /*
+ else error had happened.
+ */
+ }
+
+ if(BTA_JV_SUCCESS == status)
+ {
+ ret = count;
+ }
+ return ret;
+}
+
+
+/*******************************************************************************
+**
+** Function BTA_JvGetDeviceClass
+**
+** Description This function obtains the local Class of Device. This
+** function executes in place. The result is returned right away.
+**
+** Returns DEV_CLASS, A three-byte array of UINT8 that contains the
+** Class of Device information. The definitions are in the
+** "Bluetooth Assigned Numbers".
+**
+*******************************************************************************/
+UINT8 * BTA_JvGetDeviceClass(void)
+{
+ APPL_TRACE_API0( "BTA_JvGetDeviceClass");
+ return BTM_ReadDeviceClass();
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvSetServiceClass
+**
+** Description This function sets the service class of local Class of Device
+**
+** Returns BTA_JV_SUCCESS if successful.
+** BTA_JV_FAIL if internal failure.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvSetServiceClass(UINT32 service)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_SET_SERVICE_CLASS *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvSetServiceClass");
+ if ((p_msg = (tBTA_JV_API_SET_SERVICE_CLASS *)GKI_getbuf(sizeof(tBTA_JV_API_SET_SERVICE_CLASS))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_SET_SERVICE_CLASS_EVT;
+ p_msg->service = service;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvSetEncryption
+**
+** Description This function ensures that the connection to the given device
+** is encrypted.
+** When the operation is complete the tBTA_JV_DM_CBACK callback
+** function will be called with a BTA_JV_SET_ENCRYPTION_EVT.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvSetEncryption(BD_ADDR bd_addr)
+{
+ tBTA_JV_STATUS ret = BTA_JV_FAILURE;
+ tBTA_JV_API_SET_ENCRYPTION *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvSetEncryption");
+ if ((p_msg = (tBTA_JV_API_SET_ENCRYPTION *)GKI_getbuf(sizeof(tBTA_JV_API_SET_ENCRYPTION))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_SET_ENCRYPTION_EVT;
+ bdcpy(p_msg->bd_addr, bd_addr);
+ bta_sys_sendmsg(p_msg);
+ ret = BTA_JV_SUCCESS;
+ }
+
+ return(ret);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvIsAuthenticated
+**
+** Description This function checks if the peer device is authenticated
+**
+** Returns TRUE if authenticated.
+** FALSE if not.
+**
+*******************************************************************************/
+BOOLEAN BTA_JvIsAuthenticated(BD_ADDR bd_addr)
+{
+ BOOLEAN is_authenticated = FALSE;
+ UINT8 sec_flags;
+
+ if(BTM_GetSecurityFlags(bd_addr, &sec_flags))
+ {
+ if(sec_flags&BTM_SEC_FLAG_AUTHENTICATED)
+ is_authenticated = TRUE;
+ }
+ return is_authenticated;
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvIsTrusted
+**
+** Description This function checks if the peer device is trusted
+** (previously paired)
+**
+** Returns TRUE if trusted.
+** FALSE if not.
+**
+*******************************************************************************/
+BOOLEAN BTA_JvIsTrusted(BD_ADDR bd_addr)
+{
+ BOOLEAN is_trusted = FALSE;
+ UINT8 sec_flags;
+
+ if(BTM_GetSecurityFlags(bd_addr, &sec_flags))
+ {
+ if ((sec_flags&BTM_SEC_FLAG_AUTHENTICATED) ||
+ (sec_flags&BTM_SEC_FLAG_LKEY_KNOWN))
+ {
+ is_trusted = TRUE;
+ }
+ }
+ return is_trusted;
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvIsAuthorized
+**
+** Description This function checks if the peer device is authorized
+**
+** Returns TRUE if authorized.
+** FALSE if not.
+**
+*******************************************************************************/
+BOOLEAN BTA_JvIsAuthorized(BD_ADDR bd_addr)
+{
+ BOOLEAN is_authorized = FALSE;
+ UINT8 sec_flags;
+
+ if(BTM_GetSecurityFlags(bd_addr, &sec_flags))
+ {
+ if(sec_flags&BTM_SEC_FLAG_AUTHORIZED)
+ is_authorized = TRUE;
+ }
+ return is_authorized;
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvIsEncrypted
+**
+** Description This function checks if the link to peer device is encrypted
+**
+** Returns TRUE if encrypted.
+** FALSE if not.
+**
+*******************************************************************************/
+BOOLEAN BTA_JvIsEncrypted(BD_ADDR bd_addr)
+{
+ BOOLEAN is_encrypted = FALSE;
+ UINT8 sec_flags;
+
+ if(BTM_GetSecurityFlags(bd_addr, &sec_flags))
+ {
+ if(sec_flags&BTM_SEC_FLAG_ENCRYPTED)
+ is_encrypted = TRUE;
+ }
+ return is_encrypted;
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvGetSecurityMode
+**
+** Description This function returns the current Bluetooth security mode
+** of the local device
+**
+** Returns The current Bluetooth security mode.
+**
+*******************************************************************************/
+tBTA_JV_SEC_MODE BTA_JvGetSecurityMode(void)
+{
+ return BTM_GetSecurityMode();
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvGetSCN
+**
+** Description This function reserves a SCN (server channel number) for
+** applications running over RFCOMM. It is primarily called by
+** server profiles/applications to register their SCN into the
+** SDP database. The SCN is reported by the tBTA_JV_DM_CBACK
+** callback with a BTA_JV_GET_SCN_EVT.
+** If the SCN reported is 0, that means all SCN resources are
+** exhausted.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvGetSCN(void)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ BT_HDR *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvGetSCN");
+ if ((p_msg = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR))) != NULL)
+ {
+ p_msg->event = BTA_JV_API_GET_SCN_EVT;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvFreeSCN
+**
+** Description This function frees a server channel number that was used
+** by an application running over RFCOMM.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvFreeSCN(UINT8 scn)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_FREE_SCN *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvFreeSCN");
+ if ((p_msg = (tBTA_JV_API_FREE_SCN *)GKI_getbuf(sizeof(tBTA_JV_API_FREE_SCN))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_FREE_SCN_EVT;
+ p_msg->scn = scn;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvGetPSM
+**
+** Description This function reserves a PSM (Protocol Service Multiplexer)
+** applications running over L2CAP. It is primarily called by
+** server profiles/applications to register their PSM into the
+** SDP database.
+**
+** Returns The next free PSM
+**
+*******************************************************************************/
+UINT16 BTA_JvGetPSM(void)
+{
+#if 0
+ APPL_TRACE_API0( "BTA_JvGetPSM");
+
+ return (L2CA_AllocatePSM());
+#endif
+ return 0;
+}
+
+
+/*******************************************************************************
+**
+** Function BTA_JvStartDiscovery
+**
+** Description This function performs service discovery for the services
+** provided by the given peer device. When the operation is
+** complete the tBTA_JV_DM_CBACK callback function will be
+** called with a BTA_JV_DISCOVERY_COMP_EVT.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvStartDiscovery(BD_ADDR bd_addr, UINT16 num_uuid,
+ tSDP_UUID *p_uuid_list, void * user_data)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_START_DISCOVERY *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvStartDiscovery");
+ if ((p_msg = (tBTA_JV_API_START_DISCOVERY *)GKI_getbuf(sizeof(tBTA_JV_API_START_DISCOVERY))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_START_DISCOVERY_EVT;
+ bdcpy(p_msg->bd_addr, bd_addr);
+ p_msg->num_uuid = num_uuid;
+ memcpy(p_msg->uuid_list, p_uuid_list, num_uuid * sizeof(tSDP_UUID));
+ p_msg->num_attr = 0;
+ p_msg->user_data = user_data;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvCancelDiscovery
+**
+** Description This function cancels an active service discovery.
+** When the operation is
+** complete the tBTA_JV_DM_CBACK callback function will be
+** called with a BTA_JV_CANCEL_DISCVRY_EVT.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvCancelDiscovery(void * user_data)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_CANCEL_DISCOVERY *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvCancelDiscovery");
+ if ((p_msg = (tBTA_JV_API_CANCEL_DISCOVERY *)GKI_getbuf(sizeof(tBTA_JV_API_CANCEL_DISCOVERY))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_CANCEL_DISCOVERY_EVT;
+ p_msg->user_data = user_data;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvGetServicesLength
+**
+** Description This function obtains the number of services and the length
+** of each service found in the SDP database (result of last
+** BTA_JvStartDiscovery().When the operation is complete the
+** tBTA_JV_DM_CBACK callback function will be called with a
+** BTA_JV_SERVICES_LEN_EVT.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvGetServicesLength(BOOLEAN inc_hdr, UINT16 *p_services_len)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_GET_SERVICES_LENGTH *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvGetServicesLength");
+ if ((p_msg = (tBTA_JV_API_GET_SERVICES_LENGTH *)GKI_getbuf(sizeof(tBTA_JV_API_GET_SERVICES_LENGTH))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_GET_SERVICES_LENGTH_EVT;
+ p_msg->p_services_len = p_services_len;
+ p_msg->inc_hdr = inc_hdr;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+/*******************************************************************************
+**
+** Function BTA_JvGetServicesResult
+**
+** Description This function returns a number of service records found
+** during current service search, equals to the number returned
+** by previous call to BTA_JvGetServicesLength.
+** The contents of each SDP record will be returned under a
+** TLV (type, len, value) representation in the data buffer
+** provided by the caller.
+**
+** Returns -1, if error. Otherwise, the number of services
+**
+*******************************************************************************/
+INT32 BTA_JvGetServicesResult(BOOLEAN inc_hdr, UINT8 **TLVs)
+{
+#if 0
+ INT32 num_services = -1;
+ UINT8 *p, *np, *op, type;
+ UINT32 raw_used, raw_cur;
+ UINT32 len;
+ UINT32 hdr_len;
+
+ APPL_TRACE_API0( "BTA_JvGetServicesResult");
+ if(p_bta_jv_cfg->p_sdp_db->p_first_rec)
+ {
+ /* the database is valid */
+ num_services = 0;
+ p = p_bta_jv_cfg->p_sdp_db->raw_data;
+ raw_used = p_bta_jv_cfg->p_sdp_db->raw_used;
+ while(raw_used && p)
+ {
+ op = p;
+ type = *p++;
+ np = sdpu_get_len_from_type(p, type, &len);
+ p = np + len;
+ raw_cur = p - op;
+ if(raw_used >= raw_cur)
+ {
+ raw_used -= raw_cur;
+ }
+ else
+ {
+ /* error. can not continue */
+ break;
+ }
+ if(inc_hdr)
+ {
+ hdr_len = np - op;
+ memcpy(TLVs[num_services++], op, len+hdr_len);
+ }
+ else
+ {
+ memcpy(TLVs[num_services++], np, len);
+ }
+ } /* end of while */
+ }
+ return(num_services);
+#endif
+ return 0;
+}
+/*******************************************************************************
+**
+** Function BTA_JvServiceSelect
+**
+** Description This function checks if the SDP database contains the given
+** service UUID. When the operation is complete the
+** tBTA_JV_DM_CBACK callback function will be called with a
+** BTA_JV_SERVICE_SEL_EVT with the length of the service record.
+** If the service is not found or error, -1 is reported.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvServiceSelect(UINT16 uuid)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_SERVICE_SELECT *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvServiceSelect");
+ if ((p_msg = (tBTA_JV_API_SERVICE_SELECT *)GKI_getbuf(sizeof(tBTA_JV_API_SERVICE_SELECT))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_SERVICE_SELECT_EVT;
+ p_msg->uuid = uuid;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvServiceResult
+**
+** Description This function returns the contents of the SDP record from
+** last BTA_JvServiceSelect. The contents will be returned under
+** a TLV (type, len, value) representation in the data buffer
+** provided by the caller.
+**
+** Returns -1, if error. Otherwise, the length of service record.
+**
+*******************************************************************************/
+INT32 BTA_JvServiceResult(UINT8 *TLV)
+{
+ INT32 serv_sel = -1;
+
+ APPL_TRACE_API0( "BTA_JvServiceResult");
+ if(bta_jv_cb.p_sel_raw_data)
+ {
+ serv_sel = bta_jv_cb.sel_len;
+ memcpy(TLV, bta_jv_cb.p_sel_raw_data, serv_sel);
+ }
+
+ return serv_sel;
+}
+
+
+/*******************************************************************************
+**
+** Function BTA_JvCreateRecord
+**
+** Description Create a service record in the local SDP database.
+** When the operation is complete the tBTA_JV_DM_CBACK callback
+** function will be called with a BTA_JV_CREATE_RECORD_EVT.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvCreateRecordByUser(void *user_data)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_CREATE_RECORD *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvCreateRecordByUser");
+ if ((p_msg = (tBTA_JV_API_CREATE_RECORD *)GKI_getbuf(sizeof(tBTA_JV_API_CREATE_RECORD))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_CREATE_RECORD_EVT;
+ p_msg->user_data = user_data;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvUpdateRecord
+**
+** Description Update a service record in the local SDP database.
+** When the operation is complete the tBTA_JV_DM_CBACK callback
+** function will be called with a BTA_JV_UPDATE_RECORD_EVT.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvUpdateRecord(UINT32 handle, UINT16 *p_ids,
+ UINT8 **p_values, INT32 *p_value_sizes, INT32 array_len)
+{
+#if 0
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_UPDATE_RECORD *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvUpdateRecord");
+ if ((p_msg = (tBTA_JV_API_UPDATE_RECORD *)GKI_getbuf(sizeof(tBTA_JV_API_UPDATE_RECORD))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_UPDATE_RECORD_EVT;
+ p_msg->handle = handle;
+ p_msg->p_ids = p_ids;
+ p_msg->p_values = p_values;
+ p_msg->p_value_sizes = p_value_sizes;
+ p_msg->array_len = array_len;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+ return(status);
+#endif
+ return -1;
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvAddAttribute
+**
+** Description Add an attribute to a service record in the local SDP database.
+** When the operation is complete the tBTA_JV_DM_CBACK callback
+** function will be called with a BTA_JV_ADD_ATTR_EVT.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvAddAttribute(UINT32 handle, UINT16 attr_id,
+ UINT8 *p_value, INT32 value_size)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_ADD_ATTRIBUTE *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvAddAttribute");
+ if ((p_msg = (tBTA_JV_API_ADD_ATTRIBUTE *)GKI_getbuf(sizeof(tBTA_JV_API_ADD_ATTRIBUTE))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_ADD_ATTRIBUTE_EVT;
+ p_msg->handle = handle;
+ p_msg->attr_id = attr_id;
+ p_msg->p_value = p_value;
+ p_msg->value_size = value_size;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvDeleteAttribute
+**
+** Description Delete an attribute from a service record in the local SDP database.
+** When the operation is complete the tBTA_JV_DM_CBACK callback
+** function will be called with a BTA_JV_DELETE_ATTR_EVT.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvDeleteAttribute(UINT32 handle, UINT16 attr_id)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_ADD_ATTRIBUTE *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvDeleteAttribute");
+ if ((p_msg = (tBTA_JV_API_ADD_ATTRIBUTE *)GKI_getbuf(sizeof(tBTA_JV_API_ADD_ATTRIBUTE))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_DELETE_ATTRIBUTE_EVT;
+ p_msg->handle = handle;
+ p_msg->attr_id = attr_id;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvDeleteRecord
+**
+** Description Delete a service record in the local SDP database.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvDeleteRecord(UINT32 handle)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_ADD_ATTRIBUTE *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvDeleteRecord");
+ if ((p_msg = (tBTA_JV_API_ADD_ATTRIBUTE *)GKI_getbuf(sizeof(tBTA_JV_API_ADD_ATTRIBUTE))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_DELETE_RECORD_EVT;
+ p_msg->handle = handle;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvReadRecord
+**
+** Description Read a service record in the local SDP database.
+**
+** Returns -1, if the record is not found.
+** Otherwise, the offset (0 or 1) to start of data in p_data.
+**
+** The size of data copied into p_data is in *p_data_len.
+**
+*******************************************************************************/
+INT32 BTA_JvReadRecord(UINT32 handle, UINT8 *p_data, INT32 *p_data_len)
+{
+ UINT32 sdp_handle;
+
+ sdp_handle = bta_jv_get_sdp_handle(handle);
+
+ if(sdp_handle)
+ {
+ return SDP_ReadRecord(sdp_handle, p_data, p_data_len);
+ }
+
+ return -1;
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvL2capConnect
+**
+** Description Initiate a connection as a L2CAP client to the given BD
+** Address.
+** When the connection is initiated or failed to initiate,
+** tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_CL_INIT_EVT
+** When the connection is established or failed,
+** tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_OPEN_EVT
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS 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)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_L2CAP_CONNECT *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvL2capConnect");
+ if (p_cback &&
+ (p_msg = (tBTA_JV_API_L2CAP_CONNECT *)GKI_getbuf(sizeof(tBTA_JV_API_L2CAP_CONNECT))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_L2CAP_CONNECT_EVT;
+ p_msg->sec_mask = sec_mask;
+ p_msg->role = role;
+ p_msg->remote_psm = remote_psm;
+ p_msg->rx_mtu = rx_mtu;
+ memcpy(p_msg->peer_bd_addr, peer_bd_addr, sizeof(BD_ADDR));
+ p_msg->p_cback = p_cback;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvL2capClose
+**
+** Description This function closes an L2CAP client connection
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvL2capClose(UINT32 handle)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_L2CAP_CLOSE *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvL2capClose");
+ if (handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback &&
+ (p_msg = (tBTA_JV_API_L2CAP_CLOSE *)GKI_getbuf(sizeof(tBTA_JV_API_L2CAP_CLOSE))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_L2CAP_CLOSE_EVT;
+ p_msg->handle = handle;
+ p_msg->p_cb = &bta_jv_cb.l2c_cb[handle];
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvL2capStartServer
+**
+** Description This function starts an L2CAP server and listens for an L2CAP
+** connection from a remote Bluetooth device. When the server
+** is started successfully, tBTA_JV_L2CAP_CBACK is called with
+** BTA_JV_L2CAP_START_EVT. When the connection is established,
+** tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_OPEN_EVT.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvL2capStartServer(tBTA_SEC sec_mask, tBTA_JV_ROLE role,
+ UINT16 local_psm, UINT16 rx_mtu,
+ tBTA_JV_L2CAP_CBACK *p_cback)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_L2CAP_SERVER *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvL2capStartServer");
+ if (p_cback &&
+ (p_msg = (tBTA_JV_API_L2CAP_SERVER *)GKI_getbuf(sizeof(tBTA_JV_API_L2CAP_SERVER))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_L2CAP_START_SERVER_EVT;
+ p_msg->sec_mask = sec_mask;
+ p_msg->role = role;
+ p_msg->local_psm = local_psm;
+ p_msg->rx_mtu = rx_mtu;
+ p_msg->p_cback = p_cback;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvL2capStopServer
+**
+** Description This function stops the L2CAP server. If the server has an
+** active connection, it would be closed.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvL2capStopServer(UINT16 local_psm)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_L2CAP_SERVER *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvL2capStopServer");
+ if ((p_msg = (tBTA_JV_API_L2CAP_SERVER *)GKI_getbuf(sizeof(tBTA_JV_API_L2CAP_SERVER))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_L2CAP_STOP_SERVER_EVT;
+ p_msg->local_psm = local_psm;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvL2capRead
+**
+** Description This function reads data from an L2CAP connecti;
+ tBTA_JV_RFC_CB *p_cb = rc->p_cb;
+on
+** When the operation is complete, tBTA_JV_L2CAP_CBACK is
+** called with BTA_JV_L2CAP_READ_EVT.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvL2capRead(UINT32 handle, UINT32 req_id, UINT8 *p_data, UINT16 len)
+{
+#if 0
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+#if SDP_FOR_JV_INCLUDED == TRUE
+ tBTA_JV_API_L2CAP_READ *p_msg;
+#endif
+ tBTA_JV_L2CAP_READ evt_data;
+
+ APPL_TRACE_API0( "BTA_JvL2capRead");
+
+#if SDP_FOR_JV_INCLUDED == TRUE
+ if(BTA_JV_L2C_FOR_SDP_HDL == handle)
+ {
+ if (bta_jv_cb.l2c_cb[handle].p_cback &&
+ (p_msg = (tBTA_JV_API_L2CAP_READ *)GKI_getbuf(sizeof(tBTA_JV_API_L2CAP_READ))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_L2CAP_READ_EVT;
+ p_msg->handle = handle;
+ p_msg->req_id = req_id;
+ p_msg->p_data = p_data;
+ p_msg->len = len;
+ p_msg->p_cback = bta_jv_cb.l2c_cb[handle].p_cback;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+ }
+ else
+#endif
+ if (handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback)
+ {
+ status = BTA_JV_SUCCESS;
+ evt_data.status = BTA_JV_FAILURE;
+ evt_data.handle = handle;
+ evt_data.req_id = req_id;
+ evt_data.p_data = p_data;
+ evt_data.len = 0;
+
+ if (BT_PASS == GAP_ConnReadData((UINT16)handle, p_data, len, &evt_data.len))
+ {
+ evt_data.status = BTA_JV_SUCCESS;
+ }
+ bta_jv_cb.l2c_cb[handle].p_cback(BTA_JV_L2CAP_READ_EVT, (tBTA_JV *)&evt_data);
+ }
+
+ return(status);
+#endif
+ return -1;
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvL2capReceive
+**
+** Description This function reads data from an L2CAP connection
+** When the operation is complete, tBTA_JV_L2CAP_CBACK is
+** called with BTA_JV_L2CAP_RECEIVE_EVT.
+** If there are more data queued in L2CAP than len, the extra data will be discarded.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvL2capReceive(UINT32 handle, UINT32 req_id, UINT8 *p_data, UINT16 len)
+{
+#if 0
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_L2CAP_RECEIVE evt_data;
+ UINT32 left_over = 0;
+ UINT16 max_len, read_len;
+
+ APPL_TRACE_API0( "BTA_JvL2capReceive");
+
+ if (handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback)
+ {
+ status = BTA_JV_SUCCESS;
+ evt_data.status = BTA_JV_FAILURE;
+ evt_data.handle = handle;
+ evt_data.req_id = req_id;
+ evt_data.p_data = p_data;
+ evt_data.len = 0;
+
+ if (BT_PASS == GAP_ConnReadData((UINT16)handle, p_data, len, &evt_data.len))
+ {
+ evt_data.status = BTA_JV_SUCCESS;
+ GAP_GetRxQueueCnt ((UINT16)handle, &left_over);
+ while (left_over)
+ {
+ max_len = (left_over > 0xFFFF)?0xFFFF:left_over;
+ GAP_ConnReadData ((UINT16)handle, NULL, max_len, &read_len);
+ left_over -= read_len;
+ }
+ }
+ bta_jv_cb.l2c_cb[handle].p_cback(BTA_JV_L2CAP_RECEIVE_EVT, (tBTA_JV *)&evt_data);
+ }
+
+ return(status);
+#endif
+ return -1;
+}
+/*******************************************************************************
+**
+** Function BTA_JvL2capReady
+**
+** Description This function determined if there is data to read from
+** an L2CAP connection
+**
+** Returns BTA_JV_SUCCESS, if data queue size is in *p_data_size.
+** BTA_JV_FAILURE, if error.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvL2capReady(UINT32 handle, UINT32 *p_data_size)
+{
+#if 0
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+
+ APPL_TRACE_API1( "BTA_JvL2capReady: %d", handle);
+ if (p_data_size && handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback)
+ {
+ *p_data_size = 0;
+#if SDP_FOR_JV_INCLUDED == TRUE
+ if(BTA_JV_L2C_FOR_SDP_HDL == handle)
+ {
+ *p_data_size = bta_jv_cb.sdp_data_size;
+ status = BTA_JV_SUCCESS;
+ }
+ else
+#endif
+ if(BT_PASS == GAP_GetRxQueueCnt((UINT16)handle, p_data_size) )
+ {
+ status = BTA_JV_SUCCESS;
+ }
+ }
+
+ return(status);
+#endif
+ return -1;
+}
+
+
+/*******************************************************************************
+**
+** Function BTA_JvL2capWrite
+**
+** Description This function writes data to an L2CAP connection
+** When the operation is complete, tBTA_JV_L2CAP_CBACK is
+** called with BTA_JV_L2CAP_WRITE_EVT.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvL2capWrite(UINT32 handle, UINT32 req_id, UINT8 *p_data, UINT16 len)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_L2CAP_WRITE *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvL2capWrite");
+ if (handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback &&
+ (p_msg = (tBTA_JV_API_L2CAP_WRITE *)GKI_getbuf(sizeof(tBTA_JV_API_L2CAP_WRITE))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_L2CAP_WRITE_EVT;
+ p_msg->handle = handle;
+ p_msg->req_id = req_id;
+ p_msg->p_data = p_data;
+ p_msg->p_cb = &bta_jv_cb.l2c_cb[handle];
+ p_msg->len = len;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvRfcommConnect
+**
+** Description This function makes an RFCOMM conection to a remote BD
+** Address.
+** When the connection is initiated or failed to initiate,
+** tBTA_JV_RFCOMM_CBACK is called with BTA_JV_RFCOMM_CL_INIT_EVT
+** When the connection is established or failed,
+** tBTA_JV_RFCOMM_CBACK is called with BTA_JV_RFCOMM_OPEN_EVT
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS 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)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_RFCOMM_CONNECT *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvRfcommConnect");
+ if (p_cback &&
+ (p_msg = (tBTA_JV_API_RFCOMM_CONNECT *)GKI_getbuf(sizeof(tBTA_JV_API_RFCOMM_CONNECT))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_RFCOMM_CONNECT_EVT;
+ p_msg->sec_mask = sec_mask;
+ p_msg->role = role;
+ p_msg->remote_scn = remote_scn;
+ memcpy(p_msg->peer_bd_addr, peer_bd_addr, sizeof(BD_ADDR));
+ p_msg->p_cback = p_cback;
+ p_msg->user_data = user_data;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvRfcommClose
+**
+** Description This function closes an RFCOMM connection
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvRfcommClose(UINT32 handle)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_RFCOMM_CLOSE *p_msg;
+ UINT32 hi = (handle & BTA_JV_RFC_HDL_MASK) - 1;
+ UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
+
+ APPL_TRACE_API0( "BTA_JvRfcommClose");
+ if (hi < BTA_JV_MAX_RFC_CONN && bta_jv_cb.rfc_cb[hi].p_cback &&
+ si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si] &&
+ (p_msg = (tBTA_JV_API_RFCOMM_CLOSE *)GKI_getbuf(sizeof(tBTA_JV_API_RFCOMM_CLOSE))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_RFCOMM_CLOSE_EVT;
+ p_msg->handle = handle;
+ p_msg->p_cb = &bta_jv_cb.rfc_cb[hi];
+ p_msg->p_pcb = &bta_jv_cb.port_cb[p_msg->p_cb->rfc_hdl[si] - 1];
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvRfcommStartServer
+**
+** Description This function starts listening for an RFCOMM connection
+** request from a remote Bluetooth device. When the server is
+** started successfully, tBTA_JV_RFCOMM_CBACK is called
+** with BTA_JV_RFCOMM_START_EVT.
+** When the connection is established, tBTA_JV_RFCOMM_CBACK
+** is called with BTA_JV_RFCOMM_OPEN_EVT.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS 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)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_RFCOMM_SERVER *p_msg;
+
+ APPL_TRACE_API0( "BTA_JvRfcommStartServer");
+ if (p_cback &&
+ (p_msg = (tBTA_JV_API_RFCOMM_SERVER *)GKI_getbuf(sizeof(tBTA_JV_API_RFCOMM_SERVER))) != NULL)
+ {
+ if (max_session == 0)
+ max_session = 1;
+ if (max_session > BTA_JV_MAX_RFC_SR_SESSION)
+ {
+ APPL_TRACE_DEBUG2( "max_session is too big. use max (%d)", max_session, BTA_JV_MAX_RFC_SR_SESSION);
+ max_session = BTA_JV_MAX_RFC_SR_SESSION;
+ }
+ p_msg->hdr.event = BTA_JV_API_RFCOMM_START_SERVER_EVT;
+ p_msg->sec_mask = sec_mask;
+ p_msg->role = role;
+ p_msg->local_scn = local_scn;
+ p_msg->max_session = max_session;
+ p_msg->p_cback = p_cback;
+ p_msg->user_data = user_data; //caller's private data
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvRfcommStopServer
+**
+** Description This function stops the RFCOMM server. If the server has an
+** active connection, it would be closed.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvRfcommStopServer(UINT32 handle)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_RFCOMM_SERVER *p_msg;
+ APPL_TRACE_API0( "BTA_JvRfcommStopServer");
+ if ((p_msg = (tBTA_JV_API_RFCOMM_SERVER *)GKI_getbuf(sizeof(tBTA_JV_API_RFCOMM_SERVER))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_RFCOMM_STOP_SERVER_EVT;
+ p_msg->rfc_handle = handle;
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvRfcommRead
+**
+** Description This function reads data from an RFCOMM connection
+** The actual size of data read is returned in p_len.
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvRfcommRead(UINT32 handle, UINT32 req_id, UINT8 *p_data, UINT16 len)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_RFCOMM_READ *p_msg;
+ UINT32 hi = (handle & BTA_JV_RFC_HDL_MASK) - 1;
+ UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
+
+ APPL_TRACE_API0( "BTA_JvRfcommRead");
+ if (hi < BTA_JV_MAX_RFC_CONN && bta_jv_cb.rfc_cb[hi].p_cback &&
+ si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si] &&
+ (p_msg = (tBTA_JV_API_RFCOMM_READ *)GKI_getbuf(sizeof(tBTA_JV_API_RFCOMM_READ))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_RFCOMM_READ_EVT;
+ p_msg->handle = handle;
+ p_msg->req_id = req_id;
+ p_msg->p_data = p_data;
+ p_msg->len = len;
+ p_msg->p_cb = &bta_jv_cb.rfc_cb[hi];
+ p_msg->p_pcb = &bta_jv_cb.port_cb[p_msg->p_cb->rfc_hdl[si] - 1];
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvRfcommGetPortHdl
+**
+** Description This function fetches the rfcomm port handle
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+UINT16 BTA_JvRfcommGetPortHdl(UINT32 handle)
+{
+ UINT32 hi = (handle & BTA_JV_RFC_HDL_MASK) - 1;
+ UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
+
+ if (hi < BTA_JV_MAX_RFC_CONN &&
+ si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si])
+ return bta_jv_cb.port_cb[bta_jv_cb.rfc_cb[hi].rfc_hdl[si] - 1].port_handle;
+ else
+ return 0xffff;
+}
+
+
+/*******************************************************************************
+**
+** Function BTA_JvRfcommReady
+**
+** Description This function determined if there is data to read from
+** an RFCOMM connection
+**
+** Returns BTA_JV_SUCCESS, if data queue size is in *p_data_size.
+** BTA_JV_FAILURE, if error.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvRfcommReady(UINT32 handle, UINT32 *p_data_size)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ UINT16 size = 0;
+ UINT32 hi = (handle & BTA_JV_RFC_HDL_MASK) - 1;
+ UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
+
+ APPL_TRACE_API0( "BTA_JvRfcommReady");
+ if (hi < BTA_JV_MAX_RFC_CONN && bta_jv_cb.rfc_cb[hi].p_cback &&
+ si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si])
+ {
+ if(PORT_GetRxQueueCnt(bta_jv_cb.rfc_cb[hi].rfc_hdl[si], &size) == PORT_SUCCESS)
+ {
+ status = BTA_JV_SUCCESS;
+ }
+ }
+ *p_data_size = size;
+ return(status);
+}
+
+/*******************************************************************************
+**
+** Function BTA_JvRfcommWrite
+**
+** Description This function writes data to an RFCOMM connection
+**
+** Returns BTA_JV_SUCCESS, if the request is being processed.
+** BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+tBTA_JV_STATUS BTA_JvRfcommWrite(UINT32 handle, UINT32 req_id)
+{
+ tBTA_JV_STATUS status = BTA_JV_FAILURE;
+ tBTA_JV_API_RFCOMM_WRITE *p_msg;
+ UINT32 hi = (handle & BTA_JV_RFC_HDL_MASK) - 1;
+ UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
+
+ APPL_TRACE_API0( "BTA_JvRfcommWrite");
+ APPL_TRACE_DEBUG3( "handle:0x%x, hi:%d, si:%d", handle, hi, si);
+ if (hi < BTA_JV_MAX_RFC_CONN && bta_jv_cb.rfc_cb[hi].p_cback &&
+ si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si] &&
+ (p_msg = (tBTA_JV_API_RFCOMM_WRITE *)GKI_getbuf(sizeof(tBTA_JV_API_RFCOMM_WRITE))) != NULL)
+ {
+ p_msg->hdr.event = BTA_JV_API_RFCOMM_WRITE_EVT;
+ p_msg->handle = handle;
+ p_msg->req_id = req_id;
+ p_msg->p_cb = &bta_jv_cb.rfc_cb[hi];
+ p_msg->p_pcb = &bta_jv_cb.port_cb[p_msg->p_cb->rfc_hdl[si] - 1];
+ APPL_TRACE_API0( "write ok");
+ bta_sys_sendmsg(p_msg);
+ status = BTA_JV_SUCCESS;
+ }
+
+ return(status);
+}
+