msend.c

彩信MMS的全部代码

            MMSa_forwardReqResponse( MMS_RESULT_BUSY, 0, MMS_RSP_STATUS_NONE, NULL);
        }
        else if (sig->p_param == NULL) 
        {
            MMSa_forwardReqResponse( MMS_RESULT_ERROR_CREATING_FORWARD, 0,
                MMS_RSP_STATUS_NONE, NULL);
        } 
        else 
        {
            fsm.state = MSR_STATE_SENDING_FWD;
            fsm.originId = (MmsMsgId)sig->u_param1;
            if (briefForwardCheck((MmsForward *)sig->p_param))
            {
                
                M_SIGNAL_SENDTO_IUUP( M_FSM_MMH_CREATE, MMS_SIG_MMH_CREATE_FORWARD,
                    M_FSM_MSR_SEND, MMS_SIG_MSR_SEND_PDU, fsm.originId, 
                    sig->p_param);
            }
            else
            {
                freeMmsForward((MmsForward *)sig->p_param);
                fsmReset();
                MMSa_forwardReqResponse( MMS_RESULT_ERROR_CREATING_FORWARD, 
                    fsm.originId, MMS_RSP_STATUS_NONE, NULL);
            } 
        } 
        break;
    case MMS_SIG_MSR_SEND_PDU:
        if (fsm.isCancelled)
        {
            if (sig->p_param != NULL)
            {
                M_FREE(sig->p_param);
            } 

            responseToCaller( MMS_RESULT_CANCELLED_BY_USER, fsm.originId, 
                MMS_RSP_STATUS_NONE, NULL);
            fsmReset();
        }
        else if (sig->i_param == MMS_RESULT_OK && sig->p_param != NULL)
        {
           
            if (fsm.state == MSR_STATE_CREATING_RR)
            {
                fsm.state = MSR_STATE_SENDING_RR_1_1;
                sendOneMsg( 0, sig->p_param, sig->u_param1, 
                    (MmsMessageType)sig->u_param2);
            }
            else
            {
                fsm.state = MSR_STATE_SENDING_FWD;
                sendOneMsg( fsm.originId, sig->p_param, sig->u_param1, 
                    (MmsMessageType)sig->u_param2);
            } 
        }
        else 
        { 
             
            if (sig->p_param != NULL)
            {
                M_FREE(sig->p_param);
            } 

            responseToCaller( (MmsResult)sig->i_param, fsm.originId, 
                MMS_RSP_STATUS_NONE, NULL); 
            fsmReset();
        } 
        break; 
    case MMS_SIG_MSR_SEND_FORWARD_RSP:
        postParam = (MmsSigCohPostResultParam *)sig->p_param;
        if (postParam->result == MMS_RESULT_OK)
        {
            
 
            moveMsgToFolder( fsm.originId, MMS_SENT);

            








        } 

        MMSa_forwardReqResponse( postParam->result, fsm.originId,
            postParam->responseStatus, postParam->responseText);

#ifndef MMS_RETAIN_ADAPTER_PARAMETERS
        cohPostFreeResultParam(postParam);
#else
        
        M_FREE(postParam);
#endif 
        fsmReset();
        break;
    default:
        
        MMS_LOG_I(("MMS FSM MSR MSR SEND: received unknown signal %d\n",
            sig->type));
        break;
    } 
    
    mSignalDelete(sig);
} 






static void sendCancel(MmsMsgId msgId)
{
    

    switch (fsm.state)
    {
    case MSR_STATE_IDLE :
        break;
    case MSR_STATE_SENDING_MSG :
        if (fsm.msgIdToSend == msgId)
        {
            cohPostCancel(fsm.msgIdToSend);
            fsm.isCancelled = TRUE;
        } 
        break;
    case MSR_STATE_SENDING_RR_1_0 :
        if (fsm.originId == msgId)
        {
            cohPostCancel(fsm.msgIdToSend);
            fsm.isCancelled = TRUE;
        } 
        break;
    case MSR_STATE_SENDING_RR_1_1 :
    case MSR_STATE_SENDING_FWD :
        if (fsm.originId == msgId)
        {
            
            fsm.isCancelled = TRUE;
        } 
        break;
    case MSR_STATE_CREATING_RR :
        fsm.isCancelled = TRUE;
        break;
    default :
        MMS_LOG_I(("%s(%d): Wrong state %d\n", __FILE__, __LINE__, fsm.state));
        break;
    } 
} 








static void sendOneMsg(UINT32 msgId, unsigned char *buffer, UINT32 len, 
    MmsMessageType type)
{
    MmsSigCohPostParam *post = NULL;
    MmsMsrSendSignalId  retSignal;

    post = M_ALLOCTYPE(MmsSigCohPostParam);
    post->isResponseRequested = TRUE;
    post->type = type;
    switch (fsm.state)
    {
    case MSR_STATE_SENDING_MSG : 
        post->data.msgId = msgId;
        post->origMsg = msgId;
        retSignal = MMS_SIG_MSR_SEND_RSP;
        break;
    case MSR_STATE_SENDING_FWD : 
        post->data.pdu.packet = buffer;
        post->data.pdu.length = len; 
        post->origMsg = msgId;  
        retSignal = MMS_SIG_MSR_SEND_FORWARD_RSP;
        break;
    case MSR_STATE_SENDING_RR_1_0 : 
        post->data.msgId = msgId;
        post->origMsg = 0;
        retSignal = MMS_SIG_MSR_SEND_RSP;
        break;
    case MSR_STATE_SENDING_RR_1_1 : 
        post->data.pdu.packet = buffer;
        post->data.pdu.length = len; 
        post->origMsg = 0;
        retSignal = MMS_SIG_MSR_SEND_RR_RSP;
        break;
    default :
        MMS_LOG_I(("%s(%d): Wrong state %d\n", __FILE__, __LINE__, fsm.state));
        return;
    } 

    
    M_SIGNAL_SENDTO_IUUP( 
        M_FSM_COH_POST,     
        MMS_SIG_COH_POST,   
        0,                  
        M_FSM_MSR_SEND,     
        retSignal,          
        post);              
} 







static void moveMsgToFolder(UINT32 filedId, UINT16 folderType)
{
    FmResult fmResult;

    
    fmResult = fldrmgrMoveMsg( CMN_CLIENT_MMS, filedId, folderType);
    if (checkFolderError(fmResult) != MMS_RESULT_OK)
    {
        MMS_LOG_I(("MMS FSM MSR SEND internal parameter fault\n"));
    } 
} 






#if !MMS_SAVE_1_0_READ_REPORT
static void deleteOneMsg(UINT32 fileId)
{
    FmResult fmResult;

    
    fmResult = fldrmgrDeleteMsg( CMN_CLIENT_MMS, fileId, TRUE);
    if (checkFolderError(fmResult) != MMS_RESULT_OK)
    {
        MMS_LOG_I(("MMS FSM MSR SEND internal parameter fault\n"));
    } 
} 
#endif










static CMN_BOOL briefHeaderCheck(MmsMessagePart *mHeader)
{
    CMN_BOOL ret = FALSE;
    
    
    
    

 
    if (((mHeader->header.to  != NULL) ||
        ( mHeader->header.bcc != NULL) ||
        ( mHeader->header.cc  != NULL)) &&
        ( mHeader->header.contentType != NULL))
    {
       ret = TRUE;   
    } 

    
    freeMmsHeader(&mHeader->header);
    M_FREE(mHeader);
     
    return ret;   
} 










static CMN_BOOL briefForwardCheck(const MmsForward *forwardHeader)
{
    CMN_BOOL ret = FALSE;

    if (forwardHeader != NULL) 
    {
        

 
        if (((forwardHeader->to  != NULL) ||
            ( forwardHeader->bcc != NULL) ||
            ( forwardHeader->cc  != NULL)))
        {
           ret = TRUE;   
        } 
    } 
    else
    {
        
        ret = FALSE;
    } 
    return ret;
} 









static void responseToCaller( MmsResult result, MmsMsgId msgId, 
    MmsResponseStatus status, MmsEncodedText *text)
{
    if (fsm.state == MSR_STATE_SENDING_RR_1_0 || 
        fsm.state == MSR_STATE_SENDING_RR_1_1 ||
        fsm.state == MSR_STATE_CREATING_RR)
    {          
        MMSa_sendReadReportResponse( result, msgId);
    }
    else if (fsm.state == MSR_STATE_SENDING_MSG)
    {
        MMSa_sendMessageResponse( result, status, text);
    }
    else if (fsm.state == MSR_STATE_SENDING_FWD)
    {
        MMSa_forwardReqResponse( result, msgId, status, text);
    }
    else
    {
        MMS_LOG_I(("%s(%d): Illegal state %d for response.\n",
            __FILE__, __LINE__, (int)fsm.state));
    } 
}