/*

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

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <f32file.h>

#include <DownloadMgrClient.h>

#include <HttpDownloadMgrCommon.h>

#include "IptvTestDownloadManager.h"

#include "VCXTestLog.h"

#include "CIptvTestTimer.h"

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

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

// CTestUtilConnection::NewL()

//

// Constructs CTestUtilConnection object

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

//

EXPORT_C CIptvTestDownloadManager* CIptvTestDownloadManager::NewL(MTestUtilDownloadObserver *aObs)

    {

    VCXLOGLO1(">>>CIptvTestDownloadManager::NewL");

    CIptvTestDownloadManager* self = NewLC(aObs);

    CleanupStack::Pop(self);

    VCXLOGLO1("<<<CIptvTestDownloadManager::NewL");

    return self;

    }

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

// CTestUtilConnection::NewLC()

//

// Constructs CTestUtilConnection object

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

//

EXPORT_C CIptvTestDownloadManager* CIptvTestDownloadManager::NewLC(MTestUtilDownloadObserver *aObs)

    {

    VCXLOGLO1(">>>CIptvTestDownloadManager::NewLC");

    CIptvTestDownloadManager* self = new (ELeave) CIptvTestDownloadManager(aObs);

    CleanupStack::PushL(self);

    self->ConstructL();

    VCXLOGLO1("<<<CIptvTestDownloadManager::NewLC");

    return self;

    }

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

// CTestUtilConnection::CTestUtilConnection()

//

// Constructor

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

//

CIptvTestDownloadManager::CIptvTestDownloadManager(MTestUtilDownloadObserver *aObs)

: iObserver(aObs)

    {

    VCXLOGLO1(">>>CIptvTestDownloadManager::CIptvTestUtilConnection");

    VCXLOGLO1("<<<CIptvTestDownloadManager::CIptvTestUtilConnection");

    }

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

// CTestUtilConnection::~CTestUtilConnection()

//

// Destructor

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

//

EXPORT_C CIptvTestDownloadManager::~CIptvTestDownloadManager()

    {

    VCXLOGLO1(">>>CIptvTestDownloadManager::~CIptvTestDownloadManager");

	iDownloadMgr.DeleteAll();

	iDownloadMgr.RemoveObserver(*this);

	iDownloadMgr.Close();

	if( iDownload )

		{

		iDownload->Delete();

		iDownload = NULL;

		}

    if( iTimer )

        {

        delete iTimer;

        iTimer = NULL;

        }

    VCXLOGLO1("<<<CIptvTestDownloadManager::~CIptvTestDownloadManager");

    }

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

// CIptvTestDownloadManager::ConstructL()

//

// Second phase constructor

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

//

EXPORT_C void CIptvTestDownloadManager::ConstructL()

    {

    VCXLOGLO1(">>>CIptvTestDownloadManager::ConstructL");

	iDownloadRunning = EFalse;

	TUid uid;

	uid.iUid = 0x101FB3E3;

	iDownloadMgr.ConnectL(uid, *this, ETrue);

    iTimer = CIptvTestTimer::NewL(*this, 0);

   	VCXLOGLO1("<<<CIptvTestDownloadManager::ConstructL");

    }

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

// CIptvTestDownloadManager::HandleDMgrEventL()

//

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

//

void CIptvTestDownloadManager::HandleDMgrEventL( RHttpDownload& aDownload, THttpDownloadEvent aEvent )

	{

	VCXLOGLO1(">>>CIptvTestDownloadManager::HandleDMgrEventL");

	TInt32 downloadId;

	aDownload.GetIntAttribute(EDlAttrId, downloadId);

	VCXLOGLO3("CIptvTestDownloadManager:: downloadId: %d, aEvent: %d", downloadId, aEvent);

    switch (aEvent.iProgressState)

        {

        case EHttpContentTypeReceived:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpContentTypeReceived");

            User::LeaveIfError(aDownload.Start());

            break;

        case EHttpProgNone:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgNone");

            break;

        case EHttpStarted:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpStarted");

            break;

        case EHttpProgCreatingConnection:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgCreatingConnection");

            break;

        case EHttpProgConnectionNeeded:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgConnectionNeeded");

            break;

        case EHttpProgConnected:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgConnected");

            break;

        case EHttpProgConnectionSuspended:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgConnectionSuspended");

            break;

        case EHttpProgDisconnected:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgDisconnected");

            break;

        case EHttpProgDownloadStarted:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgDownloadStarted");

            break;

        case EHttpContentTypeRequested:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpContentTypeRequested");

            break;

        case EHttpProgSubmitIssued:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgSubmitIssued");

            break;

        case EHttpProgResponseHeaderReceived:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgResponseHeaderReceived");

            break;

        case EHttpProgResponseBodyReceived:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgResponseBodyReceived");

            break;

        case EHttpProgRedirectedPermanently:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgRedirectedPermanently");

            break;

        case EHttpProgRedirectedTemporarily:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgRedirectedTemporarily");

            break;

        case EHttpProgDlNameChanged:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgDlNameChanged");

            break;

        case EHttpProgContentTypeChanged:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgContentTypeChanged");

            break;

        case EHttpProgCodDescriptorDownloaded:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgCodDescriptorDownloaded");

            break;

        case EHttpProgCodDownloadStarted:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgCodDownloadStarted");

            break;

        case EHttpProgCodDescriptorAccepted:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgCodDescriptorAccepted");

            break;

        case EHttpProgCodLoadEnd:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgCodLoadEnd");

            break;

        case EHttpProgSupportedMultiPart:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgSupportedMultiPart");

            break;

        case EHttpProgMovingContentFile:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgMovingContentFilep");

            break;

        case EHttpProgContentFileMoved:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgContentFileMoved");

            break;

        default:

            VCXLOGLO1("CIptvTestDownloadManager:: Unknown state");

            break;

        }

    switch (aEvent.iDownloadState)

        {

        case EHttpDlCompleted:

            {

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlCompleted");

			DeleteDownloadAsync( KErrNone );

            }

            break;

        case EHttpDlFailed:

            {

			TInt32 err;

			GetError( aDownload, err );

			VCXLOGLO2("CIptvTestDownloadManager:: Download failed, err: %d", err);

			if( err == KErrNone )

			    {

			    err = KErrGeneral;

			    }

			DeleteDownloadAsync( err );

            }

            break;

        case EHttpDlCreated:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlCreated");

            iDownloadRunning = ETrue;

            break;

        case EHttpDlInprogress:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlInprogress");

            break;

        case EHttpDlPaused:

            {

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlPaused");

			TInt32 err;

			GetError(aDownload, err);

			VCXLOGLO2("CIptvTestDownloadManager:: Download is paused, err: %d", err);

			if(err == KErrNone) err = KErrGeneral;

			DeleteDownloadAsync( err );

            }

	        break;

        case EHttpDlMoved:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlMoved");

            break;

        case EHttpDlMediaRemoved:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlMediaRemoved");

            break;

        case EHttpDlMediaInserted:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlMediaInserted");

            break;

        case EHttpDlPausable:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlPausable");

            break;

        case EHttpDlNonPausable:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlNonPausable");

            break;

        case EHttpDlDeleted:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlDeleted");

            if( !iDownloadFinishInformed )

                {

                VCXLOGLO1("CIptvTestDownloadManager:: Informing observer.");

                iDownloadFinishInformed = ETrue;

                iObserver->DownloadFinished( iError );

                iDownloadRunning = EFalse;

                }

            break;

        case EHttpDlAlreadyRunning:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlAlreadyRunning");

            break;

        case EHttpDlDeleting:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlDeleting");

            if( !iDownloadFinishInformed )

                {

                VCXLOGLO1("CIptvTestDownloadManager:: Informing observer.");

                iDownloadFinishInformed = ETrue;

                iObserver->DownloadFinished( iError );

                iDownloadRunning = EFalse;

                }

            break;

        case EHttpDlCancelTransaction:

            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlCancelTransaction");

            break;

        default:

            VCXLOGLO1("CIptvTestDownloadManager:: Unknown state");

            break;

        }

	VCXLOGLO1("<<<CIptvTestDownloadManager::HandleDMgrEventL");

	}

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

// CIptvTestDownloadManager::DownloadL()

//

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

//

EXPORT_C TInt CIptvTestDownloadManager::DownloadL( TDesC& aAddress, TDesC16& aOutFile, TDesC& aUserName, TDesC& aPassword, TInt32 aIapId, TInt aTimeoutSeconds)

	{

	VCXLOGLO1(">>>CIptvTestDownloadManager::DownloadL");

	TBool result;

	if( iDownload )

		{

		VCXLOGLO1("Download already ongoing.");

		VCXLOGLO1("<<<CIptvTestDownloadManager::DownloadL");

		return KErrNone;

		}

	iDownloadFinishInformed = EFalse;

	iTimerStartedForDownloadDeletion = EFalse;

	iError = KErrNone;

    iTimer->After(aTimeoutSeconds * 1000000);

    TBuf8<3000> address;

    TBuf8<256> username;

	TBuf8<256> password;

	address.Copy(aAddress);

	username.Copy(aUserName);

	password.Copy(aPassword);

	VCXLOGLO3("CIptvTestDownloadManager:: Starting downloading: %S -> %S", &aAddress, &aOutFile);

	VCXLOGLO3("CIptvTestDownloadManager:: User: %S, PW %S", &aUserName, &aPassword);

	VCXLOGLO2("CIptvTestDownloadManager:: Timeout: %d", aTimeoutSeconds);

	TInt err = KErrNone;

	err = iDownloadMgr.SetIntAttribute( EDlMgrIap, aIapId );

    if ( err != KErrNone )

        {

        VCXLOGLO2("CIptvTestDownloadManager:: Could not set AP! err: %d", err);

        return err;

        }

	RHttpDownload& download = iDownloadMgr.CreateDownloadL( address, result );

	iDownload = &download;

    err = iDownload->SetStringAttribute( EDlAttrDestFilename, aOutFile);

    if(err != KErrNone)

    	{

    	VCXLOGLO1("Setting destfilename failed.");

    	VCXLOGLO1("<<<CIptvTestDownloadManager::DownloadL");

    	return err;

    	}

    download.SetBoolAttribute(EDlAttrNoContentTypeCheck, ETrue);

    download.SetIntAttribute(EDlAttrUserData, 0);

    err = download.SetStringAttribute(EDlAttrUsername, username);

    if(err != KErrNone)

    	{

    	VCXLOGLO1("Setting download username failed.");

    	VCXLOGLO1("<<<CIptvTestDownloadManager::DownloadL");

    	return err;

    	}

    err = download.SetStringAttribute(EDlAttrPassword, password);

    if(err != KErrNone)

    	{

    	VCXLOGLO1("Setting download password failed.");

    	VCXLOGLO1("<<<CIptvTestDownloadManager::DownloadL");

    	return err;

    	}

	err = iDownload->Start();

    if(err != KErrNone)

    	{

    	VCXLOGLO1("Starting download failed.");

    	VCXLOGLO1("<<<CIptvTestDownloadManager::DownloadL");

    	return err;

    	}

	VCXLOGLO1("<<<CIptvTestDownloadManager::DownloadL");

	return err;

	}

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

// CIptvTestDownloadManager::GetError

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

//

EXPORT_C void CIptvTestDownloadManager::GetError(RHttpDownload& aDownload,

                                          TInt32& aDownloadError)

    {

    TInt32 errorId;

    TInt32 globalErrorId;

    aDownload.GetIntAttribute(EDlAttrErrorId, errorId);

    aDownload.GetIntAttribute(EDlAttrGlobalErrorId, globalErrorId);

    VCXLOGLO2("CIptvTestDownloadManager:: DL error ID: %d", errorId);

    VCXLOGLO2("CIptvTestDownloadManager:: DL global error ID: %d", globalErrorId);

    switch(errorId)

        {

        case EConnectionFailed:

            aDownloadError = EConnectionFailed;

            VCXLOGLO1("CIptvTestDownloadManager::  EConnectionFailed -> EIptvDlConnectionFailed");

            if(globalErrorId == KErrServerBusy)

                {

                VCXLOGLO1("CIptvTestDownloadManager:: server busy -> EIptvDlGeneral");

                aDownloadError = KErrServerBusy;

                }

            break;

        case EHttpAuthenticationFailed:

            VCXLOGLO1("CIptvTestDownloadManager::  EHttpAuthenticationFailed -> EIptvDlAuthFailed");

            aDownloadError = EHttpAuthenticationFailed;

            break;

        case EProxyAuthenticationFailed:

            VCXLOGLO1("CIptvTestDownloadManager::  EProxyAuthenticationFailed -> EIptvDlProxyAuthFailed");

            aDownloadError = EProxyAuthenticationFailed;

            break;

        case EDestFileInUse:

            VCXLOGLO1("CIptvTestDownloadManager::  EDestFileInUse -> EIptvDlDestFileInUse");

            aDownloadError = EDestFileInUse;

            break;

        case EBadUrl:

            VCXLOGLO1("CIptvTestDownloadManager::  EBadUrl -> EIptvDlBadUrl");

            aDownloadError = EBadUrl;

            break;

        case EMMCRemoved:

            VCXLOGLO1("CIptvTestDownloadManager::  EMMCRemoved -> EIptvDlMmcRemoved");

            aDownloadError = EMMCRemoved;

            break;

        case EDiskFull:

            VCXLOGLO1("CIptvTestDownloadManager::  EDiskFull -> EIptvDlDiskFull");

            aDownloadError = EDiskFull;

            break;

        case EObjectNotFound:

            VCXLOGLO1("CIptvTestDownloadManager::  EObjectNotFound -> EIptvDlContentNotFound");

            aDownloadError = EObjectNotFound;

            break;

        default:

            VCXLOGLO1("CIptvTestDownloadManager::  unknown -> EIptvDlGeneral");

            aDownloadError = KErrGeneral;

            break;

        }

    }

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

// CIptvTestDownloadManager::DeleteDownloadAsync

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

//

void CIptvTestDownloadManager::DeleteDownloadAsync( TInt aErrorToObserver )

    {

    VCXLOGLO1(">>>CIptvTestDownloadManager::DeleteDownloadAsync");

    if( iDownload )

        {

        iTimer->After( 1000000 ); // 1 second

        iTimerStartedForDownloadDeletion = ETrue;

        iError = aErrorToObserver;

        }

    VCXLOGLO1("<<<CIptvTestDownloadManager::DeleteDownloadAsync");

    }

void CIptvTestDownloadManager::TimerComplete( TInt aTimerId, TInt aError )

    {

    VCXLOGLO1(">>>CIptvTestDownloadManager::TimerComplete");

    VCXLOGLO3("CIptvTestDownloadManager:: aTimerId: %d, aError: %d", aTimerId, aError);

    if( iTimerStartedForDownloadDeletion )

        {

        iTimerStartedForDownloadDeletion = EFalse;

        VCXLOGLO1("IptvTestDownloadManager:: Deleting the download.");

        if( iDownload )

            {

            iDownload->Delete();

            iDownload = NULL;

            }

        // Obsever is informed at DL deletion.

        }

    else

        {

        iObserver->DownloadFinished(KErrTimedOut);

        }

    VCXLOGLO1("<<<CIptvTestDownloadManager::TimerComplete");

    }

//  End of File