mimport.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 "mfetch.h"     
#include "mutils.h"     
#include "mcopy.h"      
#include "mimport.h"    


#define MMS_IMPORTS_PER_ITERATION   1
#define CATEGORY_INDEX_FILE         0




typedef struct
{
    CMN_BOOL isBusy;    
} MmhImportInstanceData;


typedef struct
{
    MmsFolderType toFolder; 
    MmsMsgId to;            
    UINT32 from;            
    UINT32 numberImported;  
} MmhImportData;















static MmhImportInstanceData fsm;


static void dataCleanup(MmhImportData *import);
static MmhImportData *dataInit(MmsFolderType folder);
static void findMessage(MmhImportData *import);
static void importMessage(MmhImportData *import);
static void mmhImportMain(MmsSignal *sig);








static void dataCleanup(MmhImportData *import)
{
    
    if (import != NULL && import->to != 0)
    {
        if (fldrmgrCloseMessage( CMN_CLIENT_MMS, import->to) != FM_RESULT_OK)
        {
            MMS_LOG_I(("%s(%d): Couldn't close %d\n", __FILE__, __LINE__, 
                import->to));
        } 

        if (fldrmgrDeleteMsg( CMN_CLIENT_MMS, import->to, FALSE) != FM_RESULT_OK)
        {
            MMS_LOG_I(("%s(%d): Couldn't delete %d\n", __FILE__, __LINE__, 
                import->to));
        } 
    } 

    M_FREE(import);
} 







static MmhImportData *dataInit(MmsFolderType toFolder)
{
    MmhImportData *import;

    import = M_CALLOC(sizeof(MmhImportData));
    import->toFolder = toFolder;

    return import;
} 






static void findMessage(MmhImportData *import)
{
    int     nrToCheck = 0;
    MmsCopyFile *copy;
    MmsResult result = MMS_RESULT_OK;
    FmResult fmResult;
    
    UINT32 allFileIds[MMS_IMPORTS_PER_ITERATION + 1];

    

    nrToCheck = FILEa_getFileIds( MMS_FILE_CATEGORY_IMPORT, allFileIds, 
        sizeof(allFileIds) / sizeof(UINT32));
    import->to = 0;

    
    if (nrToCheck > (int)(sizeof(allFileIds) / sizeof(UINT32)))
    {
        MMS_LOG_I(("%s(%d): FILEa_getFileIds return more than requested %d > %d\n", 
            __FILE__, __LINE__, nrToCheck, 
            (int)(sizeof(allFileIds) / sizeof(UINT32))));
        M_SIGNAL_SENDTO_IP( M_FSM_MMH_IMPORT, MMS_SIG_MMH_IMPORT_FINISHED,
            MMS_RESULT_ERROR, import);
        return;
    } 

    
    while ( --nrToCheck >= 0)
    {
        if (allFileIds[nrToCheck] == CATEGORY_INDEX_FILE)
        {
            
        }
        else
        {
            
            import->from = allFileIds[nrToCheck];
            fmResult = fldrmgrCreateMsg( CMN_CLIENT_MMS, &import->to, 
                (UINT16)import->toFolder, FALSE);
            result = checkFolderError( fmResult);

            if (result == MMS_RESULT_OK)
            {
                copy = M_CALLOC(sizeof(MmsCopyFile));
                copy->sender = M_FSM_MMH_IMPORT;
                copy->callerData = import;
                copy->from.id = import->from;
                copy->from.category = MMS_FILE_CATEGORY_IMPORT;
                copy->from.pos = 0;
                copy->from.bytes = MMH_COPY_ENTIRE_FILE;
                copy->from.isOpen = FALSE;
                copy->to.shouldCreate = FALSE;
                copy->to.id = import->to;
                copy->to.category = CMN_FILE_CATEGORY_MSG;
                copy->to.pos = MMH_COPY_APPEND;
                copy->to.isOpen = TRUE;
                
                M_SIGNAL_SENDTO_P( M_FSM_MMH_COPY, MMS_SIG_MMH_COPY_START, copy);
                return;
            } 
        } 
    } 
            
    M_SIGNAL_SENDTO_IP( M_FSM_MMH_IMPORT, MMS_SIG_MMH_IMPORT_FINISHED,
        result, import);
} 






static void importMessage(MmhImportData *import)
{
    MmsResult result;
    FmResult fmResult;

    
    result = createMsgInfoList( import->to, 0);

    
    if (result == MMS_RESULT_OK)
    {
        if ((fmResult = fldrmgrCloseMessage( CMN_CLIENT_MMS, import->to)) !=
            FM_RESULT_OK)
        {
            MMS_LOG_I(("%s(%d): Couldn't close the msg.\n", 
                __FILE__, __LINE__));
            result = checkFolderError(fmResult);
        }
        else if ((fmResult = fldrmgrSetFlagValid( CMN_CLIENT_MMS, import->to, 
            TRUE)) != FM_RESULT_OK)
        {
            MMS_LOG_I(("%s(%d): Couldn't set the msg as valid.\n", 
                __FILE__, __LINE__));
            result = checkFolderError(fmResult);
        }
        else
        {
            ++import->numberImported;
            FILEa_delete( MMS_FILE_CATEGORY_IMPORT, import->from);
            import->to = 0;
        } 
    } 

    if (result == MMS_RESULT_OK)
    {
        M_SIGNAL_SENDTO_P( M_FSM_MMH_IMPORT, MMS_SIG_MMH_IMPORT_CONTINUE,
            import);
    }
    else
    {
        M_SIGNAL_SENDTO_IP( M_FSM_MMH_IMPORT, MMS_SIG_MMH_IMPORT_FINISHED,
            result, import);
    } 
} 




void mmhImportInit(void)
{
    fsm.isBusy = FALSE;
    mSignalRegisterDst(M_FSM_MMH_IMPORT, mmhImportMain);
    
    MMS_LOG_I(("MMS FSM MMH IMPORT: initialized\n"));
} 






static void mmhImportMain(MmsSignal *sig)
{
    MmhImportData *import = NULL;
    MmsCopyFile *copy;
    UINT32 numberImported = 0;

    switch (sig->type)
    {
    case MMS_SIG_MMH_IMPORT_START :
        MMS_LOG_I(("MMS FSM MMH IMPORT: MMS_SIG_MMH_IMPORT_START\n"));

        if (fsm.isBusy) 
        {
            MMSa_importMessagesResponse( MMS_RESULT_BUSY, 0);
        }
        else
        {
            fsm.isBusy = TRUE;
            import = dataInit((MmsFolderType)sig->i_param);
            M_SIGNAL_SENDTO_P( M_FSM_MMH_IMPORT, MMS_SIG_MMH_IMPORT_CONTINUE,
                import);
        } 
        break;
    case MMS_SIG_MMH_IMPORT_CONTINUE :
        MMS_LOG_I(("MMS FSM MMH IMPORT: MMS_SIG_MMH_IMPORT_CONTINUE\n"));

        findMessage(sig->p_param);
        break;
    case MMS_SIG_MMH_COPY_FINISHED : 
        MMS_LOG_I(("MMS FSM MMH IMPORT: MMS_SIG_MMH_COPY_FINISHED\n"));

        copy = (MmsCopyFile *)sig->p_param;
        if (copy != NULL)
        {
            import = (MmhImportData *)copy->callerData;
        } 

        if ((MmsResult)sig->i_param == MMS_RESULT_OK)
        {
            importMessage(import);
        }
        else
        {
            M_SIGNAL_SENDTO_IP( M_FSM_MMH_IMPORT, MMS_SIG_MMH_IMPORT_FINISHED,
                sig->i_param, import);
        } 

        M_FREE(copy);
        break;
    case MMS_SIG_MMH_IMPORT_FINISHED :
        MMS_LOG_I(("MMS FSM MMH IMPORT: MMS_SIG_MMH_IMPORT_FINISHED\n"));

        import = (MmhImportData *)sig->p_param;
        if (import != NULL)
        {
            numberImported = import->numberImported;
        } 

        dataCleanup(import);
        MMSa_importMessagesResponse( (MmsResult)sig->i_param, numberImported);
        fsm.isBusy = FALSE;
        break;
    default :
        MMS_LOG_I(("MMS FSM MMH IMPORT: Unknown sig %d\n", sig->type));
        break;
    } 

    mSignalDelete(sig);
} 




void mmhImportTerminate(void)
{
    mSignalDeregister(M_FSM_MMH_IMPORT);
    
    MMS_LOG_I(("MMS FSM MMH IMPORT: terminated\n"));
}