diff -r 6385c4c93049 -r 8e6fa1719340 browserui/browser/BrowserAppSrc/BrowserAppUi.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/browserui/browser/BrowserAppSrc/BrowserAppUi.cpp Wed Sep 01 12:31:04 2010 +0100 @@ -0,0 +1,4753 @@ +/* +* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "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: +* Implementation of CBrowserAppUi +* +* +*/ + +// INCLUDES +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef BRDO_APP_GALLERY_SUPPORTED_FF +#include +#include +#endif + +#include +#include + +#include +#include "BrowserLauncherService.h" + +#include "cookiemanagerclient.h" + +#ifdef __SERIES60_HELP +#include +#endif //__SERIES60_HELP + +#include "BrowserAppDocument.h" +#include +#include "BrowserBmOTABinSender.h" +#include "BrowserCommandLineParser.h" +#include "BrowserApplication.h" +#include "BrowserContentView.h" +#include "BrowserContentViewContainer.h" +#include "BrowserContentViewToolbar.h" +#include "BrowserBookmarksView.h" +#include "SettingsView.h" +#include "BrowserWindowSelectionView.h" +#include "BrowserInitialView.h" +#include "CommonConstants.h" +#include "BrowserDialogs.h" +#include "BrowserDisplay.h" +#include "BrowserCommsModel.h" +#include "BrowserUtil.h" +#include "BrowserPreferences.h" +#include "SessionAndSecurity.h" +#include "BrowserUIVariant.hrh" +#include "BrowserWindowQueue.h" +#include "Logger.h" +#include + +#include +#include +#include "BrowserSoftkeysObserver.h" +#include "BrowserLoadObserver.h" +#include "BrowserSpecialLoadObserver.h" +#include "BrowserAsyncExit.h" +#include "CommonConstants.h" + + +// Dialogs Provider +#include +#include +#include + +// Multiple Windows +#include "BrowserPopupEngine.h" +#include "BrowserDialogsProviderProxy.h" +#include "BrowserWindow.h" +#include "BrowserWindowManager.h" +#include "AknInfoPopupNoteController.h" + +#include "BrowserAppUi.h" + +#include "BrowserPushMtmObserver.h" + +#ifdef BRDO_IAD_UPDATE_ENABLED_FF +#include +#include +#include +#endif + +//CONSTANTS +const TUint KBookmarkId = 1; +const TUint KUrlId = 4; +_LIT8 ( KLongZeroIdString, "5" ); +const TUint KFolderId = 6; +const TUint KLaunchFeeds = 7; + +const TInt KMaxNumOfOpenedWindows = 5; +const TInt KMinNumOfOpenedWindows = 2; // must allow at least 2 windows for most use cases + +const TUint KDot('.'); +const TUint KSlash('/'); +_LIT( KDefaultSchema, "http://" ); +const TInt KDefaultSchemaLength = 7; + +const TInt KMinimumCDriveDiskSpace = 512 * 1024; + +const TInt KRetryConnectivityTimeout( 2*1000*1000 ); // 2 seconds + +#ifdef BRDO_IAD_UPDATE_ENABLED_FF +const TUint KBrowser8xUID = 0x200267CC; +_LIT( KUpdateFileName, "lastupdatechecked.txt" ); +const TInt64 KMaxTimeToPostponeUpdate = 604800000000; +#endif + +//Following array stores Uids for external applications. +//This can be appended. This is used in HandleMessageL to enable Single Window browsing. +static TInt mArrayOfExternalAppUid[] = { 0x2001f3a9, 0x200159D0}; +// ================= MEMBER FUNCTIONS ======================= + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::CBrowserAppUi() +// ----------------------------------------------------------------------------- +// +CBrowserAppUi::CBrowserAppUi(): +iCalledFromAnotherApp( EFalse ), +iIsForeground( EFalse ), +iLastViewId( KUidBrowserNullViewId ), +iExitInProgress( EFalse ), +iShutdownRequested( EFalse ), +iParametrizedLaunchInProgress( 0 ), +iExitFromEmbeddedMode( EFalse ), +iLongZeroPressed( EFalse ), +iStartedUp( EFalse ), +iFeatureManager( EFalse ), +iUserExit( EFalse ), +iPgNotFound( EFalse ), +iOverriddenLaunchContextId( EBrowserContextIdNormal ), +iBrowserAlreadyRunning (EFalse), +iSameWinApp( EFalse ), +iFeedsClientUtilities( 0 ) + { + iViewToBeActivatedIfNeeded.iUid = 0; + iViewToReturnOnClose.iUid = 0; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::~CBrowserAppUi() +// ----------------------------------------------------------------------------- +// +CBrowserAppUi::~CBrowserAppUi() + { + LOG_ENTERFN("CBrowserAppUi::~CBrowserAppUi"); + +#ifdef BRDO_IAD_UPDATE_ENABLED_FF + delete iDelayedUpdate; + iFs.Close(); +#endif + + SetExitInProgress( ETrue ); + if(iBrowserAsyncExit) + { + iBrowserAsyncExit->Cancel(); + } + if(iIdle) + { + iIdle->Cancel(); + } + + + if( iFeatureManager ) + { + FeatureManager::UnInitializeLib(); + iFeatureManager = EFalse; + } + + // + delete iPushMtmObserver; + +#ifdef __RSS_FEEDS + delete iFeedsClientUtilities; + LOG_WRITE( "iFeedsClientUtilities deleted" ); +#endif //__RSS_FEEDS + + delete iPopupEngine; + LOG_WRITE(" iPopupEngine deleted."); + + // set user exit for 'save launch param' command handling + if ( iWindowManager ) + { + iWindowManager->SetUserExit( iUserExit ); + } + delete iWindowManager; + LOG_WRITE( " iWindowManager deleted" ); + +#ifdef BRDO_OCC_ENABLED_FF + if(iRetryConnectivity) + iRetryConnectivity->Cancel(); + + delete iRetryConnectivity; + iRetryConnectivity = NULL; +#endif + + // Delete the inetconman after deleting window manager + CInternetConnectionManager* inetconman = (CInternetConnectionManager*)iConnection; + delete inetconman; + LOG_WRITE( " inetconman deleted" ); + delete iConnStageNotifier; + LOG_WRITE( " iConnStageNotifier deleted" ); + + delete iPreferences; + LOG_WRITE( " iPreferences deleted" ); + delete iCommsModel; + LOG_WRITE( " iCommsModel deleted" ); + + delete iLateSendUi; + LOG_WRITE( " iLateSendUi deleted" ); + + delete iSender; + LOG_WRITE( " iSender deleted" ); + + delete iIdle; + LOG_WRITE( " iIdle deleted" ); + + delete iRecentUrlStore; + LOG_WRITE( " iRecentUrlStore deleted" ); + + if ( iDoorObserver ) + { + iDoorObserver->NotifyExit(MApaEmbeddedDocObserver::ENoChanges); + LOG_WRITE( " NotifyExit deleted" ); + } + delete iDialogsProvider; + LOG_WRITE( " iDialogsProvider deleted" ); + + TBool isStandAlone = !IsEmbeddedModeOn(); + LOG_WRITE_FORMAT( " isStandAlone: %d", isStandAlone ); + + delete iBrowserAsyncExit; + LOG_WRITE( " iBrowserAsyncExit deleted" ); + + iFavouritesSess.Close(); + LOG_WRITE( " iFavouritesSess.Close() deleted" ); +#ifdef BRDO_IAD_UPDATE_ENABLED_FF + CleanUpdateParams(); +#endif + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::ConstructL() +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::ConstructL() + { + LOG_CREATE; + LOG_ENTERFN( "CBrowserAppUi::ConstructL" ); +PERFLOG_CREATE; +PERFLOG_LOCAL_INIT; +PERFLOG_STOPWATCH_START; + + +#ifdef BRDO_SINGLE_CLICK_ENABLED_FF + BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible); +#else + BaseConstructL( EAknEnableSkin | EAknEnableMSK ); +#endif + + + if ( !IsEmbeddedModeOn( ) ) + { + // This is for handling low phone memory (c:) condition. Just leave in case phone memory is not sufficient. + TBool lowdisk = SysUtil::DiskSpaceBelowCriticalLevelL(&(CCoeEnv::Static()->FsSession()), KMinimumCDriveDiskSpace, EDriveC ); + if (lowdisk) User::Leave(KErrDiskFull); + +#ifdef BRDO_PERF_IMPROVEMENTS_ENABLED_FF + InitBookmarksL(); +#else + InitBrowserL(); +#endif + LOG_WRITE( "Browser started standalone" ); + } + else + { + iStartedUp = EFalse; + LOG_WRITE( "Browser started embedded" ); + } +PERFLOG_STOP_WRITE("BrowserUI::ConstructL"); + + } +#ifdef BRDO_IAD_UPDATE_ENABLED_FF +// --------------------------------------------------------- +// CBrowserAppUi::CheckUpdatesL +// --------------------------------------------------------- +void CBrowserAppUi::CheckUpdatesL() + { + LOG_ENTERFN("CBrowserAppUi::CheckUpdatesL"); + LOG_WRITE( "CBrowserAppUi::CheckUpdatesL() entering" ); + User::LeaveIfError(iFs.Connect()); + if ( FeatureManager::FeatureSupported( KFeatureIdIAUpdate ) ) + { + LOG_WRITE( "CBrowserAppUi::CheckUpdatesL() IAD Update supported" ); + TRAP_IGNORE( iUpdate = CIAUpdate::NewL( *this ) ); + LOG_WRITE( "CBrowserAppUi::CheckUpdatesL() IAD Update Client Created" ); + if ( iUpdate ) + { + LOG_WRITE( "CBrowserAppUi::CheckUpdatesL() creating IAD Update paramentes" ); + iParameters = CIAUpdateParameters::NewL(); + // Search for updates using SIS package UID + iParameters->SetUid( TUid::Uid( KBrowser8xUID ) ); + //check the updates + iUpdate->CheckUpdates( *iParameters ); + } + } + LOG_WRITE( "CBrowserAppUi::CheckUpdatesL() exiting" ); + } + +// --------------------------------------------------------- +// CBrowserAppUi::CheckUpdatesComplete +// rest of the details commented in the header +// --------------------------------------------------------- +// +void CBrowserAppUi::CheckUpdatesComplete( TInt aErrorCode, TInt aAvailableUpdates ) + { + LOG_ENTERFN("CBrowserAppUi::CheckUpdatesComplete"); + LOG_WRITE( "CBrowserAppUi::CheckUpdatesComplete - Entry" ); + + TBool result = EFalse; + TBool showDialog = EFalse; + + if ( aErrorCode == KErrNone ) + { + if ( aAvailableUpdates > 0 ) + { + LOG_WRITE( "CBrowserAppUi::CheckUpdatesComplete - update available" ); + //Check if the file is available in folder or not + if(CheckUpdateFileAvailable()) + { + LOG_WRITE( "CBrowserAppUi::CheckUpdatesComplete - update file available" ); + TTime timenow; + timenow.HomeTime(); + TInt64 time = timenow.Int64(); + TInt64 dataValue = ReadUpdateFile(); + //If the diference of the current time and the Previous Check time is more than 1 Week + //then show the dialog + if((time - dataValue)>KMaxTimeToPostponeUpdate) + { + LOG_WRITE( "CBrowserAppUi::CheckUpdatesComplete - diference of the current time and the time available in th file is more than 7 days" ); + showDialog = ETrue; + } + } + else + { + LOG_WRITE( "CBrowserAppUi::CheckUpdatesComplete - update file is not available" ); + showDialog = ETrue; + } + + if(showDialog) + { + HBufC* message = StringLoader::LoadLC(R_INSTALL_ADDON_BROWSER); + HBufC* lsc_now = StringLoader::LoadLC(R_INSTALL_BROWSER_NOW); + HBufC* rsc_later = StringLoader::LoadLC(R_INSTALL_BROWSER_LATER); + + TRAPD(err, result = iDialogsProvider->DialogConfirmL(_L(""), + *message, + *lsc_now, + *rsc_later)); + + CleanupStack::PopAndDestroy(3); //message, lsc_now, rsc_later + + if (err != KErrNone) + { + return ; + } + if ( result ) // user selected NOW + { + LOG_WRITE( "CBrowserAppUi::CheckUpdatesComplete - if file exists, just delete it." ); + // if file exists, just delete it. + DeleteUpdateFile(); + iUpdate->ShowUpdates( *iParameters ); + } + if ( !result ) // user selected LATER + { + LOG_WRITE( "CBrowserAppUi::CheckUpdatesComplete - create the file and store the current time." ); + //create the file and store the current time. + WriteUpdateFile(); + } + } + LOG_WRITE( "CBrowserAppUi::CheckUpdatesComplete - update available" ); + } + else + { + LOG_WRITE( "CBrowserAppUi::CheckUpdatesComplete - no update available" ); + // The answer was 'Later'. CIAUpdate object could be deleted + CleanUpdateParams(); + } + } + LOG_WRITE( "CBrowserAppUi::CheckUpdatesComplete - Exit" ); + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::CleanUpdateParams +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::CleanUpdateParams() + { + LOG_ENTERFN("CBrowserAppUi::CleanUpdateParams"); + LOG_WRITE( "CBrowserAppUi::CleanUpdateParams() entering" ); + if(iUpdate) + { + delete iUpdate; + iUpdate = NULL; + } + if(iParameters) + { + delete iParameters; + iParameters = NULL; + } + LOG_WRITE( "CBrowserAppUi::CleanUpdateParams() exiting" ); + } + +// --------------------------------------------------------- +// CBrowserAppUi::UpdateComplete +// rest of the details commented in the header +// --------------------------------------------------------- +// +void CBrowserAppUi::UpdateComplete( TInt aErrorCode, CIAUpdateResult* aResult ) + { + LOG_ENTERFN("CBrowserAppUi::UpdateComplete"); + LOG_WRITE( "CBrowserAppUi::UpdateComplete - Entry" ); + delete aResult; // Ownership was transferred, so this must be deleted by the client + CleanUpdateParams(); + LOG_WRITE( "CBrowserAppUi::UpdateComplete - Exit" ); + } +#endif + + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::InitBookmarksL() +// Initialize only bookmarks view related dependencies here. +// Note - Do not add unnecessary code here, it increases startup time for bookmarks view. +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::InitBookmarksL() + { + //New constructor that just replaces the default primary storage size with this one. + iRecentUrlStore = CRecentUrlStore::NewL(); + + // Init CommsModel + iCommsModel = CBrowserCommsModel::NewL(); + + // check if it can be delayed ?? +#ifdef BRDO_OCC_ENABLED_FF + iConnection = CInternetConnectionManager::NewL( &iCommsModel->CommsDb(), ETrue ); +#else + iConnection = CInternetConnectionManager::NewL( &iCommsModel->CommsDb(), EFalse ); +#endif + + // Creating object to hold application settings + CBrowserAppDocument* doc = STATIC_CAST(CBrowserAppDocument*, Document()); + iPreferences = CBrowserPreferences::NewL( *iCommsModel, *this, doc->GetOverriddenSettings()); + + // Create bookmarkview + CBrowserBookmarksView* bookmarksView = NULL; + TInt folderUid = doc->GetFolderToOpen(); + if ( IsEmbeddedModeOn() && folderUid!= KFavouritesRootUid) + { + bookmarksView = CBrowserBookmarksView::NewLC( *this, *iRecentUrlStore, folderUid ); + } + else + { + bookmarksView = CBrowserBookmarksView::NewLC( *this, *iRecentUrlStore ); + } + + iBookmarksView = bookmarksView; + AddViewL( bookmarksView ); // transfer ownership to CAknViewAppUi + CleanupStack::Pop(); // bookmarksView + } + + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::CompleteDelayedInit() +// Delayed (async) init callback. This method can be invoked explicitly in case +// some early startup cases fail if Browser has not initialized fully. No harm +// if called multiple times since there is check in the beginning of thsi function. +// ----------------------------------------------------------------------------- +// +TBool CBrowserAppUi::CompleteDelayedInit() + { + // Should not be called for other that 9.2 onward devices +#ifdef BRDO_PERF_IMPROVEMENTS_ENABLED_FF + if ( iStartedUp ) + return EFalse; // no need to re-invoke automatically + // complete initialization + TRAP_IGNORE(DelayedInitL()); + +#ifdef BRDO_IAD_UPDATE_ENABLED_FF + // complete the IAD check asynchronously + iDelayedUpdate = CIdle::NewL( CActive::EPriorityIdle ); + iDelayedUpdate->Start(TCallBack( CompleteIADUpdateCallback, this )); +#endif +#endif + + return EFalse; // no need to re-invoke automatically + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::DelayedInitL() +// Delayed (Async) initialization - whatever remains after InitBookmarksL(), do it here. +// Note: - Do not add unnecessary code here, it increases startup time for contenview. +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::DelayedInitL() + { + LOG_ENTERFN("CBrowserAppUi::DelayedInitL"); + + // Create Favengine session + User::LeaveIfError( iFavouritesSess.Connect() ); + + // Init FeatureManager + FeatureManager::InitializeLibL(); + iFeatureManager = ETrue; + + // check flash present + iFlashPresent = CheckFlashPresent(); + + // this is required, browser's connection oberver should be hit first. + // (incase of netscape plgins, transactions will be closed.) + iConnStageNotifier = CConnectionStageNotifierWCB::NewL(); + iConnStageNotifier->SetPriority(CActive::EPriorityHigh); + + // Starts a background processing, so it must be started early, to get + // finished before the first send operation! Or it must be synchronized! + iLateSendUi = CIdle::NewL( CActive::EPriorityIdle ); + iLateSendUi ->Start( TCallBack( DelayedSendUiConstructL, this ) ); + + iHTTPSecurityIndicatorSupressed = iPreferences->HttpSecurityWarningsStatSupressed(); + + // set AP to be a default one (for Push messages) + SetRequestedAP( Preferences().DefaultAccessPoint() ); + + // Create ContentView + TRect rect = ClientRect(); + CBrowserContentView* contentView = CBrowserContentView::NewLC( *this, rect ); + AddViewL( contentView ); // transfer ownership to CAknViewAppUi + CleanupStack::Pop(); // contentView + + // proxy will handle dialog events through load observer + iDialogsProvider = CBrowserDialogsProvider::NewL( NULL); + +#ifdef __RSS_FEEDS + iFeedsClientUtilities = CFeedsClientUtilities::NewL( *this, *this ); + BROWSER_LOG( ( _L("Feeds up.") ) ); +#endif //__RSS_FEEDS + + // Is Multiple Window feature suported? + if ( Preferences().UiLocalFeatureSupported( KBrowserMultipleWindows ) ) + { + if (Preferences().UiLocalFeatureSupported( KBrowserMinimalMultipleWindows ))//midrange + { + iWindowManager = CBrowserWindowManager::NewL( *this, *contentView, KMinNumOfOpenedWindows ); + } + else + { + iWindowManager = CBrowserWindowManager::NewL( *this, *contentView, KMaxNumOfOpenedWindows ); + } + LOG_WRITE_FORMAT("WindowManager Up. Max windows number. %d", KMaxNumOfOpenedWindows ); + } + else + { + iWindowManager = CBrowserWindowManager::NewL( *this, *contentView, KMinNumOfOpenedWindows ); + BROWSER_LOG( ( _L( "WindowManager Up. MWs not supported." ) ) ); + } + + contentView->SetZoomLevelL(); + BrCtlInterface().AddLoadEventObserverL(iBookmarksView); + + // create settings view + CBrowserSettingsView* settingsView = CBrowserSettingsView::NewLC( *this ); + AddViewL( settingsView ); // transfer ownership to CAknViewAppUi + CleanupStack::Pop(); // settingsView + BROWSER_LOG( ( _L( "SettingsView up" ) ) ); + + // window selection view + CBrowserWindowSelectionView* windowSelectionView = CBrowserWindowSelectionView::NewLC( *this ); + AddViewL( windowSelectionView ); // transfer ownership to CAknViewAppUi + CleanupStack::Pop(); // windowSelectionView + BROWSER_LOG( ( _L( "windowSelectionView up" ) ) ); + + // Create asyncronous object to call when exit requires it. + iBrowserAsyncExit = CBrowserAsyncExit::NewL( this ); + iIdle = CIdle::NewL( CActive::EPriorityIdle ); + + iPushMtmObserver = CBrowserPushMtmObserver::NewL( this ); + iPushMtmObserver->StartObserver(); + +#ifdef BRDO_OCC_ENABLED_FF + iRetryConnectivity = CPeriodic::NewL(CActive::EPriorityStandard); +#endif + + // Create two Panes of CBrowserContentViewContainer + CBrowserGotoPane* gotoPane = CBrowserGotoPane::NewL( contentView->Container(), + EMbmAvkonQgn_indi_find_goto, + EMbmAvkonQgn_indi_find_goto_mask, + ETrue, + contentView ); + + // Create the find pane with magnifier glass icon, and + // without adaptive popup list... + CBrowserGotoPane* findKeywordPane = CBrowserGotoPane::NewL( contentView->Container(), + EMbmAvkonQgn_indi_find_glass, + EMbmAvkonQgn_indi_find_glass_mask, + EFalse, + contentView, + ETrue ); + contentView->Container()->SetGotoPane(gotoPane); + contentView->Container()->SetFindKeywordPane(findKeywordPane); + //contentView->Container()->SetRect( rect ); // causes suncRepaint + contentView->Container()->GotoPane()->SetGPObserver(contentView); + contentView->Container()->FindKeywordPane()->SetGPObserver(contentView); + contentView->Container()->FindKeywordPane()->SetOrdinalPosition( 0 ); + contentView->Container()->GotoPane()->SetOrdinalPosition( 0 ); + + iStartedUp = ETrue; + iSecureSiteVisited = EFalse; + +#ifdef BRDO_PERF_IMPROVEMENTS_ENABLED_FF + if(LastActiveViewId() == KUidBrowserBookmarksViewId) + { + iBookmarksView->CheckForDownloads(); + iBookmarksView->UpdateFavIconsL(); + } +#endif + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::InitBrowserL() - THIS METHOD IS NOT USED FOR NORMAL STARTUP +// This method is just for supporting Browser initialization if launched in Embedded mode +// Normal initialization if split in BookmarksInit() and DelayedInit(). iStartedUp is FALSE +// if BRowser has not initialized or partially initialized. +// NOTE: DO NOT ADD ANY CODE HERE. IT IS JUST A WRAPPER. +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::InitBrowserL() + { + // Bookmarks initialization + InitBookmarksL(); + + // 2nd part of initialization + DelayedInitL(); + +#ifdef BRDO_IAD_UPDATE_ENABLED_FF + // complete the IAD check asynchronously + if(!IsEmbeddedModeOn()) + { + iDelayedUpdate = CIdle::NewL( CActive::EPriorityIdle ); + iDelayedUpdate->Start(TCallBack( CompleteIADUpdateCallback, this )); + } +#endif + } + + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::ProcessCommandL(TInt aCommand) +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::ProcessCommandL(TInt aCommand) + { + MEikAppUiFactory* appUiFactory = (iEikonEnv)->AppUiFactory(); + if (appUiFactory->MenuBar()) + { + StopDisplayingMenuBar(); + } + CAknViewAppUi::ProcessCommandL(aCommand); + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::HandleCommandL() +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::HandleCommandL(TInt aCommand) + { + // Default handling for all the thingies. + switch (aCommand) + { + case EEikCmdExit: + { + ExitBrowser ( IsAppShutterActive() ); + break; + } + case EAknSoftkeyExit:// closes the whole application chain if embedded browser + case EAknCmdExit: + { + if ( IsEmbeddedModeOn() ) + { + CAknEnv::RunAppShutter(); + break; + } + else + { + ExitBrowser ( ETrue ) ; + break; + } + } + //Fix for TSW error ICHV-75UFKZ + case EWmlCmdUserExit://closes the current browser instance only + case EWmlCmdCloseBrowser: + { + ExitBrowser ( ETrue ); + break; + } + case EWmlCmdChangeConnection : + { + ChangeConnectionL(); + break; + } + case EWmlCmdPreferences: + { + SetViewToBeActivatedIfNeededL( KUidBrowserSettingsViewId ); + break; + } + case EWmlCmdPreferencesToolbar: + { + SetViewToBeActivatedIfNeededL( KUidBrowserSettingsViewId, KUidSettingsGotoToolbarGroup.iUid ); + break; + } + case EWmlCmdFavourites: + { + SetViewToBeActivatedIfNeededL( KUidBrowserBookmarksViewId ); + break; + } + case EWmlCmdSearchWeb: + { + LoadSearchPageL(); + break; + } + case EWmlCmdReload: + { + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandReload + + (TInt)TBrCtlDefs::ECommandIdBase ); + break; + } +#ifdef BRDO_SINGLE_CLICK_ENABLED_FF + case EWmlCmdSetAsHomePage: + { + ContentView()->HandleCommandL(EWmlCmdSetAsHomePage); + break; + } +#endif + case EAknSoftkeyBack: + case EWmlCmdBack: + { + HistoryLoadPrevious(); + break; + } + case EWmlCmdBackToFeedsView: + { + //Note: iPreviousView in this case will always be one of the Feeds view. + //In general iPreviousView holds the UID of the previous view. + SetViewToBeActivatedIfNeededL( iPreviousView ); + break; + } + case EWmlCmdClearTheCache: + { + ClearTheCacheL(ETrue, ETrue); + break; + } + case EWmlCmdDeleteCookies: + { + DeleteCookiesL(); + TBrowserDialogs::InfoNoteL( + R_BROWSER_OK_NOTE, R_QTN_BROWSER_NOTE_COOKIES_DELETED ); + break; + } + + case EWmlCmdClearAllPrivacy: + { + ClearAllPrivacyL(); + break; + } + + case EWmlCmdClearHistory: + { + ClearHistoryWithPromptL(); + break; + } + + case EWmlCmdClearFormAndPasswd: + { + ClearFormAndPasswdDataL(ETrue); + break; + } + + case EWmlCmdLaunchHomePage: + { + if (!IsLaunchHomePageDimmedL()) + { + LaunchHomePageL( /* EFalse */ ); + } + break; + } + case EWmlCmdDisconnect : + { + DisconnectL(); + TBrowserDialogs::InfoNoteL( + R_BROWSER_INFO_NOTE, R_WML_DISCONNECT ); + break; + } + case EWmlCmdCancelFetch: + { + if (SpecialLoadObserver().IsConnectionStarted()) // If Connection request is in processing + { // try to Cancel. + SpecialLoadObserver().CancelConnection(); + Connection().Disconnect(); + } + else + { + CancelFetch( ETrue ); + } + break; + } + case EWmlCmdPageInfo: + { + CSessionAndSecurity* security = CSessionAndSecurity::NewLC(*this); + security->ShowPageInfoL(); + CleanupStack::PopAndDestroy(); // security + break; + } + case EWmlCmdInfoSession: + { + CSessionAndSecurity* session = CSessionAndSecurity::NewLC(*this); + session->ShowSessionInfoL(); + CleanupStack::PopAndDestroy(); // session + break; + } + case EWmlCmdInfoSecurity: + { + CSessionAndSecurity* security = CSessionAndSecurity::NewLC(*this); + security->ShowSecurityInfoL(); + CleanupStack::PopAndDestroy(); // security + break; + } + // browser engine specific command +#ifdef __SERIES60_HELP + + case EAknCmdHelp: + { + HlpLauncher::LaunchHelpApplicationL + ( iEikonEnv->WsSession(), AppHelpContextL() ); + break; + } + +#endif //__SERIES60_HELP + + case EWmlCmdForward: + { + HistoryLoadNext(); + break; + } + + case EWmlCmdRotateDisplay: + { + if ( Orientation() == EAppUiOrientationPortrait ) + { + SetOrientationL(EAppUiOrientationLandscape); + } + else if (Orientation() == EAppUiOrientationLandscape) + { + SetOrientationL(EAppUiOrientationPortrait); + } + else // EAppUiOrientationUnspecified + { + TRect rect = ApplicationRect(); + TInt width = rect.Width(); + TInt height = rect.Height(); + + if (width > height) + { + SetOrientationL(EAppUiOrientationPortrait); + } + else + { + SetOrientationL(EAppUiOrientationLandscape); + } + } + if(ContentView()->KeymapIsUp()) + { + ContentView()->RedrawKeymap(); + } + break; + } + + case EWmlCmdAboutProduct: + { + // get version info from browser control and display it + ShowNameAndVersionL(); + break; + } + case EWmlCmdProductUpdate: + { + /*if(!iAppUpdate) + { + iAppUpdate = CBrowserAppUpdate::NewL(); + } + iAppUpdate->CheckUpdates();*/ + break; + } + + //===================================================================== + // Multiple Windows Support + // + case EWmlCmdSwitchWindow: + { + if(WindowMgr().WindowCount() > 1) + { +#ifdef BRDO_MULTITOUCH_ENABLED_FF + // use switch window tab view if pageoverview bitmaps are available + if (Preferences().UiLocalFeatureSupported( KBrowserGraphicalPage ) + || Preferences().UiLocalFeatureSupported( KBrowserGraphicalHistory )) +#else + // use switch window tab view if pageoverview bitmaps are available + if (Preferences().UiLocalFeatureSupported( KBrowserGraphicalPage )) +#endif + { + SetViewToBeActivatedIfNeededL( KUidBrowserWindowSelectionViewId ); + } + else + { + SwitchWindowL(); + } + } + break; + } + case EWmlCmdCloseWindow: + { + if ( IsEmbeddedInOperatorMenu() ) + { + ExitBrowser( ETrue ); + } + else + { + CloseWindowL(); + } + break; + } + case EWmlCmdAllowPopups: + { + // Add url to whitelist + HBufC* url( WindowMgr().CurrentWindow()->BrCtlInterface(). + PageInfoLC( TBrCtlDefs::EPageInfoUrl ) ); + PopupEngine().AddUrlToWhiteListL( *url ); + CleanupStack::PopAndDestroy( url ); + break; + } + case EWmlCmdBlockPopups: + { + // Remove from whitelist + HBufC* url( WindowMgr().CurrentWindow()->BrCtlInterface(). + PageInfoLC( TBrCtlDefs::EPageInfoUrl ) ); + PopupEngine().RemoveUrlFromWhiteListL( *url ); + CleanupStack::PopAndDestroy( url ); + break; + } + case EWmlCmdShowAnchorHref: + { + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandIdBase + (TInt)TBrCtlDefs::ECommandShowAnchorHref ); + break; + } + case EWmlCmdSaveToGallery: + { + SaveFocusedImageToGalleryL(); + break; + } + case EWmlCmdOpenToViewer: + { + TBrCtlImageCarrier* imageCarrier = BrCtlInterface().FocusedImageLC(); + if (imageCarrier) + { + CArrayFixFlat* imageArray = new( ELeave ) CArrayFixFlat(1); + CleanupStack::PushL(imageArray); + imageArray->AppendL(*imageCarrier); + iDialogsProvider->DialogDisplayPageImagesL( *imageArray ); + CleanupStack::PopAndDestroy(2); // imageArray, imageCarrier + } + break; + } + case EWmlCmdSaveUrlAsBookmark: + { + HBufC* url = BrCtlInterface().PageInfoLC(TBrCtlDefs::EPageInfoFocusedNodeUrl); + ContentView()->AddNewBookmarkL(EFalse, url); + CleanupStack::PopAndDestroy(); // url + break; + } + case EWmlCmdSmartLinkMakeCall: + { + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandIdBase + (TInt)TBrCtlDefs::ECommandSmartLinkMakeCall ); + break; + } + case EWmlCmdSmartLinkSendEmail: + { + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandIdBase + (TInt)TBrCtlDefs::ECommandSmartLinkSendEmail ); + break; + } + case EWmlCmdSmartLinkSendSms: + { + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandIdBase + (TInt)TBrCtlDefs::ECommandSmartLinkSendMessage ); + break; + } + case EWmlCmdSmartLinkAddToContacts: + { + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandIdBase + (TInt)TBrCtlDefs::ECommandSmartLinkAddToPhoneBook ); + break; + } + case EWmlCmdLoadFocusedImage: + { + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandIdBase + (TInt)TBrCtlDefs::ECommandLoadFocusedImage ); + break; + } + case EWmlCmdLoadImagesOnly: + { + iPreferences->SetAutoLoadContentL(EWmlSettingsAutoloadImagesNoFlash); + break; + } + case EWmlCmdLoadImagesAndFlash: + { + iPreferences->SetAutoLoadContentL(EWmlSettingsAutoloadAll); + break; + } + case EWmlCmdOneStepBack: + { + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandIdBase + (TInt)TBrCtlDefs::ECommandOneStepBack ); + break; + } + case EEikCmdEditPaste: + { + TKeyEvent keyEvent; + keyEvent.iCode = EKeyF18; //member of TKeyCode + keyEvent.iScanCode = EEikCmdEditPaste; + keyEvent.iModifiers = EModifierCtrl; + keyEvent.iRepeats = 0; + TRAP_IGNORE( BrCtlInterface().OfferKeyEventL(keyEvent, EEventKey)); + } + break; + //===================================================================== + default: + { + if( iStartedUp ) + { + // pass to Browser Control + BrCtlInterface().HandleCommandL( aCommand ); + } + break; + } + } + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::ActiveView() +// ----------------------------------------------------------------------------- +// +CBrowserViewBase* CBrowserAppUi::ActiveView() + { + TVwsViewId activeViewId; + TInt err = GetActiveViewId( activeViewId ); + + if ( !err ) + { + return STATIC_CAST( CBrowserViewBase*, View(activeViewId.iViewUid) ); + } + else + { + //We should not panic + //On 3.0 wk40 it was observed that GetActiveViewId returned with KErrNotFound + //in case Browser was in the background + //Symbian error? + return NULL; + } + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::SetRequestedAP() +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::SetRequestedAP( TInt aAp ) + { + iRequestedAp = aAp; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::IsPageLoaded() +// ----------------------------------------------------------------------------- +// +TBool CBrowserAppUi::IsPageLoaded() + { +#ifdef BRDO_PERF_IMPROVEMENTS_ENABLED_FF + if(!iStartedUp) // ContentView/WindowMgr is not yet up => no page loaded + return EFalse; +#endif + + TBool ret( EFalse ); + TInt winCount( WindowMgr().WindowCount() ); + + // at least 2 window -> there is a page loaded + if( winCount > 1 ) + { + ret = ETrue; + } + // 1 window with a loaded content + else if( winCount == 1 ) + { + // This checks to see if a dialog is launched and if that is the case, then + // the current window is being used, hence returning true. + if( iDialogsProvider->IsDialogLaunched() ) + { + ret = ETrue; + } + else + { + ret = WindowMgr().IsContentExist(); + } + } + // else (winCount == 0), no content view -> no page loaded + return ret; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::Fetching() +// ----------------------------------------------------------------------------- +// +TBool CBrowserAppUi::Fetching() const + { + // TO DO: + // use load obs., remove ifetchstate from this class and use from loadobs. + // iLoadState + //return ( iFetchState == MFetchObserver::ELoadStart ); +#ifdef BRDO_PERF_IMPROVEMENTS_ENABLED_FF + if (!iStartedUp) // ContentView is not yet started up, so we are not fetching + return EFalse; + else +#endif + return ( LoadObserver().LoadState() != CBrowserLoadObserver::ELoadStateIdle ); + } +// ----------------------------------------------------------------------------- +// CBrowserAppUi::ContentDisplayed() +// ----------------------------------------------------------------------------- +// +TBool CBrowserAppUi::ContentDisplayed() const + { + return ( LoadObserver().ContentDisplayed() ); + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::SetContentDisplayed() +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::SetContentDisplayed(TBool aValue) + { + LoadObserver().SetContentDisplayed( aValue ); + } +// ----------------------------------------------------------------------------- +// CBrowserAppUi::FetchBookmarkL +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::FetchBookmarkL( TInt aBookmarkUid ) + { + // complete initialization if not done yet, can happen if user selects + // a bookmark quickly after launch (within 1 second) + if ( !iStartedUp ) + CompleteDelayedInit(); + + SetViewToReturnOnClose( KUidBrowserBookmarksViewId ); + if ( aBookmarkUid == KFavouritesStartPageUid ) + { + TUint defaultAp = Preferences().DefaultAccessPoint(); + if ( defaultAp != KWmlNoDefaultAccessPoint ) // There is no access point defined + { + CApAccessPointItem* apItem = Preferences().AllPreferencesL().iDefaultAPDetails; + if ( apItem ) + { + const HBufC* currentHP = apItem->ReadConstLongTextL( EApWapStartPage ); + //TPtrC currentHP(apItem->StartPage()); // Get the start page of the access point. + TFavouritesWapAp accessPoint; + + FetchL( *currentHP, KNullDesC, KNullDesC, accessPoint, + CBrowserLoadObserver::ELoadUrlTypeStartPage ); // Fetch the start page. + } + } + } + else + { + RFavouritesDb db; + User::LeaveIfError( db.Open( iFavouritesSess, KBrowserBookmarks ) ); + CleanupClosePushL( db ); + + CFavouritesItem* item = CFavouritesItem::NewLC(); + User::LeaveIfError( db.Get( aBookmarkUid, *item ) ); + + FetchBookmarkL( *item ); + CleanupStack::PopAndDestroy( 2 ); // item, db + } + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::FetchBookmarkL +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::FetchBookmarkL( const CFavouritesItem& aBookmarkItem ) + { + // complete initialization if not done yet, can happen if user selects + // a bookmark quickly after launch (within 1 second) + if ( !iStartedUp ) + CompleteDelayedInit(); + + SetViewToReturnOnClose( KUidBrowserBookmarksViewId ); + if ( Util::CheckBookmarkApL( *this, aBookmarkItem.WapAp()) ) + FetchL + ( + aBookmarkItem.Url() , + aBookmarkItem.UserName(), + aBookmarkItem.Password(), + aBookmarkItem.WapAp(), + CBrowserLoadObserver::ELoadUrlTypeOther + ); + else + TBrowserDialogs::ErrorNoteL( R_WML_INVALID_AP ); + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::SetViewToBeActivatedIfNeededL +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::SetViewToBeActivatedIfNeededL( TUid aUid, TInt aMessageId ) + { + CBrowserAppDocument* doc = STATIC_CAST(CBrowserAppDocument*, Document()); + + if((iCurrentView != aUid) && (aUid != KUidBrowserSettingsViewId)) + { + iPreviousView = iCurrentView; + iCurrentView = aUid; + } + + //Check view id validity first + if ( aUid == KUidBrowserNullViewId ) + { + SetLastActiveViewId( KUidBrowserBookmarksViewId ); + SetViewToBeActivatedIfNeededL( LastActiveViewId() ); + return; + } + + if ( ( aUid != KUidBrowserContentViewId ) && + ( LastActiveViewId() == KUidBrowserContentViewId ) ) + { + ContentView()->SetFullScreenOffL(); + } + + if ( iWindowManager && iWindowManager->ContentView()->FullScreenMode() ) + { + if ( aUid == KUidBrowserFeedsFeedViewId ) + { + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandIdBase + + (TInt)TBrCtlDefs::ECommandLeaveFullscreenBrowsing ); + } + + else if ( aUid != KUidBrowserFeedsTopicViewId && + aUid != KUidBrowserFeedsFolderViewId && + aUid != KUidBrowserBookmarksViewId ) + { + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandIdBase + + (TInt)TBrCtlDefs::ECommandEnterFullscreenBrowsing ); + } + } + + + if ( iIsForeground ) + { + if ( aUid == KUidBrowserSettingsViewId ) + { + //complete initialisation + if( !iStartedUp ) + CompleteDelayedInit(); + + CEikStatusPane* sp = STATIC_CAST( CAknAppUi*, + CEikonEnv::Static()->EikAppUi() ) + ->StatusPane(); + sp->DrawNow(); + } + + ActivateLocalViewL( aUid, TUid::Uid( aMessageId ), KNullDesC8 ); + } + else + { + iViewToBeActivatedIfNeeded = aUid; + } + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::LastActiveViewId +// ----------------------------------------------------------------------------- +// +TUid CBrowserAppUi::LastActiveViewId() const + { + return iLastViewId; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::SetLastActiveViewId +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::SetLastActiveViewId( TUid aUid ) + { +LOG_ENTERFN("CBrowserAppUi::SetLastActiveViewId"); + LOG_WRITE_FORMAT(" SetLastActiveViewId: %d", aUid); + iLastViewId = aUid; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::ExitInProgress +// ----------------------------------------------------------------------------- +// +TBool CBrowserAppUi::ExitInProgress() const + { + return iExitInProgress; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::ExitInProgress +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::SetExitInProgress( TBool aValue ) + { + iExitInProgress = aValue; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::IsConnecting +// ----------------------------------------------------------------------------- +// +TBool CBrowserAppUi::IsConnecting() const + { + return ( LoadObserver().LoadState() != CBrowserLoadObserver::ELoadStateIdle ); + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::HandleForegroundEventL +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::HandleForegroundEventL( TBool aForeground ) + { + // Handle this event only if the browser is started up + iIsForeground = IsForeground(); + if (!iStartedUp) + return; + + if( iIsForeground ) + { + if (iViewToBeActivatedIfNeeded.iUid) + { + ActivateLocalViewL( iViewToBeActivatedIfNeeded ); + } + else + { + TVwsViewId activeViewId; + if( ( GetActiveViewId( activeViewId ) == KErrNone ) && + ( LastActiveViewId() != activeViewId.iViewUid ) ) + { + // LastActiveViewId() might return with 0! + TRAP_IGNORE( ActivateLocalViewL( LastActiveViewId() ) ); + } + } + } + iViewToBeActivatedIfNeeded.iUid = 0; + CAknViewAppUi::HandleForegroundEventL( aForeground ); + + if( iIsForeground ) + { + if ( Preferences().FullScreen() == EWmlSettingsFullScreenFullScreen ) + { + ContentView()->UpdateFullScreenL(); + } + + if( !Fetching() ) + { + Display().StopProgressAnimationL(); + } + } + + if (iWindowManager) + { + iWindowManager->SendCommandToAllWindowsL( iIsForeground + ? (TInt)TBrCtlDefs::ECommandAppForeground + (TInt)TBrCtlDefs::ECommandIdBase + : (TInt)TBrCtlDefs::ECommandAppBackground + (TInt)TBrCtlDefs::ECommandIdBase); + } + + // if browser comes to foreground and exit is requested, + // asyncronous exit is started + if( iIsForeground && iExitFromEmbeddedMode && !IsEmbeddedInOperatorMenu() ) + { + iBrowserAsyncExit->Start(); + } + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::FetchL +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::FetchL( + const TDesC& aUrl, + const TDesC& aUsername, + const TDesC& aPassword, + const TFavouritesWapAp& aAccessPoint, + CBrowserLoadObserver::TBrowserLoadUrlType aUrlType ) + { +LOG_ENTERFN("CBrowserAppUi::FetchL"); + + // complete the initialization if not done yet + if(!iStartedUp) + CompleteDelayedInit(); + + // Let's cancel the previous fetch if any + if ( Fetching() ) + { + CancelFetch(); + } +#ifndef __WINS__ +//Fix for bookmark specific access point + if( iConnection && iConnection->Connected() ) + { + TUint32 passedIap( 0 ); + if ( aAccessPoint.ApId() != KWmlNoDefaultAccessPoint ) + { + passedIap = Util::IapIdFromWapIdL( *this, aAccessPoint.ApId()); + BROWSER_LOG((_L("CBrowserAppUi::FetchL Passed Iap: %d"), passedIap)); + TUint32 connectedAp = iConnection->CurrentAPId(); + BROWSER_LOG((_L("CBrowserAppUi::FetchL Existing connected Iap: %d"), connectedAp)); + if(passedIap != connectedAp) + { + StopConnectionObserving(); + BROWSER_LOG((_L("CBrowserAppUi::FetchL Stopped the connection observation."))); + DisconnectL(); + BROWSER_LOG((_L("CBrowserAppUi::FetchL Given iap and Connected iap are not same. Disconnected the existing connection."))); + } + } + + } +#endif // __WINS__ + // iDoNotRestoreContentFlag = EFalse; + + TInt toPop = 0; + TUriParser uriParser; + TInt err = uriParser.Parse(aUrl); + if ( !err && aUrl.Length() ) + { + // check url for missing scheme and add default scheme if needed + HBufC* url = NULL; + HBufC* resultUrlBuf = NULL; + //find :// + TPtrC scheme = uriParser.Extract( EUriScheme ); + // add http:// scheme as default if it is missing + if( scheme.Length() == 0 ) + { + //put the "http://" schema before the string + url = HBufC::NewLC( aUrl.Length() + KDefaultSchemaLength ); + url->Des().Copy( KDefaultSchema ); + url->Des().Append( aUrl ); + ++toPop; // url + resultUrlBuf = CreateFullUrlLC( url->Des(), aUsername, aPassword ); + LogRequestedPageToRecentUrlL( url->Des() ); + } + else + { + resultUrlBuf = CreateFullUrlLC( aUrl, aUsername, aPassword ); + LogRequestedPageToRecentUrlL( aUrl ); + } + ++toPop; // resultUrlBuf + + + if ( aAccessPoint.IsNull() || aAccessPoint.IsDefault() || (!Util::IsValidAPFromParamL( *this, aAccessPoint.ApId() )) ) + { + if ( (Preferences().AccessPointSelectionMode() == EConnectionMethod) || + (Preferences().AccessPointSelectionMode() == EAlwaysAsk) ) + { + iRequestedAp = Preferences().DefaultAccessPoint(); + } + else if ( Preferences().AccessPointSelectionMode() == EDestination ) + { + // for bug fix MLAN-7EKFV4 + iRequestedAp = KWmlNoDefaultAccessPoint; + } + } + else + { + iRequestedAp = aAccessPoint.ApId(); + } +#ifndef __WINSCW__ //On WINS we don't want this dlg to come up + //as the ConnMan will present us with a selection + BROWSER_LOG( ( _L( "requestedAp: %d" ), iRequestedAp ) ); + // it's ok to assign in the case of EDest, since CBrCtl doesn't use the apId passed in LoadUrlL() + TUint32 IAPid = iRequestedAp; + TUint32 defaultSnap = iPreferences->DefaultSnapId(); +#ifndef BRDO_OCC_ENABLED_FF + // if no AP or SNAP is defined, define it + if( (iRequestedAp == KWmlNoDefaultAccessPoint && iPreferences->AccessPointSelectionMode() == EConnectionMethod) || + (defaultSnap == KWmlNoDefaultSnapId && iPreferences->AccessPointSelectionMode() == EDestination) ) + { + StartPreferencesViewL( EShowAlwaysAsk | EShowDestinations | EShowConnectionMethods ); + } + //Check AP and snap if it is still not defined, set always ask mode this case + if ( (iRequestedAp == KWmlNoDefaultAccessPoint && iPreferences->AccessPointSelectionMode() == EConnectionMethod) || + (defaultSnap == KWmlNoDefaultSnapId && iPreferences->AccessPointSelectionMode() == EDestination) ) + { + BROWSER_LOG( ( _L( "AP or SNAP was not added set to Always ask mode" ) ) ); + iPreferences->SetAccessPointSelectionModeL(EAlwaysAsk ); + } + if ( iRequestedAp != KWmlNoDefaultAccessPoint ) + { + BROWSER_LOG( ( _L( "AP added" ) ) ); + IAPid = Util::IapIdFromWapIdL( *this, iRequestedAp ); // Get currently active ap + BROWSER_LOG( ( _L( "Access point: %d" ), IAPid ) ); + } + +#endif // BRDO_OCC_ENABLED_FF +#else //we can use any numbers here + // alr: snap on emulator should not exist; use cm mode instead? + iRequestedAp = 2; + TUint32 IAPid = 2; +#endif //__WINSCW__ + + err = KErrNone; + BROWSER_LOG( ( _L( "Load the URL" ) ) ); + + if ( iPreferences->SearchFeature() || iPreferences->ServiceFeature()) + { + iSpecialSchemeinAddress = EFalse; + + HBufC* searchScheme = HBufC::NewLC( KMaxHomePgUrlLength ); // cleanupstack + TPtr searchSchemePtr( searchScheme->Des() ); + ++toPop; + + HBufC* serviceScheme = HBufC::NewLC( KMaxHomePgUrlLength ); // cleanupstack + TPtr serviceSchemePtr( serviceScheme->Des() ); + ++toPop; + + iPreferences->GetStringValueL( KBrowserSearchProviderUrl, KMaxHomePgUrlLength, searchSchemePtr ); + iPreferences->GetStringValueL( KBrowserServiceUrl, KMaxHomePgUrlLength, serviceSchemePtr ); + + TInt err = uriParser.Parse(searchSchemePtr); + if (!err) + searchSchemePtr = uriParser.Extract( EUriScheme ); + + err = uriParser.Parse(serviceSchemePtr); + if (!err) + serviceSchemePtr = uriParser.Extract( EUriScheme ); + + + if( scheme.Length() != 0 && (!scheme.Compare(serviceSchemePtr) || !scheme.Compare(searchSchemePtr)) ) + { + iSpecialSchemeinAddress = ETrue; + TRAP( err, BrCtlInterface().LoadUrlL( resultUrlBuf->Des(), IAPid ) ); + } + else + { + LoadObserver().DoStartLoad( aUrlType ); + TRAP( err, BrCtlInterface().LoadUrlL( resultUrlBuf->Des(), IAPid ) ); + } + } + else + { + LoadObserver().DoStartLoad( aUrlType ); + BROWSER_LOG( ( _L( "PASSED IAP: %d" ), IAPid ) ); + TRAP( err, BrCtlInterface().LoadUrlL( resultUrlBuf->Des(), IAPid ) ); + } + + CleanupStack::PopAndDestroy(toPop); //resultUrlBuf and url if needed + BROWSER_LOG( ( _L( "No AP 4 %d" ), err ) ); + if ( err != KErrNone ) + { + CancelFetch(); + } + } + + BROWSER_LOG( ( _L( "Check the result" ) ) ); + switch ( err ) + { + case KErrNotFound: + { + (*(CBrowserBookmarksView*)View( KUidBrowserBookmarksViewId )).UpdateGotoPaneL(); + iCoeEnv->HandleError( KBrsrMalformedUrl ); + BROWSER_LOG( ( _L( "KErrNotFound" ) ) ); + break; + } + case KUriUtilsErrInvalidUri: // return value of TUriParser::Parse + { + (*(CBrowserBookmarksView*)View( KUidBrowserBookmarksViewId )).UpdateGotoPaneL(); + iCoeEnv->HandleError( KBrsrUnknownScheme ); + BROWSER_LOG( ( _L( "KUriUtilsErrInvalidUri" ) ) ); + break; + } + case KErrNone: + { + BROWSER_LOG( ( _L( "KErrNone" ) ) ); + ContentView()->ResetPreviousViewFlag(); + break; + } + case KErrCancel: + { + BROWSER_LOG( ( _L( "KErrCancel" ) ) ); + // do nothing, it is already cancelled by CancelFetch(). + break; + } + default: + { + BROWSER_LOG( ( _L( "default" ) ) ); + User::Leave( err ); // pass error code to caller + break; + } + } + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::ExitBrowser() +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::ExitBrowser( TBool aUserInitiated ) + { + LOG_ENTERFN("CBrowserAppUi::ExitBrowser"); + + TInt err( KErrNone ); + TBool isStandAlone = !IsEmbeddedModeOn(); + BROWSER_LOG( ( _L( " isStandAlone: %d" ), isStandAlone ) ); + + if(isStandAlone && aUserInitiated ) + { + if( iStartedUp && !BrCtlInterface().OkToExit() ) + { + return; + } + } + + //If launch with parameters is in progress, do not exit now + //as it can lead to synchronisation problems in embedded mode + if ( iParametrizedLaunchInProgress == 1 ) + { + BROWSER_LOG( ( _L( " iParametrizedLaunchInProgress" ) ) ); + return; + } + + // Operator feature - Display confirmation note on exit only if exit is initiated by user. + // Skip displaying exit confirmation if exit is initiated from fast swap window. + BROWSER_LOG( ( _L( " iPreferences: %d" ), iPreferences ) ); + if ( iPreferences->QueryOnExit() && aUserInitiated ) + { + BROWSER_LOG( ( _L( " iPreferences->QueryOnExit()" ) ) ); + TBool confirmdialog( EFalse ); + TRAP( err, confirmdialog = TBrowserDialogs::ConfirmQueryYesNoL( R_TEXT_WML_EXIT_CONFIRM ) ); + if ( !confirmdialog ) + { + return; + } + } + + //delete attacment from mailer if existing + CCoeEnv::Static()->FsSession().Delete( KAttachment() ); + + BROWSER_LOG( ( _L(" iConnection: %d"), iConnection ) ); + BROWSER_LOG( ( _L(" iExitFromEmbeddedMode: %d"), iExitFromEmbeddedMode ) ); + // if browser is embedded, should not call Exit(), + // just delete the object, otherwise leave occurs. + if( ( IsEmbeddedInOperatorMenu() || IsEmbeddedModeOn() ) && + !ExitInProgress() && iStartedUp && + ((LoadObserver().LoadUrlType() == CBrowserLoadObserver::ELoadUrlTypeEmbeddedBrowserWithUrl) || + (LoadObserver().LoadUrlType() == CBrowserLoadObserver::ELoadUrlTypeOther) ) ) + // ELoadUrlTypeEmbeddedBrowserWithUrl is typical for load via Phonebook, MMS, OperatorMenu + // ELoadUrlTypeOther is typical via Media download since those are via GotoPane entered urls + { + // Simulate an escape key event in order to close any open resources (for example an open dialog) + TKeyEvent keyEvent; + keyEvent.iModifiers = 0; + keyEvent.iRepeats = 0; + keyEvent.iCode = EKeyEscape; + keyEvent.iScanCode = EStdKeyEscape; + TRAP_IGNORE(iCoeEnv->SimulateKeyEventL( keyEvent, EEventKey )); + + // force not to load Exit() when next time call this function, + // just delete the object + SetExitFromEmbeddedMode( ETrue ); + SetExitInProgress( ETrue ); + BROWSER_LOG( ( _L( " iBrowserAsyncExit->Start()" ) ) ); + iBrowserAsyncExit->Start(); + } + else if( iExitFromEmbeddedMode ) + { + BROWSER_LOG( ( _L( " delete this;" ) ) ); + if ( iConnection ) + { + TRAP_IGNORE( SendDisconnectEventL() ); + iConnection->Disconnect(); +#ifdef __RSS_FEEDS + BROWSER_LOG( ( _L( " iFeedsClientUtilities->DisconnectFeedsViewL()" ) ) ); + if ( iFeedsClientUtilities ) + { + TRAP_IGNORE( iFeedsClientUtilities->DisconnectFeedsViewL() ); + //notify feeds engine to close the connection + TRAP_IGNORE( iFeedsClientUtilities->DisconnectManualUpdateConnectionL() ); + } +#endif + } + if (iStartedUp && SpecialLoadObserver().IsConnectionStarted()) + { + BROWSER_LOG( ( _L( " iWindowManager->SetUserExit( iUserExit )" ) ) ); + iWindowManager->SetUserExit( iUserExit ); + delete iWindowManager; + BROWSER_LOG( ( _L( " User::Exit(KErrNone)" ) ) ); + User::Exit(KErrNone); + } + else + { + PrepareToExit(); + Exit(); + } + } + else + { + BROWSER_LOG( ( _L( " Exit()" ) ) ); + if ( iConnection ) + { + TRAP_IGNORE( SendDisconnectEventL() ); + iConnection->Disconnect(); +#ifdef __RSS_FEEDS + if ( iFeedsClientUtilities ) + { + BROWSER_LOG( ( _L( " iFeedsClientUtilities->DisconnectFeedsViewL()" ) ) ); + TRAP_IGNORE( iFeedsClientUtilities->DisconnectFeedsViewL() ); + //notify feeds engine to close the connection + TRAP_IGNORE( iFeedsClientUtilities->DisconnectManualUpdateConnectionL() ); + } +#endif + } + if (iStartedUp && SpecialLoadObserver().IsConnectionStarted()) // If Connection request is in processing calling CAknAppUI::Exit() causes crash (JSAA-84RG9R) + { + //ensure that the params are saved in BrCtl + if ( iWindowManager ) + { + BROWSER_LOG( ( _L( " iWindowManager->SetUserExit( iUserExit )" ) ) ); + iWindowManager->SetUserExit( iUserExit ); + } + delete iWindowManager; + BROWSER_LOG( ( _L( " User::Exit(KErrNone)" ) ) ); + User::Exit(KErrNone); + } + else + { + // normal exit + Exit(); + } + } + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::Display +// ----------------------------------------------------------------------------- +// +MDisplay& CBrowserAppUi::Display() const + { + CBrowserWindow *window = iWindowManager->CurrentWindow(); + __ASSERT_DEBUG( window, Util::Panic( Util::EUninitializedData ) ); + return window->Display(); + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::SoftkeysObserver() +// ----------------------------------------------------------------------------- +// +CBrowserSoftkeysObserver& CBrowserAppUi::SoftkeysObserver() const + { + CBrowserWindow *window = iWindowManager->CurrentWindow(); + __ASSERT_DEBUG( window, Util::Panic( Util::EUninitializedData ) ); + return window->SoftkeysObserver(); + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::CommsModel +// ----------------------------------------------------------------------------- +// +MCommsModel& CBrowserAppUi::CommsModel() const + { + __ASSERT_DEBUG( iCommsModel, + Util::Panic( Util::EUninitializedData ) ); + return *iCommsModel; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::Preferences +// ----------------------------------------------------------------------------- +// +MPreferences& CBrowserAppUi::Preferences() const + { + __ASSERT_DEBUG( iPreferences, + Util::Panic( Util::EUninitializedData ) ); + return *iPreferences; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::Connection +// ----------------------------------------------------------------------------- +// +MConnection& CBrowserAppUi::Connection() const + { + __ASSERT_DEBUG( iConnection, + Util::Panic( Util::EUninitializedData ) ); + return *iConnection; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::BrCtlInterface +// ----------------------------------------------------------------------------- +CBrCtlInterface& CBrowserAppUi::BrCtlInterface() const + { + CBrowserWindow *window = iWindowManager->CurrentWindow(); + __ASSERT_DEBUG( window, Util::Panic( Util::EUninitializedData ) ); + return window->BrCtlInterface(); + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::LoadObserver +// ----------------------------------------------------------------------------- +// +CBrowserLoadObserver& CBrowserAppUi::LoadObserver() const + { + CBrowserWindow *window = iWindowManager->CurrentWindow(); + __ASSERT_DEBUG( window, Util::Panic( Util::EUninitializedData ) ); + return window->LoadObserver(); + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::SpecialLoadObserver +// ----------------------------------------------------------------------------- +// +CBrowserSpecialLoadObserver& CBrowserAppUi::SpecialLoadObserver() const + { + CBrowserWindow *window = iWindowManager->CurrentWindow(); + __ASSERT_DEBUG( window, Util::Panic( Util::EUninitializedData ) ); + return window->SpecialLoadObserver(); + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::DialogsProvider +// ----------------------------------------------------------------------------- +// +CBrowserDialogsProvider& CBrowserAppUi::DialogsProvider() const + { + return *iDialogsProvider; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::PopupEngine +// ----------------------------------------------------------------------------- +// +CBrowserPopupEngine& CBrowserAppUi::PopupEngine() const + { + LOG_ENTERFN("CBrowserAppUi::PopupEngine"); + if(!iPopupEngine) + { + if ( Preferences().UiLocalFeatureSupported( KBrowserMultipleWindows ) ) + { + iPopupEngine = CBrowserPopupEngine::NewL(); + BROWSER_LOG( ( _L( "PopupEngine up" ) ) ); + } + } + return *iPopupEngine; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::WindowMgr() +// ----------------------------------------------------------------------------- +// +CBrowserWindowManager& CBrowserAppUi::WindowMgr() const + { + return *iWindowManager; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::IsCancelFetchAllowed +// ----------------------------------------------------------------------------- +// +TBool CBrowserAppUi::IsCancelFetchAllowed() const + { + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::UpdateCbaL() +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::UpdateCbaL() + { + if( ActiveView() ) + { + ActiveView()->UpdateCbaL(); + } + } + +void CBrowserAppUi::LogAccessToRecentUrlL( CBrCtlInterface& aBrCtlInterface ) + { + if ((ADAPTIVEBOOKMARKS)&&(!(Preferences().AdaptiveBookmarks()==EWmlSettingsAdaptiveBookmarksOff ))) + { + HBufC* url = aBrCtlInterface.PageInfoLC( TBrCtlDefs::EPageInfoUrl ); + HBufC* name = aBrCtlInterface.PageInfoLC( TBrCtlDefs::EPageInfoTitle ); + if( url && url->Length() ) + { + // If url is same as the one in the store delete it because the url will be rewritten + // along with the name + iRecentUrlStore->DeleteData(*url); + + TInt index; + index = url->Des().LocateReverse(KSlash); + // If the only difference between the url in the store and the one we are writing is a "/" + // at the end of the url, delete the one in the store because it will be rewritten along + // with the name + if (index == url->Length()-1) + { + HBufC* urlwoslash = HBufC::NewLC( url->Length() ); + urlwoslash->Des().Copy( *url ); + urlwoslash->Des().Delete(url->Length() -1, 2); + + iRecentUrlStore->DeleteData(*urlwoslash); + + CleanupStack::PopAndDestroy(); //urlwoslash + } + + if (name && name->Length()) + { + iRecentUrlStore->SaveDataL(*url,*name); + } + else + { + if (url->Length() > KFavouritesMaxName) + { + // name will be the url but it needs to be compressed to fit max name length + HBufC* cname = HBufC::NewLC(KFavouritesMaxName); + TInt edgeStringLen = ((KFavouritesMaxName / 2) - 3); + TPtrC cnameRight( url->Right( edgeStringLen ) ); + TPtrC cnameLeft( url->Left( edgeStringLen )); + TPtr cnameDes = cname->Des(); + + cnameDes.Append( cnameLeft ); + cnameDes.AppendFill( TChar(KDot),5 ); // '.....' + cnameDes.Append( cnameRight ); + iRecentUrlStore->SaveDataL(*url,*cname); + CleanupStack::PopAndDestroy();//cname + } + else + { + iRecentUrlStore->SaveDataL(*url,*url); + } + } + } + CleanupStack().PopAndDestroy(2); // url, name + } + } + +void CBrowserAppUi::LogRequestedPageToRecentUrlL( const TDesC& aUrl ) + { + if ((ADAPTIVEBOOKMARKS)&&(!(Preferences().AdaptiveBookmarks()==EWmlSettingsAdaptiveBookmarksOff ))) + { + HBufC *url = HBufC::NewLC( aUrl.Length() ); + url->Des().Copy( aUrl ); + + if( url && url->Length() ) + { + if (url->Length() > KFavouritesMaxName) + { + // name will be the url but it needs to be compressed to fit max name length + HBufC* cname = HBufC::NewLC(KFavouritesMaxName); + TInt edgeStringLen = ((KFavouritesMaxName / 2) - 3); + TPtrC cnameRight( url->Right( edgeStringLen ) ); + TPtrC cnameLeft( url->Left( edgeStringLen )); + TPtr cnameDes = cname->Des(); + + cnameDes.Append( cnameLeft ); + cnameDes.AppendFill( TChar(KDot),5 ); // '.....' + cnameDes.Append( cnameRight ); + iRecentUrlStore->SaveDataL(*url,*cname); + CleanupStack::PopAndDestroy();//cname + } + else + { + iRecentUrlStore->SaveDataL(*url,*url); + } + } + CleanupStack().PopAndDestroy(); // url + } + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::SwitchWindowL() +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::SwitchWindowL() + { +LOG_ENTERFN("CBrowserAppUi::SwitchWindowL"); + CArrayFixFlat* windowBuf = iWindowManager->GetWindowInfoL( this ); + CleanupStack::PushL( windowBuf ); + + // Open 'Switch Window' selection dialog + HBufC* title = StringLoader::LoadLC( R_BROWSER_SWITCH_WINDOW_HEADER ); + + CArrayFixFlat* optDataArray = new ( ELeave ) + CArrayFixFlat( KGranularityMedium ); + CleanupStack::PushL( optDataArray ); + + TInt i( 0 ); + TInt numWindows = windowBuf->Count(); + +LOG_WRITE_FORMAT("Window's count: %d", numWindows ); + for ( i = 0; i < numWindows; ++i ) + { + TBrCtlSelectOptionData optData( *((*windowBuf)[i]->iWindowText), + (*windowBuf)[i]->iCurrent, + EFalse, + EFalse ); + optDataArray->AppendL( optData ); + } + + TBool ret = DialogsProvider().DialogSelectOptionL( *title, + ESelectTypeSingle, + *optDataArray ); + if ( ret ) + { + for( i = 0; i < numWindows; ++i) + { + if( (*optDataArray)[i].IsSelected() ) + { + LOG_WRITE_FORMAT("Selected window: %d", (*windowBuf)[i]->iWindowId ); + iWindowManager->SwitchWindowL( (*windowBuf)[i]->iWindowId ); + break; + } + } + } + CleanupStack::PopAndDestroy( 3 ); // optDataArray, title, windowBuf + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::SetCalledFromAnotherApp +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::SetCalledFromAnotherApp( TBool aValue ) + { + iCalledFromAnotherApp = aValue; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::CalledFromAnotherApp +// ----------------------------------------------------------------------------- +// +TBool CBrowserAppUi::CalledFromAnotherApp() + { + return iCalledFromAnotherApp; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::NoHomePageToBeLaunchedL +// ----------------------------------------------------------------------------- +// +TBool CBrowserAppUi::NoHomePageToBeLaunchedL() + { + LOG_ENTERFN("CBrowserAppUi::NoHomePageToBeLaunchedL"); + TWmlSettingsHomePage pgtype = iPreferences->HomePageType(); + TBool alwaysAskCase = (( Preferences().AccessPointSelectionMode() == EAlwaysAsk ) && + ( EWmlSettingsHomePageAccessPoint == pgtype )); + BROWSER_LOG( ( _L( "pgtype: %d, alwaysAsk: %d" ), pgtype, alwaysAskCase ) ); + + if( ( pgtype == EWmlSettingsHomePageBookmarks ) || alwaysAskCase ) + { // Can't load home page since set to Bookmarks or (AlwaysAsk AP and homepage set to AP homepage) + return ETrue; + } + else + { + // now check for other cases where homepage string might be defined and will be used + HBufC* buf = HBufC::NewLC( KMaxHomePgUrlLength ); // cleanupstack + TPtr ptr( buf->Des() ); + TInt pgFound = Preferences().HomePageUrlL( ptr ); + CleanupStack::PopAndDestroy( buf ); + if (pgFound != KErrNone) + { // no homepage string found + return ETrue; + } + else + { // homepage string was found + return EFalse; + } + } + } + +// CBrowserAppUi::ProcessCommandParametersL() +// ----------------------------------------------------------------------------- +// +TBool CBrowserAppUi::ProcessCommandParametersL( TApaCommand aCommand, + TFileName& /*aDocumentName*/ , + const TDesC8& /*aTail*/ ) + { + LOG_ENTERFN("CBrowserAppUi::ProcessCommandParametersL"); + LOG_WRITE_FORMAT(" aCommand: %d", aCommand); + + // The browser is in embedded mode and it is not initialized yet + if ( IsEmbeddedModeOn() && !iStartedUp) + { + EnableLocalScreenClearer( EFalse ); + return EFalse; + } + + if ( aCommand == EApaCommandOpen ) + { + //Startup parameters are given to browser at CBrowserAppDocument::OpenFileL(). + //- a part of shell starting (ConstructAppFromCommandLineL calls OpenFileL) + } + + else if ( aCommand == EApaCommandRun ) + { + + if ( LastActiveViewId() == KUidBrowserNullViewId ) + { + TBool specialSchemeInHomePageAddress = EFalse; + + if (NoHomePageToBeLaunchedL()) + { + // No homepage to be launched so start browser in bookmarks view + SetLastActiveViewId(KUidBrowserBookmarksViewId); + } + else if ( iPreferences->SearchFeature() || iPreferences->ServiceFeature()) + { + + HBufC* buf = HBufC::NewLC( KMaxHomePgUrlLength ); // cleanupstack + TPtr ptr( buf->Des() ); + TInt pgFound( KErrNotFound ); + pgFound = Preferences().HomePageUrlL( ptr ); + HBufC* searchScheme = HBufC::NewLC( KMaxHomePgUrlLength ); // cleanupstack + TPtr searchSchemePtr( searchScheme->Des() ); + + HBufC* serviceScheme = HBufC::NewLC( KMaxHomePgUrlLength ); // cleanupstack + TPtr serviceSchemePtr( serviceScheme->Des() ); + + iPreferences->GetStringValueL( KBrowserSearchProviderUrl, KMaxHomePgUrlLength, searchSchemePtr ); + iPreferences->GetStringValueL( KBrowserServiceUrl, KMaxHomePgUrlLength, serviceSchemePtr ); + + + if( !ptr.Compare(serviceSchemePtr) || !ptr.Compare(searchSchemePtr) ) + { + specialSchemeInHomePageAddress = ETrue; + SetLastActiveViewId(KUidBrowserBookmarksViewId); + SetViewToBeActivatedIfNeededL(KUidBrowserContentViewId, 0); + TRAPD( err, FetchL( ptr, CBrowserLoadObserver::ELoadUrlTypeOther ) ); + } + else + { + SetViewToBeActivatedIfNeededL(KUidBrowserContentViewId, 0); + StartFetchHomePageL(); + } + CleanupStack::PopAndDestroy( 3,buf ); + } + else + { + SetViewToBeActivatedIfNeededL(KUidBrowserContentViewId, 0); + StartFetchHomePageL(); + } + + if( !specialSchemeInHomePageAddress ) + { + if( iCurrentView != iLastViewId ) + ActivateLocalViewL( LastActiveViewId() ); + } + } + } + else if ( aCommand == EApaCommandViewActivate ) + // Get when activated from soft notification (Downloads List). + // Must behave as in case of EApaCommandOpen, but no OpenFileL() is called. + { + ParseAndProcessParametersL( KNullDesC8 ); + } + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::Static() +// ----------------------------------------------------------------------------- +// +CBrowserAppUi* CBrowserAppUi::Static() + { + return REINTERPRET_CAST( CBrowserAppUi*, CEikonEnv::Static()->EikAppUi() ); + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::ParseAndProcessParametersL +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::ParseAndProcessParametersL( const TDesC8& aDocumentName, TBool aDoFetch ) + { + LOG_ENTERFN("CBrowserAppUi::ParseAndProcessParametersL"); + TInt err = KErrNone; + + TUid ViewToActivate = { 0 }; + + HBufC8* params = NULL; + TLex8 parameter(aDocumentName); + + // Here we check if the url contains control characters. + TBool urlError( EFalse ); // If there is a Control caracter in the url. + parameter.Mark(); // Save the start position in the string. + while ( !parameter.Eos() && !urlError ) + { + if ( parameter.Get().IsControl() ) + { + urlError = ETrue; + } + } + parameter.UnGetToMark(); // Now go back to the beginning of the string. + + //Check for parameter validity + if( !parameter.Peek().IsDigit() || urlError ) //First char of aDocumentName is NOT a digit + { + if( ( aDocumentName.Locate( ':' ) > 0) && (!urlError) ) //There is a ":" character in aDocumentName (->probably a valid url) + { + //Add "4" + before the given parameter to make the parameter legal for url launch + _LIT8(KUrlId, "4 "); + params = HBufC8::NewL(aDocumentName.Length() + 2 + 1); + params->Des().Copy( KUrlId ); + params->Des().Append(aDocumentName); + params->Des().ZeroTerminate(); + ViewToActivate = KUidBrowserContentViewId; + } + else + { + //Activate bookmarks view if parameters are invalid and browser is not embedded. + // In embedded mode bookmarks are not shown, so if there is an + // error in the url, we make the browser to pop up a + // "Page not found" note, by defining a not existing url. + if ( IsEmbeddedModeOn() ) + { + params = HBufC8::NewL( 10 ); + params->Des().Copy(_L8("4 http://") ); + } + else + { + params = HBufC8::NewL(aDocumentName.Length() + 1 ); + params->Des().Copy(aDocumentName); + } + params->Des().ZeroTerminate(); + ViewToActivate = KUidBrowserBookmarksViewId; + } + } + else + { + params = HBufC8::NewL(aDocumentName.Length() + 1); + params->Des().Copy(aDocumentName); + params->Des().ZeroTerminate(); + ViewToActivate = KUidBrowserContentViewId; + } + CleanupStack::PushL( params ); + + //Set view to activate if no view yet activated + if ( LastActiveViewId() == KUidBrowserNullViewId ) + { + SetLastActiveViewId(ViewToActivate); + } + + CBrowserCommandLineParser8* command = CBrowserCommandLineParser8::NewL( *params ); + CleanupStack::PopAndDestroy( params ); + CleanupStack::PushL( command ); + + + // complete the delayed initialization if bookmarks view is not the first view + if(ViewToActivate != KUidBrowserBookmarksViewId && !iStartedUp) + CompleteDelayedInit(); + + //wait a while, contentview initializing itself + WaitCVInit(); + switch ( command->Count() ) + { + case 0: + { + SetViewToBeActivatedIfNeededL( LastActiveViewId() ); + break; + } + case 1: + { + if ( !aDocumentName.Compare( KLongZeroIdString ) ) + { + // Long 0 is pressed and Browser is started up for the first time... + // if no AP or SNAP is defined, define it + TUint32 defaultAp = iPreferences->DefaultAccessPoint(); + TUint32 defaultSnap = iPreferences->DefaultSnapId(); + // AP or SNAP is not defined + if( (defaultAp == KWmlNoDefaultAccessPoint && iPreferences->AccessPointSelectionMode() == EConnectionMethod) || + (defaultSnap == KWmlNoDefaultSnapId && iPreferences->AccessPointSelectionMode() == EDestination) ) + { + StartPreferencesViewL( EShowAlwaysAsk | EShowDestinations | EShowConnectionMethods ); + } + // If there is a homepage url then try to fetch it + if ( !NoHomePageToBeLaunchedL() ) + { + iLongZeroPressed = ETrue; + FetchHomePageL(); + } + else + { + if (iStartedUp) + ContentView()->SetFullScreenOffL(); + + if ( !IsEmbeddedModeOn() ) + { + SetLastActiveViewId( KUidBrowserBookmarksViewId ); + } + } + } + SetViewToBeActivatedIfNeededL( LastActiveViewId() ); + break; + } + case 2: + case 3: + { + // UID and wml adress and optional access point UID + + TUint typeId; + TInt dataId; + TLex8 param0( command->Param( 0 ) ); + TLex8 param1( command->Param( 1 ) ); + err = param0.Val( typeId ); + if ( !err ) + { + BROWSER_LOG( ( _L( " typeId: %d" ), typeId ) ); + + if ( typeId == KUrlId ) + { // FIX THIS! + TUriParser8 uri8; + err = uri8.Parse(command->Param(1)); // what if parsing fails? + User::LeaveIfError(err); + // Url decoding section was removed from here. + HBufC* url = HBufC::NewL(command->Param(1).Length()+1); + url->Des().Copy( command->Param(1) ); + CleanupStack::PushL(url); + BROWSER_LOG( ( _L( " url: %S" ), url ) ); + + TFavouritesWapAp accessPoint; // Initially "default". + BROWSER_LOG( ( _L( " Count: %d" ), command->Count() ) ); + if ( command->Count() == 3 ) + { + // URL Typeid, url, ap + TUint ap; + TLex8 param2( command->Param( 2 ) ); + err = param2.Val( ap ); + if ( !err ) + { + BROWSER_LOG( ( _L( " ap: %d" ), ap ) ); + if (iSuppressAlwaysAsk) + { + // Always ask was temporarily disabled, enable it again + iPreferences->SetAccessPointSelectionModeL(EAlwaysAsk); + + iSuppressAlwaysAsk = EFalse; + } + + // Note: OTA Provisioning application requires the + // KBrowserAccessPointSelectionMode key value to be + // read directly from cenrep, rather than use the + // cached cenrep value taken at browser initialization + // time. + TInt selectionMode; + + CRepository* repository = CRepository::NewLC( KCRUidBrowser ); + User::LeaveIfError( repository->Get( KBrowserAccessPointSelectionMode, selectionMode ) ); + CleanupStack::PopAndDestroy( repository ); + + // If selectionMode cenrep value is always ask, then + // temporarily change selection mode + if ( EBrowserCenRepApSelModeAlwaysAsk == selectionMode ) + { + iSuppressAlwaysAsk = ETrue; + iPreferences->SetAccessPointSelectionModeL(EConnectionMethod); + } + accessPoint.SetApId( ap ); + SetCalledFromAnotherApp( ETrue ); + CBrowserLoadObserver::TBrowserLoadUrlType urlType = + IsEmbeddedModeOn() ? + CBrowserLoadObserver::ELoadUrlTypeEmbeddedBrowserWithUrl : + CBrowserLoadObserver::ELoadUrlTypeOther; + if( IsPageLoaded() && + !(WindowMgr().CurrentWindow()->HasWMLContent(EFalse)) && + Preferences().UiLocalFeatureSupported( KBrowserMultipleWindows ) && + !Preferences().UiLocalFeatureSupported( KBrowserMinimalMultipleWindows )) + { + // Cancel history view, mini map, toolbar or any other active control on the current window + BrCtlInterface().HandleCommandL( TBrCtlDefs::ECommandCancel + TBrCtlDefs::ECommandIdBase ); + // there is already a window, so create a new one + CBrowserWindow *win = WindowMgr().CreateWindowL( 0, &KNullDesC ); + if (win != NULL) + { + + CleanupStack::PushL( win ); + WindowMgr().SwitchWindowL( win->WindowId() ); + TRAP( err, FetchL( *url, + KNullDesC, + KNullDesC, + accessPoint, + urlType ) ); + CleanupStack::Pop(); // win + SetLastActiveViewId( KUidBrowserContentViewId ); + } + } + else + { + // Cancel history view, mini map, toolbar or any other active control on the current window + if (iStartedUp) + BrCtlInterface().HandleCommandL( TBrCtlDefs::ECommandCancel + TBrCtlDefs::ECommandIdBase ); + TRAP( err, FetchL( *url, + KNullDesC, + KNullDesC, + accessPoint, + urlType ) ); + SetLastActiveViewId( KUidBrowserContentViewId ); + } + } + } + else + { + // URL Typeid, url + SetCalledFromAnotherApp( ETrue ); + + if ( aDoFetch ) + { + CBrowserLoadObserver::TBrowserLoadUrlType urlType = + IsEmbeddedModeOn() ? + CBrowserLoadObserver::ELoadUrlTypeEmbeddedBrowserWithUrl : + CBrowserLoadObserver::ELoadUrlTypeOther; + if( IsPageLoaded() && + !(WindowMgr().CurrentWindow()->HasWMLContent(EFalse)) && + Preferences().UiLocalFeatureSupported( KBrowserMultipleWindows ) && + !Preferences().UiLocalFeatureSupported( KBrowserMinimalMultipleWindows )) + { + // Cancel history view, mini map, toolbar or any other active control on the current window + BrCtlInterface().HandleCommandL( TBrCtlDefs::ECommandCancel + TBrCtlDefs::ECommandIdBase ); + // there is already a window, so create a new one + CBrowserWindow *win = NULL; + if(WindowMgr().CurrentWindow()) + { + if(iSameWinApp) + { + //We will be using same/already opened window if call is from external + //application. So no new windows will be opened. + win = WindowMgr().CurrentWindow(); + iWindowIdFromFromExternApp = win->WindowId(); + } + if(!win) + { + //If not called from external app, then create window. + win = WindowMgr().CreateWindowL( (WindowMgr().CurrentWindow()->WindowId()) ? WindowMgr().CurrentWindow()->WindowId() : 0, &KNullDesC ); + } + } + else + win = WindowMgr().CreateWindowL( 0, &KNullDesC ); + if (win != NULL) + { + + CleanupStack::PushL( win ); + WindowMgr().SwitchWindowL( win->WindowId() ); + TRAP( err, FetchL( *url, + KNullDesC, + KNullDesC, + accessPoint, + urlType ) ); + CleanupStack::Pop(); // win + } + } + else + { + // Cancel history view, mini map, toolbar or any other active control on the current window + if (iStartedUp) + BrCtlInterface().HandleCommandL( TBrCtlDefs::ECommandCancel + TBrCtlDefs::ECommandIdBase ); + TRAP( err, FetchL( *url, + KNullDesC, + KNullDesC, + accessPoint, + urlType ) ); + } + } + if (err==KErrNone) + { + SetLastActiveViewId(ViewToActivate); + } + } + CleanupStack::PopAndDestroy(); // url + } + else if( typeId == KLaunchFeeds ) + { + // Special facility to launch non-embedded into the feeds view + if( !iBrowserAlreadyRunning ) + { + SetOverriddenLaunchContextId(EBrowserContextIdFeeds); + SetLastActiveViewId( KUidBrowserFeedsFolderViewId ); + } + LaunchIntoFeedsL(); + } + else + { + err = param1.Val( dataId ); + if ( !err ) + { + switch ( typeId ) + { + case KBookmarkId: + { + // Bookmark typeid, uid + SetCalledFromAnotherApp( ETrue ); + + if( IsPageLoaded() && + !(WindowMgr().CurrentWindow()->HasWMLContent(EFalse)) && + Preferences().UiLocalFeatureSupported( KBrowserMultipleWindows ) && + !Preferences().UiLocalFeatureSupported( KBrowserMinimalMultipleWindows )) + { + // Cancel history view, mini map, toolbar or any other active control on the current window + BrCtlInterface().HandleCommandL( TBrCtlDefs::ECommandCancel + TBrCtlDefs::ECommandIdBase ); + // there is already a window, so create a new one + CBrowserWindow *win = WindowMgr().CreateWindowL( 0, &KNullDesC ); + if (win != NULL) + { + CleanupStack::PushL( win ); + WindowMgr().SwitchWindowL( win->WindowId() ); + TRAP( err, FetchBookmarkL( dataId ) ); + CleanupStack::Pop(); // win + } + } + else + { + // Cancel history view, mini map, toolbar or any other active control on the current window + if (iStartedUp) + BrCtlInterface().HandleCommandL( TBrCtlDefs::ECommandCancel + TBrCtlDefs::ECommandIdBase ); + TRAP( err, FetchBookmarkL( dataId ) ); + } + + if ( err ) + { + // Unable to fetch bookmark + TBrowserDialogs::InfoNoteL( + R_BROWSER_INFO_NOTE, R_WML_UNABLE_TO_FETCH_BOOKMARK ); + } + if (err==KErrNone) + { + SetLastActiveViewId(ViewToActivate); + } + + break; + } + case KFolderId: + { + SetCalledFromAnotherApp( EFalse ); + iIsForeground = IsForeground(); + CloseContentViewL(); + SetLastActiveViewId( KUidBrowserBookmarksViewId ); + break; + } + default: + { + // Typeid was not readable + // TBD: error message! + break; + } + } + } + else + { + // Dataid was not readable + User::Leave( err ); + } + } + } + else + { + // Sender Uid was not readable + User::Leave( err ); + } + if( !iSpecialSchemeinAddress ) + { + SetViewToBeActivatedIfNeededL( LastActiveViewId() ); + } + break; + } + + default: + { + SendBrowserToBackground(); + break; + } + } + CleanupStack::PopAndDestroy(); // command + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::WaitCVInit +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::WaitCVInit() + { + if( iParametrizedLaunchInProgress == 0 && iStartedUp) + { + iParametrizedLaunchInProgress = 1; + iIdle->Cancel(); + iIdle->Start( TCallBack( StopDelay, this ) ); + iWait.Start(); + iParametrizedLaunchInProgress = 2; + } + } +void CBrowserAppUi::StopConnectionObserving() + { + LOG_ENTERFN("CBrowserAppUi::StopConnectionObserving"); + if ( iConnStageNotifier && iConnStageNotifier->IsActive() ) + { + BROWSER_LOG( ( _L( " CBrowserAppUi::StopConnectionObserving Cancelling Observer" ) ) ); + iConnStageNotifier->Cancel(); + } + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::ConnNeededStatusL +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::ConnNeededStatusL( TInt aErr ) + { + LOG_ENTERFN("CBrowserAppUi::ConnNeededStatusL"); + UpdateSoftKeys(); + if (iSuppressAlwaysAsk) + { + // Always ask was temporarily disabled, after creating the network connection, enable it again + iPreferences->SetAccessPointSelectionModeL(EAlwaysAsk); + iSuppressAlwaysAsk = EFalse; + } + if ( aErr != KErrNone ) + { + if( iCalledFromAnotherApp ) + { + // This function call should be replaced by ExitBrowser(ETrue) + // so that the blank content view is not displayed. + // SendBrowserToBackground(); + } + // if any error, return Cancel to Kimono. + return; + } + + BROWSER_LOG( ( _L( " CBrowserAppUi::ConnNeededStatusL First Stop Connection Observer" ) ) ); + StopConnectionObserving(); //Need to stop the connection observer first + + + if ( !iConnStageNotifier->IsActive() ) + { + BROWSER_LOG( ( _L( " CBrowserAppUi::ConnNeededStatusL Starting Connection Observer" ) ) ); + TName* connectionName = Connection().ConnectionNameL(); + CleanupStack::PushL( connectionName ); + + iConnStageNotifier->StartNotificationL(connectionName, KLinkLayerClosed, this); + + CleanupStack::PopAndDestroy(); //connectionName + } + } + + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::SendBrowserToBackground +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::SendBrowserToBackground() + { + TApaTaskList taskList( CEikonEnv::Static()->WsSession() ); + + // Browser might be embedded. + TUid appUid; + if ( iEmbeddingApplicationUid != KNullUid ) + { + appUid = iEmbeddingApplicationUid; + } + else + { + appUid = KUidBrowserApplication; + } + TApaTask task = taskList.FindApp( appUid ); + task.SendToBackground(); + } + + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::CreateWindowInfoLC() +// ----------------------------------------------------------------------------- +// +HBufC* CBrowserAppUi::CreateWindowInfoLC( const CBrowserWindow& aWindow ) + { + HBufC* buf = aWindow.BrCtlInterface().PageInfoLC( TBrCtlDefs::EPageInfoTitle ); + if( !buf || !buf->Length() ) + { + CleanupStack::PopAndDestroy( buf ); + buf = aWindow.BrCtlInterface().PageInfoLC( TBrCtlDefs::EPageInfoUrl ); + if( !buf ) + { + + CleanupStack::PopAndDestroy( buf ); + buf = KNullDesC().AllocLC(); + } + } + return buf; + } + +#ifdef BRDO_OCC_ENABLED_FF +// ----------------------------------------------------------------------------- +// CBrowserContentView::SetRetryFlag +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::SetRetryFlag(TBool flag) + { + LOG_ENTERFN("CBrowserAppUi::SetRetryFlag"); + BROWSER_LOG( ( _L(" CBrowserAppUi::SetRetryFlag flag: %d"), flag ) ); + reConnectivityFlag = flag; + } + +// ----------------------------------------------------------------------------- +// CBrowserContentView::GetRetryFlag +// ----------------------------------------------------------------------------- +// + TBool CBrowserAppUi::GetRetryFlag() + { + LOG_ENTERFN("CBrowserAppUi::GetRetryFlag"); + BROWSER_LOG( ( _L(" CBrowserAppUi::GetRetryFlag flag: %d"), reConnectivityFlag ) ); + return reConnectivityFlag; + } + +// ----------------------------------------------------------------------------- +// CBrowserContentView::RetryConnectivity +// ----------------------------------------------------------------------------- +// +TInt CBrowserAppUi::RetryConnectivity(TAny* aCBrowserAppUi) + { + LOG_ENTERFN("CBrowserAppUi::RetryConnectivity"); + __ASSERT_DEBUG(aCBrowserAppUi, Util::Panic( Util::EUninitializedData )); + + TInt err = ((CBrowserAppUi*)aCBrowserAppUi)->RetryInternetConnection(); + + BROWSER_LOG( ( _L(" CBrowserAppUi::RetryConnectivity Error: %d"), err ) ); + return err; + } + +TInt CBrowserAppUi::RetryInternetConnection() + { + LOG_ENTERFN("CBrowserAppUi::RetryInternetConnection"); + //First cancel the timer + if ( iRetryConnectivity && iRetryConnectivity->IsActive() ) + { + iRetryConnectivity->Cancel(); + BROWSER_LOG( ( _L( "CBrowserAppUi::RetryInternetConnection Timer Cancelled successfully " ) ) ); + } + TInt err = KErrNone; + if ( !iConnection->Connected() ) + { + TRAP_IGNORE( err = iConnection->StartConnectionL( ETrue ) ); + } + if( err == KErrNone ) + { + BROWSER_LOG( ( _L( "CBrowserAppUi::RetryInternetConnection Connection restablished successfully " ) ) ); + + BROWSER_LOG( ( _L( "CBrowserAppUi::RetryInternetConnection UNSET retry flags " ) ) ); + TRAP_IGNORE( BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandUnSetRetryConnectivityFlag + (TInt)TBrCtlDefs::ECommandIdBase ) ); + SetRetryFlag(EFalse); + + TRAP_IGNORE(ConnNeededStatusL(err)); //Start the observer again + TRAP_IGNORE( BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandRetryTransactions + (TInt)TBrCtlDefs::ECommandIdBase ) ); + //Let download manager knows about this new connection + TRAP_IGNORE( BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandConnToDownloadManager + (TInt)TBrCtlDefs::ECommandIdBase ) ); + } + else + { + BROWSER_LOG( ( _L( "CBrowserAppUi::RetryInternetConnection Connection failed " ) ) ); + BROWSER_LOG( ( _L( "CBrowserAppUi::RetryInternetConnection unset retry flags " ) ) ); + TRAP_IGNORE( BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandUnSetRetryConnectivityFlag + (TInt)TBrCtlDefs::ECommandIdBase ) ); + SetRetryFlag(EFalse); + BROWSER_LOG( ( _L( "CBrowserAppUi::RetryInternetConnection clear queued transactions " ) ) ); + TRAP_IGNORE( BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandClearQuedTransactions + (TInt)TBrCtlDefs::ECommandIdBase ) ); + Display().StopProgressAnimationL(); //Stop Progress animation + if ( Fetching() ) + { + BROWSER_LOG( ( _L( "CBrowserAppUi::RetryInternetConnection cancel fetch " ) ) ); + CancelFetch(); + } + iDialogsProvider->UploadProgressNoteL(0, 0, ETrue, (MBrowserDialogsProviderObserver *)this ); //Close the uploading dialog. + iDialogsProvider->CancelAll(); //connection has been lost, so cancel the authentication dialog. + } + + return err; + } + +void CBrowserAppUi::CheckOccConnectionStage() + { + LOG_ENTERFN("CBrowserAppUi::CheckOccConnectionStage"); + + //Disconnect first + BROWSER_LOG( ( _L( "CBrowserAppUi::CheckOccConnectionStage Disconnecting..." ) ) ); + iConnection->Disconnect(); + + TNifProgressBuf buf = iConnStageNotifier->GetProgressBuffer(); + if( buf().iError == KErrDisconnected ) + { + BROWSER_LOG( ( _L("CBrowserAppUi::CheckOccConnectionStage This is OCC roaming error : %d"), buf().iError ) ); + BROWSER_LOG( ( _L( "CBrowserAppUi::CheckOccConnectionStage Set retry flags " ) ) ); + TRAP_IGNORE( BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandSetRetryConnectivityFlag + (TInt)TBrCtlDefs::ECommandIdBase ) ); + SetRetryFlag(ETrue); + TRAP_IGNORE( BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandCancelQueuedTransactions + (TInt)TBrCtlDefs::ECommandIdBase ) ); + + if( iRetryConnectivity && iRetryConnectivity->IsActive()) + { + iRetryConnectivity->Cancel(); + } + iRetryConnectivity->Start(KRetryConnectivityTimeout, 0,TCallBack(RetryConnectivity,this)); + } + else + { + BROWSER_LOG( ( _L("CBrowserAppUi::CheckOccConnectionStage This is NOT OCC roaming error : %d"), buf().iError ) ); + Display().StopProgressAnimationL(); + if ( Fetching() ) + { + CancelFetch(); + } + iDialogsProvider->UploadProgressNoteL(0, 0, ETrue, (MBrowserDialogsProviderObserver *)this ); + iDialogsProvider->CancelAll(); + } + } +#endif + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::ConnectionStageAchievedL() +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::ConnectionStageAchievedL() + { +#ifdef BRDO_OCC_ENABLED_FF + LOG_ENTERFN("CBrowserAppUi::ConnectionStageAchievedL"); + CheckOccConnectionStage(); +#else + // this function is called only when network is lost + // because we set notifier for KAgentUnconnected only + Display().StopProgressAnimationL(); + if ( Fetching() ) + { + CancelFetch(); + } + //Close the uploading dialog. + iDialogsProvider->UploadProgressNoteL( + 0, 0, ETrue, (MBrowserDialogsProviderObserver *)this ); + //connection has been lost, so cancel the authentication dialog. + iDialogsProvider->CancelAll(); + // SendDisconnectEventL(); + // not needed as by that point HTTPSession was already shutdown by executing disconnect menu option + // will cause a crash when user tries to quickly reconnect right after disconnecting, as HTTP session + // is starting to initialize, while this call is trying to close it. +#endif + } + + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::UpdateSoftKeys +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::UpdateSoftKeys() + { + TRAP_IGNORE( UpdateCbaL() ); + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::DeleteCookiesL +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::DeleteCookiesL() + { + // stringPool is not needed to initialize + RStringPool stringPool; + RCookieManager cookieManager( stringPool ); + TInt num(0); + + User::LeaveIfError( cookieManager.Connect() ); + CleanupClosePushL( cookieManager ); + User::LeaveIfError( cookieManager.ClearCookies( num ) ); + CleanupStack::PopAndDestroy( &cookieManager ); + + stringPool.Close(); + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::LaunchHomePageL +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::LaunchHomePageL() + { + LOG_ENTERFN( "CBrowserAppUi::LaunchHomePageL" ); + TWmlSettingsHomePage pgtype = iPreferences->HomePageType(); + TBool alwaysAskCase = (( Preferences().AccessPointSelectionMode() == EAlwaysAsk ) && + ( EWmlSettingsHomePageAccessPoint == pgtype )); + BROWSER_LOG( ( _L( "pgtype: %d, alwaysAsk: %d" ), pgtype, alwaysAskCase ) ); + + if( ( pgtype == EWmlSettingsHomePageBookmarks ) || alwaysAskCase ) + // Bookmarks is selected as HomePage + // has effect only for startup, otherwise 'Home' command is not shown + { + ContentView()->SetFullScreenOffL(); + // view change will be done somewhere else + SetLastActiveViewId( KUidBrowserBookmarksViewId ); + SetViewToBeActivatedIfNeededL( LastActiveViewId() ); + return; + } + + HBufC* buf = HBufC::NewLC( KMaxHomePgUrlLength ); // cleanupstack + TPtr ptr( buf->Des() ); + TInt pgFound( KErrNotFound ); + + pgFound = Preferences().HomePageUrlL( ptr ); + BROWSER_LOG( ( _L( "pgFound 1: %d" ), pgFound ) ); + + + if( pgFound == KErrNone ) // Home page url found, fetch the url + { + SetLastActiveViewId( KUidBrowserContentViewId ); + FetchL( ptr ); + } + else // Home page not found, or not defined, go to BookMarksView + { + TVwsViewId activeViewId; + if( ( GetActiveViewId( activeViewId ) != KErrNone ) || + ( activeViewId.iViewUid == KUidBrowserContentViewId ) ) + { + ContentView()->SetFullScreenOffL(); + } + SetLastActiveViewId( KUidBrowserBookmarksViewId ); + SetViewToBeActivatedIfNeededL( LastActiveViewId() ); + } + CleanupStack::PopAndDestroy( buf ); + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::ClearTheCacheL +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::ClearTheCacheL(TBool afterQuery, TBool aShowDoneNote) + { + TUint32 totalBytesFlushed = BrCtlInterface().ClearCache(); + if(afterQuery || totalBytesFlushed) + { + + HBufC* resultText = NULL; + HBufC* tempText = NULL; + TBuf<12> totalText; + + totalText.Num ((TInt)totalBytesFlushed); + + resultText = StringLoader::LoadLC( R_TEXT_WML_CACHE_EMPTIED_NOTE); + //CleanupStack::PushL(resultText); + tempText = HBufC::NewLC( resultText->Length() + totalText.Length() ); + //CleanupStack::PushL(tempText); + + tempText->Des().AppendFormat( resultText->Des(), totalBytesFlushed ); + + + + if(aShowDoneNote) + { + TBrowserDialogs::InfoNoteL ( R_BROWSER_OK_NOTE, tempText->Des() ); + } + CleanupStack::PopAndDestroy(2); //resultText, tempText + } + } + +// --------------------------------------------------------- +// CBrowserAppUi::ClearFormAndPasswdDataL +// --------------------------------------------------------- +// +void CBrowserAppUi::ClearFormAndPasswdDataL(TBool aShowPromptAndComplete) + { + if (aShowPromptAndComplete) + { + CAknQueryDialog* query = CAknQueryDialog::NewL(); + if ( query->ExecuteLD( R_BROWSER_CLEARFORMPASSWDDATA_QUERY ) ) + { + // call brctl to clear form and password data + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandClearAutoFormFillData + + (TInt)TBrCtlDefs::ECommandIdBase ); + + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandClearAutoFormFillPasswordData + + (TInt)TBrCtlDefs::ECommandIdBase ); + + TBrowserDialogs::InfoNoteL( + R_BROWSER_OK_NOTE, R_QTN_BROWSER_NOTE_FORM_AND_PASSWD_DATA_CLEARED ); + } + + } + else + { + // call brctl to clear form and password data + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandClearAutoFormFillData + + (TInt)TBrCtlDefs::ECommandIdBase ); + + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandClearAutoFormFillPasswordData + + (TInt)TBrCtlDefs::ECommandIdBase ); + + } + } + + +// --------------------------------------------------------- +// CBrowserAppUi::ClearHistoryWithPromptL +// --------------------------------------------------------- +// +void CBrowserAppUi::ClearHistoryWithPromptL() + { + CAknQueryDialog* query = CAknQueryDialog::NewL(); + + if ( query->ExecuteLD( R_BROWSER_CLEARHISTORYDATA_QUERY ) ) + { + ClearHistoryL(); + TBrowserDialogs::InfoNoteL( R_BROWSER_OK_NOTE, + R_QTN_BROWSER_NOTE_HISTORY_CLEARED ); + } + } + +// --------------------------------------------------------- +// CBrowserAppUi::ClearHistoryL +// --------------------------------------------------------- +// +void CBrowserAppUi::ClearHistoryL() + { + if (iWindowManager) + { + iWindowManager->SendCommandToAllWindowsL( + (TInt)TBrCtlDefs::ECommandClearHistory + (TInt)TBrCtlDefs::ECommandIdBase); + } + + if (!(Preferences().AdaptiveBookmarks()==EWmlSettingsAdaptiveBookmarksOff )) + { + // This call will ensure that the bookmarks are cleared when we are + // outside the bookmarksview since the next call doesn't do anything in + // that case due to the unset Container pointer. + iRecentUrlStore->ClearData(); + + // Below will serve for when we are called from BookmarksView to ensure + // thorough clearing and view refresh after clearing adapt bookmarks + iBookmarksView->HandleCommandL(EWmlCmdClearAdaptiveBookmarksNoPrompt); + } + + UpdateCbaL(); + + } + +// --------------------------------------------------------- +// CBrowserAppUi::ClearAllPrivacyL +// --------------------------------------------------------- +// +void CBrowserAppUi::ClearAllPrivacyL() + { + + CAknQueryDialog* query = CAknQueryDialog::NewL(); + if ( query->ExecuteLD( R_BROWSER_CLEARPRIVACYDATA_QUERY ) ) + { + ClearTheCacheL(EFalse, EFalse); // false -> no prompt or info note after op + DeleteCookiesL(); + ClearHistoryL(); + ClearFormAndPasswdDataL(EFalse); // no prompt or completed info note + + TBrowserDialogs::InfoNoteL( + R_BROWSER_OK_NOTE, R_QTN_BROWSER_NOTE_CLEAR_ALL_PRIVACY_DONE ); + } + } + + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::DisconnectL +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::DisconnectL() + { +//#pragma message("TODO: inform LoadObserver?") + SendDisconnectEventL(); + Connection().Disconnect(); + +#ifdef __RSS_FEEDS + iFeedsClientUtilities->DisconnectFeedsViewL(); + //notify feeds engine to close the connection + iFeedsClientUtilities->DisconnectManualUpdateConnectionL(); +#endif + } + + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::BmOTABinSenderL() +// ----------------------------------------------------------------------------- +// +MBmOTABinSender& CBrowserAppUi::BmOTABinSenderL() + { + if (!iSender) + { + iLateSendUi->Cancel(); + DoConstructSendUiL(); + } + return *iSender; + } + + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::ContentView() +// ----------------------------------------------------------------------------- +// +CBrowserContentView* CBrowserAppUi::ContentView() const + { + return (CBrowserContentView*)View( KUidBrowserContentViewId ); + } + + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::FetchL +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::FetchL( const TDesC& aUrl, CBrowserLoadObserver::TBrowserLoadUrlType aUrlType ) + { + TFavouritesWapAp ap; + ap.SetDefault(); + FetchL( aUrl, KNullDesC, KNullDesC, ap, aUrlType ); + } + +// TO DO: done by BaP +// ----------------------------------------------------------------------------- +// CBrowserAppUi::CancelFetch +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::CancelFetch( TBool aIsUserInitiated /*= EFalse*/ ) + { + LoadObserver().DoEndLoad( aIsUserInitiated ); + TRAP_IGNORE( BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandCancelFetch + (TInt)TBrCtlDefs::ECommandIdBase ) ); + SetContentDisplayed(ETrue); + } + + +// ---------------------------------------------------------------------------------------- +// CBrowserAppUi::HandleMessageL +// +// Changes the URL to another if WAP is running before Wap Url +// is started from Desk +// ---------------------------------------------------------------------------------------- +// +MCoeMessageObserver::TMessageResponse CBrowserAppUi::HandleMessageL( + TUint32 aClientHandleOfTargetWindowGroup, + TUid aMessageUid, + const TDesC8& aMessageParameters ) + { + iBrowserAlreadyRunning = ETrue; + TApaTaskList taskList( CEikonEnv::Static()->WsSession() ); + TUid wapUid = KUidBrowserApplication; + TApaTask task = taskList.FindApp( wapUid ); + task.BringToForeground(); + //Check for aMessageUid. If it is in array then set iSameWinApp = ETrue + iSameWinApp = IsSameWinApp(aMessageUid); + if ( aMessageParameters.Compare( KLongZeroIdString ) ) + { + ParseAndProcessParametersL( aMessageParameters ); + } + return CAknViewAppUi::HandleMessageL( + aClientHandleOfTargetWindowGroup, + aMessageUid, + aMessageParameters); + } + +// ---------------------------------------------------------------------------------- +// CBrowserAppUi::UpdateNaviPaneL +// ---------------------------------------------------------------------------------- +// +void CBrowserAppUi::UpdateNaviPaneL( TDesC& aStatusMsg ) + { + ContentView()->UpdateNaviPaneL( aStatusMsg ); + } + +// ---------------------------------------------------------------------------------- +// CBrowserAppUi::StopDelay +// ---------------------------------------------------------------------------------- +// +TInt CBrowserAppUi::StopDelay( TAny* aCBrowserAppUi ) + { + __ASSERT_DEBUG(aCBrowserAppUi, Util::Panic( Util::EUninitializedData )); + + ((CBrowserAppUi*)aCBrowserAppUi)->DoStopDelay(); + return 0; + } + + +// ---------------------------------------------------------------------------------- +// CBrowserAppUi::DoStopDelay +// ---------------------------------------------------------------------------------- +// +void CBrowserAppUi::DoStopDelay() + { + iWait.AsyncStop(); + } + +// ---------------------------------------------------------------------------------- +// CBrowserAppUi::DelayedSendUiConstructL +// ---------------------------------------------------------------------------------- +// +/*static*/ TInt CBrowserAppUi::DelayedSendUiConstructL( TAny* aCBrowserAppUi ) + { + __ASSERT_DEBUG(aCBrowserAppUi, Util::Panic( Util::EUninitializedData )); + TRAP_IGNORE( + ((CBrowserAppUi*)aCBrowserAppUi)->DoConstructSendUiL(); + ); + return KErrNone; + } + + +// ---------------------------------------------------------------------------------- +// CBrowserAppUi::DoConstructSendUiL +// ---------------------------------------------------------------------------------- +// +void CBrowserAppUi::DoConstructSendUiL() + { + __ASSERT_DEBUG(!iSender, Util::Panic( Util::EUnExpected )); + iSender = CWmlBrowserBmOTABinSender::NewL(); + } + +// ----------------------------------------------------------------------------------- +// CBrowserAppUi::SetViewToReturnOnClose +// ----------------------------------------------------------------------------------- +// +void CBrowserAppUi::SetViewToReturnOnClose( TUid const &aUid ) + { + iViewToReturnOnClose.iUid = aUid.iUid; + } + +// ----------------------------------------------------------------------------------- +// CBrowserAppUi::CloseContentViewL +// ----------------------------------------------------------------------------------- +// +void CBrowserAppUi::CloseContentViewL() + { +LOG_ENTERFN("CBrowserAppUi::CloseContentViewL"); + CBrowserAppDocument* doc = STATIC_CAST(CBrowserAppDocument*, Document()); + + // Close should Exit asynchronously if called from another application + // & if not in feeds view +#ifdef __RSS_FEEDS + if(CalledFromAnotherApp() && (!IsEmbeddedModeOn()) + && (GetPreviousViewFromViewHistory() != KUidBrowserFeedsFolderViewId) + && (GetPreviousViewFromViewHistory() != KUidBrowserFeedsTopicViewId) + && (GetPreviousViewFromViewHistory() != KUidBrowserFeedsFeedViewId )) + { + SetExitInProgress( ETrue ); + BROWSER_LOG( ( _L( " iBrowserAsyncExit->Start()" ) ) ); + iBrowserAsyncExit->Start(); + } +#else + if(CalledFromAnotherApp() && !IsEmbeddedModeOn()) + { + SetExitInProgress( ETrue ); + BROWSER_LOG( ( _L( " iBrowserAsyncExit->Start()" ) ) ); + iBrowserAsyncExit->Start(); + } +#endif // __RSS_FEEDS + + else + { + if ( IsEmbeddedModeOn() && + doc->GetFolderToOpen() == KFavouritesRootUid ) + { + ExitBrowser(ETrue); + } + else + { + if ( iStartedUp && ContentView()->GetPreviousViewID() == KUidBrowserBookmarksViewId ) + { + if ( GetBookmarksView()->GetAdaptiveBookmarksFolderWasActive() ) + { + GetBookmarksView()->OpenAdaptiveBookmarksWhenActivated(); + } + SetViewToBeActivatedIfNeededL( KUidBrowserBookmarksViewId ); + } + else if ( IsEmbeddedModeOn()) + { + if( !iExitInProgress ) + { + ExitBrowser( ETrue ); + } + } + else + { + if(CalledFromAnotherApp() && (!IsEmbeddedModeOn())) + { + SetViewToBeActivatedIfNeededL( GetPreviousViewFromViewHistory()); + SetCalledFromAnotherApp(EFalse); + SendBrowserToBackground(); + } + else + { + SetViewToBeActivatedIfNeededL( iViewToReturnOnClose ); + } + } + } + } + } + +// ----------------------------------------------------------------------------------- +// CBrowserAppUi::IsEmbeddedModeOn +// ----------------------------------------------------------------------------------- +// +TBool CBrowserAppUi::IsEmbeddedModeOn() const + { + return iEikonEnv->StartedAsServerApp(); + } + +// ----------------------------------------------------------------------------------- +// CBrowserAppUi::HistoryLoadPrevious +// ----------------------------------------------------------------------------------- +// +void CBrowserAppUi::HistoryLoadPrevious() + { + if( BrCtlInterface().NavigationAvailable( TBrCtlDefs::ENavigationBack ) ) + { + TRAP_IGNORE( BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandBack + + (TInt)TBrCtlDefs::ECommandIdBase ) ); + } + } + +// ----------------------------------------------------------------------------------- +// CBrowserAppUi::HistoryLoadNext +// ----------------------------------------------------------------------------------- +// +void CBrowserAppUi::HistoryLoadNext() + { + if( BrCtlInterface().NavigationAvailable( TBrCtlDefs::ENavigationForward ) ) + { + LoadObserver().DoStartLoad( CBrowserLoadObserver::ELoadUrlTypeOther ); + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandForward + + (TInt)TBrCtlDefs::ECommandIdBase ); + } + } + + +// --------------------------------------------------------------------------- +// CBrowserAppUi::IsShutdownRequested +// --------------------------------------------------------------------------- +// +TBool CBrowserAppUi::IsShutdownRequested() const + { + return iShutdownRequested; + } + +// --------------------------------------------------------------------------- +// CBrowserAppUi::IsEmbeddedInOperatorMenu +// --------------------------------------------------------------------------- +// +TBool CBrowserAppUi::IsEmbeddedInOperatorMenu() const + { + const TUid KUidOperatorMenuApp = { 0x10008D5E }; + const TUid KUidVideoServicesApp = { 0x10281893 }; + + // If the embedding application is the Operator Menu or Video Services + if ( iEmbeddingApplicationUid == KUidOperatorMenuApp || iEmbeddingApplicationUid == KUidVideoServicesApp ) + { + return ETrue; + } + else + { + return EFalse; + } + } + +// --------------------------------------------------------------------------- +// CBrowserAppUi::IsAppShutterActive +// --------------------------------------------------------------------------- +// +TBool CBrowserAppUi::IsAppShutterActive() const + { + CAknAppUi* shuttingApp = CAknEnv::AppWithShutterRunning(); + + if ( shuttingApp ) + { + return ETrue; + } + else + { + return EFalse; + } + } + +// --------------------------------------------------------------------------- +// CBrowserAppUi::FetchHomePage +// -------------------------------------------------------------------------- +// +void CBrowserAppUi::FetchHomePageL() + { +LOG_ENTERFN( "CBrowserAppUi::FetchHomePageL" ); + if(!iStartedUp) // just in case, not done + CompleteDelayedInit(); + + if ( !Fetching() ) + { + UpdateSoftKeys(); + + // If the last active view is content view, return to the bookmark view on close. + // Otherwise if the last active view is bookmark view and we return to the appropriate view on close. + TUid lastViewId = LastActiveViewId(); + if( lastViewId == KUidBrowserContentViewId || + lastViewId == KUidBrowserNullViewId ) + { + lastViewId = KUidBrowserBookmarksViewId; + } + SetViewToReturnOnClose( lastViewId ); + + if( iLongZeroPressed ) + { + BROWSER_LOG( ( _L( " LongZeroPressed." ) ) ); + + // There should only be one special load observer at startup + SpecialLoadObserver().SetLongZeroStartup( iLongZeroPressed ); + iLongZeroPressed = EFalse; + HBufC* buf = HBufC::NewLC( KMaxHomePgUrlLength ); + TPtr ptr( buf->Des() ); + TBool homePgFound( KErrNotFound ); + + // try to read Access Points homepage + TUint defaultAp( KWmlNoDefaultAccessPoint ); + // 'always ask' feature doesn't let to read the AP + if( Preferences().AccessPointSelectionMode() == EConnectionMethod ) + { + defaultAp = Preferences().DefaultAccessPoint(); + } + if ( defaultAp != KWmlNoDefaultAccessPoint ) // There is an access point defined + { + CApAccessPointItem* apItem = Preferences().AllPreferencesL().iDefaultAPDetails; + if ( apItem ) + { + const HBufC* defaultHP = apItem->ReadConstLongTextL( EApWapStartPage ); + if ( defaultHP->Length() ) + { + ptr.Zero(); + ptr.Append( *defaultHP ); + homePgFound = KErrNone; + } + } + } + // in case of error, read user defined home page from SD + TInt err( KErrNone ); + if( homePgFound == KErrNotFound ) + { + // do not let leaving + if ((Preferences().HomePageType() == EWmlSettingsHomePageAddress) + ||(Preferences().HomePageType() == EWmlSettingsHomePageUseCurrent)) + { + TRAP( err, homePgFound = Preferences().HomePageUrlL( ptr, ETrue ) ); + } + } + // we have a url to load + if( err == KErrNone && + homePgFound == KErrNone && + ptr.Length() > 0 ) + { + TRAP( err, FetchL( ptr, CBrowserLoadObserver::ELoadUrlTypeOther ) ); + // in case of any error switch back to BookmarksView + if( err != KErrNone ) + { + ContentView()->SetFullScreenOffL(); + SetLastActiveViewId( KUidBrowserBookmarksViewId ); + } + } + else + { + // we already switched to ContentView, so change the layout back + ContentView()->SetFullScreenOffL(); + SetLastActiveViewId( KUidBrowserBookmarksViewId ); + } + CleanupStack::PopAndDestroy( buf ); + } + else + { + // it checks HomePageSettings + LaunchHomePageL( /* EFalse */ ); + } + } + } + +// --------------------------------------------------------------------------- +// CBrowserAppUi::StartPreferencesViewL +// --------------------------------------------------------------------------- +// +TBool CBrowserAppUi::StartPreferencesViewL( TUint aListItems ) + { + TBool retVal( EFalse ); + TInt retUi( KErrNone ); + TInt err(KErrNone); + + //start the connection dialog + CCmApplicationSettingsUi* settings = CCmApplicationSettingsUi::NewL(); + CleanupStack::PushL( settings ); + TCmSettingSelection selection; + // empty filter array because no filtering is wanted + TBearerFilterArray filterArray; + TRAP ( err, retUi = settings->RunApplicationSettingsL( selection, aListItems, filterArray ) ); + CleanupStack::PopAndDestroy(); // settings + + //if something has been selected + if (retUi) + { + //set the selection mode + iPreferences->SetAccessPointSelectionModeL( + STATIC_CAST( TCmSettingSelectionMode, selection.iResult ) ); + + //based on the chosen connection type, store the connection identifier(iapid, snap id, always ask) + //in the preferences list + switch ( iPreferences->AccessPointSelectionMode() ) + { + case EConnectionMethod: + { + TUint32 id = iPreferences->DefaultAccessPoint(); + // CMManager gives us IAPid, need to translate to WAPid + if (selection.iId != 0) + { + id = Util::WapIdFromIapIdL( *this, selection.iId ); + } + iPreferences->SetDefaultAccessPointL( id ); + // Requested AP is preset for PushMtm + id = iPreferences->DefaultAccessPoint(); + if( id != KWmlNoDefaultAccessPoint ) + { + SetRequestedAP( id ); + retVal = ETrue; + } + break; + } + + case EDestination: + { + TUint32 snapId = iPreferences->DefaultSnapId(); + if (selection.iId != 0) + { + snapId = selection.iId; + } + iPreferences->SetDefaultSnapId( snapId ); + if( snapId != KWmlNoDefaultSnapId ) + { + retVal = ETrue; + } + break; + } + + case EAlwaysAsk: + default: + { + break; + } + } + } + + // alr: is return val needed? should it be true or false in EAA and default? check how it's used + return retVal; + } +// --------------------------------------------------------------------------- +// CBrowserAppUi::AhleConnection +// --------------------------------------------------------------------------- +// +CRecentUrlStore* CBrowserAppUi::RecentUrlStore() + { + return iRecentUrlStore; + } + +// --------------------------------------------------------------------------- +// CBrowserAppUi::SomeItemsNotSecure +// --------------------------------------------------------------------------- +// +TBool CBrowserAppUi::SomeItemsNotSecure() const + { + return !( LoadObserver().LoadStatus( CBrowserLoadObserver::ELoadStatusAllItemIsSecure ) ); + } + +// ---------------------------------------------------- +// CBrowserAppUi::IsProgressShown +// ---------------------------------------------------- +// +TBool CBrowserAppUi::IsProgressShown() const + { + return iShowProgress; + } + +// ---------------------------------------------------- +// CBrowserAppUi::SetProgressShown +// ---------------------------------------------------- +// +void CBrowserAppUi::SetProgressShown( TBool aProgressShown ) + { + iShowProgress = aProgressShown; + } + +// ---------------------------------------------------- +// CBrowserAppUi::RecognizeUiFileL +// ---------------------------------------------------- +// +TBool CBrowserAppUi::RecognizeUiFileL( RFile& aFile, TBuf& aDataTypeDes ) + { + TBool recognized = EFalse; + HBufC8* buffer = NULL; + + TFileName fileName; + User::LeaveIfError(aFile.FullName(fileName)); + + TInt fileSize; + + // Read the file from the beginning into a buffer + User::LeaveIfError(aFile.Size(fileSize)); + buffer = HBufC8::NewLC(fileSize); + TPtr8 bufferPtr(buffer->Des()); + TInt startPos = 0; + User::LeaveIfError(aFile.Read(startPos, bufferPtr, fileSize)); + // move the seek position back to start + User::LeaveIfError(aFile.Seek(ESeekStart, startPos)); + + _LIT( KDotOPML, ".opml"); + _LIT( KDotXML, ".xml"); + + // First try the name extension + if ( fileName.Length() >= 3 ) + { + TInt dotPos = fileName.LocateReverse( '.' ); + if ( dotPos != KErrNotFound ) + { + TInt extLength = fileName.Length() - dotPos; + HBufC* ext = fileName.Right( extLength ).AllocL(); + CleanupStack::PushL( ext ); + + // if .opml return true + if ( ext->CompareF( KDotOPML ) == 0) + { + aDataTypeDes = KOPMLMimeType; + recognized = ETrue; + } + else if (ext->CompareF( KDotXML ) == 0 ) + { + _LIT8( dtd, " 5) && + (bufferPtr.FindF( dtd ) != KErrNotFound )) + { + aDataTypeDes = KOPMLMimeType; + recognized = ETrue; + } + } + + CleanupStack::PopAndDestroy(); //buffer + + return recognized; + } + + +// --------------------------------------------------------- +// CBrowserAppUi::ConfirmUiHandlingL +// --------------------------------------------------------- +// +TBool CBrowserAppUi::ConfirmUiHandlingL( TFileName& aFilename, TBuf& aDataTypeDes ) + { + // switch on data type desc and handle file accordingly + if(aDataTypeDes.Compare( KOPMLMimeType ) == 0) + { + // Display confirmation dialog before activating feeds view + HBufC* message = StringLoader::LoadLC(R_FEEDS_QUERY_IMPORT_NOW, aFilename); + HBufC* lsc_yes = StringLoader::LoadLC(R_FEEDS_IMPORT_NOW_YES); + HBufC* rsc_no = StringLoader::LoadLC(R_FEEDS_IMPORT_NOW_NO); + + TBool ret(iDialogsProvider->DialogConfirmL( _L(""), *message, *lsc_yes, *rsc_no )); + + CleanupStack::PopAndDestroy(3); //message, lsc_yes, rsc_no + + if(ret) + { + return ETrue; + } + } + + return EFalse; + } + +// --------------------------------------------------------- +// CBrowserAppUi::CopyUiRFileToFileL +// --------------------------------------------------------- +// + +void CBrowserAppUi::CopyUiRFileToFileL( RFile& aFile, const TDesC& aFilepath ) + { + // + // copy r-file to a temporary file + // + RFs tempRFs; + RFile tempRFile; + TInt fileSize; + HBufC8* buffer = NULL; + + // Connect to file server + User::LeaveIfError(tempRFs.Connect()); + CleanupClosePushL(tempRFs); + + // Create the filepath to copy to + // Replace the file if it already exists + User::LeaveIfError(tempRFile.Replace(tempRFs, aFilepath, EFileWrite)); + CleanupClosePushL(tempRFile); + + // Copy the file + User::LeaveIfError(aFile.Size(fileSize)); + buffer = HBufC8::NewLC(fileSize); + TPtr8 bufferPtr(buffer->Des()); + + // Read from the start of the file + User::LeaveIfError(aFile.Read(0, bufferPtr, fileSize)); + User::LeaveIfError(tempRFile.Write(bufferPtr, fileSize)); + + tempRFile.Close(); + tempRFs.Close(); + + // Cleanup Buffer and file copy stuff + CleanupStack::PopAndDestroy(3); //buffer, tempRFile, tempRFs + } + +// --------------------------------------------------------- +// CBrowserAppUi::HandleUiFileL +// --------------------------------------------------------- +// +void CBrowserAppUi::HandleUiFileL( TFileName& aFilepath, TBuf& aDataTypeDes ) + { + // switch on data type desc and handle file accordingly + if(aDataTypeDes.Compare(KOPMLMimeType) == 0) + { + // Activate Content view first in order to + // get it's BrowserControl instance ready to go + // (as opposed to Feeds' BC instance) to be used to render + // feeds content in case the user wants to read + // the feed in-page. + SetLastActiveViewId( KUidBrowserContentViewId ); + SetViewToBeActivatedIfNeededL( LastActiveViewId() ); + ActivateLocalViewL( LastActiveViewId() ); + + // Now activate bookmarks view + SetLastActiveViewId( KUidBrowserBookmarksViewId ); + SetViewToBeActivatedIfNeededL( LastActiveViewId() ); + ActivateLocalViewL( LastActiveViewId() ); + HandleForegroundEventL( ETrue ); + + // wait until the content view is completely ready + WaitCVInit(); + + // begin import, pass to feeds view + iFeedsClientUtilities->BeginImportOPMLFeedsFileL(aFilepath); + } + } + +// --------------------------------------------------------- +// CBrowserAppUi::HandleUiDownloadL +// --------------------------------------------------------- +// +void CBrowserAppUi::HandleUiDownloadL( TFileName& aFilepath, TBuf& aDataTypeDes ) + { + // switch on data type desc and handle file accordingly + if(aDataTypeDes.Compare(KOPMLMimeType) == 0) + { + SetLastActiveViewId( KUidBrowserFeedsFolderViewId ); + // begin import + iFeedsClientUtilities->BeginImportOPMLFeedsFileL(aFilepath); + // switch back to FeedsView, so change layout + ContentView()->SetFullScreenOffL(); + } + } + +// --------------------------------------------------------- +// CBrowserAppUi::LaunchIntoFeedsL +// --------------------------------------------------------- +// +void CBrowserAppUi::LaunchIntoFeedsL() +{ + if(iBrowserAlreadyRunning && (LastActiveViewId() == KUidBrowserContentViewId)) + { + iFeedsClientUtilities->ShowFolderViewL(KUidBrowserContentViewId); + } + else + { + iFeedsClientUtilities->ShowFolderViewL(); + } +} + +// ---------------------------------------------------- +// CBrowserAppUi::CreateFullUrlLC +// ---------------------------------------------------- +// +HBufC* CBrowserAppUi::CreateFullUrlLC( + const TDesC& aUrl, + const TDesC& aUsername, + const TDesC& aPassword ) + { + // username[:password]@server/document + TInt lPw = aPassword.Length(); + TInt lUn = aUsername.Length(); + _LIT( KBrowserScheme, "://" ); + TInt index = aUrl.Find( KBrowserScheme ); + if( index == KErrNotFound ) + { + index = 0; // insert at first position + } + else + { + index += 3; // insert after scheme + } + + HBufC *fullUrl = HBufC::NewLC( aUrl.Length() + lUn + lPw + 3 ); + fullUrl->Des().Copy( aUrl ); + if( lPw + lUn ) + { + fullUrl->Des().Insert( index, _L( "@" ) ); + } + if( lPw ) + { + fullUrl->Des().Insert( index, aPassword ); + fullUrl->Des().Insert( index, _L( ":" ) ); + } + if( lUn ) + { + fullUrl->Des().Insert( index, aUsername ); + } + // insert scheme??? + fullUrl->Des().ZeroTerminate(); + + return fullUrl; + } + +// --------------------------------------------------------- +// CBrowserAppUi::HandleResourceChangeL( TInt aType ) +// --------------------------------------------------------- +// +void CBrowserAppUi::HandleResourceChangeL( TInt aType ) + { + LOG_ENTERFN("CBrowserAppUi::HandleResourceChangeL"); + LOG_WRITE_FORMAT(" aType: %d", aType); + if( iExitInProgress ) + { + BROWSER_LOG( ( _L(" iExitInProgress ETrue ") ) ); + return; + } + + CAknViewAppUi::HandleResourceChangeL( aType ); + if ( aType == KEikDynamicLayoutVariantSwitch ) + { + CBrowserViewBase* activeView = ActiveView( ); + if( activeView != NULL ) + { + activeView->HandleClientRectChange(); + if ( ContentView() && (activeView != ContentView()) ) + { + ContentView()->HandleClientRectChange(); + } + } + } + if (aType == KEikMessageFadeAllWindows) + { + if (ContentView() && ContentView()->PenEnabled()) + { + if (iCurrentView == KUidBrowserContentViewId) + { + ContentView()->Toolbar()->DisableToolbarL(ETrue); + } + } + } + + if (aType == KEikMessageUnfadeWindows) + { + if (ContentView()&& ContentView()->PenEnabled() && !ExitInProgress()) + { + if (iCurrentView == KUidBrowserContentViewId) + { + ContentView()->MakeZoomSliderVisibleL(EFalse); + ContentView()->Toolbar()->DisableToolbarL(EFalse); + } + } + } + } + +// --------------------------------------------------------- +// CBrowserAppUi::ChangeConnectionL() +// --------------------------------------------------------- +// +void CBrowserAppUi::ChangeConnectionL() + { + TConManChangeConn change; + // This will contain the new IAP as well, but it needs to pass the old one + TUint32 newAp = Util::IapIdFromWapIdL( *this, RequestedAp() ); + iConnection->ChangeIapL( change, newAp ); + if( EConManDoNothing == change ) + { + // Do nothing + } + else + { + //cancel transaction + SendDisconnectEventL(); + /* start all */ + if( EConManCloseAndStart == change ) + { + //close connection + iConnection->Disconnect(); + +#ifdef __RSS_FEEDS + //notify feeds engine to close the connection + iFeedsClientUtilities->DisconnectManualUpdateConnectionL(); +#endif + } + iConnection->SetRequestedAP( newAp ); + TInt err = iConnection->StartConnectionL( ETrue ); + if( err == KErrNone ) + { + iConnection->ShowConnectionChangedDlg(); + } + } + } + +// --------------------------------------------------------- +// CBrowserAppUi::HandleContentL() +// --------------------------------------------------------- +// +TBool CBrowserAppUi::HandleContentL( const TDesC& aFileName, + const CAiwGenericParamList& aParamList, + TBool& aContinue ) + { + // Put the file name to the generic parameter list, if it is not there yet + TInt index(0); + aParamList.FindFirst( index, EGenericParamFile, EVariantTypeDesC ); + if ( index == KErrNotFound ) + { + TAiwVariant paramVariant( aFileName ); + TAiwGenericParam genericParam( EGenericParamFile, paramVariant ); + CAiwGenericParamList* paramList = (CAiwGenericParamList*)&aParamList; + paramList->AppendL( genericParam ); + } + + // Set EGenericParamAllowMove - we allow handlers to apply move instead + // of copy for the file. + aParamList.FindFirst( index, EGenericParamAllowMove, EVariantTypeAny ); + if ( index == KErrNotFound ) + { + TBool allowMove( ETrue ); + TAiwVariant allowMoveVariant( allowMove ); + TAiwGenericParam genericParamAllowMove( EGenericParamAllowMove, allowMoveVariant ); + CAiwGenericParamList* paramList = (CAiwGenericParamList*)&aParamList; + paramList->AppendL( genericParamAllowMove ); + } + + BrowserLauncherService()->DownloadFinishedL( KErrNone, aParamList ); + + // Wait until the client sends two TBools (contentHandled & continueBrowsing). + iClientWantsToContinue = EFalse; + iWasContentHandled = EFalse; + + iLauncherServiceWait.Start(); + + // iClientWantsToContinue and iWasContentHandled contains the results + aContinue = iClientWantsToContinue; + return iWasContentHandled; + } + +// --------------------------------------------------------- +// CBrowserAppUi::DownloadedContentHandlerReserved1() +// --------------------------------------------------------- +// +TAny* CBrowserAppUi::DownloadedContentHandlerReserved1( TAny* /*aAnyParam*/ ) + { + return 0; + } + +// --------------------------------------------------------- +// CBrowserAppUi::SetContentHandlingResult() +// --------------------------------------------------------- +// +void CBrowserAppUi::SetContentHandlingResult + ( TBool aClientWantsToContinue, TBool aWasContentHandled ) + { + iClientWantsToContinue = aClientWantsToContinue; + iWasContentHandled = aWasContentHandled; + + // continue handling the content + iLauncherServiceWait.AsyncStop(); + } + +// --------------------------------------------------------- +// CBrowserAppUi::LoadSearchPageL() +// --------------------------------------------------------- +// +void CBrowserAppUi::LoadSearchPageL() + { + TPtrC url = iPreferences->SearchPageUrlL(); + + // url undefined + if ( !url.Length() ) + { + HBufC* query = StringLoader::LoadLC( + R_BROWSER_QUERY_DEF_SEARCHPAGE ); + // Ask if user want to define the search web setting now + if ( + TBrowserDialogs::DialogQueryReqL( query->Des(), + KNullDesC, + KNullDesC ) + ) + { + HBufC* prompt = StringLoader::LoadLC( + R_BROWSER_PROMPT_SEARCH_URL ); + HBufC* retBuf = HBufC::NewLC( KMaxSearchPgUrlLength ); + TPtr retString = retBuf->Des(); + retString.Copy( KNullDesC ); + + TInt result = TBrowserDialogs::DialogPromptReqL( + prompt->Des(), + &retString, + ETrue, + KMaxSearchPgUrlLength + ); + + if( result ) // URL was accepted + { + Preferences().SetSearchPageUrlL( retString ); + url.Set( iPreferences->SearchPageUrlL() ); + } + CleanupStack::PopAndDestroy( 2 ); // retBuf, prompt + } + CleanupStack::PopAndDestroy( query ); + } + + FetchL( url ); + } + +// --------------------------------------------------------- +// CBrowserAppUi::CloseWindowL() +// --------------------------------------------------------- +// +void CBrowserAppUi::CloseWindowL( TInt aWindowId ) + { +LOG_ENTERFN("AppUi::CloseWindowL"); + + //There are only two cases for closing window. One is user initialized and the + //other is script initialized. For both cases, the window should be deleted. + TBool forceDelete( ETrue ); + // this variable is useful to know if the window has a parent window which needs to be activated on closing current window + TBool parentPresent(EFalse); + if ( WindowMgr().CurrentWindowQue() && WindowMgr().CurrentWindowQue()->iParent ) + { + parentPresent = ETrue; + } + // delete the current window by default + if( aWindowId == 0 ) + { + aWindowId = WindowMgr().CurrentWindow()->WindowId(); + // scripts directly pass a real windowId, + // so if user initiated the process, we really delete the window + forceDelete = ETrue; + } + //If this window has been created from Search app + if(aWindowId == iWindowIdFromFromExternApp) + { + //Make it false as window is going to close down + iSameWinApp = EFalse; + } +#ifdef __RSS_FEEDS + // If we are closing a Feeds Full Story then go back to feeds + TBool feedsWindow(EFalse); + CBrowserWindow* win; + TInt err = WindowMgr().Window(aWindowId, win); + if (err == KErrNone) + { + feedsWindow = win->HasFeedsContent(); + win->SetHasFeedsContent(EFalse); + } +#endif + + TInt winId = WindowMgr().DeleteWindowL( aWindowId, forceDelete ); + +#ifdef __RSS_FEEDS + if (feedsWindow) + { + SetViewToBeActivatedIfNeededL( KUidBrowserFeedsFeedViewId ); + return; + } +#endif + + if( winId > 0 ) // still remain a window to be activated + { + WindowMgr().SwitchWindowL( winId ); + if(CalledFromAnotherApp() && (!IsEmbeddedModeOn()) && !parentPresent) + { + SetCalledFromAnotherApp(EFalse); + SendBrowserToBackground(); + } + } + else if( winId == 0) // last window was closed + { + if(CalledFromAnotherApp() && (!IsEmbeddedModeOn())) + { +#ifdef __RSS_FEEDS + if ((GetPreviousViewFromViewHistory() == KUidBrowserFeedsFolderViewId) || + (GetPreviousViewFromViewHistory() == KUidBrowserFeedsTopicViewId) || + (GetPreviousViewFromViewHistory() == KUidBrowserFeedsFeedViewId)) + { + SetViewToBeActivatedIfNeededL( GetPreviousViewFromViewHistory() ); + SetCalledFromAnotherApp(EFalse); + SendBrowserToBackground(); + } + else + { + ExitBrowser(ETrue); + } +#else + ExitBrowser(ETrue); +#endif // __RSS_FEEDS + } + else + { + ExitBrowser(ETrue); + } + } + // else a background window was closed + + } + +// --------------------------------------------------------- +// CBrowserAppUi::StartProgressAnimationL +// --------------------------------------------------------- +// +void CBrowserAppUi::StartProgressAnimationL() + { +LOG_ENTERFN("AppUi::StartProgressAnimationL"); + } + +// --------------------------------------------------------- +// CBrowserAppUi::StopProgressAnimationL +// --------------------------------------------------------- +// +void CBrowserAppUi::StopProgressAnimationL() + { +LOG_ENTERFN("AppUi::StopProgressAnimationL"); + } + +#ifdef __RSS_FEEDS +// --------------------------------------------------------- +// CBrowserAppUi::FeedsClientUtilities +// --------------------------------------------------------- +// +CFeedsClientUtilities& CBrowserAppUi::FeedsClientUtilities() const + { + return *iFeedsClientUtilities; + } +#endif // __RSS_FEEDS + +// --------------------------------------------------------- +// CBrowserAppUi::OpenLinkInNewWindowL() +// --------------------------------------------------------- +// +void CBrowserAppUi::OpenLinkInNewWindowL( const CFavouritesItem& aBookmarkItem ) + { + if( ( aBookmarkItem.IsItem() ) && + ( aBookmarkItem.Uid() != KFavouritesRSSItemUid ) ) + { + // Check if we should/can create a new window + // In most cases when the feature is not allowed option menu items have been dimmed. + // In the case where a long key press on a bookmark happens we fall through to this function + // and check the feature here. If a new window is not allowed we can open in the current window + if( IsPageLoaded() && + Preferences().UiLocalFeatureSupported( KBrowserMultipleWindows ) && + !Preferences().UiLocalFeatureSupported( KBrowserMinimalMultipleWindows )) + { + // there is already a window, so create a new one + CBrowserWindow *win = WindowMgr().CreateWindowL( 0, &KNullDesC ); + if (win != NULL) + { + CleanupStack::PushL( win ); + WindowMgr().SwitchWindowL( win->WindowId() ); + FetchBookmarkL( aBookmarkItem ); + CleanupStack::Pop(); // win + } + } + else + { + // no page is loaded yet, so do not create new window + FetchBookmarkL( aBookmarkItem ); + } + } + } + +// --------------------------------------------------------- +// CBrowserAppUi::SendDisconnectEventL +// --------------------------------------------------------- +// +void CBrowserAppUi::SendDisconnectEventL() + { + LOG_ENTERFN("CBrowserAppUi::SendDisconnectEventL"); + + if(!iStartedUp) + return; + + SpecialLoadObserver().CancelConnection(); + CArrayFixFlat* windows = iWindowManager->GetWindowInfoL( this ); + if( windows ) + { + TInt i; + + for ( i = 0; i < windows->Count(); i++ ) + { + CBrowserWindow* window = NULL; + iWindowManager->Window( windows->At( i )->iWindowId, window ); + if( window ) + { + TInt err; + // BROWSER_LOG( ( _L( " iConnection Connected" ) ) ); + TRAP( err, window->BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandCancelFetch + (TInt)TBrCtlDefs::ECommandIdBase ) ); + // BROWSER_LOG( ( _L( " HandleCommandL: %d"), err ) ); + } + } + + CBrowserWindow* window = NULL; + iWindowManager->Window( windows->At( 0 )->iWindowId, window ); + + // delete the window items before deleting the array + for( i=0; iCount(); ++i ) + delete windows->At( i ); + + delete windows; + } + } + /* + +// ---------------------------------------------------- +// CBrowserAppUi::IsPgNotFound +// ---------------------------------------------------- +// +TBool CBrowserAppUi::IsPgNotFound() const + { + return iPgNotFound; + } +*/ +// ---------------------------------------------------- +// CBrowserAppUi::HandleApplicationSpecificEventL +// ---------------------------------------------------- +// +void CBrowserAppUi::HandleApplicationSpecificEventL(TInt aEventType, const TWsEvent& aWsEvent) + { + CAknAppUi::HandleApplicationSpecificEventL(aEventType, aWsEvent); + + /* + * Note: Even though we get these memory events from the system for handling OOM, and we pass them off + * to the command handler, there is no code further down the line that actually handles them (it would + * normally be in BrCtl). We totally ignore these events. This is because the system has too high of an OOM threshold. + * I.e. the system may only have 6m left and think it's out of memory, however, the browser can still render + * many pages in only 6m. So, these system events are ignored and the browser handles OOM with its own mechanism. + * (See OOMStopper and OOMHandler) + */ + if(aEventType == KAppOomMonitor_FreeRam ) + { + iWindowManager->CloseAllWindowsExceptCurrent(); + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandFreeMemory + (TInt)TBrCtlDefs::ECommandIdBase); + } + else if(aEventType == KAppOomMonitor_MemoryGood) + { + BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandMemoryGood + (TInt)TBrCtlDefs::ECommandIdBase); + } + else if ( KAknFullOrPartialForegroundGained == aEventType ) + { + if ( iViewToBeActivatedIfNeeded.iUid ) + { + ActivateLocalViewL( iViewToBeActivatedIfNeeded ); + } + else + { + // LastActiveViewId() might return with 0! + TRAP_IGNORE( ActivateLocalViewL( LastActiveViewId() ) ); + } + iViewToBeActivatedIfNeeded.iUid = 0; + } + } + +// ---------------------------------------------------- +// CBrowserAppUi::OfferApplicationSpecificKeyEventL +// +// Use this function to handle key events that are application wide and not specific to any view +// All views (containers) call this first and should return if key was consumed +// As a note for future reference the red end key shows up as iCode = EKeyNo...though you would +// think it would be EKeyEnd... +// ---------------------------------------------------- +// +TKeyResponse CBrowserAppUi::OfferApplicationSpecificKeyEventL(const TKeyEvent& /*aKeyEvent*/, + TEventCode /*aType*/) + { + TKeyResponse result( EKeyWasNotConsumed ); + + return result; + } + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::GetPreviousViewFromViewHistory +// ----------------------------------------------------------------------------- +// +TUid CBrowserAppUi::GetPreviousViewFromViewHistory() +{ + return iPreviousView; +} + +// ----------------------------------------------------------------------------- +// CBrowserAppUi::SaveFocusedImageToGalleryL +// ----------------------------------------------------------------------------- +// +void CBrowserAppUi::SaveFocusedImageToGalleryL() + { + TBrCtlImageCarrier* imageCarrier = BrCtlInterface().FocusedImageLC(); + CDocumentHandler* docHandler = CDocumentHandler::NewLC(); + TUriParser uriParser; + User::LeaveIfError(uriParser.Parse(imageCarrier->Url())); + TPtrC path; + path.Set( uriParser.Extract( EUriPath ) ); + HBufC* fileName = NULL; + if( path.Length() ) + { + TInt slash = path.LocateReverse( '/' ); + if( slash != KErrNotFound && slash != path.Length() ) + { + TPtrC temp( path.Right( path.Length() - slash - 1 ) ); + if( temp.Length() ) + { + fileName = HBufC::NewLC(temp.Length() + 4); // leave room for edding extenstion if needed + fileName->Des().Copy(temp); + } + } + } + HBufC8* dataType8 = NULL; + dataType8 = HBufC8::NewLC(imageCarrier->ContentType().Length()); + dataType8->Des().Copy(imageCarrier->ContentType()); + TDataType dataType(*dataType8); + if (fileName) + { + TPtr fileNamePtr(fileName->Des()); + docHandler->CheckFileNameExtension(fileNamePtr, dataType); + docHandler->SaveL(imageCarrier->RawData(), dataType, *fileName, KEntryAttNormal); + } + else + { + docHandler->SaveL(imageCarrier->RawData(), dataType, KEntryAttNormal); + } + if (fileName) + { + CleanupStack::PopAndDestroy(2); // fileName, dataType8 + } + else + { + CleanupStack::PopAndDestroy(dataType8); // dataType8 + } + + TFileName fName; + User::LeaveIfError(docHandler->GetPath(fName)); + + #ifdef BRDO_APP_GALLERY_SUPPORTED_FF + + CMGXFileManager* mgFileManager = MGXFileManagerFactory::NewFileManagerL(CEikonEnv::Static()->FsSession()); + CleanupStack::PushL(mgFileManager); + if( fName.Length() > 0 ) + { + TRAP_IGNORE( mgFileManager->UpdateL( fName ) ); + } + else + { + TRAP_IGNORE( mgFileManager->UpdateL() ); + } + CleanupStack::PopAndDestroy(1); // mgFileManager + + #endif + + CleanupStack::PopAndDestroy(1); // imageCarrier + } + +// --------------------------------------------------------- +// CBrowserAppUi::CheckFlashPresent +// --------------------------------------------------------- +// +TBool CBrowserAppUi::CheckFlashPresent() + { + RImplInfoPtrArray animPluginList; + + TRAP_IGNORE( REComSession::ListImplementationsL( KBrowserPluginInterfaceUid, + animPluginList ) ); + + + _LIT8(KFlashMimeType, "application/x-shockwave-flash"); + + const TInt count = animPluginList.Count(); + TBool found = EFalse; + for ( TInt i = 0; i < count; i++ ) + { + CImplementationInformation* implInfo = animPluginList[i]; + if (( implInfo->DataType( ) ).Find( KFlashMimeType) != KErrNotFound) + { + found = ETrue; //flash plugin is present + break; + } + } + animPluginList.ResetAndDestroy(); + + return found; + + } + +// --------------------------------------------------------- +// CBrowserAppUi::FlashPresent +// --------------------------------------------------------- +// +TBool CBrowserAppUi::FlashPresent() + { + return iFlashPresent; + } + +// --------------------------------------------------------- +// CBrowserAppUi::ShowNameAndVersionL +// --------------------------------------------------------- +// +void CBrowserAppUi::ShowNameAndVersionL() +{ + HBufC* header = StringLoader::LoadLC( R_BROWSER_QUERY_BROWSER_VERSION ); + HBufC* browserVersion = BrCtlInterface().VersionInfoLC(TBrCtlDefs::EBrowserVersion); + + // output browser version to dialog + CAknMessageQueryDialog* dlg = CAknMessageQueryDialog::NewL( *browserVersion ); + CleanupStack::PushL(dlg); + dlg->PrepareLC( R_BROWSER_PAGE_VERSION ); + CleanupStack::Pop(dlg); + CAknPopupHeadingPane* hPane = dlg->QueryHeading(); + if ( hPane ) + { + CleanupStack::PushL(hPane); + hPane->SetTextL( *header ); + CleanupStack::Pop(hPane); + } + dlg->RunLD(); + CleanupStack::PopAndDestroy(2); // browserVersion, header +} + + +// --------------------------------------------------------- +// CBrowserAppUi::IsLaunchHomePageDimmedL +// --------------------------------------------------------- +// +TBool CBrowserAppUi::IsLaunchHomePageDimmedL() +{ + + // Set dimmed flag if shortcut key for launch home page is dimmed and was selected + TBool dimmed = EFalse; + TBool homepage = Preferences().UiLocalFeatureSupported( KBrowserUiHomePageSetting ); + if( homepage ) + { + TWmlSettingsHomePage pgtype = Preferences().HomePageType(); + TBool alwaysAskCase = ((Preferences().AccessPointSelectionMode() == EAlwaysAsk ) && + ( EWmlSettingsHomePageAccessPoint == pgtype )); + + if (alwaysAskCase || (pgtype == EWmlSettingsHomePageBookmarks)) + { + dimmed = ETrue; + } + else if (pgtype == EWmlSettingsHomePageAccessPoint) + { + // check to see if no home page defined on the access point + HBufC* buf = HBufC::NewLC( KMaxHomePgUrlLength ); // cleanupstack + TPtr ptr( buf->Des() ); + TInt pgFound = Preferences().HomePageUrlL( ptr ); + if( pgFound != KErrNone ) + { + dimmed = ETrue; + } + CleanupStack::PopAndDestroy( buf ); + } + } + else + { + dimmed = ETrue; + } + + return(dimmed); +} + +// --------------------------------------------------------- +// CBrowserAppUi::IsDisplayingMenuOrDialog +// --------------------------------------------------------- +// +TBool CBrowserAppUi::IsDisplayingMenuOrDialog() +{ + return CCoeAppUi::IsDisplayingMenuOrDialog(); +} +// --------------------------------------------------------- +// CBrowserAppUi::HandleWsEventL +// --------------------------------------------------------- +void CBrowserAppUi::HandleWsEventL(const TWsEvent& aEvent, + CCoeControl* aDestination) +{ + /** + * We need a special handling for pointer events to handle the situation + * when the pointer is crossing the boundaries of plugin window. Browser + * scrolling id done using PointerMove events not a Drag. + * When PointerMoveBuffer is ready HandlePointerBufferReadyL() is called by + * Symbian framework. By default if Pointer Down event wasn't issued on the + * current CoeControl Pointer Move events are not sent to this control. + * The code below makes sure that when we entering the Content View window + * from pluging window we are still getting move events. + * When we are leaving Content window we are generating fake Pointer Up + * event in order to on-demand scrollbars disapear properly. The later is a + * hack and needs to be re-designed in such way that pluging will pass + * pointer event back to the browser. + */ + if (aDestination != NULL) + { + TInt type=aEvent.Type(); + + switch (type) + { + case EEventPointerExit: + { + + break; + } + + case EEventPointerEnter: + { + if (iCurrentView == KUidBrowserContentViewId) + { + CCoeControl* ctrl = &(BrCtlInterface()); + ctrl->DrawableWindow()->DiscardPointerMoveBuffer(); + const TInt count = ctrl->CountComponentControls(); + for (TInt i = 0; i < count; i++) + { + CCoeControl* c = ctrl->ComponentControl(i); + if (c) + { + c->ClaimPointerGrab(EFalse); + } + } + ctrl->ClaimPointerGrab(EFalse); + } + break; + } + + } + } + CAknViewAppUi::HandleWsEventL(aEvent, aDestination); +} + +// --------------------------------------------------------- +// CBrowserAppUi::HandleSystemEventL +// --------------------------------------------------------- +#if defined(__S60_50__) +void CBrowserAppUi::HandleSystemEventL(const TWsEvent& aEvent) + { + + /** + * We need a special handling for System events to handle the situation + * like when the shut down is done while download is going on. + */ + + switch (*(TApaSystemEvent*)(aEvent.EventData())) + { + case EApaSystemEventShutdown: + // do things here + ExitBrowser ( IsAppShutterActive() ); + break; + default: + break; + } + // call base class implementation + CAknAppUi::HandleSystemEventL(aEvent); + } +#endif +// --------------------------------------------------------- +// CBrowserAppUi::StartFetchHomePageL +// --------------------------------------------------------- +void CBrowserAppUi::StartFetchHomePageL(void) + { + if(!iStartedUp) + CompleteDelayedInit(); + + // There's a homepage to be launched so start in content view + SetLastActiveViewId(KUidBrowserContentViewId); + //wait for contentview to initialize itself + WaitCVInit(); + + TInt error( KErrNone ); + TRAP( error, FetchHomePageL() ); + if( error != KErrNone ) + { + CloseContentViewL(); + } + } + +#ifdef BRDO_IAD_UPDATE_ENABLED_FF +// --------------------------------------------------------- +// CBrowserAppUi::CompleteIADUpdateCallback +// --------------------------------------------------------- +TInt CBrowserAppUi::CompleteIADUpdateCallback( TAny* aBrowserAppUi ) + { + TRAP_IGNORE( ((CBrowserAppUi*)aBrowserAppUi)->CheckUpdatesL() ) + return KErrNone; + } + + +// --------------------------------------------------------- +// CBrowserAppUi::CheckUpdateFileAvailable +// --------------------------------------------------------- +TBool CBrowserAppUi::CheckUpdateFileAvailable() + { + LOG_ENTERFN("CBrowserAppUi::CheckUpdateFileAvailable"); + TBuf privatePath; + TBuf updateFileName; + iFs.PrivatePath( privatePath ); + updateFileName.Copy( privatePath ); + updateFileName.Append( KUpdateFileName ); + RFile updatefile; + TInt err = updatefile.Open( iFs, updateFileName, EFileRead ); + if ( err == KErrNotFound ) + { + LOG_WRITE( "CBrowserAppUi::CheckUpdateFileAvailable - update file not available" ); + return EFalse; + } + else + { + LOG_WRITE( "CBrowserAppUi::CheckUpdateFileAvailable - update file available" ); + updatefile.Close(); + } + return ETrue; + } + +// --------------------------------------------------------- +// CBrowserAppUi::WriteUpdateFile +// --------------------------------------------------------- +void CBrowserAppUi::WriteUpdateFile() + { + LOG_ENTERFN("CBrowserAppUi::WriteUpdateFile"); + TBuf privatePath; + TBuf updateFileName; + iFs.PrivatePath( privatePath ); + updateFileName.Copy( privatePath ); + updateFileName.Append( KUpdateFileName ); + RFile updatefile; + TInt err = updatefile.Open( iFs, updateFileName, EFileWrite | EFileShareExclusive ); + if(err == KErrNotFound) + { + LOG_WRITE( "CBrowserAppUi::WriteUpdateFile - update file not available so create it" ); + err = updatefile.Create( iFs, updateFileName, EFileWrite | EFileShareExclusive ); + } + //Get the current time + TTime timenow; + timenow.HomeTime(); + TInt64 time = timenow.Int64(); + TBuf8<50> data; + data.AppendNum(time); + LOG_WRITE( "CBrowserAppUi::WriteUpdateFile - write the current time in update file" ); + updatefile.Write(data); + updatefile.Close(); + } + +// --------------------------------------------------------- +// CBrowserAppUi::DeleteUpdateFile +// --------------------------------------------------------- +void CBrowserAppUi::DeleteUpdateFile() + { + TBuf privatePath; + TBuf updateFileName; + iFs.PrivatePath( privatePath ); + updateFileName.Copy( privatePath ); + updateFileName.Append( KUpdateFileName ); + iFs.Delete(updateFileName); + } + +// --------------------------------------------------------- +// CBrowserAppUi::ReadUpdateFile +// --------------------------------------------------------- +TInt64 CBrowserAppUi::ReadUpdateFile() + { + TBuf privatePath; + TBuf updateFileName; + //Get the private path then append the filename + iFs.PrivatePath( privatePath ); + updateFileName.Copy( privatePath ); + updateFileName.Append( KUpdateFileName ); + RFile updatefile; + TInt err = updatefile.Open( iFs, updateFileName, EFileRead ); + TInt64 dataValue = 0; + //If file is found + if ( err != KErrNotFound ) + { + TBuf8<50> readBuf; + err = updatefile.Read(readBuf); + updatefile.Close(); + if((err == KErrNone) && (readBuf.Length()>NULL)) + { + //Convert from TBuf8 to TInt64 + TLex8 lex(readBuf); + lex.Val(dataValue); + } + } + return dataValue; + } +#endif + +TBool CBrowserAppUi::IsSameWinApp(TUid aMessageUid) +{ + TInt nElements = sizeof(mArrayOfExternalAppUid)/sizeof(TInt); + for(TInt nIndex = 0;nIndex < nElements; nIndex++) + { + if(aMessageUid == TUid::Uid(mArrayOfExternalAppUid[nIndex])) + { + return ETrue; + } + } + return EFalse; +} +// End of File