// Copyright (c) 2006-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

 // 

 //

 /**

  @file

 */

 #include "general.h"

 #include "config.h"

 #include "activecontrol.h"

 #include <usbmsshared.h>

 #include <massstorage.h>

 #include "usbms.h"

 extern CActiveControl* gActiveControl;

 extern RTest test;

 extern TBool gVerbose;

 extern TBool gSkip;

 extern TBool gTempTest;

 LOCAL_D RFs fs;

 LOCAL_D TBuf<0x40> mountList;

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

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

 LOCAL_D RUsbMassStorage UsbMs;

 LOCAL_D CUsbWatch * usbWatch;

 static const TUint KNumPropWatch = 4;

 LOCAL_D CPropertyWatch * propWatch[KNumPropWatch];

 _LIT(KMsFsy, "MSFS.FSY");

 _LIT(KMsFs, "MassStorageFileSystem");

 _LIT(KOk,"OK");

 _LIT(KError,"Error");

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

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

 _LIT(KConfigured,"Configured");

 _LIT(KNotConfigured,"NOT Configured");

 _LIT8(KDefPwd,"123");

 TMediaPassword  password(KDefPwd);

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

 CFileSystemDescriptor::~CFileSystemDescriptor()

     {

     iFsName.Close();

     iPrimaryExtName.Close();

     }

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

 CFileSystemDescriptor* CFileSystemDescriptor::NewL(const TDesC& aFsName, const TDesC& aPrimaryExtName, TBool aDrvSynch)

     {

     CFileSystemDescriptor* pSelf = new (ELeave) CFileSystemDescriptor;

     CleanupStack::PushL(pSelf);

     pSelf->iFsName.CreateMaxL(aFsName.Length());

     pSelf->iFsName.Copy(aFsName);

     pSelf->iPrimaryExtName.CreateMaxL(aPrimaryExtName.Length());

     pSelf->iPrimaryExtName.Copy(aPrimaryExtName);

     pSelf->iDriveSynch = aDrvSynch;

     CleanupStack::Pop();

     return pSelf;

     }

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

 /**

     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;

     test.Printf(_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)

         {   

         test.Printf(_L("DoDismountOrginalFS Non-primary extensions are not supported!\n"));

         return NULL;

         }

     test.Printf(_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;

         test.Printf(_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.

 */

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

     {

     TInt nRes;

     test.Printf(_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)

         {//-- there is a file system already installed

 		test.Printf(_L("DoRestoreFS This drive already has FS intalled:%S \n"), &fsName);

         return KErrAlreadyExists;

         }

     TPtrC ptrN  (apFsDesc->FsName());

     TPtrC ptrExt(apFsDesc->PrimaryExtName());

     test.Printf(_L("DoRestoreFS 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)

         {

         test.Printf(_L("DoRestoreFS Mount failed! code:%d\n"),nRes);    

         }

     return nRes;

     }

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

 /**

     Dismount the original FS from the drive and mount MsFS instead

 */

 LOCAL_C void MountMsFs(TInt driveNumber)

 	{

 	test.Printf(_L("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());

         test.Printf(_L("drv:%d FS:%S Dismounted OK\n"),driveNumber, &ptrN);

         }

     else

         {

         test.Printf(_L("drv:%d Dismount FS Failed!\n"),driveNumber);

         }

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

     TInt error;

     error = fs.MountFileSystem(KMsFs, driveNumber);

 	test.Printf(_L("MSFS Mount:   %S (%d)\n"), (error?&KError:&KOk), error);

 	if (!error)

 		msfsMountedList[driveNumber] = ETrue;

 	}

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

 /**

     Dismount MsFS and mount the original FS 

 */

 LOCAL_C TInt RestoreMount(TInt driveNumber)

 	{

 	TInt err = KErrNone;

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

 	if (msfsMountedList[driveNumber])

 		{

 		err = fs.DismountFileSystem(KMsFs, driveNumber);

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

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

         test.Printf(_L("%S Mount:    %S (%d)\n"), &ptrN, (err?&KError:&KOk), err);

         delete fsDesc;

         unmountedFsList[driveNumber] = NULL;

         }

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

 	CleanupStack::Pop();

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

 	CleanupStack::Pop();

 	return me;

 	}

 CUsbWatch::CUsbWatch(RUsb& aUsb)

 	: 

 	CActive(0), 

 	iUsb(aUsb),

 	iUsbDeviceState(EUsbcDeviceStateUndefined),

 	iWasConfigured(EFalse)

 	{}

 void CUsbWatch::ConstructL()

 	{

 	CActiveScheduler::Add(this);

 	RunL();

 	}

 CUsbWatch::~CUsbWatch()

 	{

 	Cancel();

 	iUsb.AlternateDeviceStatusNotifyCancel();

 	}

 void CUsbWatch::DoCancel()

 	{

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

 	{

 	gActiveControl->SetMSFinished(EFalse);

 	if (gVerbose)

 		{

 		switch (iUsbDeviceState)

 			{

 			case EUsbcDeviceStateUndefined : 					// 0

 				test.Printf(_L(">> CUSBWatch:Undefined %S\n"), iWasConfigured ? &KConfigured : &KNotConfigured);

 				break;

 			case EUsbcDeviceStateAttached :						// 1

 				test.Printf(_L(">> CUSBWatch:Attached %S\n"), iWasConfigured ? &KConfigured : &KNotConfigured);

 				break;

 			case EUsbcDeviceStatePowered :						// 2

 				test.Printf(_L(">> CUSBWatch:Powered %S\n"), iWasConfigured ? &KConfigured : &KNotConfigured);

 				break;

 			case EUsbcDeviceStateDefault :						// 3

 				test.Printf(_L(">> CUSBWatch:Default %S\n"), iWasConfigured ? &KConfigured : &KNotConfigured);

 				break;

 			case EUsbcDeviceStateAddress :						// 4

 				test.Printf(_L(">> CUSBWatch:Address %S\n"), iWasConfigured ? &KConfigured : &KNotConfigured);

 				break;

 			case EUsbcDeviceStateConfigured :					// 5

 				test.Printf(_L(">> CUSBWatch:Configured %S\n"), iWasConfigured ? &KConfigured : &KNotConfigured);

 				break;

 			case EUsbcDeviceStateSuspended : 					// 6

 				test.Printf(_L(">> CUSBWatch:Suspended %S\n"), iWasConfigured ? &KConfigured : &KNotConfigured);

 				break;

 			default :

 				test.Printf(_L(">> CUSBWatch:UNKNOWN %S\n"), iWasConfigured ? &KConfigured : &KNotConfigured);

 				break;

 			}

 		}

 	iUsb.AlternateDeviceStatusNotify(iStatus, iUsbDeviceState);

 	SetActive();

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

 	if(iWasConfigured && iUsbDeviceState == EUsbcDeviceStateUndefined)

 		{

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

 			{

 			if(IsDriveConnected(i))

 				{

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

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

 				}

 			}

 		iWasConfigured = EFalse;

 		}

 	// If cable is connected, mount all drives in the auto-mount list.

 	// This is done for performance, since if this is not done here,

 	// mounting will happen later after each drive enters the 

 	// Connecting state.

 	if(iUsbDeviceState == EUsbcDeviceStateConfigured)

 		{

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

 			{

 			TInt driveNumber = PropertyHandlers::allDrivesStatus[2*i];

 			if(!IsDriveConnected(i) && IsDriveInMountList(DriveNumberToLetter(driveNumber)))

 				{

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

 				MountMsFs(driveNumber);

 				}

 			}

 		iWasConfigured = ETrue;

 		}

 	}

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

 //

 // PropertyHandlers

 //

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

 TBuf8<16> PropertyHandlers::allDrivesStatus;

 TUsbMsBytesTransferred PropertyHandlers::iKBytesRead;

 TUsbMsBytesTransferred PropertyHandlers::iKBytesWritten;

 TInt PropertyHandlers::iMediaError;

 void PropertyHandlers::Read(RProperty& aProperty)

 	{

 	Transferred(aProperty, iKBytesRead);

 	}

 void PropertyHandlers::Written(RProperty& aProperty)

 	{

 	Transferred(aProperty, iKBytesWritten);

 	}

 void PropertyHandlers::Transferred(RProperty& aProperty, TUsbMsBytesTransferred& aReadOrWritten)

 	{

 	TInt err = aProperty.Get(aReadOrWritten);

 	if(err == KErrNone)

 		{

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

 			{

 			if (gVerbose)

 				{

 				test.Printf(KBytesTransferredFmt, 

 						(char)DriveNumberToLetter(allDrivesStatus[2*i]), iKBytesRead[i], iKBytesWritten[i]);

 				}

 			}

 		}

 	else

 		{

 		test.Printf(KErrFmt, err);

 		}

 	}

 void PropertyHandlers::DriveStatus(RProperty& aProperty)

 	{

 	if (gVerbose)

 		{

 		test.Printf(_L(">> PropertyHandlers::DriveStatus"));

 		}

 	TInt err = aProperty.Get(allDrivesStatus);

 	if(err == KErrNone)

 		{

 		if (gVerbose)

 			{

 			test.Printf(_L(" Status:  "));

 			}

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

 			{

 			TInt driveNumber = allDrivesStatus[2*i];

 			TInt driveStatus = allDrivesStatus[2*i+1];

 			TChar driveLetter = DriveNumberToLetter(driveNumber);

 			if (gVerbose)

 				{

 				switch(driveStatus)

 					{

 					case EUsbMsDriveState_Disconnected:

 						{

 						test.Printf(_L("%c:%d:Disconnected\n"), (char)driveLetter, driveStatus);

 						break;

 						}

 					case EUsbMsDriveState_Connecting:

 						{

 						test.Printf(_L("%c:%d:Connecting\n"), (char)driveLetter, driveStatus);

 						break;

 						}

 					case EUsbMsDriveState_Connected:

 						{

 						test.Printf(_L("%c:%d:Connected\n"), (char)driveLetter, driveStatus);

 						break;

 						}

 					case EUsbMsDriveState_Disconnecting:

 						{

 						test.Printf(_L("%c:%d:Disconnecting\n"), (char)driveLetter, driveStatus);

 						break;

 						}

 					case EUsbMsDriveState_Active:

 						{

 						test.Printf(_L("%c:%d:Active\n"), (char)driveLetter, driveStatus);

 						break;

 						}

 					case EUsbMsDriveState_Locked:

 						{

 						test.Printf(_L("%c:%d:Locked\n"), (char)driveLetter, driveStatus);

 						break;

 						}

 					case EUsbMsDriveState_MediaNotPresent:

 						{

 						test.Printf(_L("%c:%d:Not Present\n"), (char)driveLetter, driveStatus);

 						break;

 						}

 					case EUsbMsDriveState_Removed:

 						{

 						test.Printf(_L("%c:%d:Removed\n"), (char)driveLetter, driveStatus);

 						break;

 						}

 					case EUsbMsDriveState_Error:

 						{

 						test.Printf(_L("%c:%d:Error\n"), (char)driveLetter, driveStatus);

 						break;

 						}

 					default :

 						{

 						test.Printf(_L("%c:%d:Unknown\n"), (char)driveLetter, driveStatus);

 						break;

 						}

 					}

 				}

 			if (driveStatus == EUsbMsDriveState_Connected)

 				{

 				gActiveControl->SetMSFinished(EFalse);				

 				}

 			if (driveStatus == EUsbMsDriveState_Disconnected)

 				{

 				gActiveControl->SetMSFinished(ETrue);				

 				}

 			if(IsDriveInMountList(driveLetter))

 				{

 				if (driveStatus == EUsbMsDriveState_Connecting)

 					{

 					MountMsFs(driveNumber);

 					}

 				else if (driveStatus == EUsbMsDriveState_Disconnecting)

 					{

 					RestoreMount(driveNumber);

 					}

 				else

 					{

 					//RDebug::Print(_L("PropertyHandlers::DriveStatus: nothing to do"));

 					}

 				}

 			else

 				{

 				//RDebug::Print(_L("PropertyHandlers::DriveStatus: %c: is not in mountList\n"), driveLetter);

 				}

 			}

 		}

 	else

 		{

 		test.Printf(KErrFmt, err);

 		}

 	}

 void PropertyHandlers::MediaError(RProperty& aProperty)

 	{

 	TInt r = aProperty.Get(iMediaError);

 	if(r != KErrNone)

 		{

 		return;

 		}

 	test.Printf(_L("Media Error %x\n"), iMediaError);

 	if (iMediaError > 0)

 		{

 		gActiveControl->SetMSFinished(ETrue);

 		}

 	}

 void StartMassStorage(RDEVCLIENT* aPort)

 	{

     TInt r = KErrUnknown;

 	test.Start (_L("Start Mass Storage"));

 	fs.Connect();

 	// Add MS file system

 	test.Next (_L("Add MS File System"));

 	r = fs.AddFileSystem(KMsFsy);

 	test(r == KErrNone || r == KErrAlreadyExists);

 #ifdef USB_SC

 	aPort->FinalizeInterface();

 #endif

 	test.Next (_L("Create active objects\n"));

 	propWatch[0] = CPropertyWatch::NewLC(EUsbMsDriveState_KBytesRead, PropertyHandlers::Read);

 	propWatch[1] = CPropertyWatch::NewLC(EUsbMsDriveState_KBytesWritten, PropertyHandlers::Written);

 	propWatch[2] = CPropertyWatch::NewLC(EUsbMsDriveState_DriveStatus, PropertyHandlers::DriveStatus);

 	propWatch[3] = CPropertyWatch::NewLC(EUsbMsDriveState_MediaError, PropertyHandlers::MediaError);

 	usbWatch = CUsbWatch::NewLC(*aPort);

 	TBuf<8>  t_vendorId(_L("vendor"));

 	TBuf<16> t_productId(_L("product"));

 	TBuf<4>  t_productRev(_L("1.00"));

 	TMassStorageConfig msConfig;

 	msConfig.iVendorId.Copy(t_vendorId);

 	msConfig.iProductId.Copy(t_productId);

 	msConfig.iProductRev.Copy(t_productRev);

  	test.Next(_L("Connect to Mass Storage"));

 	r = UsbMs.Connect();

 	test_KErrNone (r);

 	test.Next(_L("Start Mass Storage"));

 	r = UsbMs.Start(msConfig);

 	test_KErrNone (r);

 	test.End();

 	}

 void StopMassStorage(RDEVCLIENT* aPort)

 	{

     TInt r = KErrUnknown;

 	test.Start (_L("Stop Mass Storage"));

 	r = UsbMs.Stop();

 	test_KErrNone (r);

 	UsbMs.Close();

 	for (TInt driveNumber = 0; driveNumber < KMaxDrives; driveNumber++)

 		{

 		if (msfsMountedList[driveNumber])

 			{

 			r = fs.DismountFileSystem(KMsFs, driveNumber);

 			test_KErrNone (r);

 			msfsMountedList[driveNumber] = EFalse;

 			}

 		}

 	r = fs.RemoveFileSystem(KMsFs);

 	test_KErrNone (r);

 	fs.Close();

 	delete usbWatch;

 	for (TUint i =0; i < KNumPropWatch; i++)

 		{

 		delete propWatch[i];

 		}

 	aPort->Close();

 	test.End();

 	}