/*
* Copyright (c) 2008-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:   ?Description
*
*/


#include "catalogsconnection.h"
#include "catalogshttpconnectioncreator.h"
#include "catalogsutils.h"

#include "catalogsdebug.h"

// Default for socket server message slots is 8 which is too little
// when we use the same socket server connection for several HTTP
// connections
const TInt KSocketServerMessageSlots = 20;

    
CCatalogsConnectionMonitor* CCatalogsConnectionMonitor::NewL( 
    MCatalogsConnectionStateObserver& aObserver )
    {
    CCatalogsConnectionMonitor* self = new( ELeave ) 
        CCatalogsConnectionMonitor( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }


CCatalogsConnectionMonitor::~CCatalogsConnectionMonitor()
    {
    DLTRACEIN((""));
    Cancel();
    iConnection.Close();
    iSs.Close();
    }


void CCatalogsConnectionMonitor::StartL( 
    const TConnectionInfoBuf& aInfo )
    {
    DLTRACEIN((""));
    
    TNifProgress progress;
    User::LeaveIfError( iConnection.Attach( 
        aInfo, RConnection::EAttachTypeMonitor ) );
    
    iConnection.ProgressNotification( iProgressBuf, iStatus );
        
    TInt err = iConnection.Progress( progress );
    
    DLTRACE(("Progress stage: %d, error: %d", 
        progress.iStage, progress.iError ));
    
    if ( err != KErrNone )
        {
        DLERROR(("Error when getting progress info: %d", err));
        iConnection.CancelProgressNotification();
        // Prevent RunL from running
        User::WaitForRequest( iStatus );
        User::Leave( err );
        }
    else if ( progress.iStage == KConnectionUninitialised ) 
        {
        DLTRACE(("Connection already dead"));
        iConnection.CancelProgressNotification();
        iProgressBuf = progress;
        }
    SetActive();
    }
    
    
void CCatalogsConnectionMonitor::RunL()
    {
    DLTRACEIN((""));
    LeaveIfNotErrorL( iStatus.Int(), KErrCancel );

    // Ensure that we don't miss any events
    if ( iStatus.Int() == KErrNone )
        {
        iConnection.ProgressNotification( iProgressBuf, iStatus );
        SetActive();
        }    
    
    TInt stage = iProgressBuf().iStage;    
    DLTRACE(("Stage: %d, error: %d", stage, iProgressBuf().iError ));
    
    // Take possible connection error code. This is needed for "Red phone"
    // detection
    if ( stage == KLinkLayerClosed ) 
        {
        TInt error = iProgressBuf().iError;
        if ( error ) 
            {
            stage = error;
            }
        }
    
    iObserver.ConnectionStateChangedL( stage );    
    }
    
    
void CCatalogsConnectionMonitor::DoCancel()
    {
    iConnection.CancelProgressNotification();
    
    }
    
    
TInt CCatalogsConnectionMonitor::RunError( TInt aError ) 
    {
    iObserver.ConnectionStateError( aError );
    return KErrNone;
    }
    
CCatalogsConnectionMonitor::CCatalogsConnectionMonitor( 
    MCatalogsConnectionStateObserver& aObserver ) :
    CActive( EPriorityHigh ),
    iObserver( aObserver )
    {
    CActiveScheduler::Add( this );
    }

void CCatalogsConnectionMonitor::ConstructL()
    {
    User::LeaveIfError( iSs.Connect() );
    User::LeaveIfError( iConnection.Open( iSs ) );
    }
    


// ---------------------------------------------------------------------------
// CCatalogsConnection
// ---------------------------------------------------------------------------
//    


    
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
CCatalogsConnection* CCatalogsConnection::NewL(         
    CCatalogsHttpConnectionCreator& aConnectionCreator,
    CCatalogsHttpConnectionManager& aConnectionManager,
    MCatalogsConnectionObserver& aObserver )
    {
    CCatalogsConnection* self = new( ELeave ) 
        CCatalogsConnection( 
            aConnectionCreator, 
            aConnectionManager,
            aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
void CCatalogsConnection::ConnectL( 
    const TCatalogsConnectionMethod& aMethod )
    {
    DLTRACEIN((""));
    iConnectionMethod = aMethod;
    iConnCreator.ConnectL( 
        iConnectionMethod, 
        iConnection,
        iStatus,
        &iConnManager );
        
    SetActive();
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
CCatalogsConnection::~CCatalogsConnection()
    {
    DLTRACEIN((""));
    Cancel();    
    iConnection.Close();
    iSs.Close();
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
RConnection& CCatalogsConnection::Connection()
    {
    return iConnection;
    }
    

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
RSocketServ& CCatalogsConnection::SocketServer()
    {
    return iSs;
    }
    
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
const TCatalogsConnectionMethod& CCatalogsConnection::ConnectionMethod() const
    {
    return iConnectionMethod;
    }
    
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
TBool CCatalogsConnection::IsConnectedL()
    {
    DLTRACEIN((""));
    if ( iConnection.SubSessionHandle() ) 
        {
        
        TNifProgress progress;
        User::LeaveIfError( iConnection.Progress( progress ) );
        if ( progress.iStage == KLinkLayerOpen ) 
            {
            DLTRACEOUT(("Connected"));
            return ETrue;
            }
        }
    DLTRACEOUT(("Not connected"));
    return EFalse;
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
void CCatalogsConnection::RunL()
    {
    DLTRACEIN(("")); 

    // Let RunError handle errors
    User::LeaveIfError( iStatus.Int() );

    iObserver.ConnectionCreatedL( iConnectionMethod );
    }
    
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
void CCatalogsConnection::DoCancel()
    {
    iConnCreator.Cancel();
    }
    
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
TInt CCatalogsConnection::RunError( TInt aError )
    {
    DLTRACEIN(("aError: %d", aError));
    iObserver.ConnectionError( aError );
    return KErrNone;
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
CCatalogsConnection::CCatalogsConnection(
    CCatalogsHttpConnectionCreator& aConnectionCreator,
    CCatalogsHttpConnectionManager& aConnectionManager,
    MCatalogsConnectionObserver& aObserver ) :     
    iObserver( aObserver ),
    iConnCreator( aConnectionCreator ),
    iConnManager( aConnectionManager ),
    iConnectionMethod( 0, ECatalogsConnectionMethodTypeDeviceDefault )
    {
    CActiveScheduler::Add( this );
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
void CCatalogsConnection::ConstructL()
    {
    DLTRACEIN((""));
    User::LeaveIfError( iSs.Connect( KSocketServerMessageSlots ) );
    User::LeaveIfError( iConnection.Open( iSs ) );        
    }