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

equal deleted inserted replaced

-:6e7b00453237
+:d17dc5398051
 #include "iaupdateresultsdialog.h"
 #include "iaupdatedebug.h"
 IAUpdateEngine::IAUpdateEngine(QObject *parent)
-: QObject(parent),
+: QObject(parent)
-iController(NULL),
-iFwUpdateHandler(NULL),
-iGlobalLockHandler(NULL),
-iIdle(NULL),
-iIdleAutCheck(NULL),
-iUpdateNow(EFalse),
-iRequestIssued(EFalse),
-iStartedFromApplication(EFalse),
-iUiRefreshAllowed(ETrue),
-iUpdatequeryUid(0)
 {
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::IAUpdateEngine() begin");
+iController = NULL;
+iFwUpdateHandler = NULL;
+iGlobalLockHandler = NULL;
+iAutomaticCheck = NULL;
+iIdle = NULL;
+iIdleAutCheck = NULL;
 iEikEnv = CEikonEnv::Static();
+mUpdateNow = false;
+mRequestIssued = false;
+mStartedFromApplication = false;
+mUiRefreshAllowed = true;
+mWgId = 0;
+mUpdatequeryUid = 0;
+mDialogState = NoDialog;
+mResultsDialog = NULL;
 mServiceProvider = NULL;
 mServiceProvider = new IAUpdateServiceProvider( *this );
 connect(mServiceProvider, SIGNAL(clientDisconnected()), this, SLOT(handleAllClientsClosed()));
 TRAP_IGNORE( iController = CIAUpdateUiController::NewL( *this ));
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::IAUpdateEngine() end");
 }
 if (iGlobalLockHandler)
 {
 delete iGlobalLockHandler;
 }
+if ( iAutomaticCheck )
+{
+delete iAutomaticCheck;
+}
 if ( iController )
 {
 delete iController;
 }
 if ( iFwUpdateHandler )
 // -----------------------------------------------------------------------------
 // IAUpdateEngine::StartedByLauncherL
 //
 // -----------------------------------------------------------------------------
 //
-void IAUpdateEngine::StartedByLauncherL( TBool aRefreshFromNetworkDenied )
+void IAUpdateEngine::StartedByLauncherL( bool aRefreshFromNetworkDenied )
 {
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartedByLauncherL() begin");
-iRequestIssued = ETrue;
+mRequestIssued = true;
-iRequestType = IAUpdateUiDefines::ENoRequest;
+mRequestType = IAUpdateUiDefines::ENoRequest;
-iController->SetRequestType( iRequestType );
+iController->SetRequestType( mRequestType );
-SetVisibleL( ETrue );
+SetVisibleL( true );
 CIAUpdateParameters* params = iController->ParamsReadAndRemoveFileL();
 iController->CheckUpdatesDeferredL( params, aRefreshFromNetworkDenied );
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartedByLauncherL() end");
 }
 //
 // -----------------------------------------------------------------------------
 //
 void IAUpdateEngine::CheckUpdatesRequestL( int wgid,
 CIAUpdateParameters* aFilterParams,
-TBool aForcedRefresh )
+bool aForcedRefresh )
 {
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::CheckUpdatesRequestL() begin");
 SetClientWgId( wgid );
-iRequestIssued = ETrue;
+mRequestIssued = true;
-iStartedFromApplication  = ETrue;
+mStartedFromApplication  = true;
 CleanupStack::PushL( aFilterParams );
 if ( wgid > 0 )
 {
-HideApplicationInFSWL( ETrue );
+HideApplicationInFSWL( true );
 }
 CleanupStack::Pop( aFilterParams );
 if ( !aFilterParams->ShowProgress() )
 {
 iEikEnv->RootWin().SetOrdinalPosition( -1, ECoeWinPriorityNeverAtFront );
 }
-iRequestType = IAUpdateUiDefines::ECheckUpdates;
+mRequestType = IAUpdateUiDefines::ECheckUpdates;
-iController->SetRequestType( iRequestType );
+iController->SetRequestType( mRequestType );
 iController->SetForcedRefresh( aForcedRefresh );
-iController->CheckUpdatesDeferredL( aFilterParams, EFalse );
+iController->CheckUpdatesDeferredL( aFilterParams, false );
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::CheckUpdatesRequestL() end");
 }
 // -----------------------------------------------------------------------------
 //
 void IAUpdateEngine::ShowUpdatesRequestL( int wgid, CIAUpdateParameters* aFilterParams )
 {
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowUpdatesRequestL() begin");
 SetClientWgId( wgid );
-iRequestIssued = ETrue;
+mRequestIssued = true;
 //    delete iBackgroundTimer;
 //    iBackgroundTimer = NULL;
-iStartedFromApplication  = ETrue;
+mStartedFromApplication  = true;
 CleanupStack::PushL( aFilterParams );
 if ( wgid > 0 )
 {
-HideApplicationInFSWL( ETrue );
+HideApplicationInFSWL( true );
 }
-//StatusPane()->MakeVisible( ETrue );
+//StatusPane()->MakeVisible( true );
 iEikEnv->RootWin().SetOrdinalPosition( 0, ECoeWinPriorityNormal );
 //iRequestObserver = &aObserver;
-iRequestType = IAUpdateUiDefines::EShowUpdates;
+mRequestType = IAUpdateUiDefines::EShowUpdates;
-iController->SetRequestType( iRequestType );
+iController->SetRequestType( mRequestType );
 //if ( !iMainView )
 //    {
 //    iMainView  = CIAUpdateMainView::NewL( ClientRect() );
 // by pushing object to cleanup stack its destructor is called if leave happens
 // so global lock issued by this instance can be released in destructor of CIAUpdateGlobalLockHandler
 CIAUpdateGlobalLockHandler* globalLockHandler = CIAUpdateGlobalLockHandler::NewLC();
 if ( !globalLockHandler->InUseByAnotherInstanceL() )
 {
-globalLockHandler->SetToInUseForAnotherInstancesL( ETrue );
+globalLockHandler->SetToInUseForAnotherInstancesL( true );
 CleanupStack::Pop( globalLockHandler );
 CleanupStack::Pop( aFilterParams );
 CleanupStack::PushL( globalLockHandler );
-iController->CheckUpdatesDeferredL( aFilterParams, EFalse );
+iController->CheckUpdatesDeferredL( aFilterParams, false );
 CleanupStack::Pop( globalLockHandler );
 delete iGlobalLockHandler;
 iGlobalLockHandler = globalLockHandler;
 //now possible deletion of iGlobalLockHandler in leave situation is handled
 //in HandleLeaveErrorL() and HandleLeaveErrorWithoutLeave methods.
 // -----------------------------------------------------------------------------
 // IAUpdateEngine::ShowUpdateQueryRequestL
 //
 // -----------------------------------------------------------------------------
 //
-void IAUpdateEngine::ShowUpdateQueryRequestL( int wgid, TUint aUid )
+void IAUpdateEngine::ShowUpdateQueryRequestL( int wgid, uint aUid )
 {
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowUpdateQueryRequestL begin");
 SetClientWgId( wgid );
-iRequestIssued = ETrue;
+mRequestIssued = true;
-iStartedFromApplication  = ETrue;
+mStartedFromApplication  = true;
-iUpdatequeryUid = aUid;
+mUpdatequeryUid = aUid;
-iUpdateNow = EFalse;
+mUpdateNow = false;
 if ( wgid > 0 )
 {
-HideApplicationInFSWL( ETrue );
+HideApplicationInFSWL( true );
 }
+mRequestType = IAUpdateUiDefines::EUpdateQuery;
-//iRequestObserver = &aObserver;
-iRequestType = IAUpdateUiDefines::EUpdateQuery;
 delete iIdle;
 iIdle = NULL;
 iIdle = CIdle::NewL( CActive::EPriorityIdle );
 // -----------------------------------------------------------------------------
 // IAUpdateEngine::StartUpdate
 //
 // -----------------------------------------------------------------------------
 //
-void IAUpdateEngine::StartUpdate( TBool aFirmwareUpdate )
+void IAUpdateEngine::StartUpdate( bool aFirmwareUpdate )
 {
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartUpdate() begin");
 if ( aFirmwareUpdate )
 {
 if ( !iFwUpdateHandler )
 // by pushing object to cleanup stack it's destructor is called if leave happens
 // so global lock issued by this instance can be released in destructor of CIAUpdateGlobalLockHandler
 CIAUpdateGlobalLockHandler* globalLockHandler = CIAUpdateGlobalLockHandler::NewLC();
 if ( !globalLockHandler->InUseByAnotherInstanceL() )
 {
-globalLockHandler->SetToInUseForAnotherInstancesL( ETrue );
+globalLockHandler->SetToInUseForAnotherInstancesL( true );
 // No need to be totally silent since the updating is started
 // by user.
-SetDefaultConnectionMethodL( EFalse );
+SetDefaultConnectionMethodL( false );
 iController->StartUpdateL();
 CleanupStack::Pop( globalLockHandler );
 delete iGlobalLockHandler;
 iGlobalLockHandler = globalLockHandler;
 //now possible deletion of iGlobalLockHandler in leave situation is handled
 // -----------------------------------------------------------------------------
 // IAUpdateEngine::SetVisibleL
 //
 // -----------------------------------------------------------------------------
 //
-void IAUpdateEngine::SetVisibleL( TBool aVisible )
+void IAUpdateEngine::SetVisibleL( bool aVisible )
 {
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::SetVisibleL() begin");
 IAUPDATE_TRACE_1("[IAUPDATE] visible: %d", aVisible );
 /*if ( aVisible )
 {
 // -----------------------------------------------------------------------------
 // IAUpdateEngine::SetClientWgId
 //
 // -----------------------------------------------------------------------------
 //
-void IAUpdateEngine::SetClientWgId( TInt aWgId )
+void IAUpdateEngine::SetClientWgId( int aWgId )
 {
 IAUPDATE_TRACE_1("[IAUPDATE] IAUpdateEngine::SetClientWgId() wgId %d", aWgId );
-iWgId = aWgId;
+mWgId = aWgId;
 }
 // -----------------------------------------------------------------------------
 // IAUpdateEngine::ClientInBackgroundL
 //
 // -----------------------------------------------------------------------------
 //
-TInt IAUpdateEngine::ClientInBackgroundL() const
+bool IAUpdateEngine::ClientInBackgroundL() const
 {
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ClientInBackgroundL() begin");
-TBool inBackground = EFalse;
+bool inBackground = false;
-if ( iWgId > 0 )
+if ( mWgId > 0 )
 {
-CArrayFixFlat<TInt>*  wgArray = new( ELeave ) CArrayFixFlat<TInt>(10);
+CArrayFixFlat<int>*  wgArray = new( ELeave ) CArrayFixFlat<int>(10);
 CleanupStack::PushL( wgArray );
 User::LeaveIfError( iEikEnv->WsSession().WindowGroupList( 0, wgArray ) );
-TInt ownWgId = iEikEnv->RootWin().Identifier();
+int ownWgId = iEikEnv->RootWin().Identifier();
-if ( ( wgArray->At( 0 ) != ownWgId ) && ( wgArray->At( 0 ) != iWgId  ) )
+if ( ( wgArray->At( 0 ) != ownWgId ) && ( wgArray->At( 0 ) != mWgId  ) )
 {
-inBackground = ETrue;
+inBackground = true;
 }
 CleanupStack::PopAndDestroy( wgArray );
 }
 IAUPDATE_TRACE_1("[IAUPDATE] IAUpdateEngine::ClientInBackgroundL() inBackground: %d", inBackground );
 return inBackground;
 qApp->quit();
 }
 // -----------------------------------------------------------------------------
+// IAUpdateEngine::dialogFinished
+// Called when dialog is finished.
+// -----------------------------------------------------------------------------
+//
+void IAUpdateEngine::dialogFinished(HbAction *action)
+{
+DialogState dialogState = mDialogState;
+mDialogState = NoDialog;
+switch ( dialogState )
+{
+case Results:
+mUiRefreshAllowed = true;
+if ( iController->ResultsInfo().iRebootAfterInstall )
+{
+ShowRebootDialogL();
+}
+else
+{
+DoPossibleApplicationClose();
+}
+break;
+case RebootQuery:
+if (action == mPrimaryAction )
+{
+RStarterSession startersession;
+if( startersession.Connect() == KErrNone )
+{
+startersession.Reset( RStarterSession::EUnknownReset );
+startersession.Close();
+}
+}
+else
+{
+DoPossibleApplicationClose();
+}
+break;
+case ShowUpdateQuery:
+if (action == mPrimaryAction)
+{
+IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::dialogFinished() Now");
+mUpdateNow = true;
+}
+else if (action == mSecondaryAction)
+{
+IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::dialogFinished() Later");
+CIAUpdateQueryHistory* updateQueryHistory = CIAUpdateQueryHistory::NewL();
+CleanupStack::PushL( updateQueryHistory );
+updateQueryHistory->SetTimeL( mUpdatequeryUid );
+CleanupStack::PopAndDestroy( updateQueryHistory );
+}
+InformRequestObserver( KErrNone );
+break;
+default:
+break;
+}
+}
+// -----------------------------------------------------------------------------
 // IAUpdateEngine::StartupComplete
 //
 // -----------------------------------------------------------------------------
 //
 void IAUpdateEngine::StartupComplete( TInt aError )
 delete iGlobalLockHandler;
 iGlobalLockHandler = NULL;
 iGlobalLockHandler = CIAUpdateGlobalLockHandler::NewL();
 if ( !iGlobalLockHandler->InUseByAnotherInstanceL() )
 {
-TBool totalSilent( EFalse );
+bool totalSilent(false);
-if ( iRequestType == IAUpdateUiDefines::ECheckUpdates )
+if ( mRequestType == IAUpdateUiDefines::ECheckUpdates )
 {
 if ( iController->Filter() )
 {
 if ( iController->Filter()->FilterParams() )
 {
 if ( iController->Filter()->FilterParams()->Refresh() )
 {
 if ( !iController->ForcedRefresh() )
 {
 //from bgchecker, make it silent
-totalSilent = ETrue;
+totalSilent = true;
 }
 }
 }
 }
 }
 SetDefaultConnectionMethodL( totalSilent );
-iGlobalLockHandler->SetToInUseForAnotherInstancesL( ETrue );
+iGlobalLockHandler->SetToInUseForAnotherInstancesL(true);
 iController->StartRefreshL();
 }
 else
 {
-RefreshCompleteL( ETrue, KErrServerBusy );
+RefreshCompleteL( true, KErrServerBusy );
 }
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartupCompleteL() end");
 IAUPDATE_TRACE_1("[IAUPDATE] error code: %d", aError );
 //removal of iGlobalLockHandler releases possible global operation lock to other IAD instances
 delete iGlobalLockHandler;
 iGlobalLockHandler = NULL;
-if ( iRequestType == IAUpdateUiDefines::ECheckUpdates )
+if ( mRequestType == IAUpdateUiDefines::ECheckUpdates )
 {
 InformRequestObserver( aError );
 }
 else
 {
 //if ( aWithViewActivation)
 //  {
 //  ActivateLocalViewL( TUid::Uid( EIAUpdateMainViewId ) );
 //  }
 CIAUpdateAgreement* agreement = CIAUpdateAgreement::NewLC();
-TBool agreementAccepted = agreement->AgreementAcceptedL();
+bool agreementAccepted = agreement->AgreementAcceptedL();
 if ( iController->ForcedRefresh() )
 {
 if ( !agreementAccepted )
 {
 agreement->SetAgreementAcceptedL();
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::UpdateCompleteL begin");
 IAUPDATE_TRACE_1("[IAUPDATE] error code: %d", aError );
 //removal of iGlobalLockHandler releases possible global operation lock to other IAD instances
 delete iGlobalLockHandler;
 iGlobalLockHandler = NULL;
-if ( iRequestType != IAUpdateUiDefines::ENoRequest )
+if ( mRequestType != IAUpdateUiDefines::ENoRequest )
 {
 InformRequestObserver( aError );
 }
 emit refresh( iController->Nodes(), iController->FwNodes(), KErrNone );
-ShowResultsDialogDeferredL();
+ShowResultsDialogL();
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::UpdateCompleteL end");
 }
 //
 // -----------------------------------------------------------------------------
 //
 void IAUpdateEngine::ShowResultsDialogL()
 {
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowResultsDialogL() begin");
-iUiRefreshAllowed = ETrue;
+mUiRefreshAllowed = false;
-IAUpdateResultsDialog resultsDialog;
+mResultsDialog = new IAUpdateResultsDialog(this);
-resultsDialog.showResults(iController->ResultsInfo());
+mResultsDialog->showResults(iController->ResultsInfo(),this,SLOT(dialogFinished(HbAction*)));
+mDialogState = Results;
-//TODO: How to recognise when application is closing
-if ( iController->ResultsInfo().iRebootAfterInstall )
-{
-HbMessageBox messageBox(HbMessageBox::MessageTypeQuestion);
-messageBox.setText(QString("Phone restart needed. Restart now?"));
-HbAction okAction("Ok");
-HbAction cancelAction("Cancel");
-messageBox.setPrimaryAction(&okAction);
-messageBox.setSecondaryAction(&cancelAction);
-messageBox.setTimeout(HbPopup::NoTimeout);
-messageBox.show();
-/*HbAction *selectedAction = messageBox.exec();
-if (selectedAction == messageBox.primaryAction())
-{
-RStarterSession startersession;
-if( startersession.Connect() == KErrNone )
-{
-startersession.Reset( RStarterSession::EUnknownReset );
-startersession.Close();
-return;
-}
-}*/
-}
-if ( iStartedFromApplication &&
-iController->ResultsInfo().iCountCancelled == 0 &&
-iController->ResultsInfo().iCountFailed == 0 )
-{
-qApp->quit();
-}
-IAUPDATE_TRACE_1("[IAUPDATE] IAUpdateEngine::ShowResultsDialogL() nodes count: %d", iController->Nodes().Count() );
-IAUPDATE_TRACE_1("[IAUPDATE] IAUpdateEngine::ShowResultsDialogL() fw nodes: %d", iController->FwNodes().Count() );
-//exit from result view if there are no update left
-if ( iController->Nodes().Count() == 0 && iController->FwNodes().Count() == 0 )
-{
-qApp->quit();
-}
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowResultsDialogL() end");
 }
 // -----------------------------------------------------------------------------
-// IAUpdateEngin::ShowResultsDialogDeferredL
+// IAUpdateEngine::ShowRebootDialogL
 //
 // -----------------------------------------------------------------------------
 //
-void IAUpdateEngine::ShowResultsDialogDeferredL()
+void IAUpdateEngine::ShowRebootDialogL()
 {
-IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowResultsDialogDeferredL() begin");
+IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowRebootDialogL() begin");
-delete iIdle;
-iIdle = NULL;
+HbMessageBox *messageBox = new HbMessageBox(HbMessageBox::MessageTypeQuestion);
-iIdle = CIdle::NewL( CActive::EPriorityIdle );
+messageBox->setText(QString("Phone restart needed. Restart now?"));
-iIdle->Start( TCallBack( ShowResultsDialogCallbackL, this ) );
+int actionCount = messageBox->actions().count();
-iUiRefreshAllowed = EFalse;
+for (int i=actionCount-1; i >= 0; i--)
-IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowResultsDialogDeferredL() end");
+{
-}
+messageBox->removeAction(messageBox->actions().at(i));
+}
+mPrimaryAction = NULL;
+mPrimaryAction = new HbAction("Ok");
+HbAction *secondaryAction = NULL;
+secondaryAction = new HbAction("Cancel");
+messageBox->addAction(mPrimaryAction);
+messageBox->addAction(secondaryAction);
+messageBox->setTimeout(HbPopup::NoTimeout);
+messageBox->setAttribute(Qt::WA_DeleteOnClose);
+messageBox->open(this, SLOT(dialogFinished(HbAction*)));
+mDialogState = RebootQuery;
+IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowRebootDialogL() end");
+}
 // -----------------------------------------------------------------------------
 // IAUpdateEngine::InformRequestObserver
 //
 // -----------------------------------------------------------------------------
 //
-void IAUpdateEngine::InformRequestObserver( TInt aError )
+void IAUpdateEngine::InformRequestObserver( int aError )
 {
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::InformRequestObserver() begin");
 //if ( iRequestObserver )
-if ( iRequestIssued )
+if ( mRequestIssued )
 {
 if ( iController->ClosingAllowedByClient() )
 {
-if ( iRequestType != IAUpdateUiDefines::ENoRequest )
+if ( mRequestType != IAUpdateUiDefines::ENoRequest )
 {
 //                if ( iRequestType == IAUpdateUiDefines::EUpdateQuery && iUpdateNow )
 //                    {
 //                  if ( !iBackgroundTimer )
 //                        {
 iEikEnv->RootWin().SetOrdinalPosition( -1, ECoeWinPriorityNeverAtFront );
 //                    }
 }
 }
-switch ( iRequestType )
+switch ( mRequestType )
 {
 case IAUpdateUiDefines::ENoRequest:
 {
 mServiceProvider->completeLauncherLaunch( aError );
 break;
 }
 break;
 }
 case IAUpdateUiDefines::EUpdateQuery:
 {
-mServiceProvider->completeUpdateQuery( iUpdateNow, aError );
+mServiceProvider->completeUpdateQuery( mUpdateNow, aError );
 break;
 }
 default:
 {
 break;
 }
 }
-//iRequestObserver = NULL;
+mRequestIssued = false;
-iRequestIssued = EFalse;
 }
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::InformRequestObserver() end");
 }
 // ---------------------------------------------------------------------------
 // IAUpdateEngine::SetDefaultConnectionMethodL
 // Sets the connection method for the update network connection.
 // ---------------------------------------------------------------------------
 //
-void IAUpdateEngine::SetDefaultConnectionMethodL( TBool aTotalSilent )
+void IAUpdateEngine::SetDefaultConnectionMethodL( bool aTotalSilent )
 {
 if ( aTotalSilent )
 {
 // from back ground checker, choose the IAP to make the internet access silent
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::SetDefaultConnectionMethodL() begin");
-TUint32 connectionMethodId( 0 );
+uint connectionMethodId( 0 );
-TInt connMethodId( 0 );
+int connMethodId( 0 );
 // Let's first check whether cenrep contains SNAP id other than zero
 CRepository* cenrep( CRepository::NewLC( KCRUidIAUpdateSettings ) );
 User::LeaveIfError(
 cenrep->Get( KIAUpdateAccessPoint, connMethodId ) );
 }
 else
 {
 // from grid, use the old logic
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::SetDefaultConnectionMethodL() begin");
-TUint32 connectionMethodId( 0 );
+uint connectionMethodId( 0 );
-TInt connMethodId( 0 );
+int connMethodId( 0 );
 // Set initial value to always ask
-TInt connectionMethodType( TIAUpdateConnectionMethod::EConnectionMethodTypeAlwaysAsk );
+int connectionMethodType( TIAUpdateConnectionMethod::EConnectionMethodTypeAlwaysAsk );
-TBool needSaving(EFalse);
+bool needSaving(false);
 // Let's first check whether cenrep contains SNAP id other than zero
 CRepository* cenrep( CRepository::NewLC( KCRUidIAUpdateSettings ) );
 User::LeaveIfError(
 cenrep->Get( KIAUpdateAccessPoint, connMethodId ) );
 cmManagerExt.OpenL();
 CleanupClosePushL( cmManagerExt );
 iDestIdArray.Reset();
 cmManagerExt.AllDestinationsL( iDestIdArray );
-for ( TInt i = 0; i< iDestIdArray.Count(); i++ )
+for ( int i = 0; i< iDestIdArray.Count(); i++ )
 {
 RCmDestinationExt dest = cmManagerExt.DestinationL( iDestIdArray[i] );
 CleanupClosePushL( dest );
 if ( dest.MetadataL( CMManager::ESnapMetadataInternet ) )
 {
 // Check whether Internet SNAP contains any IAP.
 if ( dest.ConnectionMethodCount() > 0 )
 {
 connectionMethodId = iDestIdArray[i];
-needSaving = ETrue;
+needSaving = true;
 IAUPDATE_TRACE_1("[IAUPDATE] connectionMethodId: %d", connectionMethodId );
 }
 CleanupStack::PopAndDestroy( &dest );
 break;
 }
 connectionMethodType = TIAUpdateConnectionMethod::EConnectionMethodTypeDestination;
 // Save to cenrep if needed
 if ( needSaving )
 {
 cenrep = CRepository::NewLC( KCRUidIAUpdateSettings );
-TInt err = cenrep->StartTransaction( CRepository::EReadWriteTransaction );
+int err = cenrep->StartTransaction( CRepository::EReadWriteTransaction );
 User::LeaveIfError( err );
 cenrep->CleanupCancelTransactionPushL();
 connMethodId = connectionMethodId;
 err = cenrep->Set( KIAUpdateAccessPoint, connMethodId );
 // ---------------------------------------------------------------------------
 // IAUpdateEngine::GetBestIAPInAllSNAPsL
 // Sets the best IAP from all snaps
 // ---------------------------------------------------------------------------
 //
-TUint32 IAUpdateEngine::GetBestIAPInAllSNAPsL( RCmManagerExt& aCmManagerExt  )
+uint IAUpdateEngine::GetBestIAPInAllSNAPsL( RCmManagerExt& aCmManagerExt  )
 {
 //go with internet SNAP first.
-TUint32 IAPID = 0;
+uint IAPID = 0;
 IAPID = GetBestIAPInInternetSNAPL( aCmManagerExt );
 if ( IAPID )
 {
 return IAPID;
 //select IAP from rest of the SNAPs
 iDestIdArray.Reset();
 aCmManagerExt.AllDestinationsL( iDestIdArray );
-for ( TInt i = 0; i< iDestIdArray.Count(); i++ )
+for ( int i = 0; i< iDestIdArray.Count(); i++ )
 {
-TUint32 SNAPID = iDestIdArray[i];
+uint SNAPID = iDestIdArray[i];
 IAPID = GetBestIAPInThisSNAPL( aCmManagerExt, SNAPID );
 if ( IAPID )
 {
 break;
 }
 // ---------------------------------------------------------------------------
 // IAUpdateEngine::GetBestIAPInInternetSNAPL
 // Sets the best IAP from internet snap
 // ---------------------------------------------------------------------------
 //
-TUint32 IAUpdateEngine::GetBestIAPInInternetSNAPL( RCmManagerExt& aCmManagerExt  )
+uint IAUpdateEngine::GetBestIAPInInternetSNAPL( RCmManagerExt& aCmManagerExt  )
 {
 //select IAP from Internet SNAP
 iDestIdArray.Reset();
 aCmManagerExt.AllDestinationsL( iDestIdArray );
-TUint32 InternetSNAPID = 0;
+uint InternetSNAPID = 0;
-for ( TInt i = 0; i< iDestIdArray.Count(); i++ )
+for ( int i = 0; i< iDestIdArray.Count(); i++ )
 {
 RCmDestinationExt dest = aCmManagerExt.DestinationL( iDestIdArray[i] );
 CleanupClosePushL( dest );
 if ( dest.MetadataL( CMManager::ESnapMetadataInternet ) )
 // ---------------------------------------------------------------------------
 // IAUpdateEngine::GetBestIAPInThisSNAPL
 // Sets the best IAP from the given snap
 // ---------------------------------------------------------------------------
 //
-TUint32 IAUpdateEngine::GetBestIAPInThisSNAPL( RCmManagerExt& aCmManagerExt, TUint32 aSNAPID  )
+uint IAUpdateEngine::GetBestIAPInThisSNAPL( RCmManagerExt& aCmManagerExt, uint aSNAPID  )
 {
 //get all usable IAPs
 TConnMonIapInfoBuf iapInfo;
 TRequestStatus status;
 RCmDestinationExt dest = aCmManagerExt.DestinationL( aSNAPID );
 CleanupClosePushL( dest );
 // Check whether the SNAP contains any IAP.
-for  (TInt i = 0; i < dest.ConnectionMethodCount(); i++ )
+for  (int i = 0; i < dest.ConnectionMethodCount(); i++ )
 {
 RCmConnectionMethodExt cm =  dest.ConnectionMethodL( i );
 CleanupClosePushL( cm );
-TUint32 iapid= cm.GetIntAttributeL( CMManager::ECmIapId );
+uint iapid= cm.GetIntAttributeL( CMManager::ECmIapId );
-for ( TInt i = 0; i < iapInfo().iCount; i++ )
+for ( int i = 0; i < iapInfo().iCount; i++ )
 {
 if ( iapInfo().iIap[i].iIapId == iapid )
 {
 CleanupStack::PopAndDestroy( 2 ); //cm & dest;
 return iapid;
 CIAUpdateQueryHistory* updateQueryHistory = CIAUpdateQueryHistory::NewL();
 // Get the delay information from the controller that has read it from
 // the config file.
 updateQueryHistory->SetDelay( iController->ConfigData().QueryHistoryDelayHours() );
 CleanupStack::PushL( updateQueryHistory );
-if ( !updateQueryHistory->IsDelayedL( iUpdatequeryUid ) )
+bool isDelayed( updateQueryHistory->IsDelayedL( mUpdatequeryUid ) );
+CleanupStack::PopAndDestroy( updateQueryHistory );
+if ( !isDelayed )
 {
 if ( ClientInBackgroundL() )
 {
 iEikEnv->RootWin().SetOrdinalPosition( -1, ECoeWinPriorityNormal );
 }
 else
 {
 iEikEnv->RootWin().SetOrdinalPosition( 0, ECoeWinPriorityNormal );
 }
-HbMessageBox messageBox(HbMessageBox::MessageTypeQuestion);
+HbMessageBox *messageBox = new HbMessageBox(HbMessageBox::MessageTypeQuestion);
-messageBox.setText(QString("Application update is available from Nokia. Update?"));
+messageBox->setText(QString("Application update is available from Nokia. Update?"));
-HbAction nowAction("Now");
+int actionCount = messageBox->actions().count();
-HbAction laterAction("Later");
+for (int i=actionCount-1; i >= 0; i--)
-messageBox.setPrimaryAction(&nowAction);
+{
-messageBox.setSecondaryAction(&laterAction);
+messageBox->removeAction(messageBox->actions().at(i));
-messageBox.setTimeout(HbPopup::NoTimeout);
+}
-messageBox.show();
+mPrimaryAction = NULL;
-iUpdateNow = ETrue;
+mPrimaryAction = new HbAction("Now");
-//HbAction *selectedAction = messageBox.exec();
+mSecondaryAction = NULL;
+mSecondaryAction = new HbAction("Later");
-/*if (selectedAction == messageBox.primaryAction())
+messageBox->addAction(mPrimaryAction);
-{
+messageBox->addAction(mSecondaryAction);
-IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowUpdateQueryL() Now");
+messageBox->setTimeout(HbPopup::NoTimeout);
-iUpdateNow = ETrue;
+messageBox->setAttribute(Qt::WA_DeleteOnClose);
-}
+messageBox->open(this, SLOT(dialogFinished(HbAction*)));
-else if (selectedAction == messageBox.secondaryAction())
+mDialogState = ShowUpdateQuery;
-{
+}
-IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowUpdateQueryL() Later");
+else
-updateQueryHistory->SetTimeL( iUpdatequeryUid );
+{
-}*/
+InformRequestObserver( KErrNone );
 }
-CleanupStack::PopAndDestroy( updateQueryHistory );
-InformRequestObserver( KErrNone );
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowUpdateQueryL() end");
 }
 // -----------------------------------------------------------------------------
 // IAUpdateEngine::HideApplicationInFSWL
 //
 // -----------------------------------------------------------------------------
 //
-void IAUpdateEngine::HideApplicationInFSWL( TBool aHide ) const
+void IAUpdateEngine::HideApplicationInFSWL( bool aHide ) const
 {
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::HideApplicationInFSW() begin");
 IAUPDATE_TRACE_1("[IAUPDATE] hide: %d", aHide );
-TInt id = iEikEnv->RootWin().Identifier();
+int id = iEikEnv->RootWin().Identifier();
 CApaWindowGroupName* wgName = CApaWindowGroupName::NewLC(
 iEikEnv->WsSession(), id );
 wgName->SetHidden( aHide );
 wgName->SetWindowGroupName( iEikEnv->RootWin() );
 CleanupStack::PopAndDestroy( wgName );
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::HideApplicationInFSW() end");
 }
-// ---------------------------------------------------------------------------
-// IAUpdateEngine::ShowResultsDialogCallbackL
-// ---------------------------------------------------------------------------
-//
-TInt IAUpdateEngine::ShowResultsDialogCallbackL( TAny* aPtr )
-{
-IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowResultsDialogCallbackL() begin");
-IAUpdateEngine* engine = static_cast<IAUpdateEngine*>( aPtr );
-//TRAPD( err, engine->ShowResultsDialogL() );
-TRAP_IGNORE( engine->ShowResultsDialogL() );
-//appUI->HandleLeaveErrorL( err );
-IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ShowResultsDialogCallbackL() end");
-return KErrNone;
-}
 // ---------------------------------------------------------------------------
 // IAUpdateEngine::UpdateQueryCallbackL
 // ---------------------------------------------------------------------------
 //
 TInt IAUpdateEngine::AutomaticCheckCallbackL( TAny* aPtr )
 {
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::AutomaticCheckCallbackL() begin");
 IAUpdateEngine* engine= static_cast<IAUpdateEngine*>( aPtr );
-TInt err = KErrNone;
+int err = KErrNone;
-CIAUpdateAutomaticCheck* automaticCheck = NULL;
+if ( !engine->iAutomaticCheck )
-TRAP( err, automaticCheck = CIAUpdateAutomaticCheck::NewL() );
+{
+TRAP( err, engine->iAutomaticCheck = CIAUpdateAutomaticCheck::NewL() );
+}
 if ( err != KErrNone )
 {
 engine->HandleLeaveErrorL( err );
 }
 else
 {
-CleanupStack::PushL( automaticCheck );
+TRAP( err, engine->iAutomaticCheck->AcceptAutomaticCheckL() );
-TRAP( err, automaticCheck->AcceptAutomaticCheckL() );
 if ( err != KErrNone )
 {
 engine->HandleLeaveErrorL( err );
 }
 }
-CleanupStack::PopAndDestroy( automaticCheck );
 IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::AutomaticCheckCallbackL() end");
 return KErrNone;
 }
+// ---------------------------------------------------------------------------
+// IAUpdateEngine::DoPossibleApplicationClose()
+// ---------------------------------------------------------------------------
+//
+void IAUpdateEngine::DoPossibleApplicationClose()
+{
+//exit from result view if there are no update left
+if ( iController->Nodes().Count() == 0 && iController->FwNodes().Count() == 0 )
+{
+qApp->quit();
+}
+else if ( mStartedFromApplication &&
+iController->ResultsInfo().iCountCancelled == 0 &&
+iController->ResultsInfo().iCountFailed == 0 )
+{
+qApp->quit();
+}
+}

changeset 42	d17dc5398051
parent 33	8110bf1194d1
child 44	329d304c1aa1
child 52	92f864ef0288