msend.c

彩信MMS的全部代码

/*
 * Copyright (C) Obigo AB, 2002-2005.
 * All rights reserved.
 *
 * This software is covered by the license agreement between
 * the end user and Obigo AB, and may be 
 * used and copied only in accordance with the terms of the 
 * said agreement.
 *
 * Obigo AB assumes no responsibility or 
 * liability for any errors or inaccuracies in this software, 
 * or any consequential, incidental or indirect damage arising
 * out of the use of the software.
 *
 */

















#include "cansilib.h"   
#include "cmnconf.h"    
#include "aapifile.h"   
#include "aapicmn.h"    
#include "gmem.h"       
#include "fldrmgr.h"    

#include "mmstypes.h"   
#include "mmsconf.h"    
#include "aapimms.h"    
#include "msig.h"       
#include "mmem.h"       
#include "mutils.h"     
#include "mcpdu.h"      
#include "msend.h"      
#include "mcpost.h"     
#include "mfetch.h"     
#include "mcreate.h"    





typedef enum
{
    MSR_STATE_IDLE,             
    MSR_STATE_CREATING_RR,      
    MSR_STATE_SENDING_MSG,      
    MSR_STATE_SENDING_FWD,      
    MSR_STATE_SENDING_RR_1_0,   
    MSR_STATE_SENDING_RR_1_1    
} MsrSendFsmState;


typedef struct
{
    MsrSendFsmState state;
    CMN_BOOL isCancelled;       
    MmsMsgId msgIdToSend;        
    MmsMsgId originId;          


} MsrSendInstanceData;















static MsrSendInstanceData fsm;


static CMN_BOOL briefForwardCheck(const MmsForward *forwardHeader);
static CMN_BOOL briefHeaderCheck(MmsMessagePart *mHeader);
static void fsmReset(void);
static void moveMsgToFolder(UINT32 filedId, UINT16 folderType);
#if !MMS_SAVE_1_0_READ_REPORT
static void deleteOneMsg(UINT32 fileId);
#endif
static void msrSendMain(MmsSignal *sig);
static void responseToCaller( MmsResult result, MmsMsgId msgId, 
    MmsResponseStatus status, MmsEncodedText *text);
static void sendCancel(MmsMsgId msgId);
static void sendOneMsg(UINT32 msgId, unsigned char *buffer, UINT32 len, 
    MmsMessageType type);






void fsmReset(void)
{
    fsm.msgIdToSend = 0;
    fsm.originId = 0;
    fsm.isCancelled = FALSE;
    fsm.state = MSR_STATE_IDLE;
} 




void msrSendInit(void)
{
    mSignalRegisterDst(M_FSM_MSR_SEND, msrSendMain);
    memset( &fsm, 0, sizeof(fsm));
    
    
    fsmReset();
    MMS_LOG_I(("MMS FSM MSR SEND: initialized\n"));
} 




void msrSendTerminate(void)
{
    mSignalDeregister(M_FSM_MSR_SEND);
    
    
    fsmReset();
    MMS_LOG_I(("MMS FSM MSR SEND: terminated\n"));
} 






static void msrSendMain(MmsSignal *sig)
{
    MmsResult result;
    MmsSigCohPostResultParam *postParam;
    MmsReadReportInfo *readReportInfo = NULL;

    switch (sig->type)
    {
    case MMS_SIG_MSR_SEND_CANCEL : 
        
        MMS_LOG_I(("MMS FSM MSR SEND: MMS_SIG_MSR_SEND_CANCEL\n"));
        sendCancel((MmsMsgId)sig->u_param1);
        break;

    case MMS_SIG_MSR_SEND_MSG : 
        
        MMS_LOG_I(("MMS FSM MSR SEND: MMS_SIG_MSR_SEND_MSG\n"));
        
        
        if (fsm.state != MSR_STATE_IDLE) 
        {
            MMSa_sendMessageResponse( MMS_RESULT_BUSY, MMS_RSP_STATUS_NONE, NULL);
        }
        else if ((MmsMsgId)sig->u_param1 == 0) 
        {
            MMSa_sendMessageResponse( MMS_RESULT_MESSAGE_ID_NOT_FOUND,
                MMS_RSP_STATUS_NONE, NULL);
        }
        else
        {    
            fsm.state = MSR_STATE_SENDING_MSG;                    
            fsm.msgIdToSend = (MmsMsgId)sig->u_param1;

            
            M_SIGNAL_SENDTO_IUU(M_FSM_MMH_FETCH, MMS_SIG_MMH_GET_HEADER_TO_SM,
                M_FSM_MSR_SEND, fsm.msgIdToSend, MMS_SIG_MSR_GET_HEADER_RSP);
        }  
        break;

    case MMS_SIG_MSR_GET_HEADER_RSP:    
        MMS_LOG_I(("MMS FSM MSR SEND received: MMS_SIG_MSR_GET_HEADER_RSP\n"));
        result = (MmsResult)sig->i_param;
        if (fsm.isCancelled)
        {
             
            if (result == MMS_RESULT_OK)
            {
                MmsMessagePart *mHeader = (MmsMessagePart*)sig->p_param;
                freeMmsHeader(&mHeader->header);
                M_FREE(mHeader);
            } 

            result = MMS_RESULT_CANCELLED_BY_USER;
        }
        else if (result == MMS_RESULT_OK) 
        {
             
            if (briefHeaderCheck((MmsMessagePart*)sig->p_param) != TRUE)
            {   
                result = MMS_RESULT_RECIPIENT_ADDRESS_NOT_SET;
            } 
        } 

        if (result == MMS_RESULT_OK)
        {   
            moveMsgToFolder( fsm.msgIdToSend, MMS_OUTBOX);
            sendOneMsg( fsm.msgIdToSend, NULL, 0, MMS_M_SEND_REQ);
        }
        else
        {
            responseToCaller( result, fsm.msgIdToSend, MMS_RSP_STATUS_NONE, NULL);
            fsmReset();
        } 
        break;

    case MMS_SIG_MSR_SEND_RR_RSP :
        
        MMS_LOG_I(("MMS FSM MSR SEND received: MMS_SIG_MSR_SEND_RR_RSP\n"));
        postParam = (MmsSigCohPostResultParam *)sig->p_param;
        MMSa_sendReadReportResponse( postParam->result, 0);
        cohPostFreeResultParam(postParam);
        fsmReset();
        break;

    case MMS_SIG_MSR_SEND_RSP:          
        
        MMS_LOG_I(("MMS FSM MSR SEND received: MMS_SIG_MSR_SEND_RSP\n"));

        postParam = (MmsSigCohPostResultParam *)sig->p_param;
        
        
        if (postParam->result == MMS_RESULT_OK) 
        {
#if MMS_SAVE_1_0_READ_REPORT
             
            moveMsgToFolder( fsm.msgIdToSend, MMS_SENT);
#else
            
            if (fsm.state == MSR_STATE_SENDING_RR_1_0)
            {
                
                deleteOneMsg(fsm.msgIdToSend);
            }
            else
            {
                 
                moveMsgToFolder( fsm.msgIdToSend, MMS_SENT);
            }
#endif
        } 

        responseToCaller( postParam->result, fsm.msgIdToSend, 
            postParam->responseStatus, postParam->responseText);

#ifndef MMS_RETAIN_ADAPTER_PARAMETERS
        cohPostFreeResultParam(postParam);
#else
        
        M_FREE(postParam);
#endif 
        fsmReset();
        break; 

    case MMS_SIG_MSR_CREATE_RR : 
        
        MMS_LOG_I(("MMS FSM MSR CREATE received: MMS_SIG_MSR_CREATE_RR\n"));

        
        if (fsm.state != MSR_STATE_IDLE) 
        {
            MMSa_sendReadReportResponse( MMS_RESULT_BUSY, 0);
        }
        else if ((MmsMsgId)sig->u_param1 == 0)  
        {
            MMSa_sendReadReportResponse( MMS_RESULT_MESSAGE_ID_NOT_FOUND, 0);
        }
        else
        {
            fsm.state = MSR_STATE_CREATING_RR;
            fsm.originId = (MmsMsgId)sig->u_param1;
            
            readReportInfo = (MmsReadReportInfo *)M_CALLOC(sizeof(MmsReadReportInfo)); 
            readReportInfo->msgId = fsm.originId;
            readReportInfo->readStatus = (MmsReadStatus)sig->i_param;

            
            M_SIGNAL_SENDTO_IUUP(M_FSM_MMH_CREATE, MMS_SIG_MMH_CREATE_RR,
                M_FSM_MSR_SEND, MMS_SIG_MSR_CREATE_RR_RSP, MMS_SIG_MSR_SEND_PDU, 
                readReportInfo);
        } 
        break; 

    case MMS_SIG_MSR_CREATE_RR_RSP:  
        if (fsm.isCancelled)
        {
            if ((MmsResult)sig->i_param == MMS_RESULT_OK)
            {
                fsm.msgIdToSend = (MmsMsgId)sig->u_param1;
                MMSa_sendReadReportResponse( MMS_RESULT_CANCELLED_BY_USER, 
                    fsm.msgIdToSend);
            }
            else
            {
                MMSa_sendReadReportResponse( MMS_RESULT_CANCELLED_BY_USER, 0);
            } 

            fsmReset();
        }
        else if ((MmsResult)sig->i_param == MMS_RESULT_OK)
        {
            
            fsm.state = MSR_STATE_SENDING_RR_1_0;
            fsm.msgIdToSend = (MmsMsgId)sig->u_param1;

            
            M_SIGNAL_SENDTO_IUU( M_FSM_MMH_FETCH, MMS_SIG_MMH_GET_HEADER_TO_SM,
                M_FSM_MSR_SEND, fsm.msgIdToSend, MMS_SIG_MSR_GET_HEADER_RSP);
        }
        else 
        {  
            MMSa_sendReadReportResponse( (MmsResult)sig->i_param, 0); 
            fsmReset();
        } 
        break;

    case MMS_SIG_MSR_CREATE_FORWARD : 
        
        MMS_LOG_I(("MMS FSM MSR SEND received: MMS_SIG_MSR_SEND_FORWARD\n"));

        
        if (fsm.state != MSR_STATE_IDLE) 
        {