C++ MessageSend函数代码示例

/****************************************************************************
NAME    
    audioIndicateCodec
    
DESCRIPTION
    Sends an event to indicate which A2DP codec is in use

RETURNS
    void
*/
void audioIndicateCodec(uint8 seid)
{
    switch(seid)
    {
        case SBC_SEID:
            MessageSend ( &theSink.task , EventSbcCodec , 0 ) ;
            break;
        case MP3_SEID:
            MessageSend ( &theSink.task , EventMp3Codec , 0 ) ;
            break;        
        case AAC_SEID:
            MessageSend ( &theSink.task , EventAacCodec , 0 ) ;
            break;  
        case APTX_SEID:
            MessageSend ( &theSink.task , EventAptxCodec , 0 ) ;
            break;  
#ifdef INCLUDE_FASTSTREAM            
        case FASTSTREAM_SEID:
            MessageSend ( &theSink.task , EventFaststreamCodec , 0 ) ;
            break;  
#endif
#ifdef INCLUDE_APTX_ACL_SPRINT            
        case APTX_SPRINT_SEID:
            MessageSend ( &theSink.task , EventAptxLLCodec , 0 ) ;
            break;              
#endif            
        default:
           AUD_DEBUG(("AUD: Unknown codec\n"));                 
    }
}

/****************************************************************************
NAME
    connectionSmInit

DESCRIPTION
    This Function is called to initialise SM. The config option is not 
    currently used but may be in future.

RETURNS
    Nothing.
*/
void connectionSmInit(cl_dm_bt_version version, connectionSmState *smState, uint8 flags)
{
    MAKE_CL_MESSAGE(CL_INTERNAL_SM_INIT_REQ);

    message->options            =  DM_SM_INIT_SECURITY_MODE | 
                                   DM_SM_INIT_MODE3_ENC;
    
    message->config             =  0;
    
    if(version >= bluetooth4_1 && (flags & CONNECTION_FLAG_SC_ENABLE))
    {
        message->options        |= DM_SM_INIT_SECURE_CONNECTIONS;

        if(flags & CONNECTION_FLAG_SCOM_ENABLE)
        {
            message->config         |=  DM_SM_SEC_MODE_CONFIG_SC_ONLY_MODE;
            message->options        |=  DM_SM_INIT_CONFIG;
        }
    }

    message->write_auth_enable  =  cl_sm_wae_acl_owner_none;

    if(version >= bluetooth2_1)
    {
        message->options            |=  DM_SM_INIT_WRITE_AUTH_ENABLE;

        message->security_mode      =   sec_mode4_ssp;
        message->mode3_enc          =   hci_enc_mode_pt_to_pt_and_bcast;

    }
    else if (version == bluetooth2_0)
    {
        /* As per the documentation for DM_SM_INIT_REQ_T in dm_prim.h
         * write auth enable applies to security mode 2.
         * mode3 encryption doesn't apply in this mode.
         * No clue why mode 3 encryption is enabled.
         */
        message->options            |=  DM_SM_INIT_WRITE_AUTH_ENABLE;
        message->security_mode      =   sec_mode2_service;
        message->mode3_enc          =   hci_enc_mode_pt_to_pt;
    }    
    else
    {
        message->security_mode      =   sec_mode2_service;
        message->mode3_enc          =   hci_enc_mode_pt_to_pt;
    }

    smState->security_mode = message->security_mode;
    smState->enc_mode = message->mode3_enc;
    
    MessageSend(connectionGetCmTask(), CL_INTERNAL_SM_INIT_REQ, message);
}

/****************************************************************************
*NAME 
*   AvrcpBrowseGetFolderItemsResponse
*
*DESCRIPTION
*   This function is used to send response for  GetFolderItems command to CT.
*   This will be called in response to a AVRCP_BROWSE_GET_FOLDER_ITEMS_IND
*   message.
*
*PARAMETRS
*   avrcp              - Task
*   avrcp_response_type- response. avrcp_response_browsing_success on Success.
*   uint16             - UID Counter. 0 for non database aware players
*   uint16             - number of items returned
*   uint16             - size of the item list in bytes
*   Source             - item list
*****************************************************************************/
void AvrcpBrowseGetFolderItemsResponse( AVRCP*              avrcp,         
                                        avrcp_response_type response,     
                                        uint16              uid_counter, 
                                        uint16              num_items,  
                                        uint16              item_list_size,
                                        Source              item_list)
{
    AVBP *avbp = (AVBP*)avrcp->avbp_task;

    if((SourceBoundary(item_list) < item_list_size) ||
       (!num_items && item_list_size) || 
       (item_list_size > (avbp->avbp_mtu - AVBP_MAX_FIXED_PDU_SIZE)))
    {
        AVRCP_DEBUG(("Wrong parameters\n"));
        if(item_list)
        {
            SourceEmpty(item_list);
        }
        return; 
    }
     
    if((isAvbpCheckConnected(avbp)) && 
      (avbp->blocking_cmd == AVBP_GET_FOLDER_ITEMS_PDU_ID))
    {
        MAKE_AVRCP_MESSAGE(AVRCP_INTERNAL_GET_FOLDER_ITEMS_RES);
        message->response = response;
        message->num_items = num_items;
        message->item_list_size = item_list_size;
        message->item_list = item_list;
        if(isAvrcpDatabaseEnabled(avrcpGetDeviceTask()))
        {
           message->uid_counter = uid_counter;
        }
        else
        {
           message->uid_counter = 0;
        }

        /* Queue the Response */
        MessageSend(&avbp->task,
                    AVRCP_INTERNAL_GET_FOLDER_ITEMS_RES,
                    message);
    }
    else
    {
        AVRCP_INFO(("Wrong State. Ignoring the response\n"));
        if(item_list)
        {
            SourceEmpty(item_list);
        }
    }
}

void ML::MsgLoopReqSend(PS_MlRequestType pLoop_Type)
{
    S_MaintenanceLoopRequest   maintenanceLoopRequest ;
    S_H245Msg                  h245Msg ;

    oscl_memcpy((int8*)&maintenanceLoopRequest.mlRequestType, (int8*)pLoop_Type, sizeof(S_MlRequestType)) ;

    h245Msg.Type1 = H245_MSG_REQ ;
    h245Msg.Type2 = MSGTYP_ML_REQ ;
    h245Msg.pData = (uint8*) & maintenanceLoopRequest ;

    MessageSend(&h245Msg) ;
}

void avrcpSendGetCapsResponse(AVRCP *avrcp, 
                            avrcp_response_type response, 
                            avrcp_capability_id caps, 
                            uint16 size_caps_list, 
                            Source caps_list)
{
    MAKE_AVRCP_MESSAGE(AVRCP_INTERNAL_GET_CAPS_RES);
    message->caps_id = caps;        
    message->response = response;        
    message->size_caps_list = size_caps_list;
    message->caps_list = caps_list;
    MessageSend(&avrcp->task, AVRCP_INTERNAL_GET_CAPS_RES, message);
}

/* Send the indicator list to the app so it can parse it for any non-HFP indicators it is interested in */
static void hfpSendUnhandledIndicatorListToApp(hfp_link_data* link, uint16 register_index, uint16 cind_index, uint16 min_range, uint16 max_range)
{
    MAKE_HFP_MESSAGE(HFP_EXTRA_INDICATOR_INDEX_IND);
    message->priority = hfpGetLinkPriority(link);
    message->indicator_register_index = register_index;
    message->indicator_index = cind_index;
    message->min_range = min_range;
    message->max_range = max_range;
    MessageSend(theHfp->clientTask, HFP_EXTRA_INDICATOR_INDEX_IND, message);
    
    /* Store the extra indicator index internally */
    hfpStoreUnhandledIndicator(link, cind_index);
}

void a2dpSendInitCfmToClient(a2dp_status_code status)
{
    MAKE_A2DP_MESSAGE(A2DP_INIT_CFM);
    message->status = status;
    MessageSend(a2dp->clientTask, A2DP_INIT_CFM, message);

    /* If the initialisation failed, free the allocated task */
    if (status != a2dp_success)
    {
        free(a2dp);
        a2dp = 0;
    }
}

/****************************************************************************
NAME    
    batteryNormal
    
DESCRIPTION
    Called when the battery voltage is detected to be in a Normal state
*/
static void powerManagerHandleVbatNormal(uint8 level)
{
#ifndef NO_LED     
    bool low_batt = powerManagerIsVbatLow();
#endif    
    PM_DEBUG(("PM: Battery Normal %d\n", level));
    MessageSend(&theSink.task, EventSysBatteryOk, 0);
    
    /* If charger connected send a charger gas gauge message (these don't have any functional use but can be associated with LEDs/tones) */
    if (powerManagerIsChargerConnected())
        MessageSend(&theSink.task, (EventSysChargerGasGauge0+level), 0);
    
    /* reset any low battery warning that may be in place */
    theSink.battery_state = POWER_BATT_LEVEL0 + level;
    csr2csrHandleAgBatteryRequestRes(level);
#ifndef NO_LED 
    /* when changing from low battery state to a normal state, refresh the led state pattern
       to replace the low battery pattern should it have been shown */
    if(low_batt) LEDManagerIndicateState(stateManagerGetState());
#endif    
    AudioSetPower(powerManagerGetLBIPM());
}

void ConnectionAuthGetPriorityDeviceStatusTestExtra(
        Task theAppTask,
        const bdaddr* bd_addr, 
        bool *is_priority_device
        )
{
    CL_AUTH_GET_PRIORITY_DEVICE_STATUS_IND_TEST_EXTRA_T *new_msg = 
                    PanicUnlessMalloc(sizeof(CL_AUTH_GET_PRIORITY_DEVICE_STATUS_IND_TEST_EXTRA_T));

    new_msg->result = ConnectionAuthGetPriorityDeviceStatus(bd_addr, &(new_msg->is_priority_device));

    MessageSend(theAppTask, CL_AUTH_GET_PRIORITY_DEVICE_STATUS_IND_TEST_EXTRA, new_msg);
}

/* 
 *  B-134381
 */
void ConnectionAuthSetPriorityDeviceTestExtra(
        Task theAppTask,
        const bdaddr *bd_addr,
        bool is_priority_device
        )
{
    CL_AUTH_SET_PRIORITY_DEVICE_IND_TEST_EXTRA_T *new_msg = 
                    PanicUnlessMalloc(sizeof(CL_AUTH_SET_PRIORITY_DEVICE_IND_TEST_EXTRA_T));

    new_msg->result = ConnectionAuthSetPriorityDevice(bd_addr, is_priority_device);

    MessageSend(theAppTask, CL_AUTH_SET_PRIORITY_DEVICE_IND_TEST_EXTRA, new_msg);
}

void ConnectionRfcommPortNegResponse(Task appTask, Sink sink, port_par* port_params)
{
    MAKE_CL_MESSAGE(CL_INTERNAL_RFCOMM_PORTNEG_RSP);
    message->theAppTask = appTask;
    message->sink = sink;

    if (port_params)
        message->port_params = *port_params;
    else
        initPortParams(&(message->port_params));

    MessageSend(connectionGetCmTask(), CL_INTERNAL_RFCOMM_PORTNEG_RSP, message);
}

void ML::MsgLoopOffSend(void)
{
    S_MaintenanceLoopOffCommand    maintenanceLoopOffCommand ;
    S_H245Msg                      h245Msg ;

    oscl_memset(&maintenanceLoopOffCommand, 0, sizeof(S_MaintenanceLoopOffCommand)) ;

    h245Msg.Type1 = H245_MSG_CMD ;
    h245Msg.Type2 = MSGTYP_ML_OFF_CMD ;
    h245Msg.pData = (uint8*) & maintenanceLoopOffCommand ;

    MessageSend(&h245Msg) ;
}

void ConnectionRfcommConnectResponse(Task theAppTask, bool response, const Sink sink, uint8 local_server_channel, const rfcomm_config_params *config)
{
    /* Send an internal message */
    MAKE_CL_MESSAGE(CL_INTERNAL_RFCOMM_CONNECT_RES);
    message->theAppTask = theAppTask;
    message->response = response;
    message->sink = sink;
    message->server_channel = local_server_channel;
    
    initConfigParams(config, &message->config);
    
    MessageSend(connectionGetCmTask(), CL_INTERNAL_RFCOMM_CONNECT_RES, message);
}

static void sendSppStartServiceCfm(spp_start_status status)
{
    if (sppsClientTask)
    {
        MAKE_SPP_MESSAGE(SPP_START_SERVICE_CFM);
        message->status = status;
        MessageSend(sppsClientTask, SPP_START_SERVICE_CFM, message);
    }
#if SPP_DEBUG_LIB
    else
        SPP_DEBUG(("sppsClientTask is NULL!\n"));
#endif
}

static void sendSppStopServiceCfm(Task theClientTask, spp_stop_status status)
{
    if (theClientTask)
    {
        MAKE_SPP_MESSAGE(SPP_STOP_SERVICE_CFM);
        message->status = status;
        MessageSend(theClientTask, SPP_STOP_SERVICE_CFM, message);
    }
#if SPP_DEBUG_LIB
    else
        SPP_DEBUG(("theClientTask is NULL!\n"));
#endif
}