/*

* 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:

* Part of Base Test - F32 Test Suite

* SYMTestCaseID Cable_plug_unplug

* SYMTestCaseDesc Test mass storage system behavior on USB cable 

* plug-in/plug-out (automated integration test)

* To run the test, invoke

* t_usbms_cable_detect X

* where X is the appropriate mass storage drive letter.

* Notes: 

* - This test does not work on the emulator due to LDD requirements.

* - The USB cable must be connected to a host.

* Test sequence:

* - (USB/MS intialisation)

* - Wait for DriveStatus = Connecting

* - Dismount FAT, Mount MSFS

* - Wait for DriveStatus = Connected

* - Simulate cable disconnection

* - Wait for USB Status != Configured

* - Dismount MSFS, Mount FAT

* - Wait for DriveStatus = Disconnected

* - Simulate cable re-connection

* - Wait for DriveStatus = Connecting

* - Dismount FAT, Mount MSFS

* - Wait for DriveStatus = Connected

* - Simulate cable disconnection

* - Wait for USB Status != Configured

* - Dismount MSFS, Mount FAT

* - (USB/MS shutdown)

* This test program includes a 3 minute timeout to ensure that 

* it does not hang in case of failure.

*

*/

/**

 @file

 @publishedPartner

*/

// This test code is based on usbmsapp and shares its class declarations.

#include "../../../usbmsapp/usbmsapp.h"

#include <e32std.h>

#include <e32svr.h>

#include <f32file.h>

#include <usbman.h>

#include <e32test.h>

#include <d32usbc.h>

#include <usbmsshared.h>

_LIT(KTxtApp,"USBMSCABLEDETECT");

LOCAL_D RTest test(_L("USBMSCABLE"));

#ifndef __WINS__

_LIT(KMsFsy, "MSFS.FSY");

_LIT(KMsFs, "MassStorageFileSystem");

_LIT(KOk,"OK");

_LIT(KError,"Error");

LOCAL_D RFs fs;

LOCAL_D RDevUsbcClient ldd;

LOCAL_D TDriveNumber selectedDriveNumber = EDriveA;

LOCAL_D TInt selectedDriveIndex = -1;

LOCAL_D TFileName gOldFileSysName;

LOCAL_C void MountMsFs(RUsb& aUsb, TInt driveNumber)

	{

	test.Printf(_L("MountMsFs driveNumber=%d\n"), driveNumber); 

	TInt error = fs.FileSystemName(gOldFileSysName, driveNumber);

	test(error==KErrNone);

    error = fs.DismountFileSystem(gOldFileSysName, driveNumber);

   	test.Printf(_L("%S Dismount %c: %S (%d)\n"), &gOldFileSysName,

	   		'A' + driveNumber, (error?&KError:&KOk), error);

	error = fs.MountFileSystem(KMsFs, driveNumber);

	test.Printf(_L("MSFS Mount %c:   %S (%d)"), 

		'A' + driveNumber, (error?&KError:&KOk), error);

	if(error!=KErrNone)

		{

		test.Printf(_L("Failed to mount Mass Storage (%d), shutting down.\n"), error); 

		TRequestStatus status;

		aUsb.TryStop(status);

		User::WaitForRequest(status);

		test(false);

		}

	}

LOCAL_C void UnmountMsFs(RUsb& aUsb, TInt driveNumber)

	{

	test.Printf(_L("UnmountMsFs driveNumber=%d\n"), driveNumber); 

	TInt error = fs.DismountFileSystem(KMsFs, driveNumber);

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

	if(error!=KErrNone)

		{

		test.Printf(_L("Failed to dismount Mass Storage (%d), shutting down.\n"), error); 

		TRequestStatus status;

		aUsb.TryStop(status);

		User::WaitForRequest(status);

		test(false);

		}

	error = fs.MountFileSystem(gOldFileSysName, driveNumber);

   	test.Printf(_L("%S Mount:    %S (%d)\n"), 

   				&gOldFileSysName, (error?&KError:&KOk), error);

	}

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

//

// 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(CActive::EPriorityStandard), 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()

	{

	iHandler(iProperty);

	iProperty.Subscribe(iStatus);

	SetActive();

	}

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

//

// CUsbWatch

//

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

CUsbWatch* CUsbWatch::NewLC(RUsb& aUsb)

	{

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

	CleanupStack::PushL(me);

	me->ConstructL();

	return me;

	}

CUsbWatch::CUsbWatch(RUsb& aUsb)

	: 

	CActive(CActive::EPriorityStandard), 

	iUsb(aUsb),

	iUsbDeviceState(EUsbDeviceStateUndefined)

	{}

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;

	}

void CUsbWatch::RunL()

	{

	static TBool done = EFalse;

	test.Printf(_L("CUsbWatch DeviceStateNotification: status=%d state=%d\n"), 

						iStatus.Int(), iUsbDeviceState);

	if(iUsbDeviceState != EUsbDeviceStateConfigured)

		{

		// note this may be called before selectedDriveIndex is initialised

		if(selectedDriveIndex!=-1 && IsDriveConnected(selectedDriveIndex))

			{

			test.Printf(_L("CUsbWatch calling UnmountMsFs\n"));

			UnmountMsFs(iUsb, selectedDriveNumber);	

			// stop only the second time we get here

			if(done) CActiveScheduler::Stop();

			done = ETrue;

			}

		}

	else

		{

		if(selectedDriveIndex!=-1 && !IsDriveConnected(selectedDriveIndex))

			{

			test.Printf(_L("CUsbWatch calling MountMsFs\n"));

			MountMsFs(iUsb, selectedDriveNumber);	

			}

		}

	const TUint stateMask = 0xFF;

	iUsb.DeviceStateNotification(stateMask, iUsbDeviceState, iStatus);

	SetActive();

	}

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

//

// PropertyHandlers (declared in usbmsapp.h)

//

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

// Unused members

TUsbMsBytesTransferred PropertyHandlers::iKBytesRead;

TUsbMsBytesTransferred PropertyHandlers::iKBytesWritten;

void PropertyHandlers::Read(RProperty& ) {}

void PropertyHandlers::Written(RProperty& ) {}

void PropertyHandlers::Transferred(RProperty& , TUsbMsBytesTransferred& ) {}

TUsbMsDrivesStatus PropertyHandlers::allDrivesStatus;

void PropertyHandlers::DriveStatus(RProperty& aProperty)

	{

	static TBool hasBeenConnected = EFalse;

	static TInt lastSelectedDriveStatus = -1;

	TInt err = aProperty.Get(allDrivesStatus);

	if(err == KErrNone)

		{

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

			{

			TInt driveNumber = allDrivesStatus[2*i];

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

			TUint16 driveLetter = static_cast<TUint16>(driveNumber-EDriveA+'A');

			test.Printf(_L("PropertyHandlers::DriveStatus: drive %c: = %d\n"), 

						driveLetter, driveStatus);

			if(driveNumber == selectedDriveNumber)

				{

				selectedDriveIndex = i;

				if(driveStatus != lastSelectedDriveStatus)

				switch(driveStatus)

					{

					case EUsbMsDriveState_Connecting:

						test.Printf(_L("EUsbMsDriveState_Connecting: don't care\n"));

						break;

					case EUsbMsDriveState_Disconnecting:

						test.Printf(_L("EUsbMsDriveState_Disconnecting: don't care\n"));

						break;

					case EUsbMsDriveState_Disconnected:

						if(hasBeenConnected)

							{

							test.Printf(_L("EUsbMsDriveState_Disconnected: connecting cable (DeviceConnectToHost)\n"));

							test(KErrNone == ldd.DeviceConnectToHost());

							}

						break;

					case EUsbMsDriveState_Connected:

					case EUsbMsDriveState_Active:

					case EUsbMsDriveState_Locked:

						hasBeenConnected = ETrue;

						test.Printf(_L("DriveStatus: disconnecting cable (DeviceDisconnectFromHost)\n"));

						test(KErrNone == ldd.DeviceDisconnectFromHost());

						break;

					default:

						test.Printf(_L("DriveStatus: Error or media removed\n"));

						test(false);

					}

				lastSelectedDriveStatus = driveStatus;

				break; // found the drive

				}

			}

		}

	else

		{

		test.Printf(_L("DriveStatus error=%d\n"), err);

		test(false);

		}

	}

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

//

// Timeout, to ensure test doesn't hang

//

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

class CTimeout : public CTimer

	{

public:

	static CTimeout* NewLC()

		{

		CTimeout* self = new (ELeave) CTimeout;

		CleanupStack::PushL(self);

		self->ConstructL();

		return self;

		}

protected:

	void ConstructL()

		{

		CTimer::ConstructL();

		CActiveScheduler::Add(this);

		After(180*1000*1000);

		}

	CTimeout() : CTimer(0) 

		{

		}

	void RunL() 

		{

		test.Printf(_L("Test did not complete within timeout period.\n"));

		test(false);

		}

	void DoCancel() 

		{

		}

	};

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

//

// Application entry point

//

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

LOCAL_C void RunAppL()

	{

    TInt error = KErrUnknown;

	TRequestStatus status;

	// Command line: the massstorage drive letter

	TBuf<0x40> cmdLine;

	User::CommandLine(cmdLine);

	cmdLine.UpperCase();

	if(cmdLine.Length() != 1 

		|| cmdLine[0] < 'A'

		|| cmdLine[0] > 'Z')

		{

		test.Printf(_L("You must specify a drive [A-Z|a-z] on the command line\n"));

		test(false);

		}

	selectedDriveNumber = (TDriveNumber)(cmdLine[0] - 'A');

	test.Printf(_L("Selected drive: %S\n"), &cmdLine);

	CActiveScheduler* sched = new(ELeave) CActiveScheduler;

	CleanupStack::PushL(sched);

	CActiveScheduler::Install(sched);

	// Ensure test cannot hang

	CTimeout::NewLC();

	test(KErrNone==fs.Connect());

	CleanupClosePushL(fs);

	// Add MS file system

	error = fs.AddFileSystem(KMsFsy);

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

		{

		test.Printf(_L("AddFileSystem failed, err=%d\n"), error);

		User::Leave(error);

		}

   	test.Printf(_L("MSFS file system: Added OK\n"));

	RUsb usb;

	error = usb.Connect();

	User::LeaveIfError(error);

	CleanupClosePushL(usb);

    // Find the personality that supports the massstorage UID

	TInt personalityId=-1;

	RArray<TInt> personalityIds;

	usb.GetPersonalityIds(personalityIds);

	for (TInt i=0; i < personalityIds.Count(); i++)

	    {

    	TBool supported=EFalse;

        usb.ClassSupported(personalityIds[i], KUsbMsClassControllerUID, supported);

        HBufC* localizedPersonalityDescriptor;

        usb.GetDescription(personalityIds[i],localizedPersonalityDescriptor);

        test.Printf(_L("USB Class Controller id=%d - '%S'\n"), 

        	personalityIds[i], localizedPersonalityDescriptor);

        if(supported)

        	{

        	personalityId = personalityIds[i];	

        	}

        delete localizedPersonalityDescriptor;

		}

	personalityIds.Close();

	if(personalityId != -1)

		{

		usb.TryStart(personalityId, status);

		User::WaitForRequest(status);

		test(KErrNone == status.Int());

		TUsbServiceState currentState;

		test(KErrNone == usb.GetServiceState(currentState));

		if(EUsbServiceStarted != currentState)

			{

			test.Printf(_L("USB Service did not start\n"));

			test(false);

			}

		test.Printf(_L("USB Service Started, personality id=%d\n"), personalityId);

		}

	else

		{

		test.Printf(_L("USB: USBMS personality 10204bbc not found\n"));

		test(false);

		}

	error = ldd.Open(0);

    test(KErrNone == error);	

	CleanupClosePushL(ldd);

	CPropertyWatch::NewLC(EUsbMsDriveState_DriveStatus, PropertyHandlers::DriveStatus);

	CUsbWatch::NewLC(usb);

	CActiveScheduler::Start();

	usb.TryStop(status);

	User::WaitForRequest(status);

	test.Printf(_L("USB TryStop returned %d\n"), status.Int());

	error = fs.RemoveFileSystem(KMsFs);

	test.Printf(_L("RemoveFileSystem returned %d\n"), error);

	CleanupStack::PopAndDestroy();	// CUsbWatch

	CleanupStack::PopAndDestroy();	// CPropertyWatch

	CleanupStack::PopAndDestroy(&ldd);

	CleanupStack::PopAndDestroy(&usb);

	CleanupStack::PopAndDestroy(&fs);

	CleanupStack::PopAndDestroy();	// CTimeout

	CleanupStack::PopAndDestroy(sched);

	}

#endif //__WINS__

GLDEF_C TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup=CTrapCleanup::New();

	test.Start(KTxtApp);

#ifdef __WINS__

	test.Printf(_L("This test cannot be run on WINS.\n"));

#else

	TRAPD(error, RunAppL());

	if (error) 

		{

		test.Printf(_L("Leave occurred; code=%d\n"), error);

		test(false);

		}

#endif //__WINS__

	test.End();	// output success/fail

	test.Close();

	delete cleanup;

	__UHEAP_MARKEND;

	return 0;

	}