/*

* 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 "WidgetUiNetworkListener.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 <WidgetUi.rsg>

#include <brctlinterface.h>

#include <widgetregistryconstants.h>

#include <centralrepository.h>

#include <StringLoader.h>

#include <AknNoteDialog.h>

#include <browserdialogsprovider.h>

#include <S32FILE.H>

#include <aknnotewrappers.h>

#include "cpglobals.h" // CPS string definitions.

#include <internetconnectionmanager.h>

#include <ActiveApDb.h>

#include <oommonitorsession.h>

#include <aknglobalnote.h>

// LOCAL FUNCTION PROTOTYPES

TInt doDestructOOMNotifyTimer( TAny* ptr );

TInt doNotifyHarvester( TAny* ptr );

// CONSTANTS

#define KUidWidgetOOMPlugin 0x10282855

const TUint32 KCRUidActiveIdleLV = 0x10275102;

const TUint32 KAIWebStatus = 0x0000300F;

const TInt KMemoryToCreateWidgetWindow = 10*1024*1024;

const TInt KOOMNotificationDialogIntervalTimeOut = 60000000;

const TInt KOOMNotificationDialogTimeOut = 2000000;

const TInt KOOMHarvesterNotificationTimeOut = 5000000;

const TInt KOOMWidgetCloseTimeOut = 15;//Do not close the widget that was started after OOM within 15 sec

class CRequestRAM : public CActive

    {

public: 

    static CRequestRAM* StartLD(CWidgetUiWindowManager* aWidgetUiWindowManager, const TUid& aUid, TUint32 aOperation);

protected: // From CActive

    /**

    * Execute asynchronous operation.

    */

    void RunL();

    /**

    * Provide cancellation methods.

    */

    void DoCancel();

    void ConstructL();

private:

    /**

    * Constructor.

    */

    CRequestRAM (CWidgetUiWindowManager* aWidgetUiWindowManager, const TUid& aUid, TUint32 aOperation);

    /**

    * Destructor. 

    *

    * Private on purpose.

    */

    ~CRequestRAM();

private:

    ROomMonitorSession iOomSession;

    CWidgetUiWindowManager* iWidgetUiWindowManager;

    TUid iUid;

    TUint32 iOperation;

    };

// ============================= LOCAL FUNCTIONS ================================

static void NotifyCommandHandled()

    {

    const TUid KMyPropertyCat = { 0x10282E5A };

    enum TMyPropertyKeys { EMyPropertyState = 109 };

    TInt state( 1 );

    RProperty::Set( KMyPropertyCat, EMyPropertyState , state );

    }

// =============================================================================

// -----------------------------------------------------------------------------

// CWidgetUiWindowManager::CWidgetUiWindowManager()

// Default constructor

//

// -----------------------------------------------------------------------------

//

CWidgetUiWindowManager::CWidgetUiWindowManager(CWidgetUiAppUi& aAppUi):

    iAppUi(aAppUi),

    iStrictMode(ETrue),

    iNetworkMode(EUnknownMode),

    iNetworkConnected(EFalse),

    iWidgetCursorMode(TBrCtlDefs::EDefaultCursor)

    {

    }

// -----------------------------------------------------------------------------

// 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;

        TInt cursorMode = -1;

        TInt enterKeyMode = -1;

        if (cenRep->Get( KWidgetInstallerStrictMode, strictMode ) == KErrNone)

            {

            iStrictMode = strictMode;

            }

        if (cenRep->Get( KWidgetCursorShowMode, cursorMode ) == KErrNone)

            {

            iWidgetCursorMode = (TBrCtlDefs::TCursorSettings) cursorMode;

            }

        if (cenRep->Get( KWidgetEnterKeyMode, enterKeyMode ) == KErrNone)

            {

            iWidgetEnterKeyMode = (TBrCtlDefs::TEnterKeySettings) enterKeyMode;

            }

        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

    iNetworkListener = CWidgetUiNetworkListener::NewL( *this );

    }

// -----------------------------------------------------------------------------

// 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()

    {

    if( iDialogsProvider)

        iDialogsProvider->CancelAll();

    iActiveFsWindow = NULL;

    iWindowList.ResetAndDestroy();

    delete iNetworkListener;

    // 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

//

// -----------------------------------------------------------------------------

//

TBool CWidgetUiWindowManager::DeactivateMiniViewL( const TUid& aUid )

    {

    CWidgetUiWindow* wdgt_window = GetWindow(aUid);

    if(!wdgt_window)

        return EFalse;

    wdgt_window->SetWindowStateMiniViewL( EMiniViewEnabled );

    // 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, EBlanketUnknown );

    iClientSession.SetMiniViewL( aUid, EFalse );

    return 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 );                    

            }

        res = ETrue;

        }

    return res;

    }

// ------------------------------------------------------------------------

// CWidgetUiWindowManager::HandleWidgetCommandL()

// Open or close widget window

//

// ------------------------------------------------------------------------

//

void CWidgetUiWindowManager::HandleWidgetCommandL( 

    const TUid& aUid,

    TUint32 aOperation )

    {

    TBool exit( EFalse );

    TBool needToNotify (ETrue) ;

    switch ( aOperation )

        {

        case LaunchFullscreen:

        case LaunchMiniview:

            {

            OpenOrCreateWindowL( aUid, aOperation );

            }

            break;

        case Deactivate:

            {

            exit = DeactivateMiniViewL( aUid );

            }

            break;

        case WidgetResume:

            {

            needToNotify = GetWindow(aUid) ? ETrue: EFalse;

            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))

                {        

                needToNotify = EFalse;

                CanWindowBeCreated( aUid, aOperation );

                break;

                }

            //WidgetLauncher modified to bring app to foreground

            GetWindow( aUid)->IncrementClickCount();

            OpenOrCreateWindowL( aUid, LaunchFullscreen );            

            }

            break;

        case WidgetOnline:

            {

            iNetworkMode = EOnlineMode;

            CWidgetUiWindow* wdgt_window( GetWindow( aUid ) );

            if (wdgt_window)

                {

#ifdef BRDO_WRT_HS_FF

                if ( wdgt_window->NetworkModeWait()->IsStarted() )

                    {

                    wdgt_window->NetworkModeWait()->AsyncStop();

                    }

#endif

                if(wdgt_window->IsWidgetLoaded())

                    wdgt_window->DetermineNetworkState();

                else

                    wdgt_window->NeedToNotifyNetworkState(ETrue);

                }

            }

            break;

       case WidgetOffline:

            {

            iNetworkMode = EOfflineMode;

            CWidgetUiWindow* wdgt_window( GetWindow( aUid ) );

            if (wdgt_window)

            	{

#ifdef BRDO_WRT_HS_FF

                if ( wdgt_window->NetworkModeWait()->IsStarted() )

                    {

                    wdgt_window->NetworkModeWait()->AsyncStop();

                    }

#endif

                // if no full view widgets open, then close the network connection

                if ( ( !FullViewWidgetsOpen() ) && ( iConnection->Connected() ) )

                    {

                    TRAP_IGNORE( wdgt_window->Engine()->HandleCommandL( 

                            (TInt)TBrCtlDefs::ECommandIdBase +

                            (TInt)TBrCtlDefs::ECommandCancelFetch ) );

                    wdgt_window->Engine()->HandleCommandL( 

                            (TInt)TBrCtlDefs::ECommandIdBase +

                            (TInt)TBrCtlDefs::ECommandDisconnect );

                    iConnection->CancelConnection();

                    iConnection->StopConnectionL();

                    }

                if(wdgt_window->IsWidgetLoaded())

                    wdgt_window->DetermineNetworkState();

                else

                    wdgt_window->NeedToNotifyNetworkState(ETrue);

                }

            }

            break; 

        }

    if(needToNotify)

    // Widget is up and running, notify that next one can be launched    

    	NotifyCommandHandled();

    if( exit )

        {

        iAppUi.Exit();

        }

    }

// ------------------------------------------------------------------------

// CWidgetUiWindowManager::CanWindowBeCreated()

// Check for availaibilty for window creation

//

// ------------------------------------------------------------------------

//

void CWidgetUiWindowManager::CanWindowBeCreated(const TUid& aUid, TUint32 aOperation)

    {

    CRequestRAM* requestRam = CRequestRAM::StartLD(this, aUid, aOperation);

    }

// ------------------------------------------------------------------------

// CWidgetUiWindowManager::OpenOrCreateWindowL()

// Open or create widget window

//

// ------------------------------------------------------------------------

//

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  )