httpclientengine.cpp

SYMBIAN S60 2ND列车时刻表软件

/*
* ==============================================================================
*  Name        : HttpClientEngine.cpp
*  Part of     : MOPlay V1 S60
*  Description : Implementation of the http client class.
*  Version     : 1
*  Author	   : Johnson
*  Create date : 2007-4-11
*  Last Update : Johnson
*  Update date : 2007-5-29
* ==============================================================================
*/

// INCLUDE FILES
#include <avkon.hrh>
#include <aknnotewrappers.h>
#include <stringloader.h>
#include <http.h>
#include <S32FILE.H>
#include <f32file.h>
#include <http/thttphdrval.h>
#include "HttpClientEngine.h"
#include "HttpConnection.h"
#include "MagicTrain.pan"
#include "Train.rsg"
// ----------------------------------------------------------------------------
// CHttpClientEngine::NewL()
// Creates instance of CHttpClientEngine.
// ----------------------------------------------------------------------------
//
CHttpClientEngine* CHttpClientEngine::NewL( MWebClientObserver& aObserver )
    {
    CHttpClientEngine* self = CHttpClientEngine::NewLC( aObserver );
    CleanupStack::Pop( self );
    return self;
    }


// ----------------------------------------------------------------------------
// CHttpClientEngine::NewLC()
// Creates instance of CHttpClientEngine.
// ----------------------------------------------------------------------------
//
CHttpClientEngine* CHttpClientEngine::NewLC( MWebClientObserver& aObserver )
    {
    CHttpClientEngine* self = new (ELeave) CHttpClientEngine( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


// ----------------------------------------------------------------------------
// CHttpClientEngine::CHttpClientEngine()
// First phase constructor.
// ----------------------------------------------------------------------------
//
CHttpClientEngine::CHttpClientEngine( MWebClientObserver& aObserver )
:    iObserver( aObserver ),
     iRunning( EFalse )
    {
    // no implementation required
    }


// ----------------------------------------------------------------------------
// CHttpClientEngine::~CHttpClientEngine()
// Destructor.
// ----------------------------------------------------------------------------
//
CHttpClientEngine::~CHttpClientEngine()
    {
    	CancelTransactionL();
    iSession.Close();
    }


// ----------------------------------------------------------------------------
// CHttpClientEngine::ConstructL()
// Second phase construction.
// ----------------------------------------------------------------------------
//
void CHttpClientEngine::ConstructL()
    {
    // Open RHTTPSession with default protocol ("HTTP/TCP")
    TRAPD( err, iSession.OpenL() );
    if( err != KErrNone ) {
        HBufC* textResource = StringLoader::LoadLC( R_WEBCLIENT_IAP_CONF_ERR, err );
        CAknErrorNote* errorNote;
        errorNote = new (ELeave) CAknErrorNote;
        // Show the error Note with textResource loaded with StringLoader.
        errorNote->ExecuteLD( *textResource);
        // Pop HBuf from CleanUpStack and Destroy it.
        CleanupStack::PopAndDestroy( textResource );
        User::Leave( err );
    }
    // Install this class as the callback for authentication requests. When 
    // page requires authentication the framework calls GetCredentialsL to get 
    // user name and password.
    InstallAuthenticationL( iSession );
    }


// ----------------------------------------------------------------------------
// CHttpClientEngine::SetHeaderL()
// Used to set header value to HTTP request
// ----------------------------------------------------------------------------
//
void CHttpClientEngine::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 );
    }

// ----------------------------------------------------------------------------
// CHttpClientEngine::DumpRespHeadersL(RHTTPTransaction& aTransaction)
// Used to display HTTP header field names and values
// ----------------------------------------------------------------------------
//
void CHttpClientEngine::DumpRespHeadersL( RHTTPTransaction& aTransaction )
    {
    RHTTPResponse resp = aTransaction.Response();
    RStringPool strP = aTransaction.Session().StringPool();
    RHTTPHeaders hdr = resp.GetHeaderCollection();
    THTTPHdrFieldIter it = hdr.Fields();

    HBufC* headerField = HBufC::NewLC( KMaxHeaderNameLength + KMaxHeaderValueLength );
    HBufC* fieldValBuf = HBufC::NewLC( KMaxHeaderValueLength );

    while ( it.AtEnd() == EFalse )
        {
        RStringTokenF fieldName = it();
        RStringF fieldNameStr = strP.StringF( fieldName );
        THTTPHdrVal fieldVal;
        if ( hdr.GetField( fieldNameStr, 0, fieldVal ) == KErrNone )
            {
            const TDesC8& fieldNameDesC = fieldNameStr.DesC();
            headerField->Des().Copy( fieldNameDesC.Left( KMaxHeaderNameLength ));
            fieldValBuf->Des().Zero();
            switch ( fieldVal.Type() )
                {
            // the value is an integer
            case THTTPHdrVal::KTIntVal:
                fieldValBuf->Des().Num( fieldVal.Int() );
                break;
            // the value is a case-insensitive string
            case THTTPHdrVal::KStrFVal:
                {
                RStringF fieldValStr = strP.StringF( fieldVal.StrF() );
                const TDesC8& fieldValDesC = fieldValStr.DesC();
                fieldValBuf->Des().Copy( fieldValDesC.Left(KMaxHeaderValueLength ));
                }
                break;
            // the value is a case-sensitive string
            case THTTPHdrVal::KStrVal:
                {
                RString fieldValStr = strP.String( fieldVal.Str() );
                const TDesC8& fieldValDesC = fieldValStr.DesC();
                fieldValBuf->Des().Copy( fieldValDesC.Left(KMaxHeaderValueLength) );
                }
                break;
            // the value is a date/time
            case THTTPHdrVal::KDateVal:
                {
                TDateTime date = fieldVal.DateTime();
                TBuf<KMaxDateTimeStringLength> dateTimeString;
                TTime t( date );
                t.FormatL( dateTimeString,KDateFormat );
                fieldValBuf->Des().Copy( dateTimeString );
                } 
                break;
            // the value is type is unknown
            default:
                break;
                }

            // Display HTTP header field name and value
            headerField->Des().Append( KColon );
            headerField->Des().Append( *fieldValBuf );
            iObserver.ClientHeaderReceived( *headerField );
            
            // Display realm for WWW-Authenticate header
            RStringF wwwAuth = strP.StringF( HTTP::EWWWAuthenticate,RHTTPSession::GetTable() );
            if ( fieldNameStr == wwwAuth )
                {
                // check the auth scheme is 'basic'
                RStringF basic = strP.StringF( HTTP::EBasic,RHTTPSession::GetTable() );
                RStringF realm = strP.StringF( HTTP::ERealm,RHTTPSession::GetTable() );
                THTTPHdrVal realmVal;
                if (( fieldVal.StrF() == basic ) && 
                    ( !hdr.GetParam( wwwAuth, realm, realmVal )))
                    {
                    RStringF realmValStr = strP.StringF( realmVal.StrF() );
                    fieldValBuf->Des().Copy( realmValStr.DesC() );
                    headerField->Des().Copy( Krealm );
                    headerField->Des().Append( *fieldValBuf );
                    iObserver.ClientHeaderReceived( *headerField );
                    }
                }
            }
        ++it;
        }
        CleanupStack::PopAndDestroy( fieldValBuf );
        CleanupStack::PopAndDestroy( headerField );
    }

// ----------------------------------------------------------------------------
// CHttpClientEngine::HandleRunErrorL()
// Called from MHFRunError() when *leave* occurs in handling of transaction event.
// ----------------------------------------------------------------------------
//
void CHttpClientEngine::HandleRunErrorL( TInt aError )
    {
    HBufC* textResource = StringLoader::LoadL( R_WEBCLIENT_MHFRUN_ERROR, aError );
    // Notify about the error
    iObserver.ClientEvent( *textResource );
    CleanupStack ::PopAndDestroy( textResource );
    iObserver.ClientFailed();
    }

// ----------------------------------------------------------------------------
// CHttpClientEngine::IssueHTTPGetL()
// Start a new HTTP GET transaction.
// ----------------------------------------------------------------------------
//
void CHttpClientEngine::IssueHTTPGetL( const TDesC8& aUri )
    {
    // Parse string to URI (as defined in RFC2396)
    TUriParser8 uri;
    uri.Parse( aUri );

    // Get request method string for HTTP GET
	CHttpConnection* httpconnection = CHttpConnection::InstanceL();
	if (!httpconnection) {
		User::Leave(KErrOpenSocket);
	}
	RHTTPConnectionInfo connInfo = iSession.ConnectionInfo();
	RStringPool pool = iSession.StringPool();

	connInfo.SetPropertyL(pool.StringF(HTTP::EHttpSocketServ,
	RHTTPSession::GetTable()), THTTPHdrVal(httpconnection->iSocksvr.Handle()));
	TInt connPtr = REINTERPRET_CAST(TInt, &httpconnection->iConnection);
	
	connInfo.SetPropertyL(pool.StringF(HTTP::EHttpSocketConnection,
	RHTTPSession::GetTable()), THTTPHdrVal(connPtr));
	  RStringF method = pool.StringF( HTTP::EGET,RHTTPSession::GetTable());
	
    // Open transaction with previous method and parsed uri. This class will
    // receive transaction events in MHFRunL and MHFRunError.
    iTransaction = iSession.OpenTransactionL( uri, *this, method );

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

    iRunning = ETrue;
    }


// ----------------------------------------------------------------------------
// CHttpClientEngine::CancelTransactionL()
// Cancels currently running transaction and frees resources related to it.
// ----------------------------------------------------------------------------
//
void CHttpClientEngine::CancelTransactionL()
    {
    if( !iRunning ) 
        return;

    // Close() also cancels transaction (Cancel() can also be used but 
    // resources allocated by transaction must be still freed with Close())
    iTransaction.Close();

    // Not running anymore
    iRunning = EFalse;
    }

// ----------------------------------------------------------------------------
// CHttpClientEngine::MHFRunL()
// Inherited from MHTTPTransactionCallback
// Called by framework to pass transaction events.
// ----------------------------------------------------------------------------
//
void CHttpClientEngine::MHFRunL( RHTTPTransaction aTransaction, 
                                const THTTPEvent& aEvent )
    {
	TPtrC8 dataChunk;
    switch ( aEvent.iStatus ) 
        {
        case THTTPEvent::EGotResponseHeaders:
            {

            RHTTPResponse resp = aTransaction.Response();
            TInt status = resp.StatusCode();

            TBuf<KMaxStatusTextLength> statusText;
            statusText.Copy( resp.StatusText().DesC() );

           
            DumpRespHeadersL( aTransaction );

            }
            break;

        case THTTPEvent::EGotResponseBodyData:
            {

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


            TBool isLast = body->GetNextDataPart( dataChunk );
            iObserver.ClientBodyReceived( dataChunk );
 
            body->ReleaseData();

            }
            break;

        case THTTPEvent::EResponseComplete:
            {
            }
            break;

        case THTTPEvent::ESucceeded:
            {
			iObserver.ClientSuccess();
            CancelTransactionL();
            //aTransaction.Close();
            iRunning = EFalse;
			
            }
            break;

        case THTTPEvent::EFailed:
            {
            iObserver.ClientFailed();
            aTransaction.Close();
            iRunning = 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 )
                {
                // Just close the transaction on errors
                aTransaction.Close();
                iRunning = EFalse;
                iObserver.ClientFailed();
                } else {
                }
            }
            break;
        }
    }

// ----------------------------------------------------------------------------
// CHttpClientEngine::MHFRunError()
// Inherited from MHTTPTransactionCallback
// Called by framework when *leave* occurs in handling of transaction event.
// These errors must be handled, or otherwise HTTP-CORE 6 panic is thrown.
// ----------------------------------------------------------------------------
//
TInt CHttpClientEngine::MHFRunError( TInt aError, 
                                    RHTTPTransaction /*aTransaction*/, 
                                    const THTTPEvent& /*aEvent*/)
    {
    // Handle error and return KErrNone.
    TRAPD( err, HandleRunErrorL( aError ) );
    return KErrNone;
    }

// ----------------------------------------------------------------------------
// CHttpClientEngine::GetCredentialsL()
//
// Inherited from MHTTPAuthenticationCallback
// Called by framework when we requested authenticated page and framework 
// needs to know username and password.
// ----------------------------------------------------------------------------
TBool CHttpClientEngine::GetCredentialsL( const TUriC8& /*aUri*/,
                                               RString aRealm, 
                                               RStringF /*aAuthenticationType*/,
                                               RString& aUsername, 
                                               RString& aPassword) 
    {
    // aURI, aReal and aAuthenticationType are informational only. We only need 
    // to set aUsername and aPassword and return ETrue, if aUsername and 
    // aPassword are provided by user.

    // Query user name and password
    return EFalse;
    }