--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/fotaapplication/fotaserver/FotaServer/src/fotadownload.cpp Wed Sep 01 12:27:42 2010 +0100
@@ -0,0 +1,1979 @@
+/*
+* 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 <NSmlDMSync.rsg> //OMA DM UI for reading resource
+#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
+#include <uri8.h>
+#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 KErrNone;
+ }
+
+
+// --------------------------------------------------------------------------
+// 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();
+
+ 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);
+
+
+ if ( iDLState.iIapId > KErrNotFound )
+ {
+ iFotaServer->iDatabase->OpenDBL();
+ iFotaServer->iDatabase->SetStateL(iDLState,KNullDesC8, EFDBIapId );
+ iFotaServer->iDatabase->CloseAndCommitDB();
+ }
+
+ /*
+ TBuf8<100> test;
+ //_LIT8( KNSmlDMFotaNode,"http://2IND02230.noe.nokia.com8080/myspace/ddv1.dd" );
+ _LIT8( KNSmlDMFotaNode,"http://fdsqa.nokia.com/fdp/interface?fid=A0A19HMCUHWRU" );
+ test.Copy(KNSmlDMFotaNode);
+
+
+ TUriParser8 parser;
+
+ if (!parser.Parse(test) && !parser.IsSchemeValid()) */
+
+ TUriParser8 parser;
+
+
+
+ if((parser.Parse(aPkgURL) == KErrNone) && !parser.IsSchemeValid() )
+
+ {
+ FLOG(_L("URL is malformed.. finalizing download"));
+ iDLState.iResult = RFotaEngineSession::EResMalformedOrBadURL;
+ iDLState.iState = RFotaEngineSession::EDownloadFailed;
+ iFotaServer->iDatabase->OpenDBL();
+ iFotaServer->iDatabase->SetStateL(iDLState, KNullDesC8, EFDBState | EFDBResult);
+ iFotaServer->iDatabase->CloseAndCommitDB();
+ iFotaServer->FinalizeDownloadL(iDLState);
+ LaunchNotifierL(ESyncMLFwUpdErrorNote, KErrGeneralNoResume, EFalse );
+ return;
+ }
+ iUpdateAfterDownload = aUpdateAfterDownload;
+
+ // 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(KFotaServerUid), 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)
+ {
+ if ( iShowDLPrgUI )
+ {
+ FLOG(_L("iDLNeedsReset = ETrue;"));
+ iDLNeedsReset = ETrue;
+ LaunchNotifierL( ESyncMLFwUpdOmaDLNotEnoughMemory, KErrDiskFull,contentsize2 );
+ }
+ else
+ {
+ iDLState.iResult = RFotaEngineSession::EResDLFailDueToDeviceOOM;
+ iDLState.iState = RFotaEngineSession::EDownloadFailed;
+ iUpdateAfterDownload = EFalse;
+ LaunchNotifierL( ESyncMLFwUpdErrorNote, KErrGeneral, contentsize2,ETrue );
+ }
+ }
+ else //resuming download
+ {
+ FLOG(_L("Memory need in order to resume. Notify user..."));
+ LaunchNotifierL( ESyncMLFwUpdOmaDLNotEnoughMemory, KErrDiskFull,contentsize2 );
+ RunDownloadSuspendL(RFotaEngineSession::EResDLFailDueToDeviceOOM);
+ }
+
+ }
+ }
+
+ // OMA DD download completed , must hide progress
+ if ( aEvent.iProgressState == EHttpProgContentTypeChanged ) // 2055
+ {
+ if ( iDLProgressDlg )
+ {
+ iDLProgressDlg->ProcessFinishedL(); // deletes itself
+ delete iDLProgressDlg;
+ iDLProgressDlg = NULL;
+ }
+ }
+ // OMA DD accepted,show progress
+ if ( aEvent.iProgressState == EHttpProgCodDescriptorAccepted ) // 2502
+
+ {
+ iDLProgress = EDescriptorDownloaded;
+ if ( iShowDLPrgUI )
+ {
+ FLOG(_L("SHOW PROGRESS"));
+ if ( iDLProgressDlg )
+ {
+ FLOG(_L("Removing Connecting progress note..."));
+ iDLProgressDlg->ProcessFinishedL();
+ delete iDLProgressDlg;
+ iDLProgressDlg = NULL;
+ }
+ if (!iDLProgressDlg)
+ {
+
+ FLOG(_L("Creating iDLProgressDlg"));
+ iDLProgressDlg = new(ELeave) CFotaDLProgressDlg((CEikDialog** ) &iDLProgressDlg , EFalse, this, EDownloadingNote );
+ iDLProgressDlg->PrepareLC( R_FOTASERVER_DL_PROGRESS_DIALOG );
+ iDLProgressDlg->RunLD();
+ }
+ CEikProgressInfo* progressInfo = iDLProgressDlg->GetProgressInfoL();
+ progressInfo->SetFinalValue( 500 );
+ iPreviousContentSize = -1;
+ iDownloadedContentSize = 0;
+ iFotaServer->iParentApp->SetUIVisibleL ( ETrue , EFalse );
+ }
+ if (iDownloadResumable)
+ {
+ FLOG(_L("Setting download as resumable"));
+ iDLState.iState = RFotaEngineSession::EDownloadProgressingWithResume;
+ iFotaServer->SetStartupReason(EFotaDownloadInterrupted);
+ }
+ else
+ {
+ FLOG(_L("Setting download as non resumable"));
+ iDLState.iState = RFotaEngineSession::EDownloadProgressing;
+ iFotaServer->SetStartupReason(EFotaPendingGenAlert);
+ }
+ iFotaServer->iDatabase->OpenDBL();
+ iFotaServer->iDatabase->SetStateL(iDLState,KNullDesC8, EFDBState );
+ iFotaServer->iDatabase->CloseAndCommitDB();
+
+
+ if (iDLState.iIapId <= 0) //Read the IAP ID when not known, and set it into db.
+ {
+ TInt32 usedapid (KErrNotFound);
+ TInt er = iDownloadMgr.GetIntAttribute( EDlMgrIap, usedapid);
+ iDLState.iIapId = usedapid;
+ FLOG(_L("Setting IAPID=%d is FotaState"),iDLState.iIapId);
+ iFotaServer->iDatabase->OpenDBL();
+ iFotaServer->iDatabase->SetStateL(iDLState,KNullDesC8, EFDBIapId );
+ iFotaServer->iDatabase->CloseAndCommitDB();
+ }
+ }
+ }
+ break;
+ case EHttpDlCompleted: // 4
+ {
+ FLOG(_L("Download State: EHttpDlCompleted"));
+
+ iRestartCounter = -1;
+ if ( iDLProgressDlg )
+ {
+ iDLProgressDlg->ProcessFinishedL(); // deletes itself
+ delete iDLProgressDlg;
+ iDLProgressDlg = NULL;
+ }
+ iDLState.iState = RFotaEngineSession::EDownloadComplete;
+
+ if (iUpdateAfterDownload)
+ iDLState.iResult = KErrNotFound;
+ else
+ iDLState.iResult = RFotaEngineSession::EResSuccessful;
+ iFotaServer->FinalizeDownloadL( iDLState );
+ }
+ break;
+ case EHttpDlPaused: //Event thrown for any resumable download
+ case EHttpDlFailed: //Event thrown for any non-resumable download or critical error on resumable download
+ {
+
+ if (aEvent.iProgressState != EHttpProgNone) //Accepting only events from COD
+ return;
+
+ if (aEvent.iDownloadState == EHttpDlPaused)
+ {
+ FLOG(_L("Download State: EHttpDlPaused"));
+ if (iDownloadResumable)
+ {
+ iDLState.iState = RFotaEngineSession::EDownloadProgressingWithResume;
+ }
+ else
+ {
+ // iDownloadResumable remains 0 even for resumable download.
+ iDLState.iState = RFotaEngineSession::EDownloadFailed;
+ }
+ }
+ else //aEvent.iDownloadState = EHttpDlFailed
+ {
+ FLOG(_L("Download State: EHttpDlFailed"));
+ iDLState.iState = RFotaEngineSession::EDownloadFailed;
+ iDownloadResumable = EFalse;
+ }
+ //Remove the download progress bar
+ if ( iDLProgressDlg && (iDLState.iResult != RFotaEngineSession::EResUserCancelled ))
+ {
+ FLOG(_L("Shd not come in EResUserCancelled"));
+ iDLProgressDlg->ProcessFinishedL(); // deletes itself
+ delete iDLProgressDlg;
+ iDLProgressDlg = NULL;
+ }
+ // This is restarted download => decrement counter
+ if ( iRestartCounter > 0 )
+ {
+ --iRestartCounter;
+ if ( iRestartCounter <=0 ) iRestartCounter = -1;
+ FLOG(_L(" iRestartCounter to %d"),iRestartCounter );
+ }
+ /*****************************/
+ //Handling all errors now...//
+ /****************************/
+ TInt notifType (KErrNotFound);
+ TInt notifParam (KErrNotFound);
+ //Handling User Cancel of Download Descriptor
+ if ( dlErrorId == EGeneral && (sysErrorId == KErrAbort || sysErrorId == KErrCancel ))
+ {
+ FLOG(_L("Reason: User cancelled download descriptor"));
+ //LaunchNotifierL(ESyncMLFwUpdOmaDLCancelled, EFalse, EFalse);
+ iRestartCounter = -1;
+ iDLState.iResult = RFotaEngineSession::EResUserCancelled;
+ notifType = ESyncMLFwUpdOmaDLCancelled;
+ notifParam = KErrNone;
+ }
+ //Handling User Cancel
+ else if ( iDLState.iResult == RFotaEngineSession::EResUserCancelled ) //This variable is set in RunDownloadCancelL or RunDownloadSuspendL
+ {
+ iRestartCounter = -1;
+ //If initial pause is successful, query user if he wants to postpone or cancel permanently.
+ iFotaServer->iDatabase->OpenDBL();
+ iFotaServer->iDatabase->SetStateL(iDLState,KNullDesC8, EFDBState);
+ iFotaServer->iDatabase->CloseAndCommitDB();
+
+ if (iDownloadResumable)
+ {
+ if (!iSilentOpn)
+ {
+ FLOG(_L("Download has been paused successful. Query user if he wants to postpone or cancel permanently"));
+ LaunchNotifierL(ESyncMLFwUpdOmaDLUserCancel, KErrNone, KErrNone);
+ break;
+ }
+ else
+ {
+ notifType = ESyncMLFwUpdOmaDLPostponed;
+ notifParam = KErrNone;
+ }
+ }
+ else
+ {
+ FLOG(_L("Error while initial pausing...%d Hence download has to be cancelled permanently!"));
+ RunDownloadCancelL(RFotaEngineSession::EResUserCancelled);
+ notifType = ESyncMLFwUpdOmaDLCancelled;
+ notifParam = KErrNone;
+ }
+ }
+ else if ( iDLState.iResult == RFotaEngineSession::EResDLFailDueToDeviceOOM )
+ {
+ FLOG(_L("Reason: Not enough memory to perform resume"));
+ iRestartCounter = -1;
+
+ if (iDownloadResumable)
+ iDLState.iState = RFotaEngineSession::EDownloadProgressingWithResume;
+ else
+ iDLState.iState = RFotaEngineSession::EDownloadFailed;
+ }
+ //Handling user cancel IAP selection popup
+ else if ( dlErrorId == EConnectionFailed && sysErrorId == KErrCancel)
+ {
+ FLOG(_L("Reason: User canceled IAP selection popup"));
+ iDLState.iResult = RFotaEngineSession::EResUserCancelled;
+ iRestartCounter = -1;
+
+ notifType = ESyncMLFwUpdOmaDLPostponed;
+ notifParam = KErrNone;
+ }
+ //Handling temproary network timeout. This may either try resume or restart based on download.
+/* else if ( dlErrorId == EGeneral && sysErrorId == KErrTimedOut )
+ {
+ FLOG(_L("Reason: Network timeout"));
+ // No restart issued yet, this is 1st download attempt
+ if ( iRestartCounter == 0 )
+ {
+ iRestartCounter = KFotaDownloadTimeoutRestartCount;
+ iDLState.iState = RFotaEngineSession::EIdle;
+ FLOG(_L("Trying to restart download (iRestartCounter=%d)"),iRestartCounter );
+ }
+
+ }*/
+ //Handling all Network interrupts
+ else if ( (dlErrorId == EConnectionFailed && sysErrorId == KErrCommsLineFail)||
+ dlErrorId == ETransactionFailed ||
+ (dlErrorId == KErrCodWapConnectionDropped && sysErrorId == KErrGeneral) ||
+ (dlErrorId == EGeneral && sysErrorId == KErrTimedOut) ||
+ (dlErrorId == EConnectionFailed && sysErrorId == KErrGprsServicesNotAllowed ) ||
+ (dlErrorId == EConnectionFailed && sysErrorId == KErrGsmMMNetworkFailure ) ||
+ (dlErrorId == EConnectionFailed && sysErrorId == KErrWlanNetworkNotFound )
+ )
+ {
+ FLOG(_L("Reason: Network breakage"));
+ iRestartCounter = -1;
+ notifType = ESyncMLFwUpdErrorNote;
+ if (iDownloadResumable)
+ {
+ notifParam = KErrCommsLineFail2;
+ iDLState.iState = RFotaEngineSession::EDownloadProgressingWithResume;
+ iDLState.iResult = RFotaEngineSession::EResDLFailDueToNWIssues;
+ }
+ else
+ {
+ notifParam = KErrCommsLineFail;
+ iDLState.iState = RFotaEngineSession::EDownloadFailed;
+ iDLState.iResult = RFotaEngineSession::EResDLFailDueToNWIssues;
+ }
+ }
+ //Handling Out Of Memory interrupt
+ else if ((dlErrorId == EGeneral && sysErrorId == KErrDiskFull ) || sysErrorId == KErrCodInsufficientSpace)
+ {
+ FLOG(_L("Reason: Disk full"));
+ iRestartCounter = -1;
+ notifType = KErrNotFound;
+ notifParam = KErrNotFound; // don't show anything
+ iDLState.iResult = RFotaEngineSession::EResDLFailDueToDeviceOOM;
+ }
+ //Handle unclassified (general) interrupts
+ else
+ {
+ iRestartCounter = -1;
+
+
+ RProperty prop;
+ TInt val = KErrNone;
+
+ TInt err = prop.Get(KPSUidStartup, KPSGlobalSystemState, val);
+ if (err==KErrNone && val!=ESwStateShuttingDown)
+ {
+ notifType = ESyncMLFwUpdErrorNote;
+ }
+ else
+ {
+ FLOG(_L("Phone is powering down..."));
+ }
+
+ if (iDownloadResumable)
+ {
+ notifParam = KErrGeneralResume;
+ iDLState.iState = RFotaEngineSession::EDownloadProgressingWithResume;
+ }
+ else
+ {
+ notifParam = KErrGeneralNoResume;
+ iDLState.iState = RFotaEngineSession::EDownloadFailed;
+ }
+
+
+ SetDLResultdlErrorId(dlErrorId ,sysErrorId );
+
+
+ }
+ if ( iRestartCounter <= 0)
+ {
+ iUpdateAfterDownload = EFalse;
+ SetDownloadActive(EFalse);
+ if ( iDLState.iSessionType!= ESanSilent && notifType!=KErrNotFound )
+ {
+ if ( iShowDLPrgUI )
+ LaunchNotifierL( (TSyncMLFwUpdNoteTypes)notifType, notifParam,0 );
+ else
+ LaunchNotifierL( (TSyncMLFwUpdNoteTypes)notifType, notifParam,0, ETrue);
+ }
+ FLOG(_L("Should come here for nonpausable "));
+ iDownloadFinalized = ETrue;
+ iFotaServer->FinalizeDownloadL( iDLState );
+ }
+ else
+ {
+ if (iDownloadResumable)
+ {
+ FLOG(_L("Resuming download..."));
+ iDownload->Start();
+ }
+ else
+ {
+ FLOG(_L("Restarting download..."));
+ iFotaServer->FinalizeDownloadL( iDLState );
+ }
+ }
+ }
+ break;
+
+ case EHttpDlPausable:
+ {
+ FLOG(_L("Download State: EHttpDlPausable"));
+ if (iDownloadResumable) //This is initially set by IsDownloadSuspendResumeSupported()
+ {
+ FLOG(_L("Download Suspend/Resume is supported!"));
+ }
+ else
+ {
+ FLOG(_L("Download Server support Suspend/Resume, but Fota doesn't!"));
+ //retain the state iDownloadResumable = EOmaDLResumeNotSupported;
+ }
+ }
+ break;
+
+ case EHttpDlNonPausable:
+ {
+ FLOG(_L("Download State: EHttpDlNonPausable"));
+ if (iDownloadResumable) //This is initially set by CheckDownloadVariations()
+ {
+ FLOG(_L("Download Server doesn't support Suspend/Resume, but Fota does!"));
+ //Reset the state to not supported.
+ iDownloadResumable = EFalse;
+ }
+ else
+ {
+ FLOG(_L("Download Server doesn't support Suspend/Resume, neither does Fota!"));
+ }
+ }
+ break;
+ case EHttpDlDeleting: //13
+ {
+ FLOG(_L("Download State: EHttpDlDeleting"));
+ }
+ break;
+ case EHttpDlDeleted: //11
+ {
+ FLOG(_L("Download State: EHttpDlDeleted"));
+ }
+ break;
+ default:
+ {
+ FLOG(_L("Default. No action performed for this Download State"));
+ }
+ break;
+ }
+ FLOG(_L("CFotaDownload::HandleDMgrEventL() <<"));
+ }
+
+
+
+// --------------------------------------------------------------------------
+// CFotaDownload::SetDLResultdlErrorId
+// Sets the appropriate error
+// --------------------------------------------------------------------------
+//
+
+void CFotaDownload::SetDLResultdlErrorId( THttpDownloadMgrError adlErrorId, TInt32 asysErrorId)
+{
+ if ( adlErrorId == EInternal)
+ {
+ FLOG(_L("Reason: error EInternal"));
+ iDLState.iResult = RFotaEngineSession::EResUndefinedError;
+ }
+ else if ( adlErrorId == EContentFileIntegrity)
+ {
+ FLOG(_L("Reason: error EContentFileIntegrity"));
+ iDLState.iResult = RFotaEngineSession::EResUndefinedError;
+ }
+ else if ( adlErrorId == EMMCRemoved)
+ {
+ FLOG(_L("Reason: error EMMCRemoved,"));
+ iDLState.iResult = RFotaEngineSession::EResUndefinedError;
+ }
+ else if ( adlErrorId == EBadUrl)
+ {
+ FLOG(_L("Reason: error EBadUrl"));
+ iDLState.iResult = RFotaEngineSession::EResMalformedOrBadURL;
+ }
+ else if ( adlErrorId == EHttpUnhandled)
+ {
+ FLOG(_L("Reason: error EHttpUnhandled, check global error id!"));
+ iDLState.iResult = RFotaEngineSession::EResUndefinedError;
+ }
+ else if ( adlErrorId == EHttpAuthenticationFailed)
+ {
+ FLOG(_L("Reason: error EHttpAuthenticationFailed"));
+ iDLState.iResult = RFotaEngineSession::EResUndefinedError;
+ }
+ else if ( adlErrorId == EObjectNotFound)
+ {
+ FLOG(_L("Reason: error EObjectNotFound"));
+ iDLState.iResult = RFotaEngineSession::EResAlternateDLServerUnavailable;
+ }
+ else if ( adlErrorId == EPartialContentModified)
+ {
+ FLOG(_L("Reason: error EPartialContentModified"));
+ iDLState.iResult = RFotaEngineSession::EResUndefinedError;
+ }
+ else if ( adlErrorId == EContentExpired)
+ {
+ FLOG(_L("Reason: error EContentExpired"));
+ iDLState.iResult = RFotaEngineSession::EResUndefinedError;
+ }
+ else if ( adlErrorId == EHttpRestartFailed)
+ {
+ FLOG(_L("Reason: error EHttpRestartFailed"));
+ iDLState.iResult = RFotaEngineSession::EResUndefinedError;
+ }
+ else if ( asysErrorId == KErrCodInvalidDescriptor )
+ {
+ FLOG(_L("Reason: error KErrCodInvalidDescriptor"));
+ iDLState.iResult = RFotaEngineSession::EResMalformedOrBadURL;
+ }
+ else
+ {
+ FLOG(_L("Reason: unknown, check dlError!"));
+ iDLState.iResult = RFotaEngineSession::EResUndefinedError;
+ }
+
+}
+
+// --------------------------------------------------------------------------
+// CFotaDownload::HandleDMgrEventL
+// --------------------------------------------------------------------------
+//
+void CFotaDownload::HandleDMgrEventL( RHttpDownload& aDownload
+ , THttpDownloadEvent aEvent )
+ {
+ DoHandleDMgrEventL(&aDownload,aEvent);
+ }
+
+
+// --------------------------------------------------------------------------
+// CFotaDownload::LaunchNotifierL
+// Launches notifier. This method is also used to finalize erronous DL
+// --------------------------------------------------------------------------
+//
+void CFotaDownload::LaunchNotifierL( const TSyncMLFwUpdNoteTypes aNotetype
+ ,const TInt aIntParam
+ ,const TInt aMemoryNeeded
+ ,TBool aFinishOnly )
+ {
+ if ( iNotifHandler ) iNotifHandler->Cancel();
+ else iNotifHandler = CFotaDownloadNotifHandler::NewL(this);
+ iNotifHandler->LaunchNotifierL( aNotetype,aIntParam,aMemoryNeeded
+ ,aFinishOnly );
+ }
+
+// --------------------------------------------------------------------------
+// CFotaDownload::CheckDownloadVariations
+// Reads download variations - fota suspend & resume bahavior & FMS from cenrep keys
+// --------------------------------------------------------------------------
+//
+void CFotaDownload::CheckDownloadVariations()
+ {
+ FLOG(_L("CFotaDownload::CheckDownloadVariations >>"));
+
+ CRepository* centrep( NULL);
+ TRAPD(err, centrep = CRepository::NewL( KCRUidFotaServer ) );
+ if (err) FLOG(_L("Error reading FotaServer cenrep... %d"),err);
+ TInt supported(KErrNone);
+ if (centrep )
+ {
+ err = centrep->Get( KSuspendResumeFeatureSupported, supported );
+ if (err) FLOG(_L("Error reading cenrep key... %d"),err);
+ iDownloadResumable = (supported==1)? ETrue:EFalse;
+
+ supported = KErrNone;
+ centrep->Get( KFotaMonitoryServiceEnabled, supported );
+ if (err) FLOG(_L("Error reading cenrep key... %d"),err);
+ iFMSEnabled = (supported > 0)? ETrue:EFalse;
+
+ delete centrep;
+ centrep = NULL;
+ }
+
+ FLOG(_L("Susp&Resume feature supported = %d, FMS feature supported = %d"),iDownloadResumable,iFMSEnabled);
+ FLOG(_L("CFotaDownload::CheckDownloadVariations <<"));
+ }
+
+// --------------------------------------------------------------------------
+// CFotaDownload::RunDownloadCancelL
+// Starts to cancel the download operation
+// --------------------------------------------------------------------------
+//
+void CFotaDownload::RunDownloadCancelL(const TInt aReason, TBool aSilent)
+ {
+ FLOG(_L("CFotaDownload::RunDownloadCancelL, reason = %d, silent = %d >>"), aReason, aSilent);
+
+ iDLState.iState = RFotaEngineSession::EDownloadFailed;
+ iDLState.iResult = aReason;
+ iSilentOpn = aSilent;
+
+ iRestartCounter = -1;
+ iUpdateAfterDownload = EFalse;
+
+ if (!iDownload)
+ {
+ //iDownload is null when user cancels the download permanently when prompted to resume.
+ //hence retrieve the download object first
+ iDownload = RetrieveDownloadL();
+ }
+ TInt err = iDownload->Delete(); //or Cancel or Reset?
+ FLOG(_L("Error = %d"),err);
+
+ if(iDownloadFinalized == EFalse)
+ {
+ iFotaServer->FinalizeDownloadL( iDLState );
+ FLOG(_L("Should not come here fro nopausable "));
+ if (aReason == RFotaEngineSession::EResUserCancelled)
+ LaunchNotifierL(ESyncMLFwUpdOmaDLCancelled, EFalse, EFalse);
+ else if (aReason == RFotaEngineSession::EResUndefinedError)
+ LaunchNotifierL(ESyncMLFwUpdErrorNote, KErrGeneralNoResume, EFalse );
+ }
+ FLOG(_L("CFotaDownload::RunDownloadCancelL <<"));
+ }
+
+// --------------------------------------------------------------------------
+// CFotaDownload::RunDownloadSuspendL
+// Starts to suspend the download operation
+// --------------------------------------------------------------------------
+//
+void CFotaDownload::RunDownloadSuspendL(const TInt aReason, TBool aSilent)
+ {
+ FLOG(_L("CFotaDownload::RunDownloadSuspendL, reason = %d, silent = %d >>"), aReason, aSilent);
+
+ iDLState.iState = RFotaEngineSession::EDownloadProgressingWithResume;
+ iDLState.iResult = aReason;
+ iSilentOpn = aSilent;
+ //First pause download, and later ask for user action.
+ TInt err = iDownload->Pause();
+
+ if (err)
+ {
+ //initial pausing becomes a problem.
+ FLOG(_L("Error while initial pausing...%d Hence download has to be cancelled permanently!"),err);
+ RunDownloadCancelL(aReason);
+ }
+
+ FLOG(_L("CFotaDownload::RunDownloadSuspendL <<"));
+ }
+
+// --------------------------------------------------------------------------
+// CFotaDownload::TryResumeDownloadL
+// Tries to resume the download operation
+// --------------------------------------------------------------------------
+//
+void CFotaDownload::TryResumeDownloadL(TBool aUserInitiated)
+ {
+ FLOG(_L("CFotaDownload::TryResumeDownloadL >>"));
+
+ iUserInitiatedResume = aUserInitiated;
+ 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);
+ }
+ //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);
+
+ //Called to read the download variations in Fota (resume support & FMS)
+ CheckDownloadVariations();
+ if (IsFMSEnabled() && iUserInitiatedResume)
+ iFotaServer->CancelFmsL();
+
+ //Query based on the type of DM session used earlier.
+ if (iUserInitiatedResume || iDLState.iSessionType != ESanSilent)
+ {
+ //Query user for resume
+ FLOG(_L("Quering user for resume..."));
+ if (iFotaServer->iNotifHandler)
+ {
+ iFotaServer->iNotifHandler->Cancel();
+ delete iFotaServer->iNotifHandler;
+ iFotaServer->iNotifHandler = NULL;
+ }
+ iNotifHandler = CFotaDownloadNotifHandler::NewL(this);
+
+ iNotifHandler->LaunchNotifierL(ESyncMLFwUpdOmaDLResume, EFalse, EFalse);
+ }
+ else //Only FMS initiated Silent Session download
+ {
+ //Resume directly
+ FLOG(_L("Resuming automatically..."));
+ ResumeDownloadL();
+ }
+ FLOG(_L("CFotaDownload::TryResumeDownloadL <<"));
+ }
+
+// --------------------------------------------------------------------------
+// CFotaDownload::ResumeDownloadL
+// Resume the download operation
+// --------------------------------------------------------------------------
+//
+void CFotaDownload::ResumeDownloadL()
+ {
+ FLOG(_L("CFotaDownload::ResumeDownloadL >>"));
+ TBool toresetdl (EFalse);
+ TBool downloadiapvalid (ETrue);
+ //Find the download ui behavior from fota cenrep
+ TInt behavior(KErrNotFound);
+ CRepository* centrep = NULL;
+ TRAPD(err, centrep = CRepository::NewL( KCRUidFotaServer ) );
+ if (( centrep ) && ( err == KErrNone))
+ {
+ centrep->Get( KSilentOmaDlUIBehavior, behavior );
+ delete centrep;
+ }
+ centrep = NULL;
+
+ if (iUserInitiatedResume ||
+ (behavior == EOmacdOffdlprgOn || behavior == EOmacdOndlprgOn))
+ {
+ FLOG(_L("Showing Connecting progress note..."));
+ iFotaServer->iParentApp->SetUIVisibleL ( ETrue , EFalse );
+
+ if ( !iDLProgressDlg )
+ {
+ iDLProgressDlg = new(ELeave) CFotaDLProgressDlg((CEikDialog** ) &iDLProgressDlg , EFalse, this, EConnectingNote );
+ iDLProgressDlg->PrepareLC( R_CONNECTION_NOTE );
+ }
+ // Load the resource files
+ TInt err = KErrNone;
+
+ // Localize the file name, and load the SCP resources
+ TFileName resFile;
+ resFile.Copy( KDriveZ );
+ resFile.Append( KSCPResourceFilename );
+
+ BaflUtils::NearestLanguageFile( CCoeEnv::Static()->FsSession(), resFile );
+
+ TInt Res1(KErrNone);
+ TRAP( err, Res1 =CCoeEnv::Static()->AddResourceFileL( resFile ) );
+
+ HBufC* buf = StringLoader::LoadLC(R_SYNCSTATUS_SYNC_CONN);
+
+ if( Res1 )
+ {
+ iFotaServer->GetEikEnv()->DeleteResourceFile( Res1 );
+ }
+ FLOG(_L("Reading txt as: %S"), &buf->Des());
+ iDLProgressDlg->SetTextL(buf->Des());
+ CleanupStack::PopAndDestroy(buf);
+
+ iDLProgressDlg->RunLD();
+ }
+ FLOG(_L("CFotaDownload::ResumeDownloadL, Stage 1"));
+
+ iDownload = RetrieveDownloadL();
+ if (iDownload)
+ {
+ FLOG(_L("CFotaDownload::ResumeDownloadL, Stage 2: Successfully retrieved download object >>"));
+
+ SetIapToUseL(iDLState, iDLState.iIapId);
+
+ FLOG(_L("CFotaDownload::ResumeDownloadL, Stage 3: Using iapid %d for resume..."), iDLState.iIapId);
+ downloadiapvalid = iFotaServer->CheckIapExistsL(iDLState.iIapId);
+ if (iDLState.iIapId > 0 && downloadiapvalid)
+ {
+ if (!iMonitor)
+ {
+ iMonitor = CFotaNetworkRegStatus::NewL (iFotaServer);
+ }
+ TBool val = iMonitor->IsConnectionPossibleL(iDLState.iIapId);
+ FLOG(_L("CFotaDownload::ResumeDownloadL, Stage 4"));
+ delete iMonitor; iMonitor = NULL;
+
+#if defined(__WINS__)
+ val =ETrue;
+#endif
+ if (!val)
+ {
+ FLOG(_L("CFotaDownload::ResumeDownloadL, Stage 5.1: Disallowing resume operation as connection not possible"));
+
+ if ( !iShowDLPrgUI && iDLProgressDlg )
+ {
+ FLOG(_L("Removing Connecting progress note..."));
+
+ iDLProgressDlg->ProcessFinishedL();
+ delete iDLProgressDlg;
+ iDLProgressDlg = NULL;
+ }
+ if (iUserInitiatedResume || iDLState.iSessionType!=ESanSilent)
+ LaunchNotifierL(ESyncMLFwUpdErrorNote, KErrCommsLineFail2,0);
+ iDLState.iState = RFotaEngineSession::EDownloadProgressingWithResume;
+ iDLState.iResult = RFotaEngineSession::EResDLFailDueToNWIssues;
+ iUpdateAfterDownload = EFalse;
+ iFotaServer->FinalizeDownloadL(iDLState);
+ return;
+ }
+ }
+
+ if (iDLState.iIapId == KErrNotFound || !downloadiapvalid )
+ {
+ iDLState.iIapId = KErrNotFound;
+ User::LeaveIfError( iDownloadMgr.SetIntAttribute( EDlMgrIap, 0)); // Download mgr interprets 0 for Always Ask
+ }
+ else
+ User::LeaveIfError( iDownloadMgr.SetIntAttribute( EDlMgrIap, iDLState.iIapId)); // IAP id
+
+ FLOG(_L("CFotaDownload::ResumeDownloadL, Stage 5.2"));
+ SetDownloadUiBehavior(EFalse);
+
+ if ( !iShowDLPrgUI && iDLProgressDlg )
+ {
+ FLOG(_L("Removing Connecting progress note..."));
+
+ iDLProgressDlg->ProcessFinishedL();
+ delete iDLProgressDlg;
+ iDLProgressDlg = NULL;
+ }
+ TInt dlsize, tlsize;
+ FLOG(_L("CFotaDownload::ResumeDownloadL, Stage 6"));
+ iFotaServer->GetDownloadUpdatePackageSizeL(iDLState.iPkgId, dlsize,tlsize);
+ iDownloadedContentSize = dlsize; //for progress bar update only
+ iUpdateAfterDownload = iDLState.iUpdateLtr; //should update after reboot?
+ iRestartCounter = 0;
+
+ //Set right states in fota db
+ iDLState.iState = RFotaEngineSession::EDownloadProgressingWithResume;
+ iDLState.iResult = KErrNotFound;
+
+ iFotaServer->iDatabase->OpenDBL();
+ iFotaServer->iDatabase->SetStateL( iDLState, KNullDesC8, EFDBState|EFDBResult);
+ iFotaServer->iDatabase->CloseAndCommitDB();
+ iFreshDL = EFalse;
+ FLOG(_L("CFotaDownload::ResumeDownloadL, Stage 6: Starting to resume download now..."));
+ TInt err = iDownload->Start();
+ if (err == KErrNone)
+ {
+ //Set the P&S Key to active...
+ FLOG(_L("Resume operation is success!"));
+ SetDownloadActive(ETrue);
+ }
+ else
+ {
+ FLOG(_L("An error occured during resume, err = %d"),err);
+ toresetdl = ETrue;
+ }
+ }
+ else
+ {
+ FLOG(_L("Failed to get the paused download object"));
+ if ( iDLProgressDlg )
+ {
+ FLOG(_L("Removing Connecting progress note..."));
+ iDLProgressDlg->ProcessFinishedL(); // deletes itself
+ delete iDLProgressDlg;
+ iDLProgressDlg = NULL;
+ }
+ toresetdl = ETrue;
+ }
+ ReSetDownloadL( toresetdl);
+
+ FLOG(_L("CFotaDownload::ResumeDownloadL <<"));
+ }
+// --------------------------------------------------------------------------
+// CFotaDownload::ReSetDownloadL
+// Sets the download state to failed
+// --------------------------------------------------------------------------
+//
+void CFotaDownload::ReSetDownloadL(TBool atoresetdl)
+{
+if (atoresetdl)
+ {
+ FLOG(_L("Resetting fota download !!!"));
+ if (iUserInitiatedResume || iDLState.iSessionType!=ESanSilent)
+ LaunchNotifierL(ESyncMLFwUpdErrorNote, KErrGeneralNoResume,0);
+ iDLState.iState = RFotaEngineSession::EDownloadFailed;
+ iDLState.iResult = RFotaEngineSession::EResUndefinedError;
+ iUpdateAfterDownload = EFalse;
+ iFotaServer->FinalizeDownloadL(iDLState);
+ }
+}
+
+
+
+// --------------------------------------------------------------------------
+// CFotaDownload::IsFMSEnabled
+// Returns FMS enabled state
+// --------------------------------------------------------------------------
+//
+TBool CFotaDownload::IsFMSEnabled()
+ {
+ FLOG(_L("CFotaDownload::IsFMSEnabled, iFMSEnabled = %d <<"), iFMSEnabled);
+ return iFMSEnabled;
+ }
+
+// --------------------------------------------------------------------------
+// CFotaDownload::IsDownloadResumable
+// Returns whether the download is resumable or not.
+// --------------------------------------------------------------------------
+//
+TBool CFotaDownload::IsDownloadResumable()
+ {
+ FLOG(_L("CFotaDownload::IsDownloadResumable, iDownloadResumable = %d <<"), iDownloadResumable);
+ return iDownloadResumable;
+ }
+
+// --------------------------------------------------------------------------
+// CFotaDownload::SetIapToUseL
+// Sets the IAP ID to use. This menthod is used in fresh and resume download.
+// --------------------------------------------------------------------------
+//
+void CFotaDownload::SetIapToUseL(TPackageState aParams, const TInt aIapid)
+ {
+ FLOG(_L("CFotaDownload::SetIapToUseL >>"));
+
+ RSyncMLSession sml;
+ TInt profIapid( KErrNotFound );
+ TInt sockIapid( KErrNotFound );
+ TSmlServerAlertedAction saa(ESmlConfirmSync);
+
+ CleanupClosePushL( sml );
+ sml.OpenL();
+ iFotaServer->GetProfileDataL(&sml,aParams.iProfileId, profIapid, saa
+ ,iIsjobStartedFromUI, iSanValue );
+ CleanupStack::PopAndDestroy( &sml );
+
+ // 2/3 GET IAP FROM ESOCK ----------------------------------------------
+ // resolve which accespoint is used for current DM session
+ if ( (profIapid == KErrNotFound || profIapid == KErrGeneral)
+ && aIapid==KErrNotFound)
+ {
+ RSocketServ serv;
+ CleanupClosePushL( serv );
+ User::LeaveIfError( serv.Connect() );
+
+ RConnection conn;
+ CleanupClosePushL( conn );
+ User::LeaveIfError( conn.Open( serv ) );
+
+ TUint count( 0 );
+ User::LeaveIfError( conn.EnumerateConnections ( count ) );
+ // enumerate connections
+ for( TUint idx=1; idx<=count; ++idx )
+ {
+ TConnectionInfo connectionInfo;
+ TConnectionInfoBuf connInfo( connectionInfo );
+
+ TInt err = conn.GetConnectionInfo( idx, connInfo ); // iapid
+ if( err != KErrNone )
+ {
+ CleanupStack::PopAndDestroy( 2 ); // conn, serv
+ User::Leave( err );
+ }
+ // enumerate connectionclients
+ TConnectionEnumArg conArg;
+ conArg.iIndex = idx;
+ TConnEnumArgBuf conArgBuf(conArg);
+ err=conn.Control(KCOLConnection,KCoEnumerateConnectionClients
+ ,conArgBuf);
+ if( err != KErrNone )
+ {
+ CleanupStack::PopAndDestroy( 2 ); // conn, serv
+ User::Leave( err );
+ }
+ TInt cliCount = conArgBuf().iCount;
+ for ( TUint j=1; j<=cliCount ;++j )
+ {
+ TConnectionGetClientInfoArg conCliInfo;
+ conCliInfo.iIndex = j;
+ TConnGetClientInfoArgBuf conCliInfoBuf(conCliInfo);
+ err=conn.Control(KCOLConnection, KCoGetConnectionClientInfo
+ , conCliInfoBuf);
+
+ if( err != KErrNone )
+ {
+ CleanupStack::PopAndDestroy( 2 ); // conn, serv
+ User::Leave( err );
+ }
+ TConnectionClientInfo conCliInf = conCliInfoBuf().iClientInfo;
+ TUid uid = conCliInf.iUid;
+ if ( uid == TUid::Uid(KSosServerUid) )
+ {
+ sockIapid = connInfo().iIapId;
+ FLOG(_L("[FotaServer] IAP found %x"),sockIapid);
+ }
+
+ FLOG(_L("[FotaServer] CFotaDownload::DownloadL uid %x")
+ ,uid.iUid);
+ }
+ }
+ CleanupStack::PopAndDestroy( 2 ); // conn, serv
+ }
+ TInt newIapid( KErrNotFound );
+ if ( sockIapid!=KErrNotFound ) newIapid = sockIapid;
+ if ( profIapid!=KErrNotFound && profIapid != KErrGeneral ) newIapid = profIapid;
+ if ( aIapid !=KErrNotFound ) newIapid = aIapid;
+
+ //Do some intelligent work during resume
+ /* Some rules..
+ * 1. If IAP is always ask in DM profile, use the earlier set during FMS trigger
+ * 2. If IAP is always ask in DM profile, query user for IAP during user trigger
+ * 3. If IAP has changed in DM profile after suspend, use the newer one during resume
+ * 4.
+ */
+ TInt active (KErrNotFound);
+ RProperty::Get(TUid::Uid(KFotaServerUid), KFotaDownloadActive, active );
+ FLOG(_L("active = %d"),active);
+ if (active==EFalse && iDLState.iState == RFotaEngineSession::EDownloadProgressingWithResume)
+ {
+ //Actual resume only
+ if (!iUserInitiatedResume && (profIapid == KErrNotFound || profIapid == KErrGeneral ) )
+ {
+ //FMS triggered resume, apply Rule 1
+ newIapid = iDLState.iIapId;
+ }
+ else if (profIapid == KErrNotFound || profIapid == KErrGeneral )
+ {
+ //User triggered resume, apply Rule 2
+ newIapid = KErrNotFound;
+ }
+ else if (profIapid != iDLState.iIapId && profIapid > KErrNone)
+ {
+ //IAP has changed in DM profile, apply Rule 3
+ newIapid = profIapid;
+ }
+ }
+ iDLState.iIapId = newIapid;
+
+
+ FLOG(_L("CFotaDownload::SetIapToUseL, iap = %d <<"), iDLState.iIapId);
+ }
+
+// --------------------------------------------------------------------------
+// CFotaDownload::SetDownloadUiBehavior
+// Sets Download UI behavior. ex: DD display and Progress note
+// --------------------------------------------------------------------------
+//
+void CFotaDownload::SetDownloadUiBehavior(TBool aFreshDL)
+ {
+ FLOG(_L("CFotaDownload::SetDownloadUiBehavior, aFreshDL = %d >>"),aFreshDL);
+
+ if (aFreshDL) //Fresh download
+ {
+ iDLState.iSessionType = iSanValue;
+ }
+ else //resuming download
+ {
+ iSanValue = iDLState.iSessionType;
+ }
+
+ if ( !iIsjobStartedFromUI && iRestartCounter==0 ) //iRestartCounter to ensure that the UI behavior is read only once.
+ {
+ TInt behavior(KErrNotFound);
+ TInt sansupported(KErrNone);
+
+ //Find whether SAN is supported or not
+ CRepository* centrep = NULL;
+
+ TRAPD( err, centrep = CRepository::NewL( KCRUidDeviceManagementInternalKeys) );
+ if( centrep ) centrep->Get( KDevManSANUIBitVariation, sansupported );
+ delete centrep; centrep = NULL;
+ FLOG(_L("...1..."));
+ if (sansupported != 1) sansupported = 0;
+
+ //Find the download ui behavior from fota cenrep
+ TRAP(err, centrep = CRepository::NewL( KCRUidFotaServer ) );
+ if ( centrep ) centrep->Get( KSilentOmaDlUIBehavior, behavior );
+ delete centrep; centrep = NULL;
+
+ FLOG(_L("Values are... SAN enabled: %d, session type: %d, downloadbehavior: %d"),sansupported, iDLState.iSessionType,behavior);
+
+ if (sansupported) //SAN is supported
+ {
+
+ DetermineUISANON(behavior) ;
+
+ }
+ else //SAN not supported
+ {
+ DetermineUISANOFF(behavior);
+
+ }
+ }
+ else// if (iRestartCounter==0) //Started from DM UI, but not retry
+ {
+ iShowOMACDUI = ETrue;
+ iShowDLPrgUI = ETrue;
+ if (aFreshDL)
+ iDLState.iSessionType = KErrNotFound;
+ }
+
+TInt value (EFotaUpdateDM);
+TInt err = RProperty::Get( KPSUidNSmlDMSyncApp, KNSmlCurrentFotaUpdateAppName, value );
+if (!err && ((value == EFotaUpdateNSC) || (value == EFotaUpdateNSCBg)))
+{
+ iShowOMACDUI = EFalse;
+ iShowDLPrgUI = ETrue;
+ FLOG(_L("CFotaDownload::DownloadL UI will not be shown!"));
+}
+ FLOG(_L("UI Behavior: OMA DD Display = %d, Download Progress = %d"),iShowOMACDUI,iShowDLPrgUI);
+
+ FLOG(_L("CFotaDownload::SetDownloadUiBehavior <<"));
+ }
+
+
+// --------------------------------------------------------------------------
+// CFotaDownload::DetermineUISANON
+// Determine UI when SAN is ON
+// --------------------------------------------------------------------------
+//
+void CFotaDownload::DetermineUISANON(TInt aBehavior)
+{
+ switch (aBehavior)
+ {
+ case EOmacdOffdlprgOff: //0
+ {
+ iShowOMACDUI = EFalse;
+ iShowDLPrgUI = EFalse;
+ }
+ break;
+ case EOmacdOffdlprgOn: //1
+ {
+ iShowOMACDUI = EFalse;
+ iShowDLPrgUI = ETrue;
+ }
+ break;
+ case EOmacdOndlprgOff: //2
+ {
+ iShowOMACDUI = ETrue;
+ iShowDLPrgUI = EFalse;
+ }
+ break;
+ case EOmacdOndlprgOn: //3
+ {
+ iShowOMACDUI = ETrue;
+ iShowDLPrgUI = ETrue;
+ }
+ break;
+ default: //includes EChooseFromSan
+ {
+ if(iSanValue == ESanSilent)
+ {
+ iShowOMACDUI = EFalse;
+ iShowDLPrgUI = EFalse;
+ }
+ else if (iSanValue == ESanInformative)
+ {
+ iShowOMACDUI = EFalse;
+ iShowDLPrgUI = ETrue;
+ }
+ else //includes ESanInteractive, ESanNotSpecified
+ {
+ iShowOMACDUI = ETrue;
+ iShowDLPrgUI = ETrue;
+ }
+ }
+ break;
+ }
+
+
+}
+
+// --------------------------------------------------------------------------
+// CFotaDownload::DetermineUISANOFF
+// Determine UI when SAN is OFF
+// --------------------------------------------------------------------------
+//
+
+void CFotaDownload::DetermineUISANOFF(TInt aBehavior)
+{
+ if (iSanValue==EAcceptedYes) //Accepted is Yes in Profile
+ {
+ switch (aBehavior)
+ {
+ case EOmacdOffdlprgOff: //0
+ {
+ iShowOMACDUI = EFalse;
+ iShowDLPrgUI = EFalse;
+ }
+ break;
+ case EOmacdOffdlprgOn: //1
+ {
+ iShowOMACDUI = EFalse;
+ iShowDLPrgUI = ETrue;
+ }
+ break;
+ case EOmacdOndlprgOff: //2
+ {
+ iShowOMACDUI = ETrue;
+ iShowDLPrgUI = EFalse;
+ }
+ break;
+ default: //includes EOmacdOndlprgOn
+ {
+ iShowOMACDUI = ETrue;
+ iShowDLPrgUI = ETrue;
+ }
+ break;
+ }
+ }
+ else // includes iSanValue = EAcceptedNo (Accepted is No in profile)
+ {
+ iShowOMACDUI = ETrue;
+ iShowDLPrgUI = ETrue;
+ }
+}
+
+
+
+
+
+
+
+// --------------------------------------------------------------------------
+// CFotaDownload::RetrieveDownloadL
+// Retrieves the RHttpDownload object from download manager during resume
+// --------------------------------------------------------------------------
+//
+RHttpDownload* CFotaDownload::RetrieveDownloadL()
+ {
+ FLOG(_L("CFotaDownload::RetrieveDownloadL >>"));
+ //Retrieve RHttpDownload object for the suspended download from Download Mgr.
+ if (!iDownloadMgr.Handle())
+ iDownloadMgr.ConnectL( TUid::Uid(KFotaServerUid) , *this, EFalse);
+ const CDownloadArray& downloads = iDownloadMgr.CurrentDownloads();
+
+ TBuf8<KMaxPath> url8;
+ TInt32 val (KErrNone);
+
+ RHttpDownload* aDownload (NULL);
+ for (TInt i = 0; i < downloads.Count(); i++ )
+ {
+ User::LeaveIfError( downloads[i]->GetStringAttribute( EDlAttrCurrentUrl, url8 ));
+ User::LeaveIfError( downloads[i]->GetIntAttribute( EDlAttrFotaPckgId, val));
+
+ FLOG(_L("Current download(s) as per download mgr: %d, url = %S, pkgid = %d"), i+1, &url8, val);
+
+ if (iDLState.iPkgId == val)
+ {
+ FLOG(_L("Successfully found the paused download object"));
+ aDownload = downloads[i];
+ if ( iUrl ) {delete iUrl; iUrl=NULL;}
+ iUrl = url8.Alloc();
+
+ }
+ }
+ FLOG(_L("CFotaDownload::RetrieveDownloadL <<"));
+ return aDownload;
+ }
+
+// --------------------------------------------------------------------------
+// CFotaDownload::SetDownloadActive
+// Sets the download activity state P&S key
+// --------------------------------------------------------------------------
+//
+void CFotaDownload::SetDownloadActive(TBool aValue)
+ {
+ FLOG(_L("CFotaDownload::SetDownloadActive, aValue = %d"),aValue);
+ iDownloadActive = aValue;
+ TBool val (EFalse);
+ TInt err = RProperty::Get(TUid::Uid(KFotaServerUid), KFotaDownloadActive, val );
+
+ if (err == KErrNone && val != aValue)
+ {
+ err = RProperty::Set(TUid::Uid(KFotaServerUid), KFotaDownloadActive, aValue );
+ FLOG(_L("RProperty KFotaDownloadActive Set %d, err = %d"), aValue, err);
+ }
+
+ FLOG(_L("CFotaDownload::SetDownloadActive <<"));
+ }
+
+// --------------------------------------------------------------------------
+// IsDownloadActive
+// Returns the activeness of the download
+// --------------------------------------------------------------------------
+//
+
+TBool CFotaDownload::IsDownloadActive()
+ {
+ FLOG(_L("CFotaDownload::IsDownloadActive, value = %d"),iDownloadActive);
+ return iDownloadActive;
+ }
+
+
+// --------------------------------------------------------------------------
+// CFotaDownloadNotifHandler::NewL
+// --------------------------------------------------------------------------
+//
+CFotaDownloadNotifHandler* CFotaDownloadNotifHandler::NewL (CFotaDownload* aDownload)
+ {
+ FLOG(_L("CFotaDownloadNotifHandler::NewL"));
+ __ASSERT_ALWAYS( aDownload, User::Panic(KFotaPanic, KErrArgument) );
+ CFotaDownloadNotifHandler* h=new (ELeave)CFotaDownloadNotifHandler;
+ h->iDownload = aDownload;
+ h->iDownload->iFotaServer->iNotifHandler = h;
+ return h;
+ }
+
+// --------------------------------------------------------------------------
+CFotaDownloadNotifHandler::CFotaDownloadNotifHandler() : CActive(EPriorityNormal)
+ {
+ FLOG(_L("CFotaDownloadNotifHandler::CFotaDownloadNotifHandler()"));
+ CActiveScheduler::Add( this );
+ }
+
+// --------------------------------------------------------------------------
+CFotaDownloadNotifHandler::~CFotaDownloadNotifHandler()
+ {
+ FLOG(_L("CFotaDownloadNotifHandler::~CFotaDownloadNotifHandler >>"));
+ iNotifier.Close();
+ Cancel();
+ FLOG(_L("CFotaDownloadNotifHandler::~CFotaDownloadNotifHandler <<"));
+ }
+
+// --------------------------------------------------------------------------
+void CFotaDownloadNotifHandler::RunL()
+ {
+ FLOG(_L("CFotaDownloadNotifHandler::RunL() note:%d, param:%d" ),iNotifParams.iNoteType, iNotifParams.iIntParam);
+
+ TBool reset (ETrue);
+
+ iNotifier.Close();
+
+ iDownload->SetDownloadActive(EFalse);
+ if ( iNotifParams.iNoteType == ESyncMLFwUpdErrorNote ) // 1
+ {
+ //do nothing here
+ }
+ if ( iNotifParams.iNoteType == ESyncMLFwUpdOmaDLNotEnoughMemory ) // 7
+ {
+ //To be active as Flexible mem is in action.
+ if (iDownload->iFreshDL)
+ iDownload->SetDownloadActive(ETrue);
+ }
+ if ( iNotifParams.iNoteType == ESyncMLFwUpdOmaDLUserCancel )
+ {
+ //At this point Download Mgr has already paused the download successfully.
+ if (iStatus.Int() == KErrCancel) //RSK Press
+ {
+ //User wants to cancel download permanently.
+ FLOG(_L("User choose to cancel download permanently!"));
+ iDownload->RunDownloadCancelL(RFotaEngineSession::EResUserCancelled);
+ }
+ else
+ {
+ //Other keys pressed, like LSK or Call termination key
+ FLOG(_L("User choose to resume download later, key press = %d"),iStatus.Int());
+ iDownload->iFotaServer->FinalizeDownloadL( iDownload->iDLState );
+ if (iStatus.Int() == KErrNone) //RSK is pressed
+ {
+ LaunchNotifierL(ESyncMLFwUpdOmaDLPostponed, EFalse, EFalse);
+ reset = EFalse;
+ }
+ else
+ iDownload->iFotaServer->ShutApp();
+ }
+ }
+
+ if ( iNotifParams.iNoteType == ESyncMLFwUpdOmaDLPostponed )
+ {
+ //Nothing to do
+ }
+
+ if ( iNotifParams.iNoteType == ESyncMLFwUpdOmaDLCancelled )
+ {
+ //Nothing to do
+ }
+
+ if ( iNotifParams.iNoteType == ESyncMLFwUpdOmaDLResume )
+ {
+ if (iStatus.Int() == KErrNone) // LSK Press
+ {
+ FLOG(_L("User choose to continue download now."));
+ iNotifParams.iNoteType = ESyncMLFwUpdUnknown;
+ iNotifParams.iIntParam = 0;
+ iDownload->ResumeDownloadL();
+ reset = EFalse;
+ }
+ else //RSK or any other key
+ {
+ FLOG(_L("User cancelled to continue download now, key press = %d."),iStatus.Int());
+ if (iStatus.Int() == KErrCancel) //RSK is pressed
+ {
+ iDownload->iDLState.iResult = RFotaEngineSession::EResUserCancelled;
+ LaunchNotifierL(ESyncMLFwUpdOmaDLUserCancel, EFalse, EFalse);
+ reset = EFalse;
+ }
+ else
+ iDownload->iFotaServer->ShutApp();
+ }
+ }
+
+ if (reset)
+ {
+ iNotifParams.iNoteType = ESyncMLFwUpdUnknown;
+ iNotifParams.iIntParam = 0;
+ }
+ }
+
+// --------------------------------------------------------------------------
+TInt CFotaDownloadNotifHandler::RunError(TInt aError)
+ {
+ FLOG(_L("CFotaDownloadNotifHandler::RunError %d"),aError);
+ return aError;
+ }
+
+// --------------------------------------------------------------------------
+void CFotaDownloadNotifHandler::DoCancel()
+ {
+ FLOG(_L("CFotaDownloadNotifHandler::DoCancel >>"));
+ if (iNotifier.Handle())
+ {
+ iNotifier.CancelNotifier( KSyncMLFwUpdNotifierUid );
+ iNotifier.Close();
+ }
+ FLOG(_L("CFotaDownloadNotifHandler::DoCancel <<"));
+ }
+
+// --------------------------------------------------------------------------
+void CFotaDownloadNotifHandler::LaunchNotifierL( const TSyncMLFwUpdNoteTypes aNotetype
+ ,const TInt aIntParam
+ , const TInt aMemoryNeeded
+ ,TBool aFinishOnly)
+ {
+ FLOG(_L("CFotaDownloadNotifHandler::LaunchNotifierL, aNoteType=%d, aParam=%d, aMemoryNeeded=%d aFinishOnly=%d >> "), aNotetype, aIntParam, aMemoryNeeded, aFinishOnly?1:0);
+
+ __ASSERT_ALWAYS( iNotifier.Handle()==0, User::Leave(KErrAlreadyExists) );
+ __ASSERT_ALWAYS( aMemoryNeeded>=0, User::Leave(KErrArgument) );
+
+
+ // Launch notifier
+ TSyncMLFwUpdNotifParams params;
+ FLOG(_L(" 1"));
+ params.iNoteType = aNotetype;
+ params.iIntParam = aIntParam;
+
+ TInt rem = 0;
+ rem = aMemoryNeeded % 1024 ;
+ if (rem)
+ {
+ params.iMemoryNeeded = (aMemoryNeeded /1024) + 1;
+ }
+ else
+ {
+ params.iMemoryNeeded = (aMemoryNeeded /1024) ;
+ }
+
+ // #endif
+ TSyncMLFwUpdNotifParamsPckg pckg(params);
+ iNotifParams.iNoteType = params.iNoteType;
+ iNotifParams.iIntParam = params.iIntParam;
+
+ iNotifParams.iMemoryNeeded = params.iMemoryNeeded;
+
+ iDummyResponsePckg = TSyncMLFwUpdNotifRetValPckg();
+ FLOG(_L(" 2"));
+ if ( !aFinishOnly )
+ {
+ User::LeaveIfError( iNotifier.Connect() );
+ iNotifier.StartNotifierAndGetResponse( iStatus, KSyncMLFwUpdNotifierUid
+ , pckg, iDummyResponsePckg );
+ SetActive();
+ }
+ else
+ {
+ iStatus = KRequestPending;
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ }
+ FLOG(_L(" 3 %d"),iStatus.Int());
+ FLOG(_L("CFotaDownloadNotifHandler::LaunchNotifierL() <<"));
+ }
+
+TBool CFotaDownloadNotifHandler::IsOpen()
+ {
+ FLOG(_L("Handle = %d"), iNotifier.Handle());
+ return (iNotifier.Handle())? ETrue:EFalse;
+ }