/*

* Copyright (c) 2008 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:  Classes for executing OOM actions (e.g. closing applications and running plugins).

*

*/

#include <hal.h>

#include <apgwgnam.h>

#include "goommonitorplugin.h"

#include "goommonitorplugin.hrh"

#include "goomactionlist.h"

#include "goomwindowgrouplist.h"

#include "goompanic.h"

#include "goomtraces.h"

#include "goomconstants.hrh"

#include "goommemorymonitor.h"

#include "goommemorymonitorserver.h"

#include "goomrunplugin.h"

#include "goomcloseapp.h"

#include "goomconfig.h"

#include "goomactionref.h"

#include "goomapplicationconfig.h"

#include "goomcloseappconfig.h"

#include "goomrunpluginconfig.h"

template <class T>

CGOomPluginList<T>::CGOomPluginList()

    {

    FUNC_LOG;

    }

template <class T>

CGOomPluginList<T>::~CGOomPluginList()

    {

    FUNC_LOG;

    TInt count = iPlugins.Count();

    for (TInt ii=0; ii<count; ii++)

        {

        TPlugin& plugin = iPlugins[ii];

        if (plugin.iImpl)    // only if successfully added

            REComSession::DestroyedImplementation(plugin.iDtorUid);

        }

    iPlugins.Close();

    }

template <class T>

void CGOomPluginList<T>::ConstructL(TInt aInterfaceUid)

    {

    FUNC_LOG;

    RImplInfoPtrArray implArray;

    CleanupClosePushL(implArray);

    REComSession::ListImplementationsL(TUid::Uid(aInterfaceUid), implArray);

    TInt count = implArray.Count();

    iPlugins.ReserveL(count);

    for (TInt ii=0; ii<count; ii++)

        {

        iPlugins.AppendL(TPlugin());

        TPlugin& plugin = iPlugins[ii];

        TUid uid(implArray[ii]->ImplementationUid());

        plugin.iImpl = static_cast<T*>(REComSession::CreateImplementationL(uid, plugin.iDtorUid, NULL));

        plugin.iUid = uid.iUid;

        }

    CleanupStack::PopAndDestroy(&implArray);

    }

template <class T>

CGOomPluginList<T>::TPlugin::TPlugin()

: iImpl(0)

    {

    FUNC_LOG;

   }

template <class T>

CGOomPluginList<T>* CGOomPluginList<T>::NewL(TInt aInterfaceUid)

    {

    FUNC_LOG;

    CGOomPluginList* self = new (ELeave) CGOomPluginList();

    CleanupStack::PushL(self);

    self->ConstructL(aInterfaceUid);

    CleanupStack::Pop(self);

    return self;

    }

CGOomActionList* CGOomActionList::NewL(CMemoryMonitor& aMonitor, CMemoryMonitorServer& aServer, RWsSession& aWs, CGOomConfig& aConfig)

    {

    FUNC_LOG;

    CGOomActionList* self = new (ELeave) CGOomActionList(aMonitor, aServer, aWs);

    CleanupStack::PushL(self);

    self->ConstructL(aConfig);

    CleanupStack::Pop();

    return self;

    }

CGOomActionList::~CGOomActionList()

    {

    FUNC_LOG;

    iCloseAppActions.ResetAndDestroy();

    iCloseAppActions.Close();

    iRunPluginActions.ResetAndDestroy();

    iRunPluginActions.Close();

    iActionRefs.Close();

    delete iPluginList;

    }

// Creates a list of actions based on the contents of the config and the current window group list

// Any old actions will be replaced.

// This function may leave, however enough memory should be reserved for this process so that at least

// some actions have been created for freeing memory, these can then be run by calling FreeMemory.

// Note that this function will only leave in extreme circumstances, in normal usage we should have

// enough reserved memory to build the complete action list.

void CGOomActionList::BuildPluginActionListL(CGOomWindowGroupList& aWindowGroupList, CGOomConfig& aConfig)

    {

    FUNC_LOG;

    if (iFreeingMemory)

        {

        TRACES("OOMWATCHER:CGOomActionList::BuildActionListL Memory is currently being freed, do not build action list");

        TRACES2("OOMWATCHER:CGOomActionList::BuildActionListL iCurrentActionIndex = %d out of %d actions in progress", iCurrentActionIndex, iActionRefs.Count());

        return;

        }

    iActionRefs.Reset();

    iCurrentActionIndex = 0;

    TInt actionsIndex = 0;

    iAppsProtectedByPlugins.Reset();

    iRunningKillAppActions = EFalse;

    //

    // There is only one kind of plugin, the graphics plugin which is based on the oom plugin

	// references to v2 plugin types removed as these are not yet used by GOOM

    // we rely on the pluginlist not having changed since construction

    // Go through each plugin in the plugin list, create a run-plugin action for each one

    TInt pluginIndex = iPluginList->Count();

    while (pluginIndex--)

        {

        // Get the config for this plugin

        CGOomRunPluginConfig& pluginConfig = aConfig.GetPluginConfig(iPluginList->Uid(pluginIndex));

        TInt priority = pluginConfig.CalculatePluginPriority(aWindowGroupList);

        TGOomSyncMode syncMode = pluginConfig.iSyncMode;

        TInt ramEstimate = pluginConfig.iRamEstimate;

        TActionRef::TActionType actionType;

        if (pluginConfig.PluginType() == EGOomAppPlugin)

            {

            actionType = TActionRef::EAppPlugin;

            }

        else

            actionType = TActionRef::ESystemPlugin;

        TActionRef ref = TActionRef(actionType, priority, syncMode, ramEstimate, *(iRunPluginActions[actionsIndex]), aWindowGroupList.GetIndexFromAppId(pluginConfig.TargetApp()));

        iAppsProtectedByPlugins.Append(pluginConfig.TargetApp());

        //It is valid to have plugins with equal priority

        User::LeaveIfError(iActionRefs.InsertInOrderAllowRepeats(ref, ComparePriorities));

        actionsIndex++;

        }

    TRACES1("BuildActionListL: Action list built with %d Plugin items",iActionRefs.Count());

    }

void CGOomActionList::BuildKillAppActionListL(CGOomWindowGroupList& aWindowGroupList, CGOomConfig& aConfig)

    {

    FUNC_LOG;

    aWindowGroupList.RefreshL();

    iRunningKillAppActions = ETrue;

    if (aWindowGroupList.Count())

            {

            // Go through each item in the wglist, create an app close action for this application

            TInt wgIndex = aWindowGroupList.Count() - 1;

            TRACES1("BuildActionListL: Windowgroup list count %d ",aWindowGroupList.Count());

            // Fix for when fast swap has focus, or pen input server has put itself into the foreground:

            // the wg at index 1 should be considered as the foreground app.

            // stopIndex is calculated to take this into account.

            TUid foregroundUid = TUid::Uid(iMonitor.ForegroundAppUid());

            TRACES1("BuildActionListL: Foreground App %x ", foregroundUid);

            while (wgIndex >= 0)

                {

                CGOomCloseAppConfig* appCloseConfig = NULL;

                // Get the app ID for the wglist item

                // This sets the window group name

                TInt32 appId = aWindowGroupList.AppId(wgIndex, ETrue);

                    {

                    //If the UID is NULL at this point, we assume the process is not an application

                    //and therefore is not a suitable candidate for closure.

                    //We also do not close system or hidden apps.

                    TRACES3("BuildActionListL: Not adding process to action list; UID = %x, wgIndex = %d, wgid = %d", appId, wgIndex, aWindowGroupList.WgId(wgIndex).iId);

                    }

                else if (aWindowGroupList.IsBusy(wgIndex) || wgName->IsBusy())

                    // If the application has been flagged as busy then look up the configuration for busy apps in the config file

                    {

                    // Find the app close config for this app ID

                    appCloseConfig = aConfig.GetApplicationConfig(KGOomBusyAppId).GetAppCloseConfig();

                    }

                else if (aWindowGroupList.IsDynamicHighPriority(wgIndex))

                    // If the application has been flagged as busy then look up the configuration for busy apps in the config file

                    {

                    // Find the app close config for this app ID

                    appCloseConfig = aConfig.GetApplicationConfig(KGOomHighPriorityAppId).GetAppCloseConfig();

                    }

                else

                    // If the application hasn't been flagged as busy or high priority then look up the priority according to the config

                    {

                    // Find the app close config for this app ID

                    appCloseConfig = aConfig.GetApplicationConfig(appId).GetAppCloseConfig();

                    }

                // Create the app close action and add it to the action list

                if (appCloseConfig)

                    {

                    TUint priority = appCloseConfig->CalculateCloseAppPriority(aWindowGroupList, wgIndex);

                    TInt wgId = aWindowGroupList.WgId(wgIndex).iId;

                    TGOomSyncMode syncMode = appCloseConfig->iSyncMode;

                    TInt ramEstimate = appCloseConfig->iRamEstimate;

                    //AppClose Actions should always have a unique prioirity determined by the application's z order.

                    TInt err = iActionRefs.InsertInOrder(ref, ComparePriorities);

                    if ((err != KErrNone) && (err != KErrAlreadyExists))

                        {

                        User::Leave(err);

                        }

                    TRACES3("BuildActionListL: Adding app to action list, Uid = %x, wgId = %d, wgIndex = %d", appId, wgId, wgIndex);

                    }

                wgIndex--;

                }

            }

        TRACES1("BuildActionListL: Action list built with %d items",iActionRefs.Count());

    }    

// Execute the OOM actions according to their priority

// Run batches of OOM actions according to their sync mode

void CGOomActionList::FreeMemory(TInt aMaxPriority)

    {

    FUNC_LOG;

    if (iFreeingMemory)

            {

            TRACES("OOMWATCHER:CGOomActionList::FreeMemory Memory is currently being freed, do not start any more actions");

            return;

            }

    iMaxPriority = aMaxPriority;

    TBool memoryFreeingActionRun = EFalse;

    // Get the configured maximum number of applications that can be closed at one time

    const CGOomGlobalConfig& globalConfig = CMemoryMonitor::GlobalConfig();

    TInt maxBatchSize = globalConfig.iMaxCloseAppBatch;

    TInt numberOfRunningActions = 0;

    TInt memoryEstimate = iMonitor.GetFreeMemory(); // The amount of free memory we expect to be free after the currently initiated operations

    while (iCurrentActionIndex < iActionRefs.Count())

        {

        if(iActionRefs[iCurrentActionIndex].Priority() > aMaxPriority)

            {

            TRACES1("Busy App wgid %d, spared by GOOM", iActionRefs[iCurrentActionIndex].WgId());

            iCurrentActionIndex++;

            continue;

            }

        TActionRef ref = iActionRefs[iCurrentActionIndex];

        CGOomAction* action = NULL;

        if (ref.Type() == TActionRef::EAppClose)

            {

            action = iCloseAppActions[numberOfRunningActions];

            static_cast<CGOomCloseApp*>(action)->Reconfigure(ref);

            //Double checking again if this app is now in foreground, if yes then we dont kill

            CApaWindowGroupName* wgName = CApaWindowGroupName::NewLC(iWs, iWs.GetFocusWindowGroup());

            TInt32 fgApp = wgName->AppUid().iUid;

            TInt32 appId = iMonitor.GetWindowGroupList()->AppIdfromWgId(ref.WgId(), ETrue);

            if(appId == fgApp)

                {

                TRACES1("Foreground App wgid %x, spared by GOOM", appId);

                iCurrentActionIndex++;

                continue;

                }

            }

        else

            {

            action = &(ref.RunPlugin());

            }

        iFreeingMemory = ETrue;

        TRACES2("CGOomActionList::FreeMemory: Running action %d which has priority %d", iCurrentActionIndex,ref.Priority());

        action->FreeMemory(iCurrentTarget - memoryEstimate);

        memoryFreeingActionRun = ETrue;

        // Actions with EContinueIgnoreMaxBatchSize don't add to the tally of running actions

        if (ref.SyncMode() != EContinueIgnoreMaxBatchSize)

            numberOfRunningActions++;

        // Update our estimate of how much RAM we think we'll have after this operation

        memoryEstimate += ref.RamEstimate();

        // Do we estimate that we are freeing enough memory (only applies if the sync mode is "esimtate" for this action)

        TBool estimatedEnoughMemoryFreed = EFalse;

        if ((ref.SyncMode() == EEstimate)

            && (memoryEstimate >= iCurrentTarget))

            {

            estimatedEnoughMemoryFreed = ETrue;

            }

        if ((ref.SyncMode() == ECheckRam)

                || (numberOfRunningActions >= maxBatchSize)

                || estimatedEnoughMemoryFreed

                || globalConfig.ForceCheckAtPriority(iActionRefs[iCurrentActionIndex].Priority()))

            // If this actions requires a RAM check then wait for it to complete

            // Also force a check if we've reached the maximum number of concurrent operations

            // Also check if we estimate that we have already freed enough memory (assuming that the sync mode is "estimate"

            {

            // Return from the loop - we will be called back (in CGOomActionList::StateChanged()) when the running actions complete

            TRACES("CGOomActionList::FreeMemory: Exiting run action loop");

            return;

            }

        // ... otherwise continue running actions, don't wait for any existing ones to complete

        iCurrentActionIndex++;

        }

    if (!memoryFreeingActionRun)

        {

        // No usable memory freeing action has been found, so we give up

        TRACES("CGOomActionList::FreeMemory: No usable memory freeing action has been found");

        iMonitor.ResetTargets();

        TInt freeMemory;

        iServer.CloseAppsFinished(freeMemory, EFalse);

        }

    }

// Should be called when the memory situation is good

// It results in notifications of the good memory state to all plugins with an outstanding FreeMemory request

void CGOomActionList::MemoryGood()

    {

    FUNC_LOG;

    TInt actionRefIndex = iActionRefs.Count();

    // Go through each of the action references, if it's a plugin action then call MemoryGood on it

    // Note that this only results in a call to the plugin if FreeMemory has been called on this plugin since that last call to MemoryGood

    while (actionRefIndex--)

        {

        if ((iActionRefs[actionRefIndex].Type() == TActionRef::EAppPlugin)

                || (iActionRefs[actionRefIndex].Type() == TActionRef::ESystemPlugin))

            {

            iActionRefs[actionRefIndex].RunPlugin().MemoryGood();

            }

        }

    }

TBool CGOomActionList::FreeMemoryAboveTarget(TInt& aFreeMemory)

    {

    FUNC_LOG;

    aFreeMemory = iMonitor.GetFreeMemory();

    TRACES1("CGOomActionList::FreeMemoryAboveTarget: Free RAM now %d",aFreeMemory);

    return (aFreeMemory >= iCurrentTarget);

    }

TInt CGOomActionList::ComparePriorities(const TActionRef& aPos1, const TActionRef& aPos2 )

    {

    FUNC_LOG;

    if (aPos1.Priority()< aPos2.Priority())

        {

        return -1;

        }

    if (aPos1.Priority() > aPos2.Priority())

        {

        return 1;

        }

    // If priorities are equal then we use hardcoded rules to determine which one is run...

    // All other actions are run in preference to application closures

	if ((aPos1.Type() != TActionRef::EAppClose)

			&& ((aPos2.Type() == TActionRef::EAppClose)))

		{

		return -1;

		}

	if ((aPos1.Type() == TActionRef::EAppClose)

			&& ((aPos2.Type() != TActionRef::EAppClose)))

		{

		return 1;

		}

	// If both actions are application closures then the Z order is used to determine which one to run (furthest back application will be closed first)

	if ((aPos1.Type() == TActionRef::EAppClose)

			&& ((aPos2.Type() == TActionRef::EAppClose)))

		{

		if (aPos1.WgIndex() < aPos2.WgIndex())

			{

			return 1;

			}

		else

			{

			return -1;

			}

		//Two Apps should not have equal window group indexes, we panic below if this is the case.

		}

	// Application plugins will be run in preference to system plugins

	if ((aPos1.Type() == TActionRef::EAppPlugin)

			&& ((aPos2.Type() == TActionRef::ESystemPlugin)))

		{

		return -1;

		}

	if ((aPos1.Type() == TActionRef::ESystemPlugin)

			&& ((aPos2.Type() == TActionRef::EAppPlugin)))

		{

		return 1;

		}

	// If both actions are application plugins then the Z order of the target app is used to determine which one to run (the one with the furthest back target app will be closed first)

	// If the target app is not running then the plugin is run in preference to target apps where the target app is running

	if ((aPos1.Type() == TActionRef::EAppPlugin)

			&& ((aPos2.Type() == TActionRef::EAppPlugin)))

		{

		// When the target app is not running then the plugin will be run ahead of plugins where the target app is running

		if ((aPos1.WgIndex() == KAppNotInWindowGroupList) && (aPos2.WgIndex() != KAppNotInWindowGroupList))

			{

			return -1;

			}

		if ((aPos1.WgIndex() != KAppNotInWindowGroupList) && (aPos2.WgIndex() == KAppNotInWindowGroupList))

			{

			return 1;

			}

		// If the target apps for both plugins are running then compare the Z order

		if ((aPos1.WgIndex() != KAppNotInWindowGroupList) && (aPos2.WgIndex() != KAppNotInWindowGroupList))

			{

			if (aPos1.WgIndex() < aPos2.WgIndex())

				{

				return 1;

				}

			else

				{