/*

* Copyright (c) 2005 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:   downloads upd pkg

*

*/

// INCLUDES

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <es_enum_internal.h>

#endif

#include <centralrepository.h>

#include <f32file.h>

#include <AknWaitDialog.h>

#include <fotaserver.rsg>

#include <eikprogi.h>

#include <eikenv.h>

#include <apgtask.h>

#include <apgwgnam.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <es_sock.h>

#else

#include <es_sock.h>

#include <es_sock_partner.h>

#endif

#include <es_enum.h>

#include <bautils.h>

#include <StringLoader.h>

#include <DevManInternalCRKeys.h> //for reading san feature

#include <e32property.h>

#include "fotastorage.h"

#include "FotaSrvApp.h"

#include "fotadownload.h"

#include "fotaserverPrivatePSKeys.h"

#include "FotaNetworkRegStatus.h"

#include <startupdomainpskeys.h>	//globalrfsstates

#define __LEAVE_IF_ERROR(x) if(KErrNone!=x) {FLOG(_L("LEAVE in %s: %d"), __FILE__, __LINE__); User::Leave(x); }

#define __LEAVE(x) {FLOG(_L("LEAVE in %s: %d"), __FILE__, __LINE__); User::Leave(x); }

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

// CFotaDownload::NewL 

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

CFotaDownload* CFotaDownload::NewL (CFotaServer* aServer)

	{

	__ASSERT_ALWAYS( aServer, User::Panic(KFotaPanic, KErrArgument) );

	CFotaDownload* ao = new (ELeave) CFotaDownload();

	ao->iFotaServer = aServer;

	return ao;

	}

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

// CFotaDownload::RunL

// Do operations started in HandleDmgrEvent

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

void CFotaDownload::RunL()

	{

	FLOG(_L( "[FotaServer] CFotaDownload::RunL() >>"));

	CancelDownload( ETrue );

	CreateDownloadL();

	FLOG(_L( "[FotaServer] CFotaDownload::RunL() <<" ) );

	}

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

// CFotaDownload::DoCancel()

// Cancel notifier request

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

//

void CFotaDownload::DoCancel()

	{

	FLOG(_L("CFotaDownload::DoCancel() >>"));

	FLOG(_L("CFotaDownload::DoCancel() <<"));

	}

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

// CFotaDownload::RunError(TInt aError)

// Handle active object run error.

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

//

TInt CFotaDownload::RunError(TInt aError)

	{

	if(aError)

		{

		FLOG(_L(" CFotaDownload::RunError err %d"), aError );

		}

	return aError;

	}

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

// CFotaDownload::CFotaDownload()

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

//

CFotaDownload::CFotaDownload() : CActive(EPriorityNormal)

		, iUpdateAfterDownload (EFalse), iUrl( NULL ),

		iDownload (NULL),

		iDownloadedContentSize(0),

		iPreviousContentSize ( 0 ), iShowOMACDUI(EFalse), iShowDLPrgUI(EFalse),

		iDownloadResumable (EFalse),				

		iFMSEnabled (EFalse),

		iDownloadActive (EFalse),

		iFreshDL(ETrue),

		iUserInitiatedResume(EFalse),		

		iSanValue(KErrNotFound),

		iDownloadFinalized(EFalse)		

	{

	CActiveScheduler::Add( this ); 

	FLOG(_L("CFotaDownload::CFotaDownload()"));

	}

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

// CFotaDownload::~CFotaDownload()

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

//

CFotaDownload::~CFotaDownload()

	{

	FLOG(_L("CFotaDownload::~CFotaDownload() >>"));

	Cancel();

	//Sets download state inactive if accidently closed. This is anyhow taken care in FinalizeDownload in Server.

	SetDownloadActive(EFalse);

	CancelDownload( ETrue );

	if ( iUrl )

		{

		delete iUrl; iUrl=NULL;

		}

/*	if ( iNotifHandler ) Deleted at server

		{

		iNotifHandler->Cancel();

		delete iNotifHandler;        

		}*/

	if ( iDLProgressDlg )

		{

		delete iDLProgressDlg; iDLProgressDlg=NULL;

		}

	if (iDownloadMgr.Handle())

		iDownloadMgr.Close();

	//don't delete iFotaServer as it doesn't belong here.

	FLOG(_L("CFotaDownload::~CFotaDownload() <<"));

}

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

// CFotaDownload::CancelDownload

// Cancel download

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

//

void CFotaDownload::CancelDownload( const TBool aCancelProgressBar )

	{

	FLOG(_L("CFotaDownload::CancelDownload() >>"));

	if( iDownloadMgr.Handle() )

		{

		iDownloadMgr.Close();

		}

	if ( aCancelProgressBar  && iDLProgressDlg )

		{

		TRAPD(err, iDLProgressDlg->ProcessFinishedL() ) ;// deletes

		if(err); // remove compiler warning

		delete iDLProgressDlg;

		iDLProgressDlg = NULL;

		}

	FLOG(_L("CFotaDownload::CancelDownload() <<"));

	}

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

// CFotaDownload::CreateDownloadL

// Create  download

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

//

void CFotaDownload::CreateDownloadL()

	{

	FLOG(_L("CFotaDownload::CreateDownloadL() >>") );

	__ASSERT_ALWAYS( iDownloadMgr.Handle()==0, User::Leave(KErrAlreadyExists) );

	RHttpDownload*  d(NULL);

	iDLNeedsReset = EFalse;

	TBool       created;

	iDownloadMgr.ConnectL( TUid::Uid(KFotaServerUid) , *this, EFalse); 

	FLOG(_L("CFotaDownload::CreateDownloadL, Stage 1") );

	iDownloadMgr.DeleteAll();

	TRAPD(err, d = &iDownloadMgr.CreateDownloadL( *iUrl, created ) );

	RFs fs;	

	if(fs.Connect() == KErrNone)

	    {

	    RFile file;    

	    CleanupClosePushL( fs );

	    CleanupClosePushL( file );

	    err=fs.MkDir(KDDDirPath);

	    FLOG(_L("creating directory err as %d"),err);

	    err=fs.SetSessionPath(KDDDirPath);

	    FLOG(_L("setting session path err as %d"),err);

	    err=fs.ShareProtected();

	    FLOG(_L("ShareProtected err as %d"),err);

	    err = file.Replace(fs,KDDFilename, EFileWrite|EFileShareAny);	

	    FLOG(_L("creating rfile err as %d"),err);	

	    err = d->SetFileHandleAttribute(file);

	    FLOG(_L("setting dlmgr destfile attrib err as %d"),err);

	    CleanupStack::PopAndDestroy( &file );

	    CleanupStack::PopAndDestroy( &fs );

	    }	

	FLOG(_L("CFotaDownload::CreateDownloadL, Stage 2. err %d"),err);

	if ( err  == KErrArgument ) User::Leave( KErrNotFound );

	else if( err !=KErrNone)    User::Leave( err );

	if ( iDLState.iIapId > KErrNotFound )

		{

		FLOG(_L("   Using internet access point iapid: %d"), iDLState.iIapId);

		err = iDownloadMgr.SetIntAttribute( EDlMgrIap, iDLState.iIapId); // IAP id

		User::LeaveIfError( err );        

		//At this point the iIapId used in the SyncML Session is presumed working. Hence

		//the same is stored in database for use during download.

		FLOG(_L("Setting IAPID=%d is FotaState"),iDLState.iIapId);

		iFotaServer->iDatabase->OpenDBL();

		iFotaServer->iDatabase->SetStateL(iDLState,KNullDesC8, EFDBIapId );

		iFotaServer->iDatabase->CloseAndCommitDB();

		}

	FLOG(_L("CFotaDownload::CreateDownloadL, Stage 3") );

	User::LeaveIfError( d->SetIntAttribute(EDlAttrFotaPckgId ,iDLState.iPkgId) );

	FLOG(_L("CFotaDownload::CreateDownloadL, Stage 4") );

	User::LeaveIfError( d->SetBoolAttribute(EDlAttrNoContentTypeCheck,ETrue) );

	// If ui hidden or download restarting, do not show descriptor

	if ( !iShowOMACDUI || iRestartCounter > 0 )

		{

		FLOG(_L("setting DD to hidden"));

		User::LeaveIfError(iDownloadMgr.SetBoolAttribute( EDlMgrSilentMode,ETrue )) ;

		}

	//It's a fresh download

	iFreshDL = ETrue;

	// Start download 

	User::LeaveIfError(iDownloadMgr.StartAll()); 

	FLOG(_L("CFotaDownload::CreateDownloadL, Stage 5") );

	iDLProgress = EStarted;

	//This P&S Key is used to notify DM UI on any download event. key=0 for idle and key=1 for download

	err = RProperty::Set( TUid::Uid(KOmaDMAppUid),

			KFotaDMRefresh,

			ETrue );

	FLOG(_L("RProperty KFotaDMRefresh Set Etrue, err = %d"), err);

	SetDownloadActive(ETrue);

	User::LeaveIfError(err);

	FLOG(_L("[FotaServer]  CFotaDownload::CreateDownloadL <<"));

}

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

	// CFotaDownload::DownloadL

	// Start download of swupd package.

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

	//

void CFotaDownload::DownloadL(TDownloadIPCParams aParams,const TDesC8& aPkgURL

		,TBool aUpdateAfterDownload,const TInt aIapid,const TInt aRestartDownload)

	{

	FLOG(_L("[FotaServer]  CFotaDownload::DownloadL >> restart %d"),aRestartDownload);

	TInt err = RProperty::Define( TUid::Uid(KOmaDMAppUid),

			KFotaDMRefresh,

			RProperty::EInt,KReadPolicy,KWritePolicy);

	FLOG(_L("RProperty KFotaDMRefresh Define, err = %d"), err);        

	if (err != KErrAlreadyExists )

		{

		User::LeaveIfError(err);

		err = RProperty::Set( TUid::Uid(KOmaDMAppUid),

				KFotaDMRefresh,

				KErrNotFound );

		FLOG(_L("RProperty KFotaDMRefresh Set KErrNotFound, err = %d"), err);

		User::LeaveIfError(err);

		}

	if ( iUrl ) {delete iUrl; iUrl=NULL;}

	iUrl = aPkgURL.Alloc();

	iUpdateAfterDownload = aUpdateAfterDownload;

	iRestartCounter = aRestartDownload;

	iDLState        = aParams;

	FLOG(_L("CFotaDownload::DownloadL, Stage 1") );

	// Set state -------------------------------------------------------------

	iDLState.iState = RFotaEngineSession::EStartingDownload;

	iDLState.iResult = KErrNotFound;

	iDLState.iUpdateLtr = aUpdateAfterDownload;

	iFotaServer->iDatabase->OpenDBL();

	iFotaServer->iDatabase->SetStateL( iDLState, *iUrl,EFDBState|EFDBResult

			| EFDBProfileId|EFDBPkgUrl|EFDBPkgName|EFDBVersion|EFDBUpdateLtr);

	iFotaServer->iDatabase->CloseAndCommitDB();

	FLOG(_L("CFotaDownload::DownloadL, Stage 2, pkgid:%d"),iDLState.iPkgId);

	// 2. Get Iap Id to use for download. This would be set in iDLState.iIapId.

	SetIapToUseL(aParams, aIapid);

	// 3. Determine whether download should be visible or not

	// Autoaccepted profile?

	SetDownloadUiBehavior(ETrue);

	CancelDownload( ETrue );

	FLOG(_L("Setting SessionType=%d in FotaState"),iDLState.iSessionType);

	iFotaServer->iDatabase->OpenDBL();

	iFotaServer->iDatabase->SetStateL(iDLState,KNullDesC8, EFDBSessionType );

	iFotaServer->iDatabase->CloseAndCommitDB();

	FLOG(_L("CFotaDownload::DownloadL, Stage 3") );

	//Called to read the download variations in Fota (resume support & FMS)

	CheckDownloadVariations();

	//Create the download

	CreateDownloadL( );

	FLOG(_L("[FotaServer]  CFotaDownload::DownloadL <<"));

	}

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

// CFotaDownload::HandleDLProgressDialogExitL

// Handle canceling of download

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

TBool CFotaDownload::HandleDLProgressDialogExitL( TInt aButtonId ) 

	{

	FLOG(_L("CFotaDownload::HandleDLProgressDialogExitL %d, note = %d >>"),aButtonId, iDLProgressDlg->iNoteType);

	// Cancel clicked during download

	if ( aButtonId == KErrNotFound )

		{

		iRestartCounter = -1;

		FLOG(_L("[FotaServer]  CFotaDownload::HandleDLProgressDialogExitL Hiding UI"));

		iFotaServer->iParentApp->SetUIVisibleL ( EFalse, ETrue );

		iUpdateAfterDownload = EFalse;

		iDLState.iResult = RFotaEngineSession::EResUserCancelled;

		if (iDLProgressDlg->iNoteType == EConnectingNote)

			{

			iDLState.iState = RFotaEngineSession::EDownloadProgressingWithResume;

			TInt active (KErrNotFound);

			RProperty::Get( TUid::Uid(KOmaDMAppUid), KFotaDownloadActive, active );

			FLOG(_L("active = %d"),active);

			if (active) //Resume operation has just begun and download request is submitted to dlmgr. Hence need to suspend.

				{

				RunDownloadSuspendL(RFotaEngineSession::EResUserCancelled, ETrue);

				}

			else //Resume operation has just begun, but download request is not submitted to dlmgr

				{

				LaunchNotifierL( ESyncMLFwUpdOmaDLPostponed, EFalse, EFalse );

				iFotaServer->FinalizeDownloadL( iDLState );

				}

			}

		else if (iDLProgressDlg->iNoteType == EDownloadingNote)

			{

			if (iDownloadResumable)

				{

				//Resume is supported. Query user whether to postpone or cancel download.

				FLOG(_L("User pressed cancel. Resume is supported; hence pause download and query user if download has to be postponed or cancelled permanently."));

				RunDownloadSuspendL(RFotaEngineSession::EResUserCancelled);

				}

			else

				{

				//Resume is not supported. Download is cancelled

				FLOG(_L("User pressed cancel. Resume is not supported & hence download has to be cancelled"));

				RunDownloadCancelL(RFotaEngineSession::EResUserCancelled);

				}

			}

		}

	FLOG(_L("CFotaDownload::HandleDLProgressDialogExitL <<"));

	return ETrue;

	}

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

// CFotaDownload::DoHandleDMgrEventL

// Handles download events. Updates package state accordingly

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

void CFotaDownload::DoHandleDMgrEventL( RHttpDownload* aDownload

		, THttpDownloadEvent aEvent )

	{

	__ASSERT_ALWAYS( aDownload, User::Panic(KFotaPanic, KErrArgument) );

	TInt32                      sysErrorId( KErrNone );

	TInt32                      contentsize;

	TInt32                      downloadedsize;

	TInt32                      tmp;

	THttpDownloadMgrError       dlErrorId;

	iDownload = aDownload;

	// If DL is in final state (complete/fail), there's an error id available.

	User::LeaveIfError( aDownload->GetIntAttribute( EDlAttrGlobalErrorId

			,sysErrorId ) );

	User::LeaveIfError( aDownload->GetIntAttribute( EDlAttrDownloadedSize

			,downloadedsize ) );

	User::LeaveIfError( aDownload->GetIntAttribute( EDlAttrLength

			,contentsize ) );

	User::LeaveIfError( aDownload->GetIntAttribute( EDlAttrErrorId

			,tmp ) );

	dlErrorId = (THttpDownloadMgrError)tmp;

	// Update progress dlg progress

	if ( !iDLProgressDlg && iRestartCounter>0)

		{

		FLOG(_L("reshowing progress..."));

		iDLProgressDlg = new(ELeave) CFotaDLProgressDlg((CEikDialog** ) &iDLProgressDlg , EFalse, this, EDownloadingNote );

		iDLProgressDlg->PrepareLC( R_FOTASERVER_DL_PROGRESS_DIALOG );

		iDLProgressDlg->RunLD();

		}

	if (iDLProgressDlg)

		{

		CEikProgressInfo* progressInfo = iDLProgressDlg->GetProgressInfoL();

		__ASSERT_ALWAYS( progressInfo, User::Panic(KFotaPanic, KErrBadHandle) );

		if ( iPreviousContentSize!=contentsize )

			{

			iPreviousContentSize = contentsize;

			if ( contentsize > 0 )

				{

				progressInfo->SetFinalValue( contentsize );

				}

			}

		TInt incr = downloadedsize - iDownloadedContentSize;

		if (incr<=0) incr=0; //Protection

		progressInfo->IncrementAndDraw(incr);

		iDownloadedContentSize = downloadedsize;

		}

	FLOG(_L("CFotaDownload::HandleDMgrEventL() >>   DLstate:%d  ProgressSt:%d\

	globErr: %d DLError: %d (%d/%d)"),aEvent.iDownloadState

	,aEvent.iProgressState,sysErrorId,dlErrorId,downloadedsize,contentsize );

	if ( sysErrorId <= -25000)  { FLOG(_L("  error %d interpreted as http \

	error %d") , sysErrorId, sysErrorId + 25000 ); }

	switch ( aEvent.iDownloadState )

	{

	case EHttpDlCreated:		// 1

		{

		FLOG(_L("Download State: EHttpDlCreated"));

		}

		break;

	case EHttpDlInprogress:     // 2

		{

		FLOG(_L("Download State: EHttpDlProgress"));

		if (aEvent.iProgressState == EHttpProgCodDescriptorDownloaded)

			{

			if (iShowOMACDUI || iShowDLPrgUI)

				{

				iFotaServer->iParentApp->SetUIVisibleL ( ETrue, EFalse);

				}

			}

		// Is ECodLoadEnd optimized out?

		if ( aEvent.iProgressState == EHttpProgCodLoadEnd ) // 2503

			{

			TInt    err;

			err = aDownload->Start();  // PPAR-6FRHFY fixed

			if(err)

				{

				FLOG(_L(" ERROR when restarting DL %d"),err);

				User::Leave(err);

				}

			FLOG( _L("          DL restarted") );

			}

		// Should tell user to free disk space. But how do we know that disk space is about be exceeded?

		if ( iDLNeedsReset )

			{

			FLOG(_L("aDownload->Reset();"));

			iDLNeedsReset = EFalse;

			iStatus = KRequestPending;

			SetActive();

			TRequestStatus* status = &iStatus;

			User::RequestComplete( status, KErrNone );

			User::LeaveIfError( aDownload->Reset() );

			}

		// Body data of descriptor or payload pkg

		if ( aEvent.iProgressState == EHttpProgResponseBodyReceived && iDLProgress==EDescriptorDownloaded/*2500*/)

			{

			// Now pkg size can be retrieved. must check size.

			iDLState.iPkgSize = contentsize;

			FLOG(_L("Setting PkgSize=%d in FotaState"),contentsize);

			iFotaServer->iDatabase->OpenDBL();

			iFotaServer->iDatabase->SetStateL(iDLState,KNullDesC8, EFDBPkgSize );

			iFotaServer->iDatabase->CloseAndCommitDB();

			TInt contentsize2 = contentsize;

			TInt dlsize (KErrNone);

			TInt tlsize (KErrNone);

			TRAPD(err, iFotaServer->GetDownloadUpdatePackageSizeL(iDLState.iPkgId, dlsize,tlsize));

			if(err); // remove compiler warning

			contentsize2 -= dlsize;

			FLOG(_L("check pkg size = %d"),contentsize2 );

			CFotaStorage::TFreeSpace avail = iFotaServer->StoragePluginL()->IsPackageStoreSizeAvailableL(contentsize2);

			iDLProgress = ESizeChecked;

			if ( avail==CFotaStorage::EDoesntFitToFileSystem )

				{

				FLOG(_L("CFotaStorage::EDoesntFitToFileSystem"));

				if (iFreshDL)