/*

* Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

* USB Mass Storage Sample Application

*

*/

/**

 @file

 @publishedPartner

*/

#include "usbmsapp.h"

#include <e32std.h>

#include <e32svr.h>

#include <e32cons.h>

#include <f32file.h>

#include <usbman.h>

#include <d32usbc.h>

#include <usbmsshared.h>

//////////////////////////////////////////////////////////////////////////////

_LIT(KTxtApp,"USBMSEXAMPLEAPP");

_LIT(KMsFsy, "MSFS.FSY");

_LIT(KMsFs, "MassStorageFileSystem");

_LIT(KOk,"OK");

_LIT(KError,"Error");

_LIT(KBytesTransferredFmt, "%c:%d/%d ");

_LIT(KErrFmt, "Property not found (%d)\r");

_LIT8(KDefPwd,"123");

//Mass Storage Device States xRef cedar/generic/base/f32/smassstorage/inc/usbmsshared.h

_LIT(KUsbMsDriveStateDisconnected, "Disconnected");

_LIT(KUsbMsDriveStateConnecting, "Connecting");

_LIT(KUsbMsDriveStateConnected, "Connected");

_LIT(KUsbMsDriveStateDisconnecting, "Disconnecting");

_LIT(KUsbMsDriveStateActive, "Active");

_LIT(KUsbMsDriveStateLocked, "Locked");

_LIT(KUsbMsDriveStateMediaNotPresent, "Media Not Present");

_LIT(KUsbMsDriveStateRemoved, "Removed");

_LIT(KUsbMsDriveStateError, "Error");

_LIT(KUsbMsDriveStateUnkown, "Unkown");

//Usb Device States

_LIT(KEUsbDeviceStateUndefined,"Undefined");

_LIT(KEUsbDeviceStateDefault,"Default");

_LIT(KEUsbDeviceStateAttached,"Attached");

_LIT(KEUsbDeviceStatePowered,"Powered");

_LIT(KEUsbDeviceStateConfigured,"Configured");

_LIT(KEUsbDeviceStateAddress,"Address");

_LIT(KEUsbDeviceStateSuspended ,"Suspended");

//////////////////////////////////////////////////////////////////////////////

/**

Console shared by main routine and active objects.

*/

LOCAL_D CConsoleBase* console = NULL;

/**

File system resource shared by main routine and active objects.

*/

LOCAL_D RFs fs;

/**

Currently selected drive, index into PropertyHandlers' objects.

*/

LOCAL_D TInt selectedDriveIndex = 0;

/**

Command line text buffer, sufficiently large so that it will

hold any reasonable input.

*/

LOCAL_D TBuf<0x40> mountList;

static TFixedArray<TBool, KMaxDrives>                   msfsMountedList;  ///< 'true' entry corresponds to the drive with mounted MSFS.FSY

static TFixedArray<CFileSystemDescriptor*, KMaxDrives>  unmountedFsList;  ///< every non-NULL entry corresponds to the unmounted original FS for the drive

/**

*/

LOCAL_D TMediaPassword  password(KDefPwd);

//////////////////////////////////////////////////////////////////////////////

/**

Move cursor to row 'row', column 0.

Erase 'count' rows starting with 'row'.

*/

LOCAL_C void Clear(int row, int count=1)

	{

	_LIT(KBlank,"                                        ");

	for(TInt i=0; i<count; i++)

		{

		console->SetPos(0,row+i);

		console->Printf(KBlank);

		}

	console->SetPos(0,row);

	}

/**

Display the user's drive selection.

*/

LOCAL_C void ShowDriveSelection()

	{

	Clear(15);

	if(PropertyHandlers::allDrivesStatus.Length()/2 > selectedDriveIndex)

		{

		console->Printf(_L("Selected Drive: %c"),

					'A' + PropertyHandlers::allDrivesStatus[selectedDriveIndex*2]);

		}

	else

		{

		console->Printf(_L("Selected Drive: (none)"));

		}

	}

//-----------------------------------------------------------------------------

/**

    Tries to restore the original FS on the drive using the FS descriptor provided

    @return standard error code.

*/

LOCAL_C TInt DoRestoreFS(RFs& aFs, TInt aDrive, CFileSystemDescriptor* apFsDesc)

    {

    TInt nRes;

    RDebug::Print(_L("# DoRestoreFS drv:%d\n"), aDrive);

    //-- 1. check that there is no FS installed   

    TBuf<128>   fsName;

    nRes = aFs.FileSystemName(fsName, aDrive);

    if(nRes == KErrNone)

        {//-- probably no file system installed at all

        RDebug::Print(_L("# This drive already has FS intalled:%S \n"), &fsName);

        return KErrAlreadyExists;

        }

    TPtrC ptrN  (apFsDesc->FsName());

    TPtrC ptrExt(apFsDesc->PrimaryExtName());

    RDebug::Print(_L("# Mounting FS:%S, Prim ext:%S, synch:%d\n"), &ptrN, &ptrExt, apFsDesc->DriveIsSynch());

    if(ptrExt.Length() >0)

        {//-- there is a primary extension to be mounted

        nRes = aFs.AddExtension(ptrExt);

        if(nRes != KErrNone && nRes != KErrAlreadyExists)

            {

            return nRes;

            }

        nRes = aFs.MountFileSystem(ptrN, ptrExt, aDrive, apFsDesc->DriveIsSynch());

        }

    else

        {

        nRes = aFs.MountFileSystem(ptrN, aDrive, apFsDesc->DriveIsSynch());

        }

    if(nRes != KErrNone)

        {

        RDebug::Print(_L("# Mount failed! code:%d\n"),nRes);    

        }

    return nRes;

    }

//-----------------------------------------------------------------------------

/**

    Dismounts the originally mounted FS and optional primary extension from the drive and stores 

    this information in the FS descriptor

    @return on success returns a pointer to the instantinated FS descriptor

*/

LOCAL_C CFileSystemDescriptor* DoDismountOrginalFS(RFs& aFs, TInt aDrive)

    {

    TInt        nRes;

    TBuf<128>   fsName;

    TBuf<128>   primaryExtName;

    TBool       bDrvSync = EFalse;

    RDebug::Print(_L("# DoDismountOrginalFS drv:%d\n"), aDrive);

    //-- 1. get file system name

    nRes = aFs.FileSystemName(fsName, aDrive);

    if(nRes != KErrNone)

        {//-- probably no file system installed at all

        return NULL;

        }

    //-- 2. find out if the drive sync/async

    TPckgBuf<TBool> drvSyncBuf;

    nRes = aFs.QueryVolumeInfoExt(aDrive, EIsDriveSync, drvSyncBuf);

    if(nRes == KErrNone)

        {

        bDrvSync = drvSyncBuf();

        }

    //-- 3. find out primary extension name if it is present; we will need to add it againt when mounting the FS

    //-- other extensions (non-primary) are not supported yet

    nRes = aFs.ExtensionName(primaryExtName, aDrive, 0);

    if(nRes != KErrNone)

        {   

        primaryExtName.SetLength(0);

        }

    //-- 3.1 check if the drive has non-primary extensions, fail in this case, because this FS can't be mounted back normally

    nRes = aFs.ExtensionName(primaryExtName, aDrive, 1);

    if(nRes == KErrNone)

        {   

        RDebug::Print(_L("Non-primary extensions are not supported!\n"));

        return NULL;

        }

    RDebug::Print(_L("# DoDismountOrginalFS FS:%S, Prim ext:%S, synch:%d\n"), &fsName, &primaryExtName, bDrvSync);

    //-- create FS descriptor and dismount the FS

    CFileSystemDescriptor* pFsDesc = NULL; 

    TRAP(nRes, pFsDesc = CFileSystemDescriptor::NewL(fsName, primaryExtName, bDrvSync));

    if(nRes != KErrNone)

        return NULL; //-- OOM ?

    nRes = aFs.DismountFileSystem(fsName, aDrive);

    if(nRes != KErrNone)

        {

        delete pFsDesc;

        pFsDesc = NULL;

        RDebug::Print(_L("# DoDismountOrginalFS Dismounting Err:%d\n"), nRes);

        }

    return pFsDesc;

}

/**

Unmount FAT and mount MSFS.

@param driveNumber

*/

LOCAL_C void MountMsFs(TInt driveNumber)

	{

	TInt x = console->WhereX();

	TInt y = console->WhereY();

	Clear(11,2);

	RDebug::Print(_L("UsbMsExampleApp::MountMsFs driveNumber=%d\n"), driveNumber);

	//-- 1. try dismounting the original FS

    CFileSystemDescriptor* fsDesc = DoDismountOrginalFS(fs, driveNumber);

    unmountedFsList[driveNumber] = fsDesc; 

    if(fsDesc)

        {

        TPtrC ptrN(fsDesc->FsName());

        RDebug::Print(_L("drv:%d FS:%S Dismounted OK"),driveNumber, &ptrN);

	   	console->Printf(_L("%S Dismount %c: %S\n"), &ptrN, 'A' + driveNumber, &KOk);

        }

    else

        {

        RDebug::Print(_L("drv:%d Dismount FS Failed!"),driveNumber);

        }

    //-- 2. try to mount the "MSFS"

    TInt error;

    error = fs.MountFileSystem(KMsFs, driveNumber);

	RDebug::Print(_L("MSFS Mount:   %S (%d)"), (error?&KError:&KOk), error);

	if (!error)

		msfsMountedList[driveNumber] = ETrue;

	// restore console position

	console->Printf(_L("MSFS Mount %c:   %S (%d)"), 'A' + driveNumber, (error?&KError:&KOk), error);

	console->SetPos(x,y);

	}

/**

Unmount MSFS and mount FAT.

@param driveNumber

*/

LOCAL_C TInt RestoreMount(TInt driveNumber)

	{

	TInt err = KErrNone;

	TInt x = console->WhereX();

	TInt y = console->WhereY();

	Clear(11,2);

    //-- 1. try dismounting the "MSFS"

	if (msfsMountedList[driveNumber])

		{

		err = fs.DismountFileSystem(KMsFs, driveNumber);

		RDebug::Print(_L("MSFS Dismount:%S (%d)"), (err?&KError:&KOk), err);

		if (err)

			return err;

		msfsMountedList[driveNumber] = EFalse;

		console->Printf(_L("MSFS Dismount:%S (%d)\n"), (err?&KError:&KOk), err);

        }

    //-- 2. try to mount the original FS back

    CFileSystemDescriptor* fsDesc = unmountedFsList[driveNumber];

    if(fsDesc)

        {

        err = DoRestoreFS(fs, driveNumber, fsDesc);

        TPtrC ptrN(fsDesc->FsName());

        RDebug::Print(_L("%S Mount:    %S (%d)"), &ptrN, (err?&KError:&KOk), err);      

        delete fsDesc;

        unmountedFsList[driveNumber] = NULL;

       	console->Printf(_L("FAT Mount:    %S (%d)"), (err?&KError:&KOk), err);

        }

    // restore console position

	console->SetPos(x,y);

	return err;

	}

/**

Return a string description of the Drive Status

@param DriveStatus

@return a descriptor containing the description of the Drive Status

 */

LOCAL_C const TDesC& DriveStatusDescription(TInt & aDriveStatus)

  {

 	switch(aDriveStatus)

		{

		case EUsbMsDriveState_Disconnected:

			return KUsbMsDriveStateDisconnected;

		case EUsbMsDriveState_Connecting:

			return KUsbMsDriveStateConnecting;

		case EUsbMsDriveState_Connected:

			return KUsbMsDriveStateConnected;

		case EUsbMsDriveState_Disconnecting:

			return KUsbMsDriveStateDisconnecting;

		case EUsbMsDriveState_Active:

			return KUsbMsDriveStateActive;

		case EUsbMsDriveState_Locked:

			return KUsbMsDriveStateLocked;

		case EUsbMsDriveState_MediaNotPresent:

			return KUsbMsDriveStateMediaNotPresent;

		case EUsbMsDriveState_Removed:

			return KUsbMsDriveStateRemoved;

		case EUsbMsDriveState_Error:

			return KUsbMsDriveStateError;

		default :

			return KUsbMsDriveStateUnkown;

		}

  }

/**

Return a string description of the Usb Device State

@param aUsbState Usb Device State

@return the descriptor containing the device state description

 */

LOCAL_C const TDesC& UsbStateDescription(TUsbDeviceState& aUsbState)

  {

	switch(aUsbState)

		{

		case EUsbDeviceStateDefault:

			return KEUsbDeviceStateDefault;

		case EUsbDeviceStateAttached:

			return KEUsbDeviceStateAttached;

		case EUsbDeviceStatePowered:

			return KEUsbDeviceStatePowered;

		case EUsbDeviceStateConfigured:

			return KEUsbDeviceStateConfigured;

		case EUsbDeviceStateAddress:

			return KEUsbDeviceStateAddress;

 		case  EUsbDeviceStateSuspended:

			return KEUsbDeviceStateSuspended;

		case EUsbDeviceStateUndefined:

		default :

			return KEUsbDeviceStateUndefined;

		}

  }

//////////////////////////////////////////////////////////////////////////////

CPropertyWatch* CPropertyWatch::NewLC(TUsbMsDriveState_Subkey aSubkey, PropertyHandlers::THandler aHandler)

	{

	CPropertyWatch* me=new(ELeave) CPropertyWatch(aHandler);

	CleanupStack::PushL(me);

	me->ConstructL(aSubkey);

	return me;

	}

CPropertyWatch::CPropertyWatch(PropertyHandlers::THandler aHandler)

	: CActive(0), iHandler(aHandler)

	{}

void CPropertyWatch::ConstructL(TUsbMsDriveState_Subkey aSubkey)

	{

	User::LeaveIfError(iProperty.Attach(KUsbMsDriveState_Category, aSubkey));

	CActiveScheduler::Add(this);

	// initial subscription and process current property value

	RunL();

	}

CPropertyWatch::~CPropertyWatch()

	{

	Cancel();

	iProperty.Close();

	}

void CPropertyWatch::DoCancel()

	{

	iProperty.Cancel();

	}

void CPropertyWatch::RunL()

	{

	// resubscribe before processing new value to prevent missing updates

	iProperty.Subscribe(iStatus);

	SetActive();

	iHandler(iProperty);

	}

//////////////////////////////////////////////////////////////////////////////

CUsbWatch* CUsbWatch::NewLC(RUsb& aUsb)

	{

	CUsbWatch* me=new(ELeave) CUsbWatch(aUsb);

	CleanupStack::PushL(me);

	me->ConstructL();

	return me;

	}

CUsbWatch::CUsbWatch(RUsb& aUsb)

	:

	CActive(0),

	iUsb(aUsb),

	iUsbDeviceState(EUsbDeviceStateUndefined),

	iIsConfigured(EFalse)

	{}

void CUsbWatch::ConstructL()

	{

	CActiveScheduler::Add(this);

	RunL();

	}

CUsbWatch::~CUsbWatch()

	{

	Cancel();

	}

void CUsbWatch::DoCancel()

	{

	iUsb.DeviceStateNotificationCancel();

	}

static TBool IsDriveConnected(TInt driveStatusIndex)

	{

	TInt driveStatus = PropertyHandlers::allDrivesStatus[2*driveStatusIndex+1];

	return driveStatus == EUsbMsDriveState_Connected

		|| driveStatus >= EUsbMsDriveState_Active;

	}

static TChar DriveNumberToLetter(TInt driveNumber)

	{

	TChar driveLetter = '?';

	fs.DriveToChar(driveNumber, driveLetter);

	return driveLetter;

	}

static TBool IsDriveInMountList(TUint driveLetter)

	{

	TUint16 driveLetter16 = static_cast<TUint16>(driveLetter);

	return(!mountList.Length() || KErrNotFound != mountList.Find(&driveLetter16, 1));

	}

void CUsbWatch::RunL()

	{

	RDebug::Print(_L("CUsbWatch DeviceStateNotification: iUsbDeviceState=%d %s"), iUsbDeviceState, &UsbStateDescription(iUsbDeviceState));

	// If the cable is disconnected, unmount all the connected drives.

	if(iIsConfigured && (iUsbDeviceState == EUsbDeviceStateUndefined))

		{

		for(TInt i=0; i<PropertyHandlers::allDrivesStatus.Length()/2; i++)

			{

			if(IsDriveConnected(i))

				{

				RDebug::Print(_L("CUsbWatch calling UnmountMsFs"));

				RestoreMount(PropertyHandlers::allDrivesStatus[2*i]);

				}

			}

		iIsConfigured = EFalse;

		}

  	if(iUsbDeviceState == EUsbDeviceStateConfigured)

  		{

  		iIsConfigured = ETrue;

  		}

	const TUint stateMask = 0xFF;

	iUsb.DeviceStateNotification(stateMask, iUsbDeviceState, iStatus);

	SetActive();

	}

//////////////////////////////////////////////////////////////////////////////

TUsbMsDrivesStatus PropertyHandlers::allDrivesStatus;

TUsbMsBytesTransferred PropertyHandlers::iKBytesRead;