contentLister/inc/erMSDisk.h File Reference

#include "stack.h"

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

Go to the source code of this file.

Defines
#define	CMD_LEN   32
#define	PROCFS_MOUNT_FILE   "/proc/mounts"
Enumerations
enum	expMemType_e {   expMain = 0, expMMC, expUSB, expCF,   expUndefined }
Functions
void	erMSDiskInit ()
void	erStartMSDiskApp ()
void	erStopMSDiskApp ()
int	erMSDiskSetConnected (int connected)
expMemType_e	get_exported_memory_type (void)
expMemType_e	get_memory_type_used ()
void	erMSDisk_storage_changed (st_ContentType_e storageType, gboolean storagePresent)
void	erMSDisk_handle_reread_settings ()

---

Define Documentation

#define CMD_LEN   32

Copyright (C) 2005-2008 iRex Technologies B.V. All rights reserved.

Definition at line 28 of file erMSDisk.h.

#define PROCFS_MOUNT_FILE   "/proc/mounts"

Definition at line 29 of file erMSDisk.h.

---

Enumeration Type Documentation

enum expMemType_e

Enumerator:

expMain
expMMC
expUSB
expCF
expUndefined

Definition at line 31 of file erMSDisk.h.

{
    expMain = 0,
    expMMC,
    expUSB,
    expCF,
    expUndefined
} expMemType_e;

---

Function Documentation

void erMSDisk_handle_reread_settings

(

)

Definition at line 334 of file erMSDisk.c.

{
    // Re-read export settings from registry
    g_export_memory_type = read_exported_memory_type();
}

Here is the call graph for this function:

void erMSDisk_storage_changed	(	st_ContentType_e	storageType,
		gboolean	storagePresent
	)

Definition at line 285 of file erMSDisk.c.

{
    CL_LOGPRINTF("storageType = %d, storagePresent = %d", storageType, storagePresent);

    // Convert st_ContentType_e to expMemType_e
    expMemType_e storage_type = expUndefined;
    switch (storageType)
    {
        case st_StorageTypeCF:
            storage_type = expCF;
            break;
        case st_StorageTypeSD:
            storage_type = expMMC;
            break;
        case st_StorageTypeUSB:
            storage_type = expUSB;
            break;
        default:
            break;
    }

    if (getListerState() == STATE_USB_CONNECTED)
    {
        // Connected to PC
        if (storagePresent == FALSE)
        {
            // Card plug out event
            if (storage_type == g_memory_type_used)
            {
                // The memory type we are using is plugged out
                CL_WARNPRINTF("WARNING! Card is plugged out when connected to PC.");

                // Stop msdisk application
                erStopMSDiskApp();
                listerHideUSBScreen();
                setListerState(STATE_NORMAL);
            }
            else
            {
                // Another type of memory is plugged out, don't care
            }
        }
    }
    else if (storage_type == g_export_memory_type)
    {   
        erStartMSDiskApp();
    }
}

Here is the call graph for this function:

void erMSDiskInit

(

)

Definition at line 106 of file erMSDisk.c.

{
    g_export_memory_type = read_exported_memory_type();
}

Here is the call graph for this function:

int erMSDiskSetConnected

(

int

connected

)

Definition at line 181 of file erMSDisk.c.

{
    CL_WARNPRINTF("connected = %d", connected);

    if (connected == 1)
    {
        listerShowUSBScreen();
        setListerState(STATE_USB_CONNECTED);

#ifdef ENABLE_CONFIG_EXPORT_IMPORT
        ctrl_export_config();
#endif

        // For USB stick, if we umount USB memory before exporting it, it fails.
        // So just handle USB memory as an exeception, still don't know why.
        if (g_export_memory_type != expUSB)
        {
            erMSDiskDisconnectFlash();
        }

        return 0;
    }
    else if (connected == 0)
    {
        // Again, it can't work for USB stick...
        if (g_export_memory_type != expUSB)
        {
            erMSDiskReconnectFlash();
        }

        listerHideUSBScreen();
        setListerState(STATE_NORMAL);

#ifdef ENABLE_CONFIG_EXPORT_IMPORT
        ctrl_handle_import_config();
#endif

        mdsRecreateArchives(st_StorageTypeMain);
        mdsRecreateArchives(st_StorageTypeCF);
        mdsRecreateArchives(st_StorageTypeSD);
        mdsRecreateArchives(st_StorageTypeUSB);
        
        return 0;
    }
    else
    {
        return -1;
    }
}

Here is the call graph for this function:

void erStartMSDiskApp

(

)

Definition at line 139 of file erMSDisk.c.

{
    char cmd[CMD_LEN];
    expMemType_e memory_type_new = expMain;  // memory to be exported, default is internal memory

    CL_WARNPRINTF("entry: g_export_memory_type [%d] g_memory_type_used [%d]", g_export_memory_type, g_memory_type_used);

    // Use export type only when mounted
    if ( is_device_mounted(dev[g_export_memory_type]) )
    {
        memory_type_new = g_export_memory_type;
    }

    if (g_memory_type_used == memory_type_new)
    {
        ;  // msdisk application already running on required memory type: do nothing
    }
    else
    {
        // Stop msdisk application if running
        if (g_memory_type_used != expUndefined)
        {
            erStopMSDiskApp();
        }

        // Start msdisk application
        g_memory_type_used = memory_type_new;
        snprintf(cmd, sizeof(cmd), "sync ; msdisk %s &", dev[g_memory_type_used]);
        CL_WARNPRINTF("-- starting msdisk [%s]", cmd);
        system(cmd);
    }
}

Here is the call graph for this function:

void erStopMSDiskApp

(

)

Definition at line 172 of file erMSDisk.c.

{
    // TODO: The better solution is using fork/exec and then sending SIGTERM signal
    CL_WARNPRINTF("-- stopping msdisk");
    system("killall msdisk; sync; sync;");

    g_memory_type_used = expUndefined;
}

expMemType_e get_exported_memory_type

(

void

)

Definition at line 54 of file erMSDisk.c.

{
    return g_export_memory_type;
}

expMemType_e get_memory_type_used

(

)

[inline]

Definition at line 59 of file erMSDisk.c.

{
    return g_memory_type_used;
}