slcreate.c

彩信MMS的全部代码

    }

    
    if (rootLayout->bgColor && rootLayout->bgColor != SMIL_COLOR_NOT_USED)
    {
        
        slcByte2HexColor(rootLayout->bgColor, colorStr);

        if (SMIL_RESULT_OK != 
            (res = slcAddTagString(SLC_TAG_BG_COLOR, colorStr, 
            SLC_ADD_QUOTES)))
        {
            return res;
        }
        
    }
    
    


    if (SMIL_RESULT_OK != 
        (res = slcAddTagTag(SLC_TAG_END, SLC_TAG_NEWLINE)))
    {
        return res;
    }
    
    return SMIL_RESULT_OK;
}





static void slcDeleteInstance(void)
{
    if (slcInst)
    {
        M_FREE(slcInst);
        slcInst = NULL;
    }
    
    
    slcFsmBusy = FALSE;
}





static void slcExitFailure(void)
{   
    
    if (slcInst && 
        SMIL_MSG_STORED_AS_FILE == slcInst->storageType &&
        SLC_FILE_NOT_USED != slcInst->fileId)
    {
        FILEa_close( CMN_FILE_CATEGORY_TMP, slcInst->fileId);
        FILEa_delete( CMN_FILE_CATEGORY_TMP , slcInst->fileId);
        slcInst->fileId = SLC_FILE_NOT_USED;
    }
}








static SmilResult slcFlushFileBuffer(void)
{
    SmilResult res = SMIL_RESULT_OK;

    if (SMIL_MSG_STORED_AS_FILE == slcInst->storageType) 
    {
        
        if (SLC_START_POS != slcInst->bufPos)
        {
            
            if (SMIL_RESULT_OK != 
                (res = slcWriteToFile( slcInst->buf, (UINT32)slcInst->bufPos, 
                SLC_UNQUOTED)))
            {
                
                return res;
            }
        }
    }

    return res;
}




void slcInit(void)
{
    slcInst = NULL;
    slcFsmBusy = FALSE;
    
    mSignalRegisterDst(M_FSM_CREATE_SMIL, slcMain);
    
    MMS_LOG_I(("SMIL SLC: initialized\n"));
}




static void slcHandleCreateOfEnd()
{
    SmilResult res;
    
    if (! slcInst)
    {
        MMS_LOG_I(("SMIL SLC: instance variable is NULL!\n"));        
        SMILa_createEndResponse(SMIL_RESULT_ERROR, NULL, 0);
        slcExitFailure();
    }
    else if (! (slcInst->flags & SLC_BIT_HEAD_CREATED))
    {
        MMS_LOG_I(("SMIL SLC: _CREATE_END received but no head has been created!\n"));
        SMILa_createEndResponse(SMIL_RESULT_NO_HEAD_DATA_RECEIVED, NULL, 0);
        slcExitFailure();
    }
    
    else if (! (slcInst->flags & SLC_BIT_PAR_CREATED))
    {
        MMS_LOG_I(("SMIL SLC: _CREATE_END received but no par(s) have been created!\n"));
        SMILa_createEndResponse(SMIL_RESULT_NO_PAR_DATA_RECEIVED, NULL, 0);
        slcExitFailure();
    }

    
    else if (SMIL_RESULT_OK != (res = slcAddTag(SLC_TAG_BODY_END)))
    {
        MMS_LOG_I(("%s(%d): Add BODY_END failed\n", __FILE__, __LINE__));
        SMILa_createEndResponse(res, NULL, 0);
        slcExitFailure();
    }
    else if (SMIL_RESULT_OK != (res = slcAddTag(SLC_TAG_NEWLINE)))
    {
        MMS_LOG_I(("%s(%d): Add NEWLINE failed\n", __FILE__, __LINE__));
        SMILa_createEndResponse(res, NULL, 0);
        slcExitFailure();
    }
    
    else if (SMIL_RESULT_OK != (res = slcAddTag(SLC_TAG_SMIL_END)))
    {
        MMS_LOG_I(("%s(%d): Add SMIL END failed\n", __FILE__, __LINE__));
        SMILa_createEndResponse(res, NULL, 0);
        slcExitFailure();
    }
    else if (SMIL_RESULT_OK != (res = slcAddTag(SLC_TAG_NEWLINE)))
    {
        MMS_LOG_I(("%s(%d): Add NEWLINE failed\n", __FILE__, __LINE__));
        SMILa_createEndResponse(res, NULL, 0);
        slcExitFailure();
    }
    


    else if (SMIL_RESULT_OK != (res = slcZeroTerminateBuffer()))
    {
        SMILa_createEndResponse(res, NULL, 0);
        slcExitFailure();
    }

    


    else if (SMIL_RESULT_OK != (res = slcFlushFileBuffer()))
    {        
        SMILa_createEndResponse(res, NULL, 0);
        slcExitFailure();
    }
    else if (SMIL_MSG_STORED_AS_FILE == slcInst->storageType) 
    {
        
        FILEa_close( CMN_FILE_CATEGORY_TMP, slcInst->fileId);
        SMILa_createEndResponse( SMIL_RESULT_OK, NULL, slcInst->fileId);
    }
    else
    {
        
        SMILa_createEndResponse( SMIL_RESULT_OK, slcInst->buf, 0);
    }

    slcDeleteInstance();
}




static void slcHandleCreateOfHead(MmsSignal *sig)
{   
    SmilResult res = SMIL_RESULT_OK;

    
    if (SMIL_RESULT_OK != (res = slcAddTag(SLC_TAG_SMIL_BEGIN)))
    {
        ; 
    }
    else if (SMIL_RESULT_OK != (res = slcAddTag(SLC_TAG_NEWLINE)))
    {
        ; 
    }
    
    else if (SMIL_RESULT_OK != 
        (res = slcCreateHead((SmilHead *)sig->p_param)))
    {
        ; 
    }
    
    else if (SMIL_RESULT_OK != 
        (res = slcAddTagTag(SLC_TAG_BODY_BEGIN, SLC_TAG_NEWLINE)))
    {
        ; 
    }
    else
    {
        slcInst->flags |= SLC_BIT_HEAD_CREATED;
    }
        
    sluFreeHead( (SmilHead *)sig->p_param);
    sig->p_param = NULL;

    SMILa_createHeadResponse(res);

    if (SMIL_RESULT_OK != res)
    {
        slcExitFailure();
        slcDeleteInstance();
    }
}




static void slcHandleCreateOfPar(const MmsSignal *sig)
{
    SmilResult res = SMIL_RESULT_OK;

    
    if (! sig->p_param)
    {
        MMS_LOG_I(("SMIL SLC: signal _CREATE_PAR received but without the par data!\n"));
        res = SMIL_RESULT_MISSING_DATA;
    }
    
    else if (! (slcInst->flags & SLC_BIT_HEAD_CREATED))
    {
        MMS_LOG_I(("SMIL SLC: signal _CREATE_PAR received but no head has been created!\n"));
        res = SMIL_RESULT_NO_HEAD_DATA_RECEIVED;
    }
    else if (! slcInst)
    {
        MMS_LOG_I(("SMIL SLC: instance variable is NULL!!\n"));        
        res = SMIL_RESULT_ERROR;
    }
    else if (SMIL_RESULT_OK != 
        (res = slcCreateNoneNestedPar( (SmilPar *)sig->p_param)))
    {
        ; 
    } 
    else
    {
        slcInst->flags |= SLC_BIT_PAR_CREATED;
    }

    sluFreeNoneNestedPar( (SmilPar *)sig->p_param);

    SMILa_createParResponse(res);

    if (SMIL_RESULT_OK != res)
    {
        slcExitFailure();
        slcDeleteInstance();
    }
}




static void slcInitInstance(void)
{
    slcInst = (SlcInstance *)M_CALLOC(sizeof(SlcInstance));
    slcInst->bufPos = SLC_START_POS;
    slcInst->fileId = SLC_FILE_NOT_USED;
    slcInst->filePos = SLC_START_POS;
    slcInst->flags = SLC_BIT_FLAG_INIT_VALUE;
    slcInst->storageType = SMIL_MSG_STORED_IN_BUFFER;
}






static void slcMain(MmsSignal *sig)
{
    if (! sig)
    {
        MMS_LOG_I(("SMIL SLC: NULL signal received.\n"));
        return;
    }
    
    switch (sig->type)
    {
    case SLC_SIG_CREATE_HEAD:
        
        
        if (! sig->p_param)
        {
            MMS_LOG_I(("SMIL SLC: signal _CREATE_HEAD received but without data!\n"));
            SMILa_createHeadResponse(SMIL_RESULT_MISSING_DATA);
            break;
        }
        
        else if (slcFsmBusy)
        {
            MMS_LOG_I(("SMIL SLC: signal _CREATE_HEAD received but FSM is busy!\n"));
            sluFreeHead( (SmilHead *)sig->p_param);
            SMILa_createHeadResponse(SMIL_RESULT_BUSY);
            break;
        }
        else
        {
            MMS_LOG_I(("SMIL SLC: beginning create head.\n"));
            
            slcFsmBusy = TRUE;  
            slcInitInstance();  
        }
        
        slcHandleCreateOfHead(sig);
        break;
        
    case SLC_SIG_CREATE_PAR:
        MMS_LOG_I(("SMIL SLC: SLC_SIG_CREATE_PAR\n"));
        
        if (! slcFsmBusy)
        {
            sluFreeNoneNestedPar( (SmilPar *)sig->p_param);
            SMILa_createParResponse(SMIL_RESULT_FSM_NOT_STARTED);
        }
        else
        {
            slcHandleCreateOfPar(sig);
        }
        break;
        
    case SLC_SIG_CREATE_END:
        MMS_LOG_I(("SMIL SLC: SLC_SIG_CREATE_END\n"));
        if (! slcFsmBusy) 
        {
            SMILa_createEndResponse(SMIL_RESULT_FSM_NOT_STARTED, NULL, 0);
        }
        else
        {
            slcHandleCreateOfEnd();
        }
        break;
        
    case SLC_SIG_CREATE_CANCEL:
        MMS_LOG_I(("SMIL SLC: SLC_SIG_CREATE_CANCEL\n"));
        
        if (! slcFsmBusy) 
        {
            SMILa_createCancelResponse(SMIL_RESULT_FSM_NOT_STARTED);
        }
        else if (! slcInst)
        {
            MMS_LOG_I(("SMIL SLC: instance variable is NULL!!\n"));
            SMILa_createCancelResponse(SMIL_RESULT_ERROR);
        }
        else
        {
              
            slcExitFailure();
            slcDeleteInstance();
            SMILa_createCancelResponse(SMIL_RESULT_CANCELLED_BY_USER);
        }
        break;
        
    default :
        MMS_LOG_I(("SMIL SLC: main unknown signal, %d\n", sig->type));
        break;
    } 
    
    mSignalDelete(sig);
} 




void slcTerminate(void)
{
    if (slcFsmBusy)
    {   
        slcDeleteInstance();
    }

    mSignalDeregister(M_FSM_CREATE_SMIL);
      
    MMS_LOG_I(("SMIL SLC: terminated\n"));
}









 
static SmilResult slcZeroTerminateBuffer(void)
{
    SmilResult res = SMIL_RESULT_OK;
    
    if (SMIL_MSG_STORED_IN_BUFFER != slcInst->storageType)
    {
        
        return SMIL_RESULT_OK;
    }
    
    else
    {
        if (slcInst->bufPos + 1 >= (int)SMIL_CREATE_BUFFER_SIZE)
        {
            


            if (SMIL_RESULT_OK != 
                (res = slcWriteToFile(slcInst->buf, (UINT32)slcInst->bufPos, 
                SLC_UNQUOTED)))
            {
                return res;
            }
            else
            {
                
                slcInst->bufPos = 0;
            }
        }
        else
        {
            
            slcInst->buf[slcInst->bufPos] = '\0';
            ++slcInst->bufPos;
        }
    }

    return res;
}













static SmilResult slcWriteToFile(const char *strBuf, unsigned int strLen, 
    SlcQuotes useQuotes)
{
   



    if (SMIL_MSG_STORED_IN_BUFFER == slcInst->storageType)
    {
        slcInst->storageType = SMIL_MSG_STORED_AS_FILE;
        
        if (SLC_FILE_CREATE_FAILED == 
            FILEa_create(CMN_FILE_CATEGORY_TMP, NULL, (UINT32*)&(slcInst->fileId)))
        {
            MMS_LOG_I(("SMIL SLC: failed to create file\n"));
            return SMIL_RESULT_OPEN_FILE_FAILED;
        }
    }
    
    
    if (SLC_ADD_QUOTES == useQuotes)
    {
        if (SLC_QUOTE_CHAR_LEN != FILEa_write(CMN_FILE_CATEGORY_TMP, 
            slcInst->fileId,
            (void *)SLC_QUOTE_CHAR, 
            (int)slcInst->filePos, 
            SLC_QUOTE_CHAR_LEN))
        {
        


            MMS_LOG_I(("SMIL SLC: failed to write to file\n"));
            return SMIL_RESULT_FILE_WRITE_FAILED;
        }
        else
        {
            slcInst->filePos += SLC_QUOTE_CHAR_LEN;
        }
    }
    
    
    if ((long)strLen != FILEa_write(CMN_FILE_CATEGORY_TMP, slcInst->fileId,
        (void *)strBuf, (int)slcInst->filePos,
        (int)strLen))
    {
    

        
        MMS_LOG_I(("SMIL SLC: failed to write to file\n"));
        return SMIL_RESULT_FILE_WRITE_FAILED;
    }
    else
    {
        slcInst->filePos += strLen;
    }
    
    
    if (SLC_ADD_QUOTES == useQuotes)
    {
        if (SLC_QUOTE_CHAR_LEN != FILEa_write(CMN_FILE_CATEGORY_TMP, 
            slcInst->fileId,
            (void *)SLC_QUOTE_CHAR, 
            (int)slcInst->filePos, 
            SLC_QUOTE_CHAR_LEN))
        {
        

            
            MMS_LOG_I(("SMIL SLC: failed to write to file\n"));
            return SMIL_RESULT_FILE_WRITE_FAILED;
        }
        else
        {
            slcInst->filePos += SLC_QUOTE_CHAR_LEN;
        }
    }
    return SMIL_RESULT_OK;
}