/*

* Copyright (c) 2006-2007 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:  ?Description

*

*/

#include <s32strm.h>

#include "irdebug.h"

#include "irreportsettings.h"

#include "irsessionloggerutility.h"

const TInt KMaxUrlLength = 256;

const TInt KMaxTimeStampLength = 64;

// ============================== Function declaration =======================

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

// Function: NewL

// Two phase constructor returns the instance of CIRSessionLogger

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

//

CIRSessionLogger* CIRSessionLogger::NewL()

	{

	IRLOG_DEBUG( "CIRSessionLogger::NewL" );

	CIRSessionLogger* self = CIRSessionLogger::NewLC();

	CleanupStack::Pop(self);

	IRLOG_DEBUG( "CIRSessionLogger::NewL - Exiting." );

	return self;

	}

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

// Function: NewLC

// Two phase constructor creates the instance of CIRSessionLogger

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

//

CIRSessionLogger* CIRSessionLogger::NewLC()

	{

	IRLOG_DEBUG( "CIRSessionLogger::NewLC" );

	CIRSessionLogger* self = new (ELeave) CIRSessionLogger;

	CleanupStack::PushL(self);

	self->ConstructL();

	IRLOG_DEBUG( "CIRSessionLogger::NewLC - Exiting." );

	return self;

	}	

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

// Function: ~CIRSessionLogger

// default destructor

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

//

CIRSessionLogger::~CIRSessionLogger()	

	{

	iRServer.Reset();

	iRServer.Close();	

	iRSongRecogLog.Reset();

	iRSongRecogLog.Close();	

	}

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

// Function: ConstructL

// Two phase constructor

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

//

void CIRSessionLogger::ConstructL()		

	{

	//No implementation

	}

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

// Function: CIRSessionLogger

// default constructor

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

//

CIRSessionLogger::CIRSessionLogger()	

	{

	//No implementation

	}

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

// Function: EndLogging

// logs the termination condition

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

//

void CIRSessionLogger::EndLogging()

	{

	IRLOG_DEBUG( "CIRSessionLogger::EndLogging" );	

	if( iSessionMarked )

		{

		HandleStopEvents();

		}

	else

		{

		iDuration = 0;	

		}

	switch(iTerminateBy)

		{

		case EUserTerminated:

			{

			//error condition for termination is disconnected by the user

			iTerminatedBy.Copy(KUSER);

			break;

			}

		case ENoConnectionToServer:

			{

			//error condition for termination is no connection to server			

			iTerminatedBy.Copy(KNOCONNECTIONTOSERVER);

			break;

			}

		case ENoConnectionToNetwork:

			{

			//error condition for termination is no connection to network

			iTerminatedBy.Copy(KNOCONNECTIONTONETWORK);

			break;

			}

		default:

			{

			break;	

			}								

		}

	IRLOG_DEBUG( "CIRSessionLogger::EndLogging - Exiting." );		

	}

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

// Function: HandleStopEvents

// logs the termination condition

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

//

void CIRSessionLogger::HandleStartEvents()

	{

	if( !iIsSessionProgressing )

		{

		iActiveSessionTime.UniversalTime();

		iIsSessionProgressing = ETrue;

		}

	}

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

// Function: HandleStartEvents

// logs the termination condition

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

//

void CIRSessionLogger::HandleStopEvents()

	{

	if( iIsSessionProgressing )

		{

		TTime endtime;	

		//endtime has session end time in GMT format

		endtime.UniversalTime();

		//session duration compensation value is calculated 

		//as difference between Compensation Time [time when it stopped] and

		//end time

		TTimeIntervalSeconds timeelaspsed;

		endtime.SecondsFrom(iActiveSessionTime,timeelaspsed);

		//compensation value session duration is converted to integer

		iDuration += timeelaspsed.Int();

		iIsSessionProgressing = EFalse;

		}

	}

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

// Function: MarkSession

// Marks the start of a session

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

//

void CIRSessionLogger::MarkSession()

	{

	iSessionMarked = ETrue;	

	iDuration = 0;

	HandleStartEvents();

	}

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

// Function: UnMarkSession

// UnMarks the start of a sessiom

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

//

void CIRSessionLogger::UnMarkSession()

	{

	iSessionMarked = EFalse;	

	}

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

// Function: SessionMarked

// Returns the session mark flag

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

//	

TBool CIRSessionLogger::SessionMarked()

	{

	return iSessionMarked;	

	}	

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

// Function: ResetResource

// reset data from channel server

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

//	

void CIRSessionLogger::ResetResource()

	{

	IRLOG_DEBUG( "CIRSessionLogger::ResetResource" );

	//reseting of resource

	iRServer.Reset();

	iRSongRecogLog.Reset();

	}

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

// Function: IsSessionProgressing

// checks whether session is progressing or not

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

//

TBool CIRSessionLogger::IsSessionProgressing()

	{

	return iIsSessionProgressing;	

	}

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

// Function: CompensationTime

// Returns the session mark flag

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

//	

TTime CIRSessionLogger::CompensationTime()

	{

	return iActiveSessionTime;	

	}

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

// Function: LogServerResult

// logs server connection result

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

//

void CIRSessionLogger::LogServerResult(const TDesC& aUrl,TResponse aResponse)

	{

	IRLOG_INFO3( "CIRSessionLogger::LogServerResult - %S (%d)", &aUrl, aResponse );

	TIRServer tempServer;

	if( aUrl.Length() <= KMaxUrlLength )

		{

		//channel server url is copied

		tempServer.iServerUrl.Copy(aUrl);

		}

	switch(aResponse)

		{

		//connected to the channel server

		case EIRConnected:

			{

			tempServer.iServerResult.Copy(KConnected);

			}

			break;

		//not connected to channel server

		//since server is not responding

		case EIRFull:

			{

			tempServer.iServerResult.Copy(KFull);

			}

			break;

		//not connected to channel server

		//since connection time out 	

		case EIRConnTimeOut:

			{

			tempServer.iServerResult.Copy(KConnTimeOut);

			}

			break;

		//not connected to channel server (may be invalid urls)

		case EIRConnFailed:

			{

			tempServer.iServerResult.Copy(KConnectionFailed);

			}

			break;

		default:

			{

			break;	

			}	

		}

	UpdateSessionLog(tempServer);

	IRLOG_DEBUG( "CIRSessionLogger::LogServerResult - Exiting." );			

	}

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

// Function: LogSongRecog

// logs song recog

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

//

void CIRSessionLogger::LogSongRecog(const TDesC& aTimeStamp)

    {

    if( aTimeStamp.Length() <= KMaxTimeStampLength )

        {

        TIRSongRecogLog tempSongRecogLog;

        tempSongRecogLog.iTimeStamp.Copy(aTimeStamp);   

        TRAP_IGNORE(iRSongRecogLog.AppendL(tempSongRecogLog));

        }    

    }

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

// Function: GetConnectedFrom

// connected information is stored

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

//

void CIRSessionLogger::GetConnectedFrom(TConnectedFrom aConnectedFrom)

	{

	IRLOG_DEBUG( "CIRSessionLogger::GetConnectedFrom" );

	switch(aConnectedFrom)

		{

		case EIRIsds:

			{

			iConnectedFrom.Copy(KISDS);

			break;

			}

		case EIRPresetAdhoc:

			{

			iConnectedFrom.Copy(KPRESETADHOC);

			break;

			}

		case EIRPresetIsds:

			{

			iConnectedFrom.Copy(KPRESETISDS);

			break;

			}

        case EIRHistoryAdhoc:

            {

            iConnectedFrom.Copy(KHISTORYADHOC);

            break;

            }

        case EIRHistoryIsds:

            {

            iConnectedFrom.Copy(KHISTORYISDS);

            break;

            }

        case EIRAdhocManual:

            {

            iConnectedFrom.Copy(KADHOCMANUAL);

            break;

            }

        case EIRAdhocExternal:

            {

            iConnectedFrom.Copy(KADHOCEXTERNAL);

            break;

            }            

		default:

			{

			break;	

			}									

		}

	IRLOG_DEBUG( "CIRSessionLogger::GetConnectedFrom - Exiting." );

	}

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

// Function: UpdateSessionLog

// update the session logs

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

//

void CIRSessionLogger::UpdateSessionLog(TIRServer& aServer)

	{

	IRLOG_DEBUG( "CIRSessionLogger::UpdateSessionLog" );

    TBool found = EFalse;

    // Only one entry per URL may be in the session log.

	for ( TInt i = 0; i < iRServer.Count() && !found; i++ )

	    {

        TIRServer& server = iRServer[i];

        if ( server.iServerUrl == aServer.iServerUrl )

            {

            // If an entry for this URL already exists, it is replaced

            // by the newer status code.

            server = aServer;

            found = ETrue;

            }

	    }

	if ( !found )

	    {

    	// Creates a new entry into the session log for this URL.

    	TRAP_IGNORE(iRServer.AppendL(aServer))	

	    }

	}

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

// Function: UpdateSessionId

// updates the session id

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

//

void CIRSessionLogger::UpdateSessionId(TInt aSessionId)

	{

	IRLOG_DEBUG( "CIRSessionLogger::UpdateSessionId" );

	iSessionId = aSessionId;	

	}

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

// Function: UpdateTerminationStatus

// updates the termination status

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

//

void CIRSessionLogger::UpdateTerminationStatus(TTerminationStatus aTerminatedBy)

	{

	IRLOG_DEBUG( "CIRSessionLogger::UpdateTerminationStatus" );

	iTerminateBy = aTerminatedBy;	

	}

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

// Function: UpdateChannelID

// updates the channel id

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

//	

void CIRSessionLogger::UpdateChannelID(TInt aChanneldID)

	{

	IRLOG_DEBUG( "CIRSessionLogger::UpdateChannelID" );

	iChannelId = aChanneldID;	

	}

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

// Function: UpdateCurrentNetwork

// updates the current network

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

//

void CIRSessionLogger::UpdateCurrentNetwork(TInt aCurrentNetwork)

	{

	IRLOG_DEBUG( "CIRSessionLogger::UpdateCurrentNetwork" );

	iSessionCurrentNetwork = aCurrentNetwork;

	}

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

// Function: UpdateHomeOperator

// updates the home network

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

//

void CIRSessionLogger::UpdateHomeOperator(TInt aHomeOperator)

	{

	IRLOG_DEBUG( "CIRSessionLogger::UpdateHomeOperator" );

	iHomeOperator = aHomeOperator;

	}

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

// Function: UpdateConnectionType

// updates the connection type

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

//

void CIRSessionLogger::UpdateConnectionType(const TDesC& aConnectionType)

	{

	IRLOG_DEBUG( "CIRSessionLogger::UpdateConnectionType" );

	iSessionConnectionType.Copy(aConnectionType);

	}

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

// Function : UpdateSessionStartGMTTime

// function updates session start time with current GMT time

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

//

void CIRSessionLogger::UpdateSessionStartGMTTime()

	{

	iStartSessionTime.UniversalTime();	

	}

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

// Function: TerminationStatus

// returns termination status

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

//

TDesC& CIRSessionLogger::TerminationStatus()

	{

	IRLOG_DEBUG( "CIRSessionLogger::TerminationStatus" );

	return iTerminatedBy;	

	}

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

// Function: ChannelID

// returns the channel id

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

//	

TInt CIRSessionLogger::ChannelID() const

	{

	IRLOG_DEBUG( "CIRSessionLogger::ChannelID" );

	return iChannelId;

	}

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

// Function: CurrentNetwork

// returns the Current Network

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

//	

TInt CIRSessionLogger::CurrentNetwork() const

	{

	IRLOG_DEBUG( "CIRSessionLogger::CurrentNetwork" );

	return iSessionCurrentNetwork;

	}

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

// Function: HomeOperator

// returns the home network

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

//

TInt CIRSessionLogger::HomeOperator() const

	{

	IRLOG_DEBUG( "CIRSessionLogger::HomeOperator" );

	return iHomeOperator;

	}

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

// Function: ConnectionType

// returns the connection type

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

//	

TDesC& CIRSessionLogger::ConnectionType()

	{

	IRLOG_DEBUG( "CIRSessionLogger::ConnectionType" );

	return iSessionConnectionType;

	}

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

// Function: StartTime

// returns the start time

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

//	

TDes& CIRSessionLogger::StartTime()

	{

	IRLOG_DEBUG( "CIRSessionLogger::StartTime" );