mcwap.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 "mmsconf.h"    
#include "mmstypes.h"   
#include "aapimms.h"    
#include "msig.h"       
#include "mtimer.h"     
#include "mmem.h"       
#include "mconfig.h"    
#include "mcwap.h"      


#define MMS_REQUEST_ID_MIN  0
#define MMS_REQUEST_ID_MAX  31
#define MMS_REQUEST_ID_NUMBER (MMS_REQUEST_ID_MAX - MMS_REQUEST_ID_MIN + 1)

#define MMS_OPERATION_QUEUE_LENGTH  10




typedef enum
{
    WAP_STARTING,   
    WAP_STARTED,    
    WAP_STOPPING,   
    WAP_STOPPED     
} CohWapFsmState;


typedef enum
{
    TIMER_CONNECTION,   
    TIMER_IDLE          
} TimerType;


typedef struct
{
    MmsStateMachine requestingFsm;  
    long            fsmInstance;    
    MmsSignalId     signal;         
} CohWapFsmData;



typedef struct
{
    








    char requestId[MMS_REQUEST_ID_NUMBER];
    UINT32 uniqueId;        
    UINT32 connections;     
    CohWapFsmState state;   

    
    CohWapFsmData operationQueue[MMS_OPERATION_QUEUE_LENGTH];
    int queueLen;           
} CohWapFsmInstanceData;















static CohWapFsmInstanceData myFsm;


static void cohWapMain(MmsSignal *sig);
static void handleStart( MmsStateMachine fsmId, long instance, MmsSignalId signal);
static void handleStartResponse(MmsResult result);
static void handleStop( MmsStateMachine fsmId, long instance, MmsSignalId signal);
static void handleStopResponse(MmsResult result);
static void handleTimerExpired(TimerType timerType);








static void cohWapMain(MmsSignal *sig)
{
    

    if (sig->type != MMS_SIG_COMMON_TIMER_EXPIRED)
    {
        M_TIMER_RESET_I( M_FSM_COH_WAP, TIMER_IDLE);
    } 

    switch (sig->type)
    {
    case MMS_SIG_COH_WAP_START :
        MMS_LOG_I(("MMS FSM COH WAP: Received MMS_SIG_COH_WAP_START\n"));
        handleStart( (MmsStateMachine)sig->u_param1, sig->i_param, 
            (MmsSignalId)sig->u_param2);
        break;
    case MMS_SIG_COH_WAP_START_RESPONSE :
        MMS_LOG_I(("MMS FSM COH WAP: Received MMS_SIG_COH_WAP_START_RESPONSE\n"));
        handleStartResponse((MmsResult)sig->u_param1);
        break;
    case MMS_SIG_COH_WAP_STOP :
        MMS_LOG_I(("MMS FSM COH WAP: Received MMS_SIG_COH_WAP_STOP\n"));
        handleStop( (MmsStateMachine)sig->u_param1, sig->i_param, 
            (MmsSignalId)sig->u_param2);
        break;
    case MMS_SIG_COH_WAP_STOP_RESPONSE :
        MMS_LOG_I(("MMS FSM COH WAP: Received MMS_SIG_COH_WAP_STOP_RESPONSE\n"));
        handleStopResponse((MmsResult)sig->u_param1);
        break;
    case MMS_SIG_COMMON_TIMER_EXPIRED :
        MMS_LOG_I(("%s(%d): Received TIMER_EXPIRED %d\n", 
            __FILE__, __LINE__, sig->i_param));
        handleTimerExpired((TimerType)sig->i_param);
        break;
    default:
        
        MMS_LOG_I(("%s(%d): received unknown signal %d\n", 
            __FILE__, __LINE__, sig->type));
        break;
    } 
    
    mSignalDelete(sig);
} 







static void handleStart( MmsStateMachine fsmId, long instance, MmsSignalId signal)
{
    
    switch (myFsm.state)
    {
    case WAP_STARTED :
        
        M_SIGNAL_SENDTO_IU( fsmId, signal, instance, MMS_RESULT_OK);

        ++myFsm.connections;
        break;
    case WAP_STOPPING :
        
        M_SIGNAL_SENDTO_IU( fsmId, signal, instance, MMS_RESULT_BUSY);
        break;
    case WAP_STOPPED :
        M_TIMER_SET_I( M_FSM_COH_WAP, MMS_CONNECT_TIMEOUT, TIMER_CONNECTION);
        MMSa_httpSessionStart();
        myFsm.state = WAP_STARTING;
        
    case WAP_STARTING :
        if (myFsm.queueLen >= MMS_OPERATION_QUEUE_LENGTH)
        {  
            M_SIGNAL_SENDTO_IU( fsmId, signal, instance, MMS_RESULT_BUSY);
            MMS_LOG_I(("%s(%d): too many consecutive calls %d\n", 
                __FILE__, __LINE__, myFsm.queueLen));
            return;
        } 

        myFsm.operationQueue[ myFsm.queueLen ].requestingFsm = fsmId;
        myFsm.operationQueue[ myFsm.queueLen ].fsmInstance = instance;
        myFsm.operationQueue[ myFsm.queueLen ].signal = signal;
        ++myFsm.queueLen;
        break;
    default :
        MMS_LOG_I(("%s(%d): unknown state %d\n", __FILE__, __LINE__, myFsm.state));
        break;
    } 
} 






static void handleStartResponse(MmsResult result)
{
    
    switch (myFsm.state)
    {
    case WAP_STARTING :
        M_TIMER_RESET_I( M_FSM_COH_WAP, TIMER_CONNECTION); 
        if (result == MMS_RESULT_OK)
        {
            myFsm.state = WAP_STARTED;
            myFsm.connections = (UINT32)myFsm.queueLen;
        }
        else
        {
            myFsm.state = WAP_STOPPED;
        } 

        while (myFsm.queueLen > 0)
        {   
            --myFsm.queueLen;
            M_SIGNAL_SENDTO_IU( myFsm.operationQueue[ myFsm.queueLen ].requestingFsm, 
                myFsm.operationQueue[ myFsm.queueLen ].signal, 
                myFsm.operationQueue[ myFsm.queueLen ].fsmInstance, result);
        } 
        break;
    case WAP_STARTED :
    case WAP_STOPPING :
    case WAP_STOPPED :
        MMS_LOG_I(("%s(%d): received START_RESPONSE in wrong state %d\n", 
            __FILE__, __LINE__, myFsm.state));
        break;
    default :
        MMS_LOG_I(("%s(%d): unknown state %d\n", __FILE__, __LINE__, myFsm.state));
        break;
    } 
} 








static void handleStop( MmsStateMachine fsmId, long instance, MmsSignalId signal)
{
    
    switch (myFsm.state)
    {
    case WAP_STARTING :
        
        M_SIGNAL_SENDTO_IU( fsmId, signal, instance, MMS_RESULT_BUSY);
        break;
    case WAP_STARTED :
        
        if (myFsm.connections > 0)
        {
            --myFsm.connections;
            mmsWapConnectionCheck();
        } 

        


        M_SIGNAL_SENDTO_IU( fsmId, signal, instance, MMS_RESULT_OK);
        break;
    case WAP_STOPPING :
        M_SIGNAL_SENDTO_IU( fsmId, signal, instance, MMS_RESULT_OK);
        break;
    case WAP_STOPPED :
        
        M_SIGNAL_SENDTO_IU( fsmId, signal, instance, MMS_RESULT_OK);
        break;
    default :
        MMS_LOG_I(("%s(%d): unknown state %d\n", __FILE__, __LINE__, myFsm.state));
        break;
    } 
} 






static void handleStopResponse(MmsResult result)
{
    switch (myFsm.state)
    {
    case WAP_STARTING :
    case WAP_STARTED :
    case WAP_STOPPED :
        MMS_LOG_I(("%s(%d): received STOP_RESPONSE in wrong state %d. Result=%d\n", 
            __FILE__, __LINE__, myFsm.state, result));
        break;
    case WAP_STOPPING :
        
        myFsm.connections = 0;
        myFsm.state = WAP_STOPPED;
        break;
    default :
        MMS_LOG_I(("%s(%d): unknown state %d\n", __FILE__, __LINE__, myFsm.state));
        break;
    } 
} 





static void handleTimerExpired(TimerType timerType)
{
    switch (myFsm.state)
    {
    case WAP_STARTING :
        myFsm.state = WAP_STOPPED;

        while (myFsm.queueLen > 0)
        {   
            --myFsm.queueLen;
            M_SIGNAL_SENDTO_IU( myFsm.operationQueue[ myFsm.queueLen ].requestingFsm, 
                myFsm.operationQueue[ myFsm.queueLen ].signal, 
                myFsm.operationQueue[ myFsm.queueLen ].fsmInstance, 
                MMS_RESULT_COMM_TIMEOUT);
        } 

        myFsm.connections = 0;
        break;
    case WAP_STARTED : 
        if (timerType == TIMER_IDLE && myFsm.connections == 0)
        {
            MMS_LOG_I(("%s(%d): IDLE! Disconnecting.\n", __FILE__, __LINE__));

            myFsm.state = WAP_STOPPING;
            MMSa_httpSessionStop();
        } 
        break;
    case WAP_STOPPING :
    case WAP_STOPPED :
         
        MMS_LOG_I(("%s(%d): received TIMER_EXPIRED when not expecting it %d %d.\n", 
            __FILE__, __LINE__, myFsm.state, timerType));
        break;
    default :
        MMS_LOG_I(("%s(%d): unknown state %d\n", __FILE__, __LINE__, myFsm.state));
        break;
    } 
} 





void mmsWapCancelHttpOperation(MmsRequestId reqId)
{
    if (myFsm.state == WAP_STARTED)
    {
        MMSa_httpCancel(reqId);
    } 
}