--- /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 <browser_platform_variant.hrh>
+#include <BrowserNG.rsg>
+#include <uri16.h>
+#include <uri8.h>
+#include <uriutils.h>
+#include <ApUtils.h>
+#include <StringLoader.h>
+#include <e32def.h>
+#include <aplistitemlist.h>
+#include <aplistitem.h>
+#include <apparc.h>
+#include <favouritesfile.h>
+#include <aknmessagequerydialog.h>
+#include <FeatMgr.h>
+#include <internetconnectionmanager.h>
+#include <APSettingsHandlerUi.h>
+#include <UriUtilsCommon.h>
+#include <aknnavi.h>
+#include <AiwGenericParam.h>
+#include <AknDef.h>
+#include <DocumentHandler.h>
+#include <SysUtil.h>
+
+#ifdef BRDO_APP_GALLERY_SUPPORTED_FF
+#include <MGXFileManagerFactory.h>
+#include <CMGXFileManager.h>
+#endif
+
+#include <browserplugininterface.h>
+#include <oommonitorplugin.h>
+
+#include <browseroverriddensettings.h>
+#include "BrowserLauncherService.h"
+
+#include "cookiemanagerclient.h"
+
+#ifdef __SERIES60_HELP
+#include <hlplch.h>
+#endif //__SERIES60_HELP
+
+#include "BrowserAppDocument.h"
+#include <downloadedcontenthandler.h>
+#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 <data_caging_path_literals.hrh>
+
+#include <brctldefs.h>
+#include <browserdialogsprovider.h>
+#include "BrowserSoftkeysObserver.h"
+#include "BrowserLoadObserver.h"
+#include "BrowserSpecialLoadObserver.h"
+#include "BrowserAsyncExit.h"
+#include "CommonConstants.h"
+
+
+// Dialogs Provider
+#include <browserdialogsproviderobserver.h>
+#include <brctlinterface.h>
+#include <browserdialogsprovider.h>
+
+// 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 <iaupdate.h>
+#include <iaupdateparameters.h>
+#include <iaupdateresult.h>
+#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<TBrCtlImageCarrier>* imageArray = new( ELeave ) CArrayFixFlat<TBrCtlImageCarrier>(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<RFavouritesDb>( 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<CWindowInfo*>* windowBuf = iWindowManager->GetWindowInfoL( this );
+ CleanupStack::PushL( windowBuf );
+
+ // Open 'Switch Window' selection dialog
+ HBufC* title = StringLoader::LoadLC( R_BROWSER_SWITCH_WINDOW_HEADER );
+
+ CArrayFixFlat<TBrCtlSelectOptionData>* optDataArray = new ( ELeave )
+ CArrayFixFlat<TBrCtlSelectOptionData>( 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" + <space> 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<KMaxDataTypeLength>& 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, "<opml" );
+ if( bufferPtr.FindF( dtd ) != KErrNotFound )
+ {
+ aDataTypeDes = KOPMLMimeType;
+ recognized = ETrue;
+ }
+ }
+ CleanupStack::PopAndDestroy(); // ext
+ }
+ }
+
+ if (!recognized)
+ {
+ // just check content of buffer
+ _LIT8( dtd, "<opml" );
+ if( (bufferPtr.Length() > 5) &&
+ (bufferPtr.FindF( dtd ) != KErrNotFound ))
+ {
+ aDataTypeDes = KOPMLMimeType;
+ recognized = ETrue;
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); //buffer
+
+ return recognized;
+ }
+
+
+// ---------------------------------------------------------
+// CBrowserAppUi::ConfirmUiHandlingL
+// ---------------------------------------------------------
+//
+TBool CBrowserAppUi::ConfirmUiHandlingL( TFileName& aFilename, TBuf<KMaxDataTypeLength>& 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<KMaxDataTypeLength>& 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<KMaxDataTypeLength>& 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<CWindowInfo*>* 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; i<windows->Count(); ++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<KMaxFileName> privatePath;
+ TBuf<KMaxFileName> 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<KMaxFileName> privatePath;
+ TBuf<KMaxFileName> 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<KMaxFileName> privatePath;
+ TBuf<KMaxFileName> updateFileName;
+ iFs.PrivatePath( privatePath );
+ updateFileName.Copy( privatePath );
+ updateFileName.Append( KUpdateFileName );
+ iFs.Delete(updateFileName);
+ }
+
+// ---------------------------------------------------------
+// CBrowserAppUi::ReadUpdateFile
+// ---------------------------------------------------------
+TInt64 CBrowserAppUi::ReadUpdateFile()
+ {
+ TBuf<KMaxFileName> privatePath;
+ TBuf<KMaxFileName> 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