/*

* 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 "irdataprovider.h"

#include "irdataproviderobserver.h"

#include "irdebug.h"

#include "irhttpdataprovider.h"

#include "irhttprequestdata.h"

#include "irsettings.h"

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

//  CIRDataProvider::NewL(MIRDataProviderObserver& aObserver)

//  Creates instance of CIRDataProvider.

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

//

EXPORT_C CIRDataProvider *CIRDataProvider::NewL(

    MIRDataProviderObserver &aObserver )

    {

    IRLOG_DEBUG( "CIRDataProvider::NewL - Entering" );

    CIRDataProvider *self = NewLC( aObserver );

    CleanupStack::Pop(self);

    IRLOG_DEBUG( "CIRDataProvider::NewL - Exiting" );

    return self;

    }

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

//  CIRDataProvider::NewL(MIRDataProviderObserver& aObserver)

//  Creates instance of CIRDataProvider.

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

//

EXPORT_C CIRDataProvider *CIRDataProvider::NewL(

    MIRDataProviderObserver &aObserver, const TDesC &aFileName )

    {

    IRLOG_DEBUG( "CIRDataProvider::NewL(..., &aFileName) - Entering" );

    CIRDataProvider *self = NewLC( aObserver, aFileName );

    CleanupStack::Pop(self);

    IRLOG_DEBUG( "CIRDataProvider::NewL(..., &aFileName) - Exiting." );

    return self;

    }

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

//  CIRDataProvider::~CIRDataProvider()

//  Destructs an instance of CIRDataProvider.

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

//

CIRDataProvider::~CIRDataProvider() // destruct - virtual, so no export

    {

    IRLOG_DEBUG( "CIRDataProvider::~CIRDataProvider() - Entering" );

    if (iHttpDataProvider)

        {

        // Cancel any active transactions

        iHttpDataProvider->CancelTransaction();

        // Destroy the data provider object

        }

    delete iHttpDataProvider;

    if( iIRSettings )

    	{

    	iIRSettings->Close();

		}

    if (iDataProviderTimer)

        {

     	iDataProviderTimer->Cancel(); // Cancel the timer

        }

    delete iDataProviderTimer; // Destroy the timer object

	if( iResponseHeaders )

		{

        delete iResponseHeaders;

		}

    iFile.Close();

    iFsSession.Close(); // Close the file server session

    IRLOG_DEBUG( "CIRDataProvider::~CIRDataProvider() - Exiting" );

    }

// General functions exported ( These are the API`s exposed )( HTTP )

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

//  CIRDataProvider::IRHttpIssueRequest(TDesC8& aUri)

//  Used to issue an Http request

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

//

EXPORT_C void CIRDataProvider::IRHttpIssueRequestL(

     CIRHttpRequestData &aRequestObject )

    {

    IRHttpCancelRequest();

    IRLOG_DEBUG( "CIRDataProvider::IRHttpIssueRequestL - Entering" );

	IRRDEBUG2("CIRDATAPROVIDER::IRHTTPISSUEREQUESTL",KNullDesC);

    CIRHttpResponseData* newResponseHeaders = new ( ELeave ) CIRHttpResponseData;

    delete iResponseHeaders;

    iResponseHeaders = newResponseHeaders;

    // Create or replace the file used to store xml response from iSDS

    User::LeaveIfError(iFile.Replace( iFsSession, iXmlFilePath, EFileWrite ));

    iHttpDataProvider->CancelTransaction();

    TInt err = iHttpDataProvider->IssueHttpRequestL( aRequestObject );

    // Cancel the timer if active

    iDataProviderTimer->Cancel();

    // Start the timer for timeout

    iDataProviderTimer->After( iTimeOut );

    if ( err == KErrCouldNotConnect )

        {

        // If error in IssueHttpRequest then close the open file

	    iFile.Close();

	    iDataProviderTimer->Cancel();

	    iDataProviderObserver.IRHttpGeneralError( err );

	    // Cancel any possibly pending transactions

	    iHttpDataProvider->CancelTransaction();

        }

    IRLOG_DEBUG( "CIRDataProvider::IRHttpIssueRequestL - Exiting." );

    }

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

//  CIRDataProvider::IRHttpCancelRequest()

//  Used to cancel a request

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

//

EXPORT_C void CIRDataProvider::IRHttpCancelRequest()

    {

    IRLOG_DEBUG( "CIRDataProvider::IRHttpCancelRequest - Entering" );

    // Cancel the timer if active

    iDataProviderTimer->Cancel();

    // Cancel any possibly pending transactions

    iHttpDataProvider->CancelTransaction();

    // Close the file handle used to store the xml response

    iFile.Close();

    IRLOG_DEBUG( "CIRDataProvider::IRHttpCancelRequest - Exiting." );

    }

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

//  CIRDataProvider::ReleaseResources()

//  Used to release the resources held by the IRHttpDataProvider

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

//

EXPORT_C void CIRDataProvider::ReleaseResources()

	{

	IRLOG_DEBUG( "CIRDataProvider::ReleaseResources - Entering" );

	// Release the resources held by the IRHttpDataProvider

	iHttpDataProvider->ReleaseResources();

	IRLOG_DEBUG( "CIRDataProvider::ReleaseResources - Exiting" );

	}

//These are the callback functions used by CIRHttpDataProvider to

//provide the CIRDataProvider with the data after processing the

//HTTP request.

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

//  CIRDataProvider::HttpEventComplete()

//  Used to Indicate to the observer that the request event has completed

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

//

void CIRDataProvider::HttpEventComplete()

    {

    IRLOG_DEBUG( "CIRDataProvider::HttpEventComplete - Entering" );

    iFile.Close();

    iDataProviderTimer->Cancel();

    // Need to take a member to a local variable, as the IRHttpDataReceived may initiate

    // an IRHttpIssueRequestL() call, causing the headers to be replaced with empty ones, and

    // causing crashes.

    CIRHttpResponseData* currentHeaders = iResponseHeaders;

    iResponseHeaders = NULL; // prevents the destructor to delete in case something streange happens.

    iDataProviderObserver.IRHttpDataReceived( iXmlFilePath,*currentHeaders );

    delete currentHeaders;

    IRLOG_DEBUG( "CIRDataProvider::HttpEventComplete - Exiting." );

    }

void CIRDataProvider::ExtractHeaderValue(const TDesC8& aHeaderData,const

	TDesC8& aHeaderName,const TDesC8& aDelimeter,TDes8& aHolder) const

	{

	IRLOG_DEBUG( "CIRDataProvider::ExtractHeaderValue - Entering" );

	TInt position = aHeaderData.Find(aHeaderName);

	if( position >= 0)

		{

		TPtrC8 headerValue = aHeaderData.Mid(position);

		TInt delimeterPosition = headerValue.Find(aDelimeter);

		if( delimeterPosition != KErrNotFound )

			{

			delimeterPosition++;

			TPtrC8 value = headerValue.Mid(delimeterPosition);

			aHolder.Copy(value);

			aHolder.TrimAll();

			}

		}

	IRLOG_DEBUG( "CIRDataProvider::ExtractHeaderValue - Exiting." );

	}

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

//  CIRDataProvider::HttpHeaderReceived( const TDesC8& aHeaderData )

//  Used by CIRHttpDataProvider to indicate that an HTTP header is received.

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

//

void CIRDataProvider::HttpHeaderReceived( const TDesC8& aHeaderData )

    {

    IRLOG_DEBUG( "CIRDataProvider::HttpHeaderReceived - Entering." );

	_LIT8(KDelim,":");

	_LIT8(KContentType,"Content-Type");

	ExtractHeaderValue(aHeaderData,KContentType,KDelim,iResponseHeaders->

		iContentType);

	_LIT8(KMaxAge,"max-age");

	_LIT8(KDelimEqual,"=");

	ExtractHeaderValue(aHeaderData,KMaxAge,KDelimEqual,iResponseHeaders->

		iMaxAge);

	_LIT8(KContentLength,"Content-Length");

	ExtractHeaderValue(aHeaderData,KContentLength,KDelim,iResponseHeaders->

		iContentLength);

	_LIT8(KExpires,"Expires");

	ExtractHeaderValue(aHeaderData,KExpires,KDelim,iResponseHeaders->iExpires);

	IRLOG_DEBUG( "CIRDataProvider::HttpHeaderReceived - Exiting." );

    }

void CIRDataProvider::HttpDateHeaderReceived(const TDesC8 &aHeader,

	const TTime& aTime )

	{

	IRLOG_DEBUG( "CIRDataProvider::HttpDateHeaderReceived - Entering." );

	_LIT8(KDate,"Date");

	_LIT8(KLastModified,"Last-Modified");

	TInt position = aHeader.Find(KDate);

	if( position != KErrNotFound )

		{

		iResponseHeaders->iDate = aTime;

		//find the difference between device time and response time

		//and storing the offset

		SetOffsetSeconds( aTime );

		return ;

		}

	position = aHeader.Find(KLastModified);

	if( position != KErrNotFound )

		{

		iResponseHeaders->iLastModified = aTime;

		}

	IRLOG_DEBUG( "CIRDataProvider::HttpDateHeaderReceived - Exiting." );

	}

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

//  CIRDataProvider::HttpBodyReceived( const TDesC8& aBodyData )

//  Used by CIRHttpDataProvider to indicate that an HTTP response body

//  is received.

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

//

void CIRDataProvider::HttpBodyReceived( const TDesC8 &aBodyData )

    {

    IRLOG_DEBUG( "CIRDataProvider::HttpBodyReceived - Entering" );

    TInt FileWritePos = 0;

    iFile.Seek( ESeekEnd, FileWritePos );

    iFile.Write( FileWritePos, aBodyData );

    IRLOG_DEBUG( "CIRDataProvider::HttpBodyReceived - Exiting." );

    }

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

//  CIRDataProvider::HttpTransactionError(TInt aErrCode)

//  Used by CIRHttpDataProvider to indicate that a HTTP Transaction error

//  has occured.

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

//

void CIRDataProvider::HttpTransactionError( TInt aErrCode )

    {

    IRLOG_DEBUG( "CIRDataProvider::HttpTransactionError - Entering" );

    iFile.Close();

    iDataProviderTimer->Cancel();

    iDataProviderObserver.IRHttpGeneralError( aErrCode );

    // Cancel any possibly pending transactions

    iHttpDataProvider->CancelTransaction();

    IRLOG_DEBUG( "CIRDataProvider::HttpTransactionError - Exiting." );

    }

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

//  CIRDataProvider::HttpResponseCodeRecieved(TInt aResponseCode)

//  Used by CIRHttpDataProvider to indicate to the iSDS Client that a

//  304 Not Changed response received

//  Note: Implemented in version 0.2

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

//

void CIRDataProvider::HttpResponseCodeRecieved( TInt aResponseCode )

    {

    IRLOG_DEBUG( "CIRDataProvider::HttpResponseCodeRecieved - Entering" );

    iDataProviderObserver.IRHttpResponseCodeReceived( aResponseCode, *iResponseHeaders );

    IRLOG_DEBUG( "CIRDataProvider::HttpResponseCodeRecieved- Exiting" );

    }

// constructor support

// don't export these, because used only by functions in this DLL

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

//  CIRDataProvider::CIRDataProvider(MIRDataProviderObserver& aObserver):

//  iDataProviderObserver(aObserver)

//  Default Constructor

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

//

void CIRDataProvider::TimerExpired()

    {

    IRLOG_INFO( "CIRDataProvider::TimerExpired - Entering" );

    IRHttpCancelRequest();

    HttpTransactionError( KDataProviderTimeout );

    IRLOG_INFO( "CIRDataProvider::TimerExpired - Exiting" );

    }

CIRDataProvider::CIRDataProvider( MIRDataProviderObserver &aObserver ):

    iDataProviderObserver( aObserver ) // first-phase C++ constructor

    {

    IRLOG_INFO( "CIRDataProvider::CIRDataProvider" );

    // Definition not required

    }

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

//  void CIRDataProvider::ConstructL()

//  2nd Phase construction

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

//

void CIRDataProvider::ConstructL() // second-phase constructor

    {

    IRLOG_DEBUG( "CIRDataProvider::ConstructL - Entering" );

    _LIT( KXmlFile, "iSdsResponse.xml" );

    ConstructL(KXmlFile);

    iHttpDataProvider->iSetNonUAProfUserAgent = EFalse;

    IRLOG_DEBUG( "CIRDataProvider::ConstructL - Exiting" );

    }

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

//  void CIRDataProvider::ConstructL(TDesC& aFilePath)

//  2nd Phase construction

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

//

void CIRDataProvider::ConstructL( const TDesC &aFileName )

    {

    IRLOG_DEBUG( "CIRDataProvider::ConstructL(const TDesC &aFileName) - Entering" );

    iHttpDataProvider = CIRHttpDataProvider::NewL( *this );

    iDataProviderTimer = CIRDataProviderTimer::NewL( EPriorityHigh,  *this );

    User::LeaveIfError(iFsSession.Connect());

    iIRSettings = CIRSettings::OpenL();

    iXmlFilePath = iIRSettings->PrivatePath();

    iXmlFilePath.Append( aFileName );

    iTimeOut = iIRSettings->GetTimeOut();

    iHttpDataProvider->iSetNonUAProfUserAgent = ETrue;

    IRLOG_DEBUG( "CIRDataProvider::ConstructL(const TDesC &aFileName) - Exiting." );

    }

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

//  CIRDataProvider::NewLC(MIRDataProviderObserver& aObserver)

//  Creates instance of CIRDataProvider.

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

//

CIRDataProvider *CIRDataProvider::NewLC( MIRDataProviderObserver &aObserver )

    {

    IRLOG_DEBUG( "CIRDataProvider::NewLC - Entering." );

    CIRDataProvider *self = new( ELeave )CIRDataProvider( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

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

    return self;

    }

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

//  CIRDataProvider::NewLC(MIRDataProviderObserver& aObserver)

//  Creates instance of CIRDataProvider.

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

//

CIRDataProvider *CIRDataProvider::NewLC( MIRDataProviderObserver &aObserver,

    const TDesC &aFileName )

    {

    IRLOG_DEBUG( "CIRDataProvider::NewLC - Entering." );

    CIRDataProvider *self = new( ELeave )CIRDataProvider( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aFileName );

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

    return self;

    }

EXPORT_C CIRHttpDataProvider* CIRDataProvider::GetHttpDataProvider()

{

IRLOG_DEBUG( "CIRDataProvider::GetHttpDataProvider" );

	return iHttpDataProvider;

}

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

//  CIRDataProvider::SetOffsetSeconds( const TTime& aTime )

//  Stores the offset between device time and response header in settings

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

//

void CIRDataProvider::SetOffsetSeconds( const TTime& aTime )

	{

	IRLOG_DEBUG( "CIRDataProvider::SetOffsetSeconds - Entering" );

	TTime currenttime;

	//calculates the current time

	currenttime.UniversalTime();

	//finds offset from isds response

	TTimeIntervalSeconds offsetseconds;

	//Find offset from isds response

	TInt err = currenttime.SecondsFrom(aTime,offsetseconds);

	if( err )

		{

		//if error offsetseconds is set to zero

		offsetseconds = 0;

		}

	//storing the offset value in setting

	TRAP_IGNORE( iIRSettings->SetTimeCorrectionL(offsetseconds.Int()) )

	IRLOG_DEBUG( "CIRDataProvider::SetOffsetSeconds - Exiting." );

	}