diff -r 000000000000 -r dd21522fd290 widgets/widgetapp/src/WidgetUiWindowManager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/widgets/widgetapp/src/WidgetUiWindowManager.cpp Mon Mar 30 12:54:55 2009 +0300 @@ -0,0 +1,1186 @@ +/* +* Copyright (c) 2006, 2008 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: Manages widget windows, each window display one widget +* +*/ + + +#include "WidgetUiWindowManager.h" +#include "WidgetUiWindowView.h" +#include "WidgetUiWindowContainer.h" +#include "WidgetUiWindow.h" +#include "WidgetUiAppUi.h" +#include "WidgetInstallerInternalCRKeys.h" +#include "SWInstWidgetUid.h" +#include "widgetappdefs.rh" +#include "Browser_platform_variant.hrh" +#ifdef BRDO_WRT_HS_FF +#include "cpspublisher.h" +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "cpglobals.h" // CPS string definitions. + +#include +#include + + +/** +* Utility class to show the prompt for platform security access. +* +* The class exists only to provide platform security access prompt +* for the widgets which are launched in minview +*/ +class CGlobalQueryHandlerAO : public CActive + { +public: + /** + * Startup. + * + * @param aManager Window Manager. + * @param aWindow Window. + * @param aMessage Message to be prompted. + * @param aSoftkeys for prompt. + */ + static CGlobalQueryHandlerAO* StartLD ( + CWidgetUiWindowManager& aManager, + CWidgetUiWindow& aWindow, + const TDesC& aMessage, + TInt aSoftkeys); + /** + * ShowGlobalQueryDialogL. + * + * @param aMessage Message to be prompted. + * @param aSoftkeys for prompt. + */ + void ShowGlobalQueryDialogL ( + const TDesC& aMessage, + TInt aSoftkeys ); +protected: // From CActive + /** + * Execute asynchronous operation. + */ + void RunL(); + + /** + * Provide cancellation methods. + */ + void DoCancel(); + +private: + + /** + * Constructor. + * + * @param aManager Manager. + * @param aWindow Window. + * @param aMessage Message for prompt. + * @param aSoftkeys for prompt. + */ + CGlobalQueryHandlerAO ( + CWidgetUiWindowManager& aManager, + CWidgetUiWindow& aWindow, + const TDesC& aMessage, + TInt aSoftkeys); + + /** + * Destructor. + * + * Private on purpose. + */ + ~CGlobalQueryHandlerAO(); + +private: + + CWidgetUiWindowManager& iManager; + CWidgetUiWindow& iWindow; + CAknGlobalConfirmationQuery* iGlobalConfirmationQuery ; + CActiveSchedulerWait iScheduler; + HBufC* iConfirmationText; + + }; + +// ============================================================================= + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::CWidgetUiWindowManager() +// Default constructor +// +// ----------------------------------------------------------------------------- +// +CWidgetUiWindowManager::CWidgetUiWindowManager(CWidgetUiAppUi& aAppUi): + iAppUi(aAppUi), + iStrictMode(ETrue) + { + } + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::ConstructL() +// Symbian constructor +// +// ----------------------------------------------------------------------------- +// +void CWidgetUiWindowManager::ConstructL() + { + CRepository* cenRep(NULL); + + CCoeEnv::Static()->FsSession().CreatePrivatePath( EDriveC ); + // Create the client-side session + User::LeaveIfError( iClientSession.Connect() ); + iServerConnected = ETrue; + + + TRAPD(error,cenRep = CRepository::NewL( TUid::Uid( KSWInstWidgetUIUid ) )); + if (!error) + { + TInt strictMode; + if (cenRep->Get( KWidgetInstallerStrictMode, strictMode ) == KErrNone) + { + iStrictMode = strictMode; + } + delete cenRep; + } + + iDialogsProvider = CBrowserDialogsProvider::NewL( NULL ); + iHandler = CDocumentHandler::NewL(CEikonEnv::Static()->Process()); + + iDb = CActiveApDb::NewL( EDatabaseTypeIAP ); + iConnection = CInternetConnectionManager::NewL( iDb->Database(), EFalse ); +#ifdef BRDO_WRT_HS_FF + iCpsPublisher = CCpsPublisher::NewL(); +#endif + } + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::NewL +// Two-phased constructor +// +// ----------------------------------------------------------------------------- +// +CWidgetUiWindowManager* CWidgetUiWindowManager::NewL( CWidgetUiAppUi& aAppUi ) + { + CWidgetUiWindowManager* self = new ( ELeave ) CWidgetUiWindowManager( aAppUi ); + + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + + return self; + } + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::~CWidgetUiWindowManager() +// Destructor +// +// ----------------------------------------------------------------------------- +// +CWidgetUiWindowManager::~CWidgetUiWindowManager() + { + iWindowList.ResetAndDestroy(); + + // TODO Why there is a "Disconnect" method in the first place... + // RHandleBase::Close() should be enough? + if ( iServerConnected ) + { + iClientSession.Disconnect(); + } + + iClientSession.Close(); + + delete iHandler; + delete iDialogsProvider; + + if ( iConnection ) + { + TRAP_IGNORE( iConnection->StopConnectionL() ); + } + + delete iConnection; +#ifdef BRDO_WRT_HS_FF + delete iCpsPublisher; +#endif + delete iDb; + } + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::DeactivateMiniViewL() +// Stop MiniView. Stops publishing and exits widget +// +// ----------------------------------------------------------------------------- +// +void CWidgetUiWindowManager::DeactivateMiniViewL( const TUid& aUid ) + { + CWidgetUiWindow* wdgt_window = GetWindow(aUid); + + if(!wdgt_window) + return ; + wdgt_window->SetWindowStateMiniViewL( EMiniViewEnabled ); + SuspendWidget( aUid ); + + // TODO also other states are possible when we should react? + + // Removing . Miniview, shall remove full view as well. For blanket permissions + // will be revoked for miniview + + iClientSession.SetBlanketPermissionL( aUid, EFalse ); + iClientSession.SetMiniViewL( aUid, EFalse ); + CloseWindow( wdgt_window ); + } + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::ActivateMiniView() +// Start publishing offscreenbitmap to HS. +// +// ----------------------------------------------------------------------------- +// +TBool CWidgetUiWindowManager::ActivateMiniViewL( + const TUid& aUid, + const TRect& aRect ) + { + TBool res( EFalse ); + CWidgetUiWindow* wdgt_window( GetWindow( aUid ) ); + + __ASSERT_DEBUG( wdgt_window, User::Invariant() ); + + if ( wdgt_window->WidgetMiniViewState() != EMiniViewNotEnabled ) + { + // We could throw User::Invariant() if state == EPublishStart, but that would be nasty... + if ( wdgt_window->WidgetMiniViewState() != EPublishStart ) + { + iClientSession.SetMiniViewL( aUid, ETrue ); + + HideWindow( iActiveFsWindow ); + //This is done to prevent offscreen bit map overlap + //when widget selected from FSW + wdgt_window->Engine()->MakeVisible( EFalse ); + + if ( !iClientSession.IsBlanketPermGranted ( aUid) ) + { + AllowPlatformAccessL(aUid); + } + else + { + wdgt_window->SetBlanketPromptDisplayed(ETrue); + ResumeWidgetL(aUid); + } + } + + res = ETrue; + } + + return res; + } + +// ------------------------------------------------------------------------ +// CWidgetUiWindowManager::HandleWidgetCommandL() +// Open or close widget window +// +// ------------------------------------------------------------------------ +// +void CWidgetUiWindowManager::HandleWidgetCommandL( + const TUid& aUid, + TUint32 aOperation ) + { + switch ( aOperation ) + { + case LaunchFullscreen: + case LaunchMiniview: + { + OpenOrCreateWindowL( aUid, aOperation ); + } + break; + case Deactivate: + { + DeactivateMiniViewL( aUid ); + } + break; + case WidgetResume: + { + ResumeWidgetL( aUid ); + } + break; + case WidgetSuspend: + { + SuspendWidget( aUid ); + } + break; + case WidgetSelect: + { + // If we don't have window we know that WidgetUI has died + // We must enable miniview state + if( !GetWindow( aUid )) + { + OpenOrCreateWindowL( aUid, LaunchMiniview ); + } + //WidgetLauncher modified to bring app to foreground + OpenOrCreateWindowL( aUid, LaunchFullscreen ); + } + break; + } + } + +void CWidgetUiWindowManager::OpenOrCreateWindowL( + const TUid& aUid, + TUint32 aOperation ) + { + CWidgetUiWindow* wdgt_window( GetWindow( aUid ) ); + TBool setFullViewState(EFalse); + +#ifdef BRDO_WRT_HS_FF + TSize miniviewSize( iCpsPublisher->BitmapSize()); +#else + TSize miniviewSize( 0,0 ); +#endif + + if( wdgt_window ) + { + // This might come from app shell as well where appshell window needs to be resized + // then active window should be set + // if active window is there hide it + // set the new window as current and active. Chcek if window needs resizing and set the registry as fullView and active + // can be checked , we can launch in full view if Rect size is same as view size + + + if ( aOperation == LaunchMiniview ) + { + if ( !ActivateMiniViewL( aUid, miniviewSize ) ) + { + wdgt_window = NULL; + } + } + + // If the existing widget is in miniview state, we need to make it full-screen. + // Sanity check that we don't have to do anything extra. + else + { +#ifdef BRDO_WRT_HS_FF + //Make sure that all the mini widgets are already suspended + SuspendAllWidget(); +#endif + // TODO Combine these methods somewhere in WidgetUiWindow, so it knows + // how to tamper its own internal state. For example MakeFullScreen(). + + setFullViewState = ETrue; + iClientSession.SetFullViewL( aUid, ETrue ); + } + } + else + { + // Create a new window. + if ( !IsWidgetAllowedL( aUid ) ) + { + ShowNoteDialogL( R_WIDGETUI_STRICT_MODE_ACCESS ); + + iAppUi.SendAppToBackground(); + } + else + { + // Does the widget support miniviews, in case that is desired? + if ( aOperation == LaunchFullscreen || DoesWidgetSupportMiniviewL( aUid ) ) + { + if ( aOperation == LaunchFullscreen ) + iClientSession.SetFullViewL( aUid, ETrue ); + // Create window. + wdgt_window = CreateNewWidgetWindowL( aUid ); + + if ( aOperation ) + { + // Don't care if this returns, we know miniviews are supported. + TRAPD( err, ActivateMiniViewL( aUid, miniviewSize ) ); + if ( err ) + { + CloseWindow( wdgt_window ); + wdgt_window = NULL; + } + } + else + { +#ifdef BRDO_WRT_HS_FF + SuspendAllWidget(); +#endif + setFullViewState = ETrue; + + } + } + } + } + + // Windows are up & running. Hopefully. + if ( wdgt_window ) + { + if ( iActiveFsWindow != wdgt_window ) + { + HideWindow( iActiveFsWindow ); + } + + if( setFullViewState ) + { + iActiveFsWindow = wdgt_window; + iActiveFsWindow->SetWindowStateFullView(ETrue); + iActiveFsWindow->SetCurrentWindow( ETrue ); + if ( iActiveFsWindow->Engine()->Rect() != View()->ClientRect()) + { + iActiveFsWindow->Engine()->SetRect( View()->ClientRect() ); + } + //iActiveFsWindow->Engine()->MakeVisible( ETrue ); + + } + } + iClientSession.SetActive( aUid, ETrue ); + } + +// ============================================================================= +// CWidgetUiWindowManager::AllowPlatformAccessL() +// Prompt for network access allow +// +// ============================================================================= +// +void CWidgetUiWindowManager::AllowPlatformAccessL( const TUid& aUid ) + { + CWidgetUiWindow* wdgt_window( GetWindow( aUid ) ); + if( !wdgt_window) + return ; + + HBufC* confirmationText = StringLoader::LoadLC(R_WIDGETUI_PLEASE_WORK); + TInt softKey = R_AVKON_SOFTKEYS_OK_CANCEL; + CGlobalQueryHandlerAO* tmp = NULL; + TRAP_IGNORE( tmp = CGlobalQueryHandlerAO::StartLD( *this, *wdgt_window , confirmationText->Des(), softKey ) ); + CleanupStack::PopAndDestroy(confirmationText); + } + +// ============================================================================= +// CWidgetUiWindowManager::GetWindow() +// return the window of a widget with a particular url +// +// ============================================================================= +// +CWidgetUiWindow* CWidgetUiWindowManager::GetWindow( const TDesC& aUrl ) + { + for ( TInt i = 0; i < iWindowList.Count(); i++ ) + { + CWidgetUiWindow* window = iWindowList[i]; + if ( window->Url()->Des() == aUrl ) + { + return window; + } + } + return NULL; + } + +// ============================================================================= +// CWidgetUiWindowManager::GetWindow() +// return the window of a widget with a particular Uid +// +// ============================================================================= +// +CWidgetUiWindow* CWidgetUiWindowManager::GetWindow( const TUid& aUid ) + { + for ( TInt i = 0; i < iWindowList.Count(); i++ ) + { + CWidgetUiWindow* window = iWindowList[i]; + if ( window->Uid() == aUid ) + { + return window; + } + } + return NULL; + } + +// ============================================================================= +// CWidgetUiWindowManager::CloseWindow() +// close window of widget +// +// ============================================================================= +// +void CWidgetUiWindowManager::CloseWindow( CWidgetUiWindow* aWidgetWindow ) + { + + TBool lastOne( iWindowList.Count() == 1 ); + + RemoveFromWindowList( aWidgetWindow ); + + if ( !lastOne ) + { + // Starting JS timer, since we stopped it for deactivating miniview widget + CWidgetUiWindow* window = iWindowList[iWindowList.Count() - 1]; + if ( window) + TRAP_IGNORE ( window->Engine()->HandleCommandL( + (TInt)TBrCtlDefs::ECommandAppForeground + + (TInt)TBrCtlDefs::ECommandIdBase)); + + for ( TInt i = 0; i < iWindowList.Count(); ++i )// Fix needed. Do we need onShow here. + { + CWidgetUiWindow* window( iWindowList[i] ); + if ( window->WidgetMiniViewState() == EPublishStart ) + { + TRAP_IGNORE (window->WidgetExtension()->HandleCommandL( + (TInt)TBrCtlDefs::ECommandAppForeground + + (TInt)TBrCtlDefs::ECommandIdBase)); + + break; + } + } + + } + } + +// ============================================================================= +// CWidgetUiWindowManager::RemoveFromWindowList() +// remove widget window from window list +// +// ============================================================================= +// +void CWidgetUiWindowManager::RemoveFromWindowList( CWidgetUiWindow* aWidgetWindow ) + { + __ASSERT_DEBUG( aWidgetWindow, User::Invariant() ); + if ( iDialogsProvider->IsDialogLaunched() ) + { + return; + } + + if ( iClientSession.IsWidgetInFullView ( aWidgetWindow->Uid())) + { + HideWindow( aWidgetWindow ); + if (aWidgetWindow == iActiveFsWindow) + iActiveFsWindow = NULL; + // make widgets act like separate applications by pushing to background + // when widget is in fullview , this way user is sent back to app shell or idle + // to run another widget + iAppUi.SendAppToBackground(); + } + + // update the status of the widget to not active. + TRAP_IGNORE(iClientSession.SetFullViewL( aWidgetWindow->Uid(), EFalse )); + iClientSession.SetActive( aWidgetWindow->Uid(), EFalse ); + + iWindowList.Remove( iWindowList.Find( aWidgetWindow ) ); + TBool lastOne( iWindowList.Count() == 0 ); + if ( lastOne ) + { + TRAP_IGNORE( aWidgetWindow->Engine()->HandleCommandL( + (TInt)TBrCtlDefs::ECommandIdBase + + (TInt)TBrCtlDefs::ECommandDisconnect ) ); + + delete aWidgetWindow; + iAppUi.Exit(); + } + else + { + delete aWidgetWindow; + } + } + +// ============================================================================= +// CWidgetUiWindowManager::CloseWindow() +// close window of widget with a particular Uid +// +// ============================================================================= +// +void CWidgetUiWindowManager::CloseWindow( const TUid& aUid ) + { + CWidgetUiWindow* widgetWindow = GetWindow( aUid ); + CloseWindow( widgetWindow ); + } + +// ============================================================================= +// CWidgetUiWindowManager::CloseAllWindowsExceptCurrent() +// close all window except the current widget +// +// ============================================================================= +// +void CWidgetUiWindowManager::CloseAllWindowsExceptCurrent() + { + TInt idx(0); + SuspendAllWidget(); + while (iWindowList.Count() > 1) + { + CWidgetUiWindow* window = iWindowList[idx]; + TRAP_IGNORE(iClientSession.SetMiniViewL( window->Uid(), EFalse )); + if(CheckIfWindowNeedsToBeClosed(window)) + { + RemoveFromWindowList( window ); + } + else + { + idx++;// skip ActiveWindow + } + } + } + +// ============================================================================= +// CWidgetUiWindowManager::CheckIfWindowNeedsToBeClosed() +// return true for the widgets that needs to be closed +// +// ============================================================================= +// +TBool CWidgetUiWindowManager::CheckIfWindowNeedsToBeClosed(CWidgetUiWindow* aWindow) const + { + __ASSERT_DEBUG( aWindow, User::Invariant() ); + + if( aWindow == iActiveFsWindow ) + { + if ( aWindow->WidgetMiniViewState() == EPublishStart || + aWindow->WidgetMiniViewState() == EPublishSuspend ) + { + // Incase when the widget is active and as in full as well as miniview. + // it will stop publishing + TRAP_IGNORE(aWindow->SetWindowStateMiniViewL( EMiniViewEnabled )); + } + return EFalse; + } + return ETrue; + } + +// ============================================================================= +// CWidgetUiWindowManager::Exit() +// Exit from widget and close widget window +// +// ============================================================================= +// +void CWidgetUiWindowManager::Exit( TInt aCommand, const TUid& aUid ) + { + CWidgetUiWindow* window( GetWindow( aUid ) ); + if( !window ) + return; + if( ( window->WidgetMiniViewState() == EMiniViewEnabled ) || + ( window->WidgetMiniViewState() == EMiniViewNotEnabled ) ) + { + // The widget is not publishing. + if ( window->WidgetExtension() ) + { + if ( window->WidgetExtension()->HandleCommandL( aCommand ) ) + return; + } + + CloseWindow( window ); + if( window == iActiveFsWindow) + iActiveFsWindow = NULL; + } + else + { + ExitPublishingWidget( aUid ); + } + } + +// ============================================================================= +// CWidgetUiWindowManager::ExitPublishingWidget() +// Exit from widget in full view when it is publishing +// +// ============================================================================= +// +void CWidgetUiWindowManager::ExitPublishingWidget( const TUid& aUid ) + { + CWidgetUiWindow* window( GetWindow( aUid ) ); + if( !window ) + return; + + // make widgets act like separate applications by pushing to background + // this way user is sent back to app shell or idle to run another widget + iAppUi.SendAppToBackground(); + + if ( iWindowList.Count() == 0 ) + { + iAppUi.Exit(); //TODO Check if it is required for publishin widget + } + window->Engine()->MakeVisible( EFalse ); + window->SetWindowStateFullView( EFalse ); + // Add registry info + TRAP_IGNORE(iClientSession.SetFullViewL( window->Uid(), EFalse )); + } + +// ============================================================================= +// CWidgetUiWindowManager::SetActiveWidgetAtExit() +// Set active widget to widget in full view which is not added to homescreen +// incase no such widget is there set it to null +// +// ============================================================================= +// +void CWidgetUiWindowManager::SetActiveWidgetAtExit() + { + //Get widget in Fullview that is not publishing and not same as active window + for ( TInt i = 0; i < iWindowList.Count(); ++i ) + { + CWidgetUiWindow* window( iWindowList[i] ); + if ( ( window != iActiveFsWindow ) && + ( window->WidgetFullViewState() ) ) + { + iActiveFsWindow = window; + //ShowWindow( window ); + return; + } + } + + iActiveFsWindow = NULL; + } + +// ============================================================================= +// CWidgetUiWindowManager::HandleLSKcommandL() +// Execute LSK Handler if present +// +// ============================================================================= +// +TBool CWidgetUiWindowManager::HandleLSKCommandL( TInt aCommand ) + { + if ( iActiveFsWindow && iActiveFsWindow->WidgetExtension() ) + + { + return iActiveFsWindow->WidgetExtension()->HandleCommandL( aCommand ); + } + return EFalse; + + } + +// ============================================================================= +// CWidgetUiWindowManager::GetWidgetEntryForUrl() +// return Uid of widget with a particular Url +// +// ============================================================================= +// +TInt CWidgetUiWindowManager::GetWidgetEntryForUrl( const TDesC& aUrl ) //const + { + return iClientSession.GetWidgetUidForUrl( aUrl ); + } + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::SetDisplayLandscape() +// switch the display orientation to landscape +// +// ----------------------------------------------------------------------------- +// +void CWidgetUiWindowManager::SetDisplayLandscape( ) + { + TRAP_IGNORE(iAppUi.SetDisplayLandscapeL()); + } + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::SetDisplayPortrait() +// switch the display orientation to portrait +// +// ----------------------------------------------------------------------------- +// +void CWidgetUiWindowManager::SetDisplayPortrait( ) + { + TRAP_IGNORE(iAppUi.SetDisplayPortraitL()); + } + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::SetDisplayAuto() +// switch the display orientation to device defined +// +// ----------------------------------------------------------------------------- +// +void CWidgetUiWindowManager::SetDisplayAuto( ) + { + iAppUi.SetDisplayAuto(); + } + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::HandleForegroundEvent +// called when application goes to background or comes back to foreground +// +// This method is called only for "Go to background" events. "Come to foreground" +// is filtered away by CWidgetUiAppUi::HandleForegroundEventL . +// But we need to check the aForeground value anyway since flipping back and +// forth from powersave mode doesn't involve OpenOrCreateWindowL. +// ----------------------------------------------------------------------------- +// +void CWidgetUiWindowManager::HandleForegroundEvent( TBool aForeground ) + { + if ( aForeground ) + { + ShowWindow( iActiveFsWindow ); + } + else + { + HideWindow( iActiveFsWindow ); + } + } + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::HandleOOMEventL +// called when out of memory message is received by app ui +// +// ----------------------------------------------------------------------------- +// +void CWidgetUiWindowManager::HandleOOMEventL( TBool /*aForeground*/ ) + { + HBufC* message = StringLoader::LoadLC( R_WIDGETUI_OOM_EVENT ); + CAknConfirmationNote* note = new (ELeave) CAknConfirmationNote( ETrue ); + note->ExecuteLD(*message ); + CleanupStack::PopAndDestroy( message );// message + + CloseWindowsAsync( ETrue );// close all widgets + } + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::CloseWindowsAsync +// close all windows or current window async +// +// ----------------------------------------------------------------------------- +// +void CWidgetUiWindowManager::CloseWindowsAsync( TBool aAllWindows ) + { + iAppUi.AsyncExit(aAllWindows); + } + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::SuspendWidget +// Suspend currently publishing widget (if so). +// +// ----------------------------------------------------------------------------- +// +void CWidgetUiWindowManager::SuspendWidget( const TUid& aUid ) + { + CWidgetUiWindow* wdgt_window = GetWindow(aUid); + + if(!wdgt_window) + return; + + if( (wdgt_window->WidgetMiniViewState() == EPublishStart) && + (wdgt_window->WidgetMiniViewState() != EPublishSuspend)) + { + TRAP_IGNORE( + wdgt_window->SetWindowStateMiniViewL(EPublishSuspend); + + wdgt_window->WidgetExtension()->HandleCommandL( + (TInt)TBrCtlDefs::ECommandAppBackground + + (TInt)TBrCtlDefs::ECommandIdBase); + + wdgt_window->Engine()->HandleCommandL( + (TInt)TBrCtlDefs::ECommandAppBackground + + (TInt)TBrCtlDefs::ECommandIdBase); + ); + + } + + } + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::ResumeWidget +// Resume publishing stuff, in case it is valid for the widget. +// +// ----------------------------------------------------------------------------- +// +void CWidgetUiWindowManager::ResumeWidgetL( const TUid& aUid ) + { + CWidgetUiWindow* wdgt_window( GetWindow( aUid ) ); + + // Window can be null if WidgetUI has been killed due to low memory situation + //__ASSERT_DEBUG( wdgt_window, User::Invariant() ); + if(!wdgt_window || !wdgt_window->GetBlanketPromptDisplayed()) + return; + + if( (wdgt_window ->WidgetMiniViewState() == EMiniViewEnabled) || + (wdgt_window->WidgetMiniViewState() == EPublishSuspend) ) + { + //HideWindow( iActiveFsWindow ); + //iActiveFsWindow = NULL; + // Publish should start only after widget is resumed. + wdgt_window->SetWindowStateMiniViewL(EPublishStart); + + wdgt_window->Engine()->HandleCommandL( + (TInt)TBrCtlDefs::ECommandAppForeground + + (TInt)TBrCtlDefs::ECommandIdBase); + + wdgt_window->WidgetExtension()->HandleCommandL( + (TInt)TBrCtlDefs::ECommandAppForeground + + (TInt)TBrCtlDefs::ECommandIdBase); +#ifdef BRDO_WRT_HS_FF + wdgt_window->Engine()->SetRect( iCpsPublisher->BitmapSize()); +#endif + } + } + +// ----------------------------------------------------------------------------- +// CWidgetUiWindowManager::SuspendAllWidget +// SUspend all publishing widgets, if not already done. +// +// ----------------------------------------------------------------------------- +// +void CWidgetUiWindowManager::SuspendAllWidget() + { + for ( TInt i = 0; i < iWindowList.Count(); i++ ) + { + CWidgetUiWindow* window = iWindowList[i]; + if ( window->WidgetMiniViewState() == EPublishStart) + { + SuspendWidget(window->Uid()); + } + } + + } + +// ------------------------------------------------------------------------ +// CWidgetUiWindowManager::HideWindow +// +// Hide currently active window. +// ------------------------------------------------------------------------ +void CWidgetUiWindowManager::HideWindow( CWidgetUiWindow* aWindow ) + { + if ( aWindow ) + { + // Hide the previously active widget. + aWindow->SetCurrentWindow(EFalse); + /* + if( iActiveFsWindow->WidgetMiniViewState() == EPublishSuspend ) + { + iClientSession.SetFullView( aWindow->Uid(), EFalse ); + aWindow->SetWindowStateFullView( EFalse ); + } + */ + } + } + +// ------------------------------------------------------------------------ +// CWidgetUiWindowManager::IsWidgetAllowedL +// +// Check widget's compatibility for running. +// ------------------------------------------------------------------------ +TBool CWidgetUiWindowManager::IsWidgetAllowedL( + const TUid& aUid ) //const + { + __UHEAP_MARK; + + TBool res( EFalse ); + CWidgetPropertyValue* value( iClientSession.GetWidgetPropertyValueL( + aUid, + ENokiaWidget ) ); + + if ( iStrictMode ) + { + if ( *value ) + { + res = ETrue; + } + } + else + { + res = *value; + } + + delete value; + + __UHEAP_MARKEND; + return res; + } + +// ------------------------------------------------------------------------ +// CWidgetUiWindowManager::ShowNoteDialogL +// +// Show a note to user. +// ------------------------------------------------------------------------ +void CWidgetUiWindowManager::ShowNoteDialogL( TInt aResourceID ) const + { + CEikDialog* dialog( NULL ); + HBufC* message( StringLoader::LoadLC( aResourceID ) ); + + dialog = new (ELeave) CAknNoteDialog( + &dialog, + CAknNoteDialog::ENoTone, + CAknNoteDialog::ELongTimeout ); + + CleanupStack::PushL( dialog ); + static_cast< CAknNoteDialog* >( dialog )->SetTextL( *message ); + CleanupStack::Pop( dialog ); + + CleanupStack::PopAndDestroy( message ); + dialog->ExecuteLD(R_WIDGETUI_OK_NOTE); + delete dialog; + dialog = NULL; + } + +// ------------------------------------------------------------------------ +// CWidgetUiWindowManager::CreateNewWidgetWindowL +// +// New widget, new window. +// ------------------------------------------------------------------------ +CWidgetUiWindow* CWidgetUiWindowManager::CreateNewWidgetWindowL( + const TUid& aUid ) + { +#ifdef BRDO_WRT_HS_FF + CWidgetUiWindow* window( + CWidgetUiWindow::OpenWindowL( *this, aUid, iCpsPublisher ) ); +#else + CWidgetUiWindow* window( + CWidgetUiWindow::OpenWindowL( *this, aUid, NULL ) ); +#endif + + CleanupStack::PushL( window ); + + // Add it to the queue + iWindowList.AppendL( window ); + + CleanupStack::Pop( window ); + + // reset the display orientation when the widget is launched + iAppUi.SetDisplayAuto(); + + window->ReloadWidget(); + + return window; + } + +// ------------------------------------------------------------------------ +// CWidgetUiWindowManager::DoesWidgetSupportMiniviewL +// +// Register widget to CPS listener. +// ------------------------------------------------------------------------ +TBool CWidgetUiWindowManager::DoesWidgetSupportMiniviewL( const TUid& aUid ) + { + __UHEAP_MARK; + CWidgetPropertyValue* val( iClientSession.GetWidgetPropertyValueL( aUid, EMiniViewEnable ) ); + TBool res( *val ); + + delete val; + + __UHEAP_MARKEND; + + return res; + } + +void CWidgetUiWindowManager::ShowWindow( CWidgetUiWindow* aWindow ) + { + if ( !aWindow ) + return; + if ( aWindow != iActiveFsWindow ) + { + HideWindow( iActiveFsWindow ); + } + + iActiveFsWindow = aWindow; + iActiveFsWindow->SetCurrentWindow( ETrue ); + iActiveFsWindow->Engine()->MakeVisible( ETrue ); + } + +// ------------------------------------------------------------------------ +// CGlobalQueryHandlerAO::StartLD +// +// Initialize AO. +// ------------------------------------------------------------------------ +CGlobalQueryHandlerAO* CGlobalQueryHandlerAO::StartLD( + CWidgetUiWindowManager& aManager, + CWidgetUiWindow& aWindow, + const TDesC& aMessage, + TInt aSoftkeys) + { + CGlobalQueryHandlerAO* self( new( ELeave ) CGlobalQueryHandlerAO( aManager, aWindow, aMessage, aSoftkeys) ); + TRAPD(error, self->ShowGlobalQueryDialogL ( aMessage, aSoftkeys )); + if ( error ) + { + delete self; + User::Leave(error); + } + self->SetActive(); + self->iScheduler.Start(); + return self; + } + +// ------------------------------------------------------------------------ +// CGlobalQueryHandlerAO::CGlobalQueryHandlerAO +// +// Constructor. +// ------------------------------------------------------------------------ +CGlobalQueryHandlerAO::CGlobalQueryHandlerAO( + CWidgetUiWindowManager& aManager, + CWidgetUiWindow& aWindow, + const TDesC& aMessage, + TInt aSoftkeys):CActive( EPriorityHigh ), + iWindow ( aWindow ), + iManager(aManager), + iConfirmationText(aMessage.AllocL()) + { + CActiveScheduler::Add( this ); + } + +// ------------------------------------------------------------------------ +// CGlobalQueryHandlerAO::CGlobalQueryHandlerAO +// +// ISet network and platofrom access permission based on user response. +// ------------------------------------------------------------------------ +void CGlobalQueryHandlerAO::RunL() + { + if (iScheduler.IsStarted()) + { + iScheduler.AsyncStop(); + } + + RWidgetRegistryClientSession clientSession = iManager.WidgetUIClientSession(); + if (iStatus == EAknSoftkeyOk) + { + clientSession.SetBlanketPermissionL( iWindow.Uid(), ETrue ); + } + else if ( iStatus == EAknSoftkeyCancel) + { + //iWindow.SetNetworkAccessGrant(EDeny); + clientSession.SetBlanketPermissionL( iWindow.Uid(), EFalse ); + //User::Leave( KErrAccessDenied ); + } + iWindow.SetBlanketPromptDisplayed(ETrue); + iManager.ResumeWidgetL(iWindow.Uid()); + delete this; + } + +// ------------------------------------------------------------------------ +// CGlobalQueryHandlerAO::DoCancel +// +// Do nothing. +// ------------------------------------------------------------------------ +void CGlobalQueryHandlerAO::DoCancel() + { + if ( iGlobalConfirmationQuery ) + { + iGlobalConfirmationQuery->CancelConfirmationQuery(); + } + iScheduler.AsyncStop(); + } + +// ------------------------------------------------------------------------ +// CGlobalQueryHandlerAO::~CGlobalQueryHandlerAO +// +// Destructor. +// ------------------------------------------------------------------------ +CGlobalQueryHandlerAO::~CGlobalQueryHandlerAO() + { + Cancel(); + delete iGlobalConfirmationQuery; + delete iConfirmationText; + } + +// --------------------------------------------------------- +// CGlobalQueryHandlerAO::ShowGlobalQueryDialogL() +// --------------------------------------------------------- +// +void CGlobalQueryHandlerAO::ShowGlobalQueryDialogL(const TDesC& aMessage, TInt aSoftkeys) + { + iGlobalConfirmationQuery = CAknGlobalConfirmationQuery::NewL(); + iGlobalConfirmationQuery->ShowConfirmationQueryL + (iStatus, + aMessage, + aSoftkeys); + } + +// End of file + + + + +