Snap for 4373604 from 8e89469b5e223a48e1915f16862e81a3f4581259 to oc-mr1-release

Change-Id: I6676010766f362dd3512533f650f75be0e2519d5

25 files changed, 361 insertions, 192 deletions

diff --git a/bta/jv/bta_jv_act.cc b/bta/jv/bta_jv_act.cc
index deba61132..d1d66aa8e 100644
--- a/bta/jv/bta_jv_act.cc
+++ b/bta/jv/bta_jv_act.cc
@@ -627,7 +627,9 @@ bool bta_jv_check_psm(uint16_t psm) {
 void bta_jv_enable(tBTA_JV_MSG* p_data) {
   tBTA_JV_STATUS status = BTA_JV_SUCCESS;
   bta_jv_cb.p_dm_cback = p_data->enable.p_cback;
-  bta_jv_cb.p_dm_cback(BTA_JV_ENABLE_EVT, (tBTA_JV*)&status, 0);
+  tBTA_JV bta_jv;
+  bta_jv.status = status;
+  bta_jv_cb.p_dm_cback(BTA_JV_ENABLE_EVT, &bta_jv, 0);
   memset(bta_jv_cb.free_psm_list, 0, sizeof(bta_jv_cb.free_psm_list));
 }
 
@@ -718,9 +720,12 @@ void bta_jv_get_channel_id(tBTA_JV_MSG* p_data) {
         bta_jv_cb.scn[channel - 1] = true;
         scn = (uint8_t)channel;
       }
-      if (bta_jv_cb.p_dm_cback)
-        bta_jv_cb.p_dm_cback(BTA_JV_GET_SCN_EVT, (tBTA_JV*)&scn,
+      if (bta_jv_cb.p_dm_cback) {
+        tBTA_JV bta_jv;
+        bta_jv.scn = scn;
+        bta_jv_cb.p_dm_cback(BTA_JV_GET_SCN_EVT, &bta_jv,
                              p_data->alloc_channel.rfcomm_slot_id);
+      }
       return;
     }
     case BTA_JV_CONN_TYPE_L2CAP:
@@ -736,9 +741,12 @@ void bta_jv_get_channel_id(tBTA_JV_MSG* p_data) {
       break;
   }
 
-  if (bta_jv_cb.p_dm_cback)
-    bta_jv_cb.p_dm_cback(BTA_JV_GET_PSM_EVT, (tBTA_JV*)&psm,
+  if (bta_jv_cb.p_dm_cback) {
+    tBTA_JV bta_jv;
+    bta_jv.psm = psm;
+    bta_jv_cb.p_dm_cback(BTA_JV_GET_PSM_EVT, &bta_jv,
                          p_data->alloc_channel.l2cap_socket_id);
+  }
 }
 
 /*******************************************************************************
@@ -840,8 +848,9 @@ static void bta_jv_start_discovery_cback(uint16_t result, void* user_data) {
     }
 
     dcomp.status = status;
-    bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, (tBTA_JV*)&dcomp,
-                         *p_rfcomm_slot_id);
+    tBTA_JV bta_jv;
+    bta_jv.disc_comp = dcomp;
+    bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, &bta_jv, *p_rfcomm_slot_id);
     osi_free(p_rfcomm_slot_id);
   }
 }
@@ -862,9 +871,12 @@ void bta_jv_start_discovery(tBTA_JV_MSG* p_data) {
   if (bta_jv_cb.sdp_active != BTA_JV_SDP_ACT_NONE) {
     /* SDP is still in progress */
     status = BTA_JV_BUSY;
-    if (bta_jv_cb.p_dm_cback)
-      bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, (tBTA_JV*)&status,
+    if (bta_jv_cb.p_dm_cback) {
+      tBTA_JV bta_jv;
+      bta_jv.status = status;
+      bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, &bta_jv,
                            p_data->start_discovery.rfcomm_slot_id);
+    }
     return;
   }
 
@@ -893,9 +905,12 @@ void bta_jv_start_discovery(tBTA_JV_MSG* p_data) {
           bta_jv_start_discovery_cback, (void*)rfcomm_slot_id)) {
     bta_jv_cb.sdp_active = BTA_JV_SDP_ACT_NONE;
     /* failed to start SDP. report the failure right away */
-    if (bta_jv_cb.p_dm_cback)
-      bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, (tBTA_JV*)&status,
+    if (bta_jv_cb.p_dm_cback) {
+      tBTA_JV bta_jv;
+      bta_jv.status = status;
+      bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, &bta_jv,
                            p_data->start_discovery.rfcomm_slot_id);
+    }
   }
   /*
   else report the result when the cback is called
@@ -915,11 +930,12 @@ void bta_jv_create_record(tBTA_JV_MSG* p_data) {
   tBTA_JV_API_CREATE_RECORD* cr = &(p_data->create_record);
   tBTA_JV_CREATE_RECORD evt_data;
   evt_data.status = BTA_JV_SUCCESS;
-  if (bta_jv_cb.p_dm_cback)
-    // callback user immediately to create his own sdp record in stack thread
-    // context
-    bta_jv_cb.p_dm_cback(BTA_JV_CREATE_RECORD_EVT, (tBTA_JV*)&evt_data,
-                         cr->rfcomm_slot_id);
+  if (bta_jv_cb.p_dm_cback) {
+    // callback immediately to create the sdp record in stack thread context
+    tBTA_JV bta_jv;
+    bta_jv.create_rec = evt_data;
+    bta_jv_cb.p_dm_cback(BTA_JV_CREATE_RECORD_EVT, &bta_jv, cr->rfcomm_slot_id);
+  }
 }
 
 /*******************************************************************************
@@ -1072,9 +1088,11 @@ void bta_jv_l2cap_connect(tBTA_JV_MSG* p_data) {
   }
 
   evt_data.handle = handle;
-  if (cc->p_cback)
-    cc->p_cback(BTA_JV_L2CAP_CL_INIT_EVT, (tBTA_JV*)&evt_data,
-                cc->l2cap_socket_id);
+  if (cc->p_cback) {
+    tBTA_JV bta_jv;
+    bta_jv.l2c_cl_init = evt_data;
+    cc->p_cback(BTA_JV_L2CAP_CL_INIT_EVT, &bta_jv, cc->l2cap_socket_id);
+  }
 }
 
 /*******************************************************************************
@@ -1096,8 +1114,11 @@ void bta_jv_l2cap_close(tBTA_JV_MSG* p_data) {
   evt_data.status = bta_jv_free_l2c_cb(cc->p_cb);
   evt_data.async = false;
 
-  if (p_cback)
-    p_cback(BTA_JV_L2CAP_CLOSE_EVT, (tBTA_JV*)&evt_data, l2cap_socket_id);
+  if (p_cback) {
+    tBTA_JV bta_jv;
+    bta_jv.l2c_close = evt_data;
+    p_cback(BTA_JV_L2CAP_CLOSE_EVT, &bta_jv, l2cap_socket_id);
+  }
 }
 
 /*******************************************************************************
@@ -1231,9 +1252,11 @@ void bta_jv_l2cap_start_server(tBTA_JV_MSG* p_data) {
     p_cb->psm = ls->local_psm;
   }
 
-  if (ls->p_cback)
-    ls->p_cback(BTA_JV_L2CAP_START_EVT, (tBTA_JV*)&evt_data,
-                ls->l2cap_socket_id);
+  if (ls->p_cback) {
+    tBTA_JV bta_jv;
+    bta_jv.l2c_start = evt_data;
+    ls->p_cback(BTA_JV_L2CAP_START_EVT, &bta_jv, ls->l2cap_socket_id);
+  }
 }
 
 /*******************************************************************************
@@ -1258,8 +1281,11 @@ void bta_jv_l2cap_stop_server(tBTA_JV_MSG* p_data) {
       evt_data.handle = p_cb->handle;
       evt_data.status = bta_jv_free_l2c_cb(p_cb);
       evt_data.async = false;
-      if (p_cback)
-        p_cback(BTA_JV_L2CAP_CLOSE_EVT, (tBTA_JV*)&evt_data, l2cap_socket_id);
+      if (p_cback) {
+        tBTA_JV bta_jv;
+        bta_jv.l2c_close = evt_data;
+        p_cback(BTA_JV_L2CAP_CLOSE_EVT, &bta_jv, l2cap_socket_id);
+      }
       break;
     }
   }
@@ -1289,7 +1315,9 @@ void bta_jv_l2cap_read(tBTA_JV_MSG* p_data) {
     evt_data.status = BTA_JV_SUCCESS;
   }
 
-  rc->p_cback(BTA_JV_L2CAP_READ_EVT, (tBTA_JV*)&evt_data, rc->l2cap_socket_id);
+  tBTA_JV bta_jv;
+  bta_jv.l2c_read = evt_data;
+  rc->p_cback(BTA_JV_L2CAP_READ_EVT, &bta_jv, rc->l2cap_socket_id);
 }
 
 /*******************************************************************************
@@ -1341,7 +1369,9 @@ void bta_jv_l2cap_write(tBTA_JV_MSG* p_data) {
             GAP_ConnWriteData(ls->handle, ls->p_data, ls->len, &evt_data.len)) {
       evt_data.status = BTA_JV_SUCCESS;
     }
-    ls->p_cb->p_cback(BTA_JV_L2CAP_WRITE_EVT, (tBTA_JV*)&evt_data, ls->user_id);
+    tBTA_JV bta_jv;
+    bta_jv.l2c_write = evt_data;
+    ls->p_cb->p_cback(BTA_JV_L2CAP_WRITE_EVT, &bta_jv, ls->user_id);
   } else {
     /* As this pointer is checked in the API function, this occurs only when the
      * channel is
@@ -1379,7 +1409,9 @@ void bta_jv_l2cap_write_fixed(tBTA_JV_MSG* p_data) {
 
   L2CA_SendFixedChnlData(ls->channel, ls->addr, msg);
 
-  ls->p_cback(BTA_JV_L2CAP_WRITE_FIXED_EVT, (tBTA_JV*)&evt_data, ls->user_id);
+  tBTA_JV bta_jv;
+  bta_jv.l2c_write_fixed = evt_data;
+  ls->p_cback(BTA_JV_L2CAP_WRITE_FIXED_EVT, &bta_jv, ls->user_id);
 }
 
 /*******************************************************************************
@@ -1570,9 +1602,10 @@ void bta_jv_rfcomm_connect(tBTA_JV_MSG* p_data) {
       APPL_TRACE_ERROR("run out of rfc control block");
     }
   }
-  cc->p_cback(BTA_JV_RFCOMM_CL_INIT_EVT, (tBTA_JV*)&evt_data,
-              cc->rfcomm_slot_id);
-  if (evt_data.status == BTA_JV_FAILURE) {
+  tBTA_JV bta_jv;
+  bta_jv.rfc_cl_init = evt_data;
+  cc->p_cback(BTA_JV_RFCOMM_CL_INIT_EVT, &bta_jv, cc->rfcomm_slot_id);
+  if (bta_jv.rfc_cl_init.status == BTA_JV_FAILURE) {
     if (sec_id) bta_jv_free_sec_id(&sec_id);
     if (handle) RFCOMM_RemoveConnection(handle);
   }
@@ -1893,8 +1926,10 @@ void bta_jv_rfcomm_start_server(tBTA_JV_MSG* p_data) {
     PORT_SetState(handle, &port_state);
   } while (0);
 
-  rs->p_cback(BTA_JV_RFCOMM_START_EVT, (tBTA_JV*)&evt_data, rs->rfcomm_slot_id);
-  if (evt_data.status == BTA_JV_SUCCESS) {
+  tBTA_JV bta_jv;
+  bta_jv.rfc_start = evt_data;
+  rs->p_cback(BTA_JV_RFCOMM_START_EVT, &bta_jv, rs->rfcomm_slot_id);
+  if (bta_jv.rfc_start.status == BTA_JV_SUCCESS) {
     PORT_SetDataCOCallback(handle, bta_jv_port_data_co_cback);
   } else {
     if (sec_id) bta_jv_free_sec_id(&sec_id);
@@ -1968,8 +2003,9 @@ void bta_jv_rfcomm_write(tBTA_JV_MSG* p_data) {
   evt_data.cong = p_pcb->cong;
 
   if (p_cb->p_cback) {
-    p_cb->p_cback(BTA_JV_RFCOMM_WRITE_EVT, (tBTA_JV*)&evt_data,
-                  p_pcb->rfcomm_slot_id);
+    tBTA_JV bta_jv;
+    bta_jv.rfc_write = evt_data;
+    p_cb->p_cback(BTA_JV_RFCOMM_WRITE_EVT, &bta_jv, p_pcb->rfcomm_slot_id);
   } else {
     APPL_TRACE_ERROR("%s No JV callback set", __func__);
   }
@@ -2519,7 +2555,9 @@ void bta_jv_l2cap_start_server_le(tBTA_JV_MSG* p_data) {
   evt_data.sec_id = t->sec_id;
 
 out:
-  ss->p_cback(BTA_JV_L2CAP_START_EVT, (tBTA_JV*)&evt_data, ss->l2cap_socket_id);
+  tBTA_JV bta_jv;
+  bta_jv.l2c_start = evt_data;
+  ss->p_cback(BTA_JV_L2CAP_START_EVT, &bta_jv, ss->l2cap_socket_id);
 }
 
 /*******************************************************************************
diff --git a/bta/mce/bta_mce_act.cc b/bta/mce/bta_mce_act.cc
index cd9cdbab7..f188b01c2 100644
--- a/bta/mce/bta_mce_act.cc
+++ b/bta/mce/bta_mce_act.cc
@@ -111,8 +111,9 @@ static void bta_mce_search_cback(uint16_t result, void* user_data) {
     evt_data.status = BTA_MCE_SUCCESS;
   }
 
-  bta_mce_cb.p_dm_cback(BTA_MCE_MAS_DISCOVERY_COMP_EVT, (tBTA_MCE*)&evt_data,
-                        user_data);
+  tBTA_MCE bta_mce;
+  bta_mce.mas_disc_comp = evt_data;
+  bta_mce_cb.p_dm_cback(BTA_MCE_MAS_DISCOVERY_COMP_EVT, &bta_mce, user_data);
 }
 
 /*******************************************************************************
@@ -127,7 +128,9 @@ static void bta_mce_search_cback(uint16_t result, void* user_data) {
 void bta_mce_enable(tBTA_MCE_MSG* p_data) {
   tBTA_MCE_STATUS status = BTA_MCE_SUCCESS;
   bta_mce_cb.p_dm_cback = p_data->enable.p_cback;
-  bta_mce_cb.p_dm_cback(BTA_MCE_ENABLE_EVT, (tBTA_MCE*)&status, NULL);
+  tBTA_MCE bta_mce;
+  bta_mce.status = status;
+  bta_mce_cb.p_dm_cback(BTA_MCE_ENABLE_EVT, &bta_mce, NULL);
 }
 
 /*******************************************************************************
@@ -151,9 +154,11 @@ void bta_mce_get_remote_mas_instances(tBTA_MCE_MSG* p_data) {
   if (bta_mce_cb.sdp_active != BTA_MCE_SDP_ACT_NONE) {
     /* SDP is still in progress */
     status = BTA_MCE_BUSY;
-    if (bta_mce_cb.p_dm_cback)
-      bta_mce_cb.p_dm_cback(BTA_MCE_MAS_DISCOVERY_COMP_EVT, (tBTA_MCE*)&status,
-                            NULL);
+    if (bta_mce_cb.p_dm_cback) {
+      tBTA_MCE bta_mce;
+      bta_mce.status = status;
+      bta_mce_cb.p_dm_cback(BTA_MCE_MAS_DISCOVERY_COMP_EVT, &bta_mce, NULL);
+    }
 
     return;
   }
@@ -170,9 +175,11 @@ void bta_mce_get_remote_mas_instances(tBTA_MCE_MSG* p_data) {
     bta_mce_cb.sdp_active = BTA_MCE_SDP_ACT_NONE;
 
     /* failed to start SDP. report the failure right away */
-    if (bta_mce_cb.p_dm_cback)
-      bta_mce_cb.p_dm_cback(BTA_MCE_MAS_DISCOVERY_COMP_EVT, (tBTA_MCE*)&status,
-                            NULL);
+    if (bta_mce_cb.p_dm_cback) {
+      tBTA_MCE bta_mce;
+      bta_mce.status = status;
+      bta_mce_cb.p_dm_cback(BTA_MCE_MAS_DISCOVERY_COMP_EVT, &bta_mce, NULL);
+    }
   }
   /*
   else report the result when the cback is called
diff --git a/bta/sdp/bta_sdp_act.cc b/bta/sdp/bta_sdp_act.cc
index 89e9f6b7e..172875fe8 100644
--- a/bta/sdp/bta_sdp_act.cc
+++ b/bta/sdp/bta_sdp_act.cc
@@ -447,7 +447,9 @@ static void bta_sdp_search_cback(uint16_t result, void* user_data) {
   }
   evt_data.status = status;
 
-  bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, (tBTA_SDP*)&evt_data,
+  tBTA_SDP bta_sdp;
+  bta_sdp.sdp_search_comp = evt_data;
+  bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, &bta_sdp,
                         (void*)&uuid->uu.uuid128);
   osi_free(user_data);  // We no longer need the user data to track the search
 }
@@ -465,7 +467,9 @@ void bta_sdp_enable(tBTA_SDP_MSG* p_data) {
   APPL_TRACE_DEBUG("%s in, sdp_active:%d", __func__, bta_sdp_cb.sdp_active);
   tBTA_SDP_STATUS status = BTA_SDP_SUCCESS;
   bta_sdp_cb.p_dm_cback = p_data->enable.p_cback;
-  bta_sdp_cb.p_dm_cback(BTA_SDP_ENABLE_EVT, (tBTA_SDP*)&status, NULL);
+  tBTA_SDP bta_sdp;
+  bta_sdp.status = status;
+  bta_sdp_cb.p_dm_cback(BTA_SDP_ENABLE_EVT, &bta_sdp, NULL);
 }
 
 /*******************************************************************************
@@ -495,7 +499,9 @@ void bta_sdp_search(tBTA_SDP_MSG* p_data) {
       result.uuid = p_data->get_search.uuid;
       result.remote_addr = p_data->get_search.bd_addr;
       result.status = status;
-      bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, (tBTA_SDP*)&result, NULL);
+      tBTA_SDP bta_sdp;
+      bta_sdp.sdp_search_comp = result;
+      bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, &bta_sdp, NULL);
     }
     return;
   }
@@ -528,7 +534,9 @@ void bta_sdp_search(tBTA_SDP_MSG* p_data) {
       result.uuid = p_data->get_search.uuid;
       result.remote_addr = p_data->get_search.bd_addr;
       result.status = status;
-      bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, (tBTA_SDP*)&result, NULL);
+      tBTA_SDP bta_sdp;
+      bta_sdp.sdp_search_comp = result;
+      bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, &bta_sdp, NULL);
     }
   }
   /*
diff --git a/stack/avct/avct_api.cc b/stack/avct/avct_api.cc
index 52e1c8c7e..af789e3e1 100644
--- a/stack/avct/avct_api.cc
+++ b/stack/avct/avct_api.cc
@@ -167,7 +167,9 @@ uint16_t AVCT_CreateConn(uint8_t* p_handle, tAVCT_CC* p_cc,
         /* bind lcb to ccb */
         p_ccb->p_lcb = p_lcb;
         AVCT_TRACE_DEBUG("ch_state: %d", p_lcb->ch_state);
-        avct_lcb_event(p_lcb, AVCT_LCB_UL_BIND_EVT, (tAVCT_LCB_EVT*)&p_ccb);
+        tAVCT_LCB_EVT avct_lcb_evt;
+        avct_lcb_evt.p_ccb = p_ccb;
+        avct_lcb_event(p_lcb, AVCT_LCB_UL_BIND_EVT, &avct_lcb_evt);
       }
     }
   }
@@ -204,8 +206,9 @@ uint16_t AVCT_RemoveConn(uint8_t handle) {
   }
   /* send unbind event to lcb */
   else {
-    avct_lcb_event(p_ccb->p_lcb, AVCT_LCB_UL_UNBIND_EVT,
-                   (tAVCT_LCB_EVT*)&p_ccb);
+    tAVCT_LCB_EVT avct_lcb_evt;
+    avct_lcb_evt.p_ccb = p_ccb;
+    avct_lcb_event(p_ccb->p_lcb, AVCT_LCB_UL_UNBIND_EVT, &avct_lcb_evt);
   }
   return result;
 }
@@ -268,7 +271,9 @@ uint16_t AVCT_CreateBrowse(uint8_t handle, uint8_t role) {
       p_ccb->p_bcb = p_bcb;
       p_bcb->peer_addr = p_ccb->p_lcb->peer_addr;
       AVCT_TRACE_DEBUG("ch_state: %d", p_bcb->ch_state);
-      avct_bcb_event(p_bcb, AVCT_LCB_UL_BIND_EVT, (tAVCT_LCB_EVT*)&p_ccb);
+      tAVCT_LCB_EVT avct_lcb_evt;
+      avct_lcb_evt.p_ccb = p_ccb;
+      avct_bcb_event(p_bcb, AVCT_LCB_UL_BIND_EVT, &avct_lcb_evt);
     }
   }
 
@@ -301,8 +306,9 @@ uint16_t AVCT_RemoveBrowse(uint8_t handle) {
   } else if (p_ccb->p_bcb != NULL)
   /* send unbind event to bcb */
   {
-    avct_bcb_event(p_ccb->p_bcb, AVCT_LCB_UL_UNBIND_EVT,
-                   (tAVCT_LCB_EVT*)&p_ccb);
+    tAVCT_LCB_EVT avct_lcb_evt;
+    avct_lcb_evt.p_ccb = p_ccb;
+    avct_bcb_event(p_ccb->p_bcb, AVCT_LCB_UL_UNBIND_EVT, &avct_lcb_evt);
   }
 
   return result;
@@ -417,14 +423,16 @@ uint16_t AVCT_MsgReq(uint8_t handle, uint8_t label, uint8_t cr, BT_HDR* p_msg) {
         osi_free(p_msg);
       } else {
         p_ccb->p_bcb = avct_bcb_by_lcb(p_ccb->p_lcb);
-        avct_bcb_event(p_ccb->p_bcb, AVCT_LCB_UL_MSG_EVT,
-                       (tAVCT_LCB_EVT*)&ul_msg);
+        tAVCT_LCB_EVT avct_lcb_evt;
+        avct_lcb_evt.ul_msg = ul_msg;
+        avct_bcb_event(p_ccb->p_bcb, AVCT_LCB_UL_MSG_EVT, &avct_lcb_evt);
       }
     }
     /* send msg event to lcb */
     else {
-      avct_lcb_event(p_ccb->p_lcb, AVCT_LCB_UL_MSG_EVT,
-                     (tAVCT_LCB_EVT*)&ul_msg);
+      tAVCT_LCB_EVT avct_lcb_evt;
+      avct_lcb_evt.ul_msg = ul_msg;
+      avct_lcb_event(p_ccb->p_lcb, AVCT_LCB_UL_MSG_EVT, &avct_lcb_evt);
     }
   }
   return result;
diff --git a/stack/avct/avct_bcb_act.cc b/stack/avct/avct_bcb_act.cc
index ddd5fe01b..bd99562ca 100644
--- a/stack/avct/avct_bcb_act.cc
+++ b/stack/avct/avct_bcb_act.cc
@@ -112,7 +112,9 @@ void avct_bcb_chnl_open(tAVCT_BCB* p_bcb, UNUSED_ATTR tAVCT_LCB_EVT* p_data) {
       L2CA_ErtmConnectReq(AVCT_BR_PSM, p_lcb->peer_addr, &ertm_info);
   if (p_bcb->ch_lcid == 0) {
     /* if connect req failed, send ourselves close event */
-    avct_bcb_event(p_bcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&result);
+    tAVCT_LCB_EVT avct_lcb_evt;
+    avct_lcb_evt.result = result;
+    avct_bcb_event(p_bcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
   }
 }
 
@@ -195,7 +197,9 @@ void avct_bcb_open_ind(tAVCT_BCB* p_bcb, tAVCT_LCB_EVT* p_data) {
   p_bcb->p_tx_msg = NULL;
 
   /* send msg event to bcb */
-  avct_bcb_event(p_bcb, AVCT_LCB_UL_MSG_EVT, (tAVCT_LCB_EVT*)&ul_msg);
+  tAVCT_LCB_EVT avct_lcb_evt;
+  avct_lcb_evt.ul_msg = ul_msg;
+  avct_bcb_event(p_bcb, AVCT_LCB_UL_MSG_EVT, &avct_lcb_evt);
 }
 
 /*******************************************************************************
diff --git a/stack/avct/avct_l2c.cc b/stack/avct/avct_l2c.cc
index cad4e4a16..f81ed56f8 100644
--- a/stack/avct/avct_l2c.cc
+++ b/stack/avct/avct_l2c.cc
@@ -194,10 +194,13 @@ void avct_l2c_connect_cfm_cback(uint16_t lcid, uint16_t result) {
       else {
         AVCT_TRACE_DEBUG("avct_l2c_connect_cfm_cback conflict_lcid:0x%x",
                          p_lcb->conflict_lcid);
-        if (p_lcb->conflict_lcid == lcid)
+        if (p_lcb->conflict_lcid == lcid) {
           p_lcb->conflict_lcid = 0;
-        else
-          avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&result);
+        } else {
+          tAVCT_LCB_EVT avct_lcb_evt;
+          avct_lcb_evt.result = result;
+          avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
+        }
       }
     } else if (p_lcb->conflict_lcid == lcid) {
       /* we must be in AVCT_CH_CFG state for the ch_lcid channel */
@@ -331,7 +334,9 @@ void avct_l2c_disconnect_ind_cback(uint16_t lcid, bool ack_needed) {
       L2CA_DisconnectRsp(lcid);
     }
 
-    avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&result);
+    tAVCT_LCB_EVT avct_lcb_evt;
+    avct_lcb_evt.result = result;
+    avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
     AVCT_TRACE_DEBUG("ch_state di: %d ", p_lcb->ch_state);
   }
 }
@@ -360,7 +365,9 @@ void avct_l2c_disconnect_cfm_cback(uint16_t lcid, uint16_t result) {
     res = (p_lcb->ch_result != 0) ? p_lcb->ch_result : result;
     p_lcb->ch_result = 0;
 
-    avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&res);
+    tAVCT_LCB_EVT avct_lcb_evt;
+    avct_lcb_evt.result = res;
+    avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
     AVCT_TRACE_DEBUG("ch_state dc: %d ", p_lcb->ch_state);
   }
 }
@@ -382,7 +389,9 @@ void avct_l2c_congestion_ind_cback(uint16_t lcid, bool is_congested) {
   /* look up lcb for this channel */
   p_lcb = avct_lcb_by_lcid(lcid);
   if (p_lcb != NULL) {
-    avct_lcb_event(p_lcb, AVCT_LCB_LL_CONG_EVT, (tAVCT_LCB_EVT*)&is_congested);
+    tAVCT_LCB_EVT avct_lcb_evt;
+    avct_lcb_evt.cong = is_congested;
+    avct_lcb_event(p_lcb, AVCT_LCB_LL_CONG_EVT, &avct_lcb_evt);
   }
 }
 
diff --git a/stack/avct/avct_l2c_br.cc b/stack/avct/avct_l2c_br.cc
index e6f767dd6..3b364cde6 100644
--- a/stack/avct/avct_l2c_br.cc
+++ b/stack/avct/avct_l2c_br.cc
@@ -192,7 +192,9 @@ void avct_l2c_br_connect_cfm_cback(uint16_t lcid, uint16_t result) {
 
   if (result != L2CAP_CONN_OK) {
     /* failure */
-    avct_bcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&result);
+    tAVCT_LCB_EVT avct_lcb_evt;
+    avct_lcb_evt.result = result;
+    avct_bcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
     return;
   }
 
@@ -342,7 +344,9 @@ void avct_l2c_br_disconnect_ind_cback(uint16_t lcid, bool ack_needed) {
     L2CA_DisconnectRsp(lcid);
   }
 
-  avct_bcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&result);
+  tAVCT_LCB_EVT avct_lcb_evt;
+  avct_lcb_evt.result = result;
+  avct_bcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
 }
 
 /*******************************************************************************
@@ -367,7 +371,9 @@ void avct_l2c_br_disconnect_cfm_cback(uint16_t lcid, uint16_t result) {
   res = (p_lcb->ch_result != 0) ? p_lcb->ch_result : result;
   p_lcb->ch_result = 0;
 
-  avct_bcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&res);
+  tAVCT_LCB_EVT avct_lcb_evt;
+  avct_lcb_evt.result = res;
+  avct_bcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
 }
 
 /*******************************************************************************
@@ -387,7 +393,9 @@ void avct_l2c_br_congestion_ind_cback(uint16_t lcid, bool is_congested) {
   p_lcb = avct_bcb_by_lcid(lcid);
   if (p_lcb == NULL) return;
 
-  avct_bcb_event(p_lcb, AVCT_LCB_LL_CONG_EVT, (tAVCT_LCB_EVT*)&is_congested);
+  tAVCT_LCB_EVT avct_lcb_evt;
+  avct_lcb_evt.cong = is_congested;
+  avct_bcb_event(p_lcb, AVCT_LCB_LL_CONG_EVT, &avct_lcb_evt);
 }
 
 /*******************************************************************************
diff --git a/stack/avct/avct_lcb_act.cc b/stack/avct/avct_lcb_act.cc
index 7d1d0739e..e2ce9db42 100644
--- a/stack/avct/avct_lcb_act.cc
+++ b/stack/avct/avct_lcb_act.cc
@@ -173,7 +173,9 @@ void avct_lcb_chnl_open(tAVCT_LCB* p_lcb, UNUSED_ATTR tAVCT_LCB_EVT* p_data) {
   p_lcb->ch_lcid = L2CA_ConnectReq(AVCT_PSM, p_lcb->peer_addr);
   if (p_lcb->ch_lcid == 0) {
     /* if connect req failed, send ourselves close event */
-    avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&result);
+    tAVCT_LCB_EVT avct_lcb_evt;
+    avct_lcb_evt.result = result;
+    avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
   }
 }
 
diff --git a/stack/avdt/avdt_ad.cc b/stack/avdt/avdt_ad.cc
index 3012def4d..614398585 100644
--- a/stack/avdt/avdt_ad.cc
+++ b/stack/avdt/avdt_ad.cc
@@ -305,7 +305,9 @@ void avdt_ad_tc_close_ind(tAVDT_TC_TBL* p_tbl, UNUSED_ATTR uint16_t reason) {
     if (p_scb != NULL) {
       close.tcid = p_tbl->tcid;
       close.type = avdt_ad_tcid_to_type(p_tbl->tcid);
-      avdt_scb_event(p_scb, AVDT_SCB_TC_CLOSE_EVT, (tAVDT_SCB_EVT*)&close);
+      tAVDT_SCB_EVT avdt_scb_evt;
+      avdt_scb_evt.close = close;
+      avdt_scb_event(p_scb, AVDT_SCB_TC_CLOSE_EVT, &avdt_scb_evt);
     }
   }
 }
@@ -343,7 +345,9 @@ void avdt_ad_tc_open_ind(tAVDT_TC_TBL* p_tbl) {
     if (p_tbl->cfg_flags & AVDT_L2C_CFG_CONN_ACP) {
       evt.err_param = AVDT_ACP;
     }
-    avdt_ccb_event(p_ccb, AVDT_CCB_LL_OPEN_EVT, (tAVDT_CCB_EVT*)&evt);
+    tAVDT_CCB_EVT avdt_ccb_evt;
+    avdt_ccb_evt.msg.hdr = evt;
+    avdt_ccb_event(p_ccb, AVDT_CCB_LL_OPEN_EVT, &avdt_ccb_evt);
   }
   /* if media or other channel, notify scb that channel open */
   else {
@@ -356,7 +360,9 @@ void avdt_ad_tc_open_ind(tAVDT_TC_TBL* p_tbl) {
       open.peer_mtu = p_tbl->peer_mtu;
       open.lcid = avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][p_tbl->tcid].lcid;
       open.hdr.err_code = avdt_ad_tcid_to_type(p_tbl->tcid);
-      avdt_scb_event(p_scb, AVDT_SCB_TC_OPEN_EVT, (tAVDT_SCB_EVT*)&open);
+      tAVDT_SCB_EVT avdt_scb_evt;
+      avdt_scb_evt.open = open;
+      avdt_scb_event(p_scb, AVDT_SCB_TC_OPEN_EVT, &avdt_scb_evt);
     }
   }
 }
@@ -382,7 +388,9 @@ void avdt_ad_tc_cong_ind(tAVDT_TC_TBL* p_tbl, bool is_congested) {
   /* if signaling channel, notify ccb of congestion */
   if (p_tbl->tcid == 0) {
     p_ccb = avdt_ccb_by_idx(p_tbl->ccb_idx);
-    avdt_ccb_event(p_ccb, AVDT_CCB_LL_CONG_EVT, (tAVDT_CCB_EVT*)&is_congested);
+    tAVDT_CCB_EVT avdt_ccb_evt;
+    avdt_ccb_evt.llcong = is_congested;
+    avdt_ccb_event(p_ccb, AVDT_CCB_LL_CONG_EVT, &avdt_ccb_evt);
   }
   /* if media or other channel, notify scb that channel open */
   else {
@@ -390,8 +398,9 @@ void avdt_ad_tc_cong_ind(tAVDT_TC_TBL* p_tbl, bool is_congested) {
     p_scb =
         avdt_scb_by_hdl(avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][p_tbl->tcid].scb_hdl);
     if (p_scb != NULL) {
-      avdt_scb_event(p_scb, AVDT_SCB_TC_CONG_EVT,
-                     (tAVDT_SCB_EVT*)&is_congested);
+      tAVDT_SCB_EVT avdt_scb_evt;
+      avdt_scb_evt.llcong = is_congested;
+      avdt_scb_event(p_scb, AVDT_SCB_TC_CONG_EVT, &avdt_scb_evt);
     }
   }
 }
diff --git a/stack/avdt/avdt_api.cc b/stack/avdt/avdt_api.cc
index a7a6fa5b6..26e0c29ee 100644
--- a/stack/avdt/avdt_api.cc
+++ b/stack/avdt/avdt_api.cc
@@ -42,7 +42,9 @@ void avdt_ccb_idle_ccb_timer_timeout(void* data) {
   uint8_t avdt_event = AVDT_CCB_IDLE_TOUT_EVT;
   uint8_t err_code = AVDT_ERR_TIMEOUT;
 
-  avdt_ccb_event(p_ccb, avdt_event, (tAVDT_CCB_EVT*)&err_code);
+  tAVDT_CCB_EVT avdt_ccb_evt;
+  avdt_ccb_evt.err_code = err_code;
+  avdt_ccb_event(p_ccb, avdt_event, &avdt_ccb_evt);
 }
 
 void avdt_ccb_ret_ccb_timer_timeout(void* data) {
@@ -50,7 +52,9 @@ void avdt_ccb_ret_ccb_timer_timeout(void* data) {
   uint8_t avdt_event = AVDT_CCB_RET_TOUT_EVT;
   uint8_t err_code = AVDT_ERR_TIMEOUT;
 
-  avdt_ccb_event(p_ccb, avdt_event, (tAVDT_CCB_EVT*)&err_code);
+  tAVDT_CCB_EVT avdt_ccb_evt;
+  avdt_ccb_evt.err_code = err_code;
+  avdt_ccb_event(p_ccb, avdt_event, &avdt_ccb_evt);
 }
 
 void avdt_ccb_rsp_ccb_timer_timeout(void* data) {
@@ -58,7 +62,9 @@ void avdt_ccb_rsp_ccb_timer_timeout(void* data) {
   uint8_t avdt_event = AVDT_CCB_RSP_TOUT_EVT;
   uint8_t err_code = AVDT_ERR_TIMEOUT;
 
-  avdt_ccb_event(p_ccb, avdt_event, (tAVDT_CCB_EVT*)&err_code);
+  tAVDT_CCB_EVT avdt_ccb_evt;
+  avdt_ccb_evt.err_code = err_code;
+  avdt_ccb_event(p_ccb, avdt_event, &avdt_ccb_evt);
 }
 
 void avdt_scb_transport_channel_timer_timeout(void* data) {
diff --git a/stack/avdt/avdt_ccb_act.cc b/stack/avdt/avdt_ccb_act.cc
index 852dcf842..f679dab46 100644
--- a/stack/avdt/avdt_ccb_act.cc
+++ b/stack/avdt/avdt_ccb_act.cc
@@ -506,8 +506,9 @@ void avdt_ccb_snd_start_cmd(tAVDT_CCB* p_ccb, tAVDT_CCB_EVT* p_data) {
       p_scb = avdt_scb_by_hdl(seid_list[i]);
       if (p_scb != NULL) {
         AVDT_TRACE_DEBUG("%s: AVDT_SCB_MSG_START_REJ_EVT: i=%d", __func__, i);
-        avdt_scb_event(p_scb, AVDT_SCB_MSG_START_REJ_EVT,
-                       (tAVDT_SCB_EVT*)&avdt_msg.hdr);
+        tAVDT_SCB_EVT avdt_scb_evt;
+        avdt_scb_evt.msg.hdr = avdt_msg.hdr;
+        avdt_scb_event(p_scb, AVDT_SCB_MSG_START_REJ_EVT, &avdt_scb_evt);
       }
     }
   }
@@ -580,8 +581,9 @@ void avdt_ccb_snd_suspend_cmd(tAVDT_CCB* p_ccb, tAVDT_CCB_EVT* p_data) {
     for (i = 0; i < p_data->msg.multi.num_seps; i++) {
       p_scb = avdt_scb_by_hdl(seid_list[i]);
       if (p_scb != NULL) {
-        avdt_scb_event(p_scb, AVDT_SCB_MSG_SUSPEND_REJ_EVT,
-                       (tAVDT_SCB_EVT*)&avdt_msg.hdr);
+        tAVDT_SCB_EVT avdt_scb_evt;
+        avdt_scb_evt.msg.hdr = avdt_msg.hdr;
+        avdt_scb_event(p_scb, AVDT_SCB_MSG_SUSPEND_REJ_EVT, &avdt_scb_evt);
       }
     }
   }
@@ -644,7 +646,9 @@ void avdt_ccb_clear_cmds(tAVDT_CCB* p_ccb, UNUSED_ATTR tAVDT_CCB_EVT* p_data) {
   */
   do {
     /* we know p_curr_cmd = NULL after this */
-    avdt_ccb_cmd_fail(p_ccb, (tAVDT_CCB_EVT*)&err_code);
+    tAVDT_CCB_EVT avdt_ccb_evt;
+    avdt_ccb_evt.err_code = err_code;
+    avdt_ccb_cmd_fail(p_ccb, &avdt_ccb_evt);
 
     /* set up next message */
     p_ccb->p_curr_cmd = (BT_HDR*)fixed_queue_try_dequeue(p_ccb->cmd_q);
@@ -686,13 +690,16 @@ void avdt_ccb_cmd_fail(tAVDT_CCB* p_ccb, tAVDT_CCB_EVT* p_data) {
     evt = avdt_msg_rej_2_evt[p_ccb->p_curr_cmd->event - 1];
 
     if (evt & AVDT_CCB_MKR) {
-      avdt_ccb_event(p_ccb, (uint8_t)(evt & ~AVDT_CCB_MKR),
-                     (tAVDT_CCB_EVT*)&msg);
+      tAVDT_CCB_EVT avdt_ccb_evt;
+      avdt_ccb_evt.msg = msg;
+      avdt_ccb_event(p_ccb, (uint8_t)(evt & ~AVDT_CCB_MKR), &avdt_ccb_evt);
     } else {
       /* we get the scb out of the current cmd */
       p_scb = avdt_scb_by_hdl(*((uint8_t*)(p_ccb->p_curr_cmd + 1)));
       if (p_scb != NULL) {
-        avdt_scb_event(p_scb, evt, (tAVDT_SCB_EVT*)&msg);
+        tAVDT_SCB_EVT avdt_scb_evt;
+        avdt_scb_evt.msg = msg;
+        avdt_scb_event(p_scb, evt, &avdt_scb_evt);
       }
     }
 
@@ -744,13 +751,13 @@ void avdt_ccb_cong_state(tAVDT_CCB* p_ccb, tAVDT_CCB_EVT* p_data) {
  *
  ******************************************************************************/
 void avdt_ccb_ret_cmd(tAVDT_CCB* p_ccb, tAVDT_CCB_EVT* p_data) {
-  uint8_t err_code = AVDT_ERR_TIMEOUT;
-
   p_ccb->ret_count++;
   if (p_ccb->ret_count == AVDT_RET_MAX) {
     /* command failed */
     p_ccb->ret_count = 0;
-    avdt_ccb_cmd_fail(p_ccb, (tAVDT_CCB_EVT*)&err_code);
+    tAVDT_CCB_EVT avdt_ccb_evt;
+    avdt_ccb_evt.err_code = AVDT_ERR_TIMEOUT;
+    avdt_ccb_cmd_fail(p_ccb, &avdt_ccb_evt);
 
     /* go to next queued command */
     avdt_ccb_snd_cmd(p_ccb, p_data);
@@ -882,8 +889,6 @@ void avdt_ccb_clr_reconn(tAVDT_CCB* p_ccb, UNUSED_ATTR tAVDT_CCB_EVT* p_data) {
  *
  ******************************************************************************/
 void avdt_ccb_chk_reconn(tAVDT_CCB* p_ccb, UNUSED_ATTR tAVDT_CCB_EVT* p_data) {
-  uint8_t err_code = AVDT_ERR_CONNECT;
-
   if (p_ccb->reconn) {
     p_ccb->reconn = false;
 
@@ -891,7 +896,10 @@ void avdt_ccb_chk_reconn(tAVDT_CCB* p_ccb, UNUSED_ATTR tAVDT_CCB_EVT* p_data) {
     avdt_ccb_clear_ccb(p_ccb);
 
     /* clear out current command, if any */
-    avdt_ccb_cmd_fail(p_ccb, (tAVDT_CCB_EVT*)&err_code);
+    uint8_t err_code = AVDT_ERR_CONNECT;
+    tAVDT_CCB_EVT avdt_ccb_evt;
+    avdt_ccb_evt.err_code = err_code;
+    avdt_ccb_cmd_fail(p_ccb, &avdt_ccb_evt);
 
     /* reopen the signaling channel */
     avdt_ccb_event(p_ccb, AVDT_CCB_UL_OPEN_EVT, NULL);
diff --git a/stack/avdt/avdt_msg.cc b/stack/avdt/avdt_msg.cc
index ef06576e5..7ab7edc00 100644
--- a/stack/avdt/avdt_msg.cc
+++ b/stack/avdt/avdt_msg.cc
@@ -1623,8 +1623,9 @@ void avdt_msg_ind(tAVDT_CCB* p_ccb, BT_HDR* p_buf) {
   if (ok) {
     /* if it's a ccb event send to ccb */
     if (evt & AVDT_CCB_MKR) {
-      avdt_ccb_event(p_ccb, (uint8_t)(evt & ~AVDT_CCB_MKR),
-                     (tAVDT_CCB_EVT*)&msg);
+      tAVDT_CCB_EVT avdt_ccb_evt;
+      avdt_ccb_evt.msg = msg;
+      avdt_ccb_event(p_ccb, (uint8_t)(evt & ~AVDT_CCB_MKR), &avdt_ccb_evt);
     }
     /* if it's a scb event */
     else {
@@ -1643,7 +1644,9 @@ void avdt_msg_ind(tAVDT_CCB* p_ccb, BT_HDR* p_buf) {
       if (evt) {
         p_scb = avdt_scb_by_hdl(scb_hdl);
         if (p_scb != NULL) {
-          avdt_scb_event(p_scb, evt, (tAVDT_SCB_EVT*)&msg);
+          tAVDT_SCB_EVT avdt_scb_evt;
+          avdt_scb_evt.msg = msg;
+          avdt_scb_event(p_scb, evt, &avdt_scb_evt);
         }
       }
     }
diff --git a/stack/avdt/avdt_scb_act.cc b/stack/avdt/avdt_scb_act.cc
index 85d32fd37..de6912b02 100644
--- a/stack/avdt/avdt_scb_act.cc
+++ b/stack/avdt/avdt_scb_act.cc
@@ -299,11 +299,10 @@ uint8_t* avdt_scb_hdl_report(tAVDT_SCB* p_scb, uint8_t* p, uint16_t len) {
   uint32_t ssrc;
   uint8_t o_v, o_p, o_cc;
   AVDT_REPORT_TYPE pt;
-  tAVDT_REPORT_DATA report, *p_rpt;
+  tAVDT_REPORT_DATA report;
 
   AVDT_TRACE_DEBUG("%s", __func__);
   if (p_scb->cs.p_report_cback) {
-    p_rpt = &report;
     /* parse report packet header */
     AVDT_MSG_PRS_RPT_OCTET1(p, o_v, o_p, o_cc);
     pt = *p++;
@@ -330,8 +329,16 @@ uint8_t* avdt_scb_hdl_report(tAVDT_SCB* p_scb, uint8_t* p, uint16_t len) {
         break;
 
       case AVDT_RTCP_PT_SDES: /* the packet type - SDES (Source Description) */
-        if (*p == AVDT_RTCP_SDES_CNAME) {
-          p_rpt = (tAVDT_REPORT_DATA*)(p + 2);
+        uint8_t sdes_type;
+        BE_STREAM_TO_UINT8(sdes_type, p);
+        if (sdes_type == AVDT_RTCP_SDES_CNAME) {
+          uint8_t name_length;
+          BE_STREAM_TO_UINT8(name_length, p);
+          if (name_length > len - 2 || name_length > AVDT_MAX_CNAME_SIZE) {
+            result = AVDT_BAD_PARAMS;
+          } else {
+            BE_STREAM_TO_ARRAY(p, &(report.cname[0]), name_length);
+          }
         } else {
           AVDT_TRACE_WARNING(" - SDES SSRC=0x%08x sc=%d %d len=%d %s", ssrc,
                              o_cc, *p, *(p + 1), p + 2);
@@ -345,7 +352,7 @@ uint8_t* avdt_scb_hdl_report(tAVDT_SCB* p_scb, uint8_t* p, uint16_t len) {
     }
 
     if (result == AVDT_SUCCESS)
-      (*p_scb->cs.p_report_cback)(avdt_scb_to_hdl(p_scb), pt, p_rpt);
+      (*p_scb->cs.p_report_cback)(avdt_scb_to_hdl(p_scb), pt, &report);
   }
   p_start += len;
   return p_start;
@@ -578,7 +585,9 @@ void avdt_scb_hdl_setconfig_rsp(tAVDT_SCB* p_scb,
 
     /* initiate open */
     single.seid = p_scb->peer_seid;
-    avdt_scb_event(p_scb, AVDT_SCB_API_OPEN_REQ_EVT, (tAVDT_SCB_EVT*)&single);
+    tAVDT_SCB_EVT avdt_scb_evt;
+    avdt_scb_evt.msg.single = single;
+    avdt_scb_event(p_scb, AVDT_SCB_API_OPEN_REQ_EVT, &avdt_scb_evt);
   }
 }
 
@@ -925,7 +934,9 @@ void avdt_scb_snd_abort_req(tAVDT_SCB* p_scb,
 
     hdr.seid = p_scb->peer_seid;
 
-    avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_ABORT, (tAVDT_MSG*)&hdr);
+    tAVDT_MSG avdt_msg;
+    avdt_msg.hdr = hdr;
+    avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_ABORT, &avdt_msg);
   }
 }
 
@@ -961,7 +972,9 @@ void avdt_scb_snd_close_req(tAVDT_SCB* p_scb,
 
   hdr.seid = p_scb->peer_seid;
 
-  avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_CLOSE, (tAVDT_MSG*)&hdr);
+  tAVDT_MSG avdt_msg;
+  avdt_msg.hdr = hdr;
+  avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_CLOSE, &avdt_msg);
 }
 
 /*******************************************************************************
@@ -1006,7 +1019,9 @@ void avdt_scb_snd_getconfig_req(tAVDT_SCB* p_scb,
 
   hdr.seid = p_scb->peer_seid;
 
-  avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_GETCONFIG, (tAVDT_MSG*)&hdr);
+  tAVDT_MSG avdt_msg;
+  avdt_msg.hdr = hdr;
+  avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_GETCONFIG, &avdt_msg);
 }
 
 /*******************************************************************************
@@ -1037,7 +1052,9 @@ void avdt_scb_snd_open_req(tAVDT_SCB* p_scb,
 
   hdr.seid = p_scb->peer_seid;
 
-  avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_OPEN, (tAVDT_MSG*)&hdr);
+  tAVDT_MSG avdt_msg;
+  avdt_msg.hdr = hdr;
+  avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_OPEN, &avdt_msg);
 }
 
 /*******************************************************************************
diff --git a/stack/avrc/avrc_api.cc b/stack/avrc/avrc_api.cc
index e2d85f904..b67a6b764 100644
--- a/stack/avrc/avrc_api.cc
+++ b/stack/avrc/avrc_api.cc
@@ -594,7 +594,10 @@ static uint8_t avrc_proc_far_msg(uint8_t handle, uint8_t label, uint8_t cr,
     }
     avrc_cmd.status = AVRC_STS_NO_ERROR;
     avrc_cmd.target_pdu = p_rcb->rasm_pdu;
-    status = AVRC_BldCommand((tAVRC_COMMAND*)&avrc_cmd, &p_cmd);
+
+    tAVRC_COMMAND avrc_command;
+    avrc_command.continu = avrc_cmd;
+    status = AVRC_BldCommand(&avrc_command, &p_cmd);
     if (status == AVRC_STS_NO_ERROR) {
       AVRC_MsgReq(handle, (uint8_t)(label), AVRC_CMD_CTRL, p_cmd);
     }
diff --git a/stack/btm/btm_acl.cc b/stack/btm/btm_acl.cc
index 9f0b1f3fa..8df6acb81 100644
--- a/stack/btm/btm_acl.cc
+++ b/stack/btm/btm_acl.cc
@@ -479,7 +479,9 @@ void btm_acl_update_busy_level(tBTM_BLI_EVENT event) {
     evt.busy_level = busy_level;
     btm_cb.busy_level = busy_level;
     if (btm_cb.p_bl_changed_cb && (btm_cb.bl_evt_mask & BTM_BL_UPDATE_MASK)) {
-      (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA*)&evt);
+      tBTM_BL_EVENT_DATA btm_bl_event_data;
+      btm_bl_event_data.update = evt;
+      (*btm_cb.p_bl_changed_cb)(&btm_bl_event_data);
     }
   }
 }
@@ -683,7 +685,9 @@ void btm_acl_encrypt_change(uint16_t handle, uint8_t status,
       evt.new_role = btm_cb.devcb.switch_role_ref_data.role;
       evt.p_bda = &btm_cb.devcb.switch_role_ref_data.remote_bd_addr;
       evt.hci_status = btm_cb.devcb.switch_role_ref_data.hci_status;
-      (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA*)&evt);
+      tBTM_BL_EVENT_DATA btm_bl_event_data;
+      btm_bl_event_data.role_chg = evt;
+      (*btm_cb.p_bl_changed_cb)(&btm_bl_event_data);
 
       BTM_TRACE_DEBUG(
           "Role Switch Event: new_role 0x%02x, HCI Status 0x%02x, rs_st:%d",
@@ -1488,7 +1492,9 @@ void btm_acl_role_changed(uint8_t hci_status, const RawAddress* bd_addr,
     evt.new_role = new_role;
     evt.p_bda = p_bda;
     evt.hci_status = hci_status;
-    (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA*)&evt);
+    tBTM_BL_EVENT_DATA btm_bl_event_data;
+    btm_bl_event_data.role_chg = evt;
+    (*btm_cb.p_bl_changed_cb)(&btm_bl_event_data);
   }
 
   BTM_TRACE_DEBUG(
diff --git a/stack/btm/btm_sco.cc b/stack/btm/btm_sco.cc
index bb60c61e4..dea830f96 100644
--- a/stack/btm/btm_sco.cc
+++ b/stack/btm/btm_sco.cc
@@ -840,8 +840,9 @@ void btm_sco_conn_req(const RawAddress& bda, DEV_CLASS dev_class,
         memcpy(evt_data.dev_class, dev_class, DEV_CLASS_LEN);
         evt_data.link_type = link_type;
         evt_data.sco_inx = xx;
-        p->esco.p_esco_cback(BTM_ESCO_CONN_REQ_EVT,
-                             (tBTM_ESCO_EVT_DATA*)&evt_data);
+        tBTM_ESCO_EVT_DATA btm_esco_evt_data;
+        btm_esco_evt_data.conn_evt = evt_data;
+        p->esco.p_esco_cback(BTM_ESCO_CONN_REQ_EVT, &btm_esco_evt_data);
       }
 
       return;
@@ -1596,7 +1597,9 @@ void btm_esco_proc_conn_chg(uint8_t status, uint16_t handle,
         data.tx_interval = p->esco.data.tx_interval = tx_interval;
         data.retrans_window = p->esco.data.retrans_window = retrans_window;
 
-        (*p->esco.p_esco_cback)(BTM_ESCO_CHG_EVT, (tBTM_ESCO_EVT_DATA*)&data);
+        tBTM_ESCO_EVT_DATA btm_esco_evt_data;
+        btm_esco_evt_data.chg_evt = data;
+        (*p->esco.p_esco_cback)(BTM_ESCO_CHG_EVT, &btm_esco_evt_data);
       }
       return;
     }
diff --git a/stack/btm/btm_sec.cc b/stack/btm/btm_sec.cc
index 933420089..60a3a17ef 100644
--- a/stack/btm/btm_sec.cc
+++ b/stack/btm/btm_sec.cc
@@ -3593,7 +3593,7 @@ void btm_proc_sp_req_evt(tBTM_SP_EVT event, uint8_t* p) {
     }
 
     if (btm_cb.api.p_sp_callback) {
-      status = (*btm_cb.api.p_sp_callback)(event, (tBTM_SP_EVT_DATA*)&evt_data);
+      status = (*btm_cb.api.p_sp_callback)(event, &evt_data);
       if (status != BTM_NOT_AUTHORIZED) {
         return;
       }
@@ -3805,9 +3805,11 @@ void btm_read_local_oob_complete(uint8_t* p) {
   } else
     evt_data.status = BTM_ERR_PROCESSING;
 
-  if (btm_cb.api.p_sp_callback)
-    (*btm_cb.api.p_sp_callback)(BTM_SP_LOC_OOB_EVT,
-                                (tBTM_SP_EVT_DATA*)&evt_data);
+  if (btm_cb.api.p_sp_callback) {
+    tBTM_SP_EVT_DATA btm_sp_evt_data;
+    btm_sp_evt_data.loc_oob = evt_data;
+    (*btm_cb.api.p_sp_callback)(BTM_SP_LOC_OOB_EVT, &btm_sp_evt_data);
+  }
 }
 
 /*******************************************************************************
diff --git a/stack/gatt/gatt_api.cc b/stack/gatt/gatt_api.cc
index 1ee014d6a..c77a4c54f 100644
--- a/stack/gatt/gatt_api.cc
+++ b/stack/gatt/gatt_api.cc
@@ -498,8 +498,9 @@ tGATT_STATUS GATTS_HandleValueIndication(uint16_t conn_id, uint16_t attr_handle,
       cmd_status = GATT_NO_RESOURCES;
     }
   } else {
-    p_msg = attp_build_sr_msg(*p_tcb, GATT_HANDLE_VALUE_IND,
-                              (tGATT_SR_MSG*)&indication);
+    tGATT_SR_MSG gatt_sr_msg;
+    gatt_sr_msg.attr_value = indication;
+    p_msg = attp_build_sr_msg(*p_tcb, GATT_HANDLE_VALUE_IND, &gatt_sr_msg);
     if (p_msg != NULL) {
       cmd_status = attp_send_sr_msg(*p_tcb, p_msg);
 
@@ -553,8 +554,10 @@ tGATT_STATUS GATTS_HandleValueNotification(uint16_t conn_id,
   notif.auth_req = GATT_AUTH_REQ_NONE;
 
   tGATT_STATUS cmd_sent;
+  tGATT_SR_MSG gatt_sr_msg;
+  gatt_sr_msg.attr_value = notif;
   BT_HDR* p_buf =
-      attp_build_sr_msg(*p_tcb, GATT_HANDLE_VALUE_NOTIF, (tGATT_SR_MSG*)&notif);
+      attp_build_sr_msg(*p_tcb, GATT_HANDLE_VALUE_NOTIF, &gatt_sr_msg);
   if (p_buf != NULL) {
     cmd_sent = attp_send_sr_msg(*p_tcb, p_buf);
   } else
@@ -656,8 +659,9 @@ tGATT_STATUS GATTC_ConfigureMTU(uint16_t conn_id, uint16_t mtu) {
 
   p_clcb->p_tcb->payload_size = mtu;
   p_clcb->operation = GATTC_OPTYPE_CONFIG;
-  return attp_send_cl_msg(*p_clcb->p_tcb, p_clcb, GATT_REQ_MTU,
-                          (tGATT_CL_MSG*)&mtu);
+  tGATT_CL_MSG gatt_cl_msg;
+  gatt_cl_msg.mtu = mtu;
+  return attp_send_cl_msg(*p_clcb->p_tcb, p_clcb, GATT_REQ_MTU, &gatt_cl_msg);
 }
 
 
@@ -926,8 +930,10 @@ tGATT_STATUS GATTC_SendHandleValueConfirm(uint16_t conn_id, uint16_t handle) {
 
   VLOG(1) << "notif_count= " << p_tcb->ind_count;
   /* send confirmation now */
-  tGATT_STATUS ret = attp_send_cl_msg(*p_tcb, nullptr, GATT_HANDLE_VALUE_CONF,
-                                      (tGATT_CL_MSG*)&handle);
+  tGATT_CL_MSG gatt_cl_msg;
+  gatt_cl_msg.handle = handle;
+  tGATT_STATUS ret =
+      attp_send_cl_msg(*p_tcb, nullptr, GATT_HANDLE_VALUE_CONF, &gatt_cl_msg);
 
   p_tcb->ind_count = 0;
 
diff --git a/stack/gatt/gatt_cl.cc b/stack/gatt/gatt_cl.cc
index a3fcf087f..2843ac938 100644
--- a/stack/gatt/gatt_cl.cc
+++ b/stack/gatt/gatt_cl.cc
@@ -270,7 +270,9 @@ void gatt_send_queue_write_cancel(tGATT_TCB& tcb, tGATT_CLCB* p_clcb,
 
   VLOG(1) << __func__;
 
-  rt = attp_send_cl_msg(tcb, p_clcb, GATT_REQ_EXEC_WRITE, (tGATT_CL_MSG*)&flag);
+  tGATT_CL_MSG gatt_cl_msg;
+  gatt_cl_msg.exec_write = flag;
+  rt = attp_send_cl_msg(tcb, p_clcb, GATT_REQ_EXEC_WRITE, &gatt_cl_msg);
 
   if (rt != GATT_SUCCESS) {
     gatt_end_operation(p_clcb, rt, NULL);
@@ -647,11 +649,13 @@ void gatt_process_notification(tGATT_TCB& tcb, uint8_t op_code, uint16_t len,
   }
 
   encrypt_status = gatt_get_link_encrypt_status(tcb);
+  tGATT_CL_COMPLETE gatt_cl_complete;
+  gatt_cl_complete.att_value = value;
   for (i = 0, p_reg = gatt_cb.cl_rcb; i < GATT_MAX_APPS; i++, p_reg++) {
     if (p_reg->in_use && p_reg->app_cb.p_cmpl_cb) {
       conn_id = GATT_CREATE_CONN_ID(tcb.tcb_idx, p_reg->gatt_if);
       (*p_reg->app_cb.p_cmpl_cb)(conn_id, event, encrypt_status,
-                                 (tGATT_CL_COMPLETE*)&value);
+                                 &gatt_cl_complete);
     }
   }
 }
diff --git a/stack/gatt/gatt_sr.cc b/stack/gatt/gatt_sr.cc
index 211e57c9b..3af986639 100644
--- a/stack/gatt/gatt_sr.cc
+++ b/stack/gatt/gatt_sr.cc
@@ -315,8 +315,10 @@ void gatt_process_exec_write_req(tGATT_TCB& tcb, uint8_t op_code,
       if (tcb.prep_cnt[i]) {
         gatt_if = (tGATT_IF)(i + 1);
         conn_id = GATT_CREATE_CONN_ID(tcb.tcb_idx, gatt_if);
+        tGATTS_DATA gatts_data;
+        gatts_data.exec_write = flag;
         gatt_sr_send_req_callback(conn_id, trans_id, GATTS_REQ_TYPE_WRITE_EXEC,
-                                  (tGATTS_DATA*)&flag);
+                                  &gatts_data);
         tcb.prep_cnt[i] = 0;
       }
     }
@@ -742,18 +744,20 @@ static void gatts_process_mtu_req(tGATT_TCB& tcb, uint16_t len,
   l2cble_set_fixed_channel_tx_data_length(tcb.peer_bda, L2CAP_ATT_CID,
                                           tcb.payload_size);
 
-  BT_HDR* p_buf =
-      attp_build_sr_msg(tcb, GATT_RSP_MTU, (tGATT_SR_MSG*)&tcb.payload_size);
+  tGATT_SR_MSG gatt_sr_msg;
+  gatt_sr_msg.mtu = tcb.payload_size;
+  BT_HDR* p_buf = attp_build_sr_msg(tcb, GATT_RSP_MTU, &gatt_sr_msg);
   attp_send_sr_msg(tcb, p_buf);
 
+  tGATTS_DATA gatts_data;
+  gatts_data.mtu = tcb.payload_size;
   /* Notify all registered applicaiton with new MTU size. Us a transaction ID */
   /* of 0, as no response is allowed from applcations                    */
   for (int i = 0; i < GATT_MAX_APPS; i++) {
     if (gatt_cb.cl_rcb[i].in_use) {
       uint16_t conn_id =
           GATT_CREATE_CONN_ID(tcb.tcb_idx, gatt_cb.cl_rcb[i].gatt_if);
-      gatt_sr_send_req_callback(conn_id, 0, GATTS_REQ_TYPE_MTU,
-                                (tGATTS_DATA*)&tcb.payload_size);
+      gatt_sr_send_req_callback(conn_id, 0, GATTS_REQ_TYPE_MTU, &gatts_data);
     }
   }
 }
@@ -1140,12 +1144,14 @@ void gatts_process_value_conf(tGATT_TCB& tcb, uint8_t op_code) {
   bool continue_processing = gatts_proc_ind_ack(tcb, handle);
 
   if (continue_processing) {
+    tGATTS_DATA gatts_data;
+    gatts_data.handle = handle;
     for (auto& el : *gatt_cb.srv_list_info) {
       if (el.s_hdl <= handle && el.e_hdl >= handle) {
         uint32_t trans_id = gatt_sr_enqueue_cmd(tcb, op_code, handle);
         uint16_t conn_id = GATT_CREATE_CONN_ID(tcb.tcb_idx, el.gatt_if);
         gatt_sr_send_req_callback(conn_id, trans_id, GATTS_REQ_TYPE_CONF,
-                                  (tGATTS_DATA*)&handle);
+                                  &gatts_data);
       }
     }
   }
diff --git a/stack/gatt/gatt_utils.cc b/stack/gatt/gatt_utils.cc
index ad8ab7aa2..e7cc76286 100644
--- a/stack/gatt/gatt_utils.cc
+++ b/stack/gatt/gatt_utils.cc
@@ -849,15 +849,15 @@ void gatt_sr_send_req_callback(uint16_t conn_id, uint32_t trans_id,
  ******************************************************************************/
 tGATT_STATUS gatt_send_error_rsp(tGATT_TCB& tcb, uint8_t err_code,
                                  uint8_t op_code, uint16_t handle, bool deq) {
-  tGATT_ERROR error;
   tGATT_STATUS status;
   BT_HDR* p_buf;
 
-  error.cmd_code = op_code;
-  error.reason = err_code;
-  error.handle = handle;
+  tGATT_SR_MSG msg;
+  msg.error.cmd_code = op_code;
+  msg.error.reason = err_code;
+  msg.error.handle = handle;
 
-  p_buf = attp_build_sr_msg(tcb, GATT_RSP_ERROR, (tGATT_SR_MSG*)&error);
+  p_buf = attp_build_sr_msg(tcb, GATT_RSP_ERROR, &msg);
   if (p_buf != NULL) {
     status = attp_send_sr_msg(tcb, p_buf);
   } else
diff --git a/stack/hid/hidh_api.cc b/stack/hid/hidh_api.cc
index 704426fe3..adbc93104 100644
--- a/stack/hid/hidh_api.cc
+++ b/stack/hid/hidh_api.cc
@@ -233,11 +233,6 @@ void HID_HostInit(void) {
   uint8_t log_level = hh_cb.trace_level;
   memset(&hh_cb, 0, sizeof(tHID_HOST_CTB));
   hh_cb.trace_level = log_level;
-
-  for (size_t i = 0; i < HID_HOST_MAX_DEVICES; i++) {
-    hh_cb.devices[i].conn.process_repage_timer =
-        alarm_new("hid_devices_conn.process_repage_timer");
-  }
 }
 
 /*******************************************************************************
@@ -281,6 +276,10 @@ tHID_STATUS HID_HostRegister(tHID_HOST_DEV_CALLBACK* dev_cback) {
   hh_cb.callback = dev_cback;
   hh_cb.reg_flag = true;
 
+  for (size_t i = 0; i < HID_HOST_MAX_DEVICES; i++) {
+    hh_cb.devices[i].conn.process_repage_timer =
+        alarm_new("hid_devices_conn.process_repage_timer");
+  }
   return (HID_SUCCESS);
 }
 
@@ -299,6 +298,7 @@ tHID_STATUS HID_HostDeregister(void) {
   if (!hh_cb.reg_flag) return (HID_ERR_NOT_REGISTERED);
 
   for (i = 0; i < HID_HOST_MAX_DEVICES; i++) {
+    alarm_free(hh_cb.devices[i].conn.process_repage_timer);
     HID_HostRemoveDev(i);
   }
 
diff --git a/stack/mcap/mca_api.cc b/stack/mcap/mca_api.cc
index 565cebbe4..44ab25682 100644
--- a/stack/mcap/mca_api.cc
+++ b/stack/mcap/mca_api.cc
@@ -415,12 +415,13 @@ tMCA_RESULT MCA_CreateMdl(tMCA_CL mcl, tMCA_DEP dep, uint16_t data_psm,
       /* save the info required by dcb connection */
       p_dcb->p_chnl_cfg = p_chnl_cfg;
       p_dcb->mdl_id = mdl_id;
-      tMCA_CCB_MSG* p_evt_data =
-          (tMCA_CCB_MSG*)osi_malloc(sizeof(tMCA_CCB_MSG));
       if (!p_ccb->data_vpsm)
         p_ccb->data_vpsm =
             L2CA_Register(data_psm, (tL2CAP_APPL_INFO*)&mca_l2c_int_appl);
       if (p_ccb->data_vpsm) {
+        tMCA_CCB_EVT* mca_ccb_evt =
+            (tMCA_CCB_EVT*)osi_malloc(sizeof(tMCA_CCB_EVT));
+        tMCA_CCB_MSG* p_evt_data = &mca_ccb_evt->api;
         p_evt_data->dcb_idx = mca_dcb_to_hdl(p_dcb);
         p_evt_data->mdep_id = peer_dep_id;
         p_evt_data->mdl_id = mdl_id;
@@ -428,10 +429,8 @@ tMCA_RESULT MCA_CreateMdl(tMCA_CL mcl, tMCA_DEP dep, uint16_t data_psm,
         p_evt_data->op_code = MCA_OP_MDL_CREATE_REQ;
         p_evt_data->hdr.event = MCA_CCB_API_REQ_EVT;
         p_evt_data->hdr.layer_specific = false;
-        mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, (tMCA_CCB_EVT*)p_evt_data);
+        mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, mca_ccb_evt);
         return MCA_SUCCESS;
-      } else {
-        osi_free(p_evt_data);
       }
 
       mca_dcb_dealloc(p_dcb, NULL);
@@ -460,8 +459,6 @@ tMCA_RESULT MCA_CreateMdlRsp(tMCA_CL mcl, tMCA_DEP dep, uint16_t mdl_id,
                              const tMCA_CHNL_CFG* p_chnl_cfg) {
   tMCA_RESULT result = MCA_BAD_HANDLE;
   tMCA_CCB* p_ccb = mca_ccb_by_hdl(mcl);
-  tMCA_CCB_MSG evt_data;
-  tMCA_DCB* p_dcb;
 
   MCA_TRACE_API("MCA_CreateMdlRsp: %d dep=%d mdl_id=%d cfg=%d rsp_code=%d", mcl,
                 dep, mdl_id, cfg, rsp_code);
@@ -474,10 +471,11 @@ tMCA_RESULT MCA_CreateMdlRsp(tMCA_CL mcl, tMCA_DEP dep, uint16_t mdl_id,
     if (p_ccb->p_rx_msg && (p_ccb->p_rx_msg->mdep_id == dep) &&
         (p_ccb->p_rx_msg->mdl_id == mdl_id) &&
         (p_ccb->p_rx_msg->op_code == MCA_OP_MDL_CREATE_REQ)) {
+      tMCA_CCB_MSG evt_data;
       result = MCA_SUCCESS;
       evt_data.dcb_idx = 0;
       if (rsp_code == MCA_RSP_SUCCESS) {
-        p_dcb = mca_dcb_alloc(p_ccb, dep);
+        tMCA_DCB* p_dcb = mca_dcb_alloc(p_ccb, dep);
         if (p_dcb) {
           evt_data.dcb_idx = mca_dcb_to_hdl(p_dcb);
           p_dcb->p_chnl_cfg = p_chnl_cfg;
@@ -493,7 +491,9 @@ tMCA_RESULT MCA_CreateMdlRsp(tMCA_CL mcl, tMCA_DEP dep, uint16_t mdl_id,
         evt_data.param = cfg;
         evt_data.rsp_code = rsp_code;
         evt_data.op_code = MCA_OP_MDL_CREATE_RSP;
-        mca_ccb_event(p_ccb, MCA_CCB_API_RSP_EVT, (tMCA_CCB_EVT*)&evt_data);
+        tMCA_CCB_EVT mca_ccb_evt;
+        mca_ccb_evt.api = evt_data;
+        mca_ccb_event(p_ccb, MCA_CCB_API_RSP_EVT, &mca_ccb_evt);
       }
     } else {
       MCA_TRACE_ERROR(
@@ -570,8 +570,9 @@ tMCA_RESULT MCA_ReconnectMdl(tMCA_CL mcl, tMCA_DEP dep, uint16_t data_psm,
     p_dcb = mca_dcb_alloc(p_ccb, dep);
     result = MCA_NO_RESOURCES;
     if (p_dcb) {
-      tMCA_CCB_MSG* p_evt_data =
-          (tMCA_CCB_MSG*)osi_malloc(sizeof(tMCA_CCB_MSG));
+      tMCA_CCB_EVT* mca_ccb_evt =
+          (tMCA_CCB_EVT*)osi_malloc(sizeof(tMCA_CCB_EVT));
+      tMCA_CCB_MSG* p_evt_data = &mca_ccb_evt->api;
 
       p_dcb->p_chnl_cfg = p_chnl_cfg;
       p_dcb->mdl_id = mdl_id;
@@ -582,7 +583,7 @@ tMCA_RESULT MCA_ReconnectMdl(tMCA_CL mcl, tMCA_DEP dep, uint16_t data_psm,
       p_evt_data->mdl_id = mdl_id;
       p_evt_data->op_code = MCA_OP_MDL_RECONNECT_REQ;
       p_evt_data->hdr.event = MCA_CCB_API_REQ_EVT;
-      mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, (tMCA_CCB_EVT*)p_evt_data);
+      mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, mca_ccb_evt);
       return MCA_SUCCESS;
     }
   }
@@ -607,7 +608,6 @@ tMCA_RESULT MCA_ReconnectMdlRsp(tMCA_CL mcl, tMCA_DEP dep, uint16_t mdl_id,
                                 const tMCA_CHNL_CFG* p_chnl_cfg) {
   tMCA_RESULT result = MCA_BAD_HANDLE;
   tMCA_CCB* p_ccb = mca_ccb_by_hdl(mcl);
-  tMCA_CCB_MSG evt_data;
   tMCA_DCB* p_dcb;
 
   MCA_TRACE_API("MCA_ReconnectMdlRsp: %d ", mcl);
@@ -620,6 +620,7 @@ tMCA_RESULT MCA_ReconnectMdlRsp(tMCA_CL mcl, tMCA_DEP dep, uint16_t mdl_id,
     if (p_ccb->p_rx_msg && (p_ccb->p_rx_msg->mdl_id == mdl_id) &&
         (p_ccb->p_rx_msg->op_code == MCA_OP_MDL_RECONNECT_REQ)) {
       result = MCA_SUCCESS;
+      tMCA_CCB_MSG evt_data;
       evt_data.dcb_idx = 0;
       if (rsp_code == MCA_RSP_SUCCESS) {
         p_dcb = mca_dcb_alloc(p_ccb, dep);
@@ -637,7 +638,9 @@ tMCA_RESULT MCA_ReconnectMdlRsp(tMCA_CL mcl, tMCA_DEP dep, uint16_t mdl_id,
       evt_data.mdl_id = mdl_id;
       evt_data.rsp_code = rsp_code;
       evt_data.op_code = MCA_OP_MDL_RECONNECT_RSP;
-      mca_ccb_event(p_ccb, MCA_CCB_API_RSP_EVT, (tMCA_CCB_EVT*)&evt_data);
+      tMCA_CCB_EVT mca_ccb_evt;
+      mca_ccb_evt.api = evt_data;
+      mca_ccb_event(p_ccb, MCA_CCB_API_RSP_EVT, &mca_ccb_evt);
     } else {
       MCA_TRACE_ERROR(
           "The given MCL is not expecting a MCA_ReconnectMdlRsp with the given "
@@ -728,11 +731,12 @@ tMCA_RESULT MCA_Abort(tMCA_CL mcl) {
       return MCA_BUSY;
     }
 
-    tMCA_CCB_MSG* p_evt_data = (tMCA_CCB_MSG*)osi_malloc(sizeof(tMCA_CCB_MSG));
+    tMCA_CCB_EVT* mca_ccb_evt = (tMCA_CCB_EVT*)osi_malloc(sizeof(tMCA_CCB_EVT));
+    tMCA_CCB_MSG* p_evt_data = &mca_ccb_evt->api;
     result = MCA_SUCCESS;
     p_evt_data->op_code = MCA_OP_MDL_ABORT_REQ;
     p_evt_data->hdr.event = MCA_CCB_API_REQ_EVT;
-    mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, (tMCA_CCB_EVT*)p_evt_data);
+    mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, mca_ccb_evt);
   }
   return result;
 }
@@ -763,12 +767,13 @@ tMCA_RESULT MCA_Delete(tMCA_CL mcl, uint16_t mdl_id) {
       return MCA_BAD_PARAMS;
     }
 
-    tMCA_CCB_MSG* p_evt_data = (tMCA_CCB_MSG*)osi_malloc(sizeof(tMCA_CCB_MSG));
+    tMCA_CCB_EVT* mca_ccb_evt = (tMCA_CCB_EVT*)osi_malloc(sizeof(tMCA_CCB_EVT));
+    tMCA_CCB_MSG* p_evt_data = &mca_ccb_evt->api;
     result = MCA_SUCCESS;
     p_evt_data->mdl_id = mdl_id;
     p_evt_data->op_code = MCA_OP_MDL_DELETE_REQ;
     p_evt_data->hdr.event = MCA_CCB_API_REQ_EVT;
-    mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, (tMCA_CCB_EVT*)p_evt_data);
+    mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, mca_ccb_evt);
   }
   return result;
 }
diff --git a/stack/mcap/mca_dact.cc b/stack/mcap/mca_dact.cc
index a99d47c38..d05f3cdb8 100644
--- a/stack/mcap/mca_dact.cc
+++ b/stack/mcap/mca_dact.cc
@@ -111,13 +111,14 @@ void mca_dcb_free_data(UNUSED_ATTR tMCA_DCB* p_dcb, tMCA_DCB_EVT* p_data) {
  *
  ******************************************************************************/
 void mca_dcb_do_disconn(tMCA_DCB* p_dcb, UNUSED_ATTR tMCA_DCB_EVT* p_data) {
-  tMCA_CLOSE close;
-
   if ((p_dcb->lcid == 0) || (L2CA_DisconnectReq(p_dcb->lcid) == false)) {
+    tMCA_CLOSE close;
     close.param = MCA_INT;
     close.reason = L2CAP_DISC_OK;
     close.lcid = 0;
-    mca_dcb_event(p_dcb, MCA_DCB_TC_CLOSE_EVT, (tMCA_DCB_EVT*)&close);
+    tMCA_DCB_EVT mca_dcb_evt;
+    mca_dcb_evt.close = close;
+    mca_dcb_event(p_dcb, MCA_DCB_TC_CLOSE_EVT, &mca_dcb_evt);
   }
 }
 
diff --git a/stack/mcap/mca_main.cc b/stack/mcap/mca_main.cc
index 9f9dbaf1f..1cc8e7593 100644
--- a/stack/mcap/mca_main.cc
+++ b/stack/mcap/mca_main.cc
@@ -272,11 +272,6 @@ void mca_set_cfg_by_tbl(tL2CAP_CFG_INFO* p_cfg, tMCA_TC_TBL* p_tbl) {
 void mca_tc_close_ind(tMCA_TC_TBL* p_tbl, uint16_t reason) {
   tMCA_CCB* p_ccb;
   tMCA_DCB* p_dcb;
-  tMCA_CLOSE close;
-
-  close.param = MCA_ACP;
-  close.reason = reason;
-  close.lcid = p_tbl->lcid;
 
   MCA_TRACE_DEBUG("%s() - tcid: %d, cb_idx:%d, old: %d", __func__, p_tbl->tcid,
                   p_tbl->cb_idx, p_tbl->state);
@@ -284,22 +279,30 @@ void mca_tc_close_ind(tMCA_TC_TBL* p_tbl, uint16_t reason) {
   /* Check if the transport channel is in use */
   if (p_tbl->state == MCA_TC_ST_UNUSED) return;
 
+  tMCA_CLOSE close;
+
+  close.param = MCA_ACP;
+  close.reason = reason;
+  close.lcid = p_tbl->lcid;
+
   /* clear mca_tc_tbl entry */
   if (p_tbl->cfg_flags & MCA_L2C_CFG_DISCN_INT) close.param = MCA_INT;
   p_tbl->cfg_flags = 0;
   p_tbl->peer_mtu = L2CAP_DEFAULT_MTU;
 
-  /* if control channel, notify ccb that channel close */
+  /* if control channel, notify ccb of the channel close */
   if (p_tbl->tcid == MCA_CTRL_TCID) {
     p_ccb = mca_ccb_by_hdl((tMCA_CL)p_tbl->cb_idx);
-    mca_ccb_event(p_ccb, MCA_CCB_LL_CLOSE_EVT, (tMCA_CCB_EVT*)&close);
-  }
-  /* notify dcb that channel close */
-  else {
-    /* look up dcb  */
+    tMCA_CCB_EVT mca_ccb_evt;
+    mca_ccb_evt.close = close;
+    mca_ccb_event(p_ccb, MCA_CCB_LL_CLOSE_EVT, &mca_ccb_evt);
+  } else {
+    /* notify dcb of the channel close */
     p_dcb = mca_dcb_by_hdl(p_tbl->cb_idx);
     if (p_dcb != NULL) {
-      mca_dcb_event(p_dcb, MCA_DCB_TC_CLOSE_EVT, (tMCA_DCB_EVT*)&close);
+      tMCA_DCB_EVT mca_dcb_evt;
+      mca_dcb_evt.close = close;
+      mca_dcb_event(p_dcb, MCA_DCB_TC_CLOSE_EVT, &mca_dcb_evt);
     }
   }
   p_tbl->state = MCA_TC_ST_UNUSED;
@@ -334,20 +337,21 @@ void mca_tc_open_ind(tMCA_TC_TBL* p_tbl) {
     open.param = MCA_ACP;
   }
 
-  /* if control channel, notify ccb that channel open */
+  /* if control channel, notify ccb that the channel is open */
   if (p_tbl->tcid == MCA_CTRL_TCID) {
     p_ccb = mca_ccb_by_hdl((tMCA_CL)p_tbl->cb_idx);
-
-    mca_ccb_event(p_ccb, MCA_CCB_LL_OPEN_EVT, (tMCA_CCB_EVT*)&open);
-  }
-  /* must be data channel, notify dcb that channel open */
-  else {
-    /* look up dcb */
+    tMCA_CCB_EVT mca_ccb_evt;
+    mca_ccb_evt.open = open;
+    mca_ccb_event(p_ccb, MCA_CCB_LL_OPEN_EVT, &mca_ccb_evt);
+  } else {
+    /* must be data channel, notify dcb that the channel is open */
     p_dcb = mca_dcb_by_hdl(p_tbl->cb_idx);
 
     /* put lcid in event data */
     if (p_dcb != NULL) {
-      mca_dcb_event(p_dcb, MCA_DCB_TC_OPEN_EVT, (tMCA_DCB_EVT*)&open);
+      tMCA_DCB_EVT mca_dcb_evt;
+      mca_dcb_evt.open = open;
+      mca_dcb_event(p_dcb, MCA_DCB_TC_OPEN_EVT, &mca_dcb_evt);
     }
   }
 }
@@ -376,14 +380,16 @@ void mca_tc_cong_ind(tMCA_TC_TBL* p_tbl, bool is_congested) {
   /* if control channel, notify ccb of congestion */
   if (p_tbl->tcid == MCA_CTRL_TCID) {
     p_ccb = mca_ccb_by_hdl((tMCA_CL)p_tbl->cb_idx);
-    mca_ccb_event(p_ccb, MCA_CCB_LL_CONG_EVT, (tMCA_CCB_EVT*)&is_congested);
-  }
-  /* notify dcb that channel open */
-  else {
-    /* look up dcb by cb_idx */
+    tMCA_CCB_EVT mca_ccb_evt;
+    mca_ccb_evt.llcong = is_congested;
+    mca_ccb_event(p_ccb, MCA_CCB_LL_CONG_EVT, &mca_ccb_evt);
+  } else {
+    /* notify dcb that channel open */
     p_dcb = mca_dcb_by_hdl(p_tbl->cb_idx);
     if (p_dcb != NULL) {
-      mca_dcb_event(p_dcb, MCA_DCB_TC_CONG_EVT, (tMCA_DCB_EVT*)&is_congested);
+      tMCA_DCB_EVT mca_dcb_evt;
+      mca_dcb_evt.llcong = is_congested;
+      mca_dcb_event(p_dcb, MCA_DCB_TC_CONG_EVT, &mca_dcb_evt);
     }
   }
 }