/*

* Copyright (c) 2006-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:  

*

*/

#include "catalogshttpsessionmanagerimpl.h"

#include <es_sock.h>

#include "catalogshttpoperation.h"

#include "catalogshttpconfig.h"

#include "catalogstransportoperationid.h"

#include "catalogshttpconnectioncreator.h"

#include "catalogsnetworkmanager.h"

#include "catalogsutils.h"

#include "catalogshttputils.h"

#include "catalogsdebug.h"

// 20 minutes

const TInt KDisconnectionDelayInMicroSeconds = 1000000*60*20;

// 20 seconds after we switch to another APN even if the old one is still

// up

const TInt KApSwitchDelay = 1000000*20;

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

CCatalogsNetworkManager* CCatalogsHttpSessionManager::iNetworkManager = NULL;

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

// ResumeOperationCallback, called by CAsyncCallBack

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

//	    

static TInt ResumeOperationCallback( TAny* aData )

    {

    DLTRACEIN((""));

    static_cast<CCatalogsHttpSessionManager*>( aData )->ResumeOperationAction();

    return KErrNone;

    }

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

// NewL

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

//	

    {

    CCatalogsHttpSessionManager* self = new( ELeave ) 

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//	

CCatalogsHttpSessionManager::~CCatalogsHttpSessionManager()

    {

    DLTRACEIN((""));

    Cancel();

    iConnectionTimer.Close();

    DeletePtr( iMonitor );

    iTransactionQueue.Close();

    iDownloadQueue.Close();

    iGeneralQueue.Close();

    iRunningQueue.Close();

    ReleasePtr( iConnection );

    delete iConnectionCreator;

    delete iCallback;    

    // set as NULL after delete because iNetworkManager is static    

    DeletePtr( iNetworkManager );

    DLTRACEOUT((""));

    }

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

// Add a reference

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

//

void CCatalogsHttpSessionManager::AddRef()

    {

    iRefCount++;    

    }

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

// Release a reference

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

//

TInt CCatalogsHttpSessionManager::Release()

    {

    DLTRACEIN( ( "" ) );

    iRefCount--;

    if ( !iRefCount ) 

        {

        delete this;

        return 0;

        }

    return iRefCount;

    }

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

// StartOperation

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

//	

TInt CCatalogsHttpSessionManager::StartOperation( 

    MCatalogsHttpOperation* aOperation, TBool aConnect )

    {

    DLTRACEIN((""));

    DLINFO( ("Operation ID: %i, Type: %i", 

        aOperation->OperationId().Id(), aOperation->OperationType() ) );

    DASSERT( aOperation );

    UpdateRunningOperations();

    DLINFO(("Running operations: %d, transactions: %d, general: %d",

        iRunningOperations, iRunningTransactions, iRunningFromGeneral ));

    // Make sure the download is removed from queue

    RemoveFromQueue( aOperation );

    // Check if the operation can connect either by using the current AP

    // or by opening a new one

    if ( aConnect )

        {

        TBool isRunning = EFalse;

        TRAPD( err, isRunning = ConnectL( *aOperation ) );

        if ( err != KErrNone )  

            {

            DLTRACEOUT(("Error: %d, err"));

            return err;

            }

        if ( !isRunning ) 

            {

            DLTRACEOUT(("Not running, adding to queue"));

            return AddToQueue( aOperation );

            }

        }

     // Check whether operation belongs to general queue or not

    if ( aOperation->Config().Priority() > ECatalogsPriorityQueued )

        {        

        // non-general queues

        if ( iRunningOperations < KMaxConcurrentOperations ) 

            {

            DLTRACE(("Not general queue"));

            // Check that transactions leave room for downloads and vice versa

            if ( ( ( aOperation->OperationType() == ECatalogsHttpTransaction ) && 

                 ( iRunningTransactions < KMaxConcurrentOperations - KMinDownloads ) ) ||

                 ( ( aOperation->OperationType() == ECatalogsHttpDownload ) &&

                 ( iRunningOperations - iRunningTransactions < 

                   KMaxConcurrentOperations - KMinTransactions ) ) )

                {

                iRunningOperations++;

                if ( aOperation->OperationType() == ECatalogsHttpTransaction ) 

                    {

                    iRunningTransactions++;

                    }               

                DLINFO( ( "Running: %i, TRs: %i", iRunningOperations,

                    iRunningTransactions ) );

                return iRunningQueue.InsertInAddressOrder( aOperation );

                }            

            else 

                {

                DLINFO( ( "Running %i, TRs: %i, DLs: %i", iRunningOperations,

                    iRunningTransactions, 

                    iRunningOperations - iRunningTransactions ) );

                }

            }

        else 

            {

            DLINFO( ( "Running: %i >= Max: %i", iRunningOperations, 

                KMaxConcurrentOperations ) );

            }   

        }

    else if ( !iRunningFromGeneral )    

        {

        // General queue

        DLTRACE(("Operation from general"));        

        return iRunningQueue.InsertInAddressOrder( aOperation );                

        }

    return AddToQueue( aOperation );

    }

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

// PauseOperation

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

//	    

TInt CCatalogsHttpSessionManager::PauseOperation(   

    MCatalogsHttpOperation* aOperation )

    {

    DLTRACEIN( ("") );

    DASSERT( aOperation );

    TInt err = RemoveFromQueue( aOperation );

    if ( err == KErrNone )

        {

        err = iRunningQueue.InsertInAddressOrder( aOperation );

        ResumeOperation();

        }

    else

        {

        DLERROR(( "Error %d", err ));

        }

    return err;

    }

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

// CompleteOperation

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

//	    

TInt CCatalogsHttpSessionManager::CompleteOperation( 

    MCatalogsHttpOperation* aOperation )

    {

    DLTRACEIN( ("Running ops: %d, queues: Run: %d, DL: %d, TR: %d, Gen: %d",

        iRunningOperations, iRunningQueue.Count(),

        iDownloadQueue.Count(), iTransactionQueue.Count(),

        iGeneralQueue.Count() ) );

    // This shouldn't happen unless the operation is canceled before the

    // connection has been created

    if ( iConnectedOperation == aOperation ) 

        {

        iConnectedOperation = NULL;

        if ( iConnection ) 

            {

            // This prevents AP selection queries after the operation

            // has been canceled. 

            DLTRACE(("Cancel connection creation"));            

            iConnection->Cancel();    

            // DLMAIN-545, iConnectionState was left as Disconnecting

            // which prevented the creation of new connections

            iConnectionState = ECatalogsConnectionDisconnected;  

            // iConnection will be released in ConnectL/destructor

            }        

        }

    TInt index = iRunningQueue.FindInAddressOrder( aOperation );

    if ( index != KErrNotFound ) 

        {

        DLTRACE(("Removing from running ops, count after: %d", 

            iRunningQueue.Count() - 1 ));

        iRunningQueue.Remove( index );

        ResumeOperation();        

        }

    else 

        {

        RemoveFromQueue( aOperation );

        // This ensures that connection timer is started if necessary

        UpdateRunningOperations();

        }

    return KErrNone;

    }

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

// Priority change handler

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

//	

TInt CCatalogsHttpSessionManager::OperationPriorityChanged(

    MCatalogsHttpOperation* aOperation )

    {

    if ( RemoveFromQueue( aOperation ) == KErrNone ) 

        {

        return AddToQueue( aOperation );

        }

    return KErrNotFound;

    }

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

// Connection creator

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

//	

CCatalogsHttpConnectionCreator& CCatalogsHttpSessionManager::ConnectionCreatorL()

    {

    DLTRACEIN((""));

    if( !iConnectionCreator ) 

        {

        iConnectionCreator = CCatalogsHttpConnectionCreator::NewL();

        }

    return *iConnectionCreator;        

    }

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

// 

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

//	

CCatalogsNetworkManager& CCatalogsHttpSessionManager::NetworkManagerL()

    {

    DLTRACEIN((""));

    if ( !iNetworkManager )

        {

        iNetworkManager = CCatalogsNetworkManager::NewL();         

        }

    return *iNetworkManager;

    }

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

// 

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

//	

void CCatalogsHttpSessionManager::SetResumeMode( TBool aResumeQueued )

    {

    iResumeQueued = aResumeQueued;

    }

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

// 

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

//  

void CCatalogsHttpSessionManager::RunL()

    {

    DLTRACEIN(("iStatus: %d", iStatus.Int() ));

    if ( iStatus.Int() == KErrNone )

        {

        if ( iConnection )

            {

            DLTRACE(("Idle timeout, releasing connection"));

            DASSERT( iConnection && iConnection->RefCount() == 1 );

            // Monitor is deleted elsewhere        

            if ( iMonitor ) 

                {

                iMonitor->Cancel();

                }

            NetworkManagerL().CloseAccessPointL( iConnection->ConnectionMethod() );

            // We don't need to monitor the shutdown because we're not 

            // switching to an another APN

            ReleasePtr( iConnection );

            iConnectionState = ECatalogsConnectionDisconnected;

            }

        else if ( iSwitchApTimer )

            {

            iSwitchApTimer = EFalse;

            // emulate real connection shutdown

            ConnectionStateChangedL( KConnectionUninitialised );

            }        

        }

    }

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

// 

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

//  

void CCatalogsHttpSessionManager::DoCancel()

    {

    DLTRACEIN((""));

    iConnectionTimer.Cancel();

    iSwitchApTimer = EFalse;

    }

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

// 

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

//  

TInt CCatalogsHttpSessionManager::RunError( TInt aError )

    {

    DLTRACEIN(("aError: %d", aError ));

    (void) aError;

    return KErrNone;

    }

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

// CCatalogsHttpSessionManager

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

//	

    CActive( CActive::EPriorityStandard ),

    iRefCount( 1 ),

    {

    CActiveScheduler::Add( this );

    }

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

// ResumeOperation

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

//	    

void CCatalogsHttpSessionManager::ResumeOperation()

    {

    DLTRACEIN((""));

    DLINFO( ( "Tr queue: %i, Dl queue: %i, general: %i", 

        iTransactionQueue.Count(),

        iDownloadQueue.Count(), 

        iGeneralQueue.Count() ) );

    if ( !iResumeQueued ) 

        {

        DLTRACEOUT(("Operation resuming disabled"));

        return;

        }    

    DLTRACE(("Callback"))

    if ( !iCallback->IsActive() ) 

        {        

        iResumeCount++;

        iCallback->CallBack();

        }

    else

        {

        iResumeCount++;

        }

    }

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

// ResumeOperationAction

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

//	        

TInt CCatalogsHttpSessionManager::ResumeOperationAction()

    {

    DLTRACEIN((""));

    RCatalogsHttpOperationArray* array = NULL;    

    UpdateRunningOperations();

    if ( !iRunningFromGeneral && iGeneralQueue.Count() )    

        {

        array = &iGeneralQueue;

        }

    else if ( iTransactionQueue.Count() && ( iDownloadQueue.Count() == 0 ||

         iTransactionQueue[0]->Config().Priority() >= 

         iDownloadQueue[0]->Config().Priority() ) )

        {

        DLTRACE( ("Resuming transaction") );

        // Resume transaction

        array = &iTransactionQueue;

        }

    else if ( iDownloadQueue.Count() ) 

        {

        DLTRACE( ("Resuming download") );

        // Resume download

        array = &iDownloadQueue;

        }

    if ( array ) 

        {            

        iResumeCount--;

        if ( iResumeCount ) 

            {

            DLTRACE(("Call resume callback again"));

            iCallback->CallBack();

            }

        MCatalogsHttpOperation* operation = (*array)[0];

        DLTRACE( ( "Resuming: %x, type: %i, id: %i", 

            operation, operation->OperationType(),

            operation->OperationId().Id() ) );

        // Start will remove the operation

        return operation->Start( MCatalogsHttpOperation::EAutomaticResume );            

        }

    iResumeCount = 0;

    DLTRACE( ( "Nothing to resume" ) );    

    return KErrNotFound; 

    }

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

// ConnectionCreatedL

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

//	

void CCatalogsHttpSessionManager::ConnectionCreatedL( 

    const TCatalogsConnectionMethod& aMethod )

    {

    DLTRACEIN(("method: %d, %u, %u",

        aMethod.iType, aMethod.iId, aMethod.iApnId ));

    StartMonitoringL( EFalse );

    iLatestConnectionMethod = aMethod;

    iConnectionState = ECatalogsConnectionConnected;

    // Update connection to queued operations that require it

    SetConnectionToQueue( 

        aMethod,

        iDownloadQueue );

    SetConnectionToQueue( 

        aMethod,

        iTransactionQueue );

    SetConnectionToQueue( 

        aMethod,

        iGeneralQueue );

    DLTRACE(("Starting the operation"));

    if ( iConnectedOperation )