contentLister/inc/metadataStoreManager.h File Reference

metadataStoreManager - manage the metadata store More...

#include "stack.h"

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	mdsInit (void)
void	mdsDestroy (void)
int	mdsScanRoot (st_ContentType_e contentType)
int	mdsScanCurrent (st_ContentType_e contentType)
int	mdsScanNext (st_ContentType_e contentType, char *directory, unsigned int theIndex)
int	mdsScanPrevious (st_ContentType_e contentType)
void	mdsSetIndex (st_ContentType_e contentType, unsigned int index)
unsigned int	mdsGetIndex (st_ContentType_e contentType)
int	mdsGetRootLocation (const st_ContentType_e contentType, char *location, const int length)
int	mdsGetItemCount (void)
int	mdsGetItemIndex (const gchar *szFilename)
gboolean	mdsGetItemFilename (int index, gchar *szFilename, int len)
int	mdsSetPageContent (clDisplayItem_t *displayItemArray, int nBegin, int *nChunk)
mdsSortStruct_t *	mdsGetSortStructOfRootInfo (st_ContentType_e type)
void	mdsSetSortStructOfRootInfo (st_ContentType_e type, const mdsSortStruct_t *sort)
gchar *	getContentCategoryID (st_ContentType_e type)
char *	getFieldString (mdsFieldType_e type)
mdsFieldType_e	getFieldType (char *stringValue)
gboolean	storageIsMounted (st_ContentType_e storageType)
gboolean	mdsArcLocIsChanged (st_ContentType_e archiveType, st_ContentType_e storageType)
void	mdsRecreateArchives (st_ContentType_e storageType)
void	displayScanResult (void)

---

Detailed Description

metadataStoreManager - manage the metadata store

metadataStoreManager - init and manage the metadata store

<File description>="">

The data retrieved from the meta store is copied into an internal data format (dsListItem_t) used to render the information on the screen

"MAX_ITEMS_ON_ONE_PAGE" is a predefined value indicating the amount of meta store items that are displayed on one content lister page

<File description>="">

Definition in file metadataStoreManager.h.

---

Function Documentation

void displayScanResult

(

void

)

Definition at line 1071 of file metadataStoreManager.c.

{
    int     i;
    mdsFsItem_t *pFsItem;

    for (i = 0; i < g_contentArray->len; i++)
    {
        pFsItem = &g_array_index(g_contentArray, mdsFsItem_t, i);
        printf("%d. Name: %s", i, pFsItem->szFilename);
        printf("\ttype: %d\n", (int) pFsItem->fit);
    }
}

gchar* getContentCategoryID

(

st_ContentType_e

type

)

Definition at line 716 of file metadataStoreManager.c.

{
    static gchar szID[ERMDS_MAX_EXTENSION_ID_SIZE+1] = "";

    switch (type)
    {
        case st_ContentTypeBooks:
            strcpy(szID, BOOKS_CATEGORY);
            break;
        case st_ContentTypeNews:
            strcpy(szID, NEWSPAPERS_CATEGORY);
            break;
        case st_ContentTypeNotes:
            strcpy(szID, NOTES_CATEGORY);
            break;
        case st_ContentTypeDocs:
            strcpy(szID, DOCUMENTS_CATEGORY);
            break;
        case st_StorageTypeCF:
            strcpy(szID, CF_CATEGORY);
            break;
        case st_StorageTypeMain:
            strcpy(szID, MAIN_CATEGORY);
            break;
        case st_StorageTypeSD:
            strcpy(szID, SD_CATEGORY);
            break;
        case st_StorageTypeUSB:
            strcpy(szID, USB_CATEGORY);
            break;
        case st_MenuTypeMode:
            strcpy(szID, MODE_CATEGORY);
            break;
        case st_DownloadHistory:
            strcpy(szID, DOWNLOAD_HISTORY);
            break;
        case st_SearchResult:
            strcpy(szID, SEARCH_RESULT);
            break;
        case st_RecentDocuments:
            strcpy(szID, RECENTDOCUMENTS);
            break;
        case st_ContentTypeUndefined:
        default:
            szID[0] = '\0';
            break;
    }
    return szID;
}

char* getFieldString

(

mdsFieldType_e

type

)

Definition at line 629 of file metadataStoreManager.c.

{
    static char string[ERCL_MAX_FIELDNAME_SIZE+1];

    switch (type)
    {
       case mdsFieldAuthor:
           strcpy(string, AUTHOR);
           break;
       case mdsFieldDate:
            strcpy(string, DATE);
           break;
       case mdsFieldDescription:
            strcpy(string, DESCRIPTION);
            break;
       case mdsFieldFile:
            strcpy(string, FIELDFILE);
           break;
       case mdsFieldTitle:
            strcpy(string, TITLE);
            break;
       case mdsFieldFsName:
            strcpy(string, FSNAME);
            break;
        case mdsFieldExtName:
            strcpy(string, EXTENSION);
            break; 
        case mdsFieldSize:
            strcpy(string, SIZE);
            break;
        case mdsFieldNone:
        default:
            string[0] = '\0';
            break;
    }
    return string;
}

mdsFieldType_e getFieldType

(

char *

stringValue

)

Definition at line 667 of file metadataStoreManager.c.

{
    if (stringValue)
    {
        //author - date - description - file - fsname - title - none 
        if (strcmp(stringValue, AUTHOR) == 0)
        {
            return mdsFieldAuthor;
        }
        else if (strcmp(stringValue, DATE) == 0)
        {
            return mdsFieldDate;
        }
        else if (strcmp(stringValue, FIELDFILE) == 0)
        {
            return mdsFieldFile;
        }
        else if (strcmp(stringValue, FSNAME) == 0)
        {
            return mdsFieldFsName;
        }
        else if (strcmp(stringValue, TITLE) == 0)
        {
            return mdsFieldTitle;
        }
        else if (strcmp(stringValue, DESCRIPTION) == 0)
        {
            return mdsFieldDescription;
        }
        else if (strcmp(stringValue, EXTENSION) == 0)
        {
            return mdsFieldExtName;
        }
        else if (strcmp(stringValue, SIZE) == 0)
        {
            return mdsFieldSize;
        }
        else
        {
            return mdsFieldNone;
        }
    }
    else
    {
        return mdsFieldNone;
    }

}

gboolean mdsArcLocIsChanged	(	st_ContentType_e	archiveType,
		st_ContentType_e	storageType
	)

Definition at line 825 of file metadataStoreManager.c.

{
    char archiveDirName[ERMDS_MAX_FILENAME_SIZE], storageDirName[ERMDS_MAX_FILENAME_SIZE];
    gboolean bRet = FALSE;
    
    if ((archiveType != st_ContentTypeNews) 
            && (archiveType != st_ContentTypeBooks)
            && (archiveType != st_ContentTypeDocs)
            && (archiveType != st_ContentTypeNotes))
    {
        CL_ERRORPRINTF("invalid archive type[%d]", archiveType);
        return bRet;
    }
    if ((storageType != st_StorageTypeCF)
            && (storageType != st_StorageTypeSD)
            && (storageType != st_StorageTypeUSB)
            && (storageType != st_StorageTypeMain))
    {
        CL_ERRORPRINTF("invalid storage type[%d]", storageType);
        return bRet;
    }
              
    if ( mdsGetRootLocation(archiveType, archiveDirName, sizeof(archiveDirName)) > 0 )
    {
        if ( mdsGetRootLocation(storageType, storageDirName, sizeof(storageDirName)) > 0 )
        {
           CL_LOGPRINTF("%s,%s", archiveDirName, storageDirName);
           if (isRealPathSubFolder(archiveDirName, storageDirName))
           {
              bRet = TRUE;
           }
        }
        else
        {
            CL_ERRORPRINTF("error");
        }
    }
    else
    {
        CL_ERRORPRINTF("error");
    }
    return bRet;
}

Here is the call graph for this function:

void mdsDestroy

(

void

)

Destroy memory allocated by this module

Parameters:

-

Returns:

-

Definition at line 93 of file metadataStoreManager.c.

{
    rootInfoDestroy();
    stackDestroyAll();

    if (g_contentArray)
    {
        g_array_free(g_contentArray, TRUE);
        g_contentArray = NULL;
    }
}

Here is the call graph for this function:

unsigned int mdsGetIndex

(

st_ContentType_e

contentType

)

Retrieve the index field of the current top stack item

Definition at line 369 of file metadataStoreManager.c.

{
    unsigned int returnValue = 0;
    stItem_t *theItem;

    theItem = stackPeek(contentType);

    if (NULL != theItem)
    {
        returnValue = theItem->index;
    }
    else
    {
        if (NULL != g_rootInfo[contentType])
        {
            returnValue = g_rootInfo[contentType]->index;
        }
    }
    return returnValue;
}

Here is the call graph for this function:

int mdsGetItemCount

(

void

)

Definition at line 258 of file metadataStoreManager.c.

{

    if (g_contentArray)
    {
        CL_STACKPRINTF("%d", g_contentArray->len);
        return g_contentArray->len;
    }
    else
    {
        CL_STACKPRINTF("0");
        return 0;
    }
}

gboolean mdsGetItemFilename	(	int	index,
		gchar *	szFilename,
		int	len
	)

Definition at line 305 of file metadataStoreManager.c.

{
    mdsFsItem_t *pFsItem = NULL;

    g_return_val_if_fail((g_contentArray != NULL), FALSE);
    g_return_val_if_fail( ((index >= 0) && (index < g_contentArray->len)) , FALSE);
    g_return_val_if_fail((szFilename != NULL), FALSE);
   
    pFsItem = &g_array_index(g_contentArray, mdsFsItem_t, index);
    g_return_val_if_fail((pFsItem != NULL), FALSE);
    snprintf(szFilename, len, "%s", pFsItem->szFilename);

    return TRUE;
}

int mdsGetItemIndex

(

const gchar *

szFilename

)

Definition at line 274 of file metadataStoreManager.c.

{
    int         i;
    int         index = -1;
    gboolean    found;
    mdsFsItem_t *pFsItem;
    char        *cp;
    char        szRealpath[PATH_MAX];

    g_return_val_if_fail((g_contentArray != NULL), -1);
    
    for ( i = 0, found = FALSE ;
          i < g_contentArray->len  &&  !found ;
          i++ )
    {
        pFsItem = &g_array_index(g_contentArray, mdsFsItem_t, i);
        cp = realpath(pFsItem->szFilename, szRealpath);
        if (cp != NULL)
        {
            if (strcmp(szFilename, szRealpath) == 0 )
            {
                found = TRUE;
                index = i;
            }
        }
    }

    return index;
}

int mdsGetRootLocation	(	const st_ContentType_e	contentType,
		char *	location,
		const int	length
	)

Retrieve the root location of specified content type

Definition at line 780 of file metadataStoreManager.c.

{
    int     nRet = 0;
    char*   cp;
    char    szRealpath[PATH_MAX];
    
    if (NULL == location || 0 >= length) 
    {
        CL_ERRORPRINTF("Invalid buffer pointer or length!");
        return nRet;
    }
    
    if ((NULL == g_rootInfo[contentType]) || (NULL == g_rootInfo[contentType]->dirArray))
    {
        if (contentType == st_MenuTypeMode)
        {
            CL_ERRORPRINTF("No root dir specified for st_MenuTypeMode!");
            return nRet;
        }
        else
        {
            CL_ERRORPRINTF("No root dir for contentType [%d], fallback to MODE menu", contentType);
            return mdsGetRootLocation(st_MenuTypeMode, location, length);
        }
    }
    
    mdsDirectory_t *directory =  &g_array_index(g_rootInfo[contentType]->dirArray,  mdsDirectory_t, 0);
    if (directory)
    {
        cp = realpath(directory->szFilename, szRealpath);
        if (cp == NULL)
        {
            // no realpath found -> report original path
            cp = directory->szFilename;
        }
        nRet = snprintf(location, length, "%s", cp);
    }
    else
    {
        CL_ERRORPRINTF("Invalid directory pointer!");
    }
    return nRet;
}

Here is the call graph for this function:

mdsSortStruct_t* mdsGetSortStructOfRootInfo

(

st_ContentType_e

type

)

Definition at line 582 of file metadataStoreManager.c.

{
   stItem_t *rootItem = NULL;

   if (type < st_ContentTypeBooks || type >= st_ContentTypeUndefined || type >= TOTAL_STACK_COUNT)
   {
       CL_ERRORPRINTF("Invalid arguments");
       return NULL;
   }

   rootItem =  g_rootInfo[type];
   if (rootItem)
   {
        return &(rootItem->sort); 
   }
   else
   {
       CL_WARNPRINTF("Can't find the rootItem of type%d", type);
       return NULL;
   }
}

void mdsInit

(

void

)

Init stack (for every content key) Init storage used for content history

Parameters:

-

Returns:

-

Definition at line 79 of file metadataStoreManager.c.

{
    // destory the old ones
    mdsDestroy();   

    rootInfoInit();
    stackInitAll();

    mdsRecreateArchives(st_StorageTypeMain);
    mdsRecreateArchives(st_StorageTypeCF);
    mdsRecreateArchives(st_StorageTypeSD);
    mdsRecreateArchives(st_StorageTypeUSB);
}

Here is the call graph for this function:

void mdsRecreateArchives

(

st_ContentType_e

storageType

)

Definition at line 873 of file metadataStoreManager.c.

{
    CL_LOGPRINTF("entry");

    // check the argument is valid or not
    if ( (storageType != st_StorageTypeCF) && (storageType != st_StorageTypeSD)
          && (storageType != st_StorageTypeUSB) && (storageType != st_StorageTypeMain) )
    {
        CL_ERRORPRINTF("invalid storage type[%d]", storageType);
        return;
    }

    if (st_StorageTypeMain == storageType)
    {
        // if it's internal memory, 
        // always recreate the archive folders if they don't exist  
        recreateArchives(st_StorageTypeMain);
    }
    else
    {
        // if one of the archives points to the storage, 
        // recreate the archive folders if they don't exsit on storage
        if ( mdsArcLocIsChanged(st_ContentTypeNews, storageType)
             || mdsArcLocIsChanged(st_ContentTypeBooks, storageType)
             || mdsArcLocIsChanged(st_ContentTypeDocs, storageType)
             || mdsArcLocIsChanged(st_ContentTypeNotes, storageType) )
        {
            recreateArchives(storageType);
        }
    }
}

Here is the call graph for this function:

int mdsScanCurrent

(

st_ContentType_e

contentType

)

Scan using the current "content details" information if not available use the "root" values

Parameters:

contentType

indication of the content category

Returns:

error code in case of failure

Definition at line 140 of file metadataStoreManager.c.

{
    stItem_t *contentInfo;
    int     result = 0;
    mdsSortStruct_t *sort = NULL;
    int     sortResult;

    CL_STACKPRINTF("entry: contentType [%d]", contentType);

    if (NULL == g_rootInfo[contentType])
    {
        CL_ERRORPRINTF("No g_rootInfo for contentType [%d], fallback to MODE menu", contentType);
        contentType = st_MenuTypeMode;
    }
    g_return_val_if_fail( (NULL != g_rootInfo[contentType]), result);

    // clear the previous retrieved content information
    if (g_contentArray)
    {
        CL_STACKPRINTF("g_array_free");
        g_array_free(g_contentArray, TRUE);
        g_contentArray = NULL;
    }

    contentInfo = stackPeek(contentType);

    CL_TIMEDISPLAY("before scan");

    if (NULL == contentInfo)
    {
        CL_STACKPRINTF("=> root content");
        result = erMdsContentScan(g_rootInfo[contentType]->dirArray, &g_contentArray);
    }
    else
    {
        //retrieve new content
        stackItemDisplay(contentInfo);
        result = erMdsContentScan(contentInfo->dirArray, &g_contentArray);
    }
    
    CL_TIMEDISPLAY("after scan");

    if ((ERMDS_CONTENT_SCAN_FAILED != result) && (NULL != g_contentArray))
    {
        // we always take the sort settings from the rootInfo
        sort = &g_rootInfo[contentType]->sort;
        sortResult = erMdsContentSort(g_contentArray, sort);

        CL_LOGPRINTF("erMdsContentSort returned %d", sortResult);
    }
    return result;
}

Here is the call graph for this function:

int mdsScanNext	(	st_ContentType_e	contentType,
		char *	directory,
		unsigned int	theIndex
	)

Scan using the current "content details" information but with this new directory data. And store these new "content details" for this contentType on the stack.

Parameters:

	contentType	indication of the content category
	folder	directory information
	index	currently selected index

Returns:

error code in case of failure

Scan using the current "content details" information but with this new directory data. And store these new "content details" for this contentType on the stack.

Also up

Definition at line 200 of file metadataStoreManager.c.

{
    stItem_t *newItem;
    stItem_t *currentItem;
    int     result = 0;
    mdsDirectory_t folder;

    strcpy(folder.szFilename, directory);

    CL_STACKPRINTF("%s", folder.szFilename);

    newItem = g_new0(stItem_t, 1);
    currentItem = stackPeek(contentType);

    if (NULL == currentItem)
    {
        CL_STACKPRINTF("=> root content");
        currentItem = g_rootInfo[contentType];
    }

    // create a new array to store the directory info
    newItem->dirArray = g_array_sized_new(FALSE, TRUE, ERMDS_MAX_FILENAME_SIZE, INITIAL_DIR_COUNT_ARRAY_SIZE);
    CL_STACKPRINTF("newItem->dirArray 0x%x", (unsigned int) newItem->dirArray);
    g_array_append_val(newItem->dirArray, folder);

    // copy the rest of the content from the "current" content details

    // we needn't copy the sort settings because we always use them from the rootInfo.
    // newItem->sort.ascending = currentItem->sort.ascending;
    // newItem->sort.ft = currentItem->sort.ft;
    newItem->index = 0;

    // put the new item on the stack
    stackPush(contentType, newItem);

    //copy of new item (not of the referenced data!) was made on the stack
    g_free(newItem);

    result = mdsScanCurrent(contentType);
    return result;
}

Here is the call graph for this function:

int mdsScanPrevious

(

st_ContentType_e

contentType

)

Remove the current "content details" from the stack and scan using the new current "content details" information.

if not available use the "root" values /home/ann/eReader/svn/eReader/content/

Parameters:

contentType

indication of the content category

Returns:

error code in case of failure

Remove the current "content details" from the stack and scan using the new current "content details" information.

Definition at line 246 of file metadataStoreManager.c.

{
    int     result = 0;

    CL_STACKPRINTF("");

    stackPop(contentType);
    result = mdsScanCurrent(contentType);
    return result;
}

Here is the call graph for this function:

int mdsScanRoot

(

st_ContentType_e

contentType

)

Scan the root directory

Parameters:

contentType

indication of the content category

Returns:

error code in case of failure

Definition at line 105 of file metadataStoreManager.c.

{
    int     result = 0;
    mdsSortStruct_t *sort = NULL;
    int     sortResult;

    CL_STACKPRINTF("");

    // clear the previous retrieved content information
    if (g_contentArray)
    {
        CL_STACKPRINTF("g_array_free");
        g_array_free(g_contentArray, TRUE);
        g_contentArray = NULL;
    }

    CL_TIMEDISPLAY("before scan");

    if (NULL != g_rootInfo[contentType])
    {
        result = erMdsContentScan(g_rootInfo[contentType]->dirArray, &g_contentArray);
        sort = &g_rootInfo[contentType]->sort;
    }

    CL_TIMEDISPLAY("after scan");

    if ((ERMDS_CONTENT_SCAN_FAILED != result) && (NULL != g_contentArray))
    {
        sortResult = erMdsContentSort(g_contentArray, sort);

        CL_LOGPRINTF("erMdsContentSort returned %d", sortResult);
    }
    return result;
}

Here is the call graph for this function:

void mdsSetIndex	(	st_ContentType_e	contentType,
		unsigned int	index
	)

Update the index field of the current top stack item

Definition at line 345 of file metadataStoreManager.c.

{
    stItem_t *theItem;

    theItem = stackPeek(contentType);

    if (NULL != theItem)
    {
        //update the index value
        theItem->index = index;
    }
    else
    {
        //update the root index
        if (NULL != g_rootInfo[contentType])
        {
            g_rootInfo[contentType]->index = index;
        }
    }
    return;
}

Here is the call graph for this function:

int mdsSetPageContent	(	clDisplayItem_t *	displayItemArray,
		int	nBegin,
		int *	nChunk
	)

Definition at line 321 of file metadataStoreManager.c.

{
    int     returnValue;

    if (g_contentArray)
    {
        CL_TIMEDISPLAY("before erClGetDisplayItems");

        returnValue = erClGetDisplayItems(g_contentArray, nBegin, nChunk, displayItemArray);

        CL_TIMEDISPLAY("after erClGetDisplayItems");

    }
    else
    {
        CL_ERRORPRINTF("g_contentArray == NULL");
        returnValue = (-1);
    }

    return returnValue;
}

Here is the call graph for this function:

void mdsSetSortStructOfRootInfo	(	st_ContentType_e	type,
		const mdsSortStruct_t *	sort
	)

Definition at line 604 of file metadataStoreManager.c.

{
   stItem_t *rootItem = NULL;
   mdsSortStruct_t *localSort = NULL;

   if (type < st_ContentTypeBooks || type >= st_ContentTypeUndefined || type >= TOTAL_STACK_COUNT || NULL == sort)
   {
       CL_ERRORPRINTF("Invalid arguments");
       return;
   }

   rootItem =  g_rootInfo[type];
   if (rootItem)
   {
        localSort = &(rootItem->sort);
        localSort->ascending = sort->ascending;
        localSort->ft = sort->ft;
   }
   else
   {
       CL_WARNPRINTF("Can't find the rootItem of type%d", type);
       return;
   }
}

gboolean storageIsMounted

(

st_ContentType_e

storageType

)

Definition at line 1021 of file metadataStoreManager.c.

{
    CL_LOGPRINTF("entry");

    gboolean found = FALSE;

    char storageDirName[ERMDS_MAX_FILENAME_SIZE];

    if ( mdsGetRootLocation(storageType, storageDirName, sizeof(storageDirName)) > 0 )
    {
        char *cp = NULL;
        char realPath[ERMDS_MAX_FILENAME_SIZE];
        
        cp = realpath(storageDirName, realPath);
        CL_LOGPRINTF("%s,%s", storageDirName, realPath);

        FILE *fp = setmntent("/proc/mounts", "r");
        struct mntent* mt = NULL;

         while ((mt = getmntent(fp)))
         {
            CL_LOGPRINTF("Partition: %s: %s %s", mt->mnt_fsname, mt->mnt_dir, mt->mnt_type);

            if (strcasecmp(mt->mnt_dir, realPath) == 0)
            {
                if ( strcasecmp(mt->mnt_type, "vfat") == 0 )
                {
                    found = TRUE;
                    break;
                }
                else
                {
                    found = FALSE;
                }
            }
         }
        
         endmntent(fp);
    }
    else
    {
        CL_ERRORPRINTF("can't get the path of storageType[%d]", storageType);
    }

    CL_LOGPRINTF("found[%d]", found); 
    return found;
}

Here is the call graph for this function: