/*

* 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 "catalogshttpdownloadmanagerimpl.h"

#include "catalogsconstants.h"

#include "catalogshttpoperation.h"

#include "catalogsutils.h"

#include "catalogshttpdownload.h"

#include "catalogshttpconfigimpl.h"

#include "catalogshttpsessionmanager.h"

#include "catalogshttptransactionmanager.h"

#include "catalogshttpconnectionmanager.h"

#include "catalogshttpsessionmanagerimpl.h"

#include "catalogsnetworkmanager.h"

#include "catalogshttpsessionimpl.h"

#include "catalogsconnection.h"

#include "catalogsdebug.h"

#include <QString>

#include <QVector>

#include <QList>

#include <downloadevent.h>

#include <xqconversions.h>

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

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

// Creator

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

//

CCatalogsHttpDownloadManager* CCatalogsHttpDownloadManager::NewL( 

    MCatalogsHttpSessionManager& aManager, 

    CCatalogsHttpSession& aSession,

    TInt32 aSessionId,

    MCatalogsHttpTransactionManager& aTransactionManager,

    CCatalogsHttpConnectionManager& aConnectionManager,

    TBool aCleanup )

    {

    DLTRACEIN(("aMan=%X aTrans=%X",&aManager,&aTransactionManager));

    CCatalogsHttpDownloadManager* self = new ( ELeave ) 

            CCatalogsHttpDownloadManager( 

                aManager, 

                aSession,

                aSessionId, 

                aTransactionManager, 

                aConnectionManager );        

    DLTRACE(("constructor ok"));

    CleanupStack::PushL( self );

    self->ConstructL( aCleanup );

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CCatalogsHttpDownloadManager::~CCatalogsHttpDownloadManager()

    {

    DLTRACEIN( ( "" ) );

    Cancel();

    // HLa iEventQueue.Close();

    // Release downloads

    TInt count = iDownloads.Count() - 1;

    while( count > -1 )

        {

        while( iDownloads[count]->Release() )

            {

            }

        --count;

        }

    count = iRestoredDownloads.Count() - 1;

    while( count > -1 )

        {

        while( iRestoredDownloads[count]->Release() )

            {

            }

        --count;

        }

    iDownloads.Close();    

    iRestoredDownloads.Close();

    if ( iNetworkManager ) 

        {

        iNetworkManager->RemoveObserver( *this );

        }

    if ( iDmgr ) 

        {

        DLTRACE(("We were connected to DL manager"));

        DeleteHangingDownloads();

        }

    delete iDefaultConfig;

    iManager.Release();

    iFs.Close();

    DLTRACEOUT( ( "" ) );

    }

void CCatalogsHttpDownloadManager::DeleteHangingDownloads() 

    {

    DLTRACEIN((""));

    // This pauses all downloads in addition to disconnecting

 	iDmgr->pauseAll(); 

   TInt count = iDownloads.Count();

    for ( TInt i = 0; i < count; ++i )

        {

         TInt32 deleteStatus = 0;

         deleteStatus = dynamic_cast<CCatalogsHttpDownload*>(iDownloads[i])->GetStatusState();

         if ( deleteStatus == CCatalogsHttpDownload::EDownloadCanBeDeleted ) 

            {

            DLTRACE(("Deleting download"));

            iDmgr->removeOne(dynamic_cast<CCatalogsHttpDownload*>(iDownloads[i])->GetDownload());

            }

        }        

    }

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

// Download creator

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

//

MCatalogsHttpOperation* CCatalogsHttpDownloadManager::CreateDownloadL( 

    const TDesC16& aUrl, TBool aStart, MCatalogsHttpObserver* aObserver )

    {

    DLTRACEIN((""));

    HBufC8* buf = ConvertUnicodeToUtf8L( aUrl );

    CleanupStack::PushL( buf );

    DLTRACE(("Creating download"));

    MCatalogsHttpOperation* operation = CreateDownloadL( *buf, 

        aStart, aObserver );

    CleanupStack::PopAndDestroy( buf );    

    DLTRACEOUT((""));

    return operation;

    }

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

// Download creator

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

//

MCatalogsHttpOperation* CCatalogsHttpDownloadManager::CreateDownloadL( 

    const TDesC8& aUrl, TBool /* aStart */, MCatalogsHttpObserver* aObserver )

    {

    DLTRACEIN((""));

    // Create a new download

    QString Url = XQConversions::s60Desc8ToQString(aUrl);  

    iDownload = iDmgr->createDownload( Url );

    CCatalogsHttpDownload* dl = CCatalogsHttpDownload::NewLC( 

        *this,

        //download,

        iDownload,

        *iDefaultConfig );

    dl->SetUriL( aUrl );

    dl->SetFileServerSession( iFs );

        // If the given observer != NULL, set it as the observer for the download

    if ( aObserver ) 

        {        

        dl->Config().SetObserver( aObserver );        

        }

    // Add the download to downloads

    iDownloads.AppendL( dl );

    CleanupStack::Pop( dl );

    DLTRACEOUT((""));

    return dl;        

    }

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

// Download getter

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

//    

MCatalogsHttpOperation* CCatalogsHttpDownloadManager::Download( 

    const TCatalogsTransportOperationId& aId ) const

    {

    TInt count = iDownloads.Count();

    for ( TInt i = 0; i < count; ++i )

        {

        if ( iDownloads[i]->OperationId() == aId ) 

            {

            return iDownloads[i];

            }

        }

    return NULL;

    }

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

// Current downloads getter

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

//    

const RCatalogsHttpOperationArray& 

    CCatalogsHttpDownloadManager::CurrentDownloads() const

    {

    return iDownloads;

    }

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

// Restored downloads getter

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

//

const RCatalogsHttpOperationArray& 

    CCatalogsHttpDownloadManager::RestoredDownloads() const

    {

    return iRestoredDownloads;

    }

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

// Cancels all downloads

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

//

void CCatalogsHttpDownloadManager::CancelAll()

    {

    TInt count = iDownloads.Count();

    while( count-- )

        {

        iDownloads[ count ]->Cancel();        

        }

    iDownloads.Reset();

    DeleteRestoredDownloads();

    iCancellingAll = EFalse;      

    }

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

// 

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

//

void CCatalogsHttpDownloadManager::NotifyCancelAll()

    {

    DLTRACEIN((""));    

    TInt count = iDownloads.Count();

    while( count-- && iDownloads.Count() )

        {

        // NotifyCancel can lead to canceling other downloads too so we must

        // make sure that we don't go out of bounds

        if ( count >= iDownloads.Count() ) 

            {

            count = iDownloads.Count() - 1;

            }

        iDownloads[count]->NotifyCancel();        

        }

    }

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

// Deletes restored downloads

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

//

void CCatalogsHttpDownloadManager::DeleteRestoredDownloads()

    {

    DLTRACEIN((""));

    TInt count = iRestoredDownloads.Count();

    while ( count-- )

        {

        iRestoredDownloads[count]->Cancel();        

        }

    iRestoredDownloads.Reset();             

    }

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

// Returns the default configuration for downloads

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

//

MCatalogsHttpConfig& CCatalogsHttpDownloadManager::DefaultConfig() const

    {

    return *iDefaultConfig;

    }

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

// Moves a restored download to current downloads

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

//

TInt CCatalogsHttpDownloadManager::MoveRestoredDlToCurrentDls( 

    MCatalogsHttpOperation& aDownload )

    {

    DLTRACEIN((""));

    DASSERT( aDownload.OperationType() == ECatalogsHttpDownload );

    TInt index = FindInDownloads( iRestoredDownloads, &aDownload );

    if ( index != KErrNotFound ) 

        {

        DLTRACE(( "Removing from restored downloads" ));

        iRestoredDownloads.Remove( index );

        index = iDownloads.Append( &aDownload );

        // Update latest download id counter

        TInt opId = aDownload.OperationId().Id();

        if ( opId > iCurrentDlId ) 

            {

            iCurrentDlId = opId;

            }

        DLTRACE(( "Append err: %i", index ));                                

        }

    return index;

    }

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

// Removes the download from the manager

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

//

void CCatalogsHttpDownloadManager::RemoveDownload( 

    MCatalogsHttpOperation* aDownload )

    {    

    DLTRACEIN( ( "Total DLs before: %i", iDownloads.Count() ) );

    TInt index = KErrNotFound;

    // If cancelling all, we don't want to remove them separately 

    // from the list

    if ( !iCancellingAll ) 

        {        

        // Search from downloads

        index = FindInDownloads( iDownloads, aDownload );

        if ( index != KErrNotFound ) 

            {

            DLTRACE( ( "Removing from downloads" ) );

            iDownloads.Remove( index );

            }

        else 

            {

            // Search from restored

            index = FindInDownloads( iRestoredDownloads, aDownload );

            if ( index != KErrNotFound ) 

                {

                DLTRACE( ("Removing from restored downloads") );

                iRestoredDownloads.Remove( index );

                }

            }

        }

    DLTRACEOUT( ( "Total DLs after: %i", iDownloads.Count() ) );

    }

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

// Create download transaction

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

//

MCatalogsHttpOperation* CCatalogsHttpDownloadManager::CreateDlTransactionL( 

    const TDesC8& aUrl, MCatalogsHttpObserver& aObserver,

    const CCatalogsHttpConfig& aConfig )

    {

    return iTrManager.CreateDlTransactionL( aUrl, aObserver, aConfig );

    }

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

// Sets the access point for the next download

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

//

void CCatalogsHttpDownloadManager::SetConnectionMethodL( 

    const TCatalogsConnectionMethod& aMethod )

    {

    DLTRACEIN((""));

    if ( aMethod != iCurrentAp )

        {

		try

		{

        DLTRACE( ( "Set AP, type: %d, id: %u, apn: %d", 

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

		 iDmgr->pauseAll(); 

        iCurrentAp = aMethod;

        DLTRACE(("AP set"));

		}

		 catch(const std::exception& exception)

		 {

		 qt_symbian_exception2LeaveL(exception);

		 }

        }    

    }

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

// Connection setter

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

//

void CCatalogsHttpDownloadManager::SetConnectionL(

    CCatalogsConnection& aConnection )

    {

    DLTRACEIN((""));

    // No need to do any comparisons, SetConnectionMethodL ensures that

    // we don't update the APN unnecessarily to download manager

    //

    // There used to be a pointer comparison here but it didn't always work

    // correctly because the new CCatalogsConnection object was often

    // created to the same address as the old one so the APN was not

    // updated to the download manager    

    SetConnectionMethodL( aConnection.ConnectionMethod() );            

    }

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

// Add a reference

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

//

void CCatalogsHttpDownloadManager::AddRef()

    {

    iRefCount++;    

    }

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

// Release a reference

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

//

TInt CCatalogsHttpDownloadManager::Release()

    {

    DLTRACEIN( ( "" ) );

    iRefCount--;

    if ( !iRefCount ) 

        {

        delete this;

        return 0;

        }

    return iRefCount;

    }

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

// Returns the session id

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

//

TInt32 CCatalogsHttpDownloadManager::SessionId() const

    {

    return iSessionId;

    }

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

// Handles download manager events

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

//    

 void CCatalogsHttpDownloadManager::downloadMgrEventRecieved(WRT::DownloadManagerEvent* dlmEvent)

  {

  	switch(dlmEvent ->type())

		{

    default:

    	break;

		};

  }  

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

// Accesspoint observer

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

//

void CCatalogsHttpDownloadManager::HandleAccessPointEventL( 

    const TCatalogsConnectionMethod& /* aAp */,

    const TCatalogsAccessPointEvent& aEvent )

    {

    DLTRACEIN((""));

    if ( aEvent == ECatalogsAccessPointClosed ) 

        {

		try

		{

        DLTRACE(("Disconnecting download manager"));

		iDmgr->pauseAll();

	}

 		catch(const std::exception& exception) 

               { 

               qt_symbian_exception2LeaveL(exception); 

               } 

        }

    }