/*

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

*     CDownloadHandler implementation

*

*

*/

#include <aknappui.h>

#include <COEUTILS.H>

#include <wlanerrorcodes.h> //For download error handling

#include <etelpckt.h>       //For download error handling

#include <exterror.h>       //For download error handling

#include <httpdownloadmgrcommon.h> // For download error handling (not in S60 5.0 SDK)

#include "ADM.hrh"

#include "ADMDownloadHandler.h"

#include "ADMAppUi.h"

#include "networkstatuslistener.h"

#include "globals.h"

#include "macros.h"

/*

#ifdef USE_LOGFILE

#include "debug.h"

#undef LOG

#undef LOG2

#undef LOG3

#undef LOG4

#undef LOG5

#undef LOG6

#undef LOG7

#undef LOG8

#undef LOG8_2

#define LOG( aMsg ) { _LIT(KMsg, aMsg); iAppUi.iLog.Write( KMsg ); RDebug::Print( KMsg ); }

#define LOG2( aMsg, aParam1 ) { _LIT(KMsg, aMsg); iAppUi.iLog.WriteFormat( KMsg, aParam1 ); RDebug::Print( KMsg, aParam1 ); }

#define LOG3( aMsg, aParam1, aParam2 ) { _LIT(KMsg, aMsg); iAppUi.iLog.WriteFormat( KMsg, aParam1, aParam2 ); RDebug::Print( KMsg, aParam1, aParam2 ); }

#define LOG4( aMsg, aParam1, aParam2, aParam3 ) { _LIT(KMsg, aMsg); iAppUi.iLog.WriteFormat( KMsg, aParam1, aParam2, aParam3 ); RDebug::Print( KMsg, aParam1, aParam2, aParam3 ); }

#define LOG5( aMsg, aParam1, aParam2, aParam3, aParam4 ) { _LIT(KMsg, aMsg); iAppUi.iLog.WriteFormat( KMsg, aParam1, aParam2, aParam3, aParam4 ); RDebug::Print( KMsg, aParam1, aParam2, aParam3, aParam4 ); }

#define LOG6( aMsg, aParam1, aParam2, aParam3, aParam4, aParam5 ) { _LIT(KMsg, aMsg); iAppUi.iLog.WriteFormat( KMsg, aParam1, aParam2, aParam3, aParam4, aParam5 ); RDebug::Print( KMsg, aParam1, aParam2, aParam3, aParam4, aParam5 ); }

#define LOG7( aMsg, aParam1, aParam2, aParam3, aParam4, aParam5, aParam6 ) { _LIT(KMsg, aMsg); iAppUi.iLog.WriteFormat( KMsg, aParam1, aParam2, aParam3, aParam4, aParam5, aParam6 ); RDebug::Print( KMsg, aParam1, aParam2, aParam3, aParam4, aParam5, aParam6 ); }

#define LOG8( aMsg, aParam1, aParam2, aParam3, aParam4, aParam5, aParam6, aParam7 ) { _LIT(KMsg, aMsg); iAppUi.iLog.WriteFormat( KMsg, aParam1, aParam2, aParam3, aParam4, aParam5, aParam6, aParam7 ); RDebug::Print( KMsg, aParam1, aParam2, aParam3, aParam4, aParam5, aParam6, aParam7 ); }

#define LOG8_2( aMsg, aParam1 ) { _LIT8(KMsg, aMsg); iAppUi.iLog.WriteFormat( KMsg, aParam1 ); RDebug::Print(_L("RDebug _L8() at line %d"), __LINE__); }

#endif

*/

#ifdef USE_LOGFILE

// Logging version

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

//

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

//

CDownloadHandler* CDownloadHandler::NewL(MDownloadClient* aDlClient, RFileLogger& aLogger, const TBool aMasterInstance)

	{

	CDownloadHandler* object = new ( ELeave ) CDownloadHandler(aDlClient, aLogger, aMasterInstance);

	CleanupStack::PushL( object );

	object->ConstructL();

	CleanupStack::Pop();

	return object;

	}

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

//

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

//

CDownloadHandler::CDownloadHandler(MDownloadClient* aDlClient, RFileLogger& aLogger, const TBool aMasterInstance) :

	iLog(aLogger),

	iDlClient(aDlClient),

	iMasterInstance(aMasterInstance),

	iPtrToResponseBodyFileName(0,0)

	{

	}

#else

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

//

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

//

CDownloadHandler* CDownloadHandler::NewLC(MDownloadClient* aDlClient, const TBool aMasterInstance)

	{

	CDownloadHandler* object = new ( ELeave ) CDownloadHandler(aDlClient, aMasterInstance);

	CleanupStack::PushL( object );

	object->ConstructL();

	return object;

	}

CDownloadHandler* CDownloadHandler::NewL(MDownloadClient* aDlClient, const TBool aMasterInstance)

	{

	CDownloadHandler* object = CDownloadHandler::NewLC(aDlClient, aMasterInstance);

	CleanupStack::Pop();

	return object;

	}

CDownloadHandler::CDownloadHandler(MDownloadClient* aDlClient, const TBool aMasterInstance) :

	iDlClient(aDlClient),

	iMasterInstance(aMasterInstance),

	iPtrToResponseBodyFileName(0,0)

	{

	}

#endif

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

// Default destructor

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

//

CDownloadHandler::~CDownloadHandler()

	{

	DELETE_IF_NONNULL( iUrl );

	DELETE_IF_NONNULL( iResponseBodyFileName );

	delete iNetworkStatusListener;

	iDownloadManager.DeleteAll();

	iDownloadManager.Close();

	}

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

//

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

//

void CDownloadHandler::ConstructL()

	{

//	TBool masterInstance(!(iADMAppUiObj->EikonEnv()->StartedAsServerApp()));

	const TUid uid = {_UID3};

	iDownloadManager.ConnectL(uid , *this, iMasterInstance );

	iNetworkStatusListener = CNetworkStatusListener::NewL( *this );

	}

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

//

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

//

void CDownloadHandler::SetIAP(TUint32 aIAP)

	{

	iIAP = aIAP;

	if ( iIAP > 0)

		{

		LOG2( "CDownloadHandler::SetIap(): %d", aIAP );

		// Set the download manager to silent mode

		iDownloadManager.SetBoolAttribute( EDlMgrSilentMode, ETrue );

		iDownloadManager.SetIntAttribute( EDlMgrIap, iIAP );

		iNetworkStatusListener->SetIapIdToMonitor(iIAP);

		}

	}

#ifdef USE_LOGFILE

void CDownloadHandler::Log(TRefByValue<const TDesC16> aFmt, ...)

	{

	VA_LIST list;

	VA_START(list, aFmt);

	TBuf<0x100> buf;

	buf.AppendFormatList(aFmt, list);

	iLog.Write(buf);

	}

#endif

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

// Callback for CNetworkStatusObserver

//

// Called when the connection status changes

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

//

void CDownloadHandler::HandleNetworkStatusChangedL(const TInt aStatus)

	{

	LOG2( "+ HandleNetworkStatusChangedL(): %d", aStatus );

	// Did we lose the network connection?

	if (aStatus == EConnMonStatusNotAvailable)

		{

		iNetworkLost = ETrue;

		}

	//LOG2( "- HandleNetworkStatusChangedL(): %d", iNetworkLost );

	}

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

// Processes download errors and sets aDownloadError

//

// @param aGlErrId Global error ID from download manager.

// @param aErrId Error ID from download manager.

// @param aDownloadError Reference to the download error variable function is

//      going to set in case of known error.

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

//

TBool CDownloadHandler::ProcessDlErrors(const TInt32 aGlErrId, const TInt32 aErrId, EDownloadError& aDownloadError)

	{

	if (iFetchType && (aGlErrId || aErrId))

		LOG4( "+ ProcessDlErrors(%d, %d, %d)", aGlErrId, aErrId, aDownloadError );

	TBool requestRestart = EFalse;

	// Process the error codes

	switch (aErrId)

		{

		case KErrNone:

			// everything a-OK!

			break;

		case EConnectionFailed:

			aDownloadError = EDlErrDownloadFailure;

			break;

		case ETransactionFailed:

			// We set the download error to network failure as that's the

			// error propagated to TState::DownloadFailed().

			// The state machine will try to restart the download, if the

			// error code is EDlErrDownloadFailure, but NOT for EDlErrNetworkFailure.

			aDownloadError = EDlErrDownloadFailure;

			requestRestart = ETrue;

			break;

		case EObjectNotFound:

			aDownloadError = EDlErrFileNotFound;

			break;

		default:

			LOG2( "Unhandled ErrId %d", aErrId );

			aDownloadError = EDlErrDownloadFailure;

			break;

		}

	// Process the global error code

	switch (aGlErrId)

		{

		case KErrNone:

			// everything a-OK!

			break;

		case KErrCancel:

		case KErrAbort:

			// The user has cancelled the download / IAP selection box

			aDownloadError = EDlErrCancelled;

			break;

		case KErrDiskFull:

			// Disk full

			aDownloadError = EDlErrNotEnoughSpace;

			break;

		case KErrUnknown:

			// act on KErrUnknown only, if error ID is not set

			if (aErrId == KErrNone)

				{

				aDownloadError = EDlErrDownloadFailure;

				requestRestart = ETrue;

				}

			break;

		case KErrNotFound:

		case KErrBadName:

		case KErrNotSupported:

		case KErrCommsLineFail:

		case KErrTimedOut:

		case KErrCouldNotConnect:

		case KErrDisconnected:

		case KErrGprsServicesNotAllowed:

		case KErrGsmMMNetworkFailure:

		// WLAN network related errors:

		case KErrWlanNetworkNotFound:

		case KErrWlanRoamingFailed:

		case KErrWlanNetworkLost:

#if 0

		case KErrBadName:

		case KErrNotSupported:

		case KErrWlanOpenAuthFailed:

		case KErrWlanSharedKeyAuthRequired:

		case KErrWlanSharedKeyAuthFailed:

		case KErrWlanWpaAuthRequired:

		case KErrWlanIllegalEncryptionKeys:

		case KErrWlanPskModeRequired:

		case KErrWlanEapModeRequired:

		case KErrWlanSimNotInstalled:

		case KErrWlanNotSubscribed:

		case KErrWlanAccessBarred:

		case KErrWlanPasswordExpired:

		case KErrWlanNoDialinPermissions:

		case KErrWlanAccountDisabled:

		case KErrWlanRestrictedLogonHours:

		case KErrWlanServerCertificateExpired:

		case KErrWlanCerficateVerifyFailed:

		case KErrWlanNoUserCertificate:

		case KErrWlanNoCipherSuite:

		case KErrWlanUserRejected:

		case KErrWlanUserCertificateExpired:

		// less fatal, but still needs to fail the download:

		case KErrWlanWpaAuthFailed:

		case KErrWlan802dot1xAuthFailed:

		case KErrWlanIllegalWpaPskKey:

		case KErrWlanEapSimFailed:

		case KErrWlanEapTlsFailed:

		case KErrWlanEapPeapFailed:

		case KErrWlanEapMsChapv2:

		case KErrWlanEapAkaFailed:

		case KErrWlanEapTtlsFailed:

		case KErrWlanLeapFailed:

		case KErrWlanEapGtcFailed:

#endif

			// A fatal network error has occured, don't retry the download

			requestRestart = EFalse;

			aDownloadError = EDlErrNetworkFailure;

			break;

		default:

			if (!requestRestart)

				{

				// We assume all the other error codes to be 'hard' network errors

				LOG2( "Unhandled GlErrId %d", aGlErrId );

				aDownloadError = EDlErrNetworkFailure;

				}

			break;

		}

	if (iFetchType && aDownloadError != ENoError)

		LOG3( "- ProcessDlErrors(): %d, %d", requestRestart, aDownloadError );

	return requestRestart;

	}

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

//

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

//

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

	{

	TInt32 glErrId = KErrNone;

	TInt32 errId = ENoError;

	// Get error IDs

	aDownload.GetIntAttribute( EDlAttrGlobalErrorId, glErrId );

	aDownload.GetIntAttribute( EDlAttrErrorId, errId );

#ifdef DO_LOG

	if (iFetchType)

		{

		_LIT(KFmt, ", GlErrId=%6d, ErrId=%d");

		TBuf<64> buf;

		if ( ((glErrId != KErrNone) || (errId != ENoError)) && glErrId != KErrUnknown )

			{

			buf.AppendFormat(KFmt, glErrId, errId);

			}

		if ( ( iDownloadState != aEvent.iDownloadState ) ||

			 ( iProgressState != aEvent.iProgressState ) )

			{

			iDownloadState = aEvent.iDownloadState;

			iProgressState = aEvent.iProgressState;

			LOG5( "DlSt=%5d, PrSt=%5d, L=%d%S", iDownloadState, iProgressState, iNetworkLost, &buf );

			}

		}

#endif

	if (iNetworkLost && !iCancelled)

		{

		TBuf<KMaxPath> fn;

		aDownload.GetStringAttribute( EDlAttrDestFilename, fn );

		iDownloadError = EDlErrNetworkFailure;

		LOG2( "Connection lost! Cancelling '%S' download.", &fn );

		DoHandleHttpFetchFailure(fn, glErrId, errId);

		return;

		}

	switch ( aEvent.iDownloadState )

		{

		case EHttpDlCreated:

			{

			break;

			}

		case EHttpDlInprogress:

			{

			// Already downloaded content size

			TInt32 downloadedSize( 0 );

			// Total download size

			TInt32 dlLength( 0 );

			if ( aEvent.iProgressState == EHttpProgConnected )

				{

				TInt32 iap;

				// Get the selected IAP (ignore any errors from Get())

				iDownloadManager.GetIntAttribute( EDlMgrIap, iap );

				if (iIAP != iap)

					{

					LOG2( "* Using IAP %d", iap );

					iIAP = iap;

					iDlClient->HandleIapChanged(iIAP);

					}

				}

			aDownload.GetIntAttribute( EDlAttrDownloadedSize, downloadedSize );

			aDownload.GetIntAttribute( EDlAttrLength, dlLength );

			UpdateDownloadSpeed(downloadedSize);

			iDlClient->HandleHttpFetchInProgress( downloadedSize, dlLength, iDlAvgSpeed );

			break;

			}

		case EHttpDlPaused:

		case EHttpDlFailed:

// These two fill fold to EHttpDlFailed. We don't want to process failure events twice.

//		case EHttpDlNonPausableNetworkLoss:

//		case EHttpDlMultipleMOFailed:

			{

			TBuf<KMaxPath> buf;

			aDownload.GetStringAttribute( EDlAttrDestFilename, buf );

			// We just monitor the progress state and start download, when

			// content-type is received. Any errors are ignored in this state.

			if (

				// we have to check error codes in EHttpProgNone state, otherwise

				// we'll end up infinite loop, for instance, in AP selection cancellation

				 ( aEvent.iProgressState == EHttpContentTypeReceived ) ||

				 ( ( aEvent.iProgressState == EHttpProgNone ) && ( errId == ENoError) ) )

				{

				// TODO: Should we check glErrId and do Reset() before starting download?

				// need to start the download if not already started

				LOG( "Starting download" );

				aDownload.Start();

				// Start timing the download

				iDlStartTime.UniversalTime();

				// ignore any errors, so we can start the download

				break;

				}

			if ( ProcessDlErrors(glErrId, errId, iDownloadError) )

				{

				if (++iConnectionAttempt < KDownloadConnectionRetries)

					{

					LOG4( "Restarting download due to network failure (%d: %d, %d)", iConnectionAttempt, glErrId, errId );

					// TODO: Do we need to do a Reset() before Start()?

					aDownload.Start();

					// We don't restart the download timer on purpose

					//

					// Clear the error id so it doesn't get caught below

					// as this is not an error situation.

					iDownloadError = EDlErrNoError;

					}

				else

					{

					LOG4( "Too many retries, cancelling download (%d; %d, %d)", iDownloadError, glErrId, errId );

					// iDownloadError has been set properly by ProcessDlErrors()

					}

				}

			if ( iDownloadError != KErrNone )

				{

				if (iFetchType)

					LOG2( "DlErr=%d", iDownloadError );

				// Inform about it

				DoHandleHttpFetchFailure(buf, glErrId, errId);

				// TODO: Just in case: don't delete the download in HandleDMgrEventL

				// That seems to cause problems on different devices.

				// Download failed, delete it

				// aDownload.Delete();

				}

			break;

			}

		case EHttpDlCompleted:

			{

			TBuf<KMaxPath> buf;

			// Download Manager total Length of the download

			TInt32 dlLength( 0 );

			aDownload.GetIntAttribute( EDlAttrLength, dlLength );

			aDownload.GetStringAttribute( EDlAttrDestFilename, buf );

			const TInt64 dlTime = UpdateDownloadSpeed(dlLength);

			iDlClient->HandleHttpFetchCompleted(buf, iFetchType, dlLength, iDlAvgSpeed, dlTime);

			break;

			}

		case EHttpDlDeleting:

			// Signal that we're deleting the download

			iDlClient->HandleDownloadDeleting();

			break;

		default:

			{

			break;

			}

		} // switch

	}

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

// Updates the average download speed counter

// @param aBytesDownloaded Bytes downloaded during this download

// @returns Time in microseconds spend in this download

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

//

TInt64 CDownloadHandler::UpdateDownloadSpeed(const TInt32 aBytesDownloaded)

	{

	TInt64 fromDlStart = 0;

	if (aBytesDownloaded > 0)

		{

		TTime time;

		time.UniversalTime();

		fromDlStart = time.MicroSecondsFrom(iDlStartTime).Int64();

		// Use ifs to avoid divide-by-zero

		if (fromDlStart > 0)

			{

			iDlAvgSpeed = aBytesDownloaded*1000000.0 / fromDlStart;

			}

		}

	return fromDlStart;

	}

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

//

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

//

void CDownloadHandler::CancelAllDownloads()

	{

	// Remove all downloads

	iDownloadManager.DeleteAll();

	}

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

// Handles client callback when download fails

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

//

void CDownloadHandler::DoHandleHttpFetchFailure(const TDesC& aDlFilename, const TInt aGlobalErrorId, const TInt aErrorId)

	{

	if (!iCancelled)

		{

		iDlClient->HandleHttpFetchFailure(aDlFilename, aGlobalErrorId, aErrorId, iFetchType);

		iCancelled = ETrue;

		}

	else

		{

		LOG( "DoHandleHttpFetchFailure(): Called, but already cancelled" );

		}

	}

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

//

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