bta/dm/bta_dm_api.cc

/******************************************************************************
 *
 *  Copyright (C) 2003-2014 Broadcom Corporation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at:
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 ******************************************************************************/

/******************************************************************************
 *
 *  This is the API implementation file for the BTA device manager.
 *
 ******************************************************************************/

#include "bt_common.h"
#include "bta_sys.h"
#include "bta_api.h"
#include "bta_closure_api.h"
#include "bta_dm_int.h"
#include "bta_sys_int.h"
#include "btm_api.h"
#include "btm_int.h"
#include "osi/include/osi.h"
#include <string.h>
#include "utl.h"

/*****************************************************************************
 *  Constants
 ****************************************************************************/

static const tBTA_SYS_REG bta_dm_reg =
{
    bta_dm_sm_execute,
    bta_dm_sm_disable
};

static const tBTA_SYS_REG bta_dm_search_reg =
{
    bta_dm_search_sm_execute,
    bta_dm_search_sm_disable
};

/*******************************************************************************
 *
 * Function         BTA_EnableBluetooth
 *
 * Description      Enables bluetooth service.  This function must be
 *                  called before any other functions in the BTA API are called.
 *
 *
 * Returns          tBTA_STATUS
 *
 ******************************************************************************/
tBTA_STATUS BTA_EnableBluetooth(tBTA_DM_SEC_CBACK *p_cback)
{
    /* Bluetooth disabling is in progress */
    if (bta_dm_cb.disabling)
        return BTA_FAILURE;

    bta_sys_register(BTA_ID_DM, &bta_dm_reg );
    bta_sys_register(BTA_ID_DM_SEARCH, &bta_dm_search_reg );

    /* if UUID list is not provided as static data */
    bta_sys_eir_register(bta_dm_eir_update_uuid);

    tBTA_DM_API_ENABLE *p_msg =
        (tBTA_DM_API_ENABLE *)osi_malloc(sizeof(tBTA_DM_API_ENABLE));
    p_msg->hdr.event = BTA_DM_API_ENABLE_EVT;
    p_msg->p_sec_cback = p_cback;

    bta_sys_sendmsg(p_msg);

    return BTA_SUCCESS;
}

/*******************************************************************************
 *
 * Function         BTA_DisableBluetooth
 *
 * Description      Disables bluetooth service.  This function is called when
 *                  the application no longer needs bluetooth service
 *
 * Returns          void
 *
 ******************************************************************************/
tBTA_STATUS BTA_DisableBluetooth(void)
{
    BT_HDR *p_msg = (BT_HDR *)osi_malloc(sizeof(BT_HDR));

    p_msg->event = BTA_DM_API_DISABLE_EVT;

    bta_sys_sendmsg(p_msg);

    return BTA_SUCCESS;
}

/*******************************************************************************
 *
 * Function         BTA_EnableTestMode
 *
 * Description      Enables bluetooth device under test mode
 *
 *
 * Returns          tBTA_STATUS
 *
 ******************************************************************************/
tBTA_STATUS BTA_EnableTestMode(void)
{
    BT_HDR *p_msg = (BT_HDR *)osi_malloc(sizeof(BT_HDR));

    APPL_TRACE_API("%s", __func__);

    p_msg->event = BTA_DM_API_ENABLE_TEST_MODE_EVT;
    bta_sys_sendmsg(p_msg);

    return BTA_SUCCESS;
}

/*******************************************************************************
 *
 * Function         BTA_DisableTestMode
 *
 * Description      Disable bluetooth device under test mode
 *
 *
 * Returns          None
 *
 ******************************************************************************/
void BTA_DisableTestMode(void)
{
    BT_HDR *p_msg = (BT_HDR *)osi_malloc(sizeof(BT_HDR));

    APPL_TRACE_API("%s", __func__);

    p_msg->event = BTA_DM_API_DISABLE_TEST_MODE_EVT;
    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmSetDeviceName
 *
 * Description      This function sets the Bluetooth name of local device
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmSetDeviceName(char *p_name)
{
    tBTA_DM_API_SET_NAME *p_msg =
        (tBTA_DM_API_SET_NAME *)osi_malloc(sizeof(tBTA_DM_API_SET_NAME));

    p_msg->hdr.event = BTA_DM_API_SET_NAME_EVT;
    strlcpy((char*)p_msg->name, p_name, BD_NAME_LEN);

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmSetVisibility
 *
 * Description      This function sets the Bluetooth connectable,
 *                  discoverable, pairable and conn paired only modes of local device
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmSetVisibility(tBTA_DM_DISC disc_mode, tBTA_DM_CONN conn_mode, uint8_t pairable_mode, uint8_t conn_filter )
{
    tBTA_DM_API_SET_VISIBILITY *p_msg =
        (tBTA_DM_API_SET_VISIBILITY *)osi_malloc(sizeof(tBTA_DM_MSG));

    p_msg->hdr.event = BTA_DM_API_SET_VISIBILITY_EVT;
    p_msg->disc_mode = disc_mode;
    p_msg->conn_mode = conn_mode;
    p_msg->pair_mode = pairable_mode;
    p_msg->conn_paired_only = conn_filter;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmSearch
 *
 * Description      This function searches for peer Bluetooth devices. It performs
 *                  an inquiry and gets the remote name for devices. Service
 *                  discovery is done if services is non zero
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmSearch(tBTA_DM_INQ *p_dm_inq, tBTA_SERVICE_MASK services, tBTA_DM_SEARCH_CBACK *p_cback)
{
    tBTA_DM_API_SEARCH *p_msg =
        (tBTA_DM_API_SEARCH *)osi_calloc(sizeof(tBTA_DM_API_SEARCH));

    p_msg->hdr.event = BTA_DM_API_SEARCH_EVT;
    memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ));
    p_msg->services = services;
    p_msg->p_cback = p_cback;
    p_msg->rs_res  = BTA_DM_RS_NONE;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmSearchCancel
 *
 * Description      This function  cancels a search initiated by BTA_DmSearch
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmSearchCancel(void)
{
    BT_HDR *p_msg = (BT_HDR *)osi_malloc(sizeof(BT_HDR));

    p_msg->event = BTA_DM_API_SEARCH_CANCEL_EVT;
    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmDiscover
 *
 * Description      This function does service discovery for services of a
 *                  peer device
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmDiscover(BD_ADDR bd_addr, tBTA_SERVICE_MASK services,
                    tBTA_DM_SEARCH_CBACK *p_cback, bool sdp_search)
{
    tBTA_DM_API_DISCOVER *p_msg =
        (tBTA_DM_API_DISCOVER *)osi_calloc(sizeof(tBTA_DM_API_DISCOVER));

    p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);
    p_msg->services = services;
    p_msg->p_cback = p_cback;
    p_msg->sdp_search = sdp_search;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmDiscoverUUID
 *
 * Description      This function does service discovery for services of a
 *                  peer device
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmDiscoverUUID(BD_ADDR bd_addr, tSDP_UUID *uuid,
                    tBTA_DM_SEARCH_CBACK *p_cback, bool sdp_search)
{
    tBTA_DM_API_DISCOVER *p_msg =
        (tBTA_DM_API_DISCOVER *)osi_malloc(sizeof(tBTA_DM_API_DISCOVER));

    p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);
    p_msg->services = BTA_USER_SERVICE_MASK; //Not exposed at API level
    p_msg->p_cback = p_cback;
    p_msg->sdp_search = sdp_search;

#if (BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE)
    p_msg->num_uuid = 0;
    p_msg->p_uuid = NULL;
#endif
    memcpy(&p_msg->uuid, uuid, sizeof(tSDP_UUID) );

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmBond
 *
 * Description      This function initiates a bonding procedure with a peer
 *                  device
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmBond(BD_ADDR bd_addr)
{
    tBTA_DM_API_BOND *p_msg =
        (tBTA_DM_API_BOND *)osi_malloc(sizeof(tBTA_DM_API_BOND));

    p_msg->hdr.event = BTA_DM_API_BOND_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);
    p_msg->transport = BTA_TRANSPORT_UNKNOWN;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmBondByTransports
 *
 * Description      This function initiates a bonding procedure with a peer
 *                  device
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmBondByTransport(BD_ADDR bd_addr, tBTA_TRANSPORT transport)
{
    tBTA_DM_API_BOND *p_msg =
        (tBTA_DM_API_BOND *)osi_malloc(sizeof(tBTA_DM_API_BOND));

    p_msg->hdr.event = BTA_DM_API_BOND_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);
    p_msg->transport = transport;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmBondCancel
 *
 * Description      This function cancels the bonding procedure with a peer
 *                  device
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmBondCancel(BD_ADDR bd_addr)
{
    tBTA_DM_API_BOND_CANCEL *p_msg =
        (tBTA_DM_API_BOND_CANCEL *)osi_malloc(sizeof(tBTA_DM_API_BOND_CANCEL));

    p_msg->hdr.event = BTA_DM_API_BOND_CANCEL_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmPinReply
 *
 * Description      This function provides a pincode for a remote device when
 *                  one is requested by DM through BTA_DM_PIN_REQ_EVT
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmPinReply(BD_ADDR bd_addr, bool accept, uint8_t pin_len, uint8_t *p_pin)

{
    tBTA_DM_API_PIN_REPLY *p_msg =
        (tBTA_DM_API_PIN_REPLY *)osi_malloc(sizeof(tBTA_DM_API_PIN_REPLY));

    p_msg->hdr.event = BTA_DM_API_PIN_REPLY_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);
    p_msg->accept = accept;
    if (accept) {
        p_msg->pin_len = pin_len;
        memcpy(p_msg->p_pin, p_pin, pin_len);
    }

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmLocalOob
 *
 * Description      This function retrieves the OOB data from local controller.
 *                  The result is reported by:
 *                  - bta_dm_co_loc_oob_ext() if device supports secure
 *                    connections (SC)
 *                  - bta_dm_co_loc_oob() if device doesn't support SC
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmLocalOob(void)
{
    tBTA_DM_API_LOC_OOB *p_msg =
        (tBTA_DM_API_LOC_OOB *)osi_malloc(sizeof(tBTA_DM_API_LOC_OOB));

    p_msg->hdr.event = BTA_DM_API_LOC_OOB_EVT;
    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmConfirm
 *
 * Description      This function accepts or rejects the numerical value of the
 *                  Simple Pairing process on BTA_DM_SP_CFM_REQ_EVT
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmConfirm(BD_ADDR bd_addr, bool accept)
{
    tBTA_DM_API_CONFIRM *p_msg =
        (tBTA_DM_API_CONFIRM *)osi_malloc(sizeof(tBTA_DM_API_CONFIRM));

    p_msg->hdr.event = BTA_DM_API_CONFIRM_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);
    p_msg->accept = accept;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmAddDevice
 *
 * Description      This function adds a device to the security database list of
 *                  peer device
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmAddDevice(BD_ADDR bd_addr, DEV_CLASS dev_class, LINK_KEY link_key,
                     tBTA_SERVICE_MASK trusted_mask, bool is_trusted,
                     uint8_t key_type, tBTA_IO_CAP io_cap, uint8_t pin_length)
{
    tBTA_DM_API_ADD_DEVICE *p_msg =
        (tBTA_DM_API_ADD_DEVICE *)osi_calloc(sizeof(tBTA_DM_API_ADD_DEVICE));

    p_msg->hdr.event = BTA_DM_API_ADD_DEVICE_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);
    p_msg->tm = trusted_mask;
    p_msg->is_trusted = is_trusted;
    p_msg->io_cap = io_cap;

    if (link_key) {
        p_msg->link_key_known = true;
        p_msg->key_type = key_type;
        memcpy(p_msg->link_key, link_key, LINK_KEY_LEN);
    }

    /* Load device class if specified */
    if (dev_class) {
        p_msg->dc_known = true;
        memcpy(p_msg->dc, dev_class, DEV_CLASS_LEN);
    }

    memset(p_msg->bd_name, 0, BD_NAME_LEN + 1);
    memset(p_msg->features, 0, sizeof (p_msg->features));
    p_msg->pin_length = pin_length;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmRemoveDevice
 *
 * Description      This function removes a device fromthe security database list of
 *                  peer device. It manages unpairing even while connected.
 *
 *
 * Returns          void
 *
 ******************************************************************************/
tBTA_STATUS BTA_DmRemoveDevice(BD_ADDR bd_addr)
{
    tBTA_DM_API_REMOVE_DEVICE *p_msg =
        (tBTA_DM_API_REMOVE_DEVICE *)osi_calloc(sizeof(tBTA_DM_API_REMOVE_DEVICE));

    p_msg->hdr.event = BTA_DM_API_REMOVE_DEVICE_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);

    bta_sys_sendmsg(p_msg);

    return BTA_SUCCESS;
}

/*******************************************************************************
 *
 * Function         BTA_GetEirService
 *
 * Description      This function is called to get BTA service mask from EIR.
 *
 * Parameters       p_eir - pointer of EIR significant part
 *                  p_services - return the BTA service mask
 *
 * Returns          None
 *
 ******************************************************************************/
extern const uint16_t bta_service_id_to_uuid_lkup_tbl [];
void BTA_GetEirService( uint8_t *p_eir, tBTA_SERVICE_MASK *p_services )
{
    uint8_t xx, yy;
    uint8_t num_uuid, max_num_uuid = 32;
    uint8_t uuid_list[32*LEN_UUID_16];
    uint16_t *p_uuid16 = (uint16_t *)uuid_list;
    tBTA_SERVICE_MASK mask;

    BTM_GetEirUuidList( p_eir, LEN_UUID_16, &num_uuid, uuid_list, max_num_uuid);
    for( xx = 0; xx < num_uuid; xx++ )
    {
        mask = 1;
        for( yy = 0; yy < BTA_MAX_SERVICE_ID; yy++ )
        {
            if( *(p_uuid16 + xx) == bta_service_id_to_uuid_lkup_tbl[yy] )
            {
                *p_services |= mask;
                break;
            }
            mask <<= 1;
        }

        /* for HSP v1.2 only device */
        if (*(p_uuid16 + xx) == UUID_SERVCLASS_HEADSET_HS)
            *p_services |= BTA_HSP_SERVICE_MASK;

       if (*(p_uuid16 + xx) == UUID_SERVCLASS_HDP_SOURCE)
            *p_services |= BTA_HL_SERVICE_MASK;

        if (*(p_uuid16 + xx) == UUID_SERVCLASS_HDP_SINK)
            *p_services |= BTA_HL_SERVICE_MASK;
    }
}

/*******************************************************************************
 *
 * Function         BTA_DmGetConnectionState
 *
 * Description      Returns whether the remote device is currently connected.
 *
 * Returns          0 if the device is NOT connected.
 *
 ******************************************************************************/
uint16_t BTA_DmGetConnectionState(const BD_ADDR bd_addr )
{
    tBTA_DM_PEER_DEVICE * p_dev = bta_dm_find_peer_device(bd_addr);
    return (p_dev && p_dev->conn_state == BTA_DM_CONNECTED);
}


/*******************************************************************************
 *                   Device Identification (DI) Server Functions
 ******************************************************************************/
/*******************************************************************************
 *
 * Function         BTA_DmSetLocalDiRecord
 *
 * Description      This function adds a DI record to the local SDP database.
 *
 * Returns          BTA_SUCCESS if record set sucessfully, otherwise error code.
 *
 ******************************************************************************/
tBTA_STATUS BTA_DmSetLocalDiRecord( tBTA_DI_RECORD *p_device_info,
                              uint32_t *p_handle )
{
    tBTA_STATUS  status = BTA_FAILURE;

    if(bta_dm_di_cb.di_num < BTA_DI_NUM_MAX)
    {
        if(SDP_SetLocalDiRecord((tSDP_DI_RECORD *)p_device_info, p_handle) == SDP_SUCCESS)
        {
            if(!p_device_info->primary_record)
            {
                bta_dm_di_cb.di_handle[bta_dm_di_cb.di_num] = *p_handle;
                bta_dm_di_cb.di_num ++;
            }

            bta_sys_add_uuid(UUID_SERVCLASS_PNP_INFORMATION);
            status =  BTA_SUCCESS;
        }
    }

    return status;
}

/*******************************************************************************
 *
 * Function         bta_dmexecutecallback
 *
 * Description      This function will request BTA to execute a call back in the context of BTU task
 *                  This API was named in lower case because it is only intended
 *                  for the internal customers(like BTIF).
 *
 * Returns          void
 *
 ******************************************************************************/
void bta_dmexecutecallback (tBTA_DM_EXEC_CBACK* p_callback, void * p_param)
{
    tBTA_DM_API_EXECUTE_CBACK *p_msg =
        (tBTA_DM_API_EXECUTE_CBACK *)osi_malloc(sizeof(tBTA_DM_MSG));

    p_msg->hdr.event = BTA_DM_API_EXECUTE_CBACK_EVT;
    p_msg->p_param= p_param;
    p_msg->p_exec_cback= p_callback;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmAddBleKey
 *
 * Description      Add/modify LE device information.  This function will be
 *                  normally called during host startup to restore all required
 *                  information stored in the NVRAM.
 *
 * Parameters:      bd_addr          - BD address of the peer
 *                  p_le_key         - LE key values.
 *                  key_type         - LE SMP key type.
 *
 * Returns          BTA_SUCCESS if successful
 *                  BTA_FAIL if operation failed.
 *
 ******************************************************************************/
void BTA_DmAddBleKey (BD_ADDR bd_addr, tBTA_LE_KEY_VALUE *p_le_key, tBTA_LE_KEY_TYPE key_type)
{
#if (BLE_INCLUDED == TRUE)

    tBTA_DM_API_ADD_BLEKEY *p_msg =
        (tBTA_DM_API_ADD_BLEKEY *)osi_calloc(sizeof(tBTA_DM_API_ADD_BLEKEY));

    p_msg->hdr.event = BTA_DM_API_ADD_BLEKEY_EVT;
    p_msg->key_type = key_type;
    bdcpy(p_msg->bd_addr, bd_addr);
    memcpy(&p_msg->blekey, p_le_key, sizeof(tBTA_LE_KEY_VALUE));

    bta_sys_sendmsg(p_msg);
#endif
}

/*******************************************************************************
 *
 * Function         BTA_DmAddBleDevice
 *
 * Description      Add a BLE device.  This function will be normally called
 *                  during host startup to restore all required information
 *                  for a LE device stored in the NVRAM.
 *
 * Parameters:      bd_addr          - BD address of the peer
 *                  dev_type         - Remote device's device type.
 *                  addr_type        - LE device address type.
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmAddBleDevice(BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type, tBT_DEVICE_TYPE dev_type)
{
#if (BLE_INCLUDED == TRUE)
    tBTA_DM_API_ADD_BLE_DEVICE *p_msg =
        (tBTA_DM_API_ADD_BLE_DEVICE *)osi_calloc(sizeof(tBTA_DM_API_ADD_BLE_DEVICE));

    p_msg->hdr.event = BTA_DM_API_ADD_BLEDEVICE_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);
    p_msg->addr_type = addr_type;
    p_msg->dev_type = dev_type;

    bta_sys_sendmsg(p_msg);
#endif
}

/*******************************************************************************
 *
 * Function         BTA_DmBlePasskeyReply
 *
 * Description      Send BLE SMP passkey reply.
 *
 * Parameters:      bd_addr          - BD address of the peer
 *                  accept           - passkey entry sucessful or declined.
 *                  passkey          - passkey value, must be a 6 digit number,
 *                                     can be lead by 0.
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmBlePasskeyReply(BD_ADDR bd_addr, bool accept, uint32_t passkey)
{
#if (BLE_INCLUDED == TRUE)
    tBTA_DM_API_PASSKEY_REPLY *p_msg =
        (tBTA_DM_API_PASSKEY_REPLY *)osi_calloc(sizeof(tBTA_DM_API_PASSKEY_REPLY));

    p_msg->hdr.event = BTA_DM_API_BLE_PASSKEY_REPLY_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);
    p_msg->accept = accept;

    if (accept)
        p_msg->passkey = passkey;

    bta_sys_sendmsg(p_msg);
#endif
}

/*******************************************************************************
 *
 * Function         BTA_DmBleConfirmReply
 *
 * Description      Send BLE SMP SC user confirmation reply.
 *
 * Parameters:      bd_addr          - BD address of the peer
 *                  accept           - numbers to compare are the same or different.
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmBleConfirmReply(BD_ADDR bd_addr, bool accept)
{
#if (BLE_INCLUDED == TRUE)
    tBTA_DM_API_CONFIRM *p_msg =
        (tBTA_DM_API_CONFIRM *)osi_calloc(sizeof(tBTA_DM_API_CONFIRM));

    p_msg->hdr.event = BTA_DM_API_BLE_CONFIRM_REPLY_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);
    p_msg->accept = accept;

    bta_sys_sendmsg(p_msg);
#endif
}

/*******************************************************************************
 *
 * Function         BTA_DmBleSecurityGrant
 *
 * Description      Grant security request access.
 *
 * Parameters:      bd_addr          - BD address of the peer
 *                  res              - security grant status.
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmBleSecurityGrant(BD_ADDR bd_addr, tBTA_DM_BLE_SEC_GRANT res)
{
#if (BLE_INCLUDED == TRUE)
    tBTA_DM_API_BLE_SEC_GRANT *p_msg =
        (tBTA_DM_API_BLE_SEC_GRANT *)osi_calloc(sizeof(tBTA_DM_API_BLE_SEC_GRANT));

    p_msg->hdr.event = BTA_DM_API_BLE_SEC_GRANT_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);
    p_msg->res = res;

    bta_sys_sendmsg(p_msg);
#endif
}

/*******************************************************************************
 *
 * Function         BTA_DmSetBlePrefConnParams
 *
 * Description      This function is called to set the preferred connection
 *                  parameters when default connection parameter is not desired.
 *
 * Parameters:      bd_addr          - BD address of the peripheral
 *                  scan_interval    - scan interval
 *                  scan_window      - scan window
 *                  min_conn_int     - minimum preferred connection interval
 *                  max_conn_int     - maximum preferred connection interval
 *                  slave_latency    - preferred slave latency
 *                  supervision_tout - preferred supervision timeout
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmSetBlePrefConnParams(const BD_ADDR bd_addr,
                               uint16_t min_conn_int, uint16_t max_conn_int,
                               uint16_t slave_latency, uint16_t supervision_tout )
{
#if (BLE_INCLUDED == TRUE)
    tBTA_DM_API_BLE_CONN_PARAMS *p_msg =
        (tBTA_DM_API_BLE_CONN_PARAMS *)osi_calloc(sizeof(tBTA_DM_API_BLE_CONN_PARAMS));

    p_msg->hdr.event = BTA_DM_API_BLE_CONN_PARAM_EVT;
    memcpy(p_msg->peer_bda, bd_addr, BD_ADDR_LEN);
    p_msg->conn_int_max = max_conn_int;
    p_msg->conn_int_min = min_conn_int;
    p_msg->slave_latency = slave_latency;
    p_msg->supervision_tout = supervision_tout;

    bta_sys_sendmsg(p_msg);
#endif
}

/*******************************************************************************
 *
 * Function         BTA_DmSetBleConnScanParams
 *
 * Description      This function is called to set scan parameters used in
 *                  BLE connection request
 *
 * Parameters:      scan_interval    - scan interval
 *                  scan_window      - scan window
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmSetBleConnScanParams(uint32_t scan_interval, uint32_t scan_window)
{
#if (BLE_INCLUDED == TRUE)
    tBTA_DM_API_BLE_SCAN_PARAMS *p_msg =
        (tBTA_DM_API_BLE_SCAN_PARAMS *)osi_calloc(sizeof(tBTA_DM_API_BLE_SCAN_PARAMS));

    p_msg->hdr.event = BTA_DM_API_BLE_CONN_SCAN_PARAM_EVT;
    p_msg->scan_int = scan_interval;
    p_msg->scan_window = scan_window;

    bta_sys_sendmsg(p_msg);
#endif  // BLE_INCLUDED == true
}

/*******************************************************************************
 *
 * Function         BTA_DmSetBleScanParams
 *
 * Description      This function is called to set scan parameters
 *
 * Parameters:      client_if - Client IF
 *                  scan_interval - scan interval
 *                  scan_window - scan window
 *                  scan_mode - scan mode
 *                  scan_param_setup_status_cback - Set scan param status callback
 *
 * Returns          void
 *
 ******************************************************************************/

#if (BLE_INCLUDED == TRUE)
void BTA_DmSetBleScanParams(tGATT_IF client_if, uint32_t scan_interval,
                            uint32_t scan_window, tBLE_SCAN_MODE scan_mode,
                            tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)
{
    tBTA_DM_API_BLE_SCAN_PARAMS *p_msg =
        (tBTA_DM_API_BLE_SCAN_PARAMS *)osi_calloc(sizeof(tBTA_DM_API_BLE_SCAN_PARAMS));

    p_msg->hdr.event = BTA_DM_API_BLE_SCAN_PARAM_EVT;
    p_msg->client_if = client_if;
    p_msg->scan_int = scan_interval;
    p_msg->scan_window = scan_window;
    p_msg->scan_mode = scan_mode;
    p_msg->scan_param_setup_cback = scan_param_setup_cback;

    bta_sys_sendmsg(p_msg);
}
#endif  // BLE_INCLUDED == true

/*******************************************************************************
 *
 * Function         BTA_DmSetBleAdvParams
 *
 * Description      This function sets the advertising parameters BLE functionality.
 *                  It is to be called when device act in peripheral or broadcaster
 *                  role.
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmSetBleAdvParams(uint16_t adv_int_min, uint16_t adv_int_max,
                           tBLE_BD_ADDR *p_dir_bda)
{
#if (BLE_INCLUDED == TRUE)
    if (p_dir_bda != NULL) {
        tBLE_BD_ADDR *bda  = new tBLE_BD_ADDR;
        memcpy(bda, p_dir_bda, sizeof(tBLE_BD_ADDR));
        do_in_bta_thread(FROM_HERE,
          base::Bind(&bta_dm_ble_set_adv_params, adv_int_min, adv_int_max, base::Owned(bda)));
    }

    do_in_bta_thread(FROM_HERE,
      base::Bind(&bta_dm_ble_set_adv_params, adv_int_min, adv_int_max, nullptr));

#endif
}

/*******************************************************************************
 *                      BLE ADV data management API
 *******************************************************************************/

#if (BLE_INCLUDED == TRUE)
/*******************************************************************************
 *
 * Function         BTA_DmBleSetStorageParams
 *
 * Description      This function is called to override the BTA scan response.
 *
 * Parameters       batch_scan_full_max -Max storage space (in %) allocated to full scanning
 *                  batch_scan_trunc_max -Max storage space (in %) allocated to truncated scanning
 *                  batch_scan_notify_threshold -Setup notification level based on total space
 *                  p_setup_cback - Setup callback pointer
 *                  p_thres_cback - Threshold callback pointer
 *                  p_rep_cback - Reports callback pointer
 *                  ref_value - Ref value
 *
 * Returns          None
 *
 ******************************************************************************/
extern void BTA_DmBleSetStorageParams(uint8_t batch_scan_full_max,
                                         uint8_t batch_scan_trunc_max,
                                         uint8_t batch_scan_notify_threshold,
                                         tBTA_BLE_SCAN_SETUP_CBACK *p_setup_cback,
                                         tBTA_BLE_SCAN_THRESHOLD_CBACK *p_thres_cback,
                                         tBTA_BLE_SCAN_REP_CBACK* p_rep_cback,
                                         tBTA_DM_BLE_REF_VALUE ref_value)
{
    tBTA_DM_API_SET_STORAGE_CONFIG *p_msg =
        (tBTA_DM_API_SET_STORAGE_CONFIG *)osi_malloc(sizeof(tBTA_DM_API_SET_STORAGE_CONFIG));

    bta_dm_cb.p_setup_cback = p_setup_cback;

    p_msg->hdr.event = BTA_DM_API_BLE_SETUP_STORAGE_EVT;
    p_msg->p_setup_cback=bta_ble_scan_setup_cb;
    p_msg->p_thres_cback=p_thres_cback;
    p_msg->p_read_rep_cback=p_rep_cback;
    p_msg->ref_value = ref_value;
    p_msg->batch_scan_full_max = batch_scan_full_max;
    p_msg->batch_scan_trunc_max = batch_scan_trunc_max;
    p_msg->batch_scan_notify_threshold = batch_scan_notify_threshold;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmBleEnableBatchScan
 *
 * Description      This function is called to enable the batch scan
 *
 * Parameters       scan_mode -Batch scan mode
 *                  scan_interval - Scan interval
 *                  scan_window - Scan window
 *                  discard_rule -Discard rules
 *                  addr_type - Address type
 *                  ref_value - Reference value
 *
 * Returns          None
 *
 ******************************************************************************/
extern void BTA_DmBleEnableBatchScan(tBTA_BLE_BATCH_SCAN_MODE scan_mode,
                                         uint32_t scan_interval, uint32_t scan_window,
                                         tBTA_BLE_DISCARD_RULE discard_rule,
                                         tBLE_ADDR_TYPE        addr_type,
                                         tBTA_DM_BLE_REF_VALUE ref_value)
{
    tBTA_DM_API_ENABLE_SCAN *p_msg =
        (tBTA_DM_API_ENABLE_SCAN *)osi_malloc(sizeof(tBTA_DM_API_ENABLE_SCAN));

    p_msg->hdr.event = BTA_DM_API_BLE_ENABLE_BATCH_SCAN_EVT;
    p_msg->scan_mode = scan_mode;
    p_msg->scan_int = scan_interval;
    p_msg->scan_window = scan_window;
    p_msg->discard_rule = discard_rule;
    p_msg->addr_type = addr_type;
    p_msg->ref_value = ref_value;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmBleDisableBatchScan
 *
 * Description      This function is called to disable the batch scan
 *
 * Parameters       ref_value - Reference value
 *
 * Returns          None
 *
 ******************************************************************************/
extern void BTA_DmBleDisableBatchScan(tBTA_DM_BLE_REF_VALUE ref_value)
{
    tBTA_DM_API_DISABLE_SCAN *p_msg =
        (tBTA_DM_API_DISABLE_SCAN *)osi_malloc(sizeof(tBTA_DM_API_DISABLE_SCAN));

    p_msg->hdr.event = BTA_DM_API_BLE_DISABLE_BATCH_SCAN_EVT;
    p_msg->ref_value = ref_value;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmBleReadScanReports
 *
 * Description      This function is called to read scan reports
 *
 * Parameters       scan_type -Batch scan mode
 *                  ref_value - Reference value
 *
 * Returns          None
 *
 ******************************************************************************/
extern void BTA_DmBleReadScanReports(tBTA_BLE_BATCH_SCAN_MODE scan_type,
                                             tBTA_DM_BLE_REF_VALUE ref_value)
{
    tBTA_DM_API_READ_SCAN_REPORTS *p_msg =
        (tBTA_DM_API_READ_SCAN_REPORTS *)osi_malloc(sizeof(tBTA_DM_API_READ_SCAN_REPORTS));

    p_msg->hdr.event = BTA_DM_API_BLE_READ_SCAN_REPORTS_EVT;
    p_msg->scan_type = scan_type;
    p_msg->ref_value = ref_value;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmBleTrackAdvertiser
 *
 * Description      This function is called to track advertiser
 *
 * Parameters       ref_value - Reference value
 *                  p_track_adv_cback - Track ADV callback
 *
 * Returns          None
 *
 ******************************************************************************/
extern void BTA_DmBleTrackAdvertiser(tBTA_DM_BLE_REF_VALUE ref_value,
                            tBTA_BLE_TRACK_ADV_CBACK *p_track_adv_cback)
{
    tBTA_DM_API_TRACK_ADVERTISER *p_msg =
        (tBTA_DM_API_TRACK_ADVERTISER *)osi_malloc(sizeof(tBTA_DM_API_TRACK_ADVERTISER));

    p_msg->hdr.event = BTA_DM_API_BLE_TRACK_ADVERTISER_EVT;
    p_msg->p_track_adv_cback = p_track_adv_cback;
    p_msg->ref_value = ref_value;

    bta_sys_sendmsg(p_msg);
}

#endif

/*******************************************************************************
 *                      BLE ADV data management API
 *******************************************************************************/

/*******************************************************************************
 *
 * Function         BTA_DmBleSetBgConnType
 *
 * Description      This function is called to set BLE connectable mode for a
 *                  peripheral device.
 *
 * Parameters       bg_conn_type: it can be auto connection, or selective connection.
 *                  p_select_cback: callback function when selective connection procedure
 *                              is being used.
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmBleSetBgConnType(tBTA_DM_BLE_CONN_TYPE bg_conn_type, tBTA_DM_BLE_SEL_CBACK *p_select_cback)
{
#if (BLE_INCLUDED == TRUE)
    tBTA_DM_API_BLE_SET_BG_CONN_TYPE *p_msg =
        (tBTA_DM_API_BLE_SET_BG_CONN_TYPE *)osi_calloc(sizeof(tBTA_DM_API_BLE_SET_BG_CONN_TYPE));

    p_msg->hdr.event = BTA_DM_API_BLE_SET_BG_CONN_TYPE;
    p_msg->bg_conn_type = bg_conn_type;
    p_msg->p_select_cback = p_select_cback;

    bta_sys_sendmsg(p_msg);
#endif
}

/*******************************************************************************
 *
 * Function         bta_dm_discover_send_msg
 *
 * Description      This function send discover message to BTA task.
 *
 * Returns          void
 *
 ******************************************************************************/
#if (BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE)
static void bta_dm_discover_send_msg(BD_ADDR bd_addr, tBTA_SERVICE_MASK_EXT *p_services,
                    tBTA_DM_SEARCH_CBACK *p_cback, bool sdp_search,
                    tBTA_TRANSPORT transport)
{
    const size_t len = p_services ?
        (sizeof(tBTA_DM_API_DISCOVER) + sizeof(tBT_UUID) * p_services->num_uuid)
        : sizeof(tBTA_DM_API_DISCOVER);
    tBTA_DM_API_DISCOVER *p_msg = (tBTA_DM_API_DISCOVER *)osi_calloc(len);

    p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);
    p_msg->p_cback = p_cback;
    p_msg->sdp_search = sdp_search;
    p_msg->transport    = transport;

    if (p_services != NULL) {
#if (BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE)
        p_msg->services = p_services->srvc_mask;
        p_msg->num_uuid = p_services->num_uuid;
        if (p_services->num_uuid != 0) {
            p_msg->p_uuid = (tBT_UUID *)(p_msg + 1);
            memcpy(p_msg->p_uuid, p_services->p_uuid,
                   sizeof(tBT_UUID) * p_services->num_uuid);
        }
#endif
    }

    bta_sys_sendmsg(p_msg);
}
#endif

/*******************************************************************************
 *
 * Function         BTA_DmDiscoverByTransport
 *
 * Description      This function does service discovery on particular transport
 *                  for services of a
 *                  peer device. When services.num_uuid is 0, it indicates all
 *                  GATT based services are to be searched; otherwise a list of
 *                  UUID of interested services should be provided through
 *                  p_services->p_uuid.
 *
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmDiscoverByTransport(BD_ADDR bd_addr, tBTA_SERVICE_MASK_EXT *p_services,
                    tBTA_DM_SEARCH_CBACK *p_cback, bool sdp_search,
                    tBTA_TRANSPORT transport)
{
#if (BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE)
    bta_dm_discover_send_msg(bd_addr, p_services, p_cback, sdp_search, transport);
#endif
}


/*******************************************************************************
 *
 * Function         BTA_DmDiscoverExt
 *
 * Description      This function does service discovery for services of a
 *                  peer device. When services.num_uuid is 0, it indicates all
 *                  GATT based services are to be searched; other wise a list of
 *                  UUID of interested services should be provided through
 *                  p_services->p_uuid.
 *
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmDiscoverExt(BD_ADDR bd_addr, tBTA_SERVICE_MASK_EXT *p_services,
                    tBTA_DM_SEARCH_CBACK *p_cback, bool sdp_search)
{
#if (BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE)
    bta_dm_discover_send_msg(bd_addr, p_services, p_cback, sdp_search, BTA_TRANSPORT_UNKNOWN);
#endif

}

/*******************************************************************************
 *
 * Function         BTA_DmSearchExt
 *
 * Description      This function searches for peer Bluetooth devices. It performs
 *                  an inquiry and gets the remote name for devices. Service
 *                  discovery is done if services is non zero
 *
 * Parameters       p_dm_inq: inquiry conditions
 *                  p_services: if service is not empty, service discovery will be done.
 *                            for all GATT based service condition, put num_uuid, and
 *                            p_uuid is the pointer to the list of UUID values.
 *                  p_cback: callback functino when search is completed.
 *
 *
 *
 * Returns          void
 *
 ******************************************************************************/
#if (BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE)
void BTA_DmSearchExt(tBTA_DM_INQ *p_dm_inq, tBTA_SERVICE_MASK_EXT *p_services, tBTA_DM_SEARCH_CBACK *p_cback)
{
    const size_t len = p_services ?
        (sizeof(tBTA_DM_API_SEARCH) + sizeof(tBT_UUID) * p_services->num_uuid)
        : sizeof(tBTA_DM_API_SEARCH);
    tBTA_DM_API_SEARCH *p_msg = (tBTA_DM_API_SEARCH *)osi_calloc(len);

    p_msg->hdr.event = BTA_DM_API_SEARCH_EVT;
    memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ));
    p_msg->p_cback = p_cback;
    p_msg->rs_res  = BTA_DM_RS_NONE;

    if (p_services != NULL) {
        p_msg->services = p_services->srvc_mask;
        p_msg->num_uuid = p_services->num_uuid;

        if (p_services->num_uuid != 0) {
            p_msg->p_uuid = (tBT_UUID *)(p_msg + 1);
            memcpy(p_msg->p_uuid, p_services->p_uuid,
                   sizeof(tBT_UUID) * p_services->num_uuid);
        } else {
            p_msg->p_uuid = NULL;
        }
    }

    bta_sys_sendmsg(p_msg);
}
#else
void BTA_DmSearchExt(UNUSED_ATTR tBTA_DM_INQ *p_dm_inq,
                     UNUSED_ATTR tBTA_SERVICE_MASK_EXT *p_services,
                     UNUSED_ATTR tBTA_DM_SEARCH_CBACK *p_cback)
{
}
#endif
/*******************************************************************************
 *
 * Function         BTA_DmBleUpdateConnectionParam
 *
 * Description      Update connection parameters, can only be used when connection is up.
 *
 * Parameters:      bd_addr          - BD address of the peer
 *                  min_int   -     minimum connection interval, [0x0004~ 0x4000]
 *                  max_int   -     maximum connection interval, [0x0004~ 0x4000]
 *                  latency   -     slave latency [0 ~ 500]
 *                  timeout   -     supervision timeout [0x000a ~ 0xc80]
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmBleUpdateConnectionParam(BD_ADDR bd_addr, uint16_t min_int,
                                    uint16_t max_int, uint16_t latency,
                                    uint16_t timeout)
{
#if (BLE_INCLUDED == TRUE)
    tBTA_DM_API_UPDATE_CONN_PARAM *p_msg =
        (tBTA_DM_API_UPDATE_CONN_PARAM *)osi_calloc(sizeof(tBTA_DM_API_UPDATE_CONN_PARAM));

    p_msg->hdr.event = BTA_DM_API_UPDATE_CONN_PARAM_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);
    p_msg->min_int = min_int;
    p_msg->max_int = max_int;
    p_msg->latency = latency;
    p_msg->timeout = timeout;

    bta_sys_sendmsg(p_msg);
#endif
}

/*******************************************************************************
 *
 * Function         BTA_DmBleConfigLocalPrivacy
 *
 * Description      Enable/disable privacy on the local device
 *
 * Parameters:      privacy_enable   - enable/disabe privacy on remote device.
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmBleConfigLocalPrivacy(bool privacy_enable)
{
#if (BLE_INCLUDED == TRUE && BLE_PRIVACY_SPT == TRUE)
    tBTA_DM_API_LOCAL_PRIVACY *p_msg =
        (tBTA_DM_API_LOCAL_PRIVACY *)osi_calloc(sizeof(tBTA_DM_API_ENABLE_PRIVACY));

    p_msg->hdr.event = BTA_DM_API_LOCAL_PRIVACY_EVT;
    p_msg->privacy_enable   = privacy_enable;

    bta_sys_sendmsg(p_msg);
#else
    UNUSED (privacy_enable);
#endif
}

#if (BLE_INCLUDED == TRUE)
/*******************************************************************************
 *
 * Function         BTA_DmBleCfgFilterCondition
 *
 * Description      This function is called to configure the adv data payload filter
 *                  condition.
 *
 * Parameters       action: to read/write/clear
 *                  cond_type: filter condition type
 *                  filt_index - Filter index
 *                  p_cond: filter condition parameter
 *                  p_cmpl_back - Command completed callback
 *                  ref_value - Reference value
 *
 * Returns          void
 *
 ******************************************************************************/
#if (BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
void BTA_DmBleCfgFilterCondition(tBTA_DM_BLE_SCAN_COND_OP action,
                                 tBTA_DM_BLE_PF_COND_TYPE cond_type,
                                 tBTA_DM_BLE_PF_FILT_INDEX filt_index,
                                 tBTA_DM_BLE_PF_COND_PARAM *p_cond,
                                 tBTA_DM_BLE_PF_CFG_CBACK *p_cmpl_cback,
                                 tBTA_DM_BLE_REF_VALUE ref_value)
{
    tBTA_DM_API_CFG_FILTER_COND *p_msg;
    APPL_TRACE_API ("BTA_DmBleCfgFilterCondition: %d, %d", action, cond_type);

    uint16_t  len = sizeof(tBTA_DM_API_CFG_FILTER_COND) +
                  sizeof(tBTA_DM_BLE_PF_COND_PARAM);
    uint8_t *p;

    if (NULL != p_cond)
    {
        switch(cond_type)
        {
            case BTA_DM_BLE_PF_SRVC_DATA_PATTERN:
            case BTA_DM_BLE_PF_MANU_DATA:
                /* Length of pattern and pattern mask and other elements in */
                /* tBTA_DM_BLE_PF_MANU_COND */
                len += ((p_cond->manu_data.data_len) * 2) +
                        sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint8_t);
                break;

            case BTA_DM_BLE_PF_LOCAL_NAME:
                len += ((p_cond->local_name.data_len) + sizeof(uint8_t));
                break;

            case BTM_BLE_PF_SRVC_UUID:
            case BTM_BLE_PF_SRVC_SOL_UUID:
                len += sizeof(tBLE_BD_ADDR) + sizeof(tBTA_DM_BLE_PF_COND_MASK);
                break;

            default:
                break;
        }
    }

    p_msg = (tBTA_DM_API_CFG_FILTER_COND *)osi_calloc(len);
    p_msg->hdr.event = BTA_DM_API_CFG_FILTER_COND_EVT;
    p_msg->action = action;
    p_msg->cond_type = cond_type;
    p_msg->filt_index = filt_index;
    p_msg->p_filt_cfg_cback = p_cmpl_cback;
    p_msg->ref_value = ref_value;
    if (p_cond) {
        p_msg->p_cond_param = (tBTA_DM_BLE_PF_COND_PARAM *)(p_msg + 1);
        memcpy(p_msg->p_cond_param, p_cond, sizeof(tBTA_DM_BLE_PF_COND_PARAM));

        p = (uint8_t *)(p_msg->p_cond_param + 1);

        if (cond_type == BTA_DM_BLE_PF_SRVC_DATA_PATTERN ||
            cond_type == BTA_DM_BLE_PF_MANU_DATA) {
            p_msg->p_cond_param->manu_data.p_pattern = p;
            p_msg->p_cond_param->manu_data.data_len = p_cond->manu_data.data_len;
            memcpy(p_msg->p_cond_param->manu_data.p_pattern, p_cond->manu_data.p_pattern,
                   p_cond->manu_data.data_len);
            p += p_cond->manu_data.data_len;

            if (cond_type == BTA_DM_BLE_PF_MANU_DATA) {
                p_msg->p_cond_param->manu_data.company_id_mask =
                    p_cond->manu_data.company_id_mask;
                if ( p_cond->manu_data.p_pattern_mask != NULL) {
                    p_msg->p_cond_param->manu_data.p_pattern_mask = p;
                    memcpy(p_msg->p_cond_param->manu_data.p_pattern_mask,
                           p_cond->manu_data.p_pattern_mask,
                           p_cond->manu_data.data_len);
                }
            }
        } else if (cond_type == BTA_DM_BLE_PF_LOCAL_NAME) {
            p_msg->p_cond_param->local_name.p_data = p;
            p_msg->p_cond_param->local_name.data_len =
                p_cond->local_name.data_len;
            memcpy(p_msg->p_cond_param->local_name.p_data,
                   p_cond->local_name.p_data, p_cond->local_name.data_len);
        } else if (cond_type == BTM_BLE_PF_SRVC_UUID ||
                   cond_type == BTM_BLE_PF_SRVC_SOL_UUID) {
            if (p_cond->srvc_uuid.p_target_addr != NULL) {
                p_msg->p_cond_param->srvc_uuid.p_target_addr = (tBLE_BD_ADDR *)(p);
                p_msg->p_cond_param->srvc_uuid.p_target_addr->type =
                    p_cond->srvc_uuid.p_target_addr->type;
                memcpy(p_msg->p_cond_param->srvc_uuid.p_target_addr->bda,
                       p_cond->srvc_uuid.p_target_addr->bda, BD_ADDR_LEN);
                p = (uint8_t *)(p_msg->p_cond_param->srvc_uuid.p_target_addr + 1);
            }
            if (p_cond->srvc_uuid.p_uuid_mask) {
                p_msg->p_cond_param->srvc_uuid.p_uuid_mask = (tBTA_DM_BLE_PF_COND_MASK *)p;
                memcpy(p_msg->p_cond_param->srvc_uuid.p_uuid_mask,
                       p_cond->srvc_uuid.p_uuid_mask,
                       sizeof(tBTA_DM_BLE_PF_COND_MASK));
            }
        }
    }

    bta_sys_sendmsg(p_msg);

}
#else
void BTA_DmBleCfgFilterCondition(UNUSED_ATTR tBTA_DM_BLE_SCAN_COND_OP action,
                                 UNUSED_ATTR tBTA_DM_BLE_PF_COND_TYPE cond_type,
                                 UNUSED_ATTR tBTA_DM_BLE_PF_FILT_INDEX filt_index,
                                 UNUSED_ATTR tBTA_DM_BLE_PF_COND_PARAM *p_cond,
                                 UNUSED_ATTR tBTA_DM_BLE_PF_CFG_CBACK *p_cmpl_cback,
                                 UNUSED_ATTR tBTA_DM_BLE_REF_VALUE ref_value)
{
}
#endif

/*******************************************************************************
 *
 * Function         BTA_DmBleScanFilterSetup
 *
 * Description      This function is called to setup the adv data payload filter param
 *
 * Parameters       p_target: enable the filter condition on a target device; if NULL
 *                  filt_index - Filter index
 *                  p_filt_params -Filter parameters
 *                  ref_value - Reference value
 *                  action - Add, delete or clear
 *                  p_cmpl_back - Command completed callback
 *
 * Returns          void
 *
 ******************************************************************************/
#if (BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
void BTA_DmBleScanFilterSetup(uint8_t action,
                              tBTA_DM_BLE_PF_FILT_INDEX filt_index,
                              tBTA_DM_BLE_PF_FILT_PARAMS *p_filt_params,
                              tBLE_BD_ADDR *p_target,
                              tBTA_DM_BLE_PF_PARAM_CBACK *p_cmpl_cback,
                              tBTA_DM_BLE_REF_VALUE ref_value)
{
    const size_t len = sizeof(tBTA_DM_API_SCAN_FILTER_PARAM_SETUP) +
        sizeof(tBLE_BD_ADDR);
    tBTA_DM_API_SCAN_FILTER_PARAM_SETUP *p_msg =
        (tBTA_DM_API_SCAN_FILTER_PARAM_SETUP *)osi_calloc(len);

    APPL_TRACE_API("%s: %d", __func__, action);

    p_msg->hdr.event = BTA_DM_API_SCAN_FILTER_SETUP_EVT;
    p_msg->action = action;
    p_msg->filt_index = filt_index;
    if (p_filt_params) {
        memcpy(&p_msg->filt_params, p_filt_params,
               sizeof(tBTA_DM_BLE_PF_FILT_PARAMS));
    }
    p_msg->p_filt_param_cback = p_cmpl_cback;
    p_msg->ref_value        = ref_value;

    if (p_target) {
        p_msg->p_target = (tBLE_BD_ADDR *)(p_msg + 1);
        memcpy(p_msg->p_target, p_target, sizeof(tBLE_BD_ADDR));
    }

    bta_sys_sendmsg(p_msg);
}
#else
void BTA_DmBleScanFilterSetup(UNUSED_ATTR uint8_t action,
                              UNUSED_ATTR tBTA_DM_BLE_PF_FILT_INDEX filt_index,
                              UNUSED_ATTR tBTA_DM_BLE_PF_FILT_PARAMS *p_filt_params,
                              UNUSED_ATTR tBLE_BD_ADDR *p_target,
                              UNUSED_ATTR tBTA_DM_BLE_PF_PARAM_CBACK *p_cmpl_cback,
                              UNUSED_ATTR tBTA_DM_BLE_REF_VALUE ref_value)
}
#endif

/*******************************************************************************
 *
 * Function         BTA_DmBleGetEnergyInfo
 *
 * Description      This function is called to obtain the energy info
 *
 * Parameters       p_cmpl_cback - Command complete callback
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmBleGetEnergyInfo(tBTA_BLE_ENERGY_INFO_CBACK *p_cmpl_cback)
{
    const size_t len = sizeof(tBTA_DM_API_ENERGY_INFO) + sizeof(tBLE_BD_ADDR);
    tBTA_DM_API_ENERGY_INFO *p_msg = (tBTA_DM_API_ENERGY_INFO *)osi_calloc(len);

    APPL_TRACE_API("%s", __func__);

    p_msg->hdr.event = BTA_DM_API_BLE_ENERGY_INFO_EVT;
    p_msg->p_energy_info_cback = p_cmpl_cback;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmEnableScanFilter
 *
 * Description      This function is called to enable the adv data payload filter
 *
 * Parameters       action - enable or disable the APCF feature
 *                  p_cmpl_cback - Command completed callback
 *                  ref_value - Reference value
 *
 * Returns          void
 *
 ******************************************************************************/
#if (BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
void BTA_DmEnableScanFilter(uint8_t action, tBTA_DM_BLE_PF_STATUS_CBACK *p_cmpl_cback,
                                    tBTA_DM_BLE_REF_VALUE ref_value)
{
    const size_t len = sizeof(tBTA_DM_API_ENABLE_SCAN_FILTER) +
        sizeof(tBLE_BD_ADDR);
    tBTA_DM_API_ENABLE_SCAN_FILTER *p_msg =
        (tBTA_DM_API_ENABLE_SCAN_FILTER *)osi_calloc(len);

    APPL_TRACE_API("%s: %d", __func__, action);

    p_msg->hdr.event = BTA_DM_API_SCAN_FILTER_ENABLE_EVT;
    p_msg->action = action;
    p_msg->ref_value = ref_value;
    p_msg->p_filt_status_cback = p_cmpl_cback;

    bta_sys_sendmsg(p_msg);

}
#else
void BTA_DmEnableScanFilter(UNUSED_ATTR uint8_t action,
                            UNUSED_ATTR tBTA_DM_BLE_PF_STATUS_CBACK *p_cmpl_cback,
                            UNUSED_ATTR tBTA_DM_BLE_REF_VALUE ref_value)
{
}
#endif

/*******************************************************************************
 *
 * Function         BTA_DmBleUpdateConnectionParams
 *
 * Description      Update connection parameters, can only be used when connection is up.
 *
 * Parameters:      bd_addr   - BD address of the peer
 *                  min_int   -     minimum connection interval, [0x0004~ 0x4000]
 *                  max_int   -     maximum connection interval, [0x0004~ 0x4000]
 *                  latency   -     slave latency [0 ~ 500]
 *                  timeout   -     supervision timeout [0x000a ~ 0xc80]
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmBleUpdateConnectionParams(const BD_ADDR bd_addr, uint16_t min_int, uint16_t max_int,
                                    uint16_t latency, uint16_t timeout)
{
    tBTA_DM_API_UPDATE_CONN_PARAM *p_msg =
        (tBTA_DM_API_UPDATE_CONN_PARAM *)osi_calloc(sizeof(tBTA_DM_API_UPDATE_CONN_PARAM));

    p_msg->hdr.event = BTA_DM_API_UPDATE_CONN_PARAM_EVT;
    bdcpy(p_msg->bd_addr, bd_addr);
    p_msg->min_int = min_int;
    p_msg->max_int = max_int;
    p_msg->latency = latency;
    p_msg->timeout = timeout;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmBleSetDataLength
 *
 * Description      This function is to set maximum LE data packet size
 *
 * Returns          void
 *
 *
 ******************************************************************************/
void BTA_DmBleSetDataLength(BD_ADDR remote_device, uint16_t tx_data_length)
{
    tBTA_DM_API_BLE_SET_DATA_LENGTH *p_msg =
        (tBTA_DM_API_BLE_SET_DATA_LENGTH *)osi_malloc(sizeof(tBTA_DM_API_BLE_SET_DATA_LENGTH));

    bdcpy(p_msg->remote_bda, remote_device);
    p_msg->hdr.event = BTA_DM_API_SET_DATA_LENGTH_EVT;
    p_msg->tx_data_length = tx_data_length;

    bta_sys_sendmsg(p_msg);
}

#endif

/*******************************************************************************
 *
 * Function         BTA_DmSetEncryption
 *
 * Description      This function is called to ensure that connection is
 *                  encrypted.  Should be called only on an open connection.
 *                  Typically only needed for connections that first want to
 *                  bring up unencrypted links, then later encrypt them.
 *
 * Parameters:      bd_addr       - Address of the peer device
 *                  transport     - transport of the link to be encruypted
 *                  p_callback    - Pointer to callback function to indicat the
 *                                  link encryption status
 *                  sec_act       - This is the security action to indicate
 *                                  what knid of BLE security level is required for
 *                                  the BLE link if the BLE is supported
 *                                  Note: This parameter is ignored for the BR/EDR link
 *                                        or the BLE is not supported
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmSetEncryption(BD_ADDR bd_addr, tBTA_TRANSPORT transport, tBTA_DM_ENCRYPT_CBACK *p_callback,
                            tBTA_DM_BLE_SEC_ACT sec_act)
{
    tBTA_DM_API_SET_ENCRYPTION *p_msg = (tBTA_DM_API_SET_ENCRYPTION *)osi_calloc(sizeof(tBTA_DM_API_SET_ENCRYPTION));

    APPL_TRACE_API("%s", __func__);

    p_msg->hdr.event = BTA_DM_API_SET_ENCRYPTION_EVT;
    memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);
    p_msg->transport = transport;
    p_msg->p_callback = p_callback;
    p_msg->sec_act = sec_act;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmCloseACL
 *
 * Description      This function force to close an ACL connection and remove the
 *                  device from the security database list of known devices.
 *
 * Parameters:      bd_addr       - Address of the peer device
 *                  remove_dev    - remove device or not after link down
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmCloseACL(BD_ADDR bd_addr, bool remove_dev, tBTA_TRANSPORT transport)
{
    tBTA_DM_API_REMOVE_ACL *p_msg =
        (tBTA_DM_API_REMOVE_ACL *)osi_calloc(sizeof(tBTA_DM_API_REMOVE_ACL));

    APPL_TRACE_API("%s", __func__);

    p_msg->hdr.event = BTA_DM_API_REMOVE_ACL_EVT;
    memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);
    p_msg->remove_dev = remove_dev;
    p_msg->transport = transport;

    bta_sys_sendmsg(p_msg);
}

#if (BLE_INCLUDED == TRUE)
/*******************************************************************************
 *
 * Function         BTA_DmBleObserve
 *
 * Description      This procedure keep the device listening for advertising
 *                  events from a broadcast device.
 *
 * Parameters       start: start or stop observe.
 *
 * Returns          void

 *
 * Returns          void.
 *
 ******************************************************************************/
extern void BTA_DmBleObserve(bool start, uint8_t duration,
                             tBTA_DM_SEARCH_CBACK *p_results_cb)
{
    tBTA_DM_API_BLE_OBSERVE *p_msg =
        (tBTA_DM_API_BLE_OBSERVE *)osi_calloc(sizeof(tBTA_DM_API_BLE_OBSERVE));

    APPL_TRACE_API("%s:start = %d ", __func__, start);

    p_msg->hdr.event = BTA_DM_API_BLE_OBSERVE_EVT;
    p_msg->start = start;
    p_msg->duration = duration;
    p_msg->p_cback = p_results_cb;

    bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_VendorInit
 *
 * Description      This function initializes vendor specific
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_VendorInit (void)
{
    APPL_TRACE_API("BTA_VendorInit");
}

/*******************************************************************************
 *
 * Function         BTA_VendorCleanup
 *
 * Description      This function frees up Broadcom specific VS specific dynamic memory
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_VendorCleanup (void)
{
    tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
    BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);

#if (BLE_INCLUDED == TRUE && BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
    if (cmn_ble_vsc_cb.max_filter > 0)
    {
        btm_ble_adv_filter_cleanup();
#if (BLE_PRIVACY_SPT == TRUE)
        btm_ble_resolving_list_cleanup ();
#endif
    }

    if (cmn_ble_vsc_cb.tot_scan_results_strg > 0)
        btm_ble_batchscan_cleanup();
#endif

   if(cmn_ble_vsc_cb.adv_inst_max > 0)
      btm_ble_multi_adv_cleanup();
}

#endif