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

/******************************************************************************
 *
 *  This file contains the action functions the NFA_CE state machine.
 *
 ******************************************************************************/
#include <log/log.h>
#include <string.h>

#include <android-base/stringprintf.h>
#include <base/logging.h>

#include "ce_api.h"
#include "ndef_utils.h"
#include "nfa_ce_int.h"
#include "nfa_mem_co.h"

#if (NFC_NFCEE_INCLUDED == TRUE)
#include "nfa_ee_int.h"
#endif

using android::base::StringPrintf;

extern bool nfc_debug_enabled;

/*****************************************************************************
* Protocol-specific event handlers
*****************************************************************************/

/*******************************************************************************
**
** Function         nfa_ce_handle_t3t_evt
**
** Description      Handler for Type-3 tag card emulation events
**
** Returns          Nothing
**
*******************************************************************************/
void nfa_ce_handle_t3t_evt(tCE_EVENT event, tCE_DATA* p_ce_data) {
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  tNFA_CONN_EVT_DATA conn_evt;

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("nfa_ce_handle_t3t_evt: event 0x%x", event);
  /* For the felica on host for nfcFcallback */
  for (uint8_t idx = 0; idx < NFA_CE_LISTEN_INFO_IDX_INVALID; idx++) {
    if ((p_cb->listen_info[idx].flags & NFA_CE_LISTEN_INFO_IN_USE) &&
        (p_cb->listen_info[idx].flags & NFA_CE_LISTEN_INFO_FELICA) &&
        (p_cb->listen_info[idx].flags & NFA_CE_LISTEN_INFO_T3T_ACTIVATE_PND)) {
      p_cb->idx_cur_active = idx;
      p_cb->p_active_conn_cback =
          p_cb->listen_info[p_cb->idx_cur_active].p_conn_cback;
      break;
    }
  }
  switch (event) {
    case CE_T3T_NDEF_UPDATE_START_EVT:
      /* Notify app using callback associated with the active ndef */
      if (p_cb->idx_cur_active == NFA_CE_LISTEN_INFO_IDX_NDEF) {
        conn_evt.status = NFA_STATUS_OK;
        (*p_cb->p_active_conn_cback)(NFA_CE_NDEF_WRITE_START_EVT, &conn_evt);
      } else {
        LOG(ERROR) << StringPrintf(
            "nfa_ce_handle_t3t_evt: got CE_T3T_UPDATE_START_EVT, but no active "
            "NDEF");
      }
      break;

    case CE_T3T_NDEF_UPDATE_CPLT_EVT:
      /* Notify app using callback associated with the active ndef */
      if (p_cb->idx_cur_active == NFA_CE_LISTEN_INFO_IDX_NDEF) {
        conn_evt.ndef_write_cplt.status = NFA_STATUS_OK;
        conn_evt.ndef_write_cplt.len = p_ce_data->update_info.length;
        conn_evt.ndef_write_cplt.p_data = p_ce_data->update_info.p_data;
        (*p_cb->p_active_conn_cback)(NFA_CE_NDEF_WRITE_CPLT_EVT, &conn_evt);
      } else {
        LOG(ERROR) << StringPrintf(
            "nfa_ce_handle_t3t_evt: got CE_T3T_UPDATE_CPLT_EVT, but no active "
            "NDEF");
      }
      break;

    case CE_T3T_RAW_FRAME_EVT:
      if (p_cb->idx_cur_active == NFA_CE_LISTEN_INFO_IDX_NDEF) {
        conn_evt.data.status = p_ce_data->raw_frame.status;
        conn_evt.data.p_data = (uint8_t*)(p_ce_data->raw_frame.p_data + 1) +
                               p_ce_data->raw_frame.p_data->offset;
        conn_evt.data.len = p_ce_data->raw_frame.p_data->len;
        (*p_cb->p_active_conn_cback)(NFA_DATA_EVT, &conn_evt);
      } else {
        /* If we have not notified the app of activation, do so now */
        if (p_cb->listen_info[p_cb->idx_cur_active].flags &
            NFA_CE_LISTEN_INFO_T3T_ACTIVATE_PND) {
          p_cb->listen_info[p_cb->idx_cur_active].flags &=
              ~NFA_CE_LISTEN_INFO_T3T_ACTIVATE_PND;

          conn_evt.ce_activated.handle =
              NFA_HANDLE_GROUP_CE | ((tNFA_HANDLE)p_cb->idx_cur_active);
          memcpy(&(conn_evt.ce_activated.activate_ntf),
                 &p_cb->activation_params, sizeof(tNFC_ACTIVATE_DEVT));
          conn_evt.ce_activated.status = NFA_STATUS_OK;

          (*p_cb->p_active_conn_cback)(NFA_CE_ACTIVATED_EVT, &conn_evt);
        }
        /* Notify app of t3t raw data */
        conn_evt.ce_data.status = p_ce_data->raw_frame.status;
        conn_evt.ce_data.handle =
            (NFA_HANDLE_GROUP_CE | ((tNFA_HANDLE)p_cb->idx_cur_active));
        conn_evt.ce_data.p_data = (uint8_t*)(p_ce_data->raw_frame.p_data + 1) +
                                  p_ce_data->raw_frame.p_data->offset;
        conn_evt.ce_data.len = p_ce_data->raw_frame.p_data->len;
        (*p_cb->p_active_conn_cback)(NFA_CE_DATA_EVT, &conn_evt);
      }
      GKI_freebuf(p_ce_data->raw_frame.p_data);
      break;

    default:
      DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
          "nfa_ce_handle_t3t_evt unhandled event=0x%02x", event);
      break;
  }
}

/*******************************************************************************
**
** Function         nfa_ce_handle_t4t_evt
**
** Description      Handler for Type-4 tag card emulation events (for NDEF case)
**
** Returns          Nothing
**
*******************************************************************************/
void nfa_ce_handle_t4t_evt(tCE_EVENT event, tCE_DATA* p_ce_data) {
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  tNFA_CONN_EVT_DATA conn_evt;

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("nfa_ce_handle_t4t_evt: event 0x%x", event);

  /* AID for NDEF selected. we had notified the app of activation. */
  p_cb->idx_cur_active = NFA_CE_LISTEN_INFO_IDX_NDEF;
  if (p_cb->listen_info[p_cb->idx_cur_active].flags &
      NFA_CE_LISTEN_INFO_T4T_ACTIVATE_PND) {
    p_cb->p_active_conn_cback =
        p_cb->listen_info[p_cb->idx_cur_active].p_conn_cback;
  }

  switch (event) {
    case CE_T4T_NDEF_UPDATE_START_EVT:
      conn_evt.status = NFA_STATUS_OK;
      (*p_cb->p_active_conn_cback)(NFA_CE_NDEF_WRITE_START_EVT, &conn_evt);
      break;

    case CE_T4T_NDEF_UPDATE_CPLT_EVT:
      conn_evt.ndef_write_cplt.len = p_ce_data->update_info.length;
      conn_evt.ndef_write_cplt.p_data = p_ce_data->update_info.p_data;

      if (NDEF_MsgValidate(p_ce_data->update_info.p_data,
                           p_ce_data->update_info.length, true) != NDEF_OK)
        conn_evt.ndef_write_cplt.status = NFA_STATUS_FAILED;
      else
        conn_evt.ndef_write_cplt.status = NFA_STATUS_OK;

      (*p_cb->p_active_conn_cback)(NFA_CE_NDEF_WRITE_CPLT_EVT, &conn_evt);
      break;

    case CE_T4T_NDEF_UPDATE_ABORT_EVT:
      conn_evt.ndef_write_cplt.len = 0;
      conn_evt.ndef_write_cplt.status = NFA_STATUS_FAILED;
      conn_evt.ndef_write_cplt.p_data = NULL;
      (*p_cb->p_active_conn_cback)(NFA_CE_NDEF_WRITE_CPLT_EVT, &conn_evt);
      break;

    default:
      /* CE_T4T_RAW_FRAME_EVT is not used in NFA CE */
      DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
          "nfa_ce_handle_t4t_evt unhandled event=0x%02x", event);
      break;
  }
}

/*******************************************************************************
**
** Function         nfa_ce_handle_t4t_aid_evt
**
** Description      Handler for Type-4 tag AID events (for AIDs registered using
**                  NFA_CeRegisterT4tAidOnDH)
**
** Returns          Nothing
**
*******************************************************************************/
void nfa_ce_handle_t4t_aid_evt(tCE_EVENT event, tCE_DATA* p_ce_data) {
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  uint8_t listen_info_idx;
  tNFA_CONN_EVT_DATA conn_evt;

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("nfa_ce_handle_t4t_aid_evt: event 0x%x", event);

  /* Get listen_info for this aid callback */
  for (listen_info_idx = 0; listen_info_idx < NFA_CE_LISTEN_INFO_IDX_INVALID;
       listen_info_idx++) {
    if ((p_cb->listen_info[listen_info_idx].flags &
         NFA_CE_LISTEN_INFO_IN_USE) &&
        (p_cb->listen_info[listen_info_idx].flags &
         NFA_CE_LISTEN_INFO_T4T_AID) &&
        (p_cb->listen_info[listen_info_idx].t4t_aid_handle ==
         p_ce_data->raw_frame.aid_handle)) {
      p_cb->idx_cur_active = listen_info_idx;
      p_cb->p_active_conn_cback =
          p_cb->listen_info[p_cb->idx_cur_active].p_conn_cback;
      break;
    }
  }

  if (event == CE_T4T_RAW_FRAME_EVT) {
    if (listen_info_idx != NFA_CE_LISTEN_INFO_IDX_INVALID) {
      /* Found listen_info entry */
      conn_evt.ce_activated.handle =
          NFA_HANDLE_GROUP_CE | ((tNFA_HANDLE)p_cb->idx_cur_active);

      /* If we have not notified the app of activation, do so now */
      if (p_cb->listen_info[p_cb->idx_cur_active].flags &
          NFA_CE_LISTEN_INFO_T4T_ACTIVATE_PND) {
        p_cb->listen_info[p_cb->idx_cur_active].flags &=
            ~NFA_CE_LISTEN_INFO_T4T_ACTIVATE_PND;

        memcpy(&(conn_evt.ce_activated.activate_ntf), &p_cb->activation_params,
               sizeof(tNFC_ACTIVATE_DEVT));
        conn_evt.ce_activated.status = NFA_STATUS_OK;
        (*p_cb->p_active_conn_cback)(NFA_CE_ACTIVATED_EVT, &conn_evt);
      }

      /* Notify app of AID data */
      conn_evt.ce_data.status = p_ce_data->raw_frame.status;
      conn_evt.ce_data.handle =
          NFA_HANDLE_GROUP_CE | ((tNFA_HANDLE)p_cb->idx_cur_active);
      conn_evt.ce_data.p_data = (uint8_t*)(p_ce_data->raw_frame.p_data + 1) +
                                p_ce_data->raw_frame.p_data->offset;
      conn_evt.ce_data.len = p_ce_data->raw_frame.p_data->len;
      (*p_cb->p_active_conn_cback)(NFA_CE_DATA_EVT, &conn_evt);
    } else {
      LOG(ERROR) << StringPrintf(
          "nfa_ce_handle_t4t_aid_evt: unable to find listen_info for aid hdl "
          "%i",
          p_ce_data->raw_frame.aid_handle);
    }

    GKI_freebuf(p_ce_data->raw_frame.p_data);
  }
}

/*****************************************************************************
* Discovery configuration and discovery event handlers
*****************************************************************************/

/*******************************************************************************
**
** Function         nfa_ce_discovery_cback
**
** Description      Processing event from discovery callback
**
** Returns          None
**
*******************************************************************************/
void nfa_ce_discovery_cback(tNFA_DM_RF_DISC_EVT event, tNFC_DISCOVER* p_data) {
  tNFA_CE_MSG ce_msg;
  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("event:0x%02X", event);

  switch (event) {
    case NFA_DM_RF_DISC_START_EVT:
      DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
          "nfa_ce_handle_disc_start (status=0x%x)", p_data->start);
      break;

    case NFA_DM_RF_DISC_ACTIVATED_EVT:
      ce_msg.activate_ntf.hdr.event = NFA_CE_ACTIVATE_NTF_EVT;
      ce_msg.activate_ntf.p_activation_params = &p_data->activate;
      nfa_ce_hdl_event((NFC_HDR*)&ce_msg);
      break;

    case NFA_DM_RF_DISC_DEACTIVATED_EVT:
      /* DM broadcasts deactivaiton event in listen sleep state, so check before
       * processing */
      if (nfa_ce_cb.flags & NFA_CE_FLAGS_LISTEN_ACTIVE_SLEEP) {
        ce_msg.hdr.event = NFA_CE_DEACTIVATE_NTF_EVT;
        ce_msg.hdr.layer_specific = p_data->deactivate.type;
        nfa_ce_hdl_event((NFC_HDR*)&ce_msg);
      }
      break;

    default:
      LOG(ERROR) << StringPrintf("Unexpected event");
      break;
  }
}

/*******************************************************************************
**
** Function         nfc_ce_t3t_set_listen_params
**
** Description      Set t3t listening parameters
**
** Returns          Nothing
**
*******************************************************************************/
void nfc_ce_t3t_set_listen_params(void) {
  uint8_t i;
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  uint8_t tlv[128], *p_params;
  uint8_t tlv_size;
  uint16_t t3t_flags2_mask = 0xFFFF; /* Mask of which T3T_IDs are disabled */
  uint8_t t3t_idx = 0;
  uint8_t adv_Feat = 1;
  uint8_t t3tPMM[NCI_T3T_PMM_LEN] = {0xFF, 0xFF, 0xFF, 0xFF,
                                     0xFF, 0xFF, 0xFF, 0xFF};

  /* Point to start of tlv buffer */
  p_params = tlv;

  /* Set system code and NFCID2 */
  for (i = 0; i < NFA_CE_LISTEN_INFO_MAX; i++) {
    if ((p_cb->listen_info[i].flags & NFA_CE_LISTEN_INFO_IN_USE) &&
        (p_cb->listen_info[i].protocol_mask & NFA_PROTOCOL_MASK_T3T)) {
      /* Set tag's system code and NFCID2 */
      UINT8_TO_STREAM(p_params, NFC_PMID_LF_T3T_ID1 + t3t_idx); /* type */
      /* length */
      UINT8_TO_STREAM(p_params, NCI_PARAM_LEN_LF_T3T_ID(NFC_GetNCIVersion()));
      /* System Code */
      UINT16_TO_BE_STREAM(p_params, p_cb->listen_info[i].t3t_system_code);
      ARRAY_TO_BE_STREAM(p_params, p_cb->listen_info[i].t3t_nfcid2,
                         NCI_RF_F_UID_LEN);
      if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
        ARRAY_TO_BE_STREAM(p_params, p_cb->listen_info[i].t3t_pmm,
                           NCI_T3T_PMM_LEN);
      }
      /* Set mask for this ID */
      t3t_flags2_mask &= ~((uint16_t)(1 << t3t_idx));
      t3t_idx++;
    }
  }

  /* For NCI draft 22+, the polarity of NFC_PMID_LF_T3T_FLAGS2 is flipped */
  t3t_flags2_mask = ~t3t_flags2_mask;

  UINT8_TO_STREAM(p_params, NFC_PMID_LF_T3T_FLAGS2);      /* type */
  UINT8_TO_STREAM(p_params, NCI_PARAM_LEN_LF_T3T_FLAGS2); /* length */
  /* Mask of IDs to disable listening */
  UINT16_TO_STREAM(p_params, t3t_flags2_mask);

  if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
    /*Name changed in NCI2.0*/
    UINT8_TO_STREAM(p_params, NCI_PARAM_ID_LF_T3T_RD_ALLOWED);  /* type */
    UINT8_TO_STREAM(p_params, NCI_PARAM_LEN_LF_T3T_RD_ALLOWED); /* length */
  } else {
    UINT8_TO_STREAM(p_params, NCI_PARAM_ID_LF_CON_ADV_FEAT);  /* type */
    UINT8_TO_STREAM(p_params, NCI_PARAM_LEN_LF_CON_ADV_FEAT); /* length */
  }
  UINT8_TO_STREAM(p_params, adv_Feat);

  if (NFC_GetNCIVersion() != NCI_VERSION_2_0) {
    UINT8_TO_STREAM(p_params, NCI_PARAM_ID_LF_T3T_PMM);  /* type */
    UINT8_TO_STREAM(p_params, NCI_PARAM_LEN_LF_T3T_PMM); /* length */
    ARRAY_TO_BE_STREAM(p_params, t3tPMM, NCI_T3T_PMM_LEN);
  }
  tlv_size = (uint8_t)(p_params - tlv);
  if (appl_dta_mode_flag == 0x01) {
    nfa_dm_cb.eDtaMode |= NFA_DTA_HCEF_MODE;
  }
  nfa_dm_check_set_config(tlv_size, (uint8_t*)tlv, false);
}

/*******************************************************************************
**
** Function         nfa_ce_t3t_generate_rand_nfcid
**
** Description      Generate a random NFCID2 for Type-3 tag
**
** Returns          Nothing
**
*******************************************************************************/
void nfa_ce_t3t_generate_rand_nfcid(uint8_t nfcid2[NCI_RF_F_UID_LEN]) {
  uint32_t rand_seed = GKI_get_tick_count();

  /* For Type-3 tag, nfcid2 starts witn 02:fe */
  nfcid2[0] = 0x02;
  nfcid2[1] = 0xFE;

  /* The remaining 6 bytes are random */
  nfcid2[2] = (uint8_t)(rand_seed & 0xFF);
  nfcid2[3] = (uint8_t)(rand_seed >> 8 & 0xFF);
  rand_seed >>= (rand_seed & 3);
  nfcid2[4] = (uint8_t)(rand_seed & 0xFF);
  nfcid2[5] = (uint8_t)(rand_seed >> 8 & 0xFF);
  rand_seed >>= (rand_seed & 3);
  nfcid2[6] = (uint8_t)(rand_seed & 0xFF);
  nfcid2[7] = (uint8_t)(rand_seed >> 8 & 0xFF);
}

/*******************************************************************************
**
** Function         nfa_ce_start_listening
**
** Description      Start listening
**
** Returns          NFA_STATUS_OK if successful
**
*******************************************************************************/
tNFA_STATUS nfa_ce_start_listening(void) {
  tNFA_DM_DISC_TECH_PROTO_MASK listen_mask;
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  tNFA_HANDLE disc_handle;
  uint8_t listen_info_idx;

  /*************************************************************************/
  /* Construct protocol preference list to listen for */

  /* First, get protocol preference for active NDEF (if any) */
  if ((p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].flags &
       NFA_CE_LISTEN_INFO_IN_USE) &&
      (p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].rf_disc_handle ==
       NFA_HANDLE_INVALID)) {
    listen_mask = 0;

    if (p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].protocol_mask &
        NFA_PROTOCOL_MASK_T3T) {
      /* set T3T config params */
      nfc_ce_t3t_set_listen_params();

      listen_mask |= NFA_DM_DISC_MASK_LF_T3T;
    }

    if (p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].protocol_mask &
        NFA_PROTOCOL_MASK_ISO_DEP) {
      listen_mask |= nfa_ce_cb.isodep_disc_mask;
    }

    disc_handle = nfa_dm_add_rf_discover(listen_mask, NFA_DM_DISC_HOST_ID_DH,
                                         nfa_ce_discovery_cback);

    if (disc_handle == NFA_HANDLE_INVALID)
      return (NFA_STATUS_FAILED);
    else
      p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].rf_disc_handle =
          disc_handle;
  }

  /* Next, add protocols from non-NDEF, if any */
  for (listen_info_idx = 0; listen_info_idx < NFA_CE_LISTEN_INFO_IDX_INVALID;
       listen_info_idx++) {
    /* add RF discovery to DM only if it is not added yet */
    if ((p_cb->listen_info[listen_info_idx].flags &
         NFA_CE_LISTEN_INFO_IN_USE) &&
        (p_cb->listen_info[listen_info_idx].rf_disc_handle ==
         NFA_HANDLE_INVALID)) {
      if (p_cb->listen_info[listen_info_idx].flags &
          NFA_CE_LISTEN_INFO_FELICA) {
        /* set T3T config params */
        nfc_ce_t3t_set_listen_params();

        disc_handle = nfa_dm_add_rf_discover(NFA_DM_DISC_MASK_LF_T3T,
                                             NFA_DM_DISC_HOST_ID_DH,
                                             nfa_ce_discovery_cback);

        if (disc_handle == NFA_HANDLE_INVALID)
          return (NFA_STATUS_FAILED);
        else
          p_cb->listen_info[listen_info_idx].rf_disc_handle = disc_handle;
      } else if (p_cb->listen_info[listen_info_idx].flags &
                 NFA_CE_LISTEN_INFO_T4T_AID) {
        disc_handle = nfa_dm_add_rf_discover(nfa_ce_cb.isodep_disc_mask,
                                             NFA_DM_DISC_HOST_ID_DH,
                                             nfa_ce_discovery_cback);

        if (disc_handle == NFA_HANDLE_INVALID)
          return (NFA_STATUS_FAILED);
        else
          p_cb->listen_info[listen_info_idx].rf_disc_handle = disc_handle;
      }
#if (NFC_NFCEE_INCLUDED == TRUE)
      else if (p_cb->listen_info[listen_info_idx].flags &
               NFA_CE_LISTEN_INFO_UICC) {
        listen_mask = 0;
        if (nfa_ee_is_active(p_cb->listen_info[listen_info_idx].ee_handle)) {
          if (p_cb->listen_info[listen_info_idx].tech_mask &
              NFA_TECHNOLOGY_MASK_A) {
            listen_mask |= NFA_DM_DISC_MASK_LA_ISO_DEP;
          }
          if (p_cb->listen_info[listen_info_idx].tech_mask &
              NFA_TECHNOLOGY_MASK_B) {
            listen_mask |= NFA_DM_DISC_MASK_LB_ISO_DEP;
          }
          if (p_cb->listen_info[listen_info_idx].tech_mask &
              NFA_TECHNOLOGY_MASK_F) {
            listen_mask |= NFA_DM_DISC_MASK_LF_T3T;
          }
          if (p_cb->listen_info[listen_info_idx].tech_mask &
              NFA_TECHNOLOGY_MASK_B_PRIME) {
            listen_mask |= NFA_DM_DISC_MASK_L_B_PRIME;
          }
        }

        if (listen_mask) {
          /* Start listening for requested technologies */
          /* register discovery callback to NFA DM */
          disc_handle = nfa_dm_add_rf_discover(
              listen_mask,
              (tNFA_DM_DISC_HOST_ID)(
                  p_cb->listen_info[listen_info_idx].ee_handle & 0x00FF),
              nfa_ce_discovery_cback);

          if (disc_handle == NFA_HANDLE_INVALID)
            return (NFA_STATUS_FAILED);
          else {
            p_cb->listen_info[listen_info_idx].rf_disc_handle = disc_handle;
            p_cb->listen_info[listen_info_idx].tech_proto_mask = listen_mask;
          }
        } else {
          LOG(ERROR) << StringPrintf(
              "UICC[0x%x] is not activated",
              p_cb->listen_info[listen_info_idx].ee_handle);
        }
      }
#endif
    }
  }

  return NFA_STATUS_OK;
}

/*******************************************************************************
**
** Function         nfa_ce_restart_listen_check
**
** Description      Called on deactivation. Check if any active listen_info
**                  entries to listen for
**
** Returns          TRUE if listening is restarted.
**                  FALSE if listening not restarted
**
*******************************************************************************/
bool nfa_ce_restart_listen_check(void) {
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  uint8_t listen_info_idx;

  /* Check if any active entries in listen_info table */
  for (listen_info_idx = 0; listen_info_idx < NFA_CE_LISTEN_INFO_MAX;
       listen_info_idx++) {
    if (p_cb->listen_info[listen_info_idx].flags & NFA_CE_LISTEN_INFO_IN_USE)
      break;
  }

  /* Restart listening if there are any active listen_info entries */
  if (listen_info_idx != NFA_CE_LISTEN_INFO_IDX_INVALID) {
    /* restart listening */
    nfa_ce_start_listening();
  } else {
    /* No active listen_info entries */
    return false;
  }

  return true;
}

/*******************************************************************************
**
** Function         nfa_ce_remove_listen_info_entry
**
** Description      Remove entry from listen_info table. (when API deregister is
**                  called or listen_start failed)
**
**
** Returns          Nothing
**
*******************************************************************************/
void nfa_ce_remove_listen_info_entry(uint8_t listen_info_idx, bool notify_app) {
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  tNFA_CONN_EVT_DATA conn_evt;

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("NFA_CE: removing listen_info entry %i", listen_info_idx);

  /* Notify app that listening has stopped  if requested (for API deregister) */
  /* For LISTEN_START failures, app has already notified of NFA_LISTEN_START_EVT
   * failure */
  if (notify_app) {
    if (listen_info_idx == NFA_CE_LISTEN_INFO_IDX_NDEF) {
      conn_evt.status = NFA_STATUS_OK;
      (*p_cb->listen_info[listen_info_idx].p_conn_cback)(
          NFA_CE_LOCAL_TAG_CONFIGURED_EVT, &conn_evt);
    }
#if (NFC_NFCEE_INCLUDED == TRUE)
    else if (p_cb->listen_info[listen_info_idx].flags &
             NFA_CE_LISTEN_INFO_UICC) {
      conn_evt.status = NFA_STATUS_OK;
      (*p_cb->listen_info[listen_info_idx].p_conn_cback)(
          NFA_CE_UICC_LISTEN_CONFIGURED_EVT, &conn_evt);
    }
#endif
    else {
      conn_evt.ce_deregistered.handle = NFA_HANDLE_GROUP_CE | listen_info_idx;
      (*p_cb->listen_info[listen_info_idx].p_conn_cback)(
          NFA_CE_DEREGISTERED_EVT, &conn_evt);
    }
  }

  /* Handle NDEF stopping */
  if (listen_info_idx == NFA_CE_LISTEN_INFO_IDX_NDEF) {
    /* clear NDEF contents */
    CE_T3tSetLocalNDEFMsg(true, 0, 0, NULL, NULL);
    CE_T4tSetLocalNDEFMsg(true, 0, 0, NULL, NULL);

    if (p_cb->listen_info[listen_info_idx].protocol_mask &
        NFA_PROTOCOL_MASK_T3T) {
      p_cb->listen_info[listen_info_idx].protocol_mask = 0;

      /* clear T3T Flags for NDEF */
      nfc_ce_t3t_set_listen_params();
    }

    /* Free scratch buffer for this NDEF, if one was allocated */
    nfa_ce_free_scratch_buf();
  }
  /* If stopping listening Felica system code, then clear T3T Flags for this */
  else if (p_cb->listen_info[listen_info_idx].flags &
           NFA_CE_LISTEN_INFO_FELICA) {
    p_cb->listen_info[listen_info_idx].protocol_mask = 0;

    /* clear T3T Flags for registered Felica system code */
    nfc_ce_t3t_set_listen_params();
  }
  /* If stopping listening T4T AID, then deregister this AID from CE_T4T */
  else if (p_cb->listen_info[listen_info_idx].flags &
           NFA_CE_LISTEN_INFO_T4T_AID) {
    /* Free t4t_aid_cback used by this AID */
    CE_T4tDeregisterAID(p_cb->listen_info[listen_info_idx].t4t_aid_handle);
  }

  if (p_cb->listen_info[listen_info_idx].rf_disc_handle != NFA_HANDLE_INVALID) {
    nfa_dm_delete_rf_discover(
        p_cb->listen_info[listen_info_idx].rf_disc_handle);
    p_cb->listen_info[listen_info_idx].rf_disc_handle = NFA_HANDLE_INVALID;
  }

  /* Remove entry from listen_info table */
  p_cb->listen_info[listen_info_idx].flags = 0;
}

/*******************************************************************************
**
** Function         nfa_ce_free_scratch_buf
**
** Description      free scratch buffer (if one is allocated)
**
** Returns          nothing
**
*******************************************************************************/
void nfa_ce_free_scratch_buf(void) {
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  if (p_cb->p_scratch_buf) {
    nfa_mem_co_free(p_cb->p_scratch_buf);
    p_cb->p_scratch_buf = NULL;
  }
}

/*******************************************************************************
**
** Function         nfa_ce_realloc_scratch_buffer
**
** Description      Set scratch buffer if necessary (for writable NDEF messages)
**
** Returns          NFA_STATUS_OK if successful
**
*******************************************************************************/
tNFA_STATUS nfa_ce_realloc_scratch_buffer(void) {
  tNFA_STATUS result = NFA_STATUS_OK;

  /* If current NDEF message is read-only, then we do not need a scratch buffer
   */
  if (nfa_ce_cb.listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].flags &
      NFC_CE_LISTEN_INFO_READONLY_NDEF) {
    /* Free existing scratch buffer, if one was allocated */
    nfa_ce_free_scratch_buf();
  } else {
    /* If no scratch buffer allocated yet, or if current scratch buffer size is
     * different from current ndef size, */
    /* then allocate a new scratch buffer. */
    if ((nfa_ce_cb.p_scratch_buf == NULL) ||
        (nfa_ce_cb.scratch_buf_size != nfa_ce_cb.ndef_max_size)) {
      /* Free existing scratch buffer, if one was allocated */
      nfa_ce_free_scratch_buf();

      nfa_ce_cb.p_scratch_buf =
          (uint8_t*)nfa_mem_co_alloc(nfa_ce_cb.ndef_max_size);
      if (nfa_ce_cb.p_scratch_buf != NULL) {
        nfa_ce_cb.scratch_buf_size = nfa_ce_cb.ndef_max_size;
      } else {
        LOG(ERROR) << StringPrintf(
            "Unable to allocate scratch buffer for writable NDEF message (%i "
            "bytes)",
            nfa_ce_cb.ndef_max_size);
        result = NFA_STATUS_FAILED;
      }
    }
  }

  return (result);
}

/*******************************************************************************
**
** Function         nfa_ce_set_content
**
** Description      Set NDEF contents
**
** Returns          void
**
*******************************************************************************/
tNFC_STATUS nfa_ce_set_content(void) {
  tNFC_STATUS status;
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  tNFA_PROTOCOL_MASK ndef_protocol_mask;
  bool readonly;

  /* Check if listening for NDEF */
  if (!(p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].flags &
        NFA_CE_LISTEN_INFO_IN_USE)) {
    /* Not listening for NDEF */
    return (NFA_STATUS_OK);
  }

  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("Setting NDEF contents");

  readonly = (p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].flags &
              NFC_CE_LISTEN_INFO_READONLY_NDEF)
                 ? true
                 : false;
  ndef_protocol_mask =
      p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].protocol_mask;

  /* Allocate a scratch buffer if needed (for handling write-requests) */
  status = nfa_ce_realloc_scratch_buffer();
  if (status == NFA_STATUS_OK) {
    if ((ndef_protocol_mask & NFA_PROTOCOL_MASK_T3T) &&
        (status == NFA_STATUS_OK)) {
      /* Type3Tag    - NFC-F */
      status = CE_T3tSetLocalNDEFMsg(readonly, p_cb->ndef_max_size,
                                     p_cb->ndef_cur_size, p_cb->p_ndef_data,
                                     p_cb->p_scratch_buf);
    }

    if ((ndef_protocol_mask & NFA_PROTOCOL_MASK_ISO_DEP) &&
        (status == NFA_STATUS_OK)) {
      /* ISODEP/4A,4B- NFC-A or NFC-B */
      status = CE_T4tSetLocalNDEFMsg(readonly, p_cb->ndef_max_size,
                                     p_cb->ndef_cur_size, p_cb->p_ndef_data,
                                     p_cb->p_scratch_buf);
    }
  }

  if (status != NFA_STATUS_OK) {
    /* clear NDEF contents */
    CE_T3tSetLocalNDEFMsg(true, 0, 0, NULL, NULL);
    CE_T4tSetLocalNDEFMsg(true, 0, 0, NULL, NULL);

    LOG(ERROR) << StringPrintf("Unable to set contents (error %02x)", status);
  }

  return (status);
}

/*******************************************************************************
**
** Function         nfa_ce_activate_ntf
**
** Description      Action when activation has occured (NFA_CE_ACTIVATE_NTF_EVT)
**
**                  - Find the listen_info entry assocated with this activation
**                      - get the app callback that registered for this listen
**                      - call CE_SetActivatedTagType with activation parameters
**
** Returns          TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_ce_activate_ntf(tNFA_CE_MSG* p_ce_msg) {
  tNFC_ACTIVATE_DEVT* p_activation_params =
      p_ce_msg->activate_ntf.p_activation_params;
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  tNFA_CONN_EVT_DATA conn_evt;
  tCE_CBACK* p_ce_cback = NULL;
  uint16_t t3t_system_code = 0xFFFF;
  uint8_t listen_info_idx = NFA_CE_LISTEN_INFO_IDX_INVALID;
  uint8_t* p_nfcid2 = NULL;
  uint8_t i;
  bool t4t_activate_pending = false;

  bool t3t_activate_pending = false;
  bool t3t_offhost_entry_found = false;
  uint8_t t3t_activate_idx = 0;
  uint8_t t3t_offhost_idx = 0;

  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
      "protocol=%d", p_ce_msg->activate_ntf.p_activation_params->protocol);

  /* Tag is in listen active state */
  p_cb->flags |= NFA_CE_FLAGS_LISTEN_ACTIVE_SLEEP;

  /* Store activation parameters */
  memcpy(&p_cb->activation_params, p_activation_params,
         sizeof(tNFC_ACTIVATE_DEVT));

  /* Find the listen_info entry corresponding to this activation */
  if (p_cb->activation_params.protocol == NFA_PROTOCOL_T3T) {
    /* Look for T3T entries in listen_info table that match activated system
     * code and NFCID2 */
    for (listen_info_idx = 0; listen_info_idx < NFA_CE_LISTEN_INFO_IDX_INVALID;
         listen_info_idx++) {
      /* Look for entries with NFA_PROTOCOL_MASK_T3T */
      if (p_cb->listen_info[listen_info_idx].flags &
          NFA_CE_LISTEN_INFO_IN_USE) {
        if (p_cb->listen_info[listen_info_idx].protocol_mask &
            NFA_PROTOCOL_MASK_T3T) {
          /* Check if system_code and nfcid2 that matches activation params */
          p_nfcid2 = p_cb->listen_info[listen_info_idx].t3t_nfcid2;
          t3t_system_code = p_cb->listen_info[listen_info_idx].t3t_system_code;

          /* Compare NFCID2 (note: NFCC currently does not return system code in
           * activation parameters) */
          if ((memcmp(p_nfcid2,
                      p_cb->activation_params.rf_tech_param.param.lf.nfcid2,
                      NCI_RF_F_UID_LEN) == 0)
              /* && (t3t_system_code == p_ce_msg->activation.p_activate_info->rf_tech_param.param.lf.system_code) */) {
            p_cb->listen_info[listen_info_idx].flags |=
                NFA_CE_LISTEN_INFO_T3T_ACTIVATE_PND;
            t3t_activate_pending = true;
            t3t_activate_idx = listen_info_idx;
          }
        }

        /* Check if entry is for T3T UICC */
        if ((p_cb->listen_info[listen_info_idx].flags &
             NFA_CE_LISTEN_INFO_UICC) &&
            (p_cb->listen_info[listen_info_idx].tech_mask &
             NFA_TECHNOLOGY_MASK_F)) {
          t3t_offhost_entry_found = true;
          t3t_offhost_idx = listen_info_idx;
        }
      }
    }

    p_ce_cback = nfa_ce_handle_t3t_evt;
    /* If listening for PROTO_T3T on DH and eSE/UICC, then notify CE module
     * now and wait for reader/writer to SELECT a target */
    if (t3t_activate_pending && t3t_offhost_entry_found) {
      CE_SetActivatedTagType(&p_cb->activation_params, t3t_system_code,
                             p_ce_cback);
      return true;
    } else if (t3t_activate_pending) {
      listen_info_idx = t3t_activate_idx;
    } else if (t3t_offhost_entry_found) {
      listen_info_idx = t3t_offhost_idx;
    }
  } else if (p_cb->activation_params.protocol == NFA_PROTOCOL_ISO_DEP) {
    p_ce_cback = nfa_ce_handle_t4t_evt;

    /* For T4T, we do not know which AID will be selected yet */

    /* For all T4T entries in listen_info, set T4T_ACTIVATE_NOTIFY_PENDING flag
     */
    for (i = 0; i < NFA_CE_LISTEN_INFO_IDX_INVALID; i++) {
      if (p_cb->listen_info[i].flags & NFA_CE_LISTEN_INFO_IN_USE) {
        if (p_cb->listen_info[i].protocol_mask & NFA_PROTOCOL_MASK_ISO_DEP) {
          /* Found listen_info table entry for T4T raw listen */
          p_cb->listen_info[i].flags |= NFA_CE_LISTEN_INFO_T4T_ACTIVATE_PND;

          /* If entry if for NDEF, select it, so application gets nofitifed of
           * ACTIVATE_EVT now */
          if (i == NFA_CE_LISTEN_INFO_IDX_NDEF) {
            listen_info_idx = NFA_CE_LISTEN_INFO_IDX_NDEF;
          }

          t4t_activate_pending = true;
        }

#if (NFC_NFCEE_INCLUDED == TRUE)
        /* Check if entry is for ISO_DEP UICC */
        if (p_cb->listen_info[i].flags & NFA_CE_LISTEN_INFO_UICC) {
          if (((p_cb->activation_params.rf_tech_param.mode ==
                NFC_DISCOVERY_TYPE_LISTEN_A) &&
               (p_cb->listen_info[i].tech_proto_mask &
                NFA_DM_DISC_MASK_LA_ISO_DEP)) ||
              ((p_cb->activation_params.rf_tech_param.mode ==
                NFC_DISCOVERY_TYPE_LISTEN_B) &&
               (p_cb->listen_info[i].tech_proto_mask &
                NFA_DM_DISC_MASK_LB_ISO_DEP))) {
            listen_info_idx = i;
          }
        }
#endif
      }
    }

    /* If listening for ISO_DEP, but not NDEF nor UICC, then notify CE module
     * now and wait for reader/writer to SELECT an AID */
    if (t4t_activate_pending &&
        (listen_info_idx == NFA_CE_LISTEN_INFO_IDX_INVALID)) {
      CE_SetActivatedTagType(&p_cb->activation_params, 0, p_ce_cback);
      return true;
    }
  } else if (p_cb->activation_params.intf_param.type ==
             NFC_INTERFACE_EE_DIRECT_RF) {
    /* search any entry listening UICC */
    for (i = 0; i < NFA_CE_LISTEN_INFO_IDX_INVALID; i++) {
      if ((p_cb->listen_info[i].flags & NFA_CE_LISTEN_INFO_IN_USE) &&
          (p_cb->listen_info[i].flags & NFA_CE_LISTEN_INFO_UICC)) {
        listen_info_idx = i;
        break;
      }
    }
  }

  /* Check if valid listen_info entry was found */
  if ((listen_info_idx == NFA_CE_LISTEN_INFO_IDX_INVALID) ||
      ((listen_info_idx == NFA_CE_LISTEN_INFO_IDX_NDEF) &&
       !(p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].flags &
         NFA_CE_LISTEN_INFO_IN_USE))) {
    DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
        "No listen_info found for this activation. listen_info_idx=%d",
        listen_info_idx);
    return true;
  }

  p_cb->listen_info[listen_info_idx].flags &=
      ~NFA_CE_LISTEN_INFO_T4T_ACTIVATE_PND;
  p_cb->listen_info[listen_info_idx].flags &=
      ~NFA_CE_LISTEN_INFO_T3T_ACTIVATE_PND;

  /* Get CONN_CBACK for this activation */
  p_cb->p_active_conn_cback = p_cb->listen_info[listen_info_idx].p_conn_cback;
  p_cb->idx_cur_active = listen_info_idx;

  if ((p_cb->idx_cur_active == NFA_CE_LISTEN_INFO_IDX_NDEF) ||
      (p_cb->listen_info[p_cb->idx_cur_active].flags &
       NFA_CE_LISTEN_INFO_UICC)) {
    memcpy(&(conn_evt.activated.activate_ntf), &p_cb->activation_params,
           sizeof(tNFC_ACTIVATE_DEVT));

    (*p_cb->p_active_conn_cback)(NFA_ACTIVATED_EVT, &conn_evt);
  } else {
    conn_evt.ce_activated.handle =
        NFA_HANDLE_GROUP_CE | ((tNFA_HANDLE)p_cb->idx_cur_active);
    memcpy(&(conn_evt.ce_activated.activate_ntf), &p_cb->activation_params,
           sizeof(tNFC_ACTIVATE_DEVT));
    conn_evt.ce_activated.status = NFA_STATUS_OK;

    (*p_cb->p_active_conn_cback)(NFA_CE_ACTIVATED_EVT, &conn_evt);
  }

  /* we don't need any CE subsystem in case of NFCEE direct RF interface */
  if (p_ce_cback) {
    /* Notify CE subsystem */
    CE_SetActivatedTagType(&p_cb->activation_params, t3t_system_code,
                           p_ce_cback);
  }
  return true;
}

/*******************************************************************************
**
** Function         nfa_ce_deactivate_ntf
**
** Description      Action when deactivate occurs. (NFA_CE_DEACTIVATE_NTF_EVT)
**
**                  - If deactivate due to API deregister, then remove its entry
**                    from listen_info table
**
**                  - If NDEF was modified while activated, then restore
**                    original NDEF contents
**
**                  - Restart listening (if any active entries in listen table)
**
** Returns          TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_ce_deactivate_ntf(tNFA_CE_MSG* p_ce_msg) {
  tNFC_DEACT_TYPE deact_type = (tNFC_DEACT_TYPE)p_ce_msg->hdr.layer_specific;
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  tNFA_CONN_EVT_DATA conn_evt;
  uint8_t i;

  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("deact_type=%d", deact_type);

  /* Check if deactivating to SLEEP mode */
  if ((deact_type == NFC_DEACTIVATE_TYPE_SLEEP) ||
      (deact_type == NFC_DEACTIVATE_TYPE_SLEEP_AF)) {
    if (nfa_ce_cb.idx_wild_card == NFA_CE_LISTEN_INFO_IDX_INVALID) {
      /* notify deactivated as sleep and wait for reactivation or deactivation
       * to idle */
      conn_evt.deactivated.type = deact_type;

      /* if T4T AID application has not been selected then p_active_conn_cback
       * could be NULL */
      if (p_cb->p_active_conn_cback)
        (*p_cb->p_active_conn_cback)(NFA_DEACTIVATED_EVT, &conn_evt);
    } else {
      conn_evt.ce_deactivated.handle =
          NFA_HANDLE_GROUP_CE | ((tNFA_HANDLE)nfa_ce_cb.idx_wild_card);
      conn_evt.ce_deactivated.type = deact_type;
      if (p_cb->p_active_conn_cback)
        (*p_cb->p_active_conn_cback)(NFA_CE_DEACTIVATED_EVT, &conn_evt);
    }

    return true;
  } else {
    deact_type = NFC_DEACTIVATE_TYPE_IDLE;
  }

  /* Tag is in idle state */
  p_cb->flags &= ~NFA_CE_FLAGS_LISTEN_ACTIVE_SLEEP;

  /* First, notify app of deactivation */
  for (i = 0; i < NFA_CE_LISTEN_INFO_IDX_INVALID; i++) {
    if (p_cb->listen_info[i].flags & NFA_CE_LISTEN_INFO_IN_USE) {
      if ((p_cb->listen_info[i].flags & NFA_CE_LISTEN_INFO_UICC) &&
          (i == p_cb->idx_cur_active)) {
        conn_evt.deactivated.type = deact_type;
        if (p_cb->p_active_conn_cback)
          (*p_cb->p_active_conn_cback)(NFA_DEACTIVATED_EVT, &conn_evt);
      } else if ((p_cb->activation_params.protocol == NFA_PROTOCOL_ISO_DEP) &&
                 (p_cb->listen_info[i].protocol_mask &
                  NFA_PROTOCOL_MASK_ISO_DEP)) {
        /* Don't send NFA_DEACTIVATED_EVT if NFA_ACTIVATED_EVT wasn't sent */
        if (!(p_cb->listen_info[i].flags &
              NFA_CE_LISTEN_INFO_T4T_ACTIVATE_PND)) {
          if (i == NFA_CE_LISTEN_INFO_IDX_NDEF) {
            conn_evt.deactivated.type = deact_type;
            if (p_cb->p_active_conn_cback)
              (*p_cb->p_active_conn_cback)(NFA_DEACTIVATED_EVT, &conn_evt);
          } else {
            conn_evt.ce_deactivated.handle =
                NFA_HANDLE_GROUP_CE | ((tNFA_HANDLE)i);
            conn_evt.ce_deactivated.type = deact_type;
            if (p_cb->p_active_conn_cback)
              (*p_cb->p_active_conn_cback)(NFA_CE_DEACTIVATED_EVT, &conn_evt);
          }
        }
      } else if ((p_cb->activation_params.protocol == NFA_PROTOCOL_T3T) &&
                 (p_cb->listen_info[i].protocol_mask & NFA_PROTOCOL_MASK_T3T)) {
        /* Don't send NFA_DEACTIVATED_EVT if NFA_ACTIVATED_EVT wasn't sent */
        if (!(p_cb->listen_info[i].flags &
              NFA_CE_LISTEN_INFO_T3T_ACTIVATE_PND)) {
          if (i == NFA_CE_LISTEN_INFO_IDX_NDEF) {
            conn_evt.deactivated.type = deact_type;
            if (p_cb->p_active_conn_cback)
              (*p_cb->p_active_conn_cback)(NFA_DEACTIVATED_EVT, &conn_evt);
          } else {
            conn_evt.ce_deactivated.handle =
                NFA_HANDLE_GROUP_CE | ((tNFA_HANDLE)i);
            conn_evt.ce_deactivated.type = deact_type;
            if (p_cb->p_active_conn_cback) {
              (*p_cb->p_active_conn_cback)(NFA_CE_DEACTIVATED_EVT, &conn_evt);
            } else {
              android_errorWriteLog(0x534e4554, "120846143");
            }
          }
        }
      }
    }
  }

  /* Check if app initiated the deactivation (due to API deregister). If so,
   * remove entry from listen_info table. */
  if (p_cb->flags & NFA_CE_FLAGS_APP_INIT_DEACTIVATION) {
    p_cb->flags &= ~NFA_CE_FLAGS_APP_INIT_DEACTIVATION;
    nfa_ce_remove_listen_info_entry(p_cb->idx_cur_active, true);
  }

  p_cb->p_active_conn_cback = NULL;
  p_cb->idx_cur_active = NFA_CE_LISTEN_INFO_IDX_INVALID;

  /* Restart listening (if any listen_info entries are still active) */
  nfa_ce_restart_listen_check();

  return true;
}

/*******************************************************************************
**
** Function         nfa_ce_disable_local_tag
**
** Description      Disable local NDEF tag
**                      - clean up control block
**                      - remove NDEF discovery configuration
**
** Returns          Nothing
**
*******************************************************************************/
void nfa_ce_disable_local_tag(void) {
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  tNFA_CONN_EVT_DATA evt_data;

  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("Disabling local NDEF tag");

  /* If local NDEF tag is in use, then disable it */
  if (p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].flags &
      NFA_CE_LISTEN_INFO_IN_USE) {
    /* NDEF Tag is in not idle state */
    if ((p_cb->flags & NFA_CE_FLAGS_LISTEN_ACTIVE_SLEEP) &&
        (p_cb->idx_cur_active == NFA_CE_LISTEN_INFO_IDX_NDEF)) {
      /* wait for deactivation */
      p_cb->flags |= NFA_CE_FLAGS_APP_INIT_DEACTIVATION;
      nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_IDLE);
    } else {
      /* Notify DM to stop listening for ndef  */
      if (p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].rf_disc_handle !=
          NFA_HANDLE_INVALID) {
        nfa_dm_delete_rf_discover(
            p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].rf_disc_handle);
        p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].rf_disc_handle =
            NFA_HANDLE_INVALID;
      }
      nfa_ce_remove_listen_info_entry(NFA_CE_LISTEN_INFO_IDX_NDEF, true);
    }
  } else {
    /* Notify application */
    evt_data.status = NFA_STATUS_OK;
    nfa_dm_conn_cback_event_notify(NFA_CE_LOCAL_TAG_CONFIGURED_EVT, &evt_data);
  }
}

/*******************************************************************************
**
** Function         nfa_ce_api_cfg_local_tag
**
** Description      Configure local NDEF tag
**                      - store ndef attributes in to control block
**                      - update discovery configuration
**
** Returns          TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_ce_api_cfg_local_tag(tNFA_CE_MSG* p_ce_msg) {
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  tNFA_CONN_EVT_DATA conn_evt;

  /* Check if disabling local tag */
  if (p_ce_msg->local_tag.protocol_mask == 0) {
    nfa_ce_disable_local_tag();
    return true;
  }

  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
      "Configuring local NDEF tag: protocol_mask=%01x cur_size=%i, "
      "max_size=%i, readonly=%i uid_len=%i",
      p_ce_msg->local_tag.protocol_mask, p_ce_msg->local_tag.ndef_cur_size,
      p_ce_msg->local_tag.ndef_max_size, p_ce_msg->local_tag.read_only,
      p_ce_msg->local_tag.uid_len);

  /* If local tag was already set, then check if NFA_CeConfigureLocalTag called
   * to change protocol mask  */
  if ((p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].flags &
       NFA_CE_LISTEN_INFO_IN_USE) &&
      (p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].rf_disc_handle !=
       NFA_HANDLE_INVALID) &&
      ((p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].protocol_mask &
        (NFA_PROTOCOL_MASK_T3T | NFA_PROTOCOL_MASK_ISO_DEP)) !=
       (p_ce_msg->local_tag.protocol_mask &
        (NFA_PROTOCOL_MASK_T3T | NFA_PROTOCOL_MASK_ISO_DEP)))) {
    /* Listening for different tag protocols. Stop discovery */
    nfa_dm_delete_rf_discover(
        p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].rf_disc_handle);
    p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].rf_disc_handle =
        NFA_HANDLE_INVALID;

    /* clear NDEF contents */
    CE_T3tSetLocalNDEFMsg(true, 0, 0, NULL, NULL);
    CE_T4tSetLocalNDEFMsg(true, 0, 0, NULL, NULL);
  }

  /* Store NDEF info to control block */
  p_cb->p_ndef_data = p_ce_msg->local_tag.p_ndef_data;
  p_cb->ndef_cur_size = p_ce_msg->local_tag.ndef_cur_size;
  p_cb->ndef_max_size = p_ce_msg->local_tag.ndef_max_size;

  /* Fill in LISTEN_INFO entry for NDEF */
  p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].flags =
      NFA_CE_LISTEN_INFO_IN_USE;
  p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].protocol_mask =
      p_ce_msg->local_tag.protocol_mask;
  p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].p_conn_cback =
      nfa_dm_conn_cback_event_notify;
  if (p_ce_msg->local_tag.read_only)
    p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].flags |=
        NFC_CE_LISTEN_INFO_READONLY_NDEF;
  p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].t3t_system_code =
      T3T_SYSTEM_CODE_NDEF;

  /* Set NDEF contents */
  conn_evt.status = NFA_STATUS_FAILED;

  if (p_cb->listen_info[NFA_CE_LISTEN_INFO_IDX_NDEF].protocol_mask &
      (NFA_PROTOCOL_MASK_T3T | NFA_PROTOCOL_MASK_ISO_DEP)) {
    /* Ok to set contents now */
    if (nfa_ce_set_content() != NFA_STATUS_OK) {
      LOG(ERROR) << StringPrintf(
          "nfa_ce_api_cfg_local_tag: could not set contents");
      nfa_dm_conn_cback_event_notify(NFA_CE_LOCAL_TAG_CONFIGURED_EVT,
                                     &conn_evt);
      return true;
    }

    /* Start listening and notify app of status */
    conn_evt.status = nfa_ce_start_listening();
    nfa_dm_conn_cback_event_notify(NFA_CE_LOCAL_TAG_CONFIGURED_EVT, &conn_evt);
  }

  return true;
}

/*******************************************************************************
**
** Function         nfa_ce_api_reg_listen
**
** Description      Register listen params for Felica system code, T4T AID,
**                  or UICC
**
** Returns          TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_ce_api_reg_listen(tNFA_CE_MSG* p_ce_msg) {
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  tNFA_CONN_EVT_DATA conn_evt;
  uint8_t i;
  uint8_t listen_info_idx = NFA_CE_LISTEN_INFO_IDX_INVALID;

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("Registering UICC/Felica/Type-4 tag listener. Type=%i",
                      p_ce_msg->reg_listen.listen_type);

  /* Look for available entry in listen_info table */
  /* - If registering UICC listen, make sure there isn't another entry for the
   * ee_handle  */
  /* - Skip over entry 0 (reserved for local NDEF tag) */
  for (i = 1; i < NFA_CE_LISTEN_INFO_MAX; i++) {
    if ((p_ce_msg->reg_listen.listen_type == NFA_CE_REG_TYPE_UICC) &&
        (p_cb->listen_info[i].flags & NFA_CE_LISTEN_INFO_IN_USE) &&
        (p_cb->listen_info[i].flags & NFA_CE_LISTEN_INFO_UICC) &&
        (p_cb->listen_info[i].ee_handle == p_ce_msg->reg_listen.ee_handle)) {
      LOG(ERROR) << StringPrintf("UICC (0x%x) listening already specified",
                                 p_ce_msg->reg_listen.ee_handle);
      conn_evt.status = NFA_STATUS_FAILED;
      nfa_dm_conn_cback_event_notify(NFA_CE_UICC_LISTEN_CONFIGURED_EVT,
                                     &conn_evt);
      return true;
    }
    /* If this is a free entry, and we haven't found one yet, remember it */
    else if ((!(p_cb->listen_info[i].flags & NFA_CE_LISTEN_INFO_IN_USE)) &&
             (listen_info_idx == NFA_CE_LISTEN_INFO_IDX_INVALID)) {
      listen_info_idx = i;
    }
  }

  /* Add new entry to listen_info table */
  if (listen_info_idx == NFA_CE_LISTEN_INFO_IDX_INVALID) {
    LOG(ERROR) << StringPrintf("Maximum listen callbacks exceeded (%i)",
                               NFA_CE_LISTEN_INFO_MAX);

    if (p_ce_msg->reg_listen.listen_type == NFA_CE_REG_TYPE_UICC) {
      conn_evt.status = NFA_STATUS_FAILED;
      nfa_dm_conn_cback_event_notify(NFA_CE_UICC_LISTEN_CONFIGURED_EVT,
                                     &conn_evt);
    } else {
      /* Notify application */
      conn_evt.ce_registered.handle = NFA_HANDLE_INVALID;
      conn_evt.ce_registered.status = NFA_STATUS_FAILED;
      (*p_ce_msg->reg_listen.p_conn_cback)(NFA_CE_REGISTERED_EVT, &conn_evt);
    }
    return true;
  } else {
    DLOG_IF(INFO, nfc_debug_enabled)
        << StringPrintf("NFA_CE: adding listen_info entry %i", listen_info_idx);

    /* Store common parameters */
    /* Mark entry as 'in-use', and NFA_CE_LISTEN_INFO_START_NTF_PND */
    /* (LISTEN_START_EVT will be notified when discovery successfully starts */
    p_cb->listen_info[listen_info_idx].flags =
        NFA_CE_LISTEN_INFO_IN_USE | NFA_CE_LISTEN_INFO_START_NTF_PND;
    p_cb->listen_info[listen_info_idx].rf_disc_handle = NFA_HANDLE_INVALID;
    p_cb->listen_info[listen_info_idx].protocol_mask = 0;

    /* Store type-specific parameters */
    switch (p_ce_msg->reg_listen.listen_type) {
      case NFA_CE_REG_TYPE_ISO_DEP:
        p_cb->listen_info[listen_info_idx].protocol_mask =
            NFA_PROTOCOL_MASK_ISO_DEP;
        p_cb->listen_info[listen_info_idx].flags |= NFA_CE_LISTEN_INFO_T4T_AID;
        p_cb->listen_info[listen_info_idx].p_conn_cback =
            p_ce_msg->reg_listen.p_conn_cback;

        /* Register this AID with CE_T4T */
        p_cb->listen_info[listen_info_idx].t4t_aid_handle = CE_T4tRegisterAID(
            p_ce_msg->reg_listen.aid_len, p_ce_msg->reg_listen.aid,
            nfa_ce_handle_t4t_aid_evt);
        if (p_cb->listen_info[listen_info_idx].t4t_aid_handle ==
            CE_T4T_AID_HANDLE_INVALID) {
          LOG(ERROR) << StringPrintf("Unable to register AID");
          p_cb->listen_info[listen_info_idx].flags = 0;

          /* Notify application */
          conn_evt.ce_registered.handle = NFA_HANDLE_INVALID;
          conn_evt.ce_registered.status = NFA_STATUS_FAILED;
          (*p_ce_msg->reg_listen.p_conn_cback)(NFA_CE_REGISTERED_EVT,
                                               &conn_evt);

          return true;
        }
        if (p_cb->listen_info[listen_info_idx].t4t_aid_handle ==
            CE_T4T_WILDCARD_AID_HANDLE)
          nfa_ce_cb.idx_wild_card = listen_info_idx;
        break;

      case NFA_CE_REG_TYPE_FELICA:
        p_cb->listen_info[listen_info_idx].protocol_mask =
            NFA_PROTOCOL_MASK_T3T;
        p_cb->listen_info[listen_info_idx].flags |= NFA_CE_LISTEN_INFO_FELICA;
        p_cb->listen_info[listen_info_idx].p_conn_cback =
            p_ce_msg->reg_listen.p_conn_cback;

        /* Store system code and nfcid2 */
        p_cb->listen_info[listen_info_idx].t3t_system_code =
            p_ce_msg->reg_listen.system_code;
        memcpy(p_cb->listen_info[listen_info_idx].t3t_nfcid2,
               p_ce_msg->reg_listen.nfcid2, NCI_RF_F_UID_LEN);
        memcpy(p_cb->listen_info[listen_info_idx].t3t_pmm,
               p_ce_msg->reg_listen.t3tPmm, NCI_T3T_PMM_LEN);
        break;

#if (NFC_NFCEE_INCLUDED == TRUE)
      case NFA_CE_REG_TYPE_UICC:
        p_cb->listen_info[listen_info_idx].flags |= NFA_CE_LISTEN_INFO_UICC;
        p_cb->listen_info[listen_info_idx].p_conn_cback =
            &nfa_dm_conn_cback_event_notify;

        /* Store EE handle and Tech */
        p_cb->listen_info[listen_info_idx].ee_handle =
            p_ce_msg->reg_listen.ee_handle;
        p_cb->listen_info[listen_info_idx].tech_mask =
            p_ce_msg->reg_listen.tech_mask;
        break;
#endif
    }
  }

  /* Start listening */
  conn_evt.status = nfa_ce_start_listening();
  if (conn_evt.status != NFA_STATUS_OK) {
    LOG(ERROR) << StringPrintf(
        "nfa_ce_api_reg_listen: unable to register new listen params with DM");
    p_cb->listen_info[listen_info_idx].flags = 0;
  }

  /* Nofitify app of status */
  if (p_ce_msg->reg_listen.listen_type == NFA_CE_REG_TYPE_UICC) {
    (*p_cb->listen_info[listen_info_idx].p_conn_cback)(
        NFA_CE_UICC_LISTEN_CONFIGURED_EVT, &conn_evt);
  } else {
    conn_evt.ce_registered.handle = NFA_HANDLE_GROUP_CE | listen_info_idx;
    DLOG_IF(INFO, nfc_debug_enabled)
        << StringPrintf("nfa_ce_api_reg_listen: registered handle 0x%04X",
                        conn_evt.ce_registered.handle);
    (*p_cb->listen_info[listen_info_idx].p_conn_cback)(NFA_CE_REGISTERED_EVT,
                                                       &conn_evt);
  }

  return true;
}

/*******************************************************************************
**
** Function         nfa_ce_api_dereg_listen
**
** Description      Deregister listen params
**
** Returns          TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_ce_api_dereg_listen(tNFA_CE_MSG* p_ce_msg) {
  tNFA_CE_CB* p_cb = &nfa_ce_cb;
  uint8_t listen_info_idx;
  tNFA_CONN_EVT_DATA conn_evt;

#if (NFC_NFCEE_INCLUDED == TRUE)
  /* Check if deregistering UICC , or virtual secure element listen */
  if (p_ce_msg->dereg_listen.listen_info == NFA_CE_LISTEN_INFO_UICC) {
    /* Deregistering UICC listen. Look for listen_info for this UICC ee handle
     */
    for (listen_info_idx = 0; listen_info_idx < NFA_CE_LISTEN_INFO_MAX;
         listen_info_idx++) {
      if ((p_cb->listen_info[listen_info_idx].flags &
           NFA_CE_LISTEN_INFO_IN_USE) &&
          (p_cb->listen_info[listen_info_idx].flags &
           NFA_CE_LISTEN_INFO_UICC) &&
          (p_cb->listen_info[listen_info_idx].ee_handle ==
           p_ce_msg->dereg_listen.handle)) {
        /* UICC is in not idle state */
        if ((p_cb->flags & NFA_CE_FLAGS_LISTEN_ACTIVE_SLEEP) &&
            (p_cb->idx_cur_active == listen_info_idx)) {
          /* wait for deactivation */
          p_cb->flags |= NFA_CE_FLAGS_APP_INIT_DEACTIVATION;
          nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_IDLE);
        } else {
          /* Stop listening */
          if (p_cb->listen_info[listen_info_idx].rf_disc_handle !=
              NFA_HANDLE_INVALID) {
            nfa_dm_delete_rf_discover(
                p_cb->listen_info[listen_info_idx].rf_disc_handle);
            p_cb->listen_info[listen_info_idx].rf_disc_handle =
                NFA_HANDLE_INVALID;
          }

          /* Remove entry and notify application */
          nfa_ce_remove_listen_info_entry(listen_info_idx, true);
        }
        break;
      }
    }

    if (listen_info_idx == NFA_CE_LISTEN_INFO_MAX) {
      LOG(ERROR) << StringPrintf("cannot find listen_info for UICC");
      conn_evt.status = NFA_STATUS_INVALID_PARAM;
      nfa_dm_conn_cback_event_notify(NFA_CE_UICC_LISTEN_CONFIGURED_EVT,
                                     &conn_evt);
    }
  } else
#endif
  {
    /* Deregistering virtual secure element listen */
    listen_info_idx = p_ce_msg->dereg_listen.handle & NFA_HANDLE_MASK;
    if (nfa_ce_cb.idx_wild_card == listen_info_idx) {
      nfa_ce_cb.idx_wild_card = NFA_CE_LISTEN_INFO_IDX_INVALID;
    }

    if ((listen_info_idx < NFA_CE_LISTEN_INFO_MAX) &&
        (p_cb->listen_info[listen_info_idx].flags &
         NFA_CE_LISTEN_INFO_IN_USE)) {
      /* virtual secure element is in not idle state */
      if ((p_cb->flags & NFA_CE_FLAGS_LISTEN_ACTIVE_SLEEP) &&
          (p_cb->idx_cur_active == listen_info_idx)) {
        /* wait for deactivation */
        p_cb->flags |= NFA_CE_FLAGS_APP_INIT_DEACTIVATION;
        nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_IDLE);
      } else {
        /* Stop listening */
        if (p_cb->listen_info[listen_info_idx].rf_disc_handle !=
            NFA_HANDLE_INVALID) {
          nfa_dm_delete_rf_discover(
              p_cb->listen_info[listen_info_idx].rf_disc_handle);
          p_cb->listen_info[listen_info_idx].rf_disc_handle =
              NFA_HANDLE_INVALID;
        }

        /* Remove entry and notify application */
        nfa_ce_remove_listen_info_entry(listen_info_idx, true);
      }
    } else {
      LOG(ERROR) << StringPrintf(
          "cannot find listen_info for "
          "Felica/T4tAID");
      conn_evt.status = NFA_STATUS_INVALID_PARAM;
      nfa_dm_conn_cback_event_notify(NFA_CE_DEREGISTERED_EVT, &conn_evt);
    }
  }

  return true;
}

/*******************************************************************************
**
** Function         nfa_ce_api_cfg_isodep_tech
**
** Description      Configure the technologies (NFC-A and/or NFC-B) to listen
**                  for ISO-DEP
**
** Returns          TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_ce_api_cfg_isodep_tech(tNFA_CE_MSG* p_ce_msg) {
  nfa_ce_cb.isodep_disc_mask = 0;
  if (p_ce_msg->hdr.layer_specific & NFA_TECHNOLOGY_MASK_A)
    nfa_ce_cb.isodep_disc_mask = NFA_DM_DISC_MASK_LA_ISO_DEP;

  if (p_ce_msg->hdr.layer_specific & NFA_TECHNOLOGY_MASK_B)
    nfa_ce_cb.isodep_disc_mask |= NFA_DM_DISC_MASK_LB_ISO_DEP;
  return true;
}