Check in for - new rfc multi accept code

Change-Id: I66794a8821481c58e045bb8acd8b7b758900d3e9

8 files changed, 5650 insertions, 4 deletions

diff --git a/bta/Android.mk b/bta/Android.mk
index 0076c3f..79d8677 100644
--- a/bta/Android.mk
+++ b/bta/Android.mk
@@ -8,9 +8,9 @@ include $(CLEAR_VARS)
 
 ifeq ($(BOARD_HAVE_BLUETOOTH_BCM),true)
 LOCAL_CFLAGS += \
-	-DBOARD_HAVE_BLUETOOTH_BCM 
+	-DBOARD_HAVE_BLUETOOTH_BCM
 endif
-LOCAL_CFLAGS += -DBUILDCFG 
+LOCAL_CFLAGS += -DBUILDCFG
 
 LOCAL_PRELINK_MODULE:=false
 LOCAL_SRC_FILES:= \
@@ -120,9 +120,13 @@ LOCAL_SRC_FILES:= \
     ./sys/bta_sys_cfg.c \
     ./sys/ptim.c \
     ./sys/bd.c \
-    ./sys/utl.c
+    ./sys/utl.c \
+    ./jv/bta_jv_act.c \
+    ./jv/bta_jv_cfg.c \
+    ./jv/bta_jv_main.c \
+    ./jv/bta_jv_api.c
 
-LOCAL_MODULE := libbt-brcm_bta 
+LOCAL_MODULE := libbt-brcm_bta
 LOCAL_MODULE_TAGS := optional
 LOCAL_SHARED_LIBRARIES := libcutils libc
 
diff --git a/bta/include/bta_jv_api.h b/bta/include/bta_jv_api.h
new file mode 100755
index 0000000..303ef2d
--- /dev/null
+++ b/bta/include/bta_jv_api.h
@@ -0,0 +1,1109 @@
+/*****************************************************************************
+**
+**  Name:           bta_jv_api.h
+**
+**  Description:    This is the public interface file the BTA Java I/F
+**
+**  Copyright (c) 2006-2009, Broadcom Corp., All Rights Reserved.
+**  Widcomm Bluetooth Core. Proprietary and confidential.
+**
+*****************************************************************************/
+#ifndef BTA_JV_API_H
+#define BTA_JV_API_H
+
+#include "data_types.h"
+#include "bt_target.h"
+#include "bt_types.h"
+#include "bta_api.h"
+#include "btm_api.h"
+/*****************************************************************************
+**  Constants and data types
+*****************************************************************************/
+/* status values */
+#define BTA_JV_SUCCESS             0            /* Successful operation. */
+#define BTA_JV_FAILURE             1            /* Generic failure. */
+#define BTA_JV_BUSY                2            /* Temporarily can not handle this request. */
+#define BTA_JV_NO_DATA             3            /* no data. */
+
+typedef UINT8 tBTA_JV_STATUS;
+#define BTA_JV_INTERNAL_ERR        (-1) /* internal error. */
+
+#define BTA_JV_MAX_UUIDS        SDP_MAX_UUID_FILTERS
+#define BTA_JV_MAX_ATTRS        SDP_MAX_ATTR_FILTERS
+#define BTA_JV_MAX_SDP_REC      SDP_MAX_RECORDS
+#if SDP_FOR_JV_INCLUDED == TRUE
+#define BTA_JV_MAX_L2C_CONN     (GAP_MAX_CONNECTIONS + 1)
+#else
+#define BTA_JV_MAX_L2C_CONN     GAP_MAX_CONNECTIONS
+#endif
+#define BTA_JV_MAX_SCN          PORT_MAX_RFC_PORTS /* same as BTM_MAX_SCN (in btm_int.h) */
+#define BTA_JV_MAX_RFC_CONN     MAX_RFC_PORTS
+
+#ifndef BTA_JV_DEF_RFC_MTU
+#define BTA_JV_DEF_RFC_MTU      (3*330)
+#endif
+
+/* */
+#ifndef BTA_JV_MAX_RFC_SR_SESSION
+#define BTA_JV_MAX_RFC_SR_SESSION   3
+#endif
+
+/* BTA_JV_MAX_RFC_SR_SESSION can not be bigger than MAX_BD_CONNECTIONS */
+#if (BTA_JV_MAX_RFC_SR_SESSION > MAX_BD_CONNECTIONS)
+#undef BTA_JV_MAX_RFC_SR_SESSION
+#define BTA_JV_MAX_RFC_SR_SESSION   MAX_BD_CONNECTIONS
+#endif
+
+#define BTA_JV_FIRST_SERVICE_ID BTA_FIRST_JV_SERVICE_ID
+#define BTA_JV_LAST_SERVICE_ID  BTA_LAST_JV_SERVICE_ID
+#define BTA_JV_NUM_SERVICE_ID   (BTA_LAST_JV_SERVICE_ID - BTA_FIRST_JV_SERVICE_ID + 1)
+
+/* Discoverable modes */
+enum
+{
+    BTA_JV_DISC_NONE,
+    BTA_JV_DISC_LIMITED,
+    BTA_JV_DISC_GENERAL
+};
+typedef UINT16 tBTA_JV_DISC;
+
+/* Security Mode (BTA_JvGetSecurityMode) */
+#define BTA_JV_SEC_MODE_UNDEFINED   BTM_SEC_MODE_UNDEFINED  /* 0 */
+#define BTA_JV_SEC_MODE_NONE        BTM_SEC_MODE_NONE       /* 1 */
+#define BTA_JV_SEC_MODE_SERVICE     BTM_SEC_MODE_SERVICE    /* 2 */
+#define BTA_JV_SEC_MODE_LINK        BTM_SEC_MODE_LINK       /* 3 */
+#define BTA_JV_SEC_MODE_SP          BTM_SEC_MODE_SP         /* 4 */
+#define BTA_JV_SEC_MODE_SP_DEBUG    BTM_SEC_MODE_SP_DEBUG   /* 5 */
+typedef UINT8 tBTA_JV_SEC_MODE;
+
+#define BTA_JV_ROLE_SLAVE       BTM_ROLE_SLAVE
+#define BTA_JV_ROLE_MASTER      BTM_ROLE_MASTER
+typedef UINT32 tBTA_JV_ROLE;
+
+#define BTA_JV_SERVICE_LMTD_DISCOVER    BTM_COD_SERVICE_LMTD_DISCOVER   /* 0x0020 */
+#define BTA_JV_SERVICE_POSITIONING      BTM_COD_SERVICE_POSITIONING     /* 0x0100 */
+#define BTA_JV_SERVICE_NETWORKING       BTM_COD_SERVICE_NETWORKING      /* 0x0200 */
+#define BTA_JV_SERVICE_RENDERING        BTM_COD_SERVICE_RENDERING       /* 0x0400 */
+#define BTA_JV_SERVICE_CAPTURING        BTM_COD_SERVICE_CAPTURING       /* 0x0800 */
+#define BTA_JV_SERVICE_OBJ_TRANSFER     BTM_COD_SERVICE_OBJ_TRANSFER    /* 0x1000 */
+#define BTA_JV_SERVICE_AUDIO            BTM_COD_SERVICE_AUDIO           /* 0x2000 */
+#define BTA_JV_SERVICE_TELEPHONY        BTM_COD_SERVICE_TELEPHONY       /* 0x4000 */
+#define BTA_JV_SERVICE_INFORMATION      BTM_COD_SERVICE_INFORMATION     /* 0x8000 */
+
+
+
+/* Java I/F callback events */
+/* events received by tBTA_JV_DM_CBACK */
+#define BTA_JV_ENABLE_EVT           0  /* JV enabled */
+#define BTA_JV_SET_DISCOVER_EVT     1  /* the result for BTA_JvSetDiscoverability */
+#define BTA_JV_LOCAL_ADDR_EVT       2  /* Local device address */
+#define BTA_JV_LOCAL_NAME_EVT       3  /* Local device name */
+#define BTA_JV_REMOTE_NAME_EVT      4  /* Remote device name */
+#define BTA_JV_SET_ENCRYPTION_EVT   5  /* Set Encryption */
+#define BTA_JV_GET_SCN_EVT          6  /* Reserved an SCN */
+#define BTA_JV_GET_PSM_EVT          7  /* Reserved a PSM */
+#define BTA_JV_DISCOVERY_COMP_EVT   8  /* SDP discovery complete */
+#define BTA_JV_SERVICES_LEN_EVT     9  /* the result for BTA_JvGetServicesLength */
+#define BTA_JV_SERVICE_SEL_EVT      10 /* the result for BTA_JvServiceSelect */
+#define BTA_JV_CREATE_RECORD_EVT    11 /* the result for BTA_JvCreateRecord */
+#define BTA_JV_UPDATE_RECORD_EVT    12 /* the result for BTA_JvUpdateRecord */
+#define BTA_JV_ADD_ATTR_EVT         13 /* the result for BTA_JvAddAttribute */
+#define BTA_JV_DELETE_ATTR_EVT      14 /* the result for BTA_JvDeleteAttribute */
+#define BTA_JV_CANCEL_DISCVRY_EVT   15 /* the result for BTA_JvCancelDiscovery */
+
+/* events received by tBTA_JV_L2CAP_CBACK */
+#define BTA_JV_L2CAP_OPEN_EVT       16 /* open status of L2CAP connection */
+#define BTA_JV_L2CAP_CLOSE_EVT      17 /* L2CAP connection closed */
+#define BTA_JV_L2CAP_START_EVT      18 /* L2CAP server started */
+#define BTA_JV_L2CAP_CL_INIT_EVT    19 /* L2CAP client initiated a connection */
+#define BTA_JV_L2CAP_DATA_IND_EVT   20 /* L2CAP connection received data */
+#define BTA_JV_L2CAP_CONG_EVT       21 /* L2CAP connection congestion status changed */
+#define BTA_JV_L2CAP_READ_EVT       22 /* the result for BTA_JvL2capRead */
+#define BTA_JV_L2CAP_RECEIVE_EVT    23 /* the result for BTA_JvL2capReceive*/
+#define BTA_JV_L2CAP_WRITE_EVT      24 /* the result for BTA_JvL2capWrite*/
+
+/* events received by tBTA_JV_RFCOMM_CBACK */
+#define BTA_JV_RFCOMM_OPEN_EVT      25 /* open status of RFCOMM Client connection */
+#define BTA_JV_RFCOMM_CLOSE_EVT     26 /* RFCOMM connection closed */
+#define BTA_JV_RFCOMM_START_EVT     27 /* RFCOMM server started */
+#define BTA_JV_RFCOMM_CL_INIT_EVT   28 /* RFCOMM client initiated a connection */
+#define BTA_JV_RFCOMM_DATA_IND_EVT  29 /* RFCOMM connection received data */
+#define BTA_JV_RFCOMM_CONG_EVT      30 /* RFCOMM connection congestion status changed */
+#define BTA_JV_RFCOMM_READ_EVT      31 /* the result for BTA_JvRfcommRead */
+#define BTA_JV_RFCOMM_WRITE_EVT     32 /* the result for BTA_JvRfcommWrite*/
+#define BTA_JV_RFCOMM_SRV_OPEN_EVT  33 /* open status of Server RFCOMM connection */
+#define BTA_JV_MAX_EVT              34 /* max number of JV events */
+
+typedef UINT16 tBTA_JV_EVT;
+
+/* data associated with BTA_JV_SET_DISCOVER_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    tBTA_JV_DISC    disc_mode;  /* The current discoverable mode */
+} tBTA_JV_SET_DISCOVER;
+
+/* data associated with BTA_JV_DISCOVERY_COMP_EVT_ */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    int scn;                    /* channel # */
+} tBTA_JV_DISCOVERY_COMP;
+
+/* data associated with BTA_JV_SET_ENCRYPTION_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    BD_ADDR     bd_addr;        /* The peer address */
+} tBTA_JV_SET_ENCRYPTION;
+
+/* data associated with BTA_JV_SERVICES_LEN_EVT */
+typedef struct
+{
+    INT32       num_services;       /* -1, if error. Otherwise, the number of
+                                     * services collected from peer */
+    UINT16      *p_services_len;    /* this points the same location as the
+                                     * parameter in BTA_JvGetServicesLength() */
+} tBTA_JV_SERVICES_LEN;
+
+/* data associated with BTA_JV_SERVICE_SEL_EVT */
+typedef struct
+{
+    BD_ADDR     bd_addr;            /* The peer address */
+    UINT16      service_len;        /* the length of this record */
+} tBTA_JV_SERVICE_SEL;
+
+/* data associated with BTA_JV_CREATE_RECORD_EVT */
+typedef struct
+{
+   tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+} tBTA_JV_CREATE_RECORD;
+
+/* data associated with BTA_JV_UPDATE_RECORD_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The SDP record handle was updated */
+} tBTA_JV_UPDATE_RECORD;
+
+/* data associated with BTA_JV_ADD_ATTR_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The SDP record handle was updated */
+} tBTA_JV_ADD_ATTR;
+
+/* data associated with BTA_JV_DELETE_ATTR_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The SDP record handle was updated */
+} tBTA_JV_DELETE_ATTR;
+
+/* data associated with BTA_JV_L2CAP_OPEN_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The connection handle */
+    BD_ADDR         rem_bda;    /* The peer address */
+    INT32           tx_mtu;     /* The transmit MTU */
+} tBTA_JV_L2CAP_OPEN;
+
+/* data associated with BTA_JV_L2CAP_CLOSE_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The connection handle */
+    BOOLEAN         async;      /* FALSE, if local initiates disconnect */
+} tBTA_JV_L2CAP_CLOSE;
+
+/* data associated with BTA_JV_L2CAP_START_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The connection handle */
+    UINT8           sec_id;     /* security ID used by this server */
+} tBTA_JV_L2CAP_START;
+
+/* data associated with BTA_JV_L2CAP_CL_INIT_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The connection handle */
+    UINT8           sec_id;     /* security ID used by this client */
+} tBTA_JV_L2CAP_CL_INIT;
+
+/* data associated with BTA_JV_L2CAP_CONG_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The connection handle */
+    BOOLEAN         cong;       /* TRUE, congested. FALSE, uncongested */
+} tBTA_JV_L2CAP_CONG;
+
+/* data associated with BTA_JV_L2CAP_READ_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The connection handle */
+    UINT32          req_id;     /* The req_id in the associated BTA_JvL2capRead() */
+    UINT8           *p_data;    /* This points the same location as the p_data
+                                 * parameter in BTA_JvL2capRead () */
+    UINT16          len;        /* The length of the data read. */
+} tBTA_JV_L2CAP_READ;
+
+/* data associated with BTA_JV_L2CAP_RECEIVE_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The connection handle */
+    UINT32          req_id;     /* The req_id in the associated BTA_JvL2capReceive() */
+    UINT8           *p_data;    /* This points the same location as the p_data
+                                 * parameter in BTA_JvL2capReceive () */
+    UINT16          len;        /* The length of the data read. */
+} tBTA_JV_L2CAP_RECEIVE;
+
+/* data associated with BTA_JV_L2CAP_WRITE_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The connection handle */
+    UINT32          req_id;     /* The req_id in the associated BTA_JvL2capWrite() */
+    UINT16          len;        /* The length of the data written. */
+    BOOLEAN         cong;       /* congestion status */
+} tBTA_JV_L2CAP_WRITE;
+
+/* data associated with BTA_JV_RFCOMM_OPEN_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The connection handle */
+    BD_ADDR         rem_bda;    /* The peer address */
+} tBTA_JV_RFCOMM_OPEN;
+/* data associated with BTA_JV_RFCOMM_SRV_OPEN_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;             /* Whether the operation succeeded or failed. */
+    UINT32          handle;             /* The connection handle */
+    UINT32          new_listen_handle;  /* The new listen handle */
+    BD_ADDR         rem_bda;            /* The peer address */
+} tBTA_JV_RFCOMM_SRV_OPEN;
+
+
+/* data associated with BTA_JV_RFCOMM_CLOSE_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;      /* Whether the operation succeeded or failed. */
+    UINT32          port_status; /* PORT status */
+    UINT32          handle;      /* The connection handle */
+    BOOLEAN         async;       /* FALSE, if local initiates disconnect */
+} tBTA_JV_RFCOMM_CLOSE;
+
+/* data associated with BTA_JV_RFCOMM_START_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The connection handle */
+    UINT8           sec_id;     /* security ID used by this server */
+    BOOLEAN         use_co;     /* TRUE to use co_rfc_data */
+} tBTA_JV_RFCOMM_START;
+
+/* data associated with BTA_JV_RFCOMM_CL_INIT_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The connection handle */
+    UINT8           sec_id;     /* security ID used by this client */
+    BOOLEAN         use_co;     /* TRUE to use co_rfc_data */
+} tBTA_JV_RFCOMM_CL_INIT;
+/*data associated with BTA_JV_L2CAP_DATA_IND_EVT & BTA_JV_RFCOMM_DATA_IND_EVT */
+typedef struct
+{
+    UINT32          handle;     /* The connection handle */
+} tBTA_JV_DATA_IND;
+
+/* data associated with BTA_JV_RFCOMM_CONG_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The connection handle */
+    BOOLEAN         cong;       /* TRUE, congested. FALSE, uncongested */
+} tBTA_JV_RFCOMM_CONG;
+
+/* data associated with BTA_JV_RFCOMM_READ_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The connection handle */
+    UINT32          req_id;     /* The req_id in the associated BTA_JvRfcommRead() */
+    UINT8           *p_data;    /* This points the same location as the p_data
+                                 * parameter in BTA_JvRfcommRead () */
+    UINT16          len;        /* The length of the data read. */
+} tBTA_JV_RFCOMM_READ;
+
+/* data associated with BTA_JV_RFCOMM_WRITE_EVT */
+typedef struct
+{
+    tBTA_JV_STATUS  status;     /* Whether the operation succeeded or failed. */
+    UINT32          handle;     /* The connection handle */
+    UINT32          req_id;     /* The req_id in the associated BTA_JvRfcommWrite() */
+    int             len;        /* The length of the data written. */
+    BOOLEAN         cong;       /* congestion status */
+} tBTA_JV_RFCOMM_WRITE;
+
+
+/* union of data associated with JV callback */
+typedef union
+{
+    tBTA_JV_STATUS          status;         /* BTA_JV_ENABLE_EVT */
+    tBTA_JV_DISCOVERY_COMP  disc_comp;      /* BTA_JV_DISCOVERY_COMP_EVT */
+    tBTA_JV_SET_DISCOVER    set_discover;   /* BTA_JV_SET_DISCOVER_EVT */
+    tBTA_JV_SET_ENCRYPTION  set_encrypt;    /* BTA_JV_SET_ENCRYPTION_EVT */
+    BD_ADDR                 bd_addr;        /* BTA_JV_LOCAL_ADDR_EVT */
+    UINT8                   *p_name;        /* BTA_JV_LOCAL_NAME_EVT,
+                                               BTA_JV_REMOTE_NAME_EVT */
+    UINT8                   scn;            /* BTA_JV_GET_SCN_EVT */
+    UINT16                  psm;            /* BTA_JV_GET_PSM_EVT */
+    tBTA_JV_SERVICES_LEN    servs_len;      /* BTA_JV_SERVICES_LEN_EVT */
+    tBTA_JV_SERVICE_SEL     serv_sel;       /* BTA_JV_SERVICE_SEL_EVT */
+    tBTA_JV_CREATE_RECORD   create_rec;     /* BTA_JV_CREATE_RECORD_EVT */
+    tBTA_JV_UPDATE_RECORD   update_rec;     /* BTA_JV_UPDATE_RECORD_EVT */
+    tBTA_JV_ADD_ATTR        add_attr;       /* BTA_JV_ADD_ATTR_EVT */
+    tBTA_JV_DELETE_ATTR     del_attr;       /* BTA_JV_DELETE_ATTR_EVT */
+    tBTA_JV_L2CAP_OPEN      l2c_open;       /* BTA_JV_L2CAP_OPEN_EVT */
+    tBTA_JV_L2CAP_CLOSE     l2c_close;      /* BTA_JV_L2CAP_CLOSE_EVT */
+    tBTA_JV_L2CAP_START     l2c_start;      /* BTA_JV_L2CAP_START_EVT */
+    tBTA_JV_L2CAP_CL_INIT   l2c_cl_init;    /* BTA_JV_L2CAP_CL_INIT_EVT */
+    tBTA_JV_L2CAP_CONG      l2c_cong;       /* BTA_JV_L2CAP_CONG_EVT */
+    tBTA_JV_L2CAP_READ      l2c_read;       /* BTA_JV_L2CAP_READ_EVT */
+    tBTA_JV_L2CAP_WRITE     l2c_write;      /* BTA_JV_L2CAP_WRITE_EVT */
+    tBTA_JV_RFCOMM_OPEN     rfc_open;       /* BTA_JV_RFCOMM_OPEN_EVT */
+    tBTA_JV_RFCOMM_SRV_OPEN rfc_srv_open;   /* BTA_JV_RFCOMM_SRV_OPEN_EVT */
+    tBTA_JV_RFCOMM_CLOSE    rfc_close;      /* BTA_JV_RFCOMM_CLOSE_EVT */
+    tBTA_JV_RFCOMM_START    rfc_start;      /* BTA_JV_RFCOMM_START_EVT */
+    tBTA_JV_RFCOMM_CL_INIT  rfc_cl_init;    /* BTA_JV_RFCOMM_CL_INIT_EVT */
+    tBTA_JV_RFCOMM_CONG     rfc_cong;       /* BTA_JV_RFCOMM_CONG_EVT */
+    tBTA_JV_RFCOMM_READ     rfc_read;       /* BTA_JV_RFCOMM_READ_EVT */
+    tBTA_JV_RFCOMM_WRITE    rfc_write;      /* BTA_JV_RFCOMM_WRITE_EVT */
+    tBTA_JV_DATA_IND        data_ind;    /* BTA_JV_L2CAP_DATA_IND_EVT
+                                               BTA_JV_RFCOMM_DATA_IND_EVT */
+} tBTA_JV;
+
+/* JAVA DM Interface callback */
+typedef void (tBTA_JV_DM_CBACK)(tBTA_JV_EVT event, tBTA_JV *p_data, void * user_data);
+
+/* JAVA RFCOMM interface callback */
+typedef void* (tBTA_JV_RFCOMM_CBACK)(tBTA_JV_EVT event, tBTA_JV *p_data, void *user_data);
+
+/* JAVA L2CAP interface callback */
+typedef void (tBTA_JV_L2CAP_CBACK)(tBTA_JV_EVT event, tBTA_JV *p_data);
+
+/* JV configuration structure */
+typedef struct
+{
+    UINT16  sdp_raw_size;           /* The size of p_sdp_raw_data */
+    UINT16  sdp_db_size;            /* The size of p_sdp_db */
+    UINT8   *p_sdp_raw_data;        /* The data buffer to keep raw data */
+    tSDP_DISCOVERY_DB   *p_sdp_db;  /* The data buffer to keep SDP database */
+} tBTA_JV_CFG;
+
+/*****************************************************************************
+**  External Function Declarations
+*****************************************************************************/
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*******************************************************************************
+**
+** 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 functions in the JV API are
+**                  called.
+**
+** Returns          BTA_JV_SUCCESS if successful.
+**                  BTA_JV_FAIL if internal failure.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvEnable(tBTA_JV_DM_CBACK *p_cback);
+
+/*******************************************************************************
+**
+** Function         BTA_JvDisable
+**
+** Description      Disable the Java I/F
+**
+** Returns          void
+**
+*******************************************************************************/
+BTA_API extern void BTA_JvDisable(void);
+
+/*******************************************************************************
+**
+** Function         BTA_JvIsEnable
+**
+** Description      Get the JV registration status.
+**
+** Returns          TRUE, if registered
+**
+*******************************************************************************/
+BTA_API extern BOOLEAN BTA_JvIsEnable(void);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvSetDiscoverability(tBTA_JV_DISC disc_mode);
+
+/*******************************************************************************
+**
+** Function         BTA_JvGetDiscoverability
+**
+** Description      This function gets the Bluetooth
+**                  discoverable modes of local device
+**
+** Returns          The current Bluetooth discoverable mode.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_DISC BTA_JvGetDiscoverability(void);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvGetLocalDeviceAddr(void);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvGetLocalDeviceName(void);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvGetRemoteDeviceName(BD_ADDR bd_addr);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern INT32 BTA_JvGetPreknownDevice(UINT8 * p_bd_addr, UINT32 index);
+
+/*******************************************************************************
+**
+** Function         BTA_JvGetDeviceClass
+**
+** Description      This function obtains the local Class of Device.
+**
+** Returns          DEV_CLASS, A three-byte array of UINT8 that contains the
+**                  Class of Device information. The definitions are in the
+**                  "Bluetooth Assigned Numbers".
+**
+*******************************************************************************/
+BTA_API extern UINT8 * BTA_JvGetDeviceClass(void);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvSetServiceClass(UINT32 service);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvSetEncryption(BD_ADDR bd_addr);
+
+/*******************************************************************************
+**
+** Function         BTA_JvIsAuthenticated
+**
+** Description      This function checks if the peer device is authenticated
+**
+** Returns          TRUE if authenticated.
+**                  FALSE if not.
+**
+*******************************************************************************/
+BTA_API extern BOOLEAN BTA_JvIsAuthenticated(BD_ADDR bd_addr);
+
+/*******************************************************************************
+**
+** Function         BTA_JvIsTrusted
+**
+** Description      This function checks if the peer device is trusted
+**                  (previously paired)
+**
+** Returns          TRUE if trusted.
+**                  FALSE if not.
+**
+*******************************************************************************/
+BTA_API extern BOOLEAN BTA_JvIsTrusted(BD_ADDR bd_addr);
+
+/*******************************************************************************
+**
+** Function         BTA_JvIsAuthorized
+**
+** Description      This function checks if the peer device is authorized
+**
+** Returns          TRUE if authorized.
+**                  FALSE if not.
+**
+*******************************************************************************/
+BTA_API extern BOOLEAN BTA_JvIsAuthorized(BD_ADDR bd_addr);
+
+/*******************************************************************************
+**
+** Function         BTA_JvIsEncrypted
+**
+** Description      This function checks if the link to peer device is encrypted
+**
+** Returns          TRUE if encrypted.
+**                  FALSE if not.
+**
+*******************************************************************************/
+BTA_API extern BOOLEAN BTA_JvIsEncrypted(BD_ADDR bd_addr);
+
+/*******************************************************************************
+**
+** Function         BTA_JvGetSecurityMode
+**
+** Description      This function returns the current Bluetooth security mode
+**                  of the local device
+**
+** Returns          The current Bluetooth security mode.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_SEC_MODE BTA_JvGetSecurityMode(void);
+
+/* BTA_JvIsMaster is replaced by BTA_DmIsMaster */
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvGetSCN(void);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvFreeSCN(UINT8 scn);
+
+/*******************************************************************************
+**
+** 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
+**
+*******************************************************************************/
+BTA_API extern UINT16 BTA_JvGetPSM(void);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvStartDiscovery(BD_ADDR bd_addr, UINT16 num_uuid,
+                           tSDP_UUID *p_uuid_list, void* user_data);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvCancelDiscovery(void * user_data);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvGetServicesLength(BOOLEAN inc_hdr, UINT16 *p_services_len);
+
+/*******************************************************************************
+**
+** 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
+**
+*******************************************************************************/
+BTA_API extern INT32 BTA_JvGetServicesResult(BOOLEAN inc_hdr, UINT8 **TLVs);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvServiceSelect(UINT16 uuid);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern INT32 BTA_JvServiceResult(UINT8 *TLV);
+
+/*******************************************************************************
+**
+** Function         BTA_JvCreateRecord
+**
+** Description      Create a service record in the local SDP database by user in
+**                  tBTA_JV_DM_CBACK callback with a BTA_JV_CREATE_RECORD_EVT.
+**
+** Returns          BTA_JV_SUCCESS, if the request is being processed.
+**                  BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvCreateRecordByUser(void* user_data);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvUpdateRecord(UINT32 handle, UINT16 *p_ids,
+                           UINT8 **p_values, INT32 *p_value_sizes, INT32 array_len);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvAddAttribute(UINT32 handle, UINT16 attr_id,
+                           UINT8 *p_value, INT32 value_size);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvDeleteAttribute(UINT32 handle, UINT16 attr_id);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvDeleteRecord(UINT32 handle);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern INT32 BTA_JvReadRecord(UINT32 handle, UINT8 *p_data, INT32 *p_data_len);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern 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);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvL2capClose(UINT32 handle);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern 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);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvL2capStopServer(UINT16 local_psm);
+
+/*******************************************************************************
+**
+** Function         BTA_JvL2capRead
+**
+** Description      This function reads data from an L2CAP connection
+**                  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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvL2capRead(UINT32 handle, UINT32 req_id,
+                                              UINT8 *p_data, UINT16 len);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvL2capReceive(UINT32 handle, UINT32 req_id,
+                                              UINT8 *p_data, UINT16 len);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvL2capReady(UINT32 handle, UINT32 *p_data_size);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvL2capWrite(UINT32 handle, UINT32 req_id,
+                                               UINT8 *p_data, UINT16 len);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern 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);
+
+/*******************************************************************************
+**
+** Function         BTA_JvRfcommClose
+**
+** Description      This function closes an RFCOMM connection
+**
+** Returns          BTA_JV_SUCCESS, if the request is being processed.
+**                  BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvRfcommClose(UINT32 handle);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern 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);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvRfcommStopServer(UINT32 handle);
+
+/*******************************************************************************
+**
+** Function         BTA_JvRfcommRead
+**
+** Description      This function reads data from an RFCOMM connection
+**                  When the operation is complete, tBTA_JV_RFCOMM_CBACK is
+**                  called with BTA_JV_RFCOMM_READ_EVT.
+**
+** Returns          BTA_JV_SUCCESS, if the request is being processed.
+**                  BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvRfcommRead(UINT32 handle, UINT32 req_id,
+                                               UINT8 *p_data, UINT16 len);
+
+/*******************************************************************************
+**
+** 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.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvRfcommReady(UINT32 handle, UINT32 *p_data_size);
+
+/*******************************************************************************
+**
+** Function         BTA_JvRfcommWrite
+**
+** Description      This function writes data to an RFCOMM connection
+**                  When the operation is complete, tBTA_JV_RFCOMM_CBACK is
+**                  called with BTA_JV_RFCOMM_WRITE_EVT.
+**
+** Returns          BTA_JV_SUCCESS, if the request is being processed.
+**                  BTA_JV_FAILURE, otherwise.
+**
+*******************************************************************************/
+BTA_API extern tBTA_JV_STATUS BTA_JvRfcommWrite(UINT32 handle, UINT32 req_id);
+
+
+/*******************************************************************************
+**
+** 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);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* BTA_JV_API_H */
+
diff --git a/bta/include/bta_jv_co.h b/bta/include/bta_jv_co.h
new file mode 100755
index 0000000..09e09c5
--- /dev/null
+++ b/bta/include/bta_jv_co.h
@@ -0,0 +1,38 @@
+/*****************************************************************************
+**
+**  Name:           bta_jv_co.h
+**
+**  Description:    This is the interface file for java interface call-out
+**                  functions.
+**
+**  Copyright (c) 2007, Widcomm Inc., All Rights Reserved.
+**  Widcomm Bluetooth Core. Proprietary and confidential.
+**
+*****************************************************************************/
+#ifndef BTA_JV_CO_H
+#define BTA_JV_CO_H
+
+#include "bta_jv_api.h"
+
+/*****************************************************************************
+**  Function Declarations
+*****************************************************************************/
+
+
+/*******************************************************************************
+**
+** Function         bta_jv_co_rfc_data
+**
+** Description      This function is called by JV to send data to the java glue
+**                  code when the RX data path is configured to use a call-out
+**
+** Returns          void
+**
+*******************************************************************************/
+
+BTA_API extern int bta_co_rfc_data_incoming(void *user_data, BT_HDR *p_buf);
+BTA_API extern int bta_co_rfc_data_outgoing_size(void *user_data, int *size);
+BTA_API extern int bta_co_rfc_data_outgoing(void *user_data, UINT8* buf, UINT16 size);
+
+#endif /* BTA_DG_CO_H */
+
diff --git a/bta/jv/bta_jv_act.c b/bta/jv/bta_jv_act.c
new file mode 100755
index 0000000..60729e3
--- /dev/null
+++ b/bta/jv/bta_jv_act.c
@@ -0,0 +1,2339 @@
+/*****************************************************************************
+**
+**  Name:           bta_jv_act.c
+**
+**  Description:    This file contains action functions for advanced audio.
+**
+**  Copyright (c) 2006-2009, Broadcom Corp., All Rights Reserved.
+**  Widcomm Bluetooth Core. Proprietary and confidential.
+**
+*****************************************************************************/
+
+#include <hardware/bluetooth.h>
+#include <arpa/inet.h>
+
+#include "bt_types.h"
+#include "gki.h"
+#include "bd.h"
+#include "utl.h"
+#include "bta_sys.h"
+#include "bta_api.h"
+#include "bta_jv_api.h"
+#include "bta_jv_int.h"
+#include "bta_jv_co.h"
+#include "btm_api.h"
+#include "btm_int.h"
+#include "sdp_api.h"
+#include "l2c_api.h"
+#include "port_api.h"
+#include <string.h>
+#include "rfcdefs.h"
+#include "avct_api.h"
+#include "avdt_api.h"
+
+
+#include <cutils/log.h>
+#define info(fmt, ...)  LOGI ("%s: " fmt,__FUNCTION__,  ## __VA_ARGS__)
+#define debug(fmt, ...) LOGD ("%s: " fmt,__FUNCTION__,  ## __VA_ARGS__)
+#define error(fmt, ...) LOGE ("## ERROR : %s: " fmt "##",__FUNCTION__,  ## __VA_ARGS__)
+#define asrt(s) if(!(s)) LOGE ("## %s assert %s failed at line:%d ##",__FUNCTION__, #s, __LINE__)
+
+
+
+#define HDL2CB(handle) \
+    UINT32  __hi = ((handle) & BTA_JV_RFC_HDL_MASK) - 1; \
+    UINT32  __si = BTA_JV_RFC_HDL_TO_SIDX(handle); \
+    tBTA_JV_RFC_CB  *p_cb = &bta_jv_cb.rfc_cb[__hi]; \
+    tBTA_JV_PCB   *p_pcb = &bta_jv_cb.port_cb[p_cb->rfc_hdl[__si] - 1]
+
+extern void uuid_to_string(bt_uuid_t *p_uuid, char *str);
+static inline void logu(const char* title, const uint8_t * p_uuid)
+{
+    char uuids[128];
+    uuid_to_string((bt_uuid_t*)p_uuid, uuids);
+    LOGD("%s: %s", title, uuids);
+}
+
+
+static tBTA_JV_PCB * bta_jv_add_rfc_port(tBTA_JV_RFC_CB *p_cb);
+
+/*******************************************************************************
+**
+** Function     bta_jv_get_local_device_addr_cback
+**
+** Description  Callback from btm after local bdaddr is read
+**
+** Returns      void
+**
+*******************************************************************************/
+static void bta_jv_get_local_device_addr_cback(BD_ADDR bd_addr)
+{
+    if(bta_jv_cb.p_dm_cback)
+        bta_jv_cb.p_dm_cback(BTA_JV_LOCAL_ADDR_EVT, (tBTA_JV *)bd_addr, 0);
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_get_remote_device_name_cback
+**
+** Description  Callback from btm after remote name is read
+**
+** Returns      void
+**
+*******************************************************************************/
+static void bta_jv_get_remote_device_name_cback(tBTM_REMOTE_DEV_NAME *p_name)
+{
+    tBTA_JV evt_data;
+    evt_data.p_name = p_name->remote_bd_name;
+    if(bta_jv_cb.p_dm_cback)
+        bta_jv_cb.p_dm_cback(BTA_JV_REMOTE_NAME_EVT, &evt_data, 0);
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_alloc_sec_id
+**
+** Description  allocate a security id
+**
+** Returns
+**
+*******************************************************************************/
+UINT8 bta_jv_alloc_sec_id(void)
+{
+    UINT8 ret = 0;
+    int i;
+    for(i=0; i<BTA_JV_NUM_SERVICE_ID; i++)
+    {
+        if(0 == bta_jv_cb.sec_id[i])
+        {
+            bta_jv_cb.sec_id[i] = BTA_JV_FIRST_SERVICE_ID + i;
+            ret = bta_jv_cb.sec_id[i];
+            break;
+        }
+    }
+    return ret;
+
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_free_sec_id
+**
+** Description  free the given security id
+**
+** Returns
+**
+*******************************************************************************/
+static void bta_jv_free_sec_id(UINT8 *p_sec_id)
+{
+    UINT8 sec_id = *p_sec_id;
+    *p_sec_id = 0;
+    if(sec_id >= BTA_JV_FIRST_SERVICE_ID && sec_id <= BTA_JV_LAST_SERVICE_ID)
+    {
+        BTM_SecClrService(sec_id);
+        bta_jv_cb.sec_id[sec_id - BTA_JV_FIRST_SERVICE_ID] = 0;
+    }
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_alloc_rfc_cb
+**
+** Description  allocate a control block for the given port handle
+**
+** Returns
+**
+*******************************************************************************/
+tBTA_JV_RFC_CB * bta_jv_alloc_rfc_cb(UINT16 port_handle, tBTA_JV_PCB **pp_pcb)
+{
+    tBTA_JV_RFC_CB *p_cb = NULL;
+    tBTA_JV_PCB *p_pcb;
+    int i;
+    for(i=0; i<BTA_JV_MAX_RFC_CONN; i++)
+    {
+        if(0 == bta_jv_cb.rfc_cb[i].handle )
+        {
+            p_cb = &bta_jv_cb.rfc_cb[i];
+            p_cb->handle            = i + 1;
+            p_cb->max_sess          = 1;
+            p_cb->rfc_hdl[0]        = port_handle;
+            APPL_TRACE_DEBUG2( "bta_jv_alloc_rfc_cb port_handle:%d handle:%d",
+                port_handle, p_cb->handle);
+            p_pcb = &bta_jv_cb.port_cb[port_handle - 1];
+            p_pcb->handle = p_cb->handle;
+            p_pcb->port_handle = port_handle;
+            *pp_pcb = p_pcb;
+            break;
+        }
+    }
+    return p_cb;
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_rfc_port_to_pcb
+**
+** Description  find the port control block associated with the given port handle
+**
+** Returns
+**
+*******************************************************************************/
+tBTA_JV_PCB * bta_jv_rfc_port_to_pcb(UINT16 port_handle)
+{
+    tBTA_JV_PCB *p_pcb = NULL;
+
+    if ((port_handle > 0) && (port_handle <= MAX_RFC_PORTS) && bta_jv_cb.port_cb[port_handle - 1].handle)
+    {
+        p_pcb = &bta_jv_cb.port_cb[port_handle - 1];
+    }
+
+    return p_pcb;
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_rfc_port_to_cb
+**
+** Description  find the RFCOMM control block associated with the given port handle
+**
+** Returns
+**
+*******************************************************************************/
+tBTA_JV_RFC_CB * bta_jv_rfc_port_to_cb(UINT16 port_handle)
+{
+    tBTA_JV_RFC_CB *p_cb = NULL;
+    UINT32 handle;
+
+    if ((port_handle > 0) && (port_handle <= MAX_RFC_PORTS) && bta_jv_cb.port_cb[port_handle - 1].handle)
+    {
+        handle = bta_jv_cb.port_cb[port_handle - 1].handle;
+        handle &= BTA_JV_RFC_HDL_MASK;
+        if (handle)
+            p_cb = &bta_jv_cb.rfc_cb[handle - 1];
+    }
+    return p_cb;
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_free_rfc_pcb
+**
+** Description  free the given port control block
+**
+** Returns
+**
+*******************************************************************************/
+tBTA_JV_STATUS bta_jv_free_rfc_pcb(tBTA_JV_PCB *p_pcb)
+{
+    tBTA_JV_STATUS status = BTA_JV_SUCCESS;
+    BOOLEAN         remove = FALSE;
+    BOOLEAN         is_server = TRUE;
+    UINT16          port_handle;
+
+    APPL_TRACE_DEBUG2( "bta_jv_free_rfc_pcb handle:%d s:%d", p_pcb->port_handle, p_pcb->state);
+
+    if (p_pcb->port_handle)
+    {
+        if(BTA_JV_ST_NONE != p_pcb->state)
+        {
+            remove = TRUE;
+            if(p_pcb->state <= BTA_JV_ST_CL_MAX)
+                is_server = FALSE;
+            port_handle = p_pcb->port_handle;
+        }
+        p_pcb->port_handle = 0;
+        p_pcb->state = BTA_JV_ST_NONE;
+
+        //Initialize congestion flags
+        p_pcb->cong = FALSE;
+
+        if(remove)
+        {
+            if(is_server)
+            {
+                if(RFCOMM_RemoveServer(port_handle) != PORT_SUCCESS)
+                    status = BTA_JV_FAILURE;
+            }
+            else
+            {
+                if(RFCOMM_RemoveConnection(port_handle) != PORT_SUCCESS)
+                    status = BTA_JV_FAILURE;
+            }
+        }
+    }
+    return status;
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_free_rfc_cb
+**
+** Description  free the given RFCOMM control block
+**
+** Returns
+**
+*******************************************************************************/
+tBTA_JV_STATUS bta_jv_free_rfc_cb(tBTA_JV_RFC_CB *p_cb)
+{
+    tBTA_JV_STATUS status = BTA_JV_SUCCESS;
+    UINT8           i;
+    APPL_TRACE_DEBUG1( "bta_jv_free_rfc_cb max_sess:%d", p_cb->max_sess);
+    for (i=0; i<p_cb->max_sess; i++)
+    {
+        APPL_TRACE_DEBUG2( "[%d]: port=%d", i, p_cb->rfc_hdl[i]);
+        if (p_cb->rfc_hdl[i])
+            bta_jv_free_rfc_pcb (&bta_jv_cb.port_cb[p_cb->rfc_hdl[i] - 1]);
+    }
+
+    p_cb->scn = 0;
+    bta_jv_free_sec_id(&p_cb->sec_id);
+    p_cb->p_cback = NULL;
+    p_cb->handle = 0;
+
+    return status;
+}
+static tBTA_JV_STATUS bta_jv_free_rfc_listen_cb(tBTA_JV_RFC_CB *p_cb)
+{
+    tBTA_JV_STATUS status = BTA_JV_SUCCESS;
+    UINT8           i;
+    debug( "max_sess:%d", p_cb->max_sess);
+    for (i=0; i<p_cb->max_sess; i++)
+    {
+        APPL_TRACE_DEBUG2( "[%d]: port=%d", i, p_cb->rfc_hdl[i]);
+        if (p_cb->rfc_hdl[i])
+        {
+            tBTA_JV_PCB *p_pcb = &bta_jv_cb.port_cb[p_cb->rfc_hdl[i] - 1];
+            if(p_pcb->state == BTA_JV_ST_SR_LISTEN)
+            {
+                debug( "free listen pcb: scn:%d, ueser_data:%d", p_cb->scn, (int)p_pcb->user_data);
+                p_pcb->user_data = 0;
+                bta_jv_free_rfc_pcb (p_pcb);
+                p_cb->max_sess = 1;
+                break;
+            }
+        }
+    }
+    //p_cb->scn = 0;
+    bta_jv_free_sec_id(&p_cb->sec_id);
+    //p_cb->p_cback = NULL;
+    //p_cb->handle = 0;
+    return status;
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_free_l2c_cb
+**
+** Description  free the given L2CAP control block
+**
+** Returns
+**
+*******************************************************************************/
+tBTA_JV_STATUS bta_jv_free_l2c_cb(tBTA_JV_L2C_CB *p_cb)
+{
+#if 0
+    tBTA_JV_STATUS status = BTA_JV_SUCCESS;
+
+    if(BTA_JV_ST_NONE != p_cb->state)
+    {
+#if SDP_FOR_JV_INCLUDED == TRUE
+        if(BTA_JV_L2C_FOR_SDP_HDL == p_cb->handle)
+        {
+            bta_jv_cb.sdp_data_size = 0;
+            if(SDP_ConnClose(bta_jv_cb.sdp_for_jv))
+            {
+                bta_jv_cb.sdp_for_jv = 0;
+            }
+            else
+                status = BTA_JV_FAILURE;
+        }
+        else
+#endif
+        if(GAP_ConnClose(p_cb->handle) != BT_PASS)
+            status = BTA_JV_FAILURE;
+    }
+    p_cb->psm = 0;
+    p_cb->state = BTA_JV_ST_NONE;
+    bta_jv_free_sec_id(&p_cb->sec_id);
+    p_cb->p_cback = NULL;
+    return status;
+#endif
+    return 0;
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_alloc_sdp_id
+**
+** Description  allocate a SDP id for the given SDP record handle
+**
+** Returns
+**
+*******************************************************************************/
+UINT32 bta_jv_alloc_sdp_id(UINT32 sdp_handle)
+{
+    int j;
+    UINT32 id = 0;
+
+    /* find a free entry */
+    for (j = 0; j < BTA_JV_MAX_SDP_REC; j++)
+    {
+        if (bta_jv_cb.sdp_handle[j] == 0)
+        {
+            bta_jv_cb.sdp_handle[j] = sdp_handle;
+            id = (UINT32)(j + 1);
+            break;
+        }
+    }
+    /* the SDP record handle reported is the (index + 1) to control block */
+    return id;
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_free_sdp_id
+**
+** Description  free the sdp id
+**
+** Returns
+**
+*******************************************************************************/
+void bta_jv_free_sdp_id(UINT32 sdp_id)
+{
+    if(sdp_id > 0 && sdp_id <= BTA_JV_MAX_SDP_REC)
+    {
+        bta_jv_cb.sdp_handle[sdp_id - 1] = 0;
+    }
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_get_sdp_handle
+**
+** Description  find the SDP handle associated with the given sdp id
+**
+** Returns
+**
+*******************************************************************************/
+UINT32 bta_jv_get_sdp_handle(UINT32 sdp_id)
+{
+    UINT32 sdp_handle = 0;
+
+    if(sdp_id > 0 && sdp_id <= BTA_JV_MAX_SDP_REC)
+    {
+        sdp_handle = bta_jv_cb.sdp_handle[sdp_id - 1];
+    }
+    return sdp_handle;
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_check_psm
+**
+** Description  for now use only the legal PSM per JSR82 spec
+**
+** Returns      TRUE, if allowed
+**
+*******************************************************************************/
+BOOLEAN bta_jv_check_psm(UINT16 psm)
+{
+    BOOLEAN ret = FALSE;
+
+    if(L2C_IS_VALID_PSM(psm) )
+    {
+        if(psm < 0x1001)
+        {
+            /* see if this is defined by spec */
+            switch(psm)
+            {
+            case SDP_PSM:           /* 1 */
+            case BT_PSM_RFCOMM:     /* 3 */
+                /* do not allow java app to use these 2 PSMs */
+                break;
+
+            case TCS_PSM_INTERCOM:  /* 5 */
+            case TCS_PSM_CORDLESS:  /* 7 */
+                if( FALSE == bta_sys_is_register(BTA_ID_CT) &&
+                    FALSE == bta_sys_is_register(BTA_ID_CG) )
+                    ret = TRUE;
+                break;
+
+            case BT_PSM_BNEP:       /* F */
+                if(FALSE == bta_sys_is_register(BTA_ID_PAN))
+                    ret = TRUE;
+                break;
+
+            case HID_PSM_CONTROL:   /* 0x11 */
+            case HID_PSM_INTERRUPT: /* 0x13 */
+                //FIX: allow HID Device and HID Host to coexist
+                if( FALSE == bta_sys_is_register(BTA_ID_HD) ||
+                    FALSE == bta_sys_is_register(BTA_ID_HH) )
+                    ret = TRUE;
+                break;
+
+            case AVCT_PSM:          /* 0x17 */
+            case AVDT_PSM:          /* 0x19 */
+                if ((FALSE == bta_sys_is_register(BTA_ID_AV)) &&
+                   (FALSE == bta_sys_is_register(BTA_ID_AVK)))
+                    ret = TRUE;
+                break;
+
+            default:
+                ret = TRUE;
+                break;
+            }
+        }
+        else
+            ret = TRUE;
+    }
+    return ret;
+
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_enable
+**
+** Description  Initialises the JAVA I/F
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_enable(tBTA_JV_MSG *p_data)
+{
+    tBTA_JV_STATUS status = BTA_JV_SUCCESS;
+    bta_jv_cb.p_dm_cback = p_data->enable.p_cback;
+    bta_jv_cb.p_dm_cback(BTA_JV_ENABLE_EVT, (tBTA_JV *)&status, 0);
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_disable
+**
+** Description  Disables the BT device manager
+**              free the resources used by java
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_disable (tBTA_JV_MSG *p_data)
+{
+    int i;
+
+    bta_jv_cb.p_dm_cback = NULL;
+    /* delete the SDP records created by java apps */
+    for(i=0; i<BTA_JV_MAX_SDP_REC; i++)
+    {
+        if(bta_jv_cb.sdp_handle[i])
+        {
+            APPL_TRACE_DEBUG1( "delete SDP record: %d", bta_jv_cb.sdp_handle[i]);
+            SDP_DeleteRecord(bta_jv_cb.sdp_handle[i]);
+            bta_jv_cb.sdp_handle[i] = 0;
+        }
+    }
+
+    /* free the SCNs allocated by java apps */
+    for(i=0; i<BTA_JV_MAX_SCN; i++)
+    {
+        if(bta_jv_cb.scn[i])
+        {
+            APPL_TRACE_DEBUG1( "free scn: %d", (i+1));
+            BTM_FreeSCN((UINT8)(i+1));
+            bta_jv_cb.scn[i] = FALSE;
+        }
+    }
+
+    /* disconnect L2CAP connections */
+    for(i=0; i<BTA_JV_MAX_L2C_CONN; i++)
+    {
+        bta_jv_free_l2c_cb(&bta_jv_cb.l2c_cb[i]);
+    }
+
+    /* disconnect RFCOMM connections */
+    for(i=0; i<BTA_JV_MAX_RFC_CONN; i++)
+    {
+        bta_jv_free_rfc_cb(&bta_jv_cb.rfc_cb[i]);
+    }
+
+    /* free the service records allocated by java apps */
+    for(i=0; i<BTA_JV_NUM_SERVICE_ID; i++)
+    {
+        if(bta_jv_cb.sec_id[i])
+        {
+            BTM_SecClrService(bta_jv_cb.sec_id[i]);
+            bta_jv_cb.sec_id[i] = 0;
+        }
+    }
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_set_discoverability
+**
+** Description  Sets discoverability
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_set_discoverability (tBTA_JV_MSG *p_data)
+{
+    tBTA_JV     evt_data;
+
+    evt_data.set_discover.status = BTA_JV_FAILURE;
+    /* initialize the default value for the event as the current mode */
+    evt_data.set_discover.disc_mode = BTM_ReadDiscoverability(NULL, NULL);
+
+    if(BTM_SUCCESS == BTM_SetDiscoverability((UINT8)p_data->set_discoverability.disc_mode, 0, 0))
+    {
+        evt_data.set_discover.status     = BTA_JV_SUCCESS;
+        /* update the mode, after BTM_SetDiscoverability() is successful */
+        evt_data.set_discover.disc_mode  = p_data->set_discoverability.disc_mode;
+    }
+
+    if(bta_jv_cb.p_dm_cback)
+        bta_jv_cb.p_dm_cback(BTA_JV_SET_DISCOVER_EVT, &evt_data, 0);
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_get_local_device_addr
+**
+** Description  Reads the local Bluetooth device address
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_get_local_device_addr(tBTA_JV_MSG *p_data)
+{
+    BTM_ReadLocalDeviceAddr((tBTM_CMPL_CB *)bta_jv_get_local_device_addr_cback);
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_get_local_device_name
+**
+** Description  Reads the local Bluetooth device name
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_get_local_device_name(tBTA_JV_MSG *p_data)
+{
+    tBTA_JV evt_data;
+    char *name;
+
+    BTM_ReadLocalDeviceName(&name);
+    evt_data.p_name = (UINT8*)name;
+    if(bta_jv_cb.p_dm_cback)
+        bta_jv_cb.p_dm_cback(BTA_JV_LOCAL_NAME_EVT, &evt_data, 0);
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_get_remote_device_name
+**
+** Description  Reads the local Bluetooth device name
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_get_remote_device_name(tBTA_JV_MSG *p_data)
+{
+
+    BTM_ReadRemoteDeviceName(p_data->get_rmt_name.bd_addr,
+        (tBTM_CMPL_CB *)bta_jv_get_remote_device_name_cback);
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_set_service_class
+**
+** Description  update the service class field of device class
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_set_service_class (tBTA_JV_MSG *p_data)
+{
+    tBTA_UTL_COD cod;
+
+    /* set class of device */
+    /* BTA_JvSetServiceClass(UINT32 service) assumes that the service class passed to the API function as defined in the assigned number page.
+    For example: the object transfer bit is bit 20 of the 24-bit Class of device; the value of this bit is 0x00100000 (value 1)
+    Our btm_api.h defines this bit as #define BTM_COD_SERVICE_OBJ_TRANSFER        0x1000 // (value 2)
+    This reflects that the service class defined at btm is UINT16, which starts at bit 8 of the 24 bit Class of Device
+    The following statement converts from (value 1) into (value 2) */
+    cod.service = (p_data->set_service.service >> 8);
+    utl_set_device_class(&cod, BTA_UTL_SET_COD_SERVICE_CLASS);
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_sec_cback
+**
+** Description  callback function to handle set encryption complete event
+**
+** Returns      void
+**
+*******************************************************************************/
+static void bta_jv_sec_cback (BD_ADDR bd_addr, void *p_ref_data, tBTM_STATUS result)
+{
+    tBTA_JV_SET_ENCRYPTION  set_enc;
+    if(bta_jv_cb.p_dm_cback)
+    {
+        bdcpy(set_enc.bd_addr, bd_addr);
+        set_enc.status = result;
+        if (result > BTA_JV_BUSY)
+            set_enc.status = BTA_JV_FAILURE;
+        bta_jv_cb.p_dm_cback(BTA_JV_SET_ENCRYPTION_EVT, (tBTA_JV *)&set_enc, 0);
+    }
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_set_encryption
+**
+** Description  Reads the local Bluetooth device name
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_set_encryption(tBTA_JV_MSG *p_data)
+{
+    BTM_SetEncryption(p_data->set_encrypt.bd_addr, bta_jv_sec_cback, NULL);
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_get_scn
+**
+** Description  obtain a free SCN
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_get_scn(tBTA_JV_MSG *p_data)
+{
+#if 0
+    UINT8   scn;
+    scn = BTM_AllocateSCN();
+    if(scn)
+        bta_jv_cb.scn[scn-1] = TRUE;
+    if(bta_jv_cb.p_dm_cback)
+        bta_jv_cb.p_dm_cback(BTA_JV_GET_SCN_EVT, (tBTA_JV *)&scn);
+#endif
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_free_scn
+**
+** Description  free a SCN
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_free_scn(tBTA_JV_MSG *p_data)
+{
+    UINT8   scn = p_data->free_scn.scn;
+
+    if (scn > 0 && scn <= BTA_JV_MAX_SCN && bta_jv_cb.scn[scn-1])
+    {
+        /* this scn is used by JV */
+        bta_jv_cb.scn[scn-1] = FALSE;
+        BTM_FreeSCN(scn);
+    }
+}
+static inline tBT_UUID shorten_sdp_uuid(const tBT_UUID* u)
+{
+    static uint8_t bt_base_uuid[] =
+       {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB };
+
+    logu("in, uuid:", u);
+    debug("uuid len:%d", u->len);
+    if(u->len == 16)
+    {
+        if(memcmp(&u->uu.uuid128[4], &bt_base_uuid[4], 12) == 0)
+        {
+            tBT_UUID su;
+            memset(&su, 0, sizeof(su));
+            if(u->uu.uuid128[0] == 0 && u->uu.uuid128[1] == 0)
+            {
+                su.len = 2;
+                uint16_t u16;
+                memcpy(&u16, &u->uu.uuid128[2], sizeof(u16));
+                su.uu.uuid16 = ntohs(u16);
+                debug("shorten to 16 bits uuid: %x", su.uu.uuid16);
+            }
+            else
+            {
+                su.len = 4;
+                uint32_t u32;
+                memcpy(&u32, &u->uu.uuid128[0], sizeof(u32));
+                su.uu.uuid32 = ntohl(u32);
+                debug("shorten to 32 bits uuid: %x", su.uu.uuid32);
+            }
+            return su;
+        }
+    }
+    debug("cannot shorten none-reserved 128 bits uuid");
+    return *u;
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_start_discovery_cback
+**
+** Description  Callback for Start Discovery
+**
+** Returns      void
+**
+*******************************************************************************/
+static void bta_jv_start_discovery_cback(UINT16 result, void * user_data)
+{
+    tBTA_JV_STATUS status;
+    UINT8          old_sdp_act = bta_jv_cb.sdp_active;
+
+    debug( "bta_jv_start_discovery_cback res: 0x%x", result);
+
+    bta_jv_cb.sdp_active = BTA_JV_SDP_ACT_NONE;
+    if(bta_jv_cb.p_dm_cback)
+    {
+        if (old_sdp_act == BTA_JV_SDP_ACT_CANCEL)
+        {
+            debug("BTA_JV_SDP_ACT_CANCEL");
+            status = BTA_JV_SUCCESS;
+            bta_jv_cb.p_dm_cback(BTA_JV_CANCEL_DISCVRY_EVT, (tBTA_JV *)&status, user_data);
+        }
+        else
+        {
+            tBTA_JV_DISCOVERY_COMP dcomp;
+            dcomp.scn = 0;
+            status = BTA_JV_FAILURE;
+            if (result == SDP_SUCCESS || result == SDP_DB_FULL)
+            {
+                tSDP_DISC_REC       *p_sdp_rec = NULL;
+                tSDP_PROTOCOL_ELEM  pe;
+                logu("bta_jv_cb.uuid", bta_jv_cb.uuid.uu.uuid128);
+                tBT_UUID su = shorten_sdp_uuid(&bta_jv_cb.uuid);
+                logu("shorten uuid:", su.uu.uuid128);
+                p_sdp_rec = SDP_FindServiceUUIDInDb(p_bta_jv_cfg->p_sdp_db, &su, p_sdp_rec);
+                debug("p_sdp_rec:%p", p_sdp_rec);
+                if(p_sdp_rec && SDP_FindProtocolListElemInRec(p_sdp_rec, UUID_PROTOCOL_RFCOMM, &pe))
+                {
+                    dcomp.scn = (UINT8) pe.params[0];
+                    status = BTA_JV_SUCCESS;
+                }
+            }
+
+            dcomp.status = status;
+            bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, (tBTA_JV *)&dcomp, user_data);
+        }
+        //free sdp db
+        //utl_freebuf(&(p_bta_jv_cfg->p_sdp_db));
+    }
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_start_discovery
+**
+** Description  Discovers services on a remote device
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_start_discovery(tBTA_JV_MSG *p_data)
+{
+    tBTA_JV_STATUS status = BTA_JV_FAILURE;
+    debug("in, sdp_active:%d", bta_jv_cb.sdp_active);
+    if (bta_jv_cb.sdp_active != BTA_JV_SDP_ACT_NONE)
+    {
+        /* SDP is still in progress */
+        status = BTA_JV_BUSY;
+        if(bta_jv_cb.p_dm_cback)
+            bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, (tBTA_JV *)&status, p_data->start_discovery.user_data);
+        return;
+    }
+/*
+    if(p_data->start_discovery.num_uuid == 0)
+    {
+        p_data->start_discovery.num_uuid = 1;
+        p_data->start_discovery.uuid_list[0].len       = 2;
+        p_data->start_discovery.uuid_list[0].uu.uuid16 = UUID_SERVCLASS_PUBLIC_BROWSE_GROUP;
+    }
+*/
+    /* init the database/set up the filter */
+    debug("call SDP_InitDiscoveryDb, p_data->start_discovery.num_uuid:%d",
+        p_data->start_discovery.num_uuid);
+    SDP_InitDiscoveryDb (p_bta_jv_cfg->p_sdp_db, p_bta_jv_cfg->sdp_db_size,
+                    p_data->start_discovery.num_uuid, p_data->start_discovery.uuid_list, 0, NULL);
+
+    /* tell SDP to keep the raw data */
+    p_bta_jv_cfg->p_sdp_db->raw_data = p_bta_jv_cfg->p_sdp_raw_data;
+    p_bta_jv_cfg->p_sdp_db->raw_size = p_bta_jv_cfg->sdp_raw_size;
+
+    bta_jv_cb.p_sel_raw_data     = 0;
+    bta_jv_cb.uuid = p_data->start_discovery.uuid_list[0];
+
+    bta_jv_cb.sdp_active = BTA_JV_SDP_ACT_YES;
+    if (!SDP_ServiceSearchAttributeRequest2(p_data->start_discovery.bd_addr,
+                                   p_bta_jv_cfg->p_sdp_db,
+                                   bta_jv_start_discovery_cback, p_data->start_discovery.user_data))
+    {
+        bta_jv_cb.sdp_active = BTA_JV_SDP_ACT_NONE;
+        /* failed to start SDP. report the failure right away */
+        if(bta_jv_cb.p_dm_cback)
+            bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, (tBTA_JV *)&status, p_data->start_discovery.user_data);
+    }
+    /*
+    else report the result when the cback is called
+    */
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_cancel_discovery
+**
+** Description  Cancels an active discovery
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_cancel_discovery(tBTA_JV_MSG *p_data)
+{
+    tBTA_JV_STATUS status = BTA_JV_SUCCESS;
+    if (bta_jv_cb.sdp_active == BTA_JV_SDP_ACT_YES)
+    {
+        if (SDP_CancelServiceSearch (p_bta_jv_cfg->p_sdp_db))
+        {
+            bta_jv_cb.sdp_active = BTA_JV_SDP_ACT_CANCEL;
+            return;
+        }
+    }
+    if(bta_jv_cb.p_dm_cback)
+        bta_jv_cb.p_dm_cback(BTA_JV_CANCEL_DISCVRY_EVT, (tBTA_JV *)&status, p_data->cancel_discovery.user_data);
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_get_services_length
+**
+** Description  Obtain the length of each record in the SDP DB.
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_get_services_length(tBTA_JV_MSG *p_data)
+{
+#if 0
+    tBTA_JV_SERVICES_LEN    evt_data;
+    UINT8   *p, *np, *op, type;
+    UINT32  raw_used, raw_cur;
+    UINT32  len;
+
+    evt_data.num_services = -1;
+    evt_data.p_services_len = p_data->get_services_length.p_services_len;
+    if(p_bta_jv_cfg->p_sdp_db->p_first_rec)
+    {
+        /* the database is valid */
+        evt_data.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(p_data->get_services_length.inc_hdr)
+            {
+                evt_data.p_services_len[evt_data.num_services++] = len + np - op;
+            }
+            else
+            {
+                evt_data.p_services_len[evt_data.num_services++] = len;
+            }
+        } /* end of while */
+    }
+
+    if(bta_jv_cb.p_dm_cback)
+        bta_jv_cb.p_dm_cback(BTA_JV_SERVICES_LEN_EVT, (tBTA_JV *)&evt_data);
+#endif
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_service_select
+**
+** Description  Obtain the length of given UUID in the SDP DB.
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_service_select(tBTA_JV_MSG *p_data)
+{
+#if 0
+    tBTA_JV_SERVICE_SEL     serv_sel;
+    tSDP_DISC_REC *p_rec, *p_tmp;
+    UINT8   *p, *np, *op, type;
+    UINT32  raw_used, raw_cur;
+    UINT32  len;
+
+    serv_sel.service_len = 0;
+    bta_jv_cb.p_sel_raw_data     = 0;
+    p_rec = SDP_FindServiceInDb (p_bta_jv_cfg->p_sdp_db, p_data->service_select.uuid, NULL);
+    if(p_rec)
+    {
+        /* found the record in the database */
+        /* the database must be valid */
+        p = p_bta_jv_cfg->p_sdp_db->raw_data;
+        raw_used = p_bta_jv_cfg->p_sdp_db->raw_used;
+        p_tmp = p_bta_jv_cfg->p_sdp_db->p_first_rec;
+        while(raw_used && p && p_tmp)
+        {
+            op = p;
+            type = *p++;
+            np = sdpu_get_len_from_type(p, type, &len);
+            if(p_tmp == p_rec)
+            {
+                bta_jv_cb.p_sel_raw_data = op;
+                bta_jv_cb.sel_len = len;
+                serv_sel.service_len = len;
+                bdcpy(serv_sel.bd_addr, p_rec->remote_bd_addr);
+                APPL_TRACE_DEBUG1( "bta_jv_service_select found uuid: 0x%x",
+                    p_data->service_select.uuid);
+                break;
+            }
+            p = np + len;
+            raw_cur = p - op;
+            if(raw_used >= raw_cur)
+            {
+                raw_used -= raw_cur;
+            }
+            else
+            {
+                /* error. can not continue */
+                break;
+            }
+            p_tmp = p_tmp->p_next_rec;
+        } /* end of while */
+    }
+    APPL_TRACE_DEBUG1( "service_len: %d", serv_sel.service_len);
+    if(bta_jv_cb.p_dm_cback)
+        bta_jv_cb.p_dm_cback(BTA_JV_SERVICE_SEL_EVT, (tBTA_JV *)&serv_sel);
+#endif
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_create_record
+**
+** Description  Create an SDP record with the given attributes
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_create_record(tBTA_JV_MSG *p_data)
+{
+    tBTA_JV_API_CREATE_RECORD *cr = &(p_data->create_record);
+    tBTA_JV_CREATE_RECORD   evt_data;
+    evt_data.status = BTA_JV_SUCCESS;
+    if(bta_jv_cb.p_dm_cback)
+        //callback user immediately to create his own sdp record in stack thread context
+        bta_jv_cb.p_dm_cback(BTA_JV_CREATE_RECORD_EVT, (tBTA_JV *)&evt_data, cr->user_data);
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_update_record
+**
+** Description  Update an SDP record with the given attributes
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_update_record(tBTA_JV_MSG *p_data)
+{
+#if 0
+    tBTA_JV_API_UPDATE_RECORD *ur = &(p_data->update_record);
+    tBTA_JV_UPDATE_RECORD   evt_data;
+    UINT32 handle;
+    INT32 i;
+    UINT8 *ptr;
+    UINT8 *next_ptr;
+    UINT8 *end;
+    UINT32 len;
+    UINT8 type;
+
+    evt_data.status = BTA_JV_FAILURE;
+    evt_data.handle = ur->handle;
+
+    handle = bta_jv_get_sdp_handle(ur->handle);
+
+    if(handle)
+    {
+        /* this is a record created by JV */
+        for (i = 0; i < ur->array_len; i++)
+        {
+            ptr = ur->p_values[i];
+            end = ptr + ur->p_value_sizes[i];
+
+            while (ptr < end)
+            {
+                type = *ptr;
+                next_ptr = sdpu_get_len_from_type(ptr + 1, *ptr, &len);
+
+                if(ATTR_ID_SERVICE_RECORD_HDL != ur->p_ids[i])
+                {
+                if (!SDP_AddAttribute(handle, ur->p_ids[i], (UINT8)((type >> 3) & 0x1f),
+                    len, next_ptr))
+                {
+                    /* failed on updating attributes.  */
+                    if(bta_jv_cb.p_dm_cback)
+                        bta_jv_cb.p_dm_cback(BTA_JV_UPDATE_RECORD_EVT, (tBTA_JV *)&evt_data);
+                    return;
+                }
+                }
+
+                ptr = next_ptr + len;
+            } /* end of while */
+        } /* end of for */
+        evt_data.status = BTA_JV_SUCCESS;
+    }
+
+    if(bta_jv_cb.p_dm_cback)
+        bta_jv_cb.p_dm_cback(BTA_JV_UPDATE_RECORD_EVT, (tBTA_JV *)&evt_data);
+#endif
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_add_attribute
+**
+** Description  Add an attribute to an SDP record
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_add_attribute(tBTA_JV_MSG *p_data)
+{
+#if 0
+    tBTA_JV_API_ADD_ATTRIBUTE *aa = &(p_data->add_attr);
+    tBTA_JV_ADD_ATTR   evt_data;
+    UINT32 handle;
+    UINT8 type;
+    UINT32 len;
+    UINT8 *ptr;
+    UINT8 *next_ptr;
+
+    evt_data.status = BTA_JV_FAILURE;
+    evt_data.handle = aa->handle;
+    handle = bta_jv_get_sdp_handle(aa->handle);
+
+    if(handle)
+    {
+        /* this is a record created by JV */
+        ptr = aa->p_value;
+        type = *ptr;
+        next_ptr = sdpu_get_len_from_type(ptr + 1, *ptr, &len);
+        APPL_TRACE_DEBUG3( "bta_jv_add_attribute: ptr chg:%d len:%d, size:%d",
+            (next_ptr - ptr), len, aa->value_size);
+        if(ATTR_ID_SERVICE_RECORD_HDL != aa->attr_id && /* do not allow the SDP record handle to be updated */
+            ((INT32)(next_ptr - ptr + len) == aa->value_size) && /* double check data size */
+            SDP_AddAttribute(handle, aa->attr_id, (UINT8)((type >> 3) & 0x1f),
+                    len, next_ptr))
+        {
+            evt_data.status = BTA_JV_SUCCESS;
+        }
+    }
+
+    if(bta_jv_cb.p_dm_cback)
+        bta_jv_cb.p_dm_cback(BTA_JV_ADD_ATTR_EVT, (tBTA_JV *)&evt_data);
+#endif
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_delete_attribute
+**
+** Description  Delete an attribute from the given SDP record
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_delete_attribute(tBTA_JV_MSG *p_data)
+{
+#if 0
+    tBTA_JV_API_ADD_ATTRIBUTE *da = &(p_data->add_attr);
+    tBTA_JV_DELETE_ATTR   evt_data;
+    UINT32 handle;
+
+    evt_data.status = BTA_JV_FAILURE;
+    evt_data.handle = da->handle;
+    handle = bta_jv_get_sdp_handle(da->handle);
+
+    if(handle)
+    {
+        /* this is a record created by JV */
+        if(SDP_DeleteAttribute(handle, da->attr_id))
+            evt_data.status = BTA_JV_SUCCESS;
+    }
+
+    if(bta_jv_cb.p_dm_cback)
+        bta_jv_cb.p_dm_cback(BTA_JV_DELETE_ATTR_EVT, (tBTA_JV *)&evt_data);
+#endif
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_delete_record
+**
+** Description  Delete an SDP record
+**
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_delete_record(tBTA_JV_MSG *p_data)
+{
+    tBTA_JV_API_ADD_ATTRIBUTE *dr = &(p_data->add_attr);
+    UINT32 handle;
+
+    handle = bta_jv_get_sdp_handle(dr->handle);
+
+    if(handle)
+    {
+        /* this is a record created by JV */
+        SDP_DeleteRecord(handle);
+        bta_jv_free_sdp_id(dr->handle);
+    }
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_l2cap_client_cback
+**
+** Description  handles the l2cap client events
+**
+** Returns      void
+**
+*******************************************************************************/
+static void bta_jv_l2cap_client_cback(UINT16 gap_handle, UINT16 event)
+{
+#if 0
+    tBTA_JV_L2C_CB  *p_cb = &bta_jv_cb.l2c_cb[gap_handle];
+    tBTA_JV     evt_data;
+
+    if(gap_handle >= BTA_JV_MAX_L2C_CONN && !p_cb->p_cback)
+        return;
+
+    APPL_TRACE_DEBUG2( "bta_jv_l2cap_client_cback: %d evt:x%x",
+        gap_handle, event);
+    evt_data.l2c_open.status = BTA_JV_SUCCESS;
+    evt_data.l2c_open.handle = gap_handle;
+    switch (event)
+    {
+    case GAP_EVT_CONN_OPENED:
+        bdcpy(evt_data.l2c_open.rem_bda, GAP_ConnGetRemoteAddr(gap_handle));
+        evt_data.l2c_open.tx_mtu = GAP_ConnGetRemMtuSize(gap_handle);
+        p_cb->state = BTA_JV_ST_CL_OPEN;
+        p_cb->p_cback(BTA_JV_L2CAP_OPEN_EVT, &evt_data);
+        break;
+
+    case GAP_EVT_CONN_CLOSED:
+        p_cb->state = BTA_JV_ST_NONE;
+        bta_jv_free_sec_id(&p_cb->sec_id);
+        evt_data.l2c_close.async = TRUE;
+        p_cb->p_cback(BTA_JV_L2CAP_CLOSE_EVT, &evt_data);
+        p_cb->p_cback = NULL;
+        break;
+
+    case GAP_EVT_CONN_DATA_AVAIL:
+        evt_data.handle = gap_handle;
+        p_cb->p_cback(BTA_JV_L2CAP_DATA_IND_EVT, &evt_data);
+        break;
+
+    case GAP_EVT_CONN_CONGESTED:
+    case GAP_EVT_CONN_UNCONGESTED:
+        p_cb->cong = (event == GAP_EVT_CONN_CONGESTED) ? TRUE : FALSE;
+        evt_data.l2c_cong.cong = p_cb->cong;
+        p_cb->p_cback(BTA_JV_L2CAP_CONG_EVT, &evt_data);
+        break;
+
+    default:
+        break;
+    }
+#endif
+}
+
+#if SDP_FOR_JV_INCLUDED == TRUE
+/*******************************************************************************
+**
+** Function     bta_jv_sdp_res_cback
+**
+** Description  Callback for Start Discovery
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_sdp_res_cback (UINT16 event, tSDP_DATA *p_data)
+{
+    tBTA_JV evt_data;
+    tBTA_JV_L2C_CB  *p_cb = &bta_jv_cb.l2c_cb[BTA_JV_L2C_FOR_SDP_HDL];
+
+    APPL_TRACE_DEBUG2( "bta_jv_sdp_res_cback: %d evt:x%x",
+        bta_jv_cb.sdp_for_jv, event);
+
+    if(!bta_jv_cb.sdp_for_jv)
+        return;
+
+    evt_data.l2c_open.status = BTA_JV_SUCCESS;
+    evt_data.l2c_open.handle = BTA_JV_L2C_FOR_SDP_HDL;
+
+    switch(event)
+    {
+    case SDP_EVT_OPEN:
+        bdcpy(evt_data.l2c_open.rem_bda, p_data->open.peer_addr);
+        evt_data.l2c_open.tx_mtu = p_data->open.peer_mtu;
+        p_cb->state = BTA_JV_ST_SR_OPEN;
+        p_cb->p_cback(BTA_JV_L2CAP_OPEN_EVT, &evt_data);
+        break;
+    case SDP_EVT_DATA_IND:
+        evt_data.handle = BTA_JV_L2C_FOR_SDP_HDL;
+        memcpy(p_bta_jv_cfg->p_sdp_raw_data, p_data->data.p_data, p_data->data.data_len);
+        APPL_TRACE_DEBUG2( "data size: %d/%d ", bta_jv_cb.sdp_data_size, p_data->data.data_len);
+        bta_jv_cb.sdp_data_size = p_data->data.data_len;
+        p_cb->p_cback(BTA_JV_L2CAP_DATA_IND_EVT, &evt_data);
+        break;
+    }
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_sdp_cback
+**
+** Description  Callback for Start Discovery
+**
+** Returns      void
+**
+*******************************************************************************/
+static void bta_jv_sdp_cback(UINT16 result)
+{
+    tBTA_JV_L2CAP_CLOSE close;
+    tBTA_JV_L2C_CB  *p_cb = &bta_jv_cb.l2c_cb[BTA_JV_L2C_FOR_SDP_HDL];
+    APPL_TRACE_DEBUG1( "bta_jv_sdp_cback: result:x%x", result);
+
+    if(p_cb->p_cback)
+    {
+        close.handle    = BTA_JV_L2C_FOR_SDP_HDL;
+        close.async     = FALSE;
+        close.status    = BTA_JV_SUCCESS;
+        bta_jv_free_sec_id(&p_cb->sec_id);
+        p_cb->p_cback(BTA_JV_L2CAP_CLOSE_EVT, (tBTA_JV *)&close);
+    }
+
+    bta_jv_cb.sdp_for_jv = 0;
+    p_cb->p_cback = NULL;
+
+}
+#endif
+
+/*******************************************************************************
+**
+** Function     bta_jv_l2cap_connect
+**
+** Description  makes an l2cap client connection
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_l2cap_connect(tBTA_JV_MSG *p_data)
+{
+#if 0
+    tBTA_JV_L2C_CB      *p_cb;
+    tBTA_JV_L2CAP_CL_INIT  evt_data;
+    UINT16  handle=GAP_INVALID_HANDLE;
+    UINT8   sec_id;
+    tL2CAP_CFG_INFO cfg;
+    tBTA_JV_API_L2CAP_CONNECT *cc = &(p_data->l2cap_connect);
+
+    memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO));
+    cfg.mtu_present = TRUE;
+    cfg.mtu = cc->rx_mtu;
+    /* TODO: DM role manager
+    L2CA_SetDesireRole(cc->role);
+    */
+
+    sec_id = bta_jv_alloc_sec_id();
+    evt_data.sec_id = sec_id;
+    evt_data.status = BTA_JV_FAILURE;
+    if (sec_id)
+    {
+#if SDP_FOR_JV_INCLUDED == TRUE
+        if(SDP_PSM == cc->remote_psm && 0 == bta_jv_cb.sdp_for_jv)
+        {
+            bta_jv_cb.sdp_for_jv = SDP_ConnOpen(cc->peer_bd_addr,
+                                       bta_jv_sdp_res_cback,
+                                       bta_jv_sdp_cback);
+            if(bta_jv_cb.sdp_for_jv)
+            {
+                bta_jv_cb.sdp_data_size = 0;
+                handle = BTA_JV_L2C_FOR_SDP_HDL;
+                evt_data.status = BTA_JV_SUCCESS;
+            }
+        }
+        else
+#endif
+        if(bta_jv_check_psm(cc->remote_psm)) /* allowed */
+        {
+            if( (handle = GAP_ConnOpen("", sec_id, 0, cc->peer_bd_addr, cc->remote_psm,
+                &cfg, cc->sec_mask, GAP_FCR_CHAN_OPT_BASIC,
+                bta_jv_l2cap_client_cback)) != GAP_INVALID_HANDLE )
+            {
+                evt_data.status = BTA_JV_SUCCESS;
+            }
+        }
+    }
+
+    if (evt_data.status == BTA_JV_SUCCESS)
+    {
+        p_cb = &bta_jv_cb.l2c_cb[handle];
+        p_cb->handle = handle;
+        p_cb->p_cback = cc->p_cback;
+        p_cb->psm = 0;  /* not a server */
+        p_cb->sec_id = sec_id;
+        p_cb->state = BTA_JV_ST_CL_OPENING;
+    }
+    else
+    {
+        bta_jv_free_sec_id(&sec_id);
+    }
+    evt_data.handle = handle;
+    cc->p_cback(BTA_JV_L2CAP_CL_INIT_EVT, (tBTA_JV *)&evt_data);
+#endif
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_l2cap_close
+**
+** Description  Close an L2CAP client connection
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_l2cap_close(tBTA_JV_MSG *p_data)
+{
+#if 0
+    tBTA_JV_L2CAP_CLOSE  evt_data;
+    tBTA_JV_API_L2CAP_CLOSE *cc = &(p_data->l2cap_close);
+    tBTA_JV_L2CAP_CBACK *p_cback = cc->p_cb->p_cback;
+
+    evt_data.handle = cc->handle;
+    evt_data.status = bta_jv_free_l2c_cb(cc->p_cb);
+    evt_data.async = FALSE;
+
+    if (p_cback)
+        p_cback(BTA_JV_L2CAP_CLOSE_EVT, (tBTA_JV *)&evt_data);
+    else
+        APPL_TRACE_ERROR0("### NO CALLBACK SET !!! ###");
+#endif
+}
+
+/*******************************************************************************
+**
+** Function         bta_jv_l2cap_server_cback
+**
+** Description      handles the l2cap server callback
+**
+** Returns          void
+**
+*******************************************************************************/
+static void bta_jv_l2cap_server_cback(UINT16 gap_handle, UINT16 event)
+{
+#if 0
+    tBTA_JV_L2C_CB  *p_cb = &bta_jv_cb.l2c_cb[gap_handle];
+    tBTA_JV evt_data;
+    tBTA_JV_L2CAP_CBACK *p_cback;
+
+    if(gap_handle >= BTA_JV_MAX_L2C_CONN && !p_cb->p_cback)
+        return;
+
+    APPL_TRACE_DEBUG2( "bta_jv_l2cap_server_cback: %d evt:x%x",
+        gap_handle, event);
+    evt_data.l2c_open.status = BTA_JV_SUCCESS;
+    evt_data.l2c_open.handle = gap_handle;
+
+    switch (event)
+    {
+    case GAP_EVT_CONN_OPENED:
+        bdcpy(evt_data.l2c_open.rem_bda, GAP_ConnGetRemoteAddr(gap_handle));
+        evt_data.l2c_open.tx_mtu = GAP_ConnGetRemMtuSize(gap_handle);
+        p_cb->state = BTA_JV_ST_SR_OPEN;
+        p_cb->p_cback(BTA_JV_L2CAP_OPEN_EVT, &evt_data);
+        break;
+
+    case GAP_EVT_CONN_CLOSED:
+        evt_data.l2c_close.async = TRUE;
+        evt_data.l2c_close.handle = p_cb->handle;
+        p_cback = p_cb->p_cback;
+        evt_data.l2c_close.status = bta_jv_free_l2c_cb(p_cb);
+        p_cback(BTA_JV_L2CAP_CLOSE_EVT, &evt_data);
+        break;
+
+    case GAP_EVT_CONN_DATA_AVAIL:
+        evt_data.handle = gap_handle;
+        p_cb->p_cback(BTA_JV_L2CAP_DATA_IND_EVT, &evt_data);
+        break;
+
+    case GAP_EVT_CONN_CONGESTED:
+    case GAP_EVT_CONN_UNCONGESTED:
+        p_cb->cong = (event == GAP_EVT_CONN_CONGESTED) ? TRUE : FALSE;
+        evt_data.l2c_cong.cong = p_cb->cong;
+        p_cb->p_cback(BTA_JV_L2CAP_CONG_EVT, &evt_data);
+        break;
+
+    default:
+        break;
+    }
+#endif
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_l2cap_start_server
+**
+** Description  starts an L2CAP server
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_l2cap_start_server(tBTA_JV_MSG *p_data)
+{
+#if 0
+    tBTA_JV_L2C_CB      *p_cb;
+    UINT8   sec_id;
+    UINT16  handle;
+    tL2CAP_CFG_INFO cfg;
+    tBTA_JV_L2CAP_START evt_data;
+    tBTA_JV_API_L2CAP_SERVER *ls = &(p_data->l2cap_server);
+
+    memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO));
+
+    //FIX: MTU=0 means not present
+    if (ls->rx_mtu >0)
+    {
+        cfg.mtu_present = TRUE;
+        cfg.mtu = ls->rx_mtu;
+    }
+    else
+    {
+        cfg.mtu_present = FALSE;
+        cfg.mtu = 0;
+    }
+
+    /* TODO DM role manager
+    L2CA_SetDesireRole(ls->role);
+    */
+
+    sec_id = bta_jv_alloc_sec_id();
+    if (0 == sec_id || (FALSE == bta_jv_check_psm(ls->local_psm)) ||
+        (handle = GAP_ConnOpen("JV L2CAP", sec_id, 1, 0, ls->local_psm, &cfg,
+            ls->sec_mask, GAP_FCR_CHAN_OPT_BASIC, bta_jv_l2cap_server_cback)) == GAP_INVALID_HANDLE)
+    {
+        bta_jv_free_sec_id(&sec_id);
+        evt_data.status = BTA_JV_FAILURE;
+    }
+    else
+    {
+        /* default JV implementation requires explicit call
+           to allow incoming connections when ready*/
+
+        GAP_SetAcceptReady(handle, FALSE);
+
+        p_cb = &bta_jv_cb.l2c_cb[handle];
+        evt_data.status = BTA_JV_SUCCESS;
+        evt_data.handle = handle;
+        evt_data.sec_id = sec_id;
+        p_cb->p_cback = ls->p_cback;
+        p_cb->handle = handle;
+        p_cb->sec_id = sec_id;
+        p_cb->state = BTA_JV_ST_SR_LISTEN;
+        p_cb->psm = ls->local_psm;
+    }
+    ls->p_cback(BTA_JV_L2CAP_START_EVT, (tBTA_JV *)&evt_data);
+#endif
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_l2cap_stop_server
+**
+** Description  stops an L2CAP server
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_l2cap_stop_server(tBTA_JV_MSG *p_data)
+{
+#if 0
+    tBTA_JV_L2C_CB      *p_cb;
+    tBTA_JV_L2CAP_CLOSE  evt_data;
+    tBTA_JV_API_L2CAP_SERVER *ls = &(p_data->l2cap_server);
+    tBTA_JV_L2CAP_CBACK *p_cback;
+    int i;
+
+    for(i=0; i<BTA_JV_MAX_L2C_CONN; i++)
+    {
+        if(bta_jv_cb.l2c_cb[i].psm == ls->local_psm)
+        {
+            p_cb = &bta_jv_cb.l2c_cb[i];
+            p_cback = p_cb->p_cback;
+            evt_data.handle = p_cb->handle;
+            evt_data.status = bta_jv_free_l2c_cb(p_cb);
+            evt_data.async = FALSE;
+            p_cback(BTA_JV_L2CAP_CLOSE_EVT, (tBTA_JV *)&evt_data);
+            break;
+        }
+    }
+#endif
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_l2cap_read
+**
+** Description  Read data from an L2CAP connection
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_l2cap_read(tBTA_JV_MSG *p_data)
+{
+#if 0
+    tBTA_JV_L2CAP_READ evt_data;
+    tBTA_JV_API_L2CAP_READ *rc = &(p_data->l2cap_read);
+
+    evt_data.status = BTA_JV_FAILURE;
+    evt_data.handle = rc->handle;
+    evt_data.req_id = rc->req_id;
+    evt_data.p_data = rc->p_data;
+    evt_data.len    = 0;
+#if SDP_FOR_JV_INCLUDED == TRUE
+    if(BTA_JV_L2C_FOR_SDP_HDL == rc->handle)
+    {
+        evt_data.len = rc->len;
+        if(evt_data.len > bta_jv_cb.sdp_data_size)
+            evt_data.len = bta_jv_cb.sdp_data_size;
+
+        memcpy(rc->p_data, p_bta_jv_cfg->p_sdp_raw_data, evt_data.len);
+        bta_jv_cb.sdp_data_size = 0;
+        evt_data.status = BTA_JV_SUCCESS;
+    }
+    else
+#endif
+    if (BT_PASS == GAP_ConnReadData(rc->handle, rc->p_data, rc->len, &evt_data.len))
+    {
+        evt_data.status = BTA_JV_SUCCESS;
+    }
+
+    rc->p_cback(BTA_JV_L2CAP_READ_EVT, (tBTA_JV *)&evt_data);
+#endif
+}
+
+
+/*******************************************************************************
+**
+** Function     bta_jv_l2cap_write
+**
+** Description  Write data to an L2CAP connection
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_l2cap_write(tBTA_JV_MSG *p_data)
+{
+#if 0
+    tBTA_JV_L2CAP_WRITE evt_data;
+    tBTA_JV_API_L2CAP_WRITE *ls = &(p_data->l2cap_write);
+
+    evt_data.status = BTA_JV_FAILURE;
+    evt_data.handle = ls->handle;
+    evt_data.req_id = ls->req_id;
+    evt_data.cong   = ls->p_cb->cong;
+    evt_data.len    = 0;
+#if SDP_FOR_JV_INCLUDED == TRUE
+    if(BTA_JV_L2C_FOR_SDP_HDL == ls->handle)
+    {
+        UINT8   *p;
+        BT_HDR  *p_msg = (BT_HDR *) GKI_getbuf ((UINT16)(ls->len + BT_HDR_SIZE + L2CAP_MIN_OFFSET));
+        if(p_msg)
+        {
+            p_msg->offset = L2CAP_MIN_OFFSET;
+            p = (UINT8 *)(p_msg + 1) + L2CAP_MIN_OFFSET;
+            p_msg->len = ls->len;
+            memcpy(p, ls->p_data, p_msg->len);
+            if(SDP_WriteData (bta_jv_cb.sdp_for_jv, p_msg))
+            {
+                evt_data.len    = ls->len;
+                evt_data.status = BTA_JV_SUCCESS;
+            }
+        }
+    }
+    else
+#endif
+    if (!evt_data.cong &&
+        BT_PASS == GAP_ConnWriteData(ls->handle, ls->p_data, ls->len, &evt_data.len))
+    {
+        evt_data.status = BTA_JV_SUCCESS;
+    }
+
+    ls->p_cb->p_cback(BTA_JV_L2CAP_WRITE_EVT, (tBTA_JV *)&evt_data);
+#endif
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_port_data_co_cback
+**
+** Description  port data callback function of rfcomm
+**              connections
+**
+** Returns      void
+**
+*******************************************************************************/
+/*
+#define DATA_CO_CALLBACK_TYPE_INCOMING          1
+#define DATA_CO_CALLBACK_TYPE_OUTGOING_SIZE     2
+#define DATA_CO_CALLBACK_TYPE_OUTGOING          3
+*/
+static int bta_jv_port_data_co_cback(UINT16 port_handle, UINT8 *buf, UINT16 len, int type)
+{
+    tBTA_JV_RFC_CB  *p_cb = bta_jv_rfc_port_to_cb(port_handle);
+    tBTA_JV_PCB     *p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
+
+    if (p_cb != NULL)
+    {
+        switch(type)
+        {
+            case DATA_CO_CALLBACK_TYPE_INCOMING:
+                return bta_co_rfc_data_incoming(p_pcb->user_data, (BT_HDR*)buf);
+            case DATA_CO_CALLBACK_TYPE_OUTGOING_SIZE:
+                return bta_co_rfc_data_outgoing_size(p_pcb->user_data, (int*)buf);
+            case DATA_CO_CALLBACK_TYPE_OUTGOING:
+                return bta_co_rfc_data_outgoing(p_pcb->user_data, buf, len);
+            default:
+                APPL_TRACE_ERROR1("unknown callout type:%d", type);
+                break;
+        }
+    }
+    return 0;
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_port_mgmt_cl_cback
+**
+** Description  callback for port mamangement function of rfcomm
+**              client connections
+**
+** Returns      void
+**
+*******************************************************************************/
+static void bta_jv_port_mgmt_cl_cback(UINT32 code, UINT16 port_handle)
+{
+    tBTA_JV_RFC_CB  *p_cb = bta_jv_rfc_port_to_cb(port_handle);
+    tBTA_JV_PCB     *p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
+    tBTA_JV evt_data;
+    BD_ADDR rem_bda;
+    UINT16 lcid;
+    tBTA_JV_RFCOMM_CBACK *p_cback;  /* the callback function */
+
+    APPL_TRACE_DEBUG1( "bta_jv_port_mgmt_cl_cback:%d", port_handle);
+    if(NULL == p_cb || NULL == p_cb->p_cback)
+        return;
+
+    APPL_TRACE_DEBUG3( "bta_jv_port_mgmt_cl_cback code=%d port_handle:%d handle:%d",
+        code, port_handle, p_cb->handle);
+
+    PORT_CheckConnection(port_handle, rem_bda, &lcid);
+
+    if(code == PORT_SUCCESS)
+    {
+        evt_data.rfc_open.handle = p_cb->handle;
+        evt_data.rfc_open.status = BTA_JV_SUCCESS;
+        bdcpy(evt_data.rfc_open.rem_bda, rem_bda);
+        p_pcb->state = BTA_JV_ST_CL_OPEN;
+        p_cb->p_cback(BTA_JV_RFCOMM_OPEN_EVT, &evt_data, p_pcb->user_data);
+    }
+    else
+    {
+        evt_data.rfc_close.handle = p_cb->handle;
+        evt_data.rfc_close.status = BTA_JV_FAILURE;
+        evt_data.rfc_close.port_status = code;
+        evt_data.rfc_close.async = TRUE;
+        if (p_pcb->state == BTA_JV_ST_CL_CLOSING)
+        {
+            evt_data.rfc_close.async = FALSE;
+        }
+        p_pcb->state = BTA_JV_ST_NONE;
+        p_pcb->cong = FALSE;
+        p_cback = p_cb->p_cback;
+        bta_jv_free_rfc_cb(p_cb);
+
+        p_cback(BTA_JV_RFCOMM_CLOSE_EVT, &evt_data, p_pcb->user_data);
+    }
+
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_port_event_cl_cback
+**
+** Description  Callback for RFCOMM client port events
+**
+** Returns      void
+**
+*******************************************************************************/
+static void bta_jv_port_event_cl_cback(UINT32 code, UINT16 port_handle)
+{
+    tBTA_JV_RFC_CB  *p_cb = bta_jv_rfc_port_to_cb(port_handle);
+    tBTA_JV_PCB     *p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
+    tBTA_JV evt_data;
+
+    APPL_TRACE_DEBUG1( "bta_jv_port_event_cl_cback:%d", port_handle);
+    if(NULL == p_cb || NULL == p_cb->p_cback)
+        return;
+
+    APPL_TRACE_DEBUG3( "bta_jv_port_event_cl_cback code=x%x port_handle:%d handle:%d",
+        code, port_handle, p_cb->handle);
+    if (code & PORT_EV_RXCHAR)
+    {
+        evt_data.data_ind.handle = p_cb->handle;
+        p_cb->p_cback(BTA_JV_RFCOMM_DATA_IND_EVT, &evt_data, p_pcb->user_data);
+    }
+
+    if (code & PORT_EV_FC)
+    {
+        p_pcb->cong = (code & PORT_EV_FCS) ? FALSE : TRUE;
+        evt_data.rfc_cong.cong = p_pcb->cong;
+        evt_data.rfc_cong.handle = p_cb->handle;
+        evt_data.rfc_cong.status = BTA_JV_SUCCESS;
+        p_cb->p_cback(BTA_JV_RFCOMM_CONG_EVT, &evt_data, p_pcb->user_data);
+    }
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_rfcomm_connect
+**
+** Description  Client initiates an RFCOMM connection
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_rfcomm_connect(tBTA_JV_MSG *p_data)
+{
+    UINT16 handle = 0;
+    UINT32 event_mask = (PORT_EV_RXCHAR | PORT_EV_FC | PORT_EV_FCS);
+    tPORT_STATE port_state;
+    UINT8   sec_id;
+    tBTA_JV_RFC_CB  *p_cb = NULL;
+    tBTA_JV_PCB     *p_pcb;
+    tBTA_JV_API_RFCOMM_CONNECT *cc = &(p_data->rfcomm_connect);
+    tBTA_JV_RFCOMM_CL_INIT      evt_data;
+
+    /* TODO DM role manager
+    L2CA_SetDesireRole(cc->role);
+    */
+
+    sec_id = bta_jv_alloc_sec_id();
+    evt_data.sec_id = sec_id;
+    evt_data.status = BTA_JV_SUCCESS;
+    if (0 == sec_id ||
+        BTM_SetSecurityLevel(TRUE, "", sec_id,  cc->sec_mask, BT_PSM_RFCOMM,
+                BTM_SEC_PROTO_RFCOMM, cc->remote_scn) == FALSE)
+    {
+        evt_data.status = BTA_JV_FAILURE;
+        error("sec_id:%d is zero or BTM_SetSecurityLevel failed, remote_scn:%d", sec_id, cc->remote_scn);
+    }
+
+    if (evt_data.status == BTA_JV_SUCCESS &&
+        RFCOMM_CreateConnection(UUID_SERVCLASS_SERIAL_PORT, cc->remote_scn, FALSE,
+        BTA_JV_DEF_RFC_MTU, cc->peer_bd_addr, &handle, bta_jv_port_mgmt_cl_cback) != PORT_SUCCESS)
+    {
+        evt_data.status = BTA_JV_FAILURE;
+    }
+    if (evt_data.status == BTA_JV_SUCCESS)
+    {
+        p_cb = bta_jv_alloc_rfc_cb(handle, &p_pcb);
+        p_cb->p_cback = cc->p_cback;
+        p_cb->sec_id = sec_id;
+        p_cb->scn = 0;
+        p_pcb->state = BTA_JV_ST_CL_OPENING;
+        p_pcb->user_data = cc->user_data;
+        evt_data.use_co = TRUE;
+
+        PORT_SetEventCallback(handle, bta_jv_port_event_cl_cback);
+        PORT_SetEventMask(handle, event_mask);
+        PORT_SetDataCOCallback (handle, bta_jv_port_data_co_cback);
+
+        PORT_GetState(handle, &port_state);
+
+        port_state.fc_type = (PORT_FC_CTS_ON_INPUT | PORT_FC_CTS_ON_OUTPUT);
+
+/* coverity[uninit_use_in_call]
+FALSE-POSITIVE: port_state is initialized at PORT_GetState() */
+        PORT_SetState(handle, &port_state);
+
+        evt_data.handle = p_cb->handle;
+    }
+    cc->p_cback(BTA_JV_RFCOMM_CL_INIT_EVT, (tBTA_JV *)&evt_data, cc->user_data);
+ }
+
+/*******************************************************************************
+**
+** Function     bta_jv_rfcomm_close
+**
+** Description  Close an RFCOMM connection
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_rfcomm_close(tBTA_JV_MSG *p_data)
+{
+    tBTA_JV_RFCOMM_CLOSE     evt_data;
+    tBTA_JV_API_RFCOMM_CLOSE *cc = &(p_data->rfcomm_close);
+    tBTA_JV_RFC_CB           *p_cb = cc->p_cb;
+    tBTA_JV_PCB              *p_pcb = cc->p_pcb;
+    tBTA_JV_RFCOMM_CBACK     *p_cback = p_cb->p_cback;
+
+    evt_data.handle = p_cb->handle;
+    evt_data.status = BTA_JV_FAILURE;
+
+    void* user_data = p_pcb->user_data;
+    p_pcb->cong = FALSE;
+    if(p_pcb->state <= BTA_JV_ST_CL_MAX)
+    {
+        if(p_pcb->state == BTA_JV_ST_CL_OPEN)
+        {
+            if(PORT_SUCCESS == RFCOMM_RemoveConnection(p_pcb->port_handle))
+            {
+                p_pcb->state = BTA_JV_ST_CL_CLOSING;
+                return;
+            }
+        }
+        evt_data.status = bta_jv_free_rfc_cb(p_cb);
+    }
+    else if(BTA_JV_ST_SR_OPEN == p_pcb->state)
+    {
+        /* server is connected */
+        if(PORT_SUCCESS == RFCOMM_RemoveConnection(p_pcb->port_handle))
+        {
+            p_pcb->state = BTA_JV_ST_SR_CLOSING;
+            return;
+        }
+    }
+
+    evt_data.async = FALSE;
+
+    if (p_cback)
+        p_cback(BTA_JV_RFCOMM_CLOSE_EVT, (tBTA_JV *)&evt_data, user_data);
+    else
+        error("### NO CALLBACK SET !!! ###");
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_get_num_rfc_listen
+**
+** Description  when a RFCOMM connection goes down, make sure that there's only
+**              one port stays listening on this scn.
+**
+** Returns
+**
+*******************************************************************************/
+static UINT8 bta_jv_get_num_rfc_listen(tBTA_JV_RFC_CB *p_cb)
+{
+    UINT8   i, listen=1;
+    tBTA_JV_PCB *p_pcb;
+
+    if (p_cb->max_sess > 1)
+    {
+        listen = 0;
+        for (i=0; i<p_cb->max_sess; i++)
+        {
+            if (p_cb->rfc_hdl[i] != 0)
+            {
+                p_pcb = &bta_jv_cb.port_cb[p_cb->rfc_hdl[i] - 1];
+                if (BTA_JV_ST_SR_LISTEN == p_pcb->state)
+                {
+                    listen++;
+                }
+            }
+        }
+    }
+    return listen;
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_port_mgmt_sr_cback
+**
+** Description  callback for port mamangement function of rfcomm
+**              server connections
+**
+** Returns      void
+**
+*******************************************************************************/
+static void bta_jv_port_mgmt_sr_cback(UINT32 code, UINT16 port_handle)
+{
+    tBTA_JV_PCB     *p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
+    tBTA_JV_RFC_CB  *p_cb = bta_jv_rfc_port_to_cb(port_handle);
+    tBTA_JV evt_data;
+    BD_ADDR rem_bda;
+    UINT16 lcid;
+    UINT8  num;
+    tBTA_JV_RFCOMM_CBACK    *p_cback;
+    UINT32  si;
+
+    if(NULL == p_cb || NULL == p_cb->p_cback)
+        return;
+    void *user_data = p_pcb->user_data;
+    APPL_TRACE_DEBUG4( "bta_jv_port_mgmt_sr_cback code=%d port_handle:%d handle:%d/0x%x",
+        code, port_handle, p_cb->handle, p_pcb->handle);
+
+    PORT_CheckConnection(port_handle, rem_bda, &lcid);
+    int failed = TRUE;
+    if(code == PORT_SUCCESS)
+    {
+        evt_data.rfc_srv_open.handle = p_pcb->handle;
+        evt_data.rfc_srv_open.status = BTA_JV_SUCCESS;
+        bdcpy(evt_data.rfc_open.rem_bda, rem_bda);
+        p_pcb->state = BTA_JV_ST_SR_OPEN;
+        tBTA_JV_PCB *p_pcb_new_listen  = bta_jv_add_rfc_port(p_cb);
+        if(p_pcb_new_listen)
+        {
+            evt_data.rfc_srv_open.new_listen_handle = p_pcb_new_listen->handle;
+            p_pcb_new_listen->user_data = p_cb->p_cback(BTA_JV_RFCOMM_SRV_OPEN_EVT, &evt_data, user_data);
+            failed = FALSE;
+        }
+        else error("bta_jv_add_rfc_port failed to create new listen port");
+    }
+    if(failed)
+    {
+        evt_data.rfc_close.handle = p_cb->handle;
+        evt_data.rfc_close.status = BTA_JV_SUCCESS;
+        evt_data.rfc_close.async = TRUE;
+        if(BTA_JV_ST_SR_CLOSING == p_pcb->state)
+        {
+            evt_data.rfc_close.async = FALSE;
+        }
+        p_pcb->state = BTA_JV_ST_SR_LISTEN;
+        p_pcb->cong = FALSE;
+        p_cback = p_cb->p_cback;
+        num = bta_jv_get_num_rfc_listen(p_cb);
+        APPL_TRACE_DEBUG1( "num:%d",num);
+        if (num > 1)
+        {
+            APPL_TRACE_DEBUG1( "removing rfc handle:0x%x", p_pcb->handle);
+            si = BTA_JV_RFC_HDL_TO_SIDX(p_pcb->handle);
+            p_cb->rfc_hdl[si] = 0;
+            p_pcb->state = BTA_JV_ST_NONE;
+            p_pcb->handle = 0;
+            RFCOMM_RemoveServer(port_handle);
+        }
+        evt_data.rfc_close.port_status = code;
+        p_cback(BTA_JV_RFCOMM_CLOSE_EVT, &evt_data, user_data);
+    }
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_port_event_sr_cback
+**
+** Description  Callback for RFCOMM server port events
+**
+** Returns      void
+**
+*******************************************************************************/
+static void bta_jv_port_event_sr_cback(UINT32 code, UINT16 port_handle)
+{
+    tBTA_JV_PCB     *p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
+    tBTA_JV_RFC_CB  *p_cb = bta_jv_rfc_port_to_cb(port_handle);
+    tBTA_JV evt_data;
+
+    if(NULL == p_cb || NULL == p_cb->p_cback)
+        return;
+
+    APPL_TRACE_DEBUG3( "bta_jv_port_event_sr_cback code=x%x port_handle:%d handle:%d",
+        code, port_handle, p_cb->handle);
+
+    void *user_data = p_pcb->user_data;
+    if (code & PORT_EV_RXCHAR)
+    {
+        evt_data.data_ind.handle = p_cb->handle;
+        p_cb->p_cback(BTA_JV_RFCOMM_DATA_IND_EVT, &evt_data, user_data);
+    }
+
+    if (code & PORT_EV_FC)
+    {
+        p_pcb->cong = (code & PORT_EV_FCS) ? FALSE : TRUE;
+        evt_data.rfc_cong.cong = p_pcb->cong;
+        evt_data.rfc_cong.handle = p_cb->handle;
+        evt_data.rfc_cong.status = BTA_JV_SUCCESS;
+        p_cb->p_cback(BTA_JV_RFCOMM_CONG_EVT, &evt_data, user_data);
+    }
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_add_rfc_port
+**
+** Description  add a port for server when the existing posts is open
+**
+** Returns   return a pointer to tBTA_JV_PCB just added
+**
+*******************************************************************************/
+static tBTA_JV_PCB * bta_jv_add_rfc_port(tBTA_JV_RFC_CB *p_cb)
+{
+    UINT8   used = 0, i, listen=0;
+    UINT32  si = 0;
+    tBTA_JV_PCB *p_pcb = NULL;
+    tPORT_STATE port_state;
+    UINT32 event_mask = (PORT_EV_RXCHAR | PORT_EV_FC | PORT_EV_FCS);
+
+    if (p_cb->max_sess > 1)
+    {
+        for (i=0; i<p_cb->max_sess; i++)
+        {
+            if (p_cb->rfc_hdl[i] != 0)
+            {
+                p_pcb = &bta_jv_cb.port_cb[p_cb->rfc_hdl[i] - 1];
+                if (p_pcb->state == BTA_JV_ST_SR_LISTEN)
+                    listen++;
+                used++;
+            }
+            else if (si==0)
+            {
+                si = (UINT32)(i + 1);
+            }
+        }
+
+        debug("bta_jv_add_rfc_port max_sess=%d used:%d listen:%d si:%d",
+                    p_cb->max_sess, used, listen, si);
+        if (used <p_cb->max_sess && listen==0 && si)
+        {
+            si--;
+            if (RFCOMM_CreateConnection(p_cb->sec_id, p_cb->scn, TRUE,
+                BTA_JV_DEF_RFC_MTU, (UINT8 *) bd_addr_any, &(p_cb->rfc_hdl[si]), bta_jv_port_mgmt_sr_cback) == PORT_SUCCESS)
+            {
+                p_pcb = &bta_jv_cb.port_cb[p_cb->rfc_hdl[si] - 1];
+                p_pcb->state = BTA_JV_ST_SR_LISTEN;
+                p_pcb->port_handle = p_cb->rfc_hdl[si];
+                PORT_SetEventCallback(p_pcb->port_handle, bta_jv_port_event_sr_cback);
+                PORT_SetDataCOCallback (p_pcb->port_handle, bta_jv_port_data_co_cback);
+                PORT_SetEventMask(p_pcb->port_handle, event_mask);
+                PORT_GetState(p_pcb->port_handle, &port_state);
+
+                port_state.fc_type = (PORT_FC_CTS_ON_INPUT | PORT_FC_CTS_ON_OUTPUT);
+
+/* coverity[uninit_use_in_call]
+FALSE-POSITIVE: port_state is initialized at PORT_GetState() */
+                PORT_SetState(p_pcb->port_handle, &port_state);
+                p_pcb->handle = BTA_JV_RFC_H_S_TO_HDL(p_cb->handle, si);
+                APPL_TRACE_DEBUG1( "new rfc handle:0x%x", p_pcb->handle);
+            }
+        }
+    }
+    return p_pcb;
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_rfcomm_start_server
+**
+** Description  waits for an RFCOMM client to connect
+**
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_rfcomm_start_server(tBTA_JV_MSG *p_data)
+{
+    UINT16 handle = 0;
+    UINT32 event_mask = (PORT_EV_RXCHAR | PORT_EV_FC | PORT_EV_FCS);
+    tPORT_STATE port_state;
+    UINT8   sec_id;
+    tBTA_JV_RFC_CB  *p_cb = NULL;
+    tBTA_JV_PCB     *p_pcb;
+    tBTA_JV_API_RFCOMM_SERVER *rs = &(p_data->rfcomm_server);
+    tBTA_JV_RFCOMM_START        evt_data;
+
+    /* TODO DM role manager
+    L2CA_SetDesireRole(rs->role);
+    */
+    evt_data.status = BTA_JV_FAILURE;
+    do
+    {
+        sec_id = bta_jv_alloc_sec_id();
+
+        if (0 == sec_id ||
+            BTM_SetSecurityLevel(FALSE, "JV PORT", sec_id,  rs->sec_mask,
+                BT_PSM_RFCOMM, BTM_SEC_PROTO_RFCOMM, rs->local_scn) == FALSE)
+        {
+            break;
+        }
+
+        if (RFCOMM_CreateConnection(sec_id, rs->local_scn, TRUE,
+            BTA_JV_DEF_RFC_MTU, (UINT8 *) bd_addr_any, &handle, bta_jv_port_mgmt_sr_cback) != PORT_SUCCESS)
+        {
+            break;
+        }
+
+        p_cb = bta_jv_alloc_rfc_cb(handle, &p_pcb);
+        p_cb->max_sess = rs->max_session;
+        p_cb->p_cback = rs->p_cback;
+        p_cb->sec_id = sec_id;
+        p_cb->scn = rs->local_scn;
+        p_pcb->state = BTA_JV_ST_SR_LISTEN;
+        p_pcb->user_data = rs->user_data;
+        evt_data.status = BTA_JV_SUCCESS;
+        evt_data.handle = p_cb->handle;
+        evt_data.sec_id = sec_id;
+        evt_data.use_co = TRUE; //FALSE;
+
+        PORT_SetEventCallback(handle, bta_jv_port_event_sr_cback);
+        PORT_SetEventMask(handle, event_mask);
+        PORT_GetState(handle, &port_state);
+
+        port_state.fc_type = (PORT_FC_CTS_ON_INPUT | PORT_FC_CTS_ON_OUTPUT);
+
+/* coverity[uninit_use_in_call]
+FALSE-POSITIVE: port_state is initialized at PORT_GetState() */
+        PORT_SetState(handle, &port_state);
+    } while (0);
+
+    rs->p_cback(BTA_JV_RFCOMM_START_EVT, (tBTA_JV *)&evt_data, rs->user_data);
+    if(evt_data.status == BTA_JV_SUCCESS)
+    {
+        PORT_SetDataCOCallback (handle, bta_jv_port_data_co_cback);
+    }
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_rfcomm_stop_server
+**
+** Description  stops an RFCOMM server
+**
+** Returns      void
+**
+*******************************************************************************/
+
+void bta_jv_rfcomm_stop_server(tBTA_JV_MSG *p_data)
+{
+    tBTA_JV_RFCOMM_CLOSE  evt_data;
+    int i;
+    tBTA_JV_API_RFCOMM_SERVER *ls = &(p_data->rfcomm_server);
+    HDL2CB(ls->rfc_handle);
+    evt_data.status = BTA_JV_FAILURE;
+    if(p_cb && p_pcb)
+    {
+        evt_data.handle = p_cb->handle;
+        void* user_data = p_pcb->user_data;
+        evt_data.status = bta_jv_free_rfc_listen_cb(p_cb);
+        evt_data.async = FALSE;
+
+        /* occasionally when shutting down stack the callback is already
+           freed, hence make sure we check for this condition (pending investigatation
+           of rootcause) */
+        debug("send BTA_JV_RFCOMM_CLOSE_EVT");
+        if( p_cb->p_cback)
+             p_cb->p_cback(BTA_JV_RFCOMM_CLOSE_EVT, (tBTA_JV *)&evt_data, user_data);
+    }
+    else
+    {
+        debug("warning, no jv callback set");
+    }
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_rfcomm_read
+**
+** Description  Read data from an RFCOMM connection
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_rfcomm_read(tBTA_JV_MSG *p_data)
+{
+    tBTA_JV_API_RFCOMM_READ *rc = &(p_data->rfcomm_read);
+    tBTA_JV_RFC_CB  *p_cb = rc->p_cb;
+    tBTA_JV_PCB     *p_pcb = rc->p_pcb;
+    tBTA_JV_RFCOMM_READ    evt_data;
+
+    evt_data.status = BTA_JV_FAILURE;
+    evt_data.handle = p_cb->handle;
+    evt_data.req_id = rc->req_id;
+    evt_data.p_data = rc->p_data;
+    if (PORT_ReadData(rc->p_pcb->port_handle, (char *)rc->p_data, rc->len, &evt_data.len) ==
+        PORT_SUCCESS)
+    {
+        evt_data.status = BTA_JV_SUCCESS;
+    }
+
+    p_cb->p_cback(BTA_JV_RFCOMM_READ_EVT, (tBTA_JV *)&evt_data, p_pcb->user_data);
+}
+
+/*******************************************************************************
+**
+** Function     bta_jv_rfcomm_write
+**
+** Description  write data to an RFCOMM connection
+**
+** Returns      void
+**
+*******************************************************************************/
+void bta_jv_rfcomm_write(tBTA_JV_MSG *p_data)
+{
+    tBTA_JV_API_RFCOMM_WRITE *wc = &(p_data->rfcomm_write);
+    tBTA_JV_RFC_CB  *p_cb = wc->p_cb;
+    tBTA_JV_PCB     *p_pcb = wc->p_pcb;
+    tBTA_JV_RFCOMM_WRITE    evt_data;
+
+    evt_data.status = BTA_JV_FAILURE;
+    evt_data.handle = p_cb->handle;
+    evt_data.req_id = wc->req_id;
+    evt_data.cong   = p_pcb->cong;
+    evt_data.len    = 0;
+    if (!evt_data.cong &&
+        PORT_WriteDataCO(p_pcb->port_handle, &evt_data.len) ==
+        PORT_SUCCESS)
+    {
+        evt_data.status = BTA_JV_SUCCESS;
+    }
+    //update congestion flag
+    evt_data.cong   = p_pcb->cong;
+    if (p_cb->p_cback)
+    {
+        p_cb->p_cback(BTA_JV_RFCOMM_WRITE_EVT, (tBTA_JV *)&evt_data, p_pcb->user_data);
+    }
+    else
+    {
+        APPL_TRACE_ERROR0("bta_jv_rfcomm_write :: WARNING ! No JV callback set");
+    }
+}
+
diff --git a/bta/jv/bta_jv_api.c b/bta/jv/bta_jv_api.c
new file mode 100755
index 0000000..fd1c3d3
--- /dev/null
+++ b/bta/jv/bta_jv_api.c
@@ -0,0 +1,1572 @@
+/*****************************************************************************
+**
+**  Name:           bta_jv_api.c
+**
+**  Description:    This is the implementation of the JAVA API for
+**                  Bluetooth Wireless Technology (JABWT)
+**                    as specified by the JSR82 specificiation
+**
+**  Copyright (c) 2006-2009, Broadcom Corp., All Rights Reserved.
+**  WIDCOMM Bluetooth Core. Proprietary and confidential.
+**
+*****************************************************************************/
+
+#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);
+}
+
diff --git a/bta/jv/bta_jv_cfg.c b/bta/jv/bta_jv_cfg.c
new file mode 100755
index 0000000..b37d5de
--- /dev/null
+++ b/bta/jv/bta_jv_cfg.c
@@ -0,0 +1,45 @@
+/*****************************************************************************
+**
+**  Name:           bta_jv_cfg.c
+**
+**  Description:    This file contains compile-time configurable constants
+**                  for advanced audio
+**
+**  Copyright (c) 2004, Widcomm Inc., All Rights Reserved.
+**  Widcomm Bluetooth Core. Proprietary and confidential.
+**
+*****************************************************************************/
+
+#include "gki.h"
+#include "bta_api.h"
+#include "bd.h"
+#include "bta_jv_api.h"
+
+#ifndef BTA_JV_SDP_DB_SIZE
+#define BTA_JV_SDP_DB_SIZE          4500
+#endif
+
+#ifndef BTA_JV_SDP_RAW_DATA_SIZE
+#define BTA_JV_SDP_RAW_DATA_SIZE    1800
+#endif
+
+/* The platform may choose to use dynamic memory for these data buffers.
+ * p_bta_jv_cfg->p_sdp_db must be allocated/stay allocated
+ * between BTA_JvEnable and BTA_JvDisable
+ * p_bta_jv_cfg->p_sdp_raw_data can be allocated before calling BTA_JvStartDiscovery
+ * it can be de-allocated after the last call to access the database */
+static UINT8 bta_jv_sdp_raw_data[BTA_JV_SDP_RAW_DATA_SIZE];
+static UINT8 bta_jv_sdp_db_data[BTA_JV_SDP_DB_SIZE];
+
+/* JV configuration structure */
+const tBTA_JV_CFG bta_jv_cfg =
+{
+    BTA_JV_SDP_RAW_DATA_SIZE,   /* The size of p_sdp_raw_data */
+    BTA_JV_SDP_DB_SIZE,         /* The size of p_sdp_db_data */
+    bta_jv_sdp_raw_data,        /* The data buffer to keep raw data */
+    (tSDP_DISCOVERY_DB *)bta_jv_sdp_db_data /* The data buffer to keep SDP database */
+};
+
+tBTA_JV_CFG *p_bta_jv_cfg = (tBTA_JV_CFG *) &bta_jv_cfg;
+
+
diff --git a/bta/jv/bta_jv_int.h b/bta/jv/bta_jv_int.h
new file mode 100755
index 0000000..7a18ea2
--- /dev/null
+++ b/bta/jv/bta_jv_int.h
@@ -0,0 +1,448 @@
+/*****************************************************************************
+**
+**  Name:           bta_jv_int.h
+**
+**  Description:    This is the private interface file for the BTA Java I/F
+**
+**  Copyright (c) 2006-2009, Broadcom Corp., All Rights Reserved.
+**  Widcomm Bluetooth Core. Proprietary and confidential.
+**
+*****************************************************************************/
+#ifndef BTA_JV_INT_H
+#define BTA_JV_INT_H
+
+#include "bta_sys.h"
+#include "bta_api.h"
+#include "bta_jv_api.h"
+#include "rfcdefs.h"
+
+/*****************************************************************************
+**  Constants
+*****************************************************************************/
+
+enum
+{
+    /* these events are handled by the state machine */
+    BTA_JV_API_ENABLE_EVT = BTA_SYS_EVT_START(BTA_ID_JV),
+    BTA_JV_API_DISABLE_EVT,
+    BTA_JV_API_SET_DISCOVERABILITY_EVT,
+    BTA_JV_API_GET_LOCAL_DEVICE_ADDR_EVT,
+    BTA_JV_API_GET_LOCAL_DEVICE_NAME_EVT,
+    BTA_JV_API_GET_REMOTE_DEVICE_NAME_EVT,
+    BTA_JV_API_SET_SERVICE_CLASS_EVT,
+    BTA_JV_API_SET_ENCRYPTION_EVT,
+    BTA_JV_API_GET_SCN_EVT,
+    BTA_JV_API_FREE_SCN_EVT,
+    BTA_JV_API_START_DISCOVERY_EVT,
+    BTA_JV_API_CANCEL_DISCOVERY_EVT,
+    BTA_JV_API_GET_SERVICES_LENGTH_EVT,
+    BTA_JV_API_SERVICE_SELECT_EVT,
+    BTA_JV_API_CREATE_RECORD_EVT,
+    BTA_JV_API_UPDATE_RECORD_EVT,
+    BTA_JV_API_ADD_ATTRIBUTE_EVT,
+    BTA_JV_API_DELETE_ATTRIBUTE_EVT,
+    BTA_JV_API_DELETE_RECORD_EVT,
+    BTA_JV_API_L2CAP_CONNECT_EVT,
+    BTA_JV_API_L2CAP_CLOSE_EVT,
+    BTA_JV_API_L2CAP_START_SERVER_EVT,
+    BTA_JV_API_L2CAP_STOP_SERVER_EVT,
+    BTA_JV_API_L2CAP_READ_EVT,
+    BTA_JV_API_L2CAP_WRITE_EVT,
+    BTA_JV_API_RFCOMM_CONNECT_EVT,
+    BTA_JV_API_RFCOMM_CLOSE_EVT,
+    BTA_JV_API_RFCOMM_START_SERVER_EVT,
+    BTA_JV_API_RFCOMM_STOP_SERVER_EVT,
+    BTA_JV_API_RFCOMM_READ_EVT,
+    BTA_JV_API_RFCOMM_WRITE_EVT,
+    BTA_JV_MAX_INT_EVT
+};
+
+/* data type for BTA_JV_API_ENABLE_EVT */
+typedef struct
+{
+    BT_HDR          hdr;
+    tBTA_JV_DM_CBACK   *p_cback;
+} tBTA_JV_API_ENABLE;
+
+/* data type for BTA_JV_API_SET_DISCOVERABILITY_EVT */
+typedef struct
+{
+    BT_HDR              hdr;
+    tBTA_JV_DISC    disc_mode;
+} tBTA_JV_API_SET_DISCOVERABILITY;
+
+
+/* data type for BTA_JV_API_SET_SERVICE_CLASS_EVT */
+typedef struct
+{
+    BT_HDR      hdr;
+    UINT32      service;
+} tBTA_JV_API_SET_SERVICE_CLASS;
+
+/* data type for BTA_JV_API_SET_ENCRYPTION_EVT */
+typedef struct
+{
+    BT_HDR      hdr;
+    BD_ADDR     bd_addr;
+} tBTA_JV_API_SET_ENCRYPTION;
+
+/* data type for BTA_JV_API_GET_REMOTE_DEVICE_NAME_EVT */
+typedef struct
+{
+    BT_HDR      hdr;
+    BD_ADDR     bd_addr;
+} tBTA_JV_API_GET_REMOTE_NAME;
+
+/* data type for BTA_JV_API_START_DISCOVERY_EVT */
+typedef struct
+{
+    BT_HDR      hdr;
+    BD_ADDR bd_addr;
+    UINT16 num_uuid;
+    tSDP_UUID uuid_list[BTA_JV_MAX_UUIDS];
+    UINT16 num_attr;
+    UINT16 attr_list[BTA_JV_MAX_ATTRS];
+    void            *user_data;      /* piggyback caller's private data*/
+} tBTA_JV_API_START_DISCOVERY;
+
+/* data type for BTA_JV_API_CANCEL_DISCOVERY_EVT */
+typedef struct
+{
+    BT_HDR      hdr;
+    void            *user_data;      /* piggyback caller's private data*/
+} tBTA_JV_API_CANCEL_DISCOVERY;
+
+
+/* data type for BTA_JV_API_GET_SERVICES_LENGTH_EVT */
+typedef struct
+{
+    BT_HDR      hdr;
+    UINT16      *p_services_len;
+    BOOLEAN     inc_hdr;
+} tBTA_JV_API_GET_SERVICES_LENGTH;
+
+/* data type for BTA_JV_API_GET_SERVICE_RESULT_EVT */
+typedef struct
+{
+    BT_HDR      hdr;
+    UINT8        **TLVs;
+} tBTA_JV_API_GET_SERVICE_RESULT;
+
+/* data type for BTA_JV_API_SERVICE_SELECT_EVT */
+typedef struct
+{
+    BT_HDR      hdr;
+    UINT16        uuid;
+} tBTA_JV_API_SERVICE_SELECT;
+
+enum
+{
+    BTA_JV_ST_NONE = 0,
+    BTA_JV_ST_CL_OPENING,
+    BTA_JV_ST_CL_OPEN,
+    BTA_JV_ST_CL_CLOSING,
+    BTA_JV_ST_SR_LISTEN,
+    BTA_JV_ST_SR_OPEN,
+    BTA_JV_ST_SR_CLOSING
+} ;
+typedef UINT8  tBTA_JV_STATE;
+#define BTA_JV_ST_CL_MAX    BTA_JV_ST_CL_CLOSING
+
+/* JV L2CAP control block */
+typedef struct
+{
+    tBTA_JV_L2CAP_CBACK *p_cback;   /* the callback function */
+    UINT16              psm;        /* the psm used for this server connection */
+    tBTA_JV_STATE       state;      /* the state of this control block */
+    tBTA_SERVICE_ID     sec_id;     /* service id */
+    UINT16              handle;     /* the handle reported to java app (same as gap handle) */
+    BOOLEAN             cong;       /* TRUE, if congested */
+} tBTA_JV_L2C_CB;
+
+#define BTA_JV_RFC_HDL_MASK         0xFF
+#define BTA_JV_RFC_HDL_TO_SIDX(r)   (((r)&0xFF00) >> 8)
+#define BTA_JV_RFC_H_S_TO_HDL(h, s) ((h)|(s<<8))
+
+/* port control block */
+typedef struct
+{
+    UINT32              handle;     /* the rfcomm session handle at jv */
+    UINT16              port_handle; /* port handle */
+    tBTA_JV_STATE       state;      /* the state of this control block */
+    UINT8               max_sess;   /* max sessions */
+    void                *user_data; /* piggyback caller's private data*/
+    BOOLEAN             cong;       /* TRUE, if congested */
+} tBTA_JV_PCB;
+
+/* JV RFCOMM control block */
+typedef struct
+{
+    tBTA_JV_RFCOMM_CBACK *p_cback;  /* the callback function */
+    UINT16              rfc_hdl[BTA_JV_MAX_RFC_SR_SESSION];
+    tBTA_SERVICE_ID     sec_id;     /* service id */
+    UINT8               handle;     /* index: the handle reported to java app */
+    UINT8               scn;        /* the scn of the server */
+    UINT8               max_sess;   /* max sessions */
+} tBTA_JV_RFC_CB;
+
+/* data type for BTA_JV_API_L2CAP_CONNECT_EVT */
+typedef struct
+{
+    BT_HDR          hdr;
+    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_API_L2CAP_CONNECT;
+
+/* data type for BTA_JV_API_L2CAP_SERVER_EVT */
+typedef struct
+{
+    BT_HDR              hdr;
+    tBTA_SEC            sec_mask;
+    tBTA_JV_ROLE        role;
+    UINT16              local_psm;
+    UINT16              rx_mtu;
+    tBTA_JV_L2CAP_CBACK *p_cback;
+} tBTA_JV_API_L2CAP_SERVER;
+
+/* data type for BTA_JV_API_L2CAP_CLOSE_EVT */
+typedef struct
+{
+    BT_HDR          hdr;
+    UINT16          handle;
+    tBTA_JV_L2C_CB  *p_cb;
+} tBTA_JV_API_L2CAP_CLOSE;
+
+/* data type for BTA_JV_API_L2CAP_READ_EVT */
+typedef struct
+{
+    BT_HDR              hdr;
+    UINT16              handle;
+    UINT32              req_id;
+    tBTA_JV_L2CAP_CBACK *p_cback;
+    UINT8*              p_data;
+    UINT16              len;
+} tBTA_JV_API_L2CAP_READ;
+
+/* data type for BTA_JV_API_L2CAP_WRITE_EVT */
+typedef struct
+{
+    BT_HDR              hdr;
+    UINT16              handle;
+    UINT32              req_id;
+    tBTA_JV_L2C_CB      *p_cb;
+    UINT8               *p_data;
+    UINT16              len;
+} tBTA_JV_API_L2CAP_WRITE;
+
+/* data type for BTA_JV_API_RFCOMM_CONNECT_EVT */
+typedef struct
+{
+    BT_HDR          hdr;
+    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_API_RFCOMM_CONNECT;
+
+/* data type for BTA_JV_API_RFCOMM_SERVER_EVT */
+typedef struct
+{
+    BT_HDR          hdr;
+    tBTA_SEC        sec_mask;
+    tBTA_JV_ROLE    role;
+    UINT8           local_scn;
+    UINT8           max_session;
+    int             rfc_handle;
+    tBTA_JV_RFCOMM_CBACK *p_cback;
+    void            *user_data;
+} tBTA_JV_API_RFCOMM_SERVER;
+
+/* data type for BTA_JV_API_RFCOMM_READ_EVT */
+typedef struct
+{
+    BT_HDR          hdr;
+    UINT16          handle;
+    UINT32          req_id;
+    UINT8           *p_data;
+    UINT16          len;
+    tBTA_JV_RFC_CB  *p_cb;
+    tBTA_JV_PCB     *p_pcb;
+} tBTA_JV_API_RFCOMM_READ;
+
+/* data type for BTA_JV_API_RFCOMM_WRITE_EVT */
+typedef struct
+{
+    BT_HDR          hdr;
+    UINT16          handle;
+    UINT32          req_id;
+    UINT8           *p_data;
+    int          len;
+    tBTA_JV_RFC_CB  *p_cb;
+    tBTA_JV_PCB     *p_pcb;
+} tBTA_JV_API_RFCOMM_WRITE;
+
+/* data type for BTA_JV_API_RFCOMM_CLOSE_EVT */
+typedef struct
+{
+    BT_HDR          hdr;
+    UINT16          handle;
+    tBTA_JV_RFC_CB  *p_cb;
+    tBTA_JV_PCB     *p_pcb;
+} tBTA_JV_API_RFCOMM_CLOSE;
+
+/* data type for BTA_JV_API_CREATE_RECORD_EVT */
+typedef struct
+{
+    BT_HDR      hdr;
+    void        *user_data;
+} tBTA_JV_API_CREATE_RECORD;
+
+/* data type for BTA_JV_API_UPDATE_RECORD_EVT */
+typedef struct
+{
+    BT_HDR      hdr;
+    UINT32      handle;
+    UINT16      *p_ids;
+    UINT8       **p_values;
+    INT32       *p_value_sizes;
+    INT32       array_len;
+} tBTA_JV_API_UPDATE_RECORD;
+
+/* data type for BTA_JV_API_ADD_ATTRIBUTE_EVT */
+typedef struct
+{
+    BT_HDR      hdr;
+    UINT32      handle;
+    UINT16      attr_id;
+    UINT8       *p_value;
+    INT32       value_size;
+} tBTA_JV_API_ADD_ATTRIBUTE;
+
+/* data type for BTA_JV_API_FREE_SCN_EVT */
+typedef struct
+{
+    BT_HDR      hdr;
+    UINT8       scn;
+} tBTA_JV_API_FREE_SCN;
+/* union of all data types */
+typedef union
+{
+    /* GKI event buffer header */
+    BT_HDR                          hdr;
+    tBTA_JV_API_ENABLE              enable;
+    tBTA_JV_API_SET_DISCOVERABILITY set_discoverability;
+    tBTA_JV_API_GET_REMOTE_NAME     get_rmt_name;
+    tBTA_JV_API_SET_SERVICE_CLASS   set_service;
+    tBTA_JV_API_SET_ENCRYPTION      set_encrypt;
+    tBTA_JV_API_START_DISCOVERY     start_discovery;
+    tBTA_JV_API_CANCEL_DISCOVERY    cancel_discovery;
+    tBTA_JV_API_GET_SERVICES_LENGTH get_services_length;
+    tBTA_JV_API_GET_SERVICE_RESULT  get_service_result;
+    tBTA_JV_API_SERVICE_SELECT      service_select;
+    tBTA_JV_API_FREE_SCN            free_scn;
+    tBTA_JV_API_CREATE_RECORD       create_record;
+    tBTA_JV_API_UPDATE_RECORD       update_record;
+    tBTA_JV_API_ADD_ATTRIBUTE       add_attr;
+    tBTA_JV_API_L2CAP_CONNECT       l2cap_connect;
+    tBTA_JV_API_L2CAP_READ          l2cap_read;
+    tBTA_JV_API_L2CAP_WRITE         l2cap_write;
+    tBTA_JV_API_L2CAP_CLOSE         l2cap_close;
+    tBTA_JV_API_L2CAP_SERVER        l2cap_server;
+    tBTA_JV_API_RFCOMM_CONNECT      rfcomm_connect;
+    tBTA_JV_API_RFCOMM_READ         rfcomm_read;
+    tBTA_JV_API_RFCOMM_WRITE        rfcomm_write;
+    tBTA_JV_API_RFCOMM_CLOSE        rfcomm_close;
+    tBTA_JV_API_RFCOMM_SERVER       rfcomm_server;
+} tBTA_JV_MSG;
+
+#if SDP_FOR_JV_INCLUDED == TRUE
+#define BTA_JV_L2C_FOR_SDP_HDL     GAP_MAX_CONNECTIONS
+#endif
+
+/* JV control block */
+typedef struct
+{
+#if SDP_FOR_JV_INCLUDED == TRUE
+    UINT32                  sdp_for_jv;     /* The SDP client connection handle */
+    UINT32                  sdp_data_size;  /* the data len */
+#endif
+    /* the SDP handle reported to JV user is the (index + 1) to sdp_handle[].
+     * if sdp_handle[i]==0, it's not used.
+     * otherwise sdp_handle[i] is the stack SDP handle. */
+    UINT32                  sdp_handle[BTA_JV_MAX_SDP_REC]; /* SDP records created */
+    UINT8                   *p_sel_raw_data;/* the raw data of last service select */
+    INT32                   sel_len;        /* the SDP record size of last service select */
+    tBTA_JV_DM_CBACK        *p_dm_cback;
+    tBTA_JV_L2C_CB          l2c_cb[BTA_JV_MAX_L2C_CONN];    /* index is GAP handle (index) */
+    tBTA_JV_RFC_CB          rfc_cb[BTA_JV_MAX_RFC_CONN];
+    tBTA_JV_PCB             port_cb[MAX_RFC_PORTS];         /* index of this array is the port_handle, */
+    UINT8                   sec_id[BTA_JV_NUM_SERVICE_ID];  /* service ID */
+    BOOLEAN                 scn[BTA_JV_MAX_SCN];            /* SCN allocated by java */
+    UINT8                   sdp_active;                     /* see BTA_JV_SDP_ACT_* */
+    tSDP_UUID               uuid;                           /* current uuid of sdp discovery*/
+    void                    *user_data;                     /* piggyback user data*/
+} tBTA_JV_CB;
+
+enum
+{
+    BTA_JV_SDP_ACT_NONE = 0,
+    BTA_JV_SDP_ACT_YES,     /* waiting for SDP result */
+    BTA_JV_SDP_ACT_CANCEL   /* waiting for cancel complete */
+};
+
+/* JV control block */
+#if BTA_DYNAMIC_MEMORY == FALSE
+extern tBTA_JV_CB bta_jv_cb;
+#else
+extern tBTA_JV_CB *bta_jv_cb_ptr;
+#define bta_jv_cb (*bta_jv_cb_ptr)
+#endif
+
+/* config struct */
+extern tBTA_JV_CFG *p_bta_jv_cfg;
+
+/* this is defined in stack/sdp. used by bta jv */
+extern UINT8 *sdpu_get_len_from_type (UINT8 *p, UINT8 type, UINT32 *p_len);
+
+extern BOOLEAN bta_jv_sm_execute(BT_HDR *p_msg);
+
+extern UINT32 bta_jv_get_sdp_handle(UINT32 sdp_id);
+extern void bta_jv_enable (tBTA_JV_MSG *p_data);
+extern void bta_jv_disable (tBTA_JV_MSG *p_data);
+extern void bta_jv_set_discoverability (tBTA_JV_MSG *p_data);
+extern void bta_jv_get_local_device_addr (tBTA_JV_MSG *p_data);
+extern void bta_jv_get_local_device_name (tBTA_JV_MSG *p_data);
+extern void bta_jv_get_remote_device_name (tBTA_JV_MSG *p_data);
+extern void bta_jv_set_service_class (tBTA_JV_MSG *p_data);
+extern void bta_jv_set_encryption (tBTA_JV_MSG *p_data);
+extern void bta_jv_get_scn (tBTA_JV_MSG *p_data);
+extern void bta_jv_free_scn (tBTA_JV_MSG *p_data);
+extern void bta_jv_start_discovery (tBTA_JV_MSG *p_data);
+extern void bta_jv_cancel_discovery (tBTA_JV_MSG *p_data);
+extern void bta_jv_get_services_length (tBTA_JV_MSG *p_data);
+extern void bta_jv_service_select (tBTA_JV_MSG *p_data);
+extern void bta_jv_create_record (tBTA_JV_MSG *p_data);
+extern void bta_jv_update_record (tBTA_JV_MSG *p_data);
+extern void bta_jv_add_attribute (tBTA_JV_MSG *p_data);
+extern void bta_jv_delete_attribute (tBTA_JV_MSG *p_data);
+extern void bta_jv_delete_record (tBTA_JV_MSG *p_data);
+extern void bta_jv_l2cap_connect (tBTA_JV_MSG *p_data);
+extern void bta_jv_l2cap_close (tBTA_JV_MSG *p_data);
+extern void bta_jv_l2cap_start_server (tBTA_JV_MSG *p_data);
+extern void bta_jv_l2cap_stop_server (tBTA_JV_MSG *p_data);
+extern void bta_jv_l2cap_read (tBTA_JV_MSG *p_data);
+extern void bta_jv_l2cap_write (tBTA_JV_MSG *p_data);
+extern void bta_jv_rfcomm_connect (tBTA_JV_MSG *p_data);
+extern void bta_jv_rfcomm_close (tBTA_JV_MSG *p_data);
+extern void bta_jv_rfcomm_start_server (tBTA_JV_MSG *p_data);
+extern void bta_jv_rfcomm_stop_server (tBTA_JV_MSG *p_data);
+extern void bta_jv_rfcomm_read (tBTA_JV_MSG *p_data);
+extern void bta_jv_rfcomm_write (tBTA_JV_MSG *p_data);
+
+#endif /* BTA_JV_INT_H */
diff --git a/bta/jv/bta_jv_main.c b/bta/jv/bta_jv_main.c
new file mode 100755
index 0000000..6c97b17
--- /dev/null
+++ b/bta/jv/bta_jv_main.c
@@ -0,0 +1,91 @@
+/*****************************************************************************
+**
+**  Name:           bta_jv_main.c
+**
+**  Description:    This is the main implementation file for the BTA
+**                  Java I/F
+**
+**  Copyright (c) 2006,
+**  Widcomm Bluetooth Core. Proprietary and confidential.
+**
+*****************************************************************************/
+
+#include "bta_api.h"
+#include "bta_sys.h"
+#include "bta_jv_api.h"
+#include "bta_jv_int.h"
+
+/*****************************************************************************
+** Constants and types
+*****************************************************************************/
+
+#if BTA_DYNAMIC_MEMORY == FALSE
+tBTA_JV_CB bta_jv_cb;
+#endif
+
+/* state machine action enumeration list */
+#define BTA_JV_NUM_ACTIONS  (BTA_JV_MAX_INT_EVT & 0x00ff)
+
+/* type for action functions */
+typedef void (*tBTA_JV_ACTION)(tBTA_JV_MSG *p_data);
+
+/* action function list */
+const tBTA_JV_ACTION bta_jv_action[] =
+{
+    bta_jv_enable,                  /* BTA_JV_API_ENABLE_EVT */
+    bta_jv_disable,                 /* BTA_JV_API_DISABLE_EVT */
+    bta_jv_set_discoverability,     /* BTA_JV_API_SET_DISCOVERABILITY_EVT */
+    bta_jv_get_local_device_addr,   /* BTA_JV_API_GET_LOCAL_DEVICE_ADDR_EVT */
+    bta_jv_get_local_device_name,   /* BTA_JV_API_GET_LOCAL_DEVICE_NAME_EVT */
+    bta_jv_get_remote_device_name,  /* BTA_JV_API_GET_REMOTE_DEVICE_NAME_EVT */
+    bta_jv_set_service_class,       /* BTA_JV_API_SET_SERVICE_CLASS_EVT */
+    bta_jv_set_encryption,          /* BTA_JV_API_SET_ENCRYPTION_EVT */
+    bta_jv_get_scn,                 /* BTA_JV_API_GET_SCN_EVT */
+    bta_jv_free_scn,                /* BTA_JV_API_FREE_SCN_EVT */
+    bta_jv_start_discovery,         /* BTA_JV_API_START_DISCOVERY_EVT */
+    bta_jv_cancel_discovery,        /* BTA_JV_API_CANCEL_DISCOVERY_EVT */
+    bta_jv_get_services_length,     /* BTA_JV_API_GET_SERVICES_LENGTH_EVT */
+    bta_jv_service_select,          /* BTA_JV_API_SERVICE_SELECT_EVT */
+    bta_jv_create_record,           /* BTA_JV_API_CREATE_RECORD_EVT */
+    bta_jv_update_record,           /* BTA_JV_API_UPDATE_RECORD_EVT */
+    bta_jv_add_attribute,           /* BTA_JV_API_ADD_ATTRIBUTE_EVT */
+    bta_jv_delete_attribute,        /* BTA_JV_API_DELETE_ATTRIBUTE_EVT */
+    bta_jv_delete_record,           /* BTA_JV_API_DELETE_RECORD_EVT */
+    bta_jv_l2cap_connect,           /* BTA_JV_API_L2CAP_CONNECT_EVT */
+    bta_jv_l2cap_close,             /* BTA_JV_API_L2CAP_CLOSE_EVT */
+    bta_jv_l2cap_start_server,      /* BTA_JV_API_L2CAP_START_SERVER_EVT */
+    bta_jv_l2cap_stop_server,       /* BTA_JV_API_L2CAP_STOP_SERVER_EVT */
+    bta_jv_l2cap_read,              /* BTA_JV_API_L2CAP_READ_EVT */
+    bta_jv_l2cap_write,             /* BTA_JV_API_L2CAP_WRITE_EVT */
+    bta_jv_rfcomm_connect,          /* BTA_JV_API_RFCOMM_CONNECT_EVT */
+    bta_jv_rfcomm_close,            /* BTA_JV_API_RFCOMM_CLOSE_EVT */
+    bta_jv_rfcomm_start_server,     /* BTA_JV_API_RFCOMM_START_SERVER_EVT */
+    bta_jv_rfcomm_stop_server,      /* BTA_JV_API_RFCOMM_STOP_SERVER_EVT */
+    bta_jv_rfcomm_read,             /* BTA_JV_API_RFCOMM_READ_EVT */
+    bta_jv_rfcomm_write             /* BTA_JV_API_RFCOMM_WRITE_EVT */
+};
+
+/*******************************************************************************
+**
+** Function         bta_jv_sm_execute
+**
+** Description      State machine event handling function for JV
+**
+**
+** Returns          void
+**
+*******************************************************************************/
+BOOLEAN bta_jv_sm_execute(BT_HDR *p_msg)
+{
+    BOOLEAN ret = FALSE;
+    UINT16 action = (p_msg->event & 0x00ff);
+    /* execute action functions */
+
+    if(action < BTA_JV_NUM_ACTIONS)
+    {
+        (*bta_jv_action[action])((tBTA_JV_MSG*)p_msg);
+        ret = TRUE;
+    }
+
+    return(ret);
+}