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