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

// PSD-specific logging class

// 

//

/**

 @file PsdLogger.cpp

*/

#include "psdlogger.h"

#include "psdagt.h"

#include <comms-infras/cagentsmbase.h>

#include <logengevents.h>

CDataLogger* CDataLogger::NewL(MPsdEnv* aPsdSM,MAgentNotify* aObserver)

/**

Constructing an object of class CDataLogger, pushing it into the clean up stack and popping it.

@return a pointer to class CDataLogger.

*/

	{

	CDataLogger* log = new (ELeave) CDataLogger(aPsdSM,aObserver);

	CleanupStack::PushL(log);

	log->ConstructL();

	CleanupStack::Pop();

	return log;

	}

CDataLogger::CDataLogger(MPsdEnv* aPsdSM,MAgentNotify* aObserver)

: iSM(aPsdSM), iSMObserver(aObserver)

/**

Constructor

*/

	{

	}

void CDataLogger::ConstructL()

	{

	iRegularUpdater = CPeriodic::NewL(EPriorityLow);

	}

CDataLogger::~CDataLogger()

	{

	delete iRegularUpdater;

	}

void CDataLogger::Start()

/**

This must not log anything immediately because the asynchronous log start will probably

still be outstanding (started by the Open state) we must therefore wait for this start to complete

we will therefore wait for the time KRegularUpdateInterval before commencing logging otherwise

the log will not be open once we begin writing to it.

Assumption: log start takes less time than KRegularUpdateInterval.

We use the Active-Objectness of CDataLogger to cope with the asynchronous logging of

data transferred, with the same assumption as above.

*/

	{

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

	TCallBack callbackfn(CDataLogger::Update, this);

	iRegularUpdater->Start(KRegularUpdateInterval,KRegularUpdateInterval,callbackfn);

	}

void CDataLogger::StopL()

/**

No longer an active object

LogDataUpdateEvent will put the request in a queue

and process when available

*/

  	{

		iRegularUpdater->Cancel();

		TInt ret=KErrNone;

		if(iSM->Config().TsySupportsDataTransferInfoL(iSM->PacketNetwork()))

			{

			ret = iSM->Context().GetDataVolumeTransferred(iVolumeTransferred);

			}

		else	// retrieve last values from PPP

			{

			TPckg<RPacketContext::TDataVolume> dataPackage(iVolumeTransferred);

			ret = iSMObserver->Notification(EAgentToNifEventTypeGetDataTransfer,&dataPackage);

			}

		if (ret==KErrNone)

			LogData();

	}	

TInt CDataLogger::Update(TAny* aContext)

/**

This function is called every minute

*/

	{

	CDataLogger* datalogger = REINTERPRET_CAST(CDataLogger*,aContext);

	TRAPD(ret,datalogger->RegularUpdateL());

	return ret;

	}

void CDataLogger::RegularUpdateL()

/**

Only logs if there has been change.

*/

	{

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

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

	RPacketContext::TDataVolume newVolume;

	if(iSM->Config().TsySupportsDataTransferInfoL(iSM->PacketNetwork()))

		// does the phone support counting the data volume transfer?

		{

		User::LeaveIfError(iSM->Context().GetDataVolumeTransferred(newVolume));

		}

	else	// if not request values from PPP instead

		{

		TPckg<RPacketContext::TDataVolume> dataPackage(newVolume);

		User::LeaveIfError(iSMObserver->Notification(EAgentToNifEventTypeGetDataTransfer,&dataPackage));

		}

	if (IsVolumeChanged(newVolume))

		{

		iVolumeTransferred = newVolume;

		LogData();

		}

	}

void CDataLogger::LogData() 

	{

	TInt64 sent = MAKE_TINT64(iVolumeTransferred.iOverflowCounterSent,iVolumeTransferred.iBytesSent);

	TInt64 recvd = MAKE_TINT64(iVolumeTransferred.iOverflowCounterReceived,iVolumeTransferred.iBytesReceived);

	iSM->Logger()->LogDataUpdateEvent(CEventLogger::KConnectionStatusIdNotAvailable, KLogPacketDataEventTypeUid, sent,recvd);

	}

TBool CDataLogger::IsVolumeChanged(RPacketContext::TDataVolume& aNewVolume) const

	{

	return (aNewVolume.iBytesReceived!=iVolumeTransferred.iBytesReceived ||

				aNewVolume.iBytesSent!=iVolumeTransferred.iBytesSent);

	}