/*

* Copyright (c) 2006 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:  A class that fetches resources via HTTP 1.1.

*

*/

#include "SessionHttpConnection.h"

#include "FeedsServerSession.h"

#include "Logger.h"

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

// CSessionHttpConnection::NewL

//

// Two-phased constructor.

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

//

CSessionHttpConnection* CSessionHttpConnection::NewL( CFeedsServerSession& aFeedsSession )

    {

    CSessionHttpConnection* self = new (ELeave) CSessionHttpConnection( aFeedsSession );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CSessionHttpConnection::CSessionHttpConnection

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CSessionHttpConnection::CSessionHttpConnection( CFeedsServerSession& aFeedsSession ):

        iLeakTracker( CLeakTracker::EHttpConnection ),

        iFeedsSession( aFeedsSession ) 

    {

    }

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

// CSessionHttpConnection::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSessionHttpConnection::ConstructL()

    {

    BaseConstructL();

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

    iConnName = HBufC::NewL( KMaxName );

    Reset();

    }        

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

// CSessionHttpConnection::~CSessionHttpConnection

// Deconstructor.

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

//

CSessionHttpConnection::~CSessionHttpConnection()

    {

    // close http session

    iSession.Close();

    // close RConnection

    Disconnect();

    delete iConnName;

    // close RSocketServer

    iSocketServ.Close();

    }

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

// CSessionHttpConnection::CreateConnection

// 

// It propagates the connection callback to the browser client.

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

//

TInt CSessionHttpConnection::CreateConnection(TInt* aConnectionPtr, TInt* aSockSvrHandle, 

        TBool* aNewConn, TApBearerType* aBearerType)

    {

    TInt  err = KErrNone;

    // If need be establish the connection.

    if( !IsConnected() )

        {

        // Prepare connection name & bearer type ready for client response.

        Reset();

		// server session ask client app for connection

        TRAP( err, iFeedsSession.NetworkConnectionNeededL() );

        if  ( err == KErrNone )

            {

            // Start the scheduler to wait for client response. Scheduler will be stopped 

            // when client informs the server which bearer to use.

            //

            // See:

            //

            // [SERVER]

            //      CFeedsServerSession::SetConnectionL

            //      CSessionHttpConnection::SetConnection

            //

            // [CLIENT]

            //      CFolderItemRequestHandler::RequestCompletedL ("EFeedsServerConnectionNeeded")

            //      CFeedRequestHandler::RequestCompletedL ("EFeedsServerConnectionNeeded")

	        //

	        iWait.Start();

            // At this point, assuming that the client was able to provide us

            // with the connection information then we are able to open the specified

            // connection.

            //

            // If not (e.g. client cancelled connection request) then we must clean up

            // and handle the error.

            if  ( ConnectionInformationProvidedByClient() )

                {

                // connection info come back in response from client

                TName connName;

                connName.Copy( *iConnName );

                err = iConnection.Open( iSocketServ, connName );

                if  ( err == KErrNone )

                    {

                    *aNewConn = ETrue;

                    if (iObserver != NULL)

                        {

                        iObserver->ConnectionAvailable();

                        }

                    }

                }

            else

                {

                // Use current connection error value if the client was

                // not able to supply connection parameters.

                err = iConnectionError;

                }

            }

        }       

    else

        {

        // Otherwise the existing connection is valid and no new connection

        // is required.

        *aNewConn = EFalse;

        }

    // End of process - either set up the reference/pointer arguments for

    // a successful connection initiation, or then inform the observer of

    // the error.

    if  ( err == KErrNone )

        {

        *aConnectionPtr = (TInt) &iConnection;

        *aSockSvrHandle = iSocketServ.Handle();

        *aBearerType = iBearerType;

        }

    else

        {

        // Notify the HttpHandler that the establishing the access point failed

        if (iObserver != NULL)

            {

            iObserver->ConnectionFailed(err);

            }

        }

    return err;

    }

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

// CSessionHttpConnection::IsConnected

//

// Returns whether or not the connection is active.

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

//

TBool CSessionHttpConnection::IsConnected()

    {

    if ( !iConnection.SubSessionHandle() )

        {

        iConnStage = KConnectionUninitialised;

        }

    else

        {

        TNifProgress progress;

        iConnection.Progress( progress );

        iConnStage = progress.iStage;

        }

    return iConnStage == KLinkLayerOpen;

    }

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

// CSessionHttpConnection::Disconnect

//

// Closes the connection.

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

//

void CSessionHttpConnection::Disconnect()

    {

    if (IsConnected())

        {

        iConnection.Close();

        }

    }

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

// CSessionHttpConnection::CancelAnyConnectionAttempt

//

// Closes the connection.

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

//

void CSessionHttpConnection::CancelAnyConnectionAttempt()

    {

    SetObserver(NULL);

    if  ( iWait.IsStarted() )

        {

        iWait.AsyncStop();

        }

    Reset();

    iConnectionError = KErrCancel;

    }

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

// CSessionHttpConnection::SetConnection

//

// Sets the connection.

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

//

TBool CSessionHttpConnection::SetConnection( TDesC& aName, TInt aBearerType  )

    {

    TBool ret = EFalse;

    // unblocking

    if  ( iWait.IsStarted() )

        {

        iConnName->Des().Copy( aName );

        iBearerType = (TApBearerType) aBearerType;

        iConnectionError = KErrNone;

        ret = ETrue;

        iWait.AsyncStop();

        }

    return ret;

    }

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

//CSessionHttpConnection::Reset()

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

void CSessionHttpConnection::Reset()

    {

    iConnectionError = KErrNotReady;

    iConnName->Des().Zero();

    iBearerType = EApBearerTypeAllBearers;

    }

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

//CSessionHttpConnection::ConnectionInformationProvidedByClient()

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

TBool CSessionHttpConnection::ConnectionInformationProvidedByClient() const

   	{

    return ( iConnName->Length() > 0 );

   	}