/*

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

*

*/

#ifdef REQUEST_ZIP_RESPONSE

#include <ezgzip.h>

#include <bautils.h>

#include <f32file.h>

#endif

#include "irdataprovider.h"

#include "irdataproviderobserver.h"

#include "irdebug.h"

#include "irhttpdataprovider.h"

#include "irhttprequestdata.h"

#include "irsettings.h"

#ifdef REQUEST_ZIP_RESPONSE

_LIT( KGzXmlFile, "iSdsResponse.xml.gz" );

#endif

_LIT( KXmlFile, "iSdsResponse.xml" );

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

//  CIRDataProvider::NewL()

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

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

    {

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

    if ( iHttpDataProvider )

        {

        iHttpDataProvider->CancelTransaction();

        delete iHttpDataProvider;

        }

    if ( iIRSettings )

        {

        iIRSettings->Close();

        }

    if ( iDataProviderTimer )

        {

        iDataProviderTimer->Cancel();

        delete iDataProviderTimer;

        }

    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

#ifdef REQUEST_ZIP_RESPONSE

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

#else

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

#endif

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

#ifdef REQUEST_ZIP_RESPONSE

    // unzip the gz file

    TRAP_IGNORE( UnzipFileL( iXmlFilePath ) );

    // delete the original gz file

    BaflUtils::DeleteFile( iFsSession, iXmlGzFilePath );

#endif

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

    // prevents the destructor to delete in case something streange happens.

    iResponseHeaders = NULL;

    iDataProviderObserver.IRHttpDataReceived( iXmlFilePath, *currentHeaders );

    delete currentHeaders;

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

    }

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

//  CIRDataProvider::ExtractHeaderValue()

//  

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

//

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

//  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." );

    }

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

//  CIRDataProvider::HttpDateHeaderReceived()

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

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

//

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

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

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

//  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::TimerExpired()

//  Called to indicate expiry of timer

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

//

void CIRDataProvider::TimerExpired()

    {

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

    IRHttpCancelRequest();

    HttpTransactionError( KDataProviderTimeout );

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

    }

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

//  CIRDataProvider::CIRDataProvider()

//  Default Constructor

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

//

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

    {

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

#ifdef REQUEST_ZIP_RESPONSE

    ConstructL( KGzXmlFile );

#else

    ConstructL(KXmlFile);

#endif

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

#ifdef REQUEST_ZIP_RESPONSE

    iXmlGzFilePath = iIRSettings->PrivatePath();

    iXmlFilePath = iXmlGzFilePath;

    iXmlGzFilePath.Append( aFileName );

    iXmlFilePath.Append( KXmlFile );

#else

    iXmlFilePath = iIRSettings->PrivatePath();

    iXmlFilePath.Append( aFileName );

#endif

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

//  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." );

    }

#ifdef REQUEST_ZIP_RESPONSE

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

//  CIRDataProvider::UnzipFileL

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

//

void CIRDataProvider::UnzipFileL( const TDesC& aOutputFile )

    {

    IRLOG_DEBUG( "CIRDataProvider::UnzipFileL - Enter." );

    RFile outputFile;

    CleanupClosePushL( outputFile );

    User::LeaveIfError( outputFile.Replace( iFsSession, aOutputFile, 

                        EFileStream | EFileWrite | EFileShareExclusive ) );

    CEZGZipToFile* gZip = 

        CEZGZipToFile::NewLC( iFsSession, iXmlGzFilePath, outputFile );

    while ( gZip->InflateL() )

        {

        // unzip the gz file, quit when finish

        }

    CleanupStack::PopAndDestroy( gZip );

    CleanupStack::PopAndDestroy( &outputFile );

    IRLOG_DEBUG( "CIRDataProvider::UnzipFileL - Exit." );

    }

#endif

// End of file