fldrmgr.c

彩信MMS的全部代码

        }
        else if (folder != FM_ALL_FOLDERS &&
            myTable->indexFile.msg[i].folder != folder)
        {
            
        }
        else if (startPos > 0)
        {
            

            --startPos;
        }
        else 
        {
            if (arr != NULL)
            {
                arr[found] = myTable->indexFile.msg[i].msgFile;
            } 

            if (dates != NULL)
            {
                dates[found] = myTable->indexFile.msg[i].date;
            } 

            if (metadata != NULL)
            {
                metadata[found] = 
                    (UINT8)((myTable->indexFile.msg[i].flag >> 4) & 0x0f);
            } 

            if (attributes != NULL)
            {
                attributes[found] = (UINT8)(myTable->indexFile.msg[i].flag & 0x0f);
            } 

            ++found;
        } 
    } 

    *items = found;
    return FM_RESULT_OK;
} 












FmResult fldrmgrGetMsgIdList(CmnClientId client, UINT16 folderType, 
    UINT32 maxItems, UINT32 *items, UINT32 arr[])
{
    UINT32 i;
    UINT32 found = 0;
    UINT16 folder = 0;

    *items = 0;
    if (folderType > CMN_MAX_FOLDERS && folderType != FM_ALL_FOLDERS)
    {
        return FM_RESULT_FOLDER_NOT_FOUND;
    } 

    if (folderType == FM_ALL_FOLDERS)
    {
        folder = folderType;
    }
    else
    {
        folder = (UINT16)(client * CMN_MAX_FOLDERS + folderType);
    } 

    for (i = 0; 
        i < CMN_MAX_NO_OF_MESSAGES && found < maxItems && 
        myTable->indexFile.msg[i].msgFile != 0; ++i)
    {
        if (myTable->indexFile.msg[i].client != client)
        {
            
        }
        else if ( !FLDRMGR_FLAG_VALID(myTable->indexFile.msg[i].flag) )
        {
            
        }
        else if (folder != FM_ALL_FOLDERS && 
                myTable->indexFile.msg[i].folder != folder)
        {
            
        }
        else
        {
            arr[found] = myTable->indexFile.msg[i].msgFile;
            ++found;
        } 
    } 

    *items = found;
    return FM_RESULT_OK;
} 










FmResult fldrmgrGetNumberOfMsg( CmnClientId client, UINT16 folderType, 
    FmReadStatus readStatus, UINT32 *items)
{
    int i;
    UINT32 found = 0;
    UINT16 folder = 0;

    *items = 0;
    if (folderType > CMN_MAX_FOLDERS && folderType != FM_ALL_FOLDERS)
    {
        return FM_RESULT_FOLDER_NOT_FOUND;
    } 

    if (folderType == FM_ALL_FOLDERS)
    {
        folder = folderType;
    }
    else
    {
        folder = (UINT16)(client * CMN_MAX_FOLDERS + folderType);
    } 

    for (i = 0; 
        i < CMN_MAX_NO_OF_MESSAGES && myTable->indexFile.msg[i].msgFile != 0; 
        ++i)
    {
        
        if (myTable->indexFile.msg[i].client == client && 
            FLDRMGR_FLAG_VALID(myTable->indexFile.msg[i].flag))
        {
            
            if ((readStatus == FM_IS_UNREAD && 
                (myTable->indexFile.msg[i].flag & CMN_ATTRIBUTE_READ) != 0)
                ||
                (readStatus == FM_IS_READ && 
                (myTable->indexFile.msg[i].flag & CMN_ATTRIBUTE_READ) == 0))
            {
                



            }
            
            else if (folder == FM_ALL_FOLDERS || 
                myTable->indexFile.msg[i].folder == folder)
            {
                ++found;
            } 
        } 
    } 

    *items = found;
    return FM_RESULT_OK;
} 







FmResult fldrmgrIndexTableSave(int save)
{
    return indexTableSave( FM_OPER_ANY, save);
} 








FmResult fldrmgrInit(CmnClientId client)
{
    int     nrOfFiles = 0;
    UINT32  *allFileIds = NULL;
    FmResult result = FM_RESULT_ERROR;
    CMN_BOOL isConverted = FALSE;




#ifndef CMN_INDEX_DYNAMIC
    static IndexTable staticTable;

    myTable = &staticTable;
#else 
    myTable = G_ALLOC( client, sizeof(IndexTable)); 
    if (myTable == NULL)
    {
        CMN_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        return FM_RESULT_MEMORY_ERROR; 
    } 

    myTable->client = client; 
#endif 

    memset( myTable, 0, sizeof(IndexTable));

    
    nrOfFiles = FILEa_getFileIds( CMN_FILE_CATEGORY_MSG, NULL, 0);
    if (nrOfFiles < 0)
    {
        CMN_LOG_I(("%s(%d): FILEa_getFileIds returned %d.\n", 
            __FILE__, __LINE__, nrOfFiles));

        return FM_RESULT_FILE_ERROR; 
    }
    else if (nrOfFiles > 0)
    {
        allFileIds = G_ALLOC( client, (UINT32)nrOfFiles * sizeof(UINT32)); 
        if (allFileIds == NULL)
        {
            CMN_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
            return FM_RESULT_MEMORY_ERROR; 
        } 
        
        if (FILEa_getFileIds( CMN_FILE_CATEGORY_MSG, allFileIds, nrOfFiles) <= 0)    
        {
            CMN_LOG_I(("%s(%d): FILEa_getFileIds returned error\n", 
                __FILE__, __LINE__));

            G_FREE( client, allFileIds);
            return FM_RESULT_FILE_ERROR;
        } 

        
        if ( !initDisk( allFileIds, nrOfFiles))
        {
            CMN_LOG_I(("%s(%d): FILEa_getFileIds returned error\n", 
                __FILE__, __LINE__));

            G_FREE( client, allFileIds);
            return FM_RESULT_FILE_ERROR;
        } 
    } 

    result = indexTableInit( client, myTable);
    if (result == FM_RESULT_INDEX_FILE_CONVERTED)
    {
        isConverted = TRUE;
        result = FM_RESULT_OK;
    } 

    if (result == FM_RESULT_OK)
    {
        
        result = indexTableValidate( myTable, allFileIds, nrOfFiles);
    } 

    
    if (allFileIds != NULL)
    {
        G_FREE( client, allFileIds);
    } 

    
    if (result == FM_RESULT_OK && isConverted)
    {
        result = FM_RESULT_INDEX_FILE_CONVERTED;
    } 

    
    myTable->isDirty = FALSE;
    myTable->isDirtyBackup = FALSE;

    return result;
} 











FmResult fldrmgrOpenList(CmnClientId client, UINT32 msgId, void **cache,
    FmFileOption option)
{
    UINT32 fileId;
    UINT32 openedFileId;
    FmResult ret = FM_RESULT_MSGID_NOT_FOUND;

    option = option;
    fileId = fldrmgrGetId( client, msgId, TRUE);
    if (fileId != FM_INDEX_FILE)
    {
        openedFileId = fileId;
        ret = cacheFileOpen( cache, client, 128, 
            CMN_FILE_CATEGORY_MSG, &openedFileId);

        if (openedFileId != fileId && cache != NULL)
        { 
            (void)cacheFileClose(*cache);
            ret = FM_RESULT_MSGID_NOT_FOUND;
        } 
    } 

    return ret;
} 










FmResult fldrmgrOpenMessage(CmnClientId client, UINT32 msgId, 
    FmFileOption option)
{
    FmResult ret = FM_RESULT_MSGID_NOT_FOUND;

    msgId = fldrmgrGetId( client, msgId, FALSE);
    if (msgId != FM_INDEX_FILE &&
        FILEa_open(CMN_FILE_CATEGORY_MSG, msgId, option) == 0)
    {
        ret = FM_RESULT_OK;
    } 

    return ret;
} 









FmResult fldrmgrMoveMsg(CmnClientId client, UINT32 msgId, UINT16 dest)
{ 
    int i;

    if (dest > CMN_MAX_FOLDERS)
    {
        CMN_LOG_I(("%s(%d): Wrong destination folder %d\n", 
            __FILE__, __LINE__, dest));
        return FM_RESULT_ERROR;
    } 

    i = findIx( client, msgId);
    if (i >= CMN_MAX_NO_OF_MESSAGES)
    {
        return FM_RESULT_MSGID_NOT_FOUND;
    } 

    if (FLDRMGR_FLAG_VALID(myTable->indexFile.msg[i].flag))
    {
        myTable->indexFile.msg[i].folder = dest;
        myTable->isDirty = TRUE;  
        myTable->isDirtyBackup = TRUE;

        return indexTableSave( FM_OPER_MOVE, FM_SAVE_BOTH_FILES);
    } 

    return FM_RESULT_MSGID_NOT_FOUND;
} 









FmResult fldrmgrSetDate(CmnClientId client, UINT32 msgId, UINT32 date)
{
    int i = findIx( client, msgId);

    if (i >= CMN_MAX_NO_OF_MESSAGES)
    {
        return FM_RESULT_MSGID_NOT_FOUND;
    } 

    myTable->indexFile.msg[i].date = date;
    myTable->isDirty = TRUE;  
    myTable->isDirtyBackup = TRUE;

    return indexTableSave( FM_OPER_SET_DATE, FM_SAVE_BOTH_FILES);
} 










FmResult fldrmgrSetFlag(CmnClientId client, UINT32 msgId, UINT8 pos, CMN_BOOL value)
{
    int i = findIx( client, msgId);

    if (i >= CMN_MAX_NO_OF_MESSAGES)
    {
        return FM_RESULT_MSGID_NOT_FOUND;
    } 

    if (value)
    {
        myTable->indexFile.msg[i].flag |= pos;
    }
    else
    {
        myTable->indexFile.msg[i].flag &= ~pos;
    } 

    myTable->isDirty = TRUE;  
    myTable->isDirtyBackup = TRUE;

    return indexTableSave( FM_OPER_SET_FLAG, FM_SAVE_BOTH_FILES);
} 











FmResult fldrmgrSetFlagValid(CmnClientId client, UINT32 msgId, CMN_BOOL valid)
{
    FmResult fmResult = FM_RESULT_OK;
    int i = findIx( client, msgId);

    if (i >= CMN_MAX_NO_OF_MESSAGES)
    {
        return FM_RESULT_MSGID_NOT_FOUND;
    } 

    myTable->isDirty = TRUE;  
    myTable->isDirtyBackup = TRUE;
    if (valid)
    {
        myTable->indexFile.msg[i].flag |= CMN_ATTRIBUTE_VALID;
        
        fmResult = indexTableSave( FM_OPER_CREATE, FM_SAVE_BOTH_FILES);
    }
    else
    {
        myTable->indexFile.msg[i].flag &= ~CMN_ATTRIBUTE_VALID;
    } 

    return fmResult;
} 












FmResult fldrmgrSetList( void *cache, unsigned char *data, UINT32 dataSize, 
    UINT32 startPos)
{
    return cacheFileWrite( cache, data, dataSize, startPos);
} 









FmResult fldrmgrSetListSize( CmnClientId client, UINT32 msgId, UINT32 size)
{
    return setSize( client, msgId, TRUE, size);
} 













FmResult fldrmgrSetMessage(CmnClientId client, UINT32 msgId, unsigned char *data,
    UINT32 dataSize, UINT32 startPos)
{
    return setData( client, msgId, data, dataSize, startPos, FALSE);
} 









FmResult fldrmgrSetMessageSize(CmnClientId client, UINT32 msgId, UINT32 size)
{
    return setSize( client, msgId, FALSE, size);
} 









FmResult fldrmgrSetMetadata(CmnClientId client, UINT32 msgId, UINT8 value)
{
    int i = findIx( client, msgId);

    if (i >= CMN_MAX_NO_OF_MESSAGES)
    {
        return FM_RESULT_MSGID_NOT_FOUND;
    } 

    myTable->indexFile.msg[i].flag = (UINT8)(((value << 4) & 0xf0) | 
        (myTable->indexFile.msg[i].flag & 0x0f));
    myTable->isDirty = TRUE;  
    myTable->isDirtyBackup = TRUE;

    return indexTableSave( FM_OPER_SET_METADATA, FM_SAVE_BOTH_FILES);
} 

#ifdef _DEBUG








void fldrmgrTestClose(UINT32 fileId)
{
    FILEa_close(CMN_FILE_CATEGORY_MSG, fileId);
} 













FmResult fldrmgrTestInsert(UINT16 folder, UINT32 fileId, UINT32 infoFileId)
{