contentLister/inc/history.h File Reference

content lister - eReader history handling More...

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

Go to the source code of this file.

Defines
#define	MAX_RECENT_ITEMS   6
#define	MAX_DOWNLOAD_ITEMS   12
Functions
void	hsInit (void)
void	hsDestroy (void)
void	hsStoreItem (st_ContentType_e contentType, clDisplayItem_t *item)
void	hsGetItem (st_ContentType_e contentType, clDisplayItem_t *item)
gboolean	hsSetLocation (st_ContentType_e contentType, char *location)
char *	hsGetLocation (st_ContentType_e contentType)
gboolean	hsRemoveLocation (st_ContentType_e contentType)
void	hsSetActiveViewer (st_ContentType_e contentType, char *viewerId)
char *	hsGetActiveViewer (st_ContentType_e contentType)
st_ContentType_e	hsGetContentType (char *viewerid)
void	hsCleanupSymlinks (const char *szLinkDir)
void	hsLimitSymlinks (const char *szLinkDir, int maxItems)

---

Detailed Description

content lister - eReader history handling

<File description>=""> - store the last opened item for every category in memory

Definition in file history.h.

---

Define Documentation

#define MAX_DOWNLOAD_ITEMS   12

Definition at line 41 of file history.h.

#define MAX_RECENT_ITEMS   6

Definition at line 40 of file history.h.

---

Function Documentation

void hsCleanupSymlinks

(

const char *

szLinkDir

)

Remove symlinks for which the target is not present

Parameters:

szTargetDir

directory to scan for symlinks

Returns:

--

Definition at line 544 of file history.c.

{
    g_assert(szLinkDir != NULL);
    CL_HISTORYPRINTF("Entry: directory [%s]", szLinkDir);
    
    DIR*   dirp;
    struct dirent* direntp;
    struct stat    statBuf;
    
    char   szName[ERMDS_MAX_FILENAME_SIZE];


    if ((dirp = opendir(szLinkDir)) == NULL)
    {
        CL_ERRORPRINTF("Could not open directory %s (error %s).", szLinkDir, strerror(errno));
        return;
    }
    else
    {
        while ((direntp = readdir(dirp)) != NULL)
        {
            if (   strcmp(".",  direntp->d_name) == 0
                || strcmp("..", direntp->d_name) == 0)
            {
                // skip this entry
                continue;
            }
            
            snprintf(szName, ERMDS_MAX_FILENAME_SIZE, "%s/%s", szLinkDir, direntp->d_name);
            if (   isSymLink(szName)
                && stat(szName, &statBuf) == -1 )
            {
                // directory entry is a symlink, but no file/directory behind it: remove symlink
                CL_HISTORYPRINTF("Remove symlink [%s]", szName);
                unlink(szName);
            }
        }

        closedir(dirp);
    }
}

Here is the call graph for this function:

void hsDestroy

(

void

)

Store the history information in the registry and destroy allocated resources used by the history module

Returns:

-

Definition at line 137 of file history.c.

{
    int     index;
    regLastRead_t *theLastRead = NULL;

    CL_HISTORYPRINTF("");

    //store the history information in the registry
    prepare_registry_write();
    CL_HISTORYPRINTF("Checked and loaded registry");

    CL_HISTORYPRINTF("Store BOOKS_CATEGORY");
    theLastRead = g_new0(regLastRead_t, 1);
    hsCreateConvertItem(theLastRead, g_history[st_ContentTypeBooks]);
    // avoid writing NULL to registry
    if (g_location[st_ContentTypeBooks])
    {
        theLastRead->position = g_strdup(g_location[st_ContentTypeBooks]);
    }
    else
    {
        theLastRead->position = g_strdup("");
    }
    erRegSetLastRead(BOOKS_CATEGORY, theLastRead);
    erRegFreeLastRead(theLastRead);

    CL_HISTORYPRINTF("Store NEWSPAPERS_CATEGORY");
    theLastRead = g_new0(regLastRead_t, 1);
    hsCreateConvertItem(theLastRead, g_history[st_ContentTypeNews]);
    // avoid writing NULL to registry
    if (g_location[st_ContentTypeNews])
    {
        theLastRead->position = g_strdup(g_location[st_ContentTypeNews]);
    }
    else
    {
        theLastRead->position = g_strdup("");
    }
    CL_HISTORYPRINTF("position %s", theLastRead->position);
    erRegSetLastRead(NEWSPAPERS_CATEGORY, theLastRead);
    erRegFreeLastRead(theLastRead);

    CL_HISTORYPRINTF("Store DOCUMENTS_CATEGORY");
    theLastRead = g_new0(regLastRead_t, 1);
    hsCreateConvertItem(theLastRead, g_history[st_ContentTypeDocs]);
    CL_HISTORYPRINTF("position %s", theLastRead->position);
    // avoid writing NULL to registry
    if (g_location[st_ContentTypeDocs])
    {
        theLastRead->position = g_strdup(g_location[st_ContentTypeDocs]);
    }
    else
    {
        theLastRead->position = g_strdup("");
    }
    CL_HISTORYPRINTF("position %s", theLastRead->position);
    erRegSetLastRead(DOCUMENTS_CATEGORY, theLastRead);
    erRegFreeLastRead(theLastRead);

    CL_HISTORYPRINTF("Store NOTES_CATEGORY");
    theLastRead = g_new0(regLastRead_t, 1);
    hsCreateConvertItem(theLastRead, g_history[st_ContentTypeNotes]);
    // avoid writing NULL to registry
    if (g_location[st_ContentTypeNotes])
    {
        theLastRead->position = g_strdup(g_location[st_ContentTypeNotes]);
    }
    else
    {
        theLastRead->position = g_strdup("");
    }
    CL_HISTORYPRINTF("position %s", theLastRead->position);
    erRegSetLastRead(NOTES_CATEGORY, theLastRead);
    erRegFreeLastRead(theLastRead);

    do_registry_write();
    CL_HISTORYPRINTF("Stored registry");


    CL_HISTORYPRINTF("Free resources");

    for (index = 0; index < ARCHIVE_TYPE_COUNT; index++)
    {
        if (g_history[index])
        {
            g_free(g_history[index]);
            g_history[index] = NULL;
        }

        if (g_location[index])
        {
            g_free(g_location[index]);
            g_location[index] = NULL;
        }
    }
}

Here is the call graph for this function:

char* hsGetActiveViewer

(

st_ContentType_e

contentType

)

Get the active viewer for the specified contentType

Parameters:

contentType

Returns:

viewerId " " or NULL in case no viewer

Definition at line 335 of file history.c.

{
    char   *viewerId = NULL;

    if (stackIsArchive(contentType))
    {
        viewerId = g_activeViewer[contentType];

        CL_HISTORYPRINTF("contentType %d viewerId %s", contentType, viewerId);
    }
    return viewerId;
}

Here is the call graph for this function:

st_ContentType_e hsGetContentType

(

char *

viewerid

)

Get the contentType associated with the "active viewer"

Parameters:

contentType

Returns:

viewerId

Definition at line 348 of file history.c.

{
    st_ContentType_e theType = st_ContentTypeUndefined;
    int     index;

    CL_HISTORYPRINTF("viewerId %s", viewerId);

    for (index = 0; index < ARCHIVE_TYPE_COUNT; index++)
    {
        if (strncmp(g_activeViewer[index], viewerId, UAID_MAX_SIZE) == 0)
        {
            CL_HISTORYPRINTF("theType %d", index);
            theType = index;
        }
    }
    return theType;
}

void hsGetItem	(	st_ContentType_e	contentType,
		clDisplayItem_t *	item
	)

retrieve a copy of the history item of the specified content type

Parameters:

	contentType
	item	- reference to memory where the copy should be returned

Returns:

-

Definition at line 258 of file history.c.

{
    CL_HISTORYPRINTF("contentType %d item 0x%x", contentType, (unsigned int) item);

    if ((item) && (stackIsArchive(contentType)))
    {
        memcpy(item, g_history[contentType], sizeof(clDisplayItem_t));
    }
}

Here is the call graph for this function:

char* hsGetLocation

(

st_ContentType_e

contentType

)

Get the item location information from the history data (RAM)

Parameters:

contentType

Returns:

last viewer location of this item, NULL when not available (this string value should be freed by the calling routine !!)

Definition at line 286 of file history.c.

{
    char   *theLocation = NULL;

    CL_HISTORYPRINTF("type %d", contentType);

    if (stackIsArchive(contentType))
    {
        theLocation = g_strdup(g_location[contentType]);
    }
    return theLocation;
}

Here is the call graph for this function:

void hsInit

(

void

)

Allocate memory to store one history item for the available archive content types and retrieve the history values from the registry

Returns:

-

Definition at line 70 of file history.c.

{
    int  i;
    char buf[ERMDS_MAX_FILENAME_SIZE];
    regLastRead_t *theBooks = NULL;
    regLastRead_t *theNews  = NULL;
    regLastRead_t *theDocs  = NULL;
    regLastRead_t *theNotes = NULL;

    CL_HISTORYPRINTF("");

    // retrieve the history information from the registry
    theBooks = erRegGetLastRead(BOOKS_CATEGORY);
    theNews = erRegGetLastRead(NEWSPAPERS_CATEGORY);
    theDocs = erRegGetLastRead(DOCUMENTS_CATEGORY);
    theNotes = erRegGetLastRead(NOTES_CATEGORY);
 
    g_history[st_ContentTypeBooks] = hsCreateItem(theBooks);
    if (theBooks)
    {
        CL_HISTORYPRINTF("Found BOOKS_CATEGORY (loc %s)", theBooks->position);
        g_location[st_ContentTypeBooks] = g_strdup(theBooks->position);
        erRegFreeLastRead(theBooks);
    }
    strncpy(g_activeViewer[st_ContentTypeBooks], NO_VIEWER_ACTIVE, UAID_MAX_SIZE);

    g_history[st_ContentTypeNews] = hsCreateItem(theNews);
    if (theNews)
    {
        CL_HISTORYPRINTF("Found NEWSPAPERS_CATEGORY (loc %s)", theNews->position);
        g_location[st_ContentTypeNews] = g_strdup(theNews->position);
        erRegFreeLastRead(theNews);
    }
    strncpy(g_activeViewer[st_ContentTypeNews], NO_VIEWER_ACTIVE, UAID_MAX_SIZE);

    g_history[st_ContentTypeDocs] = hsCreateItem(theDocs);
    if (theDocs)
    {
        CL_HISTORYPRINTF("Found DOCUMENTS_CATEGORY (loc %s)", theDocs->position);
        g_location[st_ContentTypeDocs] = g_strdup(theDocs->position);
        erRegFreeLastRead(theDocs);
    }
    strncpy(g_activeViewer[st_ContentTypeDocs], NO_VIEWER_ACTIVE, UAID_MAX_SIZE);

    g_history[st_ContentTypeNotes] = hsCreateItem(theNotes);
    if (theNotes)
    {
        CL_HISTORYPRINTF("Found NOTES_CATEGORY (loc %s)", theNotes->position);
        g_location[st_ContentTypeNotes] = g_strdup(theNotes->position);
        erRegFreeLastRead(theNotes);
    }
    strncpy(g_activeViewer[st_ContentTypeNotes], NO_VIEWER_ACTIVE, UAID_MAX_SIZE);

    // retrieve the recent-documents information from the registry
    i = mdsGetRootLocation(st_RecentDocuments, buf, sizeof(buf));
    if (i > 0)
    {
        g_location[st_RecentDocuments] = g_strdup(buf);
    }
    else
    {
        CL_ERRORPRINTF("mdsGetRootLocation(st_RecentDocuments) returns [%d]", i);
    }
}

Here is the call graph for this function:

void hsLimitSymlinks	(	const char *	szLinkDir,
		int	maxItems
	)

Limit symlinks to the specified number, removing symlinks with "lowest" names

Parameters:

	szTargetDir	directory to scan for symlinks
	maxItems	maximum number of symlinks allowed

Returns:

--

Definition at line 588 of file history.c.

{
    int    i;
    DIR*   dirp;
    struct dirent* direntp;

    typedef struct
    {
        char    szName[ERMDS_MAX_FILENAME_SIZE];
    } linkInfo_t;

    linkInfo_t* linkTable = alloca( sizeof(linkInfo_t) * (maxItems + 1) );
    linkInfo_t* linkOldest  = NULL;
    linkInfo_t* linkCurrent = &linkTable[0];
    int         linkNum = 0;

    g_return_if_fail(linkTable != NULL);

    if ((dirp = opendir(szLinkDir)) == NULL)
    {
        CL_ERRORPRINTF("Could not open directory %s (error %s).", szLinkDir, strerror(errno));
        return;
    }
    else
    {
        while ((direntp = readdir(dirp)) != NULL)
        {
            if (   strcmp(".",  direntp->d_name) == 0
                || strcmp("..", direntp->d_name) == 0)
            {
                // skip this entry
                continue;
            }
            
            linkCurrent = &linkTable[linkNum];
            snprintf(linkCurrent->szName, ERMDS_MAX_FILENAME_SIZE, "%s/%s", szLinkDir, direntp->d_name);

            if (linkNum < maxItems)
            {
                // table not full: add this item
                linkNum++;
                if (   linkOldest == NULL
                    || strcmp(linkCurrent->szName, linkOldest->szName) < 0)
                {
                    linkOldest = linkCurrent;
                }
            }
            else if (strcmp(linkCurrent->szName, linkOldest->szName) < 0)
            {
                // table full and item older than oldest: remove current item
                CL_HISTORYPRINTF("Remove symlink [%s]", linkCurrent->szName);
                delete_fsitem(linkCurrent->szName);
            }
            else
            {
                // table full and item newer than oldest: replace oldest item
                CL_HISTORYPRINTF("Remove symlink [%s]", linkOldest->szName);
                delete_fsitem(linkOldest->szName);
                *linkOldest = *linkCurrent;

                // find the oldest item now in the list
                for ( i = 0,      linkCurrent = &linkTable[0] ;
                      i < linkNum ;
                      i++,        linkCurrent++ )
                {
                    if (strcmp(linkCurrent->szName, linkOldest->szName) < 0)
                    {
                        linkOldest = linkCurrent;
                    }
                }
            }
        }// while
        
        closedir(dirp);
    }
}

Here is the call graph for this function:

gboolean hsRemoveLocation

(

st_ContentType_e

contentType

)

Remove the item location information from the history data (RAM)

Parameters:

contentType

Returns:

FALSE when not available

Definition at line 299 of file history.c.

{
    gboolean returnValue = FALSE;

    if (stackIsArchive(contentType))
    {
        if (g_location[contentType])
        {
            g_free(g_location[contentType]);
            g_location[contentType] = NULL;
            returnValue = TRUE;
        }
    }
    return returnValue;
}

Here is the call graph for this function:

void hsSetActiveViewer	(	st_ContentType_e	contentType,
		char *	viewerId
	)

Store the active viewer for the specified contentType and clear viewer ID if used for another contentType.

Parameters:

	contentType
	viewerId	unique identification of the viewere

Definition at line 315 of file history.c.

{
    int     index;

    CL_HISTORYPRINTF("contentType %d viewerId %s", contentType, viewerId);

    for (index = 0; index < ARCHIVE_TYPE_COUNT; index++)
    {
        if (g_activeViewer[index] == viewerId)
        {
            strncpy(g_activeViewer[index], NO_VIEWER_ACTIVE, UAID_MAX_SIZE);
        }
    }

    if (stackIsArchive(contentType))
    {
        strncpy(g_activeViewer[contentType], viewerId, UAID_MAX_SIZE);
    }
}

Here is the call graph for this function:

gboolean hsSetLocation	(	st_ContentType_e	contentType,
		char *	location
	)

Set the item location information in the history data (RAM) Thread safe

Parameters:

	contentType
	location	current viewer location of the current history item of this contentType

Returns:

FALSE in case of failure

Definition at line 268 of file history.c.

{
    CL_HISTORYPRINTF("type %d - %s", contentType, location);

    if (stackIsArchive(contentType))
    {
        if (g_location[contentType])
        {
            g_free(g_location[contentType]);
            g_location[contentType] = NULL;
        }

        g_location[contentType] = g_strdup(location);
    }

    return TRUE;
}

Here is the call graph for this function:

void hsStoreItem	(	st_ContentType_e	contentType,
		clDisplayItem_t *	item
	)

Store (copy) the content of the item in the history of the specified content type

Parameters:

	contentType
	item	- details of the currently "open item"

Returns:

-

Definition at line 234 of file history.c.

{
    CL_HISTORYPRINTF("contentType %d item 0x%x", contentType, (unsigned int) item);

    if ((item) && (stackIsArchive(contentType)))
    {
        memcpy(g_history[contentType], item, sizeof(clDisplayItem_t));
    }

    if (item)
    {
        if (    item->fit == mdsFitFile
            &&  strcasecmp(item->szFileExt, "png") == 0 )
        {
            // Notes template: do not add to recent documents
            CL_WARNPRINTF("Notes template: file [%s] not added to recent documents", item->szFilename);
        }
        else
        {
            hsAddRecent(item);
        }
    }
}

Here is the call graph for this function: