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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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 Application - also used as an improvised boot loader mechanism

// 

//

/**

 @file

*/

#include "usbtestclient.h"

#include <e32std.h>

#include <e32svr.h>

#include <e32cons.h>

#include <usbmsshared.h>

#include <d32usbc.h>

#include <d32otgdi.h>

#include <nkern/nk_trace.h>

#include <hal.h>

#include "rusbmassstorage.h"

enum

	{

	EUsbDeviceStateUndefined  = EUsbcDeviceStateUndefined,

	EUsbDeviceStateConfigured = EUsbcDeviceStateConfigured,

	};

static CConsoleBase* console = NULL;

static RFs fs;

static TInt selectedDriveIndex = 0;

static 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

_LIT(KMsFsy, "USBTESTMSCLIENT.FSY");

_LIT(KMsFs, "MassStorageFileSystem");

_LIT(KOk,"OK");

_LIT(KError,"Error");

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

_LIT(KErrFmt, "Error: %d\r");

_LIT(KTxtApp,"USB TEST CLIENT");

_LIT(KDefPwd,"123");

//-- if defined, some useful information will be printed out via RDebug interface

//#define LOGGING_ENABLED

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

/**

    prints a line to the console and copies it to the debug log if LOGGING_ENABLED

*/

void LogPrint(TRefByValue<const TDesC> aFmt,...)

    {

    VA_LIST list;

    VA_START(list, aFmt);

    TBuf<0x100> buf;

    buf.FormatList(aFmt, list); //-- ignore overflows

    if(console)

        console->Write(buf);

#ifdef LOGGING_ENABLED

    //-- print out the line via RDebug::Print

    const TInt bufLen = buf.Length();

    if(bufLen >0 && buf[bufLen-1] == '\n')

        {

        buf.Insert(bufLen-1, _L("\r"));

        }

    else

        {

        buf.Append(_L("\r\n"));

        }

    RDebug::RawPrint(buf);

#endif

    }

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

/**

    prints a line to the debug log if LOGGING_ENABLED

*/

void Log(TRefByValue<const TDesC> aFmt,...)

    {

#ifdef LOGGING_ENABLED

    VA_LIST list;

    VA_START(list, aFmt);

    TBuf<0x100> buf;

    buf.FormatList(aFmt, list); //-- ignore overflows

    //-- print out the line via RDebug::Print

    const TInt bufLen = buf.Length();

    if(bufLen >0 && buf[bufLen-1] == '\n')

        {

        buf.Insert(bufLen-1, _L("\r"));

        }

    RDebug::RawPrint(buf);

#else

    (void)aFmt;

#endif

    }

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

static 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);

	}

static void ShowDriveSelection()

	{

	console->SetPos(0,15);

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

		{

		LogPrint(_L("Selected Drive: %c"), 'A' + PropertyHandlers::allDrivesStatus[selectedDriveIndex*2]);

		}

	else

		{

		LogPrint(_L("Selected Drive: (none)"));

		}

	}

class CPeriodUpdate : public CActive

	{

public:

	static CPeriodUpdate* NewLC();

private:

	CPeriodUpdate();

	void ConstructL();

	~CPeriodUpdate();

	void RunL();

	void DoCancel();

	RTimer iTimer;

	TUint iUpTime;

	};

CPeriodUpdate* CPeriodUpdate::NewLC()

	{

	CPeriodUpdate* me=new(ELeave) CPeriodUpdate();

	CleanupStack::PushL(me);

	me->ConstructL();

	return me;

	}

CPeriodUpdate::CPeriodUpdate()

	: CActive(0), iUpTime(0)

	{}

void CPeriodUpdate::ConstructL()

	{

	CActiveScheduler::Add(this);

	iTimer.CreateLocal();

	RunL();

	}

CPeriodUpdate::~CPeriodUpdate()

	{

	Cancel();

	}

void CPeriodUpdate::DoCancel()

	{

	}

void CPeriodUpdate::RunL()

	{

	SetActive();

	// Print RAM usage & up time

	iUpTime++;

	TUint totmins=(iUpTime/60);

	TUint tothrs=(totmins/60);

	TInt mem=0;

	if (HAL::Get(HALData::EMemoryRAMFree, mem)==KErrNone)

		{

		console->SetPos(0,22);

		console->Printf(_L("mem (bytes) : %d\n"), mem);

		console->Printf(_L("up time     : %dh:%dm:%ds\n"),

					tothrs, totmins%60, iUpTime%60);

		}

	iTimer.After(iStatus, 1000000);

	}

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

/**

    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

*/

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

    {

    TInt        nRes;

    TBuf<128>   fsName;

    TBuf<128>   primaryExtName;

    TBool       bDrvSync = EFalse;

    Log(_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)

        {

        LogPrint(_L("Non-primary extensions are not supported!\n"));

        return NULL;

        }

    Log(_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;

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

        }

    return pFsDesc;

}

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

/**

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

    @return standard error code.

*/

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

    {

    TInt nRes;

    Log(_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

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

            return KErrAlreadyExists;

            }

        }

    TPtrC ptrN  (apFsDesc->FsName());

    TPtrC ptrExt(apFsDesc->PrimaryExtName());

    Log(_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)

        {

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

        }

    return nRes;

    }

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

/**

    Dismount the original FS from the drive and mount MsFS instead

*/

static void MountMsFs(TInt driveNumber)

	{

	TInt x = console->WhereX();

	TInt y = console->WhereY();

    //-- 1. try dismounting the original FS

    CFileSystemDescriptor* fsDesc = DoDismountOrginalFS(fs, driveNumber);

    unmountedFsList[driveNumber] = fsDesc;

    console->SetPos(0, 10);

    if(fsDesc)

        {

        TPtrC ptrN(fsDesc->FsName());

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

        }

    else

        {

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

        }

    console->ClearToEndOfLine();

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

    TInt error;

    error = fs.MountFileSystem(KMsFs, driveNumber);

	console->SetPos(0, 11);

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

	console->ClearToEndOfLine();

	if (!error)

		msfsMountedList[driveNumber] = ETrue;

	// restore console position

	console->SetPos(x,y);

	}

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

/**

    Dismount MsFS and mount the original FS

*/

static TInt RestoreMount(TInt driveNumber)

	{

	TInt err = KErrNone;

	TInt x = console->WhereX();

	TInt y = console->WhereY();

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

	if (msfsMountedList[driveNumber])

		{

		err = fs.DismountFileSystem(KMsFs, driveNumber);

		console->SetPos(0, 11);

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

		console->ClearToEndOfLine();

		if (err)

			return err;

		msfsMountedList[driveNumber] = EFalse;

        }

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

    CFileSystemDescriptor* fsDesc = unmountedFsList[driveNumber];

    if(fsDesc)

        {

        err = DoRestoreFS(fs, driveNumber, fsDesc);

        TPtrC ptrN(fsDesc->FsName());

        console->SetPos(0, 10);

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

        console->ClearToEndOfLine();

        delete fsDesc;

        unmountedFsList[driveNumber] = NULL;

        }

    // restore console position

	console->SetPos(x,y);

	return err;

	}

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

//

// CPropertyWatch

// An active object that tracks changes to the KUsbMsDriveState properties

//

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

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* 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),

	iWasConfigured(EFalse)

	{}

void CUsbWatch::ConstructL()

	{

	CActiveScheduler::Add(this);

	RunL();

	}

CUsbWatch::~CUsbWatch()

	{

	Cancel();

//	iUsb.DeviceStateNotificationCancel();

	iUsb.AlternateDeviceStatusNotifyCancel();

	}

void CUsbWatch::DoCancel()

	{

//	iUsb.DeviceStateNotificationCancel();

	iUsb.AlternateDeviceStatusNotifyCancel();

	}

static TBool IsDriveConnected(TInt driveStatusIndex)

	{

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

	return driveStatus >= EUsbMsDriveState_Connected ? ETrue : EFalse;

	}

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[%d] %d"), iUsbDeviceState, iWasConfigured);