/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 class CHttpWapSession.   

*      

*

*/

// INCLUDE FILES

#include <httpfiltercommonstringsext.h>

#include "HttpWapSession.h"

#include "CodError.h"

#include "CodLogger.h"

#include "CodPanic.h"

/// WSP protocol name.

_LIT8( KCodWspProtocol, "WSP/WSP" );

/// Default WAP server port.

const TInt KCodWspRemotePort = 9201;

// ================= MEMBER FUNCTIONS =======================

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

// CHttpWapSession::NewL()

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

//

CHttpWapSession* CHttpWapSession::NewL( const TDesC8& aGateway )

    {

    CHttpWapSession* sess = new( ELeave ) CHttpWapSession();

    CleanupStack::PushL( sess );

    sess->ConstructL( aGateway );

    CleanupStack::Pop( sess );

    return sess;

    }

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

// CHttpWapSession::~CHttpWapSession()

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

//

CHttpWapSession::~CHttpWapSession()

    {

    CLOG(( EWapConn, 2, _L("-> CHttpWapSession::~CHttpWapSession") ));

    Disconnect();

    if ( iGatewayOpen )

        {

        iGateway.Close();

        }

    iSess.Close();

    delete iWait;

    CLOG(( EWapConn, 2, _L("<- CHttpWapSession::~CHttpWapSession") ));

    }

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

// CHttpWapSession::ConnectL()

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

//

void CHttpWapSession::ConnectL( TRequestStatus* aStatus )

    {

    CLOG(( EWapConn, 2, _L("-> CHttpWapSession::ConnectL") ));

    CLOG(( EWapConn, 3, _L8("  iGateway <%S> port(%d)"),\

        &(iGateway.DesC()), KCodWspRemotePort ));

    // Misuse asserts.

    __ASSERT_ALWAYS( aStatus, CodPanic( ECodInvalidArguments ) );

    __ASSERT_ALWAYS( iState == EInit, CodPanic( ECodOffState ) );

    // Internal asserts.

    __ASSERT_DEBUG( !iParentStatus, CodPanic( ECodInternal ) );

    RHTTPConnectionInfo connInfo = iSess.ConnectionInfo();

    connInfo.SetPropertyL

        ( StringF( HTTP::EWspProxyAddress ), THTTPHdrVal( iGateway ) );

    connInfo.SetPropertyL

        ( StringF( HTTP::EWspRemotePort ), THTTPHdrVal( KCodWspRemotePort ) );

    // Connect to WAP gateway.

    iSess.SetSessionEventCallback( this );

    iSess.ConnectL();

    iState = EConnecting;

    iParentStatus = aStatus;

    *iParentStatus = KRequestPending;

    CLOG(( EWapConn, 2, _L("<- CHttpWapSession::ConnectL") ));

    }

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

// CHttpWapSession::Disconnect()

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

//

void CHttpWapSession::Disconnect()

    {

    CLOG(( EWapConn, 2, _L("-> CHttpWapSession::Disconnect iState(%d)"), \

        iState ));

    switch ( iState )

        {

        case EConnecting:

        case EConnected:

            {

            TRAPD( err, iSess.DisconnectL() );

            if ( err )

                {

                // Nothing we can do about this failure!

                CLOG(( EConn, 3, _L("  failed(%d)"), err ));

                }

            else

                {

                iState = EDisconnecting;

                CLOG(( EConn, 3, _L("  starting wait") ));

                iWait->Start();

                }

            break;

            }

        case EInit:

        case EDisconnecting:

        default:

            {

            CLOG(( EConn, 3, _L("  nothing to do") ));

            // EInit state: no need to do anything.

            // EDisconnecting: we can't do anything.

            break;

            }

        }

    CLOG(( EWapConn, 2, _L("<- CHttpWapSession::Disconnect") ));

    }

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

// CHttpWapSession::CHttpWapSession()

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

//

CHttpWapSession::CHttpWapSession()

: CHttpSessionBase(),

  iState( EInit ),

  iGatewayOpen( EFalse )

    {

    CLOG(( EWapConn, 2, _L("CHttpWapSession::CHttpWapSession") ));

    }

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

// CHttpWapSession::ConstructL()

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

//

void CHttpWapSession::ConstructL( const TDesC8& aGateway ) 

    {

    __ASSERT_ALWAYS( aGateway.Length(), CodPanic(  ECodInvalidArguments ) );

    iSess.OpenL( KCodWspProtocol );

    iSess.StringPool().OpenL( HttpFilterCommonStringsExt::GetTable() );

    iGateway = iSess.StringPool().OpenFStringL( aGateway );

    // Track whether open - cannot close unopened RStringF.

    iGatewayOpen = ETrue;

    iWait = new (ELeave) CActiveSchedulerWait;

    }

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

// CHttpWapSession::MHFSessionRunL()

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

//

void CHttpWapSession::MHFSessionRunL( const THTTPSessionEvent& aEvent )

    {

    CLOG(( EWapConn, 0, _L("-> CHttpWapSession::MHFSessionRunL event(%d)"), \

                                                            aEvent.iStatus ));

    switch ( aEvent.iStatus )

        {

        case THTTPSessionEvent::EConnectedOK:

        case THTTPSessionEvent::EConnectedWithReducedCapabilities:

            {

            CLOG(( EWapConn, 3, _L("  EConnected...") ));

            if ( iState == EConnecting )

                {

                // Connecting: we are done.

                iState = EConnected;

                Done( KErrNone );

                }

            else if ( iState == EDisconnecting )

                {

                // Connecting was interrupted with a Disconnect call but it

                // seems we have already connected by that time. Now we are

                // not Done() yet: wait more for the disconnect to finish.

                CLOG(( EWapConn, 3, \

                    _L("  late connect event, keep waiting for disconnect") ));

                iState = EConnected;

                }

            else

                {

                // Unexpected state for these events.

                CLOG(( EWapConn, 0, \

                    _L("  connect event in unexpected state") ));

                CodPanic( ECodOffState );

                }

            break;

            }

        case THTTPSessionEvent::EDisconnected:

            {

            CLOG(( EWapConn, 3, _L("  EDisconnected") ));

            iState = EInit;

            Done( KErrCodWapConnectionDropped );

            break;

            }

        case THTTPSessionEvent::EConnectionTimedOut:

            {

            CLOG(( EWapConn, 3, _L("  EConnectionTimedOut") ));

            iState = EInit;

            Done( KErrCodHttpTimedOut );

            break;

            }

        default:

            {

            if( aEvent.iStatus < 0 )

                {

                // Negative value indicates error.

                iState = EInit;

                Done( KErrCodWapConnectionDropped );

                }

            break;

            }

        }

    CLOG(( EWapConn, 0, _L("<- CHttpWapSession::MHFSessionRunL") ));

    }

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

// CHttpWapSession::MHFSessionRunError()

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

//

TInt CHttpWapSession::MHFSessionRunError

( TInt LOG_ONLY( aError ), const THTTPSessionEvent& /*aEvent*/ )

    {

    CLOG(( EWapConn, 2, \

        _L("CHttpWapSession::MHFSessionRunError (%d)"), aError ));

    // This method should never be called - MHFSessionRunL does not leave.

    CodPanic( ECodInternal );

    return KErrNone;

    }

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

// CHttpWapSession::Done()

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

//

void CHttpWapSession::Done( TInt aResult )

    {

    CLOG(( EConn, 2, _L("CHttpWapSession::Done aResult(%d)"), aResult ));

    if ( iWait->IsStarted() )

        {

        // This must be Disconnect: we are waiting for it.

        CLOG(( EConn, 3, _L("  stopping wait") ));

        iWait->AsyncStop();

        }

    if ( iParentStatus )

        {

        // This must be ConnectL: parent is waiting for it.

        CLOG(( EConn, 3, _L("  completing parent") ));

        User::RequestComplete( iParentStatus, aResult );

        iParentStatus = NULL;

        }

    }