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

// Class implementation of the drive publishing classes -  

// RDriveMediaErrorPublisher,

// RDriveStateChangedPublisher, 

// CDriveTransferPublisher,

// CDriveWriteTransferPublisher,

// CDriveReadTransferPublisher,

// CUsbTransferPublisher,

// CUsbReadTransferPublisher,

// CUsbReadTransferPublisher.

// 

//

/**

 @file

 @internalTechnology

*/

#include "massstoragedebug.h"

#include "drivepublisher.h"

#include "drivemanager.h"

// 

// Use Lookup table to translate from the internal pair of state variables

// to the externally published drive state code.

//

LOCAL_D	const TUint8 table[][5] =

{

//TMountState=EDisconnected

	{EUsbMsDriveState_Disconnected, 

	 EUsbMsDriveState_Disconnected, 

	 EUsbMsDriveState_Disconnected, 

	 EUsbMsDriveState_Disconnected, 

	 EUsbMsDriveState_Disconnected},

//TMountState=EConnecting

	{EUsbMsDriveState_Connecting,

	 EUsbMsDriveState_Connecting, 

	 EUsbMsDriveState_Connecting, 

	 EUsbMsDriveState_Connecting, 

	 EUsbMsDriveState_Connecting},

//TMountState=EConnected

	//EIdle,EActive,ELocked,EMediaNotPresent,EErrDisMounted

	{EUsbMsDriveState_Connected, 

	 EUsbMsDriveState_Active, 

	 EUsbMsDriveState_Locked, 

	 EUsbMsDriveState_MediaNotPresent, 

	 EUsbMsDriveState_Removed},

//TMountState=EDisconnecting

	{EUsbMsDriveState_Disconnecting, 

	 EUsbMsDriveState_Disconnecting, 

	 EUsbMsDriveState_Disconnecting, 

	 EUsbMsDriveState_Disconnecting, 

	 EUsbMsDriveState_Disconnecting}

};

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

/**

Constructor

*/

RDriveMediaErrorPublisher::RDriveMediaErrorPublisher()

	{

	__FNLOG("RDriveMediaErrorPublisher::RDriveMediaErrorPublisher()");

	_LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy);

	_LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid);

	TInt result = RProperty::Define(EUsbMsDriveState_MediaError, RProperty::EInt,

									KMassStorageReadPolicy, KMassStorageWritePolicy);

	__ASSERT_DEBUG(result == KErrAlreadyExists || result == KErrNone, User::Invariant());

	result = iMediaErrorProperty.Attach(KUsbMsDriveState_Category, EUsbMsDriveState_MediaError);

	__ASSERT_DEBUG(result == KErrNone, User::Invariant());

	}

RDriveMediaErrorPublisher::~RDriveMediaErrorPublisher()

	{

	__FNLOG("RDriveStatePublisher::~RDriveStatePublisher()");

	iMediaErrorProperty.Close();

	RProperty::Delete(KUsbMsDriveState_Category, EUsbMsDriveState_MediaError);

	}

/**

Publishing method

Publishes the Media Error property event

@param aError ETrue if drive media has an error else EFalse for no error

*/

void RDriveMediaErrorPublisher::PublishError(TBool aError)

	{

	__PRINT1(_L("<< RDriveMediaErrorPublisher::PublishError %x"), aError);

	TInt oldValue;

	iMediaErrorProperty.Get(oldValue);

	if (oldValue != aError)

		{

		User::LeaveIfError(iMediaErrorProperty.Set(aError));

		}

	}

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

/**

Constructor

@param aDrives

@param aDriveMap

*/

RDriveStateChangedPublisher::RDriveStateChangedPublisher(TRefMsDriveList aDrives,

														 TRefDriveMap aDriveMap)

	:

	iDrives(aDrives),

	iDriveMap(aDriveMap)

	{

	__FNLOG("RDriveStateChangedPublisher::RDriveStateChangedPublisher()");

	_LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy);

	_LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid);

	TInt result = RProperty::Define(KUsbMsDriveState_Category,

									EUsbMsDriveState_DriveStatus, RProperty::EByteArray,

									KMassStorageReadPolicy, KMassStorageWritePolicy,

									KUsbMsMaxDrives*2);

	__ASSERT_DEBUG(result == KErrAlreadyExists || result == KErrNone, User::Invariant());

	result = result;	// remove urel warning

	}

RDriveStateChangedPublisher::~RDriveStateChangedPublisher()

	{

	__FNLOG("RDriveStateChangedPublisher::~RDriveStateChangedPublisher()");

	RProperty::Delete(KUsbMsDriveState_Category, EUsbMsDriveState_DriveStatus);

	}

/**

Publishing method

Sends a property event on behalf of CMassStorageDrive, with the mountstate and drivestate 

values encoded into one 32-bit word.

*/

void RDriveStateChangedPublisher::DriveStateChanged()

	{

	__FNLOG("RDriveStateChangedPublisher::DriveStateChanged");

	TUsbMsDrivesStatus allDrivesStatus;

	for(TUint8 i=0; i<KUsbMsMaxDrives && iDrives[i]; i++)

		{

		allDrivesStatus.Append(iDriveMap[i]); 

		CMassStorageDrive::TMountState ms = iDrives[i]->MountState();

		CMassStorageDrive::TDriveState ds = iDrives[i]->DriveState();

		TInt driveStatus = EUsbMsDriveState_Error;

		if((TUint8)ds < sizeof(table[0]) && (TUint8)ms < sizeof(table)/sizeof(table[0]))

			{

			driveStatus = table[ms][ds];

			__PRINT3(_L("ms=%d ds=%d %d"), ms, ds, driveStatus);

			}

		allDrivesStatus.Append(driveStatus);

		}

	__PRINT1(_L("Publishing EUsbMsDriveState_DriveStatus for %d drives\n"),

				allDrivesStatus.Length()/2);

	if(KErrNone != RProperty::Set(KUsbMsDriveState_Category,

								  EUsbMsDriveState_DriveStatus, 

								  allDrivesStatus))

		{

		__ASSERT_DEBUG(EFalse,User::Invariant());

		}

	}

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

#ifndef USB_TRANSFER_PUBLISHER

/**

Private default constructor to ensure that NewL is used

@param aSubKey 

@param aDrives

*/

CDriveTransferPublisher::CDriveTransferPublisher(

	TUsbMsDriveState_Subkey aSubKey,

	TRefMsDriveList aDrives)

	:

	iSubKey(aSubKey),

	iDrives(aDrives)

	{

	}

void CDriveTransferPublisher::ConstructL()

	{

	__FNLOG("CDriveTransferPublisher::ConstructL");

	_LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy);

	_LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid);

	TInt r = RProperty::Define(iSubKey, RProperty::EByteArray, 

							   KMassStorageReadPolicy, KMassStorageWritePolicy,

							   KUsbMsMaxDrives*sizeof(TInt));

	if (r != KErrAlreadyExists) 

		{

		User::LeaveIfError(r);

		}

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

	// Create the EDataTransferred timer

	iTimer = CPeriodic::NewL(CActive::EPriorityStandard);

	iTimerRunning = EFalse;

	}

/**

Destructor

*/

CDriveTransferPublisher::~CDriveTransferPublisher()

	{

	__FNLOG("CDriveTransferPublisher::~CDriveTransferPublisher");

	if(iTimer)

		{

		iTimer->Cancel();

		}

	delete iTimer;

	iProperty.Close();

	RProperty::Delete(KUsbMsDriveState_Category, iSubKey);

	}

/**

A static wrapper for the DoPublishDataTransferredEvent member function

for use as a timer callback function.

@param obj 'this' pointer

@return not used in CPeriodic callback (see TCallback)

*/

TInt CDriveTransferPublisher::PublishDataTransferredEvent(TAny* obj)

	{

	__FNLOG("CDrivePublisher::PublishDataTransferredEvent");

	static_cast<CDriveTransferPublisher*>(obj)->DoPublishDataTransferredEvent();

	return 1;

	}

/**

Update the data transferred properties if the counts have changed since

the last update.

*/

void CDriveTransferPublisher::DoPublishDataTransferredEvent()

	{

	if (PublishDataTransferred())

		{

		// some data has been transfered so reset the counter

		iTimerCancelCnt = ETimerCancelDelay;

		}

	// Update the cancel count if no data was transferred the last

	// (few) times this has been called

	if (--iTimerCancelCnt == 0)

		{

		StopTimer();

		iTimerCancelCnt = ETimerCancelDelay;

		}

	}

/**

Update the data transferred properties if the counts have changed since 

the last update.

*/

TBool CDriveTransferPublisher::PublishDataTransferred()

	{

	__FNLOG("CDriveWriteTransferPublisher::PublishDataTransferred");

	TUsbMsBytesTransferred bytesTransferred;

	TBool dataTransferred = EFalse;

	for (TInt i=0; i < iDrives.Count() && iDrives[i]; i++)

		{

		bytesTransferred[i] = GetBytesTransferred(i);

		}

	// Update the properties only if they have changed

	// (or if there's an error reading the old value.)

	// Possible optimisation: keep a copy of the value

	// as a member variable so we don't need the Get.

	TUsbMsBytesTransferred oldValue;

	if ((iProperty.Get(oldValue) != KErrNone) || (oldValue != bytesTransferred))

		{

#ifdef __PRINT3

		for (TInt j=0; j < iDrives.Count() && iDrives[j]; j++)

			{

			if(oldValue[j] != bytesTransferred[j])

				{

				__PRINT3(_L("CDrivePublisher: KBytes[%d] %d->%d\n"), j, oldValue[j], bytesTransferred[j]);

				}

			}

#endif

		if (KErrNone != iProperty.Set(bytesTransferred))

			{

			__ASSERT_DEBUG(EFalse, User::Invariant());

			}

		dataTransferred = ETrue;

		}

	return dataTransferred;

	}

/**

Starts timer to periodically publish results.

If the timer is not yet running then start it.

*/

void CDriveTransferPublisher::StartTimer()

	{

	__FNLOG("CDrivePublisher::StartTimer");

	if (!iTimerRunning)

		{

		// EDataTransferred event every second

		const TTimeIntervalMicroSeconds32 interval = 1 * 1000 * 1000;

		TCallBack callback(PublishDataTransferredEvent, this);

		__PRINT(_L("Starting timer"));

		iTimer->Start(interval, interval, callback);

		iTimerRunning = ETrue;

		}

	}

/**

Ensure that the Timer is stopped

*/

void CDriveTransferPublisher::StopTimer()

	{

	__FNLOG("CDrivePublisher::StopTimer");

	if (iTimerRunning)

		{

		__PRINT(_L("Stopping timer"));

		iTimer->Cancel();

		iTimerRunning = EFalse;

		}

	}

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

/**

Constructor for Write property

@param aDrives

*/

CDriveWriteTransferPublisher* CDriveWriteTransferPublisher::NewL(TRefMsDriveList aDrives)

	{

	__FNLOG("CDriveWriteTransferPublisher::NewL");

	CDriveWriteTransferPublisher* self = new (ELeave) CDriveWriteTransferPublisher(aDrives);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/**

Constructor

@param aDrives

*/

CDriveWriteTransferPublisher::CDriveWriteTransferPublisher(TRefMsDriveList aDrives)

	:

	CDriveTransferPublisher(EUsbMsDriveState_KBytesWritten, aDrives)

	{

	}

/**

Transfer function for Write property

@param aLun

*/

TUint CDriveWriteTransferPublisher::GetBytesTransferred(TUint aLun) const

	{

	return iDrives[aLun]->KBytesWritten();

	}

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

/**

Constructor for Read property

@param aDrives

*/

CDriveReadTransferPublisher* CDriveReadTransferPublisher::NewL(TRefMsDriveList aDrives)

	{

	__FNLOG("CDriveWriteTransferPublisher::NewL");

	CDriveReadTransferPublisher* self = new (ELeave) CDriveReadTransferPublisher(aDrives);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/**

Constructor

@param aDrives

*/

CDriveReadTransferPublisher::CDriveReadTransferPublisher(TRefMsDriveList aDrives)

	:

	CDriveTransferPublisher(EUsbMsDriveState_KBytesRead, aDrives)

	{

	}

/**

Transfer function for Read property

@param aLun

*/

TUint CDriveReadTransferPublisher::GetBytesTransferred(TUint aLun) const

	{

	return iDrives[aLun]->KBytesRead();

	}

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

#else

/**

Private default constructor to ensure that NewL is used

@param aSubKey

@param aArray

*/

CUsbTransferPublisher::CUsbTransferPublisher(

	TUsbMsDriveState_Subkey aSubKey,

	TRefBytesTransferedList aArray)

	:

	iSubKey(aSubKey),

	iArray(aArray)

	{

	}

void CUsbTransferPublisher::ConstructL()

	{

	__FNLOG("CUsbTransferPublisher::ConstructL");

	_LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy);

	_LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid);

	TInt r = RProperty::Define(iSubKey, RProperty::EByteArray, 

							   KMassStorageReadPolicy, KMassStorageWritePolicy,

							   KUsbMsMaxDrives*sizeof(TInt));

	if (r != KErrAlreadyExists) 

		{

		User::LeaveIfError(r);

		}

	// Attach to the properties here. Only do this once, continuously attaching

	// will currently cause a memory leak

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

	// Create the EDataTransferred timer

	iTimer = CPeriodic::NewL(CActive::EPriorityStandard);

	iTimerRunning = EFalse;

	}

/**

Destructor

*/

CUsbTransferPublisher::~CUsbTransferPublisher()

	{

	__FNLOG("CUsbTransferPublisher::~CDriveTransferPublisher");

	if(iTimer)

		{

		iTimer->Cancel();

		}

	delete iTimer;

	iProperty.Close();

	RProperty::Delete(KUsbMsDriveState_Category, iSubKey);

	}

/**

A static wrapper for the DoPublishDataTransferredEvent member function

for use as a timer callback function.

@param obj 'this' pointer

@return not used in CPeriodic callback (see TCallback)

*/

TInt CUsbTransferPublisher::PublishDataTransferredEvent(TAny* obj)

	{

	__FNLOG("CUsbTransferPublisher::PublishDataTransferredEvent");

	static_cast<CUsbTransferPublisher*>(obj)->DoPublishDataTransferredEvent();

	return 1;

	}