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

equal deleted inserted replaced

-:5cc91383ab1e
+:7333d7932ef7
 */
 // 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 <iaupdate.rsg>
+#include <qapplication.h>
+#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
 	    {
-	    CIAUpdateAppUi* appUi =
+	    qApp->quit();
-	            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::CheckUpdatesL() end");
+IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::AgreementHandledL() end");
 }
 // ---------------------------------------------------------------------------
 // CIAUpdateUiController::StartUpdateL
 CreateSelectedNodesArrayL();
 if ( !IAUpdateUtils::SpaceAvailableInInternalDrivesL( iSelectedNodesArray ) )
 {
-	    HBufC* noteText = NULL;
+if ( !mDialogUtil )
-noteText = StringLoader::LoadLC( R_IAUPDATE_INSUFFICIENT_MEMORY );
+{
-IAUpdateDialogUtil::ShowInformationQueryL( *noteText );
+mDialogUtil = new IAUpdateDialogUtil(NULL, this);
-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;
-ShowUpdatingDialogL( R_IAUPDATE_DOWNLOADING_NOTE,
+selectedNode->SetUiState( MIAUpdateNode::EDownloading );
-selectedNode->Base().Name(),
+iObserver.RefreshUI();
-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;
-CIAUpdateAppUi* appUi =
+selectedNode->SetUiState( MIAUpdateNode::EInstalling );
-static_cast< CIAUpdateAppUi* >( iEikEnv->EikAppUi() );
+iObserver.RefreshUI();
-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;
-CIAUpdateAppUi* appUi = static_cast<CIAUpdateAppUi*>( iEikEnv->EikAppUi() );
+aNode.SetUiState( MIAUpdateNode::EInstalling );
-appUi->StartWGListChangeMonitoring();
+iObserver.RefreshUI();
-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 );
-HBufC* noteText = StringLoader::LoadLC( R_IAUPDATE_REFRESHING_UPDATE_LIST );
+ShowWaitDialogL( "Refreshing updates list", ETrue );
-ShowWaitDialogL( *noteText, ETrue );
-CleanupStack::PopAndDestroy( noteText );
 }
 }
 }
 else
 {
-HBufC* noteText = StringLoader::LoadLC( R_IAUPDATE_REFRESHING_UPDATE_LIST );
+ShowWaitDialogL( "Refreshing updates list", ETrue );
-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::HandleDialogExitL
+// CIAUpdateUiController::HandleWaitDialogCancel
-// Called when wait/progress dialog is about to be cancelled.
+// Called when wait dialog is cancelled.
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
-TBool CIAUpdateUiController::HandleDialogExitL( TInt aButtonId )
+void CIAUpdateUiController::HandleWaitDialogCancel()
 {
-IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::HandleDialogExitL() begin");
+IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::HandleWaitDialogCancel() begin");
-IAUPDATE_TRACE_1("[IAUPDATE] button id: %d", aButtonId );
+TRAPD ( err, HandleUserCancelL() );
-TInt ret( ETrue );
+if ( err != KErrNone )
-if ( aButtonId == EAknSoftkeyCancel )
+{
-{
+	iObserver.HandleLeaveErrorL( err );
-TRAPD ( err, HandleUserCancelL() );
+}
-if ( err != KErrNone )
-{
+IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::HandleWaitDialogCancel() end");
-	iObserver.HandleLeaveErrorL( err );
 }
-}
+// -----------------------------------------------------------------------------
-IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::HandleDialogExitL() end");
+// CIAUpdateUiController::dialogFinished
+// 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 );
 }
-if ( iFwNodes.Count() > 0 )
+	    	for ( TInt j = 0; j < iFwNodes.Count(); ++j )
 {
-MIAUpdateFwNode* fwNode( iFwNodes[ 0 ] );
+MIAUpdateFwNode* fwNode( iFwNodes[ j ] );
 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 );
-// In release mode, we do not need the aError info, because
+if ( aError == KErrNone )
-// success counters are counted by using the last operation error info
+{
-// when counter info is asked. In debug mode the error code is logged above.
+aNode.SetUiState( MIAUpdateNode::EUpdated );
-(void)aError;
+iObserver.RefreshUI();
+}
+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 );
-iController->FinishedUpdatesL( ETrue, KServerReportMaxWaitTime );
+//const TInt KServerReportMaxWaitTime( 10000000 );         //Commented TEMP
-iState = ESendingReport;
+//iController->FinishedUpdatesL( ETrue, KServerReportMaxWaitTime ); //Commented TEMP
+//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 TDesC& aDisplayString,
+void CIAUpdateUiController::ShowWaitDialogL( const QString& 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 65	7333d7932ef7
parent 34	741e5bba2bd1
child 66	8b7f4e561641