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

/******************************************************************************
 *
 *  This file implements utility functions for the HeaLth device profile
 *  (HL).
 *
 ******************************************************************************/

#include <stdio.h>
#include <string.h>

#include "bt_target.h"
#if (HL_INCLUDED == TRUE)

#include "bt_common.h"
#include "bta_hl_co.h"
#include "bta_hl_int.h"
#include "mca_api.h"
#include "mca_defs.h"
#include "osi/include/osi.h"
#include "utl.h"

/*******************************************************************************
 *
 * Function      bta_hl_set_ctrl_psm_for_dch
 *
 * Description    This function set the control PSM for the DCH setup
 *
 * Returns     bool - true - control PSM setting is successful
 ******************************************************************************/
bool bta_hl_set_ctrl_psm_for_dch(uint8_t app_idx, uint8_t mcl_idx,
                                 UNUSED_ATTR uint8_t mdl_idx,
                                 uint16_t ctrl_psm) {
  tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
  bool success = true, update_ctrl_psm = false;

  if (p_mcb->sdp.num_recs) {
    if (p_mcb->ctrl_psm != ctrl_psm) {
      /* can not use a different ctrl PSM than the current one*/
      success = false;
    }
  } else {
    /* No SDP info control i.e. channel was opened by the peer */
    update_ctrl_psm = true;
  }

  if (success && update_ctrl_psm) {
    p_mcb->ctrl_psm = ctrl_psm;
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!success) {
    APPL_TRACE_DEBUG(
        "bta_hl_set_ctrl_psm_for_dch num_recs=%d success=%d update_ctrl_psm=%d "
        "ctrl_psm=0x%x ",
        p_mcb->sdp.num_recs, success, update_ctrl_psm, ctrl_psm);
  }
#endif

  return success;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_sdp_idx_using_ctrl_psm
 *
 * Description
 *
 * Returns      true if found
 *
 ******************************************************************************/
bool bta_hl_find_sdp_idx_using_ctrl_psm(tBTA_HL_SDP* p_sdp, uint16_t ctrl_psm,
                                        uint8_t* p_sdp_idx) {
  bool found = false;
  tBTA_HL_SDP_REC* p_rec;
  uint8_t i;

  if (ctrl_psm != 0) {
    for (i = 0; i < p_sdp->num_recs; i++) {
      p_rec = &p_sdp->sdp_rec[i];
      if (p_rec->ctrl_psm == ctrl_psm) {
        *p_sdp_idx = i;
        found = true;
        break;
      }
    }
  } else {
    *p_sdp_idx = 0;
    found = true;
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!found) {
    APPL_TRACE_DEBUG(
        "bta_hl_find_sdp_idx_using_ctrl_psm found=%d sdp_idx=%d ctrl_psm=0x%x ",
        found, *p_sdp_idx, ctrl_psm);
  }
#endif
  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_set_user_tx_buf_size
 *
 * Description  This function sets the user tx buffer size
 *
 * Returns      uint16_t buf_size
 *
 ******************************************************************************/

uint16_t bta_hl_set_user_tx_buf_size(uint16_t max_tx_size) {
  if (max_tx_size > BT_DEFAULT_BUFFER_SIZE) return BTA_HL_LRG_DATA_BUF_SIZE;
  return L2CAP_INVALID_ERM_BUF_SIZE;
}

/*******************************************************************************
 *
 * Function      bta_hl_set_user_rx_buf_size
 *
 * Description  This function sets the user rx buffer size
 *
 * Returns      uint16_t buf_size
 *
 ******************************************************************************/

uint16_t bta_hl_set_user_rx_buf_size(uint16_t mtu) {
  if (mtu > BT_DEFAULT_BUFFER_SIZE) return BTA_HL_LRG_DATA_BUF_SIZE;
  return L2CAP_INVALID_ERM_BUF_SIZE;
}

/*******************************************************************************
 *
 * Function      bta_hl_set_tx_win_size
 *
 * Description  This function sets the tx window size
 *
 * Returns      uint8_t tx_win_size
 *
 ******************************************************************************/
uint8_t bta_hl_set_tx_win_size(uint16_t mtu, uint16_t mps) {
  uint8_t tx_win_size;

  if (mtu <= mps) {
    tx_win_size = 1;
  } else {
    if (mps > 0) {
      tx_win_size = (mtu / mps) + 1;
    } else {
      APPL_TRACE_ERROR("The MPS is zero");
      tx_win_size = 10;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_set_tx_win_size win_size=%d mtu=%d mps=%d",
                   tx_win_size, mtu, mps);
#endif
  return tx_win_size;
}

/*******************************************************************************
 *
 * Function      bta_hl_set_mps
 *
 * Description  This function sets the MPS
 *
 * Returns      uint16_t MPS
 *
 ******************************************************************************/
uint16_t bta_hl_set_mps(uint16_t mtu) {
  uint16_t mps;
  if (mtu > BTA_HL_L2C_MPS) {
    mps = BTA_HL_L2C_MPS;
  } else {
    mps = mtu;
  }
#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_set_mps mps=%d mtu=%d", mps, mtu);
#endif
  return mps;
}

/*******************************************************************************
 *
 * Function      bta_hl_clean_mdl_cb
 *
 * Description  This function clean up the specified MDL control block
 *
 * Returns      void
 *
 ******************************************************************************/
void bta_hl_clean_mdl_cb(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx) {
  tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_clean_mdl_cb app_idx=%d mcl_idx=%d mdl_idx=%d",
                   app_idx, mcl_idx, mdl_idx);
#endif
  osi_free_and_reset((void**)&p_dcb->p_tx_pkt);
  osi_free_and_reset((void**)&p_dcb->p_rx_pkt);
  osi_free_and_reset((void**)&p_dcb->p_echo_tx_pkt);
  osi_free_and_reset((void**)&p_dcb->p_echo_rx_pkt);

  memset((void*)p_dcb, 0, sizeof(tBTA_HL_MDL_CB));
}

/*******************************************************************************
 *
 * Function      bta_hl_get_buf
 *
 * Description  This function allocate a buffer based on the specified data size
 *
 * Returns      BT_HDR *.
 *
 ******************************************************************************/
BT_HDR* bta_hl_get_buf(uint16_t data_size, bool fcs_use) {
  size_t size = data_size + L2CAP_MIN_OFFSET + BT_HDR_SIZE + L2CAP_FCS_LEN +
                L2CAP_EXT_CONTROL_OVERHEAD;

  if (fcs_use) size += L2CAP_FCS_LEN;

  BT_HDR* p_new = (BT_HDR*)osi_malloc(size);
  p_new->len = data_size;
  p_new->offset = L2CAP_MIN_OFFSET;

  return p_new;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_service_in_db
 *
 * Description  This function check the specified service class(es) can be find
 *              in the received SDP database
 *
 * Returns      bool true - found
 *                      false - not found
 *
 ******************************************************************************/
bool bta_hl_find_service_in_db(uint8_t app_idx, uint8_t mcl_idx,
                               uint16_t service_uuid, tSDP_DISC_REC** pp_rec) {
  tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
  bool found = true;

  switch (service_uuid) {
    case UUID_SERVCLASS_HDP_SINK:
    case UUID_SERVCLASS_HDP_SOURCE:
      *pp_rec = SDP_FindServiceInDb(p_mcb->p_db, service_uuid, *pp_rec);
      if (*pp_rec == NULL) {
        found = false;
      }
      break;
    default:
      *pp_rec = bta_hl_find_sink_or_src_srv_class_in_db(p_mcb->p_db, *pp_rec);
      if (*pp_rec == NULL) {
        found = false;
      }
      break;
  }
  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_get_service_uuids
 *
 *
 * Description  This function finds the service class(es) for both CCH and DCH
 *              operations
 *
 * Returns      uint16_t - service_id
 *                       if service_uuid = 0xFFFF then it means service uuid
 *                       can be either Sink or Source
 *
 ******************************************************************************/
uint16_t bta_hl_get_service_uuids(uint8_t sdp_oper, uint8_t app_idx,
                                  uint8_t mcl_idx, uint8_t mdl_idx) {
  tBTA_HL_MDL_CB* p_dcb;
  uint16_t service_uuid = 0xFFFF; /* both Sink and Source */

  switch (sdp_oper) {
    case BTA_HL_SDP_OP_DCH_OPEN_INIT:
    case BTA_HL_SDP_OP_DCH_RECONNECT_INIT:
      p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
      if (p_dcb->local_mdep_id != BTA_HL_ECHO_TEST_MDEP_ID) {
        if (p_dcb->peer_mdep_role == BTA_HL_MDEP_ROLE_SINK) {
          service_uuid = UUID_SERVCLASS_HDP_SINK;
        } else {
          service_uuid = UUID_SERVCLASS_HDP_SOURCE;
        }
      }
      break;
    case BTA_HL_SDP_OP_CCH_INIT:
    default:
      /* use default that is both Sink and Source */
      break;
  }
#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_get_service_uuids service_uuid=0x%x", service_uuid);
#endif
  return service_uuid;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_echo_cfg_rsp
 *
 *
 * Description  This function finds the configuration response for the echo test
 *
 * Returns      bool - true found
 *                        false not found
 *
 ******************************************************************************/
bool bta_hl_find_echo_cfg_rsp(uint8_t app_idx, uint8_t mcl_idx,
                              uint8_t mdep_idx, uint8_t cfg,
                              uint8_t* p_cfg_rsp) {
  tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
  tBTA_HL_MDEP* p_mdep = &p_acb->sup_feature.mdep[mdep_idx];
  bool status = true;

  if (p_mdep->mdep_id == BTA_HL_ECHO_TEST_MDEP_ID) {
    if ((cfg == BTA_HL_DCH_CFG_RELIABLE) || (cfg == BTA_HL_DCH_CFG_STREAMING)) {
      *p_cfg_rsp = cfg;
    } else if (cfg == BTA_HL_DCH_CFG_NO_PREF) {
      *p_cfg_rsp = BTA_HL_DEFAULT_ECHO_TEST_SRC_DCH_CFG;
    } else {
      status = false;
      APPL_TRACE_ERROR("Inavlid echo cfg value");
    }
    return status;
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!status) {
    APPL_TRACE_DEBUG(
        "bta_hl_find_echo_cfg_rsp status=failed app_idx=%d mcl_idx=%d "
        "mdep_idx=%d cfg=%d",
        app_idx, mcl_idx, mdep_idx, cfg);
  }
#endif

  return status;
}

/*******************************************************************************
 *
 * Function      bta_hl_validate_dch_cfg
 *
 * Description  This function validate the DCH configuration
 *
 * Returns      bool - true cfg is valid
 *                        false not valid
 *
 ******************************************************************************/
bool bta_hl_validate_cfg(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
                         uint8_t cfg) {
  tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
  bool is_valid = false;

  if (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx) &&
      (cfg != BTA_HL_DCH_CFG_RELIABLE)) {
    APPL_TRACE_ERROR("the first DCH should be a reliable channel");
    return is_valid;
  }

  switch (p_dcb->local_cfg) {
    case BTA_HL_DCH_CFG_NO_PREF:

      if ((cfg == BTA_HL_DCH_CFG_RELIABLE) ||
          (cfg == BTA_HL_DCH_CFG_STREAMING)) {
        is_valid = true;
      }
      break;
    case BTA_HL_DCH_CFG_RELIABLE:
    case BTA_HL_DCH_CFG_STREAMING:
      if (p_dcb->local_cfg == cfg) {
        is_valid = true;
      }
      break;
    default:
      break;
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!is_valid) {
    APPL_TRACE_DEBUG("bta_hl_validate_dch_open_cfg is_valid=%d, cfg=%d",
                     is_valid, cfg);
  }
#endif
  return is_valid;
}

/*******************************************************************************
 *
 * Function       bta_hl_find_cch_cb_indexes
 *
 * Description  This function finds the indexes needed for the CCH state machine
 *
 * Returns      bool - true found
 *                        false not found
 *
 ******************************************************************************/
bool bta_hl_find_cch_cb_indexes(tBTA_HL_DATA* p_msg, uint8_t* p_app_idx,
                                uint8_t* p_mcl_idx) {
  bool found = false;
  tBTA_HL_MCL_CB* p_mcb;
  uint8_t app_idx = 0, mcl_idx = 0;

  switch (p_msg->hdr.event) {
    case BTA_HL_CCH_SDP_OK_EVT:
    case BTA_HL_CCH_SDP_FAIL_EVT:
      app_idx = p_msg->cch_sdp.app_idx;
      mcl_idx = p_msg->cch_sdp.mcl_idx;
      found = true;
      break;

    case BTA_HL_MCA_CONNECT_IND_EVT:

      if (bta_hl_find_app_idx_using_handle(p_msg->mca_evt.app_handle,
                                           &app_idx)) {
        if (bta_hl_find_mcl_idx(app_idx,
                                p_msg->mca_evt.mca_data.connect_ind.bd_addr,
                                &mcl_idx)) {
          /* local initiated */
          found = true;
        } else if (!bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle,
                                                     &app_idx, &mcl_idx) &&
                   bta_hl_find_avail_mcl_idx(app_idx, &mcl_idx)) {
          /* remote initiated */
          p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
          p_mcb->in_use = true;
          p_mcb->cch_oper = BTA_HL_CCH_OP_REMOTE_OPEN;
          found = true;
        }
      }
      break;

    case BTA_HL_MCA_DISCONNECT_IND_EVT:

      if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx,
                                           &mcl_idx)) {
        found = true;
      } else if (bta_hl_find_app_idx_using_handle(p_msg->mca_evt.app_handle,
                                                  &app_idx) &&
                 bta_hl_find_mcl_idx(
                     app_idx, p_msg->mca_evt.mca_data.disconnect_ind.bd_addr,
                     &mcl_idx)) {
        found = true;
      }

      if (found) {
        p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
        if ((p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_CLOSE) &&
            (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_OPEN)) {
          p_mcb->cch_oper = BTA_HL_CCH_OP_REMOTE_CLOSE;
        }
      }
      break;

    case BTA_HL_MCA_RSP_TOUT_IND_EVT:

      if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx,
                                           &mcl_idx)) {
        found = true;
      }

      if (found) {
        p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
        if ((p_mcb->cch_oper != BTA_HL_CCH_OP_REMOTE_CLOSE) &&
            (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_OPEN)) {
          p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_CLOSE;
        }
      }
      break;
    default:
      break;
  }

  if (found) {
    *p_app_idx = app_idx;
    *p_mcl_idx = mcl_idx;
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!found) {
    APPL_TRACE_DEBUG(
        "bta_hl_find_cch_cb_indexes event=%s found=%d app_idx=%d mcl_idx=%d",
        bta_hl_evt_code(p_msg->hdr.event), found, app_idx, mcl_idx);
  }
#endif

  return found;
}

/*******************************************************************************
 *
 * Function       bta_hl_find_dch_cb_indexes
 *
 * Description  This function finds the indexes needed for the DCH state machine
 *
 * Returns      bool - true found
 *                        false not found
 *
 ******************************************************************************/
bool bta_hl_find_dch_cb_indexes(tBTA_HL_DATA* p_msg, uint8_t* p_app_idx,
                                uint8_t* p_mcl_idx, uint8_t* p_mdl_idx) {
  bool found = false;
  tBTA_HL_MCL_CB* p_mcb;
  uint8_t app_idx = 0, mcl_idx = 0, mdl_idx = 0;

  switch (p_msg->hdr.event) {
    case BTA_HL_MCA_CREATE_CFM_EVT:
      if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx,
                                           &mcl_idx) &&
          bta_hl_find_mdl_idx(app_idx, mcl_idx,
                              p_msg->mca_evt.mca_data.create_cfm.mdl_id,
                              &mdl_idx)) {
        found = true;
      }
      break;

    case BTA_HL_MCA_CREATE_IND_EVT:
    case BTA_HL_MCA_RECONNECT_IND_EVT:
      if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx,
                                           &mcl_idx) &&
          bta_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx)) {
        found = true;
      }
      break;

    case BTA_HL_MCA_OPEN_CFM_EVT:
      if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx,
                                           &mcl_idx) &&
          bta_hl_find_mdl_idx(app_idx, mcl_idx,
                              p_msg->mca_evt.mca_data.open_cfm.mdl_id,
                              &mdl_idx)) {
        found = true;
      }
      break;

    case BTA_HL_MCA_OPEN_IND_EVT:
      if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx,
                                           &mcl_idx) &&
          bta_hl_find_mdl_idx(app_idx, mcl_idx,
                              p_msg->mca_evt.mca_data.open_ind.mdl_id,
                              &mdl_idx)) {
        found = true;
      }
      break;

    case BTA_HL_MCA_CLOSE_CFM_EVT:

      if (bta_hl_find_mdl_idx_using_handle(
              (tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.close_cfm.mdl,
              &app_idx, &mcl_idx, &mdl_idx)) {
        found = true;
      }
      break;
    case BTA_HL_MCA_CLOSE_IND_EVT:

      if (bta_hl_find_mdl_idx_using_handle(
              (tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.close_ind.mdl,
              &app_idx, &mcl_idx, &mdl_idx)) {
        found = true;
      }
      break;
    case BTA_HL_API_SEND_DATA_EVT:

      if (bta_hl_find_mdl_idx_using_handle(p_msg->api_send_data.mdl_handle,
                                           &app_idx, &mcl_idx, &mdl_idx)) {
        found = true;
      }

      break;

    case BTA_HL_MCA_CONG_CHG_EVT:

      if (bta_hl_find_mdl_idx_using_handle(
              (tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.cong_chg.mdl,
              &app_idx, &mcl_idx, &mdl_idx)) {
        found = true;
      }

      break;

    case BTA_HL_MCA_RCV_DATA_EVT:
      app_idx = p_msg->mca_rcv_data_evt.app_idx;
      mcl_idx = p_msg->mca_rcv_data_evt.mcl_idx;
      mdl_idx = p_msg->mca_rcv_data_evt.mdl_idx;
      found = true;
      break;
    case BTA_HL_DCH_RECONNECT_EVT:
    case BTA_HL_DCH_OPEN_EVT:
    case BTA_HL_DCH_ECHO_TEST_EVT:
    case BTA_HL_DCH_SDP_FAIL_EVT:
      app_idx = p_msg->dch_sdp.app_idx;
      mcl_idx = p_msg->dch_sdp.mcl_idx;
      mdl_idx = p_msg->dch_sdp.mdl_idx;
      found = true;
      break;
    case BTA_HL_MCA_RECONNECT_CFM_EVT:
      if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx,
                                           &mcl_idx) &&
          bta_hl_find_mdl_idx(app_idx, mcl_idx,
                              p_msg->mca_evt.mca_data.reconnect_cfm.mdl_id,
                              &mdl_idx)) {
        found = true;
      }
      break;

    case BTA_HL_API_DCH_CREATE_RSP_EVT:
      if (bta_hl_find_mcl_idx_using_handle(p_msg->api_dch_create_rsp.mcl_handle,
                                           &app_idx, &mcl_idx) &&
          bta_hl_find_mdl_idx(app_idx, mcl_idx,
                              p_msg->api_dch_create_rsp.mdl_id, &mdl_idx)) {
        found = true;
      }
      break;
    case BTA_HL_MCA_ABORT_IND_EVT:
      if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx,
                                           &mcl_idx) &&
          bta_hl_find_mdl_idx(app_idx, mcl_idx,
                              p_msg->mca_evt.mca_data.abort_ind.mdl_id,
                              &mdl_idx)) {
        found = true;
      }
      break;
    case BTA_HL_MCA_ABORT_CFM_EVT:
      if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx,
                                           &mcl_idx) &&
          bta_hl_find_mdl_idx(app_idx, mcl_idx,
                              p_msg->mca_evt.mca_data.abort_cfm.mdl_id,
                              &mdl_idx)) {
        found = true;
      }
      break;
    case BTA_HL_CI_GET_TX_DATA_EVT:
    case BTA_HL_CI_PUT_RX_DATA_EVT:
      if (bta_hl_find_mdl_idx_using_handle(p_msg->ci_get_put_data.mdl_handle,
                                           &app_idx, &mcl_idx, &mdl_idx)) {
        found = true;
      }
      break;
    case BTA_HL_CI_GET_ECHO_DATA_EVT:
    case BTA_HL_CI_PUT_ECHO_DATA_EVT:
      if (bta_hl_find_mcl_idx_using_handle(
              p_msg->ci_get_put_echo_data.mcl_handle, &app_idx, &mcl_idx)) {
        p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
        mdl_idx = p_mcb->echo_mdl_idx;
        found = true;
      }
      break;

    default:
      break;
  }

  if (found) {
    *p_app_idx = app_idx;
    *p_mcl_idx = mcl_idx;
    *p_mdl_idx = mdl_idx;
  }
#if (BTA_HL_DEBUG == TRUE)
  if (!found) {
    APPL_TRACE_DEBUG(
        "bta_hl_find_dch_cb_indexes event=%s found=%d app_idx=%d mcl_idx=%d "
        "mdl_idx=%d",
        bta_hl_evt_code(p_msg->hdr.event), found, *p_app_idx, *p_mcl_idx,
        *p_mdl_idx);
  }
#endif

  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_allocate_mdl_id
 *
 * Description  This function allocates a MDL ID
 *
 * Returns      uint16_t - MDL ID
 *
 ******************************************************************************/
uint16_t bta_hl_allocate_mdl_id(uint8_t app_idx, uint8_t mcl_idx,
                                uint8_t mdl_idx) {
  uint16_t mdl_id = 0;
  tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
  bool duplicate_id;
  uint8_t i, mdl_cfg_idx;

  do {
    duplicate_id = false;
    mdl_id = ((mdl_id + 1) & 0xFEFF);
    /* check mdl_ids that are used for the current conenctions */
    for (i = 0; i < BTA_HL_NUM_MDLS_PER_MCL; i++) {
      if (p_mcb->mdl[i].in_use && (i != mdl_idx) &&
          (p_mcb->mdl[i].mdl_id == mdl_id)) {
        duplicate_id = true;
        break;
      }
    }

    if (duplicate_id) {
      /* start from the beginning to get another MDL value*/
      continue;
    } else {
      /* check mdl_ids that are stored in the persistent memory */
      if (bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, mdl_id, &mdl_cfg_idx)) {
        duplicate_id = true;
      } else {
        /* found a new MDL value */
        break;
      }
    }

  } while (true);

#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_allocate_mdl OK mdl_id=%d", mdl_id);
#endif
  return mdl_id;
}
/*******************************************************************************
 *
 * Function      bta_hl_find_mdl_idx
 *
 * Description  This function finds the MDL index based on mdl_id
 *
 * Returns      bool true-found
 *
 ******************************************************************************/
bool bta_hl_find_mdl_idx(uint8_t app_idx, uint8_t mcl_idx, uint16_t mdl_id,
                         uint8_t* p_mdl_idx) {
  tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
  bool found = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_MDLS_PER_MCL; i++) {
    if (p_mcb->mdl[i].in_use && (mdl_id != 0) &&
        (p_mcb->mdl[i].mdl_id == mdl_id)) {
      found = true;
      *p_mdl_idx = i;
      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!found) {
    APPL_TRACE_DEBUG("bta_hl_find_mdl_idx found=%d mdl_id=%d mdl_idx=%d ",
                     found, mdl_id, i);
  }
#endif

  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_an_active_mdl_idx
 *
 * Description  This function finds an active MDL
 *
 * Returns      bool true-found
 *
 ******************************************************************************/
bool bta_hl_find_an_active_mdl_idx(uint8_t app_idx, uint8_t mcl_idx,
                                   uint8_t* p_mdl_idx) {
  tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
  bool found = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_MDLS_PER_MCL; i++) {
    if (p_mcb->mdl[i].in_use &&
        (p_mcb->mdl[i].dch_state == BTA_HL_DCH_OPEN_ST)) {
      found = true;
      *p_mdl_idx = i;
      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (found) {
    APPL_TRACE_DEBUG(
        "bta_hl_find_an_opened_mdl_idx found=%d app_idx=%d mcl_idx=%d "
        "mdl_idx=%d",
        found, app_idx, mcl_idx, i);
  }
#endif

  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_dch_setup_mdl_idx
 *
 * Description  This function finds a MDL which in the DCH setup state
 *
 * Returns      bool true-found
 *
 ******************************************************************************/
bool bta_hl_find_dch_setup_mdl_idx(uint8_t app_idx, uint8_t mcl_idx,
                                   uint8_t* p_mdl_idx) {
  tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
  bool found = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_MDLS_PER_MCL; i++) {
    if (p_mcb->mdl[i].in_use &&
        (p_mcb->mdl[i].dch_state == BTA_HL_DCH_OPENING_ST)) {
      found = true;
      *p_mdl_idx = i;
      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (found) {
    APPL_TRACE_DEBUG(
        "bta_hl_find_dch_setup_mdl_idx found=%d app_idx=%d mcl_idx=%d "
        "mdl_idx=%d",
        found, app_idx, mcl_idx, i);
  }
#endif

  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_an_in_use_mcl_idx
 *
 * Description  This function finds an in-use MCL control block index
 *
 * Returns      bool true-found
 *
 ******************************************************************************/
bool bta_hl_find_an_in_use_mcl_idx(uint8_t app_idx, uint8_t* p_mcl_idx) {
  tBTA_HL_MCL_CB* p_mcb;
  bool found = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_MCLS; i++) {
    p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, i);
    if (p_mcb->in_use && (p_mcb->cch_state != BTA_HL_CCH_IDLE_ST)) {
      found = true;
      *p_mcl_idx = i;
      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (found) {
    APPL_TRACE_DEBUG(
        "bta_hl_find_an_in_use_mcl_idx found=%d app_idx=%d mcl_idx=%d ", found,
        app_idx, i);
  }
#endif

  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_an_in_use_app_idx
 *
 * Description  This function finds an in-use application control block index
 *
 * Returns      bool true-found
 *
 ******************************************************************************/
bool bta_hl_find_an_in_use_app_idx(uint8_t* p_app_idx) {
  tBTA_HL_APP_CB* p_acb;
  bool found = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_APPS; i++) {
    p_acb = BTA_HL_GET_APP_CB_PTR(i);
    if (p_acb->in_use) {
      found = true;
      *p_app_idx = i;
      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (found) {
    APPL_TRACE_DEBUG("bta_hl_find_an_in_use_app_idx found=%d app_idx=%d ",
                     found, i);
  }
#endif

  return found;
}
/*******************************************************************************
 *
 * Function      bta_hl_find_app_idx
 *
 * Description  This function finds the application control block index based on
 *              the application ID
 *
 * Returns      bool true-found
 *
 ******************************************************************************/
bool bta_hl_find_app_idx(uint8_t app_id, uint8_t* p_app_idx) {
  bool found = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_APPS; i++) {
    if (bta_hl_cb.acb[i].in_use && (bta_hl_cb.acb[i].app_id == app_id)) {
      found = true;
      *p_app_idx = i;
      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_find_app_idx found=%d app_id=%d idx=%d ", found,
                   app_id, i);
#endif

  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_app_idx_using_handle
 *
 * Description  This function finds the application control block index based on
 *              the application handle
 *
 * Returns      bool true-found
 *
 ******************************************************************************/
bool bta_hl_find_app_idx_using_handle(tBTA_HL_APP_HANDLE app_handle,
                                      uint8_t* p_app_idx) {
  bool found = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_APPS; i++) {
    if (bta_hl_cb.acb[i].in_use &&
        (bta_hl_cb.acb[i].app_handle == app_handle)) {
      found = true;
      *p_app_idx = i;
      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!found) {
    APPL_TRACE_DEBUG(
        "bta_hl_find_app_idx_using_mca_handle status=%d handle=%d app_idx=%d ",
        found, app_handle, i);
  }
#endif

  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_mcl_idx_using_handle
 *
 * Description  This function finds the MCL control block index based on
 *              the MCL handle
 *
 * Returns      bool true-found
 *
 ******************************************************************************/
bool bta_hl_find_mcl_idx_using_handle(tBTA_HL_MCL_HANDLE mcl_handle,
                                      uint8_t* p_app_idx, uint8_t* p_mcl_idx) {
  tBTA_HL_APP_CB* p_acb;
  bool found = false;
  uint8_t i = 0, j = 0;

  for (i = 0; i < BTA_HL_NUM_APPS; i++) {
    p_acb = BTA_HL_GET_APP_CB_PTR(i);
    if (p_acb->in_use) {
      for (j = 0; j < BTA_HL_NUM_MCLS; j++) {
        if (p_acb->mcb[j].mcl_handle == mcl_handle) {
          found = true;
          *p_app_idx = i;
          *p_mcl_idx = j;
          break;
        }
      }
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!found) {
    APPL_TRACE_DEBUG(
        "bta_hl_find_mcl_idx_using_handle found=%d app_idx=%d mcl_idx=%d",
        found, i, j);
  }
#endif
  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_mcl_idx
 *
 * Description  This function finds the MCL control block index based on
 *              the peer BD address
 *
 * Returns      bool true-found
 *
 ******************************************************************************/
bool bta_hl_find_mcl_idx(uint8_t app_idx, const RawAddress& p_bd_addr,
                         uint8_t* p_mcl_idx) {
  bool found = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_MCLS; i++) {
    if (bta_hl_cb.acb[app_idx].mcb[i].in_use &&
        bta_hl_cb.acb[app_idx].mcb[i].bd_addr == p_bd_addr) {
      found = true;
      *p_mcl_idx = i;
      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!found) {
    APPL_TRACE_DEBUG("bta_hl_find_mcl_idx found=%d idx=%d", found, i);
  }
#endif
  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_mdl_idx_using_handle
 *
 * Description  This function finds the MDL control block index based on
 *              the MDL handle
 *
 * Returns      bool true-found
 *
 ******************************************************************************/
bool bta_hl_find_mdl_idx_using_handle(tBTA_HL_MDL_HANDLE mdl_handle,
                                      uint8_t* p_app_idx, uint8_t* p_mcl_idx,
                                      uint8_t* p_mdl_idx) {
  tBTA_HL_APP_CB* p_acb;
  tBTA_HL_MCL_CB* p_mcb;
  tBTA_HL_MDL_CB* p_dcb;
  bool found = false;
  uint8_t i, j, k;

  for (i = 0; i < BTA_HL_NUM_APPS; i++) {
    p_acb = BTA_HL_GET_APP_CB_PTR(i);
    if (p_acb->in_use) {
      for (j = 0; j < BTA_HL_NUM_MCLS; j++) {
        p_mcb = BTA_HL_GET_MCL_CB_PTR(i, j);
        if (p_mcb->in_use) {
          for (k = 0; k < BTA_HL_NUM_MDLS_PER_MCL; k++) {
            p_dcb = BTA_HL_GET_MDL_CB_PTR(i, j, k);
            if (p_dcb->in_use) {
              if (p_dcb->mdl_handle == mdl_handle) {
                found = true;
                *p_app_idx = i;
                *p_mcl_idx = j;
                *p_mdl_idx = k;
                break;
              }
            }
          }
        }
      }
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!found) {
    APPL_TRACE_DEBUG(
        "bta_hl_find_mdl_idx_using_handle found=%d mdl_handle=%d  ", found,
        mdl_handle);
  }
#endif
  return found;
}
/*******************************************************************************
 *
 * Function      bta_hl_is_the_first_reliable_existed
 *
 * Description  This function checks whether the first reliable DCH channel
 *              has been setup on the MCL or not
 *
 * Returns      bool - true exist
 *                        false does not exist
 *
 ******************************************************************************/
bool bta_hl_is_the_first_reliable_existed(uint8_t app_idx, uint8_t mcl_idx) {
  tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
  bool is_existed = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_MDLS_PER_MCL; i++) {
    if (p_mcb->mdl[i].in_use && p_mcb->mdl[i].is_the_first_reliable) {
      is_existed = true;
      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_is_the_first_reliable_existed is_existed=%d  ",
                   is_existed);
#endif
  return is_existed;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_non_active_mdl_cfg
 *
 * Description  This function finds a valid MDL configiration index and this
 *              MDL ID is not active
 *
 * Returns      bool - true found
 *                        false not found
 *
 ******************************************************************************/
bool bta_hl_find_non_active_mdl_cfg(uint8_t app_idx, uint8_t start_mdl_cfg_idx,
                                    uint8_t* p_mdl_cfg_idx) {
  tBTA_HL_MCL_CB* p_mcb;
  tBTA_HL_MDL_CB* p_dcb;
  tBTA_HL_MDL_CFG* p_mdl;
  bool mdl_in_use;
  bool found = false;
  uint8_t i, j, k;

  for (i = start_mdl_cfg_idx; i < BTA_HL_NUM_MDL_CFGS; i++) {
    mdl_in_use = false;
    p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
    for (j = 0; j < BTA_HL_NUM_MCLS; j++) {
      p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, j);
      if (p_mcb->in_use && p_mdl->peer_bd_addr == p_mcb->bd_addr) {
        for (k = 0; k < BTA_HL_NUM_MDLS_PER_MCL; k++) {
          p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, j, k);

          if (p_dcb->in_use && p_mdl->mdl_id == p_dcb->mdl_id) {
            mdl_in_use = true;
            break;
          }
        }
      }

      if (mdl_in_use) {
        break;
      }
    }

    if (!mdl_in_use) {
      *p_mdl_cfg_idx = i;
      found = true;
      break;
    }
  }

  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_mdl_cfg_idx
 *
 * Description  This function finds an available MDL configuration index
 *
 * Returns      bool - true found
 *                        false not found
 *
 ******************************************************************************/
bool bta_hl_find_avail_mdl_cfg_idx(uint8_t app_idx, UNUSED_ATTR uint8_t mcl_idx,
                                   uint8_t* p_mdl_cfg_idx) {
  tBTA_HL_MDL_CFG *p_mdl, *p_mdl1, *p_mdl2;
  uint8_t i;
  bool found = false;
  uint8_t first_mdl_cfg_idx, second_mdl_cfg_idx, older_mdl_cfg_idx;
  bool done;

  for (i = 0; i < BTA_HL_NUM_MDL_CFGS; i++) {
    p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
    if (!p_mdl->active) {
      /* found an unused space to store mdl cfg*/
      found = true;
      *p_mdl_cfg_idx = i;
      break;
    }
  }

  if (!found) {
    /* all available mdl cfg spaces are in use so we need to find the mdl cfg
    which is
    not currently in use and has the the oldest time stamp to remove*/

    found = true;
    if (bta_hl_find_non_active_mdl_cfg(app_idx, 0, &first_mdl_cfg_idx)) {
      if (bta_hl_find_non_active_mdl_cfg(
              app_idx, (uint8_t)(first_mdl_cfg_idx + 1), &second_mdl_cfg_idx)) {
        done = false;
        while (!done) {
          p_mdl1 = BTA_HL_GET_MDL_CFG_PTR(app_idx, first_mdl_cfg_idx);
          p_mdl2 = BTA_HL_GET_MDL_CFG_PTR(app_idx, second_mdl_cfg_idx);

          if (p_mdl1->time < p_mdl2->time) {
            older_mdl_cfg_idx = first_mdl_cfg_idx;
          } else {
            older_mdl_cfg_idx = second_mdl_cfg_idx;
          }

          if (bta_hl_find_non_active_mdl_cfg(app_idx,
                                             (uint8_t)(second_mdl_cfg_idx + 1),
                                             &second_mdl_cfg_idx)) {
            first_mdl_cfg_idx = older_mdl_cfg_idx;
          } else {
            done = true;
          }
        }

        *p_mdl_cfg_idx = older_mdl_cfg_idx;

      } else {
        *p_mdl_cfg_idx = first_mdl_cfg_idx;
      }

    } else {
      found = false;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!found) {
    APPL_TRACE_DEBUG("bta_hl_find_avail_mdl_cfg_idx found=%d mdl_cfg_idx=%d ",
                     found, *p_mdl_cfg_idx);
  }
#endif

  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_mdl_cfg_idx
 *
 * Description  This function finds the MDL configuration index based on
 *              the MDL ID
 *
 * Returns      bool - true found
 *                        false not found
 *
 ******************************************************************************/
bool bta_hl_find_mdl_cfg_idx(uint8_t app_idx, uint8_t mcl_idx,
                             tBTA_HL_MDL_ID mdl_id, uint8_t* p_mdl_cfg_idx) {
  tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
  tBTA_HL_MDL_CFG* p_mdl;
  uint8_t i;
  bool found = false;

  *p_mdl_cfg_idx = 0;
  for (i = 0; i < BTA_HL_NUM_MDL_CFGS; i++) {
    p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
    if (p_mdl->active)
      APPL_TRACE_DEBUG("bta_hl_find_mdl_cfg_idx: mdl_id =%d, p_mdl->mdl_id=%d",
                       mdl_id, p_mdl->mdl_id);
    if (p_mdl->active && p_mcb->bd_addr == p_mdl->peer_bd_addr &&
        (p_mdl->mdl_id == mdl_id)) {
      found = true;
      *p_mdl_cfg_idx = i;
      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!found) {
    APPL_TRACE_DEBUG("bta_hl_find_mdl_cfg_idx found=%d mdl_cfg_idx=%d ", found,
                     i);
  }
#endif

  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_get_cur_time
 *
 * Description  This function get the cuurent time value
 *
 * Returns      bool - true found
 *                        false not found
 *
 ******************************************************************************/
bool bta_hl_get_cur_time(uint8_t app_idx, uint8_t* p_cur_time) {
  tBTA_HL_MDL_CFG* p_mdl;
  uint8_t i, j, time_latest, time;
  bool found = false, result = true;

  for (i = 0; i < BTA_HL_NUM_MDL_CFGS; i++) {
    p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
    if (p_mdl->active) {
      found = true;
      time_latest = p_mdl->time;
      for (j = (i + 1); j < BTA_HL_NUM_MDL_CFGS; j++) {
        p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, j);
        if (p_mdl->active) {
          time = p_mdl->time;
          if (time > time_latest) {
            time_latest = time;
          }
        }
      }
      break;
    }
  }

  if (found) {
    if (time_latest < BTA_HL_MAX_TIME) {
      *p_cur_time = time_latest + 1;
    } else {
      /* need to wrap around */
      result = false;
    }
  } else {
    *p_cur_time = BTA_HL_MIN_TIME;
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!result) {
    APPL_TRACE_DEBUG("bta_hl_get_cur_time result=%s cur_time=%d",
                     (result ? "OK" : "FAIL"), *p_cur_time);
  }
#endif

  return result;
}

/*******************************************************************************
 *
 * Function      bta_hl_sort_cfg_time_idx
 *
 * Description  This function sort the mdl configuration idx stored in array a
 *              based on decending time value
 *
 * Returns      bool - true found
 *                        false not found
 *
 ******************************************************************************/
void bta_hl_sort_cfg_time_idx(uint8_t app_idx, uint8_t* a, uint8_t n) {
  tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
  uint8_t temp_time, temp_idx;
  int16_t i, j;
  for (i = 1; i < n; ++i) {
    temp_idx = a[i];
    temp_time = p_acb->mdl_cfg[temp_idx].time;
    j = i - 1;
    while ((j >= 0) && (temp_time < p_acb->mdl_cfg[a[j]].time)) {
      a[j + 1] = a[j];
      --j;
    }
    a[j + 1] = temp_idx;
  }
}

/*******************************************************************************
 *
 * Function      bta_hl_compact_mdl_cfg_time
 *
 * Description  This function finds the MDL configuration index based on
 *              the MDL ID
 *
 * Returns      bool - true found
 *                        false not found
 *
 ******************************************************************************/
void bta_hl_compact_mdl_cfg_time(uint8_t app_idx, uint8_t mdep_id) {
  tBTA_HL_MDL_CFG* p_mdl;
  uint8_t i, time_min, cnt = 0;
  uint8_t s_arr[BTA_HL_NUM_MDL_CFGS];

  for (i = 0; i < BTA_HL_NUM_MDL_CFGS; i++) {
    p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
    if (p_mdl->active) {
      s_arr[cnt] = i;
      cnt++;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_compact_mdl_cfg_time cnt=%d ", cnt);
#endif

  if (cnt) {
    bta_hl_sort_cfg_time_idx(app_idx, s_arr, cnt);
    time_min = BTA_HL_MIN_TIME;
    for (i = 0; i < cnt; i++) {
      p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, s_arr[i]);
      p_mdl->time = time_min + i;
      bta_hl_co_save_mdl(mdep_id, s_arr[i], p_mdl);
    }
  }
}

/*******************************************************************************
 *
 * Function      bta_hl_is_mdl_exsit_in_mcl
 *
 * Description  This function checks whether the MDL ID
 *              has already existed in teh MCL or not
 *
 * Returns      bool - true exist
 *                        false does not exist
 *
 ******************************************************************************/
bool bta_hl_is_mdl_exsit_in_mcl(uint8_t app_idx, const RawAddress& bd_addr,
                                tBTA_HL_MDL_ID mdl_id) {
  tBTA_HL_MDL_CFG* p_mdl;
  bool found = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_MDL_CFGS; i++) {
    p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
    if (p_mdl->active && p_mdl->peer_bd_addr == bd_addr) {
      if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS) {
        if (p_mdl->mdl_id == mdl_id) {
          found = true;
          break;
        }
      } else {
        found = true;
        break;
      }
    }
  }

  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_delete_mdl_cfg
 *
 * Description  This function delete the specified MDL ID
 *
 * Returns      bool - true Success
 *                        false Failed
 *
 ******************************************************************************/
bool bta_hl_delete_mdl_cfg(uint8_t app_idx, const RawAddress& bd_addr,
                           tBTA_HL_MDL_ID mdl_id) {
  tBTA_HL_MDL_CFG* p_mdl;
  bool success = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_MDL_CFGS; i++) {
    p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
    if (p_mdl->active && p_mdl->peer_bd_addr == bd_addr) {
      if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS) {
        if (p_mdl->mdl_id == mdl_id) {
          bta_hl_co_delete_mdl(p_mdl->local_mdep_id, i);
          memset(p_mdl, 0, sizeof(tBTA_HL_MDL_CFG));
          success = true;
          break;
        }
      } else {
        bta_hl_co_delete_mdl(p_mdl->local_mdep_id, i);
        memset(p_mdl, 0, sizeof(tBTA_HL_MDL_CFG));
        success = true;
      }
    }
  }

  return success;
}

/*******************************************************************************
 *
 * Function      bta_hl_is_mdl_value_valid
 *
 *
 * Description  This function checks the specified MDL ID is in valid range.
 *
 * Returns      bool - true Success
 *                        false Failed
 *
 * note:   mdl_id range   0x0000 reserved,
 *                        0x0001-oxFEFF dynamic range,
 *                        0xFF00-0xFFFE reserved,
 *                        0xFFFF indicates all MDLs (for delete operation only)
 *
 ******************************************************************************/
bool bta_hl_is_mdl_value_valid(tBTA_HL_MDL_ID mdl_id) {
  bool status = true;

  if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS) {
    if (mdl_id != 0) {
      if (mdl_id > BTA_HL_MAX_MDL_VAL) {
        status = false;
      }
    } else {
      status = false;
    }
  }

  return status;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_mdep_cfg_idx
 *
 * Description  This function finds the MDEP configuration index based
 *                on the local MDEP ID
 *
 * Returns      bool - true found
 *                        false not found
 *
 ******************************************************************************/
bool bta_hl_find_mdep_cfg_idx(uint8_t app_idx, tBTA_HL_MDEP_ID local_mdep_id,
                              uint8_t* p_mdep_cfg_idx) {
  tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
  tBTA_HL_SUP_FEATURE* p_sup_feature = &p_acb->sup_feature;
  bool found = false;
  uint8_t i;

  for (i = 0; i < p_sup_feature->num_of_mdeps; i++) {
    if (p_sup_feature->mdep[i].mdep_id == local_mdep_id) {
      found = true;
      *p_mdep_cfg_idx = i;
      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!found) {
    APPL_TRACE_DEBUG(
        "bta_hl_find_mdep_cfg_idx found=%d mdep_idx=%d local_mdep_id=%d ",
        found, i, local_mdep_id);
  }
#endif
  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_rxtx_apdu_size
 *
 * Description  This function finds the maximum APDU rx and tx sizes based on
 *              the MDEP configuration data
 *
 * Returns      void
 *
 ******************************************************************************/
void bta_hl_find_rxtx_apdu_size(uint8_t app_idx, uint8_t mdep_cfg_idx,
                                uint16_t* p_rx_apu_size,
                                uint16_t* p_tx_apu_size) {
  tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
  tBTA_HL_MDEP_CFG* p_mdep_cfg;
  uint8_t i;
  uint16_t max_rx_apdu_size = 0, max_tx_apdu_size = 0;

  p_mdep_cfg = &p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg;

  for (i = 0; i < p_mdep_cfg->num_of_mdep_data_types; i++) {
    if (max_rx_apdu_size < p_mdep_cfg->data_cfg[i].max_rx_apdu_size) {
      max_rx_apdu_size = p_mdep_cfg->data_cfg[i].max_rx_apdu_size;
    }

    if (max_tx_apdu_size < p_mdep_cfg->data_cfg[i].max_tx_apdu_size) {
      max_tx_apdu_size = p_mdep_cfg->data_cfg[i].max_tx_apdu_size;
    }
  }

  *p_rx_apu_size = max_rx_apdu_size;
  *p_tx_apu_size = max_tx_apdu_size;

#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG(
      "bta_hl_find_rxtx_apdu_size max_rx_apdu_size=%d max_tx_apdu_size=%d ",
      max_rx_apdu_size, max_tx_apdu_size);
#endif
}

/*******************************************************************************
 *
 * Function      bta_hl_validate_peer_cfg
 *
 * Description  This function validates the peer DCH configuration
 *
 * Returns      bool - true validation is successful
 *                        false validation failed
 *
 ******************************************************************************/
bool bta_hl_validate_peer_cfg(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
                              tBTA_HL_MDEP_ID peer_mdep_id,
                              tBTA_HL_MDEP_ROLE peer_mdep_role,
                              uint8_t sdp_idx) {
  tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
  tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
  tBTA_HL_SDP_REC* p_rec;
  bool peer_found = false;
  uint8_t i;

  APPL_TRACE_DEBUG("bta_hl_validate_peer_cfg sdp_idx=%d app_idx %d", sdp_idx,
                   app_idx);

  if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID) {
    return true;
  }

  p_rec = &p_mcb->sdp.sdp_rec[sdp_idx];
  for (i = 0; i < p_rec->num_mdeps; i++) {
    APPL_TRACE_DEBUG("mdep_id %d peer_mdep_id %d", p_rec->mdep_cfg[i].mdep_id,
                     peer_mdep_id);
    APPL_TRACE_DEBUG("mdep_role %d peer_mdep_role %d",
                     p_rec->mdep_cfg[i].mdep_role, peer_mdep_role)
    if ((p_rec->mdep_cfg[i].mdep_id == peer_mdep_id) &&
        (p_rec->mdep_cfg[i].mdep_role == peer_mdep_role)) {
      peer_found = true;

      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!peer_found) {
    APPL_TRACE_DEBUG("bta_hl_validate_peer_cfg failed num_mdeps=%d",
                     p_rec->num_mdeps);
  }
#endif
  return peer_found;
}

/*******************************************************************************
 *
 * Function      bta_hl_chk_local_cfg
 *
 * Description  This function check whether the local DCH configuration is OK.
 *
 * Returns      tBTA_HL_STATUS - OK - local DCH configuration is OK
 *                               NO_FIRST_RELIABLE - the streaming DCH
 *                                                   configuration is not OK and
 *                                                   it needs to use reliable
 *                                                   DCH configuration
 *
 ******************************************************************************/
tBTA_HL_STATUS bta_hl_chk_local_cfg(uint8_t app_idx, uint8_t mcl_idx,
                                    uint8_t mdep_cfg_idx,
                                    tBTA_HL_DCH_CFG local_cfg) {
  tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
  tBTA_HL_STATUS status = BTA_HL_STATUS_OK;

  if (mdep_cfg_idx &&
      (p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.mdep_role ==
       BTA_HL_MDEP_ROLE_SOURCE) &&
      (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx)) &&
      (local_cfg != BTA_HL_DCH_CFG_RELIABLE)) {
    status = BTA_HL_STATUS_NO_FIRST_RELIABLE;
    APPL_TRACE_ERROR("BTA_HL_STATUS_INVALID_DCH_CFG");
  }

  return status;
}

/*******************************************************************************
 *
 * Function      bta_hl_validate_reconnect_params
 *
 * Description  This function validates the reconnect parameters
 *
 * Returns      bool - true validation is successful
 *                        false validation failed
 ******************************************************************************/
bool bta_hl_validate_reconnect_params(uint8_t app_idx, uint8_t mcl_idx,
                                      tBTA_HL_API_DCH_RECONNECT* p_reconnect,
                                      uint8_t* p_mdep_cfg_idx,
                                      uint8_t* p_mdl_cfg_idx) {
  tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
  tBTA_HL_SUP_FEATURE* p_sup_feature = &p_acb->sup_feature;
  uint8_t num_mdeps;
  uint8_t mdl_cfg_idx;
  bool local_mdep_id_found = false;
  bool mdl_cfg_found = false;
  bool status = false;
  uint8_t i, in_use_mdl_idx = 0;

#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_validate_reconnect_params  mdl_id=%d app_idx=%d",
                   p_reconnect->mdl_id, app_idx);
#endif
  if (bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, p_reconnect->mdl_id,
                              &mdl_cfg_idx)) {
    mdl_cfg_found = true;
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!mdl_cfg_found) {
    APPL_TRACE_DEBUG("mdl_cfg_found not found");
  }
#endif

  if (mdl_cfg_found) {
    num_mdeps = p_sup_feature->num_of_mdeps;
    for (i = 0; i < num_mdeps; i++) {
      if (p_sup_feature->mdep[i].mdep_id ==
          p_acb->mdl_cfg[mdl_cfg_idx].local_mdep_id) {
        local_mdep_id_found = true;
        *p_mdep_cfg_idx = i;
        *p_mdl_cfg_idx = mdl_cfg_idx;
        break;
      }
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!local_mdep_id_found) {
    APPL_TRACE_DEBUG("local_mdep_id not found");
  }
#endif

  if (local_mdep_id_found) {
    if (!bta_hl_find_mdl_idx(app_idx, mcl_idx, p_reconnect->mdl_id,
                             &in_use_mdl_idx)) {
      status = true;
    } else {
      APPL_TRACE_ERROR("mdl_id=%d is curreltly in use", p_reconnect->mdl_id);
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!status) {
    APPL_TRACE_DEBUG(
        "Reconnect validation failed local_mdep_id found=%d mdl_cfg_idx "
        "found=%d in_use_mdl_idx=%d ",
        local_mdep_id_found, mdl_cfg_found, in_use_mdl_idx);
  }
#endif
  return status;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_avail_mcl_idx
 *
 * Returns      bool - true found
 *                        false not found
 *
 ******************************************************************************/
bool bta_hl_find_avail_mcl_idx(uint8_t app_idx, uint8_t* p_mcl_idx) {
  bool found = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_MCLS; i++) {
    if (!bta_hl_cb.acb[app_idx].mcb[i].in_use) {
      found = true;
      *p_mcl_idx = i;
      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!found) {
    APPL_TRACE_DEBUG("bta_hl_find_avail_mcl_idx found=%d idx=%d", found, i);
  }
#endif
  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_avail_mdl_idx
 *
 * Description  This function finds an available MDL control block index
 *
 * Returns      bool - true found
 *                        false not found
 *
 ******************************************************************************/
bool bta_hl_find_avail_mdl_idx(uint8_t app_idx, uint8_t mcl_idx,
                               uint8_t* p_mdl_idx) {
  tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
  bool found = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_MDLS_PER_MCL; i++) {
    if (!p_mcb->mdl[i].in_use) {
      memset((void*)&p_mcb->mdl[i], 0, sizeof(tBTA_HL_MDL_CB));
      found = true;
      *p_mdl_idx = i;
      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!found) {
    APPL_TRACE_DEBUG("bta_hl_find_avail_mdl_idx found=%d idx=%d", found, i);
  }
#endif
  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_is_a_duplicate_id
 *
 * Description  This function finds the application has been used or not
 *
 * Returns      bool - true the app_id is a duplicate ID
 *                        false not a duplicate ID
 ******************************************************************************/
bool bta_hl_is_a_duplicate_id(uint8_t app_id) {
  bool is_duplicate = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_APPS; i++) {
    if (bta_hl_cb.acb[i].in_use && (bta_hl_cb.acb[i].app_id == app_id)) {
      is_duplicate = true;

      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (is_duplicate) {
    APPL_TRACE_DEBUG("bta_hl_is_a_duplicate_id app_id=%d is_duplicate=%d",
                     app_id, is_duplicate);
  }
#endif

  return is_duplicate;
}

/*******************************************************************************
 *
 * Function      bta_hl_find_avail_app_idx
 *
 * Description  This function finds an available application control block index
 *
 * Returns      bool - true found
 *                        false not found
 *
 ******************************************************************************/
bool bta_hl_find_avail_app_idx(uint8_t* p_idx) {
  bool found = false;
  uint8_t i;

  for (i = 0; i < BTA_HL_NUM_APPS; i++) {
    if (!bta_hl_cb.acb[i].in_use) {
      found = true;
      *p_idx = i;
      break;
    }
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!found) {
    APPL_TRACE_DEBUG("bta_hl_find_avail_app_idx found=%d app_idx=%d", found, i);
  }
#endif
  return found;
}

/*******************************************************************************
 *
 * Function      bta_hl_app_update
 *
 * Description  This function registers an HDP application MCAP and DP
 *
 * Returns      tBTA_HL_STATUS -registration status
 *
 ******************************************************************************/
tBTA_HL_STATUS bta_hl_app_update(uint8_t app_id, bool is_register) {
  tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
  tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(0);
  tMCA_CS mca_cs;
  uint8_t i, mdep_idx, num_of_mdeps;
  uint8_t mdep_counter = 0;

#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_app_update app_id=%d", app_id);
#endif

  if (is_register) {
    if ((status == BTA_HL_STATUS_OK) &&
        bta_hl_co_get_num_of_mdep(app_id, &num_of_mdeps)) {
      for (i = 0; i < num_of_mdeps; i++) {
        mca_cs.type = MCA_TDEP_DATA;
        mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
        mca_cs.p_data_cback = bta_hl_mcap_data_cback;
        /* Find the first available mdep index, and create a MDL Endpoint */
        // make a function later if needed
        for (mdep_idx = 1; mdep_idx < BTA_HL_NUM_MDEPS; mdep_idx++) {
          if (p_acb->sup_feature.mdep[mdep_idx].mdep_id == 0) {
            break; /* We found an available index */
          } else {
            mdep_counter++;
          }
        }
        /* If no available MDEPs, return error */
        if (mdep_idx == BTA_HL_NUM_MDEPS) {
          APPL_TRACE_ERROR("bta_hl_app_update: Out of MDEP IDs");
          status = BTA_HL_STATUS_MCAP_REG_FAIL;
          break;
        }
        if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
                          &(p_acb->sup_feature.mdep[mdep_idx].mdep_id),
                          &mca_cs) == MCA_SUCCESS) {
          if (bta_hl_co_get_mdep_config(
                  app_id, mdep_idx, mdep_counter,
                  p_acb->sup_feature.mdep[mdep_idx].mdep_id,
                  &p_acb->sup_feature.mdep[mdep_idx].mdep_cfg)) {
            p_acb->sup_feature.mdep[mdep_idx].ori_app_id = app_id;
            APPL_TRACE_DEBUG("mdep idx %d id %d ori_app_id %d num data type %d",
                             mdep_idx,
                             p_acb->sup_feature.mdep[mdep_idx].mdep_id,
                             p_acb->sup_feature.mdep[mdep_idx].ori_app_id,
                             p_acb->sup_feature.mdep[mdep_idx]
                                 .mdep_cfg.num_of_mdep_data_types);
            if (p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role ==
                BTA_HL_MDEP_ROLE_SOURCE) {
              p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SOURCE;
            } else if (p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role ==
                       BTA_HL_MDEP_ROLE_SINK) {
              p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SINK;
            } else {
              APPL_TRACE_ERROR(
                  "bta_hl_app_registration: Invalid Role %d",
                  p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role);
              status = BTA_HL_STATUS_MDEP_CO_FAIL;
              break;
            }
          } else {
            APPL_TRACE_ERROR("bta_hl_app_registration: Cfg callout failed");
            status = BTA_HL_STATUS_MDEP_CO_FAIL;
            break;
          }
        } else {
          APPL_TRACE_ERROR("bta_hl_app_registration: MCA_CreateDep failed");
          status = BTA_HL_STATUS_MCAP_REG_FAIL;
          break;
        }
      }
      p_acb->sup_feature.num_of_mdeps += num_of_mdeps;
      APPL_TRACE_DEBUG("num_of_mdeps %d", p_acb->sup_feature.num_of_mdeps);

      if ((status == BTA_HL_STATUS_OK) &&
          (p_acb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE)) {
        p_acb->sup_feature.advertize_source_sdp =
            bta_hl_co_advrtise_source_sdp(app_id);
      }

      if ((status == BTA_HL_STATUS_OK) &&
          (!bta_hl_co_get_echo_config(app_id, &p_acb->sup_feature.echo_cfg))) {
        status = BTA_HL_STATUS_ECHO_CO_FAIL;
      }

      if ((status == BTA_HL_STATUS_OK) &&
          (!bta_hl_co_load_mdl_config(app_id, BTA_HL_NUM_MDL_CFGS,
                                      &p_acb->mdl_cfg[0]))) {
        status = BTA_HL_STATUS_MDL_CFG_CO_FAIL;
      }
    } else {
      status = BTA_HL_STATUS_MDEP_CO_FAIL;
    }
  } else {
    for (i = 1; i < BTA_HL_NUM_MDEPS; i++) {
      if (p_acb->sup_feature.mdep[i].ori_app_id == app_id) {
        APPL_TRACE_DEBUG("Found index %", i);

        if (MCA_DeleteDep((tMCA_HANDLE)p_acb->app_handle,
                          (p_acb->sup_feature.mdep[i].mdep_id)) !=
            MCA_SUCCESS) {
          APPL_TRACE_ERROR("Error deregistering");
          status = BTA_HL_STATUS_MCAP_REG_FAIL;
          return status;
        }
        memset(&p_acb->sup_feature.mdep[i], 0, sizeof(tBTA_HL_MDEP));
      }
    }
  }

  if (status == BTA_HL_STATUS_OK) {
    /* Register/Update MDEP(s) in SDP Record */
    status = bta_hl_sdp_update(app_id);
  }
  /* else do cleanup */

  return status;
}

/*******************************************************************************
 *
 * Function      bta_hl_app_registration
 *
 * Description  This function registers an HDP application MCAP and DP
 *
 * Returns      tBTA_HL_STATUS -registration status
 *
 ******************************************************************************/
tBTA_HL_STATUS bta_hl_app_registration(uint8_t app_idx) {
  tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
  tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
  tMCA_REG reg;
  tMCA_CS mca_cs;
  uint8_t i, num_of_mdeps;
  uint8_t mdep_counter = 0;

#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_app_registration app_idx=%d", app_idx);
#endif

  reg.ctrl_psm = p_acb->ctrl_psm;
  reg.data_psm = p_acb->data_psm;
  reg.sec_mask = p_acb->sec_mask;
  reg.rsp_tout = BTA_HL_MCAP_RSP_TOUT;

  p_acb->app_handle =
      (tBTA_HL_APP_HANDLE)MCA_Register(&reg, bta_hl_mcap_ctrl_cback);
  if (p_acb->app_handle != 0) {
    mca_cs.type = MCA_TDEP_ECHO;
    mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
    mca_cs.p_data_cback = bta_hl_mcap_data_cback;

    if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
                      &(p_acb->sup_feature.mdep[0].mdep_id),
                      &mca_cs) == MCA_SUCCESS) {
      if (p_acb->sup_feature.mdep[0].mdep_id != BTA_HL_ECHO_TEST_MDEP_ID) {
        status = BTA_HL_STATUS_MCAP_REG_FAIL;
        APPL_TRACE_ERROR("BAD MDEP ID for echo test mdep_id=%d",
                         p_acb->sup_feature.mdep[0].mdep_id);
      }
    } else {
      status = BTA_HL_STATUS_MCAP_REG_FAIL;
      APPL_TRACE_ERROR("MCA_CreateDep for echo test(mdep_id=0) failed");
    }

    if ((status == BTA_HL_STATUS_OK) &&
        bta_hl_co_get_num_of_mdep(p_acb->app_id, &num_of_mdeps)) {
      p_acb->sup_feature.num_of_mdeps = num_of_mdeps + 1;

      for (i = 1; i < p_acb->sup_feature.num_of_mdeps; i++) {
        mca_cs.type = MCA_TDEP_DATA;
        mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
        mca_cs.p_data_cback = bta_hl_mcap_data_cback;

        if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
                          &(p_acb->sup_feature.mdep[i].mdep_id),
                          &mca_cs) == MCA_SUCCESS) {
          if (bta_hl_co_get_mdep_config(p_acb->app_id, i, mdep_counter,
                                        p_acb->sup_feature.mdep[i].mdep_id,
                                        &p_acb->sup_feature.mdep[i].mdep_cfg)) {
            if (p_acb->sup_feature.mdep[i].mdep_cfg.mdep_role ==
                BTA_HL_MDEP_ROLE_SOURCE) {
              p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SOURCE;
            } else if (p_acb->sup_feature.mdep[i].mdep_cfg.mdep_role ==
                       BTA_HL_MDEP_ROLE_SINK) {
              p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SINK;
            } else {
              status = BTA_HL_STATUS_MDEP_CO_FAIL;
              break;
            }
            p_acb->sup_feature.mdep[i].ori_app_id = p_acb->app_id;
            APPL_TRACE_DEBUG("index %d ori_app_id %d", i,
                             p_acb->sup_feature.mdep[i].ori_app_id);
          } else {
            status = BTA_HL_STATUS_MDEP_CO_FAIL;
            break;
          }
        } else {
          status = BTA_HL_STATUS_MCAP_REG_FAIL;
          break;
        }
      }

      if ((status == BTA_HL_STATUS_OK) &&
          (p_acb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE)) {
        /* this is a source only applciation */
        p_acb->sup_feature.advertize_source_sdp =
            bta_hl_co_advrtise_source_sdp(p_acb->app_id);
      }

      if ((status == BTA_HL_STATUS_OK) &&
          (!bta_hl_co_get_echo_config(p_acb->app_id,
                                      &p_acb->sup_feature.echo_cfg))) {
        status = BTA_HL_STATUS_ECHO_CO_FAIL;
      }

      if ((status == BTA_HL_STATUS_OK) &&
          (!bta_hl_co_load_mdl_config(p_acb->app_id, BTA_HL_NUM_MDL_CFGS,
                                      &p_acb->mdl_cfg[0]))) {
        status = BTA_HL_STATUS_MDL_CFG_CO_FAIL;
      }
    } else {
      status = BTA_HL_STATUS_MDEP_CO_FAIL;
    }
  } else {
    status = BTA_HL_STATUS_MCAP_REG_FAIL;
  }

  if (status == BTA_HL_STATUS_OK) {
    status = bta_hl_sdp_register(app_idx);
  }

  return status;
}

/*******************************************************************************
 *
 * Function         bta_hl_discard_data
 *
 * Description  This function discard an HDP event
 *
 * Returns     void
 *
 ******************************************************************************/
void bta_hl_discard_data(uint16_t event, tBTA_HL_DATA* p_data) {
#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_ERROR("BTA HL Discard event=%s", bta_hl_evt_code(event));

#endif

  switch (event) {
    case BTA_HL_API_SEND_DATA_EVT:
      break;

    case BTA_HL_MCA_RCV_DATA_EVT:
      osi_free_and_reset((void**)&p_data->mca_rcv_data_evt.p_pkt);
      break;

    default:
      /*Nothing to free*/
      break;
  }
}

/*******************************************************************************
 *
 * Function         bta_hl_save_mdl_cfg
 *
 * Description    This function saves the MDL configuration
 *
 * Returns     void
 *
 ******************************************************************************/
void bta_hl_save_mdl_cfg(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx) {
  tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
  tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
  tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
  uint8_t mdl_cfg_idx;
  tBTA_HL_MDL_ID mdl_id;
  bool found = true;
  tBTA_HL_MDL_CFG mdl_cfg;
  tBTA_HL_MDEP* p_mdep_cfg;
  tBTA_HL_L2CAP_CFG_INFO l2cap_cfg;
  uint8_t time_val = 0;
  mdl_id = p_dcb->mdl_id;
  if (!bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, mdl_id, &mdl_cfg_idx)) {
    if (!bta_hl_find_avail_mdl_cfg_idx(app_idx, mcl_idx, &mdl_cfg_idx)) {
      APPL_TRACE_ERROR("No space to save the MDL config");
      found = false; /*no space available*/
    }
  }

  if (found) {
    bta_hl_get_l2cap_cfg(p_dcb->mdl_handle, &l2cap_cfg);
    if (!bta_hl_get_cur_time(app_idx, &time_val)) {
      bta_hl_compact_mdl_cfg_time(app_idx, p_dcb->local_mdep_id);
      bta_hl_get_cur_time(app_idx, &time_val);
    }
    mdl_cfg.active = true;
    mdl_cfg.time = time_val;
    mdl_cfg.mdl_id = p_dcb->mdl_id;
    mdl_cfg.dch_mode = p_dcb->dch_mode;
    mdl_cfg.mtu = l2cap_cfg.mtu;
    mdl_cfg.fcs = l2cap_cfg.fcs;

    mdl_cfg.peer_bd_addr = p_mcb->bd_addr;
    mdl_cfg.local_mdep_id = p_dcb->local_mdep_id;
    p_mdep_cfg = &p_acb->sup_feature.mdep[p_dcb->local_mdep_cfg_idx];
    mdl_cfg.local_mdep_role = p_mdep_cfg->mdep_cfg.mdep_role;
    memcpy(&p_acb->mdl_cfg[mdl_cfg_idx], &mdl_cfg, sizeof(tBTA_HL_MDL_CFG));
    bta_hl_co_save_mdl(mdl_cfg.local_mdep_id, mdl_cfg_idx, &mdl_cfg);
  }

#if (BTA_HL_DEBUG == TRUE)
  if (found) {
    if (p_dcb->mtu != l2cap_cfg.mtu) {
      APPL_TRACE_WARNING(
          "MCAP and L2CAP peer mtu size out of sync from MCAP mtu=%d from "
          "l2cap mtu=%d",
          p_dcb->mtu, l2cap_cfg.mtu);
    }
    APPL_TRACE_DEBUG("bta_hl_save_mdl_cfg saved=%d", found);
    APPL_TRACE_DEBUG("Saved. L2cap cfg mdl_id=%d mtu=%d fcs=%d dch_mode=%d",
                     mdl_cfg.mdl_id, mdl_cfg.mtu, mdl_cfg.fcs,
                     mdl_cfg.dch_mode);
  }
#endif
}

/*******************************************************************************
 *
 * Function      bta_hl_set_dch_chan_cfg
 *
 * Description    This function setups the L2CAP DCH channel configuration
 *
 * Returns     void
 ******************************************************************************/
void bta_hl_set_dch_chan_cfg(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
                             tBTA_HL_DATA* p_data) {
  tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
  tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
  uint8_t l2cap_mode = L2CAP_FCR_ERTM_MODE;
  tBTA_HL_SUP_FEATURE* p_sup_feature = &p_acb->sup_feature;
  uint8_t local_mdep_cfg_idx = p_dcb->local_mdep_cfg_idx;

  switch (p_dcb->dch_oper) {
    case BTA_HL_DCH_OP_LOCAL_RECONNECT:
    case BTA_HL_DCH_OP_REMOTE_RECONNECT:
      if (p_dcb->dch_mode == BTA_HL_DCH_MODE_STREAMING)
        l2cap_mode = L2CAP_FCR_STREAM_MODE;
      break;
    case BTA_HL_DCH_OP_LOCAL_OPEN:
      if (p_data->mca_evt.mca_data.create_cfm.cfg == BTA_HL_DCH_CFG_STREAMING)
        l2cap_mode = L2CAP_FCR_STREAM_MODE;
      break;
    case BTA_HL_DCH_OP_REMOTE_OPEN:
      if (p_dcb->local_cfg == BTA_HL_DCH_CFG_STREAMING)
        l2cap_mode = L2CAP_FCR_STREAM_MODE;
      break;
    default:
      APPL_TRACE_ERROR("Invalid dch oper=%d for set dch chan cfg",
                       p_dcb->dch_oper);
      break;
  }
  p_dcb->chnl_cfg.fcr_opt.mode = l2cap_mode;
  p_dcb->chnl_cfg.fcr_opt.mps = bta_hl_set_mps(p_dcb->max_rx_apdu_size);
  p_dcb->chnl_cfg.fcr_opt.tx_win_sz = bta_hl_set_tx_win_size(
      p_dcb->max_rx_apdu_size, p_dcb->chnl_cfg.fcr_opt.mps);
  p_dcb->chnl_cfg.fcr_opt.max_transmit = BTA_HL_L2C_MAX_TRANSMIT;
  p_dcb->chnl_cfg.fcr_opt.rtrans_tout = BTA_HL_L2C_RTRANS_TOUT;
  p_dcb->chnl_cfg.fcr_opt.mon_tout = BTA_HL_L2C_MON_TOUT;

  p_dcb->chnl_cfg.user_rx_buf_size =
      bta_hl_set_user_rx_buf_size(p_dcb->max_rx_apdu_size);
  p_dcb->chnl_cfg.user_tx_buf_size =
      bta_hl_set_user_tx_buf_size(p_dcb->max_tx_apdu_size);
  p_dcb->chnl_cfg.fcr_rx_buf_size = L2CAP_INVALID_ERM_BUF_SIZE;
  p_dcb->chnl_cfg.fcr_tx_buf_size = L2CAP_INVALID_ERM_BUF_SIZE;
  p_dcb->chnl_cfg.data_mtu = p_dcb->max_rx_apdu_size;

  p_dcb->chnl_cfg.fcs = BTA_HL_MCA_NO_FCS;
  if (local_mdep_cfg_idx != BTA_HL_ECHO_TEST_MDEP_CFG_IDX) {
    if (p_sup_feature->mdep[local_mdep_cfg_idx].mdep_cfg.mdep_role ==
        BTA_HL_MDEP_ROLE_SOURCE) {
      p_dcb->chnl_cfg.fcs = BTA_HL_DEFAULT_SOURCE_FCS;
    }
  } else {
    p_dcb->chnl_cfg.fcs = BTA_HL_MCA_USE_FCS;
  }

#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("L2CAP Params l2cap_mode[3-ERTM 4-STREAM]=%d", l2cap_mode);
  APPL_TRACE_DEBUG("Use FCS =%s mtu=%d",
                   ((p_dcb->chnl_cfg.fcs & 1) ? "YES" : "NO"),
                   p_dcb->chnl_cfg.data_mtu);
  APPL_TRACE_DEBUG(
      "tx_win_sz=%d, max_transmit=%d, rtrans_tout=%d, mon_tout=%d, mps=%d",
      p_dcb->chnl_cfg.fcr_opt.tx_win_sz, p_dcb->chnl_cfg.fcr_opt.max_transmit,
      p_dcb->chnl_cfg.fcr_opt.rtrans_tout, p_dcb->chnl_cfg.fcr_opt.mon_tout,
      p_dcb->chnl_cfg.fcr_opt.mps);

  APPL_TRACE_DEBUG(
      "USER rx_buf_size=%d, tx_buf_size=%d, FCR rx_buf_size=%d, tx_buf_size=%d",
      p_dcb->chnl_cfg.user_rx_buf_size, p_dcb->chnl_cfg.user_tx_buf_size,
      p_dcb->chnl_cfg.fcr_rx_buf_size, p_dcb->chnl_cfg.fcr_tx_buf_size);

#endif
}

/*******************************************************************************
 *
 * Function      bta_hl_get_l2cap_cfg
 *
 * Description    This function get the current L2CAP channel configuration
 *
 * Returns     bool - true - operation is successful
 ******************************************************************************/
bool bta_hl_get_l2cap_cfg(tBTA_HL_MDL_HANDLE mdl_hnd,
                          tBTA_HL_L2CAP_CFG_INFO* p_cfg) {
  bool success = false;
  uint16_t lcid;
  tL2CAP_CFG_INFO* p_our_cfg;
  tL2CAP_CH_CFG_BITS our_cfg_bits;
  tL2CAP_CFG_INFO* p_peer_cfg;
  tL2CAP_CH_CFG_BITS peer_cfg_bits;

  lcid = MCA_GetL2CapChannel((tMCA_DL)mdl_hnd);
  if (lcid && L2CA_GetCurrentConfig(lcid, &p_our_cfg, &our_cfg_bits,
                                    &p_peer_cfg, &peer_cfg_bits)) {
    p_cfg->fcs = BTA_HL_MCA_NO_FCS;
    if (our_cfg_bits & L2CAP_CH_CFG_MASK_FCS) {
      p_cfg->fcs |= p_our_cfg->fcs;
    } else {
      p_cfg->fcs = BTA_HL_MCA_USE_FCS;
    }

    if (p_cfg->fcs != BTA_HL_MCA_USE_FCS) {
      if (peer_cfg_bits & L2CAP_CH_CFG_MASK_FCS) {
        p_cfg->fcs |= p_peer_cfg->fcs;
      } else {
        p_cfg->fcs = BTA_HL_MCA_USE_FCS;
      }
    }

    p_cfg->mtu = 0;
    if (peer_cfg_bits & L2CAP_CH_CFG_MASK_MTU) {
      p_cfg->mtu = p_peer_cfg->mtu;
    } else {
      p_cfg->mtu = L2CAP_DEFAULT_MTU;
    }
    success = true;
  } else {
    p_cfg->mtu = L2CAP_DEFAULT_MTU;
    p_cfg->fcs = BTA_HL_L2C_NO_FCS;
  }

#if (BTA_HL_DEBUG == TRUE)
  if (!success) {
    APPL_TRACE_DEBUG("bta_hl_get_l2cap_cfg success=%d mdl=%d lcid=%d", success,
                     mdl_hnd, lcid);
    APPL_TRACE_DEBUG("l2cap mtu=%d fcs=%d", p_cfg->mtu, p_cfg->fcs);
  }
#endif

  return success;
}

/*******************************************************************************
 *
 * Function      bta_hl_validate_chan_cfg
 *
 * Description    This function validates the L2CAP channel configuration
 *
 * Returns     bool - true - validation is successful
 ******************************************************************************/
bool bta_hl_validate_chan_cfg(uint8_t app_idx, uint8_t mcl_idx,
                              uint8_t mdl_idx) {
  tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
  tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
  bool success = false;
  uint8_t mdl_cfg_idx = 0;
  tBTA_HL_L2CAP_CFG_INFO l2cap_cfg;
  bool get_l2cap_result, get_mdl_result;

  get_l2cap_result = bta_hl_get_l2cap_cfg(p_dcb->mdl_handle, &l2cap_cfg);
  get_mdl_result =
      bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, p_dcb->mdl_id, &mdl_cfg_idx);

  if (get_l2cap_result && get_mdl_result) {
    if ((p_acb->mdl_cfg[mdl_cfg_idx].mtu <= l2cap_cfg.mtu) &&
        (p_acb->mdl_cfg[mdl_cfg_idx].fcs == l2cap_cfg.fcs) &&
        (p_acb->mdl_cfg[mdl_cfg_idx].dch_mode == p_dcb->dch_mode)) {
      success = true;
    }
  }

#if (BTA_HL_DEBUG == TRUE)

  if (p_dcb->mtu != l2cap_cfg.mtu) {
    APPL_TRACE_WARNING(
        "MCAP and L2CAP peer mtu size out of sync from MCAP mtu=%d from l2cap "
        "mtu=%d",
        p_dcb->mtu, l2cap_cfg.mtu);
  }

  if (!success) {
    APPL_TRACE_DEBUG(
        "bta_hl_validate_chan_cfg success=%d app_idx=%d mcl_idx=%d mdl_idx=%d",
        success, app_idx, mcl_idx, mdl_idx);
    APPL_TRACE_DEBUG("Cur. L2cap cfg mtu=%d fcs=%d dch_mode=%d", l2cap_cfg.mtu,
                     l2cap_cfg.fcs, p_dcb->dch_mode);
    APPL_TRACE_DEBUG("From saved: L2cap cfg mtu=%d fcs=%d dch_mode=%d",
                     p_acb->mdl_cfg[mdl_cfg_idx].mtu,
                     p_acb->mdl_cfg[mdl_cfg_idx].fcs,
                     p_acb->mdl_cfg[mdl_cfg_idx].dch_mode);
  }
#endif

  return success;
}

/*******************************************************************************
 *
 * Function      bta_hl_is_cong_on
 *
 * Description    This function checks whether the congestion condition is on.
 *
 * Returns      bool - true DCH is congested
 *                        false not congested
 *
 ******************************************************************************/
bool bta_hl_is_cong_on(uint8_t app_id, const RawAddress& bd_addr,
                       tBTA_HL_MDL_ID mdl_id)

{
  tBTA_HL_MDL_CB* p_dcb;
  uint8_t app_idx = 0, mcl_idx, mdl_idx;
  bool cong_status = true;

  if (bta_hl_find_app_idx(app_id, &app_idx)) {
    if (bta_hl_find_mcl_idx(app_idx, bd_addr, &mcl_idx)) {
      if (bta_hl_find_mdl_idx(app_idx, mcl_idx, mdl_id, &mdl_idx)) {
        p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
        cong_status = p_dcb->cong;
      }
    }
  }

  return cong_status;
}

/*******************************************************************************
 *
 * Function      bta_hl_check_cch_close
 *
 * Description   This function checks whether there is a pending CCH close
 *               request or not
 *
 * Returns      void
 ******************************************************************************/
void bta_hl_check_cch_close(uint8_t app_idx, uint8_t mcl_idx,
                            tBTA_HL_DATA* p_data, bool check_dch_setup) {
  tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
  tBTA_HL_MDL_CB* p_dcb;
  uint8_t mdl_idx;

#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_check_cch_close cch_close_dch_oper=%d",
                   p_mcb->cch_close_dch_oper);
#endif

  if (p_mcb->cch_oper == BTA_HL_CCH_OP_LOCAL_CLOSE) {
    if (check_dch_setup &&
        bta_hl_find_dch_setup_mdl_idx(app_idx, mcl_idx, &mdl_idx)) {
      p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
      if (!p_mcb->rsp_tout) {
        p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_ABORT;

        if (!p_dcb->abort_oper) {
          p_dcb->abort_oper |= BTA_HL_ABORT_CCH_CLOSE_MASK;
          bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_ABORT_EVT,
                                p_data);
        }
      } else {
        p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_CLOSE;
        bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
                              BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
      }
    } else if (bta_hl_find_an_active_mdl_idx(app_idx, mcl_idx, &mdl_idx)) {
      p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_CLOSE;
      bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_EVT,
                            p_data);
    } else {
      p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_NONE;
      bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_CLOSE_EVT, p_data);
    }
  }
}

/*******************************************************************************
 *
 * Function         bta_hl_clean_app
 *
 * Description      Cleans up the HDP application resources and control block
 *
 * Returns          void
 *
 ******************************************************************************/
void bta_hl_clean_app(uint8_t app_idx) {
  tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
  int i, num_act_apps = 0;

#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_clean_app");
#endif
  MCA_Deregister((tMCA_HANDLE)p_acb->app_handle);

  if (p_acb->sdp_handle) SDP_DeleteRecord(p_acb->sdp_handle);

  memset((void*)p_acb, 0, sizeof(tBTA_HL_APP_CB));

  /* check any application is still active */
  for (i = 0; i < BTA_HL_NUM_APPS; i++) {
    p_acb = BTA_HL_GET_APP_CB_PTR(i);
    if (p_acb->in_use) num_act_apps++;
  }

  if (!num_act_apps) {
    bta_sys_remove_uuid(UUID_SERVCLASS_HDP_PROFILE);
  }
}

/*******************************************************************************
 *
 * Function      bta_hl_check_deregistration
 *
 * Description   This function checks whether there is a pending deregistration
 *               request or not
 *
 * Returns      void
 ******************************************************************************/
void bta_hl_check_deregistration(uint8_t app_idx, tBTA_HL_DATA* p_data) {
  tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
  tBTA_HL_MCL_CB* p_mcb;
  uint8_t mcl_idx;
  tBTA_HL evt_data;

#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_check_deregistration");
#endif

  if (p_acb->deregistering) {
    if (bta_hl_find_an_in_use_mcl_idx(app_idx, &mcl_idx)) {
      p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
      if (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_CLOSE) {
        if (p_mcb->cch_state == BTA_HL_CCH_OPENING_ST)
          p_mcb->force_close_local_cch_opening = true;
        p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_CLOSE;
        APPL_TRACE_DEBUG("p_mcb->force_close_local_cch_opening=%d",
                         p_mcb->force_close_local_cch_opening);
        bta_hl_check_cch_close(app_idx, mcl_idx, p_data, true);
      }
    } else {
      /* all cchs are closed */
      evt_data.dereg_cfm.app_handle = p_acb->app_handle;
      evt_data.dereg_cfm.app_id = p_data->api_dereg.app_id;
      evt_data.dereg_cfm.status = BTA_HL_STATUS_OK;
      p_acb->p_cback(BTA_HL_DEREGISTER_CFM_EVT, (tBTA_HL*)&evt_data);
      bta_hl_clean_app(app_idx);
      bta_hl_check_disable(p_data);
    }
  }
}

/*******************************************************************************
 *
 * Function      bta_hl_check_disable
 *
 * Description   This function checks whether there is a pending disable
 *               request or not
 *
 * Returns      void
 *
 ******************************************************************************/
void bta_hl_check_disable(tBTA_HL_DATA* p_data) {
  tBTA_HL_CB* p_cb = &bta_hl_cb;
  tBTA_HL_APP_CB* p_acb;
  uint8_t app_idx;
  tBTA_HL_CTRL evt_data;

#if (BTA_HL_DEBUG == TRUE)
  APPL_TRACE_DEBUG("bta_hl_check_disable");
#endif

  if (bta_hl_cb.disabling) {
    if (bta_hl_find_an_in_use_app_idx(&app_idx)) {
      p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
      if (!p_acb->deregistering) {
        p_acb->deregistering = true;
        bta_hl_check_deregistration(app_idx, p_data);
      }
    } else {
      /* all apps are deregistered */
      bta_sys_deregister(BTA_ID_HL);
      evt_data.disable_cfm.status = BTA_HL_STATUS_OK;
      if (p_cb->p_ctrl_cback)
        p_cb->p_ctrl_cback(BTA_HL_CTRL_DISABLE_CFM_EVT,
                           (tBTA_HL_CTRL*)&evt_data);
      memset((void*)p_cb, 0, sizeof(tBTA_HL_CB));
    }
  }
}

/*******************************************************************************
 *
 * Function      bta_hl_build_abort_cfm
 *
 * Description   This function builds the abort confirmation event data
 *
 * Returns      None
 *
 ******************************************************************************/
void bta_hl_build_abort_cfm(tBTA_HL* p_evt_data, tBTA_HL_APP_HANDLE app_handle,
                            tBTA_HL_MCL_HANDLE mcl_handle,
                            tBTA_HL_STATUS status) {
  p_evt_data->dch_abort_cfm.status = status;
  p_evt_data->dch_abort_cfm.mcl_handle = mcl_handle;
  p_evt_data->dch_abort_cfm.app_handle = app_handle;
}

/*******************************************************************************
 *
 * Function      bta_hl_build_abort_ind
 *
 * Description   This function builds the abort indication event data
 *
 * Returns      None
 *
 ******************************************************************************/
void bta_hl_build_abort_ind(tBTA_HL* p_evt_data, tBTA_HL_APP_HANDLE app_handle,
                            tBTA_HL_MCL_HANDLE mcl_handle) {
  p_evt_data->dch_abort_ind.mcl_handle = mcl_handle;
  p_evt_data->dch_abort_ind.app_handle = app_handle;
}
/*******************************************************************************
 *
 * Function      bta_hl_build_close_cfm
 *
 * Description   This function builds the close confirmation event data
 *
 * Returns      None
 *
 ******************************************************************************/
void bta_hl_build_dch_close_cfm(tBTA_HL* p_evt_data,
                                tBTA_HL_APP_HANDLE app_handle,
                                tBTA_HL_MCL_HANDLE mcl_handle,
                                tBTA_HL_MDL_HANDLE mdl_handle,
                                tBTA_HL_STATUS status) {
  p_evt_data->dch_close_cfm.status = status;
  p_evt_data->dch_close_cfm.mdl_handle = mdl_handle;
  p_evt_data->dch_close_cfm.mcl_handle = mcl_handle;
  p_evt_data->dch_close_cfm.app_handle = app_handle;
}

/*******************************************************************************
 *
 * Function      bta_hl_build_dch_close_ind
 *
 * Description   This function builds the close indication event data
 *
 * Returns      None
 *
 ******************************************************************************/
void bta_hl_build_dch_close_ind(tBTA_HL* p_evt_data,
                                tBTA_HL_APP_HANDLE app_handle,
                                tBTA_HL_MCL_HANDLE mcl_handle,
                                tBTA_HL_MDL_HANDLE mdl_handle,
                                bool intentional) {
  p_evt_data->dch_close_ind.mdl_handle = mdl_handle;
  p_evt_data->dch_close_ind.mcl_handle = mcl_handle;
  p_evt_data->dch_close_ind.app_handle = app_handle;
  p_evt_data->dch_close_ind.intentional = intentional;
}

/*******************************************************************************
 *
 * Function      bta_hl_build_send_data_cfm
 *
 * Description   This function builds the send data confirmation event data
 *
 * Returns      None
 *
 ******************************************************************************/
void bta_hl_build_send_data_cfm(tBTA_HL* p_evt_data,
                                tBTA_HL_APP_HANDLE app_handle,
                                tBTA_HL_MCL_HANDLE mcl_handle,
                                tBTA_HL_MDL_HANDLE mdl_handle,
                                tBTA_HL_STATUS status) {
  p_evt_data->dch_send_data_cfm.mdl_handle = mdl_handle;
  p_evt_data->dch_send_data_cfm.mcl_handle = mcl_handle;
  p_evt_data->dch_send_data_cfm.app_handle = app_handle;
  p_evt_data->dch_send_data_cfm.status = status;
}

/*******************************************************************************
 *
 * Function      bta_hl_build_rcv_data_ind
 *
 * Description   This function builds the received data indication event data
 *
 * Returns      None
 *
 ******************************************************************************/
void bta_hl_build_rcv_data_ind(tBTA_HL* p_evt_data,
                               tBTA_HL_APP_HANDLE app_handle,
                               tBTA_HL_MCL_HANDLE mcl_handle,
                               tBTA_HL_MDL_HANDLE mdl_handle) {
  p_evt_data->dch_rcv_data_ind.mdl_handle = mdl_handle;
  p_evt_data->dch_rcv_data_ind.mcl_handle = mcl_handle;
  p_evt_data->dch_rcv_data_ind.app_handle = app_handle;
}

/*******************************************************************************
 *
 * Function      bta_hl_build_cch_open_cfm
 *
 * Description   This function builds the CCH open confirmation event data
 *
 * Returns      None
 *
 ******************************************************************************/
void bta_hl_build_cch_open_cfm(tBTA_HL* p_evt_data, uint8_t app_id,
                               tBTA_HL_APP_HANDLE app_handle,
                               tBTA_HL_MCL_HANDLE mcl_handle,
                               const RawAddress& bd_addr,
                               tBTA_HL_STATUS status) {
  p_evt_data->cch_open_cfm.app_id = app_id;
  p_evt_data->cch_open_cfm.app_handle = app_handle;
  p_evt_data->cch_open_cfm.mcl_handle = mcl_handle;
  p_evt_data->cch_open_cfm.bd_addr = bd_addr;
  p_evt_data->cch_open_cfm.status = status;
  APPL_TRACE_DEBUG("bta_hl_build_cch_open_cfm: status=%d", status);
}

/*******************************************************************************
 *
 * Function      bta_hl_build_cch_open_ind
 *
 * Description   This function builds the CCH open indication event data
 *
 * Returns      None
 *
 ******************************************************************************/
void bta_hl_build_cch_open_ind(tBTA_HL* p_evt_data,
                               tBTA_HL_APP_HANDLE app_handle,
                               tBTA_HL_MCL_HANDLE mcl_handle,
                               const RawAddress& bd_addr) {
  p_evt_data->cch_open_ind.app_handle = app_handle;
  p_evt_data->cch_open_ind.mcl_handle = mcl_handle;
  p_evt_data->cch_open_ind.bd_addr = bd_addr;
}

/*******************************************************************************
 *
 * Function      bta_hl_build_cch_close_cfm
 *
 * Description   This function builds the CCH close confirmation event data
 *
 * Returns      None
 *
 ******************************************************************************/
void bta_hl_build_cch_close_cfm(tBTA_HL* p_evt_data,
                                tBTA_HL_APP_HANDLE app_handle,
                                tBTA_HL_MCL_HANDLE mcl_handle,
                                tBTA_HL_STATUS status) {
  p_evt_data->cch_close_cfm.mcl_handle = mcl_handle;
  p_evt_data->cch_close_cfm.app_handle = app_handle;
  p_evt_data->cch_close_cfm.status = status;
}

/*******************************************************************************
 *
 * Function      bta_hl_build_cch_close_ind
 *
 * Description   This function builds the CCH colse indication event data
 *
 * Returns      None
 *
 ******************************************************************************/
void bta_hl_build_cch_close_ind(tBTA_HL* p_evt_data,
                                tBTA_HL_APP_HANDLE app_handle,
                                tBTA_HL_MCL_HANDLE mcl_handle,
                                bool intentional) {
  p_evt_data->cch_close_ind.mcl_handle = mcl_handle;
  p_evt_data->cch_close_ind.app_handle = app_handle;
  p_evt_data->cch_close_ind.intentional = intentional;
}

/*******************************************************************************
 *
 * Function      bta_hl_build_dch_open_cfm
 *
 * Description   This function builds the DCH open confirmation event data
 *
 * Returns      None
 *
 ******************************************************************************/
void bta_hl_build_dch_open_cfm(tBTA_HL* p_evt_data,
                               tBTA_HL_APP_HANDLE app_handle,
                               tBTA_HL_MCL_HANDLE mcl_handle,
                               tBTA_HL_MDL_HANDLE mdl_handle,
                               tBTA_HL_MDEP_ID local_mdep_id,
                               tBTA_HL_MDL_ID mdl_id, tBTA_HL_DCH_MODE dch_mode,
                               bool first_reliable, uint16_t mtu,
                               tBTA_HL_STATUS status)

{
  p_evt_data->dch_open_cfm.mdl_handle = mdl_handle;
  p_evt_data->dch_open_cfm.mcl_handle = mcl_handle;
  p_evt_data->dch_open_cfm.app_handle = app_handle;
  p_evt_data->dch_open_cfm.local_mdep_id = local_mdep_id;
  p_evt_data->dch_open_cfm.mdl_id = mdl_id;
  p_evt_data->dch_open_cfm.dch_mode = dch_mode;
  p_evt_data->dch_open_cfm.first_reliable = first_reliable;
  p_evt_data->dch_open_cfm.mtu = mtu;
  p_evt_data->dch_open_cfm.status = status;
}

/*******************************************************************************
 *
 * Function      bta_hl_build_sdp_query_cfm
 *
 * Description   This function builds the SDP query indication event data
 *
 * Returns      None
 *
 ******************************************************************************/
void bta_hl_build_sdp_query_cfm(tBTA_HL* p_evt_data, uint8_t app_id,
                                tBTA_HL_APP_HANDLE app_handle,
                                const RawAddress& bd_addr, tBTA_HL_SDP* p_sdp,
                                tBTA_HL_STATUS status)

{
  APPL_TRACE_DEBUG("bta_hl_build_sdp_query_cfm: app_id = %d, app_handle=%d",
                   app_id, app_handle);
  p_evt_data->sdp_query_cfm.app_id = app_id;
  p_evt_data->sdp_query_cfm.app_handle = app_handle;
  p_evt_data->sdp_query_cfm.bd_addr = bd_addr;
  p_evt_data->sdp_query_cfm.p_sdp = p_sdp;
  p_evt_data->sdp_query_cfm.status = status;
}

/*******************************************************************************
 *
 * Function      bta_hl_build_delete_mdl_cfm
 *
 * Description   This function builds the delete MDL confirmation event data
 *
 * Returns      None
 *
 ******************************************************************************/
void bta_hl_build_delete_mdl_cfm(tBTA_HL* p_evt_data,
                                 tBTA_HL_APP_HANDLE app_handle,
                                 tBTA_HL_MCL_HANDLE mcl_handle,
                                 tBTA_HL_MDL_ID mdl_id, tBTA_HL_STATUS status)

{
  p_evt_data->delete_mdl_cfm.mcl_handle = mcl_handle;
  p_evt_data->delete_mdl_cfm.app_handle = app_handle;
  p_evt_data->delete_mdl_cfm.mdl_id = mdl_id;
  p_evt_data->delete_mdl_cfm.status = status;
}

/*******************************************************************************
 *
 * Function      bta_hl_build_echo_test_cfm
 *
 * Description   This function builds the echo test confirmation event data
 *
 * Returns      None
 *
 ******************************************************************************/
void bta_hl_build_echo_test_cfm(tBTA_HL* p_evt_data,
                                tBTA_HL_APP_HANDLE app_handle,
                                tBTA_HL_MCL_HANDLE mcl_handle,
                                tBTA_HL_STATUS status) {
  p_evt_data->echo_test_cfm.mcl_handle = mcl_handle;
  p_evt_data->echo_test_cfm.app_handle = app_handle;
  p_evt_data->echo_test_cfm.status = status;
}

/*****************************************************************************
 *  Debug Functions
 ****************************************************************************/
#if (BTA_HL_DEBUG == TRUE)

/*******************************************************************************
 *
 * Function         bta_hl_status_code
 *
 * Description      get the status string pointer
 *
 * Returns          char * - status string pointer
 *
 ******************************************************************************/
const char* bta_hl_status_code(tBTA_HL_STATUS status) {
  switch (status) {
    case BTA_HL_STATUS_OK:
      return "BTA_HL_STATUS_OK";
    case BTA_HL_STATUS_FAIL:
      return "BTA_HL_STATUS_FAIL";
    case BTA_HL_STATUS_ABORTED:
      return "BTA_HL_STATUS_ABORTED";
    case BTA_HL_STATUS_NO_RESOURCE:
      return "BTA_HL_STATUS_NO_RESOURCE";
    case BTA_HL_STATUS_LAST_ITEM:
      return "BTA_HL_STATUS_LAST_ITEM";
    case BTA_HL_STATUS_DUPLICATE_APP_ID:
      return "BTA_HL_STATUS_DUPLICATE_APP_ID";
    case BTA_HL_STATUS_INVALID_APP_HANDLE:
      return "BTA_HL_STATUS_INVALID_APP_HANDLE";
    case BTA_HL_STATUS_INVALID_MCL_HANDLE:
      return "BTA_HL_STATUS_INVALID_MCL_HANDLE";
    case BTA_HL_STATUS_MCAP_REG_FAIL:
      return "BTA_HL_STATUS_MCAP_REG_FAIL";
    case BTA_HL_STATUS_MDEP_CO_FAIL:
      return "BTA_HL_STATUS_MDEP_CO_FAIL";
    case BTA_HL_STATUS_ECHO_CO_FAIL:
      return "BTA_HL_STATUS_ECHO_CO_FAIL";
    case BTA_HL_STATUS_MDL_CFG_CO_FAIL:
      return "BTA_HL_STATUS_MDL_CFG_CO_FAIL";
    case BTA_HL_STATUS_SDP_NO_RESOURCE:
      return "BTA_HL_STATUS_SDP_NO_RESOURCE";
    case BTA_HL_STATUS_SDP_FAIL:
      return "BTA_HL_STATUS_SDP_FAIL";
    case BTA_HL_STATUS_NO_CCH:
      return "BTA_HL_STATUS_NO_CCH";
    case BTA_HL_STATUS_NO_MCL:
      return "BTA_HL_STATUS_NO_MCL";

    case BTA_HL_STATUS_NO_FIRST_RELIABLE:
      return "BTA_HL_STATUS_NO_FIRST_RELIABLE";
    case BTA_HL_STATUS_INVALID_DCH_CFG:
      return "BTA_HL_STATUS_INVALID_DCH_CFG";
    case BTA_HL_STATUS_INVALID_BD_ADDR:
      return "BTA_HL_STATUS_INVALID_BD_ADDR";
    case BTA_HL_STATUS_INVALID_RECONNECT_CFG:
      return "BTA_HL_STATUS_INVALID_RECONNECT_CFG";
    case BTA_HL_STATUS_ECHO_TEST_BUSY:
      return "BTA_HL_STATUS_ECHO_TEST_BUSY";
    case BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID:
      return "BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID";
    case BTA_HL_STATUS_INVALID_MDL_ID:
      return "BTA_HL_STATUS_INVALID_MDL_ID";
    case BTA_HL_STATUS_NO_MDL_ID_FOUND:
      return "BTA_HL_STATUS_NO_MDL_ID_FOUND";
    case BTA_HL_STATUS_DCH_BUSY:
      return "BTA_HL_STATUS_DCH_BUSY";
    default:
      return "Unknown status code";
  }
}
/*******************************************************************************
 *
 * Function         bta_hl_evt_code
 *
 * Description      Maps HL event code to the corresponding event string
 *
 * Returns          string pointer for the associated event name
 *
 ******************************************************************************/
const char* bta_hl_evt_code(tBTA_HL_INT_EVT evt_code) {
  switch (evt_code) {
    case BTA_HL_CCH_OPEN_EVT:
      return "BTA_HL_CCH_OPEN_EVT";
    case BTA_HL_CCH_SDP_OK_EVT:
      return "BTA_HL_CCH_SDP_OK_EVT";
    case BTA_HL_CCH_SDP_FAIL_EVT:
      return "BTA_HL_CCH_SDP_FAIL_EVT";
    case BTA_HL_MCA_CONNECT_IND_EVT:
      return "BTA_HL_MCA_CONNECT_IND_EVT";
    case BTA_HL_MCA_DISCONNECT_IND_EVT:
      return "BTA_HL_MCA_DISCONNECT_IND_EVT";

    case BTA_HL_CCH_CLOSE_EVT:
      return "BTA_HL_CCH_CLOSE_EVT";
    case BTA_HL_CCH_CLOSE_CMPL_EVT:
      return "BTA_HL_CCH_CLOSE_CMPL_EVT";
    case BTA_HL_DCH_OPEN_EVT:
      return "BTA_HL_DCH_OPEN_EVT";
    case BTA_HL_MCA_CREATE_IND_EVT:
      return "BTA_HL_MCA_CREATE_IND_EVT";
    case BTA_HL_MCA_CREATE_CFM_EVT:
      return "BTA_HL_MCA_CREATE_CFM_EVT";
    case BTA_HL_MCA_OPEN_IND_EVT:
      return "BTA_HL_MCA_OPEN_IND_EVT";
    case BTA_HL_MCA_OPEN_CFM_EVT:
      return "BTA_HL_MCA_OPEN_CFM_EVT";
    case BTA_HL_DCH_CLOSE_EVT:
      return "BTA_HL_DCH_CLOSE_EVT";
    case BTA_HL_MCA_CLOSE_IND_EVT:
      return "BTA_HL_MCA_CLOSE_IND_EVT";
    case BTA_HL_MCA_CLOSE_CFM_EVT:
      return "BTA_HL_MCA_CLOSE_CFM_EVT";
    case BTA_HL_API_SEND_DATA_EVT:
      return "BTA_HL_API_SEND_DATA_EVT";
    case BTA_HL_MCA_RCV_DATA_EVT:
      return "BTA_HL_MCA_RCV_DATA_EVT";
    case BTA_HL_DCH_CLOSE_CMPL_EVT:
      return "BTA_HL_DCH_CLOSE_CMPL_EVT";

    case BTA_HL_API_ENABLE_EVT:
      return "BTA_HL_API_ENABLE_EVT";
    case BTA_HL_API_DISABLE_EVT:
      return "BTA_HL_API_DISABLE_EVT";
    case BTA_HL_API_UPDATE_EVT:
      return "BTA_HL_API_UPDATE_EVT";
    case BTA_HL_API_REGISTER_EVT:
      return "BTA_HL_API_REGISTER_EVT";
    case BTA_HL_API_DEREGISTER_EVT:
      return "BTA_HL_API_DEREGISTER_EVT";

    case BTA_HL_API_CCH_OPEN_EVT:
      return "BTA_HL_API_CCH_OPEN_EVT";

    case BTA_HL_API_CCH_CLOSE_EVT:
      return "BTA_HL_API_CCH_CLOSE_EVT";
    case BTA_HL_API_DCH_OPEN_EVT:
      return "BTA_HL_API_DCH_OPEN_EVT";

    case BTA_HL_API_DCH_RECONNECT_EVT:
      return "BTA_HL_API_DCH_RECONNECT_EVT";
    case BTA_HL_API_DCH_CLOSE_EVT:
      return "BTA_HL_API_DCH_CLOSE_EVT";
    case BTA_HL_API_DELETE_MDL_EVT:
      return "BTA_HL_API_DELETE_MDL_EVT";
    case BTA_HL_API_DCH_ABORT_EVT:
      return "BTA_HL_API_DCH_ABORT_EVT";

    case BTA_HL_DCH_RECONNECT_EVT:
      return "BTA_HL_DCH_RECONNECT_EVT";
    case BTA_HL_DCH_SDP_INIT_EVT:
      return "BTA_HL_DCH_SDP_INIT_EVT";
    case BTA_HL_DCH_SDP_FAIL_EVT:
      return "BTA_HL_DCH_SDP_FAIL_EVT";
    case BTA_HL_API_DCH_ECHO_TEST_EVT:
      return "BTA_HL_API_DCH_ECHO_TEST_EVT";
    case BTA_HL_DCH_CLOSE_ECHO_TEST_EVT:
      return "BTA_HL_DCH_CLOSE_ECHO_TEST_EVT";
    case BTA_HL_MCA_RECONNECT_IND_EVT:
      return "BTA_HL_MCA_RECONNECT_IND_EVT";
    case BTA_HL_MCA_RECONNECT_CFM_EVT:
      return "BTA_HL_MCA_RECONNECT_CFM_EVT";
    case BTA_HL_API_DCH_CREATE_RSP_EVT:
      return "BTA_HL_API_DCH_CREATE_RSP_EVT";
    case BTA_HL_DCH_ABORT_EVT:
      return "BTA_HL_DCH_ABORT_EVT";
    case BTA_HL_MCA_ABORT_IND_EVT:
      return "BTA_HL_MCA_ABORT_IND_EVT";
    case BTA_HL_MCA_ABORT_CFM_EVT:
      return "BTA_HL_MCA_ABORT_CFM_EVT";
    case BTA_HL_MCA_DELETE_IND_EVT:
      return "BTA_HL_MCA_DELETE_IND_EVT";
    case BTA_HL_MCA_DELETE_CFM_EVT:
      return "BTA_HL_MCA_DELETE_CFM_EVT";
    case BTA_HL_MCA_CONG_CHG_EVT:
      return "BTA_HL_MCA_CONG_CHG_EVT";
    case BTA_HL_CI_GET_TX_DATA_EVT:
      return "BTA_HL_CI_GET_TX_DATA_EVT";
    case BTA_HL_CI_PUT_RX_DATA_EVT:
      return "BTA_HL_CI_PUT_RX_DATA_EVT";
    case BTA_HL_CI_GET_ECHO_DATA_EVT:
      return "BTA_HL_CI_GET_ECHO_DATA_EVT";
    case BTA_HL_DCH_ECHO_TEST_EVT:
      return "BTA_HL_DCH_ECHO_TEST_EVT";
    case BTA_HL_CI_PUT_ECHO_DATA_EVT:
      return "BTA_HL_CI_PUT_ECHO_DATA_EVT";
    case BTA_HL_API_SDP_QUERY_EVT:
      return "BTA_HL_API_SDP_QUERY_EVT";
    case BTA_HL_SDP_QUERY_OK_EVT:
      return "BTA_HL_SDP_QUERY_OK_EVT";
    case BTA_HL_SDP_QUERY_FAIL_EVT:
      return "BTA_HL_SDP_QUERY_FAIL_EVT";
    case BTA_HL_MCA_RSP_TOUT_IND_EVT:
      return "BTA_HL_MCA_RSP_TOUT_IND_EVT";

    default:
      return "Unknown HL event code";
  }
}

#endif  /* Debug Functions */
#endif  // HL_INCLUDED
