FCL/sf/mw/appinstall: comparison iaupdate/IAD/ui/src/iaupdateuicontroller.cpp

equal deleted inserted replaced

-:7333d7932ef7
+:8b7f4e561641
 */
 // INCLUDES
+#include <avkon.hrh>
+#include <StringLoader.h>
 #include <centralrepository.h>
+#include <AknUtils.h>
 #include <SWInstDefs.h>
+#include <avkon.rsg>
 #include <featurecontrol.h>
 #include <cmmanager.h>
-#include <qapplication.h>
+#include <iaupdate.rsg>
-#include <hbaction.h>
-#include <hbprogressdialog.h>
 #include <iaupdateparameters.h>
 #include "iaupdateuicontroller.h"
 #include "iaupdateuicontrollerobserver.h"
+#include "iaupdateappui.h"
 #include "iaupdate.hrh"
+#include "iaupdatewaitdialog.h"
+#include "iaupdateprogressdialog.h"
 #include "iaupdatenode.h"
 #include "iaupdatefwnode.h"
 #include "iaupdatebasenode.h"
 #include "iaupdatenodefilter.h"
 #include "iaupdatefactory.h"
 #include "iaupdatestarter.h"
 #include "iaupdateprivatecrkeys.h"
 #include "iaupdatecontrollerfile.h"
 #include "iaupdateuiconfigdata.h"
+#include "iaupdatedialogutil.h"
 #include "iaupdateutils.h"
 #include "iaupdateagreement.h"
 #include "iaupdateautomaticcheck.h"
 #include "iaupdateroaminghandler.h"
 #include "iaupdatependingnodesfile.h"
 #include "iaupdaterresultsfile.h"
 #include "iaupdaterresult.h"
 #include "iaupdateridentifier.h"
 #include "iaupdateruids.h"
 #include "iaupdaterdefs.h"
+#include "iaupdatetools.h"
 #include "iaupdateparametersfilemanager.h"
 #include "iaupdateerrorcodes.h"
 #include "iaupdatefileconsts.h"
 #include "iaupdatefirsttimeinfo.h"
 #include "iaupdaterefreshhandler.h"
 #include "iaupdatenodeid.h"
-#include "iaupdatewaitdialog.h"
-#include "iaupdatedialogutil.h"
 #include "iaupdatedebug.h"
 // cenrep in emulator:
 // copy 2000F85A.txt to '\epoc32\release\winscw\udeb\Z\private\10202be9\'
 CIAUpdateUiController::~CIAUpdateUiController()
 {
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::~CIAUpdateUiController() begin");
 CancelOperation();
-delete mWaitDialog;
 delete iController;
 iNodes.Reset();
 iFwNodes.Reset();
 iSelectedNodesArray.Reset();
 iServicePackNodes.Reset();
 delete iStarter;
 delete iConfigData;
 delete iRoamingHandler;
 delete iParams;
 delete iRefreshHandler;
-delete mDialogUtil;
 // If dialogs have not been released yet, release them now.
 // ProcessFinishedL() should normally be used for dialogs but
 // here just use non-leaving delete. In normal cases, dialogs should
 // already be released in the end of the update flow before coming here.
-//delete iWaitDialog;
+delete iWaitDialog;
-//delete iProgressDialog;
+delete iProgressDialog;
 	IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::~CIAUpdateUiController() end");
 }
 // ---------------------------------------------------------------------------
 //
 void CIAUpdateUiController::CheckUpdatesL()
 {
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::CheckUpdatesL() begin");
 iCountOfAvailableUpdates = 0;
 if ( iParams )
 {
 	iFilter->SetFilterParams( iParams ); //iParams ownership is changed
 	iParams = NULL;
 }
 TBool agreementAccepted( EFalse );
 if ( !ForcedRefresh() )
 {
 CIAUpdateAgreement* agreement = CIAUpdateAgreement::NewLC();
 agreementAccepted = agreement->AgreementAcceptedL();
 if ( ( !agreementAccepted )&& ( iRequestType != IAUpdateUiDefines::ECheckUpdates ) )
 // agreement (disclaimer) dialog is not prompted when CheckUpdates is called
 //
 // Refresh from network is allowed when first time case
 iRefreshFromNetworkDenied = EFalse;
 agreementAccepted = agreement->AcceptAgreementL();
-if (!agreementAccepted)
-{
-if ( !mDialogUtil )
-{
-mDialogUtil = new IAUpdateDialogUtil(NULL, this);
-}
-if ( mDialogUtil )
-{
-mPrimaryAction = NULL;
-//mPrimaryAction = new HbAction(hbTrId("txt_software_button_accept"));
-					mPrimaryAction = new HbAction("Accept");
-HbAction *secondaryAction = NULL;
-//secondaryAction = new HbAction(hbTrId("txt_software_button_decline"));
-					secondaryAction = new HbAction("Decline");
-mDialogUtil->showAgreement(mPrimaryAction,secondaryAction);
-iDialogState = EAgreement;
-}
-}
 }
 CleanupStack::PopAndDestroy( agreement );
 }
-if ( iDialogState != EAgreement )
-{
-AgreementHandledL();
-}
-IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::CheckUpdatesL() end");
-return;
-}
-// ---------------------------------------------------------------------------
-// CIAUpdateUiController:: AgreementHandledL
-// Updates the update item list.
-// ---------------------------------------------------------------------------
-//
-void CIAUpdateUiController::AgreementHandledL()
-{
-IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::AgreementHandledL() begin");
-TBool agreementAccepted( EFalse );
-CIAUpdateAgreement* agreement = CIAUpdateAgreement::NewLC();
-agreementAccepted = agreement->AgreementAcceptedL();
-CleanupStack::PopAndDestroy( agreement );
 if ( !agreementAccepted && !ForcedRefresh() )
 {
 if ( iRequestType == IAUpdateUiDefines::ECheckUpdates )
 {
 CIAUpdateAutomaticCheck* automaticCheck = CIAUpdateAutomaticCheck::NewLC();
 	    iObserver.UpdateCompleteL( KErrNone );
 	    return;
 	    }
 	else
 	    {
-	    qApp->quit();
+	    CIAUpdateAppUi* appUi =
+	            static_cast< CIAUpdateAppUi* >( iEikEnv->EikAppUi() );
+appUi->Exit();
 	    return;
 	    }
 }
 if ( iRequestType == IAUpdateUiDefines::ECheckUpdates &&
 AllowNetworkRefreshL() &&
 // and new startup should not be called. Also, leave in that case.
 User::LeaveIfError( ret );
 }
 }
-IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::AgreementHandledL() end");
+IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::CheckUpdatesL() end");
 }
 // ---------------------------------------------------------------------------
 // CIAUpdateUiController::StartUpdateL
 CreateSelectedNodesArrayL();
 if ( !IAUpdateUtils::SpaceAvailableInInternalDrivesL( iSelectedNodesArray ) )
 {
-if ( !mDialogUtil )
+	    HBufC* noteText = NULL;
-{
+noteText = StringLoader::LoadLC( R_IAUPDATE_INSUFFICIENT_MEMORY );
-mDialogUtil = new IAUpdateDialogUtil(NULL, this);
+IAUpdateDialogUtil::ShowInformationQueryL( *noteText );
-}
+CleanupStack::PopAndDestroy( noteText );
-if ( mDialogUtil )
-{
-mPrimaryAction = NULL;
-mPrimaryAction = new HbAction(hbTrId("txt_common_button_ok"));
-//mDialogUtil->showInformation(hbTrId("txt_software_info_insufficient_memory_free_some_m"), mPrimaryAction);
-			mDialogUtil->showInformation(QString("Insufficient memory. Free some memory and try again."), mPrimaryAction);
-iDialogState = EInsufficientMemory;
-}
 }
 else
 {
 if ( !IsStartedByLauncher() )
 {
 }
 // Inform the controller that we are now starting updates. This way the
 // controller can handle situations as a whole and not as one item at the
 // time.
 iController->StartingUpdatesL();
-//Store current node list before update
-iFilter->StoreNodeListL( iNodes );
-iFilter->SortSelectedNodesFirstL( iSelectedNodesArray, iNodes );
 iFileInUseError = EFalse;
 // Set the node index to -1 because ContinueUpdateL increases it by one
 // in the beginning of the function. So, we can use the ContinueUpdateL
 // also in here.
 iNodeIndex = -1;
 MIAUpdateNode* selectedNode = iSelectedNodesArray[ iNodeIndex ];
 // Only update items that have not been installed yet.
 if ( !selectedNode->IsInstalled() )
 {
 IAUPDATE_TRACE("[IAUPDATE] Item not installed yet");
-iFilter->SortThisNodeFirstL( selectedNode, iNodes );
 if ( !selectedNode->IsDownloaded() )
 {
 // Because content has not been downloaded or installed yet,
 // it needs to be downloaded before it can be installed.
 IAUPDATE_TRACE("[IAUPDATE] Download");
 selectedNode->DownloadL( *this );
 iState = EDownloading;
 iClosingAllowedByClient = ETrue;
-selectedNode->SetUiState( MIAUpdateNode::EDownloading );
+ShowUpdatingDialogL( R_IAUPDATE_DOWNLOADING_NOTE,
-iObserver.RefreshUI();
+selectedNode->Base().Name(),
+iNodeIndex + 1,
+iSelectedNodesArray.Count() );
 nextUpdate = EFalse;
 }
 else
 {
 // Because content has been downloaded but not installed yet,
 // it needs to be installed now.
 IAUPDATE_TRACE("[IAUPDATE] Install");
 selectedNode->InstallL( *this );
 iState = EInstalling;
 iClosingAllowedByClient = EFalse;
-selectedNode->SetUiState( MIAUpdateNode::EInstalling );
+CIAUpdateAppUi* appUi =
-iObserver.RefreshUI();
+static_cast< CIAUpdateAppUi* >( iEikEnv->EikAppUi() );
+appUi->StartWGListChangeMonitoring();
+ShowUpdatingDialogL( R_IAUPDATE_INSTALLING_NOTE,
+selectedNode->Base().Name(),
+iNodeIndex + 1,
+iSelectedNodesArray.Count() );
 nextUpdate = EFalse;
 }
 }
 }
 else
 aNode.GetDependenciesL( iServicePackNodes, ETrue );
 }
 aNode.InstallL( *this );
 iState = EInstalling;
-aNode.SetUiState( MIAUpdateNode::EInstalling );
+CIAUpdateAppUi* appUi = static_cast<CIAUpdateAppUi*>( iEikEnv->EikAppUi() );
-iObserver.RefreshUI();
+appUi->StartWGListChangeMonitoring();
+iClosingAllowedByClient = EFalse;
+ShowUpdatingDialogL( R_IAUPDATE_INSTALLING_NOTE,
+aNode.Base().Name(),
+iNodeIndex + 1,
+iSelectedNodesArray.Count()  );
 	IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::StartInstallL() end");
 }
 // ---------------------------------------------------------------------------
 {
 // to avoid flickering IAD is brought to foreground only when wait dialog is really shown
 if ( allowNetworkRefresh )
 {
 iEikEnv->RootWin().SetOrdinalPosition( 0, ECoeWinPriorityNormal );
-ShowWaitDialogL( "Refreshing updates list", ETrue );
+HBufC* noteText = StringLoader::LoadLC( R_IAUPDATE_REFRESHING_UPDATE_LIST );
+ShowWaitDialogL( *noteText, ETrue );
+CleanupStack::PopAndDestroy( noteText );
 }
 }
 }
 else
 {
-ShowWaitDialogL( "Refreshing updates list", ETrue );
+HBufC* noteText = StringLoader::LoadLC( R_IAUPDATE_REFRESHING_UPDATE_LIST );
+ShowWaitDialogL( *noteText, EFalse );
+CleanupStack::PopAndDestroy( noteText );
 }
 }
 	IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::StartRefreshL() end");
 }
 }
 if ( aErrorCode == IAUpdaterDefs::KIAUpdaterShutdownRequest )
 {
-//CIAUpdateAppUi* appUi = static_cast<CIAUpdateAppUi*>( iEikEnv->EikAppUi() );
+CIAUpdateAppUi* appUi = static_cast<CIAUpdateAppUi*>( iEikEnv->EikAppUi() );
-	//appUi->Exit();
+	appUi->Exit();
 }
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::SelfUpdaterComplete() end");
 }
 // CIAUpdateUiController::DownloadProgress
 //
 // -----------------------------------------------------------------------------
 //
 void CIAUpdateUiController::DownloadProgress( MIAUpdateNode& /*aNode*/,
-TUint /*aProgress*/,
+TUint aProgress,
-TUint /*aMaxProgress*/ )
+TUint aMaxProgress )
 {
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::DownloadProgress() begin");
 if ( iProgressDialog )
 {
-	//TRAP_IGNORE ( iProgressDialog->SetProgressDialogFinalValueL( aMaxProgress ) );
+	TRAP_IGNORE ( iProgressDialog->SetProgressDialogFinalValueL( aMaxProgress ) );
-//TRAP_IGNORE ( iProgressDialog->UpdateProgressDialogValueL( aProgress ) );
+TRAP_IGNORE ( iProgressDialog->UpdateProgressDialogValueL( aProgress ) );
 }
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::DownloadProgress() end");
 }
 TInt aError )
 {
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::InstallComplete() begin");
 iState = EIdle;
-//CIAUpdateAppUi* appUi = static_cast<CIAUpdateAppUi*>( iEikEnv->EikAppUi() );
+CIAUpdateAppUi* appUi = static_cast<CIAUpdateAppUi*>( iEikEnv->EikAppUi() );
-//appUi->StopWGListChangeMonitoring();
+appUi->StopWGListChangeMonitoring();
 if ( aError == SwiUI::KSWInstErrFileInUse )
 {
 	iFileInUseError = ETrue;
 }
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::RoamingHandlerPrepared() end");
 }
 // -----------------------------------------------------------------------------
-// CIAUpdateUiController::HandleWaitDialogCancel
+// CIAUpdateUiController::HandleDialogExitL
-// Called when wait dialog is cancelled.
+// Called when wait/progress dialog is about to be cancelled.
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
-void CIAUpdateUiController::HandleWaitDialogCancel()
+TBool CIAUpdateUiController::HandleDialogExitL( TInt aButtonId )
 {
-IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::HandleWaitDialogCancel() begin");
+IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::HandleDialogExitL() begin");
+IAUPDATE_TRACE_1("[IAUPDATE] button id: %d", aButtonId );
-TRAPD ( err, HandleUserCancelL() );
-if ( err != KErrNone )
+TInt ret( ETrue );
-{
+if ( aButtonId == EAknSoftkeyCancel )
-	iObserver.HandleLeaveErrorL( err );
+{
-}
+TRAPD ( err, HandleUserCancelL() );
+if ( err != KErrNone )
-IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::HandleWaitDialogCancel() end");
+{
+	iObserver.HandleLeaveErrorL( err );
 }
+}
-// -----------------------------------------------------------------------------
-// CIAUpdateUiController::dialogFinished
+IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::HandleDialogExitL() end");
-// Called when dialog is finished.
-// -----------------------------------------------------------------------------
+return ret;
-//
-void CIAUpdateUiController::dialogFinished(HbAction *action)
-{
-TDialogState dialogState = iDialogState;
-iDialogState = ENoDialog;
-switch ( dialogState )
-{
-case EAgreement:
-if ( action == mPrimaryAction )
-{
-CIAUpdateAgreement* agreement = CIAUpdateAgreement::NewLC();
-agreement->SetAgreementAcceptedL();
-CleanupStack::PopAndDestroy(agreement);
-}
-AgreementHandledL();
-break;
-case EInsufficientMemory:
-break;
-default:
-break;
-}
 }
 // -----------------------------------------------------------------------------
 // CIAUpdateUiController::HandleUiRefreshL
 //
 	    {
 	    iRefreshed = EFalse;
 	    }
 	else if ( iState == EIdle )
 	    {
-	    //CIAUpdateAppUi* appUi = static_cast< CIAUpdateAppUi* >( iEikEnv->EikAppUi() );
+	    CIAUpdateAppUi* appUi = static_cast< CIAUpdateAppUi* >( iEikEnv->EikAppUi() );
-//if ( appUi->UiRefreshAllowed() )
+if ( appUi->UiRefreshAllowed() )
 		    {
 	    	iState = EUiRefreshing;
 	        // store node identification (Id and namespace) of currently selected nodes
 	        // to restore selections after refresh
 	        iPreviousSelections.Reset();
 nodeId->SetSelected( node->Base().IsSelected() );
 iPreviousSelections.AppendL( nodeId );
 CleanupStack::Pop( nodeId );
 }
-	    	for ( TInt j = 0; j < iFwNodes.Count(); ++j )
+if ( iFwNodes.Count() > 0 )
 {
-MIAUpdateFwNode* fwNode( iFwNodes[ j ] );
+MIAUpdateFwNode* fwNode( iFwNodes[ 0 ] );
 CIAUpdateNodeId* nodeId = CIAUpdateNodeId::NewLC();
 nodeId->SetIdL( fwNode->Base().MetaId() );
 nodeId->SetNamespaceL( fwNode->Base().MetaNamespace() );
 nodeId->SetNodeType( MIAUpdateAnyNode::ENodeTypeFw );
 nodeId->SetSelected( fwNode->Base().IsSelected() );
 TInt aError )
 {
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::InstallCompleteL() begin");
 IAUPDATE_TRACE_1("[IAUPDATE] error code: %d", aError );
-if ( aError == KErrNone )
+// In release mode, we do not need the aError info, because
-{
+// success counters are counted by using the last operation error info
-aNode.SetUiState( MIAUpdateNode::EUpdated );
+// when counter info is asked. In debug mode the error code is logged above.
-iObserver.RefreshUI();
+(void)aError;
-}
-else
-{
-aNode.SetUiState( MIAUpdateNode::EFailed );
-iObserver.RefreshUI();
-}
 // pass UID of installed package to starter
 if ( iStarter )
 {
 	if ( aNode.Type() == MIAUpdateNode::EPackageTypeServicePack )
 {
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::UpdateCompleteL() begin");
 iState = EIdle;
 iClosingAllowedByClient = EFalse;
+// Remove installed nodes from the node array.
+	for ( TInt i = iNodes.Count() - 1; i >= 0; --i )
+{
+MIAUpdateNode* node = iNodes[ i ];
+if ( node->IsInstalled() )
+{
+iNodes.Remove( i );
+}
+}
 TInt error( aError );
 TBool selfUpdaterStarted( EFalse );
 if ( error == KErrNone )
 {
 // Notice, that in case of cancellations there would not be any need
 // for timer. But just use it as in normal cases. Then, server report
 // completion or timer will call the callback later. But, that callback
 // will be ignored in CIAUpdateUiController::ServerReportSent because
 // iState is already then changed from ESendingReport to something else.
+const TInt KServerReportMaxWaitTime( 10000000 );
-//const TInt KServerReportMaxWaitTime( 10000000 );         //Commented TEMP
+iController->FinishedUpdatesL( ETrue, KServerReportMaxWaitTime );
-//iController->FinishedUpdatesL( ETrue, KServerReportMaxWaitTime ); //Commented TEMP
+iState = ESendingReport;
-//iState = ESendingReport;  //Commented temporarily
-EndUpdateFlowL( KErrNone );  //TEMP
-return;                      //TEMP
 }
 // When reports are sent, EndUpdateFlowL is called via the callback functions
 // and the update flow will be finished there. But, if we come here when cancel
 // is pressed, then call EndUpdateFlowL directly because then we do not wait
 // ---------------------------------------------------------------------------
 // CIAUpdateUiController::ShowUpdatingDialogL
 //
 // ---------------------------------------------------------------------------
 //
-/*
 void CIAUpdateUiController::ShowUpdatingDialogL( TInt aTextResourceId,
 const TDesC& aName,
 TInt aNumber,
 TInt aTotalCount )
 CArrayFix<TInt>* numberArray = new( ELeave ) CArrayFixFlat<TInt>( 2 );
 CleanupStack::PushL( numberArray );
 numberArray->AppendL( aNumber );
 numberArray->AppendL( aTotalCount );
 HBufC* noteText = NULL;
-//noteText = StringLoader::LoadLC( aTextResourceId,
+noteText = StringLoader::LoadLC( aTextResourceId,
-//                                 *stringArray,
+*stringArray,
-//                                 *numberArray );
+*numberArray );
 TPtr ptr = noteText->Des();
-//AknTextUtils::DisplayTextLanguageSpecificNumberConversion( ptr );
+AknTextUtils::DisplayTextLanguageSpecificNumberConversion( ptr );
 if ( iState == EDownloading )
 {
 	ShowProgressDialogL( *noteText, ETrue );
 }
 else
 {
-//ShowWaitDialogL( *noteText, ETrue );
+ShowWaitDialogL( *noteText, ETrue );
 }
 CleanupStack::PopAndDestroy( noteText );
 CleanupStack::PopAndDestroy( numberArray );
 CleanupStack::PopAndDestroy( stringArray );
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::ShowUpdatingDialogL() end");
-}*/
+}
 // ---------------------------------------------------------------------------
 // CIAUpdateUiController::ShowWaitDialogL
 //
 // ---------------------------------------------------------------------------
 //
-void CIAUpdateUiController::ShowWaitDialogL( const QString& aDisplayString,
+void CIAUpdateUiController::ShowWaitDialogL( const TDesC& aDisplayString,
-TBool /*aVisibilityDelayOff*/ )
+TBool aVisibilityDelayOff )
 {
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::ShowWaitDialogL() begin");
-if ( !mWaitDialog )
-{
+if ( iWaitDialog )
-mWaitDialog = new IAUpdateWaitDialog();
-mWaitDialog->SetCallback( this );
-mWaitDialog->showDialog( aDisplayString );
-}
-/*if ( iWaitDialog )
 {
 IAUPDATE_TRACE("[IAUPDATE] Wait dialog already existed. Remove it first");
 // in some rare cases previous dialog still exists
 // it's now just deleted (not recommended way) to avoid forwarding problem(s).
-//delete iWaitDialog;
+delete iWaitDialog;
 iWaitDialog = NULL;
-}*/
+}
-/*   iWaitDialog =
+iWaitDialog =
 new( ELeave ) CIAUpdateWaitDialog(
 reinterpret_cast< CEikDialog** >( &iWaitDialog ),
 aVisibilityDelayOff );
 iWaitDialog->SetTextL( aDisplayString );
 iWaitDialog->SetCallback( this );
-iWaitDialog->ExecuteLD( R_IAUPDATE_WAIT_DIALOG ); */
+iWaitDialog->ExecuteLD( R_IAUPDATE_WAIT_DIALOG );
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::ShowWaitDialogL() end");
 }
-// --------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
 // CIAUpdateUiController::ShowProgressDialogL
 //
 // ---------------------------------------------------------------------------
 //
-void CIAUpdateUiController::ShowProgressDialogL( const TDesC& /*aDisplayString*/,
+void CIAUpdateUiController::ShowProgressDialogL( const TDesC& aDisplayString,
-TBool /*aVisibilityDelayOff*/ )
+TBool aVisibilityDelayOff )
 {
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::ShowProgressDialogL() begin");
 if ( iProgressDialog )
 {
 IAUPDATE_TRACE("[IAUPDATE] Progress dialog already existed. Remove it first");
 // in some rare cases previous dialog still exists
 // it's now just deleted (not recommended way) to avoid forwarding problem(s).
-//delete iProgressDialog;
+delete iProgressDialog;
 iProgressDialog = NULL;
 }
-/*    iProgressDialog =
+iProgressDialog =
 new( ELeave ) CIAUpdateProgressDialog(
 reinterpret_cast< CEikDialog** >( &iProgressDialog ),
 aVisibilityDelayOff );
 iProgressDialog->SetTextL( aDisplayString );
 iProgressDialog->SetCallback( this );
-iProgressDialog->ExecuteLD( R_IAUPDATE_PROGRESS_DIALOG ); */
+iProgressDialog->ExecuteLD( R_IAUPDATE_PROGRESS_DIALOG );
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::ShowProgressDialogL() end");
 }
 // ---------------------------------------------------------------------------
 //
 void CIAUpdateUiController::RemoveWaitDialogL()
 {
 IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::RemoveWaitDialogL() begin");
-if ( mWaitDialog )
-{
-mWaitDialog->close();
-}
-/*if ( !iCancelling )  //that's needed because AVKON  in 3.2.3 wk12, returning
-//EFalse in TryToExitL() causes a crash
-{
-	if ( iWaitDialog )
-{
-	    iWaitDialog->ProcessFinishedL();
-}
-}*/
-	IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::RemoveWaitDialogL() end");
-}
-// ---------------------------------------------------------------------------
-// CIAUpdateUiController::RemoveProgressDialogL
-//
-// ---------------------------------------------------------------------------
-//
-void CIAUpdateUiController::RemoveProgressDialogL()
-{
-IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::RemoveProgressDialogL() begin");
 if ( !iCancelling )  //that's needed because AVKON  in 3.2.3 wk12, returning
 //EFalse in TryToExitL() causes a crash
 {
+	if ( iWaitDialog )
+{
+	    iWaitDialog->ProcessFinishedL();
+}
+}
+	IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::RemoveWaitDialogL() end");
+}
+// ---------------------------------------------------------------------------
+// CIAUpdateUiController::RemoveProgressDialogL
+//
+// ---------------------------------------------------------------------------
+//
+void CIAUpdateUiController::RemoveProgressDialogL()
+{
+IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::RemoveProgressDialogL() begin");
+if ( !iCancelling )  //that's needed because AVKON  in 3.2.3 wk12, returning
+//EFalse in TryToExitL() causes a crash
+{
 	if ( iProgressDialog )
 {
-	    //iProgressDialog->ProcessFinishedL();
+	    iProgressDialog->ProcessFinishedL();
 }
 }
 	IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::RemoveProgressDialogL() end");
 }
 {
 iForcedRefresh = aForcedRefresh;
 }
 // ---------------------------------------------------------------------------
-// CIAUpdateUiController::RefreshNodeList
-//
-// ---------------------------------------------------------------------------
-//
-void CIAUpdateUiController::RefreshNodeList()
-{
-// Restore list after update, that nodes are shown in original sequence
-iFilter->RestoreNodeListL( iNodes );
-// Remove installed nodes from the node array.
-// Set temp UI state to normal for remaining nodes
-for ( TInt i = iNodes.Count() - 1; i >= 0; --i )
-{
-MIAUpdateNode* node = iNodes[ i ];
-if ( node->IsInstalled() )
-{
-iNodes.Remove( i );
-}
-else
-{
-node->SetUiState( MIAUpdateNode::ENormal );
-}
-}
-}
-// ---------------------------------------------------------------------------
 // CIAUpdateUiController::ParamsWriteFileL
 //
 // ---------------------------------------------------------------------------
 //
 void CIAUpdateUiController::ParamsWriteFileL()

branch	RCL_3
changeset 66	8b7f4e561641
parent 65	7333d7932ef7