/*

* Copyright (c) 2007-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:  Implements CAcpHttpHandler methods

*

*/

#include <http/thttpevent.h>

#include <http/rhttpheaders.h>

#include <httpstringconstants.h>

#include <http/rhttptransaction.h>

#include <http/rhttpconnectioninfo.h>

#include <http/thttphdrval.h>

#include <commdbconnpref.h>

#include <es_enum.h>

#include <escapeutils.h>

#include "acphttphandler.h"

#include "accountcreationpluginlogger.h"

#include "macphttphandlerobserver.h"

#include "accountcreationengineconstants.h"

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

// CAcpHttpHandler::CAcpHttpHandler

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

//

CAcpHttpHandler::CAcpHttpHandler( MAcpHttpHandlerObserver& aObserver )

    : CActive( CActive::EPriorityStandard ), iObserver( aObserver )

    {

    CActiveScheduler::Add( this );

    }

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

// CAcpHttpHandler::ConstructL

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

//

void CAcpHttpHandler::ConstructL()

    {

    ACPLOG( "CAcpHttpHandler::ConstructL begin" );

    iSession.OpenL();

    ACPLOG( "CAcpHttpHandler::ConstructL end" );

    }

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

// CAcpHttpHandler::NewL

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

//

CAcpHttpHandler* CAcpHttpHandler::NewL( MAcpHttpHandlerObserver& aObserver )

    {

    CAcpHttpHandler* self = CAcpHttpHandler::NewLC( aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAcpHttpHandler::NewLC

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

//

CAcpHttpHandler* CAcpHttpHandler::NewLC( MAcpHttpHandlerObserver& aObserver )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CAcpHttpHandler::~CAcpHttpHandler

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

//

CAcpHttpHandler::~CAcpHttpHandler()

    {

    ACPLOG( "CAcpHttpHandler::~CAcpHttpHandler begin" );

    if ( IsActive() )

        {

        Cancel();

        }

    // Closing the session closes all transactions.

    iSession.Close();

    ShutdownConnection();

    delete iPostData;

    ACPLOG( "CAcpHttpHandler::~CAcpHttpHandler end" );

    }

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

// CAcpHttpHandler::GetDataL

// Fetches data from network.

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

//

void CAcpHttpHandler::GetDataL( const TDesC8& aUrl,

    const TDesC8& aContentType, const TDesC8& aBody, TBool aMimeTypeImage,

    const TDesC8& aSessionId, TBool aGetSisFile )

    {

    ACPLOG( "CAcpHttpHandler::GetDataL begin" ); 

    // Mime type in use.

    iMimeTypeImage = aMimeTypeImage;

    // Copy data to be posted into member variable.

    delete iPostData;

    iPostData = NULL;

    iPostData = aBody.AllocL();

    RHTTPConnectionInfo connInfo = iSession.ConnectionInfo();

    RStringPool pool = iSession.StringPool();

    // Start connection.

    if ( !iConnectionOpen )

        {

        iPromptShown = EFalse; // Always show connection prompt first.

        StartConnectionL();

        }

    connInfo.SetPropertyL(

        pool.StringF( HTTP::EHttpSocketServ, RHTTPSession::GetTable() ),

        THTTPHdrVal( iSocketServer.Handle() ) );

    connInfo.SetPropertyL(

        pool.StringF( HTTP::EHttpSocketConnection, RHTTPSession::GetTable() ),

        THTTPHdrVal( reinterpret_cast<TInt>( &iConnection ) ) );

    TBuf8<KMaxUriLength> url;

    // Insert session id in URLs other than sis URLs.

    if ( aSessionId.Length() && KSisMimeType().Compare( aContentType ) )

        {

        // Change http://address?param=value to

        //        http://adress;jsessionid=[sessionid]?param=value

        // Find ? and insert the session id part before it.

        TInt index = aUrl.Find( KQuestionMark8 );

        if ( KErrNotFound != index )

            {

            url.Append( aUrl.Mid( 0, index ) );

            url.Append( KSessionId );

            url.Append( aSessionId );

            url.Append( aUrl.Mid( index ) );

            }

        }

    else

        {

        // Use original URL.

        url.Copy( aUrl );

        }

    HBufC8* encoded = EscapeUtils::EscapeEncodeL( url,

        EscapeUtils::EEscapeNormal );

    CleanupStack::PushL( encoded );

    TBuf<KMaxUriLength> urlTemp;

    urlTemp.Copy( *encoded );

    ACPLOG2( " - using url: %S", &urlTemp );

    TUriParser8 uriParser;

    User::LeaveIfError( uriParser.Parse( *encoded ) );

    // Use HTTP GET when downloading SIS files.

    if ( aGetSisFile )

        {

        iTransaction = iSession.OpenTransactionL( uriParser, *this,

            GetRequestMethod( HTTP::EGET ) );

        }

    else

        {

        iTransaction = iSession.OpenTransactionL( uriParser, *this,

            GetRequestMethod( HTTP::EPOST ) );

        }

    CleanupStack::PopAndDestroy( encoded );

    // Set request headers.

    RHTTPHeaders hdr = iTransaction.Request().GetHeaderCollection();

    SetHeaderL( hdr, HTTP::EUserAgent, KUserAgent );

    SetHeaderL( hdr, HTTP::EAccept, KAccept );

    // For POST add Content-Type header and set body.

    if ( !aGetSisFile )

        {

        SetHeaderL( hdr, HTTP::EContentType, aContentType );

        iTransaction.Request().SetBody( *this );

        }

    // If connection has been opened already, submit transaction.

    if ( iConnectionOpen )

        {

        iConnection.Progress( iNifProgress );

        if ( !iNifProgress.iError && KLinkLayerOpen == iNifProgress.iStage )

            {

            ACPLOG( " - connection still open, submit next transaction" );

            SubmitTransactionL();

            }

        else

            {

            // Connection lost or not started, restart it.

            ACPLOG( " - connection lost, reconnect" );

            iConnectionOpen = EFalse;

            if ( !IsActive() ) 

                {

                iConnection.Start( iStatus );

                SetActive();

                }

            }

        }

    ACPLOG( "CAcpHttpHandler::GetDataL end" );

    }

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

// CAcpHttpHandler::SubmitTransactionL

// Submits HTTP transaction.

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

//

void CAcpHttpHandler::SubmitTransactionL()

    {

    ACPLOG( "CAcpHttpHandler::SubmitTransactionL begin" );

    // Submit the transaction. 

    // From now on, response event comes to MHFRunL and/or MHFRunError.

    iTransaction.SubmitL();

    iTransactionRunning = ETrue;

    ACPLOG( "CAcpHttpHandler::SubmitTransactionL end" );

    }

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

// CAcpHttpHandler::GetRequestMethod

// Returns request method based on type.

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

//

RStringF CAcpHttpHandler::GetRequestMethod( TInt aType ) const

    {

    return iSession.StringPool().StringF( aType, RHTTPSession::GetTable() );

    }

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

// CAcpHttpHandler::StartConnectionL

// Starts the connection asynchronously.

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

//

void CAcpHttpHandler::StartConnectionL()

    {

    ACPLOG( "CAcpHttpHandler::StartConnectionL begin" );

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

    User::LeaveIfError( iConnection.Open( iSocketServer ) );

    TCommDbConnPref pref;

    pref.SetDirection( ECommDbConnectionDirectionOutgoing );

    pref.SetBearerSet( KCommDbBearerLAN | KCommDbBearerCSD |

        KCommDbBearerWcdma | KCommDbBearerWLAN );

    // Show connection prompt only once.

    if ( !iPromptShown )

        {

        ACPLOG( " - show connection prompt" );

        pref.SetDialogPreference( ECommDbDialogPrefPrompt );

        iPromptShown = ETrue;

        }

    else

        {

        ACPLOG3( " - set iap %d / net %d", iIapId, iNetId );

        pref.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );

        pref.SetIapId( iIapId );

        pref.SetNetId( iNetId );

        }

    if ( !IsActive() ) 

        {

        iConnection.Start( pref, iStatus );

        SetActive();

        }

    ACPLOG( "CAcpHttpHandler::StartConnectionL end" );

    }

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

// CAcpHttpHandler::CancelTransaction

// Cancels ongoing transaction and frees the resources.

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

//

void CAcpHttpHandler::CancelTransaction()

    {

    ACPLOG( "CAcpHttpHandler::CancelTransaction begin" );

    if ( !iTransactionRunning )

        {

        ACPLOG( "CAcpHttpHandler::CancelTransaction end (not running)" );

        return;

        }

    iTransaction.Close();

    ACPLOG( " - transaction closed" );

    iTransactionRunning = EFalse;

    ACPLOG( "CAcpHttpHandler::CancelTransaction end" );

    }

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

// CAcpHttpHandler::ShutdownConnection

// Shuts down connection.

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

//

void CAcpHttpHandler::ShutdownConnection()

    {

    ACPLOG( "CAcpHttpHandler::ShutdownConnection begin" );

    iConnection.Close();

    iSocketServer.Close();

    ACPLOG( "CAcpHttpHandler::ShutdownConnection end" );

    }

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

// CAcpHttpHandler::SetHeaderL

// Sets transaction's request headers.

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

//

void CAcpHttpHandler::SetHeaderL( 

    RHTTPHeaders aHeaders, 

    TInt aHdrField, 

    const TDesC8& aHdrValue )

    {

    RStringF valStr = iSession.StringPool().OpenFStringL( aHdrValue );

    CleanupClosePushL( valStr );

    THTTPHdrVal val( valStr );

    aHeaders.SetFieldL( iSession.StringPool().StringF(

        aHdrField, RHTTPSession::GetTable() ), val );

    CleanupStack::PopAndDestroy( &valStr );

    ACPLOG( "CAcpHttpHandler::SetHeaderL: Request headers set." );

    }

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

// CAcpHttpHandler::GetNextDataPart

// From MHTTPDataSupplier.

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

//

TBool CAcpHttpHandler::GetNextDataPart( TPtrC8& aDataPart )

    {

    ACPLOG( "CAcpHttpHandler::GetNextDataPart begin" );

    if ( iPostData )

        {

        aDataPart.Set( iPostData->Des() );

        }

    ACPLOG( "CAcpHttpHandler::GetNextDataPart end" );

    return ETrue;

    }

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

// CAcpHttpHandler::ReleaseData

// From MHTTPDataSupplier.

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

//

void CAcpHttpHandler::ReleaseData()

    {

    ACPLOG( "CAcpHttpHandler::ReleaseData begin" );

    delete iPostData;

    iPostData = NULL;

    ACPLOG( "CAcpHttpHandler::ReleaseData end" );

    }

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

// CAcpHttpHandler::OverallDataSize

// From MHTTPDataSupplier.

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

//

TInt CAcpHttpHandler::OverallDataSize()

    {

    ACPLOG( "CAcpHttpHandler::OverallDataSize begin" );

    if ( iPostData )

        {

        ACPLOG2( "CAcpHttpHandler::OverallDataSize end (%d)",

            iPostData->Length() );

        return iPostData->Length();

        }

    else

        {

        ACPLOG( "CAcpHttpHandler::OverallDataSize end" );

        return KErrNotFound ;

        }

    }

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

// CAcpHttpHandler::Reset

// From MHTTPDataSupplier.

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

//

TInt CAcpHttpHandler::Reset()

    {

    if ( iPostData )

        {

        // iPostData (which is used as data source) is found.

        return KErrNone;

        }

    return KErrNotFound;

    }

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

// CAcpHttpHandler::MHFRunL

// From MHTTPTransactionCallback.

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

//

void CAcpHttpHandler::MHFRunL( 

    RHTTPTransaction aTransaction, 

    const THTTPEvent& aEvent )

    {

    ACPLOG2( "CAcpHttpHandler::MHFRunL: THTTPEvent=%d", aEvent.iStatus );

    switch ( aEvent.iStatus )

        {

        case THTTPEvent::EGotResponseHeaders:

            {

            ProcessHeadersL( aTransaction );

            iObserver.NotifyHttpEvent( aEvent.iStatus );

            }

            break;

        case THTTPEvent::EGotResponseBodyData:

            {

            MHTTPDataSupplier* body = aTransaction.Response().Body();

            TPtrC8 dataChunk;

            TBool isLast = body->GetNextDataPart( dataChunk );

            iObserver.NotifyBodyReceived( dataChunk );

            // Check if more data is expected.

            if ( isLast )

                {

                iObserver.NotifyHttpEvent( aEvent.iStatus );

                }

            // Always remember to release the body data.

            body->ReleaseData();

            }           

            break;

        case THTTPEvent::EResponseComplete:

            {

            iObserver.NotifyHttpEvent( aEvent.iStatus );

            }           

            break;

        case THTTPEvent::ESucceeded:

            {

            ACPLOG( " - HTTP event: succeeded" );

            CancelTransaction();

            iObserver.NotifyHttpEvent( aEvent.iStatus );

            }           

            break;

        case THTTPEvent::EFailed:

            {

            ACPLOG( " - HTTP event: failed" );

            CancelTransaction();

            iObserver.NotifyHttpEvent( aEvent.iStatus );

            }           

            break;

        default:

            {

            // Check if some other real error received.

            if ( aEvent.iStatus != THTTPEvent::ERedirectedTemporarily )

                {

                CancelTransaction();

                iObserver.NotifyHttpError( aEvent.iStatus );

                // HTTP error occurred, it's safer to restart the connection.

                iConnectionOpen = EFalse;

                iSession.Close();

                iConnection.Close();

                iSocketServer.Close();

                // Reopen session.

                iSession.OpenL();

                }

            }

            break;

        }

    }

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

// CAcpHttpHandler::MHFRunError

// From MHTTPTransactionCallback.

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

//

TInt CAcpHttpHandler::MHFRunError( 

    TInt aError, 

    RHTTPTransaction /*aTransaction*/, 

    const THTTPEvent& /*aEvent*/ )

    {

    ACPLOG2( "CAcpHttpHandler::MHFRunError: aError = %d", aError );

    iObserver.NotifyHttpError( aError );

    // HTTP error occurred, it's safer to restart the connection.

    iConnectionOpen = EFalse;

    iSession.Close();

    iConnection.Close();

    iSocketServer.Close();

    // Reopen session.

    TRAP_IGNORE( iSession.OpenL() );

    return KErrNone;