/*

* 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"

#include "WidgetUiPSNotifier.h"

#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 <S32FILE.H>

#include <aknnotewrappers.h>

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

#include <internetconnectionmanager.h>

#include <ActiveApDb.h>

#include <oommonitorsession.h>

#include <aknglobalnote.h>

#ifdef BRDO_MULTITOUCH_ENABLED_FF  

#include<akntranseffect.h>

#include<gfxtranseffect/GfxTransEffect.h>

#endif

#ifdef BRDO_OCC_ENABLED_FF

#include <extendedconnpref.h>

#endif

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

#ifdef BRDO_OCC_ENABLED_FF

const TInt KRetryConnectivityTimeout( 2*1000*1000 ); // 2 seconds

#endif

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;

        }

    iHandler = CDocumentHandler::NewL(CEikonEnv::Static()->Process());

    iDb = CActiveApDb::NewL( EDatabaseTypeIAP );

    #ifdef BRDO_OCC_ENABLED_FF

    iConnection = CInternetConnectionManager::NewL( iDb->Database(), ETrue );

    #else

    iConnection = CInternetConnectionManager::NewL( iDb->Database(), EFalse );

    #endif

#ifdef BRDO_WRT_HS_FF    

    iCpsPublisher = CCpsPublisher::NewL();

    iCenrepNotifyHandler = CCenrepNotifyHandler::NewL( *this );

    iNetworkListener = CWidgetUiNetworkListener::NewL( *this );

#endif

#ifdef BRDO_OCC_ENABLED_FF

    iConnStageNotifier = CConnectionStageNotifierWCB::NewL();

    iConnStageNotifier->SetPriority(CActive::EPriorityHigh);

    iRetryConnectivity = CPeriodic::NewL(CActive::EPriorityStandard);

#endif

        //Creating observer WidgetWindowsObeserver

    iWidgetNotifier = CWidgetUiPSNotifier::NewL(*this, EWidgetRegAltered);

#ifdef BRDO_SAPINTFN_ENABLED_FF

    iWidgetSapiNotifier = CWidgetUiPSNotifier::NewL(*this, ESapiPrompt);

    iWidgetSapiClearNotifier = CWidgetUiPSNotifier::NewL(*this, ESapiPromptCleared);

#endif

    iLightObserver = CHWRMLight::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()

    {

#ifdef BRDO_WRT_HS_FF 

    iCenrepNotifyHandler->DoCancel();

    delete iCenrepNotifyHandler;

#endif

    iActiveFsWindow = NULL;

#ifdef BRDO_OCC_ENABLED_FF 

    if ( iRetryConnectivity)

        {

        iRetryConnectivity->Cancel();

        delete iRetryConnectivity;

        iRetryConnectivity = NULL;

        }

#endif

	  iWindowList.ResetAndDestroy();

#ifdef BRDO_WRT_HS_FF   

    delete iNetworkListener;

#endif

    // TODO Why there is a "Disconnect" method in the first place...

    // RHandleBase::Close() should be enough?

    if ( iServerConnected )

        {

        iClientSession.Disconnect();

        }

    iClientSession.Close();

    delete iHandler;

    if ( iConnection )

        {

        TRAP_IGNORE( iConnection->StopConnectionL() );

        }

    delete iConnection;

#ifdef BRDO_WRT_HS_FF  

    delete iCpsPublisher;

#endif

    delete iDb;

    delete iWidgetNotifier;

#ifdef BRDO_SAPINTFN_ENABLED_FF

    delete iWidgetSapiNotifier;

    delete iWidgetSapiClearNotifier;

#endif

    delete iLightObserver;

    }

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

// 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.SetMiniViewL( aUid, EFalse );

#ifdef BRDO_OCC_ENABLED_FF

    wdgt_window->CancelAllDialogs();

     if ( wdgt_window->IsDialogsLaunched() )

        {

        return EFalse;

        }

#endif    

    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

#ifdef BRDO_MULTITOUCH_ENABLED_FF

            GfxTransEffect::BeginFullScreen(AknTransEffect::EApplicationStart,TRect(0,0,0,0),AknTransEffect::EParameterType,AknTransEffect::GfxTransParam(TUid::Uid(KWidgetAppUid)));

#endif

            if( !GetWindow(aUid))

                {        

                needToNotify = EFalse;

                CanWindowBeCreated( aUid, aOperation );

                break;

                }

            //WidgetLauncher modified to bring app to foreground

            GetWindow( aUid)->IncrementClickCount();

            OpenOrCreateWindowL( aUid, LaunchFullscreen );            

#ifdef BRDO_MULTITOUCH_ENABLED_FF            

            GfxTransEffect::EndFullScreen();

#endif            

            }

            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 ( iConnection->Connected())

                     {

                     for ( TInt i = 0; i < iWindowList.Count(); i++ )

                         {

                         CWidgetUiWindow* window = iWindowList[i];

                         if ( window && 

                     	       (window->WidgetMiniViewState() == EPublishStart ||

                     	       window->WidgetMiniViewState() == EPublishSuspend) 

                     	      )

                             //Send cancelFetch to all windows

                             TRAP_IGNORE( window->Engine()->HandleCommandL( 

                                (TInt)TBrCtlDefs::ECommandIdBase +

                                (TInt)TBrCtlDefs::ECommandCancelFetch ) );

                         }

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

                        (TInt)TBrCtlDefs::ECommandIdBase +

                        (TInt)TBrCtlDefs::ECommandDisconnect ) );                     

                      }

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

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

                    {

                     iConnection->StopConnectionL();

#ifdef BRDO_OCC_ENABLED_FF                    

                     StopConnectionObserving();

#endif

                   }

                if(wdgt_window->IsWidgetLoaded())

                    wdgt_window->DetermineNetworkState();

                else

                    wdgt_window->NeedToNotifyNetworkState(ETrue);

                }

            }

            break; 

        case WidgetFullViewClose:

        	{

        	needToNotify = EFalse ;

#ifdef BRDO_OCC_ENABLED_FF 

        	CWidgetUiWindow* window( GetWindow( aUid ) );

            if( !window )

                return;

            else if ( window->IsDialogsLaunched() )

                {

          	    iActiveFsWindow = window;

          	    // Bring app to foreground

          	    iAppUi.SendAppToForeground(); 

          	    if ( iActiveFsWindow->Engine()->Rect() != View()->ClientRect())

                    {

                    iActiveFsWindow->Engine()->SetRect( View()->ClientRect() );

                    }

                iActiveFsWindow->SetCurrentWindow( ETrue ); 

                }

            else if (window->getSapiPromptCleared())

                {

                Exit( EEikCmdExit, aUid );

                }