/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:  Declarations of OOM Monitor.

*

*/

#include <e32hashtab.h>

#include <f32file.h>

#include <w32std.h>

#include <apgtask.h>

#include <e32property.h>

/**

 * Creates thread for OOM watchers.

 * Called by the server in which the OOM Monitor runs.

 */

IMPORT_C void CreateOOMWatcherThreadL();

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

// CMemoryMonitor

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

//

class COutOfMemoryWatcher;

class CSubscribeHelper;

class COomMonitorPlugin;

class COomPlugins;

class CAppCloseTimer;

class CAppCloseWatcher;

class CMemoryMonitorServer;

class CWservEventReceiver;

class RResourceFile;

class CApaWindowGroupName;

NONSHARABLE_CLASS(CMemoryMonitor) : public CBase

    {

public:

    static CMemoryMonitor* NewL();

    ~CMemoryMonitor();

public: // event handlers

    void FreeMemThresholdCrossedL();

    void CloseAppEvent();

    void AppNotExiting(TInt aWgId);

    void StartFreeSomeRamL(TInt aTargetFree);

    void HandleFocusedWgChangeL();

private:

    CMemoryMonitor();

    void ConstructL();

    void CloseAppsFinished(TBool aMemoryGood);

    static TInt WatchdogStatusStatusChanged(TAny* aPtr);

    void HandleWatchdogStatusCallBackL();

    void ColapseWindowGroupTree();

    void SetPluginMemoryGood(TBool aSetToGood);

    void GetWgsToCloseL();

    TBool FreeMemoryAboveThreshold();

    void CancelAppCloseWatchers();

    TInt AppCloseOrder(TInt aWgIndex, TInt aWgId);

    void CloseNextApp();

    void ReadAppResourceArrayL(RResourceFile& aResFile, TInt aResId, TInt aOrderBase, TInt aOrderInc);

	void RestartAppCloser();

public:

	// All members are owned

    // generally useful sessions

    RFs iFs;

    RWsSession iWs;

private:

	// All members are owned, except where stated

    // parameters for OOM watcher.

    TInt iLowThreshold;

    TInt iGoodThreshold;

    TInt iMaxExitTime; // Time we wait for application exit gracefully, after this we'll try to shut next application down.

    TInt iRamPluginRunTime; // Time we wait for plugins to free RAM before we start to shut apps.

    // parameters for app close order

    enum TAppCloseOrderConstants

        {

        ECloseFirst = -1000000,        // apps to close first are given an order around negative one million

        ECloseNormal = 0,            // apps to close normally are given an order around zero

        ECloseLast = 1000000,        // apps to close last are given an order around one million

        ENeverClose = 1000000000    // one billion signals apps that should never be closed

        };

    typedef RHashMap<TInt, TInt> RAppCloseOrderMap;    // maps app UID to close order

    RAppCloseOrderMap iAppCloseOrderMap;

    // internal

    CApaWindowGroupName* iWgName;

    HBufC* iWgNameBuf;              // owned by iWgName

    // app closer state

    TBool iAppCloserRunning;

    TInt iCurrentTarget;

    TApaTask iCurrentTask;

    RArray<RWsSession::TWindowGroupChainInfo> iWgIds;

    TInt iNextAppToClose;

    TBool iMemoryAboveThreshold;

    // event receivers

    CAppCloseTimer* iAppCloseTimer;

    CAppCloseWatcher* iAppCloseWatcher;

    COutOfMemoryWatcher* iOOMWatcher;

    CWservEventReceiver* iWservEventReceiver;

    // parameters for P&S watcher.

    RProperty iWatchdogStatusProperty;

    CSubscribeHelper* iWatchdogStatusSubscriber;

    // Plugin support

    COomPlugins* iPlugins;

    TBool iPluginMemoryGood;

    // Server

    CMemoryMonitorServer* iServer;

    };

NONSHARABLE_CLASS(COutOfMemoryWatcher) : public CActive

    {

public:

    static COutOfMemoryWatcher* NewL(CMemoryMonitor& aLafShutdown, TInt aLowThreshold, TInt aGoodThreshold);

    ~COutOfMemoryWatcher();

    void Start();

private:

    COutOfMemoryWatcher(CMemoryMonitor& aLafShutdown);

    void ConstructL(TInt aLowThreshold, TInt aGoodThreshold);

private: // from CActive

    void DoCancel();

    void RunL();

private: // data

    RChangeNotifier iChangeNotifier;

    CMemoryMonitor& iLafShutdown;

    };

NONSHARABLE_CLASS(CSubscribeHelper) : public CActive

    {

public:

    CSubscribeHelper(TCallBack aCallBack, RProperty& aProperty);

    ~CSubscribeHelper();

public: // New functions

    void SubscribeL();

    void StopSubscribe();

private: // from CActive

    void RunL();

    void DoCancel();

private:

    TCallBack   iCallBack;

    RProperty&  iProperty;

    };

NONSHARABLE_CLASS(COomPlugins) : public CBase

    {

public:

    COomPlugins();

    ~COomPlugins();

    void ConstructL();

public:

    void FreeRam();

    void MemoryGood();

private:

    struct TPlugin

        {

        TPlugin();

        COomMonitorPlugin* iImpl;

        TUid iDtorUid;

        };

private:

    RArray<TPlugin> iPlugins;

    };

NONSHARABLE_CLASS(CAppCloseTimer) : public CTimer

    {

public:

    static CAppCloseTimer* NewL(CMemoryMonitor& aMonitor);

private:

    CAppCloseTimer(CMemoryMonitor& aMonitor);

    void RunL();

private:

    CMemoryMonitor& iMonitor;

    };

NONSHARABLE_CLASS(CAppCloseWatcher) : public CActive

    {

public:

    CAppCloseWatcher(CMemoryMonitor& aMonitor);

    ~CAppCloseWatcher();

    void Start(const TApaTask& aTask);

private:

    void DoCancel();

    void RunL();

private:

    CMemoryMonitor& iMonitor;

    RThread iThread;

    TProcessPriority iOriginalProcessPriority;

    };

NONSHARABLE_CLASS(CWservEventReceiver) : public CActive

    {

public:

    CWservEventReceiver(CMemoryMonitor& aMonitor, RWsSession& aWs);

    ~CWservEventReceiver();

    void ConstructL();

private:

    void Queue();

    void DoCancel();

    void RunL();

private:

    CMemoryMonitor& iMonitor;

    RWsSession& iWs;

    RWindowGroup iWg;

    };

NONSHARABLE_CLASS(CMemoryMonitorServer) : public CServer2

    {

public:

    static CMemoryMonitorServer* NewL(CMemoryMonitor& aMonitor);

    ~CMemoryMonitorServer();

    CMemoryMonitor& Monitor();

    void CloseAppsFinished(TBool aMemoryGood);

private:

    CMemoryMonitorServer(CMemoryMonitor& aMonitor);

    void ConstructL();

    CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;

    TInt RunError(TInt aError);

private:

    CMemoryMonitor& iMonitor;

    };

NONSHARABLE_CLASS(CMemoryMonitorSession) : public CSession2

    {

public:

    CMemoryMonitorSession();

    void CreateL();

    void CloseAppsFinished(TBool aMemoryGood);

private:

    ~CMemoryMonitorSession();

    CMemoryMonitorServer& Server();

    CMemoryMonitor& Monitor();

    void ServiceL(const RMessage2& aMessage);

private:

    RMessagePtr2 iRequestFreeRam;

    };