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

//

/**

 @file

 @internalTechnology

*/

#include <f32file.h>

#include <e32test.h>

#include <f32fsys.h>

#include <e32std.h>

#include <e32std_private.h>		// Caps.iMediaAtt

#include "massstoragedebug.h"

#include "t_ms_main.h"

#include "t_ms_scsi.h"

#include "drivepublisher.h"

//

//	TTestScsiTransport

//

/** c'tor */

TTestScsiTransport::TTestScsiTransport ()

: iProtocol(NULL),

  iBufWrite(NULL, 0)

	{

	}

/** InitialiseReadBuf */

void TTestScsiTransport::InitialiseReadBuf ()

	{

	// KMaxBufSize is defined in scsiprot.h

	iBufRead.FillZ(KMaxBufSize * 2);

	// set some values in 1/2 a buffer for testing

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

		{

		iBufRead[i] = static_cast<TInt8>(i%0x08);

		}

	}

//

//	CTestMassStorageDrive

//

/**

@param aOwner A reference to the drive manager, for use with aDriveStateChanged.

@param aDriveStateChanged A pointer to the private callback function CDriveManager::DriveStateChanged.

@param aCritSec A Critical Section object shared by all drives.

@post Object is fully constructed

 */

CMassStorageDrive::CMassStorageDrive(

	RCriticalSection& aCritSec,

	RDriveStateChangedPublisher& aDriveStateChangedPublisher)

	: 

	iCritSec(aCritSec),

	iMountState(EDisconnected),

	iDriveStateChangedPublisher(aDriveStateChangedPublisher)

	{

	}

CMassStorageDrive::~CMassStorageDrive()

	{

	delete iLocalDrive;

	}

/** Read data from the drive */

TInt CMassStorageDrive::Read(const TInt64& aPos, TInt aLength, TDes8& aBuf, TBool aWholeMedia)

	{

	TInt err = KErrUnknown;

	if( iMountState != EConnected )

		{

		err = KErrDisconnected;

		}

	else

		{

		ASSERT(iLocalDrive);

		if(aWholeMedia)

			{

			err = iLocalDrive->iProxyDrive.Read(aPos, aLength, &aBuf, KLocalMessageHandle, 0, RLocalDrive::ELocDrvWholeMedia);

			}

		else

			{

			err = iLocalDrive->iProxyDrive.Read(aPos,aLength,aBuf);

			}

		}

	return err;

	}

/** Write data to the drive */

TInt CMassStorageDrive::Write(const TInt64& aPos, TDesC8& aBuf, TBool aWholeMedia)

	{

	TInt err = KErrUnknown;

	if( iMountState != EConnected )

		{

		err = KErrDisconnected;

		}

	else

		{

		ASSERT(iLocalDrive);

		if(aWholeMedia)

			{

			err = iLocalDrive->iProxyDrive.Write(aPos, aBuf.Length(), &aBuf, KLocalMessageHandle, 0, RLocalDrive::ELocDrvWholeMedia);

			}

		else

			{

			err = iLocalDrive->iProxyDrive.Write(aPos,aBuf);

			}

		}

	return err;

	}

/** Get CAPs */

TInt CMassStorageDrive::Caps(TLocalDriveCapsV4& aInfo)

	{

	TInt err = KErrUnknown;

	if( iMountState != EConnected )

		{

		err = KErrDisconnected;

		}

	else

		{

		err = DoCaps(aInfo);

		}

	return err;

	}

/** Get CAPs helper */

TInt CMassStorageDrive::DoCaps(TLocalDriveCapsV4& aInfo)

	{

	if (!iLocalDrive)

		{ return KErrBadHandle; }

	TLocalDriveCapsV4Buf buf;

	TInt err = iLocalDrive->iProxyDrive.Caps(buf);

	// Invoke function call operator to cast to TLocalDriveCapsV4&

	aInfo = buf();

	return err;

	}

/**

Set the mount state

*/

TInt CMassStorageDrive::SetMountConnected(CProxyDrive& aProxyDrive, TBool& aMediaChanged)

	{

		__FNLOG("CMassStorageDrive::SetMountConnected");

		TInt err = KErrUnknown; //Never return this

		if(iMountState == EConnected)

			{

			err = KErrNone;

			}

		else

			{

			CLocalDriveRef* localDrive = new CLocalDriveRef(aProxyDrive, aMediaChanged);

			err = (localDrive==NULL) 

				? KErrNoMemory

				: SetMountState(EConnected, localDrive);

			}

		return err;

	}

/**

@return KErrNone on success, KErrArgument if arguments are illegal

@param aNewState

@param aLocalDrive Only provide this if aNewState is EConnected, in which case it is required.

Only sets/clears iLocalDrive if new state is Connected or Disconnected.

*/

TInt CMassStorageDrive::SetMountState(TMountState aNewState, CLocalDriveRef* aLocalDrive/*=NULL*/)

	{

	__FNLOG("CMassStorageDrive::SetMountState");

	TInt err = KErrUnknown; //Never return this

	if(iMountState != aNewState)

		{

		if 	(iMountState == EConnected 		&& aNewState==EConnecting ||

			iMountState == EDisconnected 	&& aNewState==EDisconnecting)

			{

			return KErrNone;

			}

		iMountState = aNewState;

		if(aNewState==EDisconnected || aNewState==EConnecting)

			{

			// Reset the drive state on disconnection.

			// Note: This should be called before ProxyDrive is NULLed.

			SetDriveState(EErrDisMounted);

			}

		// Only mounting and unmounting transitions affect iProxyDrive

		if(aNewState==EConnected || aNewState==EDisconnected)

			{

			delete iLocalDrive;

			iLocalDrive = aLocalDrive;  // possibly NULL

			}

#ifndef USB_TRANSFER_PUBLISHER

		// The data transferred counts are "since the host connected to the drive"

		// so reset them when going to the connected state.

		if(aNewState==EConnected)

			{			

			iBytesWritten = iBytesRead = 0;

			}

#endif			

		__PRINT1(_L("SetMountState: state=%d\n"), iMountState);

		err = KErrNone;

		}

	else if(aLocalDrive != iLocalDrive)

		{

		// Caller is not allowed to change the proxy drive

		err = KErrArgument;

		}

	return err;

	}

/**

Checks the Media Removed flag, and optionally resets it.

The media has been changed (reinserted) if this function returns true

and the Drive State is not EMediaNotPresent.

@return The state of the Media Removed flag.

@param aReset If true, the Media Removed flag is reset to EFalse.

*/

TBool CMassStorageDrive::IsMediaChanged(TBool aReset)

	{

	__FNLOG("CMassStorageDrive::IsMediaChanged");

	TBool mediaChanged = EFalse;

	if(iLocalDrive)

		{

		mediaChanged = iLocalDrive->iMediaChanged;

		if(aReset) 

			{

			iLocalDrive->iMediaChanged = EFalse;

			}

		}

	return mediaChanged;

	}

/**

Set the Drive State to Active or Idle.

@return KErrNone on success, KErrNotReady if media not present

@param aCritical ETrue for Active, EFalse for Idle

*/

TInt CMassStorageDrive::SetCritical(TBool aCritical)

	{

	__FNLOG("CMassStorageDrive::SetCritical");

	TInt err = KErrDisMounted;

	if(iLocalDrive)

		{

		if(iLocalDrive->iDriveState == CMassStorageDrive::EMediaNotPresent)

			{

			err = KErrNotReady;

			}

		else

			{

			iCritSec.Wait();

			SetDriveState(

				aCritical 

				? CMassStorageDrive::EActive

				: CMassStorageDrive::EIdle );

			iCritSec.Signal();

			err = KErrNone;

			}

		}

	return err;

	}

/**

@return Current drive media state

*/

CMassStorageDrive::TDriveState	CMassStorageDrive::DriveState() const

	{

	return iLocalDrive ? iLocalDrive->iDriveState : EErrDisMounted;

	}

/**

This test version does not check for media removal

*/

CMassStorageDrive::TDriveState	CMassStorageDrive::CheckDriveState()

	{

	return iLocalDrive ? iLocalDrive->iDriveState : EErrDisMounted;

	}

/**

@param aNewState

*/

void CMassStorageDrive::SetDriveState(TDriveState aNewState)

	{

	if(iLocalDrive)

		{

		__PRINT2(_L("SetDriveState: %d->%d\n"), iLocalDrive->iDriveState, aNewState);

		iLocalDrive->iDriveState = aNewState;

		}

	}

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

//

//	CTestDriveManager

//

/** NewL */

CDriveManager* CDriveManager::NewL(const RArray<TInt>& aDriveMap)

	{

	__FNLOG ("CDriveManager::NewL");

	CDriveManager* self = new (ELeave) CDriveManager(aDriveMap);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/** construct

*/

void CDriveManager::ConstructL()

	{

	__FNLOG("CDriveManager::ConstructL");

	User::LeaveIfError(iDriveCritSec.CreateLocal());

	iDriveStateChangedPublisher = new (ELeave) RDriveStateChangedPublisher(iDrives, iDriveMap);

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

		{

		iDrives[i] = new (ELeave) CMassStorageDrive(iDriveCritSec, *iDriveStateChangedPublisher);

		}

	// Publish initial drive state

	if (iDriveMap.Count() > 0)

		{

		iDriveStateChangedPublisher->DriveStateChanged();

		}

	}

CDriveManager::CDriveManager(const RArray<TInt>& aDriveMap)

	:

	iDriveMap(aDriveMap)

	{}

/** d'tor */

CDriveManager::~CDriveManager()

	{

	iDrives.DeleteAll();

	delete iDriveStateChangedPublisher;

	iDriveCritSec.Close();

	}

/** register drive

@param aDrive - a proxy drive to register

@param aLun - Lun to register to

@return system wide return code

*/

TInt CDriveManager::RegisterDrive(CProxyDrive&, TBool&, TUint)

	{

	// not used in test code

	ASSERT(EFalse);

	return KErrNone;

	}

/** register drive

@param aDrive - a proxy drive to register

@param aLun - Lun to register to

@return system wide return code

*/

TInt CDriveManager::DeregisterDrive(TUint)

	{

	// not used in test code

	ASSERT(EFalse);

	return KErrNone;

	}

/** get a drive by aLun

@param aLun - lun

@param aError - operation error

@return pointer to drive

*/

CMassStorageDrive* CDriveManager::Drive(TUint aLun, TInt& aError) const

	{

	aError = KErrNone;

	CMassStorageDrive* drive = NULL;

	if(aLun>=static_cast<TUint>(iDrives.Count()))

		{

		aError = KErrArgument;

		}

	else

		{

		drive = iDrives[aLun];

		}

	return drive;

	}

/** 

@return true if media is changed

@param aLun - lun

@param aReset - reset flag

*/

TBool CDriveManager::IsMediaChanged(TUint, TBool)

	{

	// not used in test code

	ASSERT(EFalse);

	return EFalse;

	}

/**

Set the Drive State to Active or Idle.

Ref: 3.6.3.2 - PREVENT_MEDIUM_REMOVAL

@return KErrNone on success, otherwise system wide error code

@param aLun The Logical Drive Unit identifier (0..numDrives-1)

@param aCritical ETrue for Active, EFalse for Idle

*/

TInt CDriveManager::SetCritical(TUint aLun, TBool aCritical)

	{

	__PRINT1(_L("CDriveManager::SetCritical lun=%d\n"), aLun);

	TInt err = KErrUnknown; // never return this

	CMassStorageDrive* drive = Drive(aLun, err);

	if(drive)

		{

		err = drive->SetCritical(aCritical);

		}

	return err;

	}

/** connect a drive according to lun

@param aLun - lun

@return system wide error code

*/

TInt CDriveManager::Connect(TUint aLun)

	{

	TInt err = KErrNone;

	CMassStorageDrive* drive = Drive(aLun, err);

	if(drive)

		{

		drive->SetMountConnecting();

		}

	return err;

	}

/** disconnect drive according to lun

@param aLun - lun

@return system wide error code

*/

TInt CDriveManager::Disconnect(TUint aLun)

	{

	TInt err = KErrNone;

	CMassStorageDrive* drive = Drive(aLun, err);

	if(drive)

		{

		drive->SetMountDisconnecting();

		}

	return err;

	}

// 

// Dummy publishers

//	

#ifdef USB_TRANSFER_PUBLISHER

CUsbWriteTransferPublisher* CUsbWriteTransferPublisher::NewL(

	TRefBytesTransferedList /* aDrives */)

	{

	return NULL;

	}

CUsbReadTransferPublisher* CUsbReadTransferPublisher::NewL(

	TRefBytesTransferedList /* aDrives */)

	{

	return NULL;

	}

void CUsbTransferPublisher::DoPublishDataTransferredEvent()

	{

	}

CUsbTransferPublisher::~CUsbTransferPublisher()

	{

	}

void CUsbTransferPublisher::StartTimer()

	{

	}

#else

CDriveWriteTransferPublisher* CDriveWriteTransferPublisher::NewL(

	TFixedArray<CMassStorageDrive*,KUsbMsMaxDrives>& /* aDrives */)

	{