/*

* Copyright (c) 2010 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: Implementation of HTTP client engine class.

*

*/

//Symbian headers

#include "posrevgeocodehttpclientengine.h"

#include "posrevgeocodelogger.h"

#include <http.h>

#include <CommDbConnPref.h>

#include <connpref.h>

#include <extendedconnpref.h>

#include <cmgenconnsettings.h>

// Used user agent for requests

_LIT8(KUserAgent, "ReverseGeoCode 1.0");

// This client accepts all content types.

_LIT8(KAccept, "*/*");

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

// CPosRevGeoCodeHTTPClientEngine::NewL()

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

CPosRevGeoCodeHTTPClientEngine* CPosRevGeoCodeHTTPClientEngine::NewL( 

                                    MPosRevGeoCodeHTTPClientObserver& aObserver )

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::NewL");

    CPosRevGeoCodeHTTPClientEngine* self = new ( ELeave ) 

                                    CPosRevGeoCodeHTTPClientEngine( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPosRevGeoCodeHTTPClientEngine::CPosRevGeoCodeHTTPClientEngine()

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

CPosRevGeoCodeHTTPClientEngine::CPosRevGeoCodeHTTPClientEngine(

                                              MPosRevGeoCodeHTTPClientObserver& aObserver ): 

                                              CActive( CActive::EPriorityStandard ),

                                              iObserver( aObserver ),

                                              iConnectionSetupDone( EFalse ),

                                              iPrevProfileId( -1 ),

                                              iMobility(NULL),

                                              iTransactionOpen( EFalse ),

                                              iUri(NULL)

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::CPosRevGeoCodeHTTPClientEngine");

    CActiveScheduler::Add(this);

    }

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

// CPosRevGeoCodeHTTPClientEngine::~CPosRevGeoCodeHTTPClientEngine()

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

CPosRevGeoCodeHTTPClientEngine::~CPosRevGeoCodeHTTPClientEngine()

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::~CPosRevGeoCodeHTTPClientEngine");

    Cancel();

    if( iMobility )

        {

		iMobility->Cancel();

        delete iMobility;

        }

    if ( iTransactionOpen )

        {

        iTransaction.Close();

        }

    iSession.Close();

    iConnection.Close();

    iSocketServ.Close();

    delete iUri;

    iCmManager.Close();

    }

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

// CPosRevGeoCodeHTTPClientEngine::ConstructL()

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

void CPosRevGeoCodeHTTPClientEngine::ConstructL()

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::ConstructL");

    iCmManager.OpenL();

    }

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

// CPosRevGeoCodeHTTPClientEngine::CloseConnection()

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

void CPosRevGeoCodeHTTPClientEngine::CloseConnection()

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::CloseConnection");

    if ( iTransactionOpen )

        {

        iTransaction.Close();

        iTransactionOpen = EFalse;

        }

    if ( iMobility )

        {

        iMobility->Cancel();

        delete iMobility;

        iMobility = NULL;

        }

    iSession.Close();

    iConnection.Close();

    iSocketServ.Close();  

    iConnectionSetupDone = EFalse;

    }

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

// CPosRevGeoCodeHTTPClientEngine::SetupConnectionL()

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

void CPosRevGeoCodeHTTPClientEngine::SetupConnectionL()

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::SetupConnectionL");

    if ( iConnectionSetupDone )

        {

        // Connection setup is done

        User::Leave(KErrAlreadyExists);

        }

    // Open HTTP Session

    iSession.OpenL();

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

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

    TConnPrefList prefList;

    TExtendedConnPref prefs;

    prefs.SetSnapPurpose( CMManager::ESnapPurposeInternet );

    prefs.SetForcedRoaming( EFalse );

    prefs.SetBearerSet( TExtendedConnPref::EExtendedConnBearerCellular | 

                        TExtendedConnPref::EExtendedConnBearerWLAN );

    prefList.AppendL( &prefs );

    iConnection.Start( prefList,iStatus );

    SetActive();

    }

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

// CPosRevGeoCodeHTTPClientEngine::SetHeaderL()

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

void CPosRevGeoCodeHTTPClientEngine::SetHeaderL( RHTTPHeaders aHeaders, TInt aHdrField, const TDesC8& aHdrValue )

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::SetHeaderL");

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

    CleanupClosePushL( valStr );

    THTTPHdrVal val(valStr);

    aHeaders.SetFieldL( iSession.StringPool().StringF( aHdrField, RHTTPSession::GetTable()), val);

    CleanupStack::PopAndDestroy();  // valStr

    }

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

// CPosRevGeoCodeHTTPClientEngine::IssueHTTPGetL()

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

void CPosRevGeoCodeHTTPClientEngine::IssueHTTPGetL( const TDesC8& aUri )

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::IssueHTTPGetL");

    if ( IsActive() )

        {

        return;

        }

    iEngineState = EGet;

    delete iUri;

    iUri = NULL;

    iUri = aUri.AllocL();

    // Create HTTP connection

    TRAPD( err, SetupConnectionL() );

    //If the Err is KErrNone, It will lead to RunL and

    //hence jump to the DoHTTPGetL() from there.

    if( err == KErrAlreadyExists )

        {

        DoHTTPGetL();

        }

    else if( err != KErrNone )

        {

        //If Setup Connection fails

        iObserver.ClientEvent( EHttpConnectionFailure );

        User::Leave(err);

        }

    }

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

// CPosRevGeoCodeHTTPClientEngine::DoHTTPGetL()

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

void CPosRevGeoCodeHTTPClientEngine::DoHTTPGetL()

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::DoHTTPGetL");

    // Parse string to URI (as defined in RFC2396)

    TUriParser8 uri;

    uri.Parse( *iUri );

    // Get request method string for HTTP GET

    RStringF method = iSession.StringPool().StringF( HTTP::EGET,RHTTPSession::GetTable() );

    CleanupClosePushL( method );

    // Open transaction with previous method and parsed uri. This class will

    // receive transaction events in MHFRunL and MHFRunError.

    iTransaction = iSession.OpenTransactionL( uri, *this, method );

    iTransactionOpen = ETrue;

    // Set headers for request; user agent and accepted content type

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

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

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

    // Submit the transaction. After this the framework will give transaction

    // events via MHFRunL and MHFRunError.

    iTransaction.SubmitL();

    CleanupStack::PopAndDestroy( 1 ); // method

    iObserver.ClientEvent( EHttpConnecting );

    }

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

// CPosRevGeoCodeHTTPClientEngine::CancelTransaction()

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

void CPosRevGeoCodeHTTPClientEngine::CancelTransaction()

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::CancelTransaction");

    iEngineState = EIdle;

    delete iUri; 

    iUri = NULL;

    // Close() also cancels transaction (Cancel() can also be used but

    // resources allocated by transaction must be still freed with Close())

    if( iTransactionOpen )

        {

        iTransaction.Close();

        iTransactionOpen = EFalse;

        iObserver.ClientEvent( EHttpTxCancelled );

        }

    }

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

// CPosRevGeoCodeHTTPClientEngine::MHFRunL()

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

void CPosRevGeoCodeHTTPClientEngine::MHFRunL( RHTTPTransaction aTransaction, const THTTPEvent& aEvent )

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::MHFRunL");

    switch ( aEvent.iStatus )

        {

        case THTTPEvent::EGotResponseHeaders:

            {

            // HTTP response headers have been received. Use

            // aTransaction.Response() to get the response. However, it's not

            // necessary to do anything with the response when this event occurs.

            iObserver.ClientEvent( EHttpHdrReceived );

            break;

            }

        case THTTPEvent::EGotResponseBodyData:

            {

            // Part (or all) of response's body data received. Use

            // aTransaction.Response().Body()->GetNextDataPart() to get the actual

            // body data.

            // Get the body data supplier

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

            TPtrC8 dataChunk;

            // GetNextDataPart() returns ETrue, if the received part is the last

            // one.

            TBool isLast = body->GetNextDataPart(dataChunk);

            iObserver.ClientBodyReceived(dataChunk);

            iObserver.ClientEvent( EHttpBytesReceieved );

            // NOTE: isLast may not be ETrue even if last data part received.

            // (e.g. multipart response without content length field)

            // Use EResponseComplete to reliably determine when body is completely

            // received.

            if( isLast )

                {

                iObserver.ClientEvent( EHttpBodyReceieved );

                }

            // Always remember to release the body data.

            body->ReleaseData();

            break;

            }

        case THTTPEvent::EResponseComplete:

            {

            // Indicates that header & body of response is completely received.

            // No further action here needed.

            iObserver.ClientEvent( EHttpTxCompleted );

            break;

            }

        case THTTPEvent::ESucceeded:

            {

            // Indicates that transaction succeeded.

            iObserver.ClientEvent( EHttpTxSuccess );

            // Transaction can be closed now. It's not needed anymore.

            aTransaction.Close();

            iTransactionOpen = EFalse;

            break;

            }

        case THTTPEvent::EFailed:

            {

            // Transaction completed with failure.

            iObserver.ClientEvent( EHttpTxFailed );

            aTransaction.Close();

            iTransactionOpen = EFalse;

            break;

            }

        default:

            // There are more events in THTTPEvent, but they are not usually

            // needed. However, event status smaller than zero should be handled

            // correctly since it's error.

            {

            if ( aEvent.iStatus < 0 )

                {

                iObserver.ClientEvent( EHttpConnectionFailure );

                // Close the transaction on errors

                aTransaction.Close();

                iTransactionOpen = EFalse;

                }

                break;

            }

        }

    }

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

// CPosRevGeoCodeHTTPClientEngine::MHFRunError()

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

TInt CPosRevGeoCodeHTTPClientEngine::MHFRunError( TInt /*aError*/, 

                                                  RHTTPTransaction /*aTransaction*/,

                                                  const THTTPEvent& /*aEvent*/ )

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::MHFRunError");

    // Just notify about the error and return KErrNone.

    CloseConnection();

    iObserver.ClientEvent(EHttpMhfRunError);

    return KErrNone;

    }

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

// CPosRevGeoCodeHTTPClientEngine::PreferredCarrierAvailable()

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

void CPosRevGeoCodeHTTPClientEngine::PreferredCarrierAvailable( 

                                               TAccessPointInfo /*aOldAPInfo*/,

                                               TAccessPointInfo /*aNewAPInfo*/,

                                               TBool /*aIsUpgrade*/,

                                               TBool aIsSeamless )

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::PreferredCarrierAvailable");

    if( !aIsSeamless && iMobility)

        {

        iMobility->MigrateToPreferredCarrier();

        }

    }

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

// CPosRevGeoCodeHTTPClientEngine::NewCarrierActive()

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

void CPosRevGeoCodeHTTPClientEngine::NewCarrierActive( TAccessPointInfo /*aNewAPInfo*/,

                                                      TBool aIsSeamless )

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::NewCarrierActive");

    if( !aIsSeamless && iMobility)

        {

        iMobility->NewCarrierAccepted();

        }

    }

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

// CPosRevGeoCodeHTTPClientEngine::Error()

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

void CPosRevGeoCodeHTTPClientEngine::Error(TInt /*aError*/)

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::Error");

    }

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

// CPosRevGeoCodeHTTPClientEngine::DoCancel()

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

void CPosRevGeoCodeHTTPClientEngine::DoCancel()

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::DoCancel");

    iConnection.Stop();

    }

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

// CPosRevGeoCodeHTTPClientEngine::DoCancel()

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

TInt CPosRevGeoCodeHTTPClientEngine::RunError(TInt /*aError*/)

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::RunError");

    // Just notify about the error and return KErrNone.

    CloseConnection();

    iObserver.ClientEvent( EHttpTxFailed );

    return KErrNone;

    }

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

// CPosRevGeoCodeHTTPClientEngine::RunL()

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

void CPosRevGeoCodeHTTPClientEngine::RunL()

    {

    FUNC("CPosRevGeoCodeHTTPClientEngine::RunL");

    TInt statusCode = iStatus.Int();

    if ( statusCode == KErrNone )

        {

        // Connection done ok

        iConnectionSetupDone = ETrue;

        RStringPool strPool = iSession.StringPool();

        CleanupClosePushL( strPool );

        // Remove first session properties just in case.

        RHTTPConnectionInfo connInfo = iSession.ConnectionInfo();

        // Clear RConnection and Socket Server instances

        connInfo.RemoveProperty(strPool.StringF(HTTP::EHttpSocketServ,RHTTPSession::GetTable()));

        connInfo.RemoveProperty(strPool.StringF(HTTP::EHttpSocketConnection,RHTTPSession::GetTable()));

        // Clear the proxy settings

        connInfo.RemoveProperty(strPool.StringF(HTTP::EProxyUsage,RHTTPSession::GetTable()));

        connInfo.RemoveProperty(strPool.StringF(HTTP::EProxyAddress,RHTTPSession::GetTable()));

        // RConnection and Socket Server

        connInfo.SetPropertyL ( strPool.StringF(HTTP::EHttpSocketServ, 

                                        RHTTPSession::GetTable()), 

                                THTTPHdrVal (iSocketServ.Handle()) );

        TInt connPtr1 = REINTERPRET_CAST(TInt, &iConnection);

        connInfo.SetPropertyL ( strPool.StringF(HTTP::EHttpSocketConnection, 

                                RHTTPSession::GetTable() ), THTTPHdrVal (connPtr1) );    

        // Register for mobility API

        delete iMobility;

        iMobility = NULL;

        iMobility = CActiveCommsMobilityApiExt::NewL( iConnection, *this );

        CleanupStack::Pop( &strPool ); // strPool

        // Start selected HTTP action

        switch( iEngineState )

            {

            case EIdle:

                {

                //

                CancelTransaction();

                break;

                }

            case EGet:

               {

               DoHTTPGetL();

               break;

               }

            };

        }

    else

        {

        //handle error

        if ( statusCode == KErrPermissionDenied )

            {

            iObserver.ClientEvent( EHttpAuthFailed );

            }

        else

            {

            //Throw some general Transaction falure error!

            iObserver.ClientEvent( EHttpTxFailed );

            }

        CloseConnection();

        }

    }

// End of file