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

// Class implementation of the drive publishing classes -

// RDriveMediaErrorPublisher,

// RDriveStateChangedPublisher,

// CDriveTransferPublisher,

// CDriveWriteTransferPublisher,

// CDriveReadTransferPublisher,

// CUsbTransferPublisher,

// CUsbReadTransferPublisher,

// CUsbReadTransferPublisher.

// 

//

/**

 @file

 @internalTechnology

*/

#include <e32std.h>

#include <e32base.h>

#include <e32property.h>

#include <f32file.h>

#include "mstypes.h"

#include "msctypes.h"

#include "usbmsshared.h"

#include "drivepublisher.h"

#include "drivemanager.h"

#include "debug.h"

#include "msdebug.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()

	{

	__MSFNLOG

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

	{

	__MSFNLOG

	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::PublishErrorL(TBool aError)

	{

    __MSFNLOG

	__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(const TMsDriveList& aDrives,

														 const TLunToDriveMap& aDriveMap)

	:

	iDrives(aDrives),

	iDriveMap(aDriveMap)

	{

	__MSFNLOG

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

	{

	__MSFNLOG

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

	{

	__MSFNLOG

	TUsbMsDrivesStatus allDrivesStatus;

	for(TUint8 i = 0; i < iDrives.Count(); i++)

		{

		allDrivesStatus.Append(iDriveMap[i]);

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

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

		}

	}

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

/**

Private default constructor to ensure that NewL is used

@param aSubKey

@param aArray

*/

CUsbTransferPublisher::CUsbTransferPublisher(TUsbMsDriveState_Subkey aSubKey,

                                             const TBytesTransferedList& aArray)

:   iSubKey(aSubKey),

	iArray(aArray)

	{

    __MSFNLOG

	}

void CUsbTransferPublisher::ConstructL()

	{

	__MSFNLOG

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

	{

	__MSFNLOG

	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)

	{

	__MSFNSLOG

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

	return 1;

	}

/**

Update the data transferred properties if the counts have changed since

the last update.

*/

void CUsbTransferPublisher::DoPublishDataTransferredEvent()

	{

    __MSFNLOG

	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 CUsbTransferPublisher::PublishDataTransferred()

	{

	__MSFNLOG

	TUsbMsBytesTransferred bytesTransferred;

	TBool dataTransferred = EFalse;

	for (TInt i = 0; i < iArray.Count(); 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

		// trace of the bytes transferred

		for (TInt j=0; j < iArray.Count(); 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 CUsbTransferPublisher::StartTimer()

	{

	__MSFNLOG

	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 CUsbTransferPublisher::StopTimer()

	{

	__MSFNLOG

	if (iTimerRunning)

		{

		__PRINT(_L("Stopping timer"));

		iTimer->Cancel();

		iTimerRunning = EFalse;

		}

	}

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

/**

Constructor for Write property

@param aArray

*/

CUsbWriteTransferPublisher* CUsbWriteTransferPublisher::NewL(const TBytesTransferedList& aArray)

	{

	__MSFNSLOG

	CUsbWriteTransferPublisher* self = new (ELeave) CUsbWriteTransferPublisher(aArray);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CUsbWriteTransferPublisher::CUsbWriteTransferPublisher(const TBytesTransferedList& aArray)

:   CUsbTransferPublisher(EUsbMsDriveState_KBytesWritten, aArray)

	{

    __MSFNLOG

	}

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

/**

Constructor for Read property

@param aArray

*/

CUsbReadTransferPublisher* CUsbReadTransferPublisher::NewL(const TBytesTransferedList& aArray)

	{

	__MSFNSLOG

	CUsbReadTransferPublisher* self = new (ELeave) CUsbReadTransferPublisher(aArray);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CUsbReadTransferPublisher::CUsbReadTransferPublisher(const TBytesTransferedList& aArray)

:   CUsbTransferPublisher(EUsbMsDriveState_KBytesRead, aArray)

	{

    __MSFNLOG

	}

/**

Transfer function for the property

@return Cumulative bytes read since the host connected to the drive,

        in multiples of KBytesPerKilobyte rounded to nearest integer value.

        The KBytes refer to multiples of 1000, not 1024.

*/

TUint CUsbTransferPublisher::GetBytesTransferred(TLun aLun) const

{

	return I64LOW(iArray[aLun] / (TUint64)1000);

}