mmain.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 "fldrmgr.h"    
#include "gmem.h"       
#include "mmsconf.h"    
#include "mmstypes.h"   
#include "aapimms.h"    
#include "msig.h"       
#include "mtimer.h"     
#include "mmain.h"      
#include "mcpdu.h"      
#include "mcreate.h"    
#include "mfetch.h"     
#include "mcopy.h"      
#include "mimport.h"    
#include "msend.h"      
#include "mreceive.h"   
#include "mnotify.h"    
#include "mcget.h"      
#include "mcnotif.h"    
#include "mcpost.h"     
#include "mmain.h"      
#include "mconfig.h"    
#include "mcwap.h"      
#include "mutils.h"     
#include "slcreate.h"   
#include "slparhlr.h"   


#define MMS_MAIN_SUBSTATE_INIT 0




typedef enum 
{
    MMS_MAIN_STATE_STARTING,        
    MMS_MAIN_STATE_STARTED,         
    MMS_MAIN_STATE_STOPPING,        
    MMS_MAIN_STATE_STOPPED          
} MmsMainState;



typedef struct
{
    MmsMainState state;             
    CMN_BOOL isFileFormatChanged;   
} CoreMainFsmInstanceData;















static CoreMainFsmInstanceData myFsm;


static void coreMain(MmsSignal *sig);
static void start(int subState);
static void terminate( int subState, int condition);






void coreMainInit(void)
{
    myFsm.state = MMS_MAIN_STATE_STOPPED;
    myFsm.isFileFormatChanged = FALSE;

    mSignalRegisterDst(M_FSM_CORE_MAIN, coreMain);
    
    MMS_LOG_I(("MMS FSM CORE MAIN: initialized\n"));
} 






static void coreMain(MmsSignal *sig)
{
    switch (sig->type)
    {
    case MMS_SIG_CORE_MAIN_START :
        MMS_LOG_I(("MMS FSM CORE MAIN: MMS_SIG_CORE_MAIN_START\n"));

        if (myFsm.state != MMS_MAIN_STATE_STOPPED)
        {
            MMSa_startResponse(MMS_RESULT_BUSY);
        }
        else
        {
            myFsm.state = MMS_MAIN_STATE_STARTING;
            M_SIGNAL_SENDTO_I( M_FSM_CORE_MAIN, MMS_SIG_CORE_MAIN_START_CONTINUE,
                MMS_MAIN_SUBSTATE_INIT);
        } 
        break;
    case MMS_SIG_CORE_MAIN_START_CONTINUE :
        start(sig->i_param);
        break;
    case MMS_SIG_CORE_MAIN_START_FINISHED :
        myFsm.state = MMS_MAIN_STATE_STARTED;
        MMSa_startResponse((MmsResult)sig->u_param1);
        break;
    case MMS_SIG_CORE_MAIN_STOP :
        MMS_LOG_I(("MMS FSM CORE MAIN: MMS_SIG_CORE_MAIN_STOP\n"));

        if (myFsm.state != MMS_MAIN_STATE_STARTED && 
            myFsm.state != MMS_MAIN_STATE_STARTING)
        {   
            MMSa_terminateResponse(MMS_RESULT_BUSY);
        }
        else
        {
            myFsm.state = MMS_MAIN_STATE_STOPPING;
            M_SIGNAL_SENDTO_IU( M_FSM_CORE_MAIN, MMS_SIG_CORE_MAIN_STOP_CONTINUE,
                sig->i_param, MMS_MAIN_SUBSTATE_INIT);
        } 
        break;
    case MMS_SIG_CORE_MAIN_STOP_CONTINUE :
        terminate( (int)sig->u_param1, sig->i_param);
        break;
    case MMS_SIG_CORE_MAIN_STOP_FINISHED :
        
        myFsm.state = MMS_MAIN_STATE_STOPPED;
        mTimerTerminate();      

        mSignalDelete(sig);     
        mSignalTerminate();     

       
#if defined USE_G_MALLOC
        gMemTerminate(CMN_CLIENT_MMS);
#endif 
        MMS_LOG_E(("MMSc_terminate is finished. Client is stopped.\n"));
        MMSa_terminateResponse(MMS_RESULT_OK);
        return; 
    default :
        MMS_LOG_I(("MMS FSM CORE MAIN: Unknown sig %d\n", sig->type));
        break;
    } 

    mSignalDelete(sig);
} 




void coreMainTerminate(void)
{
    mSignalDeregister(M_FSM_CORE_MAIN);
    
    myFsm.state = MMS_MAIN_STATE_STOPPED;
    MMS_LOG_I(("MMS FSM CORE MAIN: terminated\n"));
} 





static void start(int subState)
{
    FmResult fmResult;

    



    switch (subState)
    {
    case MMS_MAIN_SUBSTATE_INIT :
        fmResult = fldrmgrInit(CMN_CLIENT_MMS);
        if (fmResult == FM_RESULT_INDEX_FILE_CONVERTED)
        {
            myFsm.isFileFormatChanged = TRUE;
        }
        else if (fmResult != FM_RESULT_OK)
        {
            MMS_LOG_I(("fldrmgrInit failed.\n"));
            MMSa_error(MMS_RESULT_RESTART_NEEDED);
            return;
        }
        else
        {
            myFsm.isFileFormatChanged = FALSE;
        } 
        break;
    case 1 :
        cohWapInit();
        break;
    case 2 :
        mmhCreateInit();
        break;
    case 3 :
        mmhFetchInit();
        break;
    case 4 :
        mmhCopyInit();
        break;
    case 5 :
        mmhImportInit();
        break;
    case 6 :
        msrSendInit();
        break;
    case 7 :
        cohGetInit();
        break;
    case 8 :
        cohPushReceiveInit();
        break;
    case 9 :
        cohPostInit();
        break;
    case 10 :
        cfgInit();
        break;
    case 11 :
        slcInit(); 
        break;
    case 12 :
        slphInit();
        break;
    case 13 :
        


        if (myFsm.isFileFormatChanged)
        {
            M_SIGNAL_SENDTO( M_FSM_MMH_CREATE, MMS_SIG_MMH_FILE_FORMAT_CONVERTED);
        } 
        break;
    case 14 :
        

        msrReceiveInit();
        msrNotifyInit();
        break;
    default :
        M_SIGNAL_SENDTO_U( M_FSM_CORE_MAIN, MMS_SIG_CORE_MAIN_START_FINISHED,
            MMS_RESULT_OK);
        return; 
    } 

    M_SIGNAL_SENDTO_I( M_FSM_CORE_MAIN, MMS_SIG_CORE_MAIN_START_CONTINUE,
        (subState + 1));
} 







static void terminate( int subState, int condition)
{
    FmResult fmResult;

    



    switch (subState)
    {
    case MMS_MAIN_SUBSTATE_INIT :
        mmhCreateTerminate();
        break;
    case 1 :
        mmhFetchTerminate();
        break;
    case 2 :
        mmhImportTerminate();
        break;
    case 3 :
        mmhCopyTerminate();
        break;
    case 4 :
        msrSendTerminate();
        break;
    case 5 :
        msrReceiveTerminate();
        break;
    case 6 :
        msrNotifyTerminate((MmsShutdown)condition);
        break;
    case 7 :
        cohGetTerminate();
        break;
    case 8 :
        cohPushReceiveTerminate();
        break;
    case 9 :
        cohPostTerminate();
        break;
    case 10 :
        cfgTerminate();
        break;
    case 11 :
        slcTerminate(); 
        break;
    case 12 :
        slphTerminate();
        break;
    case 13 :
       
        fmResult = fldrmgrTerminate(CMN_CLIENT_MMS);
        if (fmResult != FM_RESULT_OK)   
        {
            MMS_LOG_I(("%s(%d): fldrmgrTerminate failed.\n", __FILE__, __LINE__,
                fmResult));

            MMSa_error( checkFolderError(fmResult));
        } 
        break;
    case 14 :
        cohWapTerminate();      
        break;
    default :
        M_SIGNAL_SENDTO_U( M_FSM_CORE_MAIN, MMS_SIG_CORE_MAIN_STOP_FINISHED,
            MMS_RESULT_OK);
        return; 
    } 

    M_SIGNAL_SENDTO_IU( M_FSM_CORE_MAIN, MMS_SIG_CORE_MAIN_STOP_CONTINUE,
        condition, subState + 1);
}