diff -r 7333d7932ef7 -r 8b7f4e561641 iaupdate/IAD/ui/src/iaupdateappui.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/iaupdate/IAD/ui/src/iaupdateappui.cpp Wed Sep 01 12:22:02 2010 +0100 @@ -0,0 +1,1633 @@ +/* +* Copyright (c) 2007-2010 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: This module contains the implementation of CIAUpdateAppUi class +* member functions. +* +*/ + + + +// INCLUDES +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + + +#include "iaupdateappui.h" +#include "iaupdatemainview.h" +#include "iaupdatehistoryview.h" +#include "iaupdate.hrh" +#include "iaupdatenode.h" +#include "iaupdatefwnode.h" +#include "iaupdatebasenode.h" +#include "iaupdateuicontroller.h" +#include "iaupdaterequestobserver.h" +#include "iaupdateserver.h" +#include "iaupdatestatusdialog.h" +#include "iaupdatedetailsdialog.h" +#include "iaupdatefwdetailsdialog.h" +#include "iaupdatesettingdialog.h" +#include "iaupdateprivatecrkeys.h" +#include "iaupdatestarter.h" +#include "iaupdateuiconfigdata.h" +#include "iaupdateagreement.h" +#include "iaupdateautomaticcheck.h" +#include "iaupdatequeryhistory.h" +#include "iaupdatedialogutil.h" +#include "iaupdategloballockhandler.h" +#include "iaupdatenodefilter.h" +#include "iaupdateuitimer.h" +#include "iaupdateagreement.h" +#include "iaupdatedebug.h" + + +const TUint KSWInstSvrUid = 0x101F875A; + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::ConstructL() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ConstructL() begin"); + + TInt ownWgId = iEikonEnv->RootWin().Identifier(); + RArray wgList; + iEikonEnv->WsSession().WindowGroupList( &wgList ); + TBool chained = EFalse; + for ( TInt i = 0; i < wgList.Count() && !chained ; i++ ) + { + if ( wgList[i].iId == ownWgId && wgList[i].iParentId > 0 ) + { + chained = ETrue; + } + } + wgList.Reset(); + if ( chained ) + { + BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible ); + } + else + { + iEikonEnv->RootWin().SetOrdinalPosition( -1, ECoeWinPriorityNeverAtFront ); + BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible ); + StatusPane()->MakeVisible( EFalse ); + } + + iController = CIAUpdateUiController::NewL( *this ); + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ConstructL() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::CIAUpdateAppUi +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CIAUpdateAppUi::CIAUpdateAppUi(): iIsDMSet( EFalse ), iUiRefreshAllowed( ETrue ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::CIAUpdateAppUi()"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::~CIAUpdateAppUi +// Destructor +// ----------------------------------------------------------------------------- +// +CIAUpdateAppUi::~CIAUpdateAppUi() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::~CIAUpdateAppUi() begin"); + iShowStatusDialogAgain = EFalse; + delete iGlobalLockHandler; + iDestIdArray.Reset(); + delete iController; + delete iIdle; + delete iIdleAutCheck; + delete iForegroundTimer; + delete iBackgroundTimer; + delete iDialogParam; + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::~CIAUpdateAppUi() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::StartedByLauncherL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::StartedByLauncherL( MIAUpdateRequestObserver& aObserver, + TBool aRefreshFromNetworkDenied ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::StartedByLauncherL() begin"); + iRequestObserver = &aObserver; + iRequestType = IAUpdateUiDefines::ENoRequest; + iController->SetRequestType( iRequestType ); + SetVisibleL( ETrue ); + CIAUpdateParameters* params = iController->ParamsReadAndRemoveFileL(); + iController->CheckUpdatesDeferredL( params, aRefreshFromNetworkDenied ); + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::StartedByLauncherL() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::CheckUpdatesRequestL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::CheckUpdatesRequestL( MIAUpdateRequestObserver& aObserver, + CIAUpdateParameters* aFilterParams, + TBool aForcedRefresh ) + + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::CheckUpdatesRequestL() begin"); + iStartedFromApplication = ETrue; + CleanupStack::PushL( aFilterParams ); + if ( iWgId > 0 ) + { + HideApplicationInFSWL( ETrue ); + } + CleanupStack::Pop( aFilterParams ); + + if ( !aFilterParams->ShowProgress() ) + { + iEikonEnv->RootWin().SetOrdinalPosition( -1, ECoeWinPriorityNeverAtFront ); + } + + iRequestObserver = &aObserver; + iRequestType = IAUpdateUiDefines::ECheckUpdates; + iController->SetRequestType( iRequestType ); + IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateAppUi::CheckUpdatesRequestL() Forced refresh: %d", aForcedRefresh ); + iController->SetForcedRefresh( aForcedRefresh ); + iController->CheckUpdatesDeferredL( aFilterParams, EFalse ); + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::CheckUpdatesRequestL() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::ShowUpdatesRequestL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::ShowUpdatesRequestL( MIAUpdateRequestObserver& aObserver, + CIAUpdateParameters* aFilterParams ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowUpdatesRequestL() begin"); + delete iBackgroundTimer; + iBackgroundTimer = NULL; + iStartedFromApplication = ETrue; + CleanupStack::PushL( aFilterParams ); + if ( iWgId > 0 ) + { + HideApplicationInFSWL( ETrue ); + } + + StatusPane()->MakeVisible( ETrue ); + iEikonEnv->RootWin().SetOrdinalPosition( 0, ECoeWinPriorityNormal ); + + iRequestObserver = &aObserver; + iRequestType = IAUpdateUiDefines::EShowUpdates; + iController->SetRequestType( iRequestType ); + + + if ( !iMainView ) + { + iMainView = CIAUpdateMainView::NewL( ClientRect() ); + AddViewL( iMainView ); + } + + + // 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 ); + CleanupStack::Pop( globalLockHandler ); + CleanupStack::Pop( aFilterParams ); + CleanupStack::PushL( globalLockHandler ); + iController->CheckUpdatesDeferredL( aFilterParams, EFalse ); + CleanupStack::Pop( globalLockHandler ); + delete iGlobalLockHandler; + iGlobalLockHandler = globalLockHandler; + //now possible deletion of iGlobalLockHandler in leave situation is handled + //in HandleLeaveErrorL() and HandleLeaveErrorWithoutLeave methods. + } + else + { + CleanupStack::PopAndDestroy( globalLockHandler ); + CleanupStack::PopAndDestroy( aFilterParams ); + // locked by another IAD instance, nothing else to do than just complete client's request. + InformRequestObserver( KErrNone ); + } + + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowUpdatesRequestL() end"); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::ShowUpdateQueryRequestL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::ShowUpdateQueryRequestL( MIAUpdateRequestObserver& aObserver, + TUint aUid ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowUpdateQueryRequestL begin"); + iStartedFromApplication = ETrue; + iUpdatequeryUid = aUid; + iUpdateNow = EFalse; + if ( iWgId > 0 ) + { + HideApplicationInFSWL( ETrue ); + } + + iRequestObserver = &aObserver; + iRequestType = IAUpdateUiDefines::EUpdateQuery; + + + delete iIdle; + iIdle = NULL; + iIdle = CIdle::NewL( CActive::EPriorityIdle ); + iIdle->Start( TCallBack( UpdateQueryCallbackL, this ) ); + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowUpdateQueryRequestL end") + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::HandleObserverRemoval +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::HandleObserverRemoval() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleObserverRemoval() begin"); + iRequestObserver = NULL; + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleObserverRemoval() end"); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::TextLinkL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::TextLinkL( TInt /*aLinkId*/ ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::TextLinkL() begin"); + TRAPD( err, HandleTextLinkL() ); + if ( err != KErrNone ) + { + HandleLeaveErrorL( err ); + } + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::TextLinkL() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::HandleCommandL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::HandleCommandL( TInt aCommand ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() begin"); + IAUPDATE_TRACE_1("[IAUPDATE] command id: %d", aCommand ); + + switch(aCommand) + { + case EIAUpdateCmdStartUpdate: + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EIAUpdateCmdStartUpdate"); + + + // 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 ); + // No need to be totally silent since the updating is started + // by user. + SetDefaultConnectionMethodL( EFalse ); + iController->StartUpdateL(); + CleanupStack::Pop( globalLockHandler ); + delete iGlobalLockHandler; + iGlobalLockHandler = globalLockHandler; + //now possible deletion of iGlobalLockHandler in leave situation is handled + //in HandleLeaveErrorL() and HandleLeaveErrorWithoutLeave methods. + } + else + { + CleanupStack::PopAndDestroy( globalLockHandler ); + } + break; + } + + case EIAUpdateCmdSettings: + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EIAUpdateCmdSettings"); + CIAUpdateSettingDialog::ShowDialogL(); + break; + } + + case EIAUpdateCmdUpdateDetails: + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EIAUpdateCmdUpdateDetails"); + + if ( iMainView->GetCurrentNode()->NodeType() == MIAUpdateAnyNode::ENodeTypeNormal ) + { + TIAUpdateDialogParam param; + param.iNode = static_cast( iMainView->GetCurrentNode() ); + CIAUpdateDetailsDialog::ShowDialogL( ¶m ); + } + + if (iMainView->GetCurrentNode()->NodeType() == MIAUpdateAnyNode::ENodeTypeFw ) + { + //this is changed because of the new requirement: when both NSU and FOTA available, only show FOTA in details + + MIAUpdateFwNode* node = static_cast( iMainView->GetCurrentNode() ); + CIAUpdateFwDetailsDialog::ShowDialogL( node ); + } + + break; + } + + case EIAUpdateCmdMarkedUpdateDetails: + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EIAUpdateCmdUpdateDetails"); + + if ( iMainView->GetSelectedNode()->NodeType() == MIAUpdateAnyNode::ENodeTypeNormal ) + { + TIAUpdateDialogParam param; + param.iNode = static_cast( iMainView->GetSelectedNode() ); + CIAUpdateDetailsDialog::ShowDialogL( ¶m ); + } + + if (iMainView->GetSelectedNode()->NodeType() == MIAUpdateAnyNode::ENodeTypeFw ) + { + //this is changed because of the new requirement: when both NSU and FOTA available, only show FOTA in details + + MIAUpdateFwNode* node = static_cast( iMainView->GetSelectedNode() ); + CIAUpdateFwDetailsDialog::ShowDialogL( node ); + } + + break; + } + + + // History view + case EIAUpdateCmdUpdateHistory: + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EIAUpdateCmdUpdateHistory"); + if ( !iHistoryView ) + { + iHistoryView = + CIAUpdateHistoryView::NewL( iController->HistoryL() ); + AddViewL( iHistoryView ); + } + ActivateLocalViewL( TUid::Uid( EIAUpdateHistoryViewId ) ); + break; + } + + case EIAUpdateCmdDisclaimer: + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EIAUpdateCmdDisclaimer"); + CIAUpdateAgreement* agreement = CIAUpdateAgreement::NewLC(); + agreement->ShowAgreementL(); + CleanupStack::PopAndDestroy( agreement); + break; + } + + case EAknCmdHelp: + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EAknCmdHelp"); + HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(), AppHelpContextL() ); + break; + } + + case EEikCmdExit: + case EAknCmdExit: + case EAknSoftkeyExit: + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() Exit"); + if (iController ) + { + iController->CancelOperation(); + if ( iController->Starter() ) + { + iController->Starter()->BringToForegroundL(); + } + } + if ( iRequestObserver ) + { + InformRequestObserver( KErrCancel ); + } + Exit(); + break; + } + + case EIAUpdateCmdHistoryViewExit: + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EIAUpdateCmdHistoryViewExit"); + ActivateLocalViewL( TUid::Uid( EIAUpdateMainViewId ) ); + break; + + default: + { + break; + } + } + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() end") + } + +// ----------------------------------------------------------------------------- +// CIAUpdateppUi::HandleWsEventL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::HandleWsEventL( const TWsEvent& aEvent, CCoeControl* aDestination ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleWsEventL() begin"); + CAknViewAppUi::HandleWsEventL( aEvent, aDestination ); + if ( aEvent.Type() == EEventWindowGroupListChanged ) + { + IAUPDATE_TRACE("[IAUPDATE] Window group list changed"); + + RWindowGroup owngroup; + TInt ownWgId = iEikonEnv->RootWin().Identifier(); + TApaTaskList tasklist( iEikonEnv->WsSession() ); + + TApaTask task = tasklist.FindApp( TUid::Uid( KSWInstSvrUid ) ); + + if ( task.Exists() ) + { + IAUPDATE_TRACE("[IAUPDATE] Installer task exists"); + + TInt instUiWgId = task.WgId(); + TInt ownPosition = KErrNotFound; + TInt instUiPosition = KErrNotFound; + CArrayFixFlat* wgArray = new(ELeave)CArrayFixFlat(10); + CleanupStack::PushL( wgArray ); + User::LeaveIfError( iEikonEnv->WsSession().WindowGroupList( 0, wgArray ) ); + for ( TInt i = 0; i < wgArray->Count(); i++ ) + { + if ( wgArray->At(i) == ownWgId ) + { + IAUPDATE_TRACE_1("[IAUPDATE] ownPosition: %d", i); + ownPosition = i; + } + else if ( wgArray->At(i) == instUiWgId ) + { + IAUPDATE_TRACE_1("[IAUPDATE] instUiPosition: %d", i); + instUiPosition = i; + } + } + CleanupStack::PopAndDestroy( wgArray ); + if ( ownPosition == 0 && iInstUiOnTop ) + { + // IAD is now topmost. In the case Installer UI was previously on the top of IAD + // bring Installer UI foreground + IAUPDATE_TRACE("[IAUPDATE] instUi to foreground"); + task.BringToForeground(); + iInstUiOnTop = EFalse; + } + else + { + if ( instUiPosition < ownPosition && + instUiPosition != KErrNotFound && + ownPosition != KErrNotFound ) + { + // Installer UI is on the top of IAD, i.e. it's showing FILETEXT dialog + IAUPDATE_TRACE("[IAUPDATE] instUi is on top of IAD"); + iInstUiOnTop = ETrue; + } + else + { + IAUPDATE_TRACE("[IAUPDATE] iInstUiOnTop false"); + iInstUiOnTop = EFalse; + } + } + } + else + { + IAUPDATE_TRACE("[IAUPDATE] No task. iInstUiOnTop false."); + iInstUiOnTop = EFalse; + } + } + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleWsEventL() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::StartupComplete +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::StartupComplete( TInt aError ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::StartupComplete() begin"); + IAUPDATE_TRACE_1("[IAUPDATE] error code: %d", aError); + + if( aError != KErrNone ) + { + HandleLeaveErrorWithoutLeave( aError ); + } + else + { + TRAPD( err, StartupCompleteL() ); + if( err != KErrNone ) + { + HandleLeaveErrorWithoutLeave( err ); + } + } + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::StartupComplete() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::StartupCompleteL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::StartupCompleteL() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::StartupCompleteL() begin"); + + delete iGlobalLockHandler; + iGlobalLockHandler = NULL; + iGlobalLockHandler = CIAUpdateGlobalLockHandler::NewL(); + if ( !iGlobalLockHandler->InUseByAnotherInstanceL() ) + { + TBool totalSilent( EFalse ); + if ( iRequestType == IAUpdateUiDefines::ECheckUpdates ) + { + if ( iController->Filter() ) + { + if ( iController->Filter()->FilterParams() ) + { + if ( iController->Filter()->FilterParams()->Refresh() ) + { + if ( !iController->ForcedRefresh() ) + { + //from bgchecker, make it silent + totalSilent = ETrue; + } + } + } + } + } + SetDefaultConnectionMethodL( totalSilent ); + iGlobalLockHandler->SetToInUseForAnotherInstancesL( ETrue ); + iController->StartRefreshL(); + } + else + { + RefreshCompleteL( ETrue, KErrServerBusy ); + } + + + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::StartupCompleteL() end"); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::HandleLeaveErrorL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::HandleLeaveErrorL( TInt aError ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleLeaveErrorL() begin"); + //removal of iGlobalLockHandler releases possible global operation lock to other IAD instances + delete iGlobalLockHandler; + iGlobalLockHandler = NULL; + // client request is completed before leave in case of leave error + if ( aError != KErrNone ) + { + InformRequestObserver( aError ); + User::Leave( aError ); + } + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleLeaveErrorL() end"); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::HandleLeaveErrorWithoutLeave +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::HandleLeaveErrorWithoutLeave( TInt aError ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleLeaveErrorWithoutLeave() begin"); + //removal of iGlobalLockHandler releases possible global operation lock to other IAD instances + delete iGlobalLockHandler; + iGlobalLockHandler = NULL; + if ( aError != KErrNone ) + { + InformRequestObserver( aError ); + } + if ( aError == KErrDiskFull ) + { + TRAP_IGNORE( ShowGlobalErrorNoteL( aError ) ); + } + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleLeaveErrorWithoutLeave end"); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::RefreshCompleteL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::RefreshCompleteL( TBool aWithViewActivation, TInt aError ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::RefreshCompleteL() 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::ECheckUpdates ) + { + InformRequestObserver( aError ); + } + else + { + RefreshL( aError ); + if ( aWithViewActivation) + { + ActivateLocalViewL( TUid::Uid( EIAUpdateMainViewId ) ); + } + CIAUpdateAgreement* agreement = CIAUpdateAgreement::NewLC(); + TBool agreementAccepted = agreement->AgreementAcceptedL(); + if ( iController->ForcedRefresh() ) + { + if ( !agreementAccepted ) + { + agreement->SetAgreementAcceptedL(); + } + } + CleanupStack::PopAndDestroy( agreement ); + // By calling CIdle possible waiting dialog can be closed before + // automatic check where a new dialog may be launched + delete iIdleAutCheck; + iIdleAutCheck = NULL; + iIdleAutCheck = CIdle::NewL( CActive::EPriorityIdle ); + iIdleAutCheck->Start( TCallBack( AutomaticCheckCallbackL, this ) ); + } + + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::RefreshCompleteL() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::UpdateCompleteL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::UpdateCompleteL( TInt aError ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::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 ) + { + InformRequestObserver( aError ); + } + + RefreshL( KErrNone ); + + ShowStatusDialogDeferredL(); + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::UpdateCompleteL end"); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::ShowStatusDialogL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::ShowStatusDialogL() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowStatusDialogL() begin"); + + + if ( !iDialogParam ) + { + iDialogParam = new( ELeave ) TIAUpdateDialogParam; + } + + if ( !iShowStatusDialogAgain ) + { + TIAUpdateResultsInfo resultsInfo( iController->ResultsInfo() ); + iDialogParam->iCountCancelled = resultsInfo.iCountCancelled; + iDialogParam->iCountFailed = resultsInfo.iCountFailed; + iDialogParam->iCountSuccessfull = resultsInfo.iCountSuccessfull; + iDialogParam->iShowCloseAllText = resultsInfo.iFileInUseError; + iRebootAfterInstall = resultsInfo.iRebootAfterInstall; + iDialogParam->iLinkObserver = this; + } + + iShowStatusDialogAgain = EFalse; + iUiRefreshAllowed = ETrue; + TInt ret = CIAUpdateStatusDialog::ShowDialogL( iDialogParam ); + if ( ret == EAknSoftkeyOk && iRebootAfterInstall ) + { + TInt rebootRet = IAUpdateDialogUtil::ShowConfirmationQueryL( + R_IAUPDATE_PHONE_RESTART_QUERY, + R_AVKON_SOFTKEYS_OK_CANCEL__OK ); + if ( rebootRet == EAknSoftkeyOk ) + { + RStarterSession startersession; + if( startersession.Connect() == KErrNone ) + { + startersession.Reset( RStarterSession::EUnknownReset ); + startersession.Close(); + return; + } + } + } + if ( ret == EAknSoftkeyOk && + iStartedFromApplication && + iDialogParam->iCountCancelled == 0 && + iDialogParam->iCountFailed == 0 ) + { + HandleCommandL( EEikCmdExit ); + } + + IAUPDATE_TRACE_1("[IAUPDATE] nodes count: %d", iController->Nodes().Count() ); + IAUPDATE_TRACE_1("[IAUPDATE] fw nodes: %d", iController->FwNodes().Count() ); + //exit from result view if there are no update left + if ( ret == EAknSoftkeyOk && (iController->Nodes().Count() == 0) && (iController->FwNodes().Count() == 0) ) + { + HandleCommandL( EEikCmdExit ); + } + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowStatusDialogL() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::ShowStatusDialogDeferredL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::ShowStatusDialogDeferredL() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowStatusDialogDeferredL() begin"); + delete iIdle; + iIdle = NULL; + iIdle = CIdle::NewL( CActive::EPriorityIdle ); + iIdle->Start( TCallBack( ShowStatusDialogCallbackL, this ) ); + iUiRefreshAllowed = EFalse; + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowStatusDialogDeferredL() end"); + } + + + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::RefreshL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::RefreshL( TInt aError ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::RefreshL() begin"); + IAUPDATE_TRACE_1("[IAUPDATE] Error code: %d", aError ); + iMainView->RefreshL( iController->Nodes(), iController->FwNodes(), aError ); + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::RefreshL() end"); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::InformRequestObserver +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::InformRequestObserver( TInt aError ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::InformRequestObserver() begin"); + + if ( iRequestObserver ) + { + if ( iController->ClosingAllowedByClient() ) + { + if ( iRequestType != IAUpdateUiDefines::ENoRequest ) + { + if ( iRequestType == IAUpdateUiDefines::EUpdateQuery && iUpdateNow ) + { + if ( !iBackgroundTimer ) + { + iBackgroundTimer = CIAUpdateUITimer::NewL( *this, CIAUpdateUITimer::EBackgroundDelay ); + } + if ( !iBackgroundTimer->IsActive() ) + { + iBackgroundTimer->After( 500000 ); + } + } + else + { + iEikonEnv->RootWin().SetOrdinalPosition( -1, ECoeWinPriorityNeverAtFront ); + } + } + } + CIAUpdateResult* details( NULL ); + TRAPD( error, details = CIAUpdateResult::NewL() ) + if ( details ) + { + TIAUpdateResultsInfo resultsInfo( + iController->ResultsInfo() ); + IAUPDATE_TRACE_3("[IAUPDATE] succeed: %d failed: %d cancelled: %d", + resultsInfo.iCountSuccessfull, + resultsInfo.iCountFailed, + resultsInfo.iCountCancelled ); + IAUPDATE_TRACE_2("[IAUPDATE] update now: %d available updates: %d", + iUpdateNow, iController->CountOfAvailableUpdates() ); + details->SetSuccessCount( resultsInfo.iCountSuccessfull ); + details->SetFailCount( resultsInfo.iCountFailed ); + details->SetCancelCount( resultsInfo.iCountCancelled ); + + // Ownership of details is transferred here. + iRequestObserver->RequestCompleted( details, + iController->CountOfAvailableUpdates(), + iUpdateNow, + aError ); + details = NULL; + } + else + { + iRequestObserver->RequestCompleted( details, + iController->CountOfAvailableUpdates(), + iUpdateNow, + error ); + } + iRequestObserver = NULL; + } + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::InformRequestObserver() end"); + } + + +// --------------------------------------------------------------------------- +// CIAUpdateAppUi::SetDefaultConnectionMethodL +// Sets the connection method for the update network connection. +// --------------------------------------------------------------------------- +// +void CIAUpdateAppUi::SetDefaultConnectionMethodL(TBool aTotalSilent ) + { + if ( aTotalSilent ) + { + // from back ground checker, choose the IAP to make the internet access silent + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::SetDefaultConnectionMethodL() begin"); + + TUint32 connectionMethodId( 0 ); + TInt 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 ) ); + CleanupStack::PopAndDestroy( cenrep ); + cenrep = NULL; + + RCmManagerExt cmManagerExt; + cmManagerExt.OpenL(); + CleanupClosePushL( cmManagerExt ); + + if ( connMethodId == -1 ) + { + IAUPDATE_TRACE("[IAUPDATE] user chooses default connection, use IAP logic"); + + //check what is the default connection by users + + TCmDefConnValue DCSetting; + cmManagerExt.ReadDefConnL( DCSetting ); + + + switch ( DCSetting.iType ) + { + case ECmDefConnAlwaysAsk: + case ECmDefConnAskOnce: + { + //go with the best IAP under internet snap + connectionMethodId = GetBestIAPInAllSNAPsL( cmManagerExt ); + break; + } + case ECmDefConnDestination: + { + //go with the best IAP under this snap + connectionMethodId = GetBestIAPInThisSNAPL( cmManagerExt, DCSetting.iId ); + break; + } + case ECmDefConnConnectionMethod: + { + //go with the best IAP under this snap + connectionMethodId = DCSetting.iId; + break; + } + } + } + else if ( connMethodId == 0 ) + { + //no choice from user, we go with the best IAP under Internent SNAP + connectionMethodId = GetBestIAPInAllSNAPsL( cmManagerExt ); + } + else + { + IAUPDATE_TRACE("[IAUPDATE] use chooses a snap"); + // It was some SNAP value + connectionMethodId = GetBestIAPInThisSNAPL( cmManagerExt, connMethodId ); + } + + CleanupStack::PopAndDestroy( &cmManagerExt ); + + if ( connectionMethodId != 0 ) + { + TIAUpdateConnectionMethod connectionMethod( + connectionMethodId, + TIAUpdateConnectionMethod::EConnectionMethodTypeAccessPoint ); + + iController->SetDefaultConnectionMethodL( connectionMethod ); + } + else + { + //In the totally silent case, if no usable IAP, we complete the check update with 0 updates. + //the bgchecker will try again later after 1 month. + //The LEAVE will be catched up later and complete the request from background checker. + User::LeaveIfError( KErrNotFound ); + } + + + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::SetDefaultConnectionMethodL() end"); + } + else + { + // from grid, use the old logic + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::SetDefaultConnectionMethodL() begin"); + TUint32 connectionMethodId( 0 ); + TInt connMethodId( 0 ); + + // Set initial value to always ask + TInt connectionMethodType( TIAUpdateConnectionMethod::EConnectionMethodTypeAlwaysAsk ); + TBool needSaving(EFalse); + + // Let's first check whether cenrep contains SNAP id other than zero + CRepository* cenrep( CRepository::NewLC( KCRUidIAUpdateSettings ) ); + User::LeaveIfError( + cenrep->Get( KIAUpdateAccessPoint, connMethodId ) ); + CleanupStack::PopAndDestroy( cenrep ); + cenrep = NULL; + + if ( connMethodId == -1 ) + { + IAUPDATE_TRACE("[IAUPDATE] user chooses default connection, use IAP logic"); + + connectionMethodId = 0; + connectionMethodType = TIAUpdateConnectionMethod::EConnectionMethodTypeDefault; + } + else if ( connMethodId == 0 ) + { + + IAUPDATE_TRACE("[IAUPDATE] use chooses nothing, use internal IAP logic"); + //if nothing is set by user, use our new logic + //SetDefaultConnectionMethod2L(); + //return; + // CenRep didn't contain any SNAP id. Let's try Internet SNAP then. + + RCmManagerExt cmManagerExt; + cmManagerExt.OpenL(); + CleanupClosePushL( cmManagerExt ); + iDestIdArray.Reset(); + cmManagerExt.AllDestinationsL( iDestIdArray ); + + for ( TInt 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; + IAUPDATE_TRACE_1("[IAUPDATE] connectionMethodId: %d", connectionMethodId ); + } + CleanupStack::PopAndDestroy( &dest ); + break; + } + + CleanupStack::PopAndDestroy( &dest ); + } + iDestIdArray.Reset(); + CleanupStack::PopAndDestroy( &cmManagerExt ); + } + else + { + IAUPDATE_TRACE("[IAUPDATE] use chooses a snap"); + // It was some SNAP value + connectionMethodId = connMethodId; + } + + if ( connectionMethodId > 0) + { + // We have now some valid SNAP id, either from CenRep or Internet SNAP + connectionMethodType = TIAUpdateConnectionMethod::EConnectionMethodTypeDestination; + // Save to cenrep if needed + if ( needSaving ) + { + cenrep = CRepository::NewLC( KCRUidIAUpdateSettings ); + TInt err = cenrep->StartTransaction( CRepository::EReadWriteTransaction ); + User::LeaveIfError( err ); + cenrep->CleanupCancelTransactionPushL(); + + connMethodId = connectionMethodId; + err = cenrep->Set( KIAUpdateAccessPoint, connMethodId ); + User::LeaveIfError( err ); + TUint32 ignore = KErrNone; + User::LeaveIfError( cenrep->CommitTransaction( ignore ) ); + CleanupStack::PopAndDestroy(); // CleanupCancelTransactionPushL() + CleanupStack::PopAndDestroy( cenrep ); + } + } + + TIAUpdateConnectionMethod connectionMethod( + connectionMethodId, + static_cast< TIAUpdateConnectionMethod::TConnectionMethodType >( connectionMethodType ) ); + + iController->SetDefaultConnectionMethodL( connectionMethod ); + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::SetDefaultConnectionMethodL() end"); + } + + } + + +// --------------------------------------------------------------------------- +// CIAUpdateAppUi::GetBestIAPInAllSNAPsL +// Sets the best IAP from all snaps +// --------------------------------------------------------------------------- +// +TUint32 CIAUpdateAppUi::GetBestIAPInAllSNAPsL( RCmManagerExt& aCmManagerExt ) + { + //go with internet SNAP first. + TUint32 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++ ) + { + TUint32 SNAPID = iDestIdArray[i]; + IAPID = GetBestIAPInThisSNAPL( aCmManagerExt, SNAPID ); + if ( IAPID ) + { + break; + } + } + iDestIdArray.Reset(); + return IAPID; + } + + + +// --------------------------------------------------------------------------- +// CIAUpdateAppUi::GetBestIAPInInternetSNAPL +// Sets the best IAP from internet snap +// --------------------------------------------------------------------------- +// +TUint32 CIAUpdateAppUi::GetBestIAPInInternetSNAPL( RCmManagerExt& aCmManagerExt ) + { + //select IAP from Internet SNAP + iDestIdArray.Reset(); + aCmManagerExt.AllDestinationsL( iDestIdArray ); + TUint32 InternetSNAPID = 0; + for ( TInt i = 0; i< iDestIdArray.Count(); i++ ) + { + RCmDestinationExt dest = aCmManagerExt.DestinationL( iDestIdArray[i] ); + CleanupClosePushL( dest ); + + if ( dest.MetadataL( CMManager::ESnapMetadataInternet ) ) + { + InternetSNAPID = iDestIdArray[i]; + CleanupStack::PopAndDestroy( &dest ); + break; + } + CleanupStack::PopAndDestroy( &dest ); + } + iDestIdArray.Reset(); + + return GetBestIAPInThisSNAPL( aCmManagerExt, InternetSNAPID ); + } + + + +// --------------------------------------------------------------------------- +// CIAUpdateAppUi::GetBestIAPInThisSNAPL +// Sets the best IAP from the given snap +// --------------------------------------------------------------------------- +// +TUint32 CIAUpdateAppUi::GetBestIAPInThisSNAPL( RCmManagerExt& aCmManagerExt, TUint32 aSNAPID ) + { + //get all usable IAPs + TConnMonIapInfoBuf iapInfo; + TRequestStatus status; + + RConnectionMonitor connMon; + connMon.ConnectL(); + CleanupClosePushL( connMon ); + + connMon.GetPckgAttribute( EBearerIdAll, 0, KIapAvailability,iapInfo, status ); + User::WaitForRequest( status ); + User::LeaveIfError( status.Int() ); + + CleanupStack::PopAndDestroy( &connMon ); + + RCmDestinationExt dest = aCmManagerExt.DestinationL( aSNAPID ); + CleanupClosePushL( dest ); + + // Check whether the SNAP contains any IAP. + for (TInt i = 0; i < dest.ConnectionMethodCount(); i++ ) + { + RCmConnectionMethodExt cm = dest.ConnectionMethodL( i ); + CleanupClosePushL( cm ); + + TUint32 iapid= cm.GetIntAttributeL( CMManager::ECmIapId ); + + for ( TInt i = 0; i < iapInfo().iCount; i++ ) + { + if ( iapInfo().iIap[i].iIapId == iapid ) + { + CleanupStack::PopAndDestroy( 2 ); //cm & dest; + return iapid; + } + } + + CleanupStack::PopAndDestroy( &cm ); + } + + CleanupStack::PopAndDestroy( &dest ); + return 0; + } + + + +// --------------------------------------------------------------------------- +// CIAUpdateAppUi::ShowStatusDialogCallbackL +// --------------------------------------------------------------------------- +// +TInt CIAUpdateAppUi::ShowStatusDialogCallbackL( TAny* aPtr ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowStatusDialogCallbackL() begin"); + CIAUpdateAppUi* appUI= static_cast( aPtr ); + TRAPD( err, appUI->ShowStatusDialogL() ); + appUI->HandleLeaveErrorL( err ); + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowStatusDialogCallbackL() end"); + return KErrNone; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::SetVisibleL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::SetVisibleL( TBool aVisible ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::SetVisibleL() begin"); + IAUPDATE_TRACE_1("[IAUPDATE] visible: %d", aVisible ); + if ( aVisible ) + { + if ( iEikonEnv->RootWin().OrdinalPosition() != 0 || iEikonEnv->RootWin().OrdinalPriority() != ECoeWinPriorityNormal ) + { + iEikonEnv->RootWin().SetOrdinalPosition( 0, ECoeWinPriorityNormal ); + } + + StatusPane()->MakeVisible( ETrue ); + iMainView = CIAUpdateMainView::NewL( ClientRect() ); + AddViewL( iMainView ); + ActivateLocalViewL( TUid::Uid( EIAUpdateMainViewId ) ); + } + else + { + iEikonEnv->RootWin().SetOrdinalPosition( -1, ECoeWinPriorityNeverAtFront ); + StatusPane()->MakeVisible( EFalse ); + } + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::SetVisibleL() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::Controller() +// +// ----------------------------------------------------------------------------- +// +CIAUpdateUiController* CIAUpdateAppUi::Controller() const + { + return iController; + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::PotentialCancel +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::PotentialCancel() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::PotentialCancel() begin"); + iController->DoCancelIfAllowed(); + HandleObserverRemoval(); + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::PotentialCancel() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::HandleClientToForegroundL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::HandleClientToForegroundL() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleClientToForegroundL() begin"); + if ( !iForegroundTimer ) + { + iForegroundTimer = CIAUpdateUITimer::NewL( *this, CIAUpdateUITimer::EForegroundDelay ); + } + if ( !iForegroundTimer->IsActive() ) + { + iForegroundTimer->After( 700000 ); + } + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleClientToForegroundL() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::HandleAllClientsClosedL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::HandleAllClientsClosedL() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleAllClientsClosedL() begin"); + HideApplicationInFSWL( EFalse ); + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleAllClientsClosedL() end"); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::ShowStatusDialogAgain +// +// ----------------------------------------------------------------------------- +// +TBool CIAUpdateAppUi::ShowStatusDialogAgain() const + { + return iShowStatusDialogAgain; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::StartWGListChangeMonitoring +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::StartWGListChangeMonitoring() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::StartWGListChangeMonitoring() begin"); + iInstUiOnTop = EFalse; + iEikonEnv->RootWin().EnableGroupListChangeEvents(); + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::StartWGListChangeMonitoring() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::StopWGListChangeMonitoring +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::StopWGListChangeMonitoring() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::StopWGListChangeMonitoring() begin"); + iEikonEnv->RootWin().DisableGroupListChangeEvents(); + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::StopWGListChangeMonitoring() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::SetClientWgId +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::SetClientWgId( TInt aWgId ) + { + IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateAppUi::SetClientWgId() wgId %d", aWgId ); + iWgId = aWgId; + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::ClientInBackgroundL +// +// ----------------------------------------------------------------------------- +// +TInt CIAUpdateAppUi::ClientInBackgroundL() const + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ClientInBackgroundL() begin"); + TBool inBackground = EFalse; + if ( iWgId > 0 ) + { + CArrayFixFlat* wgArray = new( ELeave ) CArrayFixFlat(10); + CleanupStack::PushL( wgArray ); + User::LeaveIfError( iEikonEnv->WsSession().WindowGroupList( 0, wgArray ) ); + TInt ownWgId = iEikonEnv->RootWin().Identifier(); + if ( ( wgArray->At( 0 ) != ownWgId ) && ( wgArray->At( 0 ) != iWgId ) ) + { + inBackground = ETrue; + } + CleanupStack::PopAndDestroy( wgArray ); + } + IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateAppUi::ClientInBackgroundL() inBackground: %d", inBackground ); + return inBackground; + } + + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::ShowUpdateQueryL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::ShowUpdateQueryL() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowUpdateQueryL() begin"); + 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 ) ) + { + if ( ClientInBackgroundL() ) + { + iEikonEnv->RootWin().SetOrdinalPosition( -1, ECoeWinPriorityNormal ); + } + else + { + iEikonEnv->RootWin().SetOrdinalPosition( 0, ECoeWinPriorityNormal ); + } + TInt ret = IAUpdateDialogUtil::ShowConfirmationQueryL( + R_IAUPDATE_PROGRAM_UPDATE, + R_IAUPDATE_SOFTKEYS_NOW_LATER__NOW ); + switch ( ret ) + { + case EIAUpdateSoftkeyNow: + IAUPDATE_TRACE("[IAUPDATE] EIAUpdateSoftkeyNow"); + iUpdateNow = ETrue; + break; + + case EIAUpdateSoftkeyLater: + IAUPDATE_TRACE("[IAUPDATE] EIAUpdateSoftkeyLater"); + updateQueryHistory->SetTimeL( iUpdatequeryUid ); + break; + + default: //case of cancel (eq. End key) + break; + } + } + CleanupStack::PopAndDestroy( updateQueryHistory ); + InformRequestObserver( KErrNone ); + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowUpdateQueryL() end"); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::HideApplicationInFSWL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::HideApplicationInFSWL( TBool aHide ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HideApplicationInFSW() begin"); + IAUPDATE_TRACE_1("[IAUPDATE] hide: %d", aHide ); + TInt id = iEikonEnv->RootWin().Identifier(); + + CApaWindowGroupName* wgName = CApaWindowGroupName::NewLC( + iEikonEnv->WsSession(), id ); + + wgName->SetHidden( aHide ); + wgName->SetWindowGroupName( iEikonEnv->RootWin() ); + CleanupStack::PopAndDestroy( wgName ); + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HideApplicationInFSW() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::ShowGlobalErrorNoteL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::ShowGlobalErrorNoteL( TInt aError ) const + { + CErrorUI* errorUI = CErrorUI::NewLC( ); + errorUI->ShowGlobalErrorNoteL( aError ); + CleanupStack::PopAndDestroy( errorUI ); + } + + + +// --------------------------------------------------------------------------- +// CIAUpdateAppUi::UpdateQueryCallbackL +// --------------------------------------------------------------------------- +// +TInt CIAUpdateAppUi::UpdateQueryCallbackL( TAny* aPtr ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::UpdateQueryCallbackL() begin"); + CIAUpdateAppUi* appUI= static_cast( aPtr ); + TRAPD( err, appUI->ShowUpdateQueryL() ); + if ( err != KErrNone ) + { + appUI->HandleLeaveErrorL( err ); + } + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::UpdateQueryCallbackL() end"); + return KErrNone; + } + + +// --------------------------------------------------------------------------- +// CIAUpdateAppUi::AutomaticCheckCallbackL +// --------------------------------------------------------------------------- +// + +TInt CIAUpdateAppUi::AutomaticCheckCallbackL( TAny* aPtr ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::AutomaticCheckCallbackL() begin"); + CIAUpdateAppUi* appUI= static_cast( aPtr ); + + TInt err = KErrNone; + CIAUpdateAutomaticCheck* automaticCheck = NULL; + TRAP( err, automaticCheck = CIAUpdateAutomaticCheck::NewL() ); + if ( err != KErrNone ) + { + appUI->HandleLeaveErrorL( err ); + } + else + { + CleanupStack::PushL( automaticCheck ); + TRAP( err, automaticCheck->AcceptAutomaticCheckL() ); + if ( err != KErrNone ) + { + appUI->HandleLeaveErrorL( err ); + } + } + + CleanupStack::PopAndDestroy( automaticCheck ); + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::AutomaticCheckCallbackL() end"); + return KErrNone; + } + + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::HandleTextLinkL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::HandleTextLinkL() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleTextLinkL() begin"); + if ( !iHistoryView ) + { + iHistoryView = CIAUpdateHistoryView::NewL( iController->HistoryL() ); + + AddViewL( iHistoryView ); + } + ActivateLocalViewL( TUid::Uid( EIAUpdateHistoryViewId ) ); + iShowStatusDialogAgain = ETrue; + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleTextLinkL() end"); + } + + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::SetDMSupport +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateAppUi::SetDMSupport( TBool aDMSupport ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::SetDMSupport begin"); + iIsDMSupported = aDMSupport; + iIsDMSet = ETrue;; + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::SetDMSupport end"); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::IsDMSupport +// +// ----------------------------------------------------------------------------- +// +TBool CIAUpdateAppUi::IsDMSupport() + { + return iIsDMSupported; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateAppUi::IsDMSupportSet +// +// ----------------------------------------------------------------------------- +// +TBool CIAUpdateAppUi::IsDMSupportSet() + { + return iIsDMSet; + } + +TBool CIAUpdateAppUi::UiRefreshAllowed() + { + return iUiRefreshAllowed; + } + +// --------------------------------------------------------------------------- +// CIAUpdateAppUi::ForegroundDelayComplete +// +// --------------------------------------------------------------------------- +// +void CIAUpdateAppUi::ForegroundDelayComplete( TInt aError ) + { + IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateAppUi::ForegroundDelayComplete() begin: %d", + aError); + + delete iForegroundTimer; + iForegroundTimer = NULL; + + iEikonEnv->RootWin().SetOrdinalPosition( 0 ); + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ForegroundDelayComplete() end"); + } + +// --------------------------------------------------------------------------- +// CIAUpdateAppUi::BackgroundDelayComplete +// +// --------------------------------------------------------------------------- +// +void CIAUpdateAppUi::BackgroundDelayComplete( TInt aError ) + { + IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateAppUi::BackgroundDelayComplete() begin: %d", + aError); + + delete iBackgroundTimer; + iBackgroundTimer = NULL; + + iEikonEnv->RootWin().SetOrdinalPosition( -1, ECoeWinPriorityNeverAtFront ); + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::BackgroundDelayComplete() end"); + } + +// --------------------------------------------------------------------------- +// CIAUpdateAppUi::ProcessStartDelayComplete +// +// --------------------------------------------------------------------------- +// +void CIAUpdateAppUi::ProcessStartDelayComplete( TInt /*aError*/ ) + { + } + + +// End of File