/*

* Copyright (c) 2006-2010 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 <u32hal.h>

#include <apgwgnam.h>

#include "oommonitorplugin.h"

#include "oommonitorplugin.hrh"

#include "oomactionlist.h"

#include "oomwindowgrouplist.h"

#include "oompanic.h"

#include "OomTraces.h"

#include "oomconstants.hrh"

#include "oommemorymonitor.h"

#include "oommemorymonitorserver.h"

#include "oomrunplugin.h"

#include "oomcloseapp.h"

#include "oomconfig.h"

#include "oomactionref.h"

#include "oomapplicationconfig.h"

#include "oomcloseappconfig.h"

#include "oomrunpluginconfig.h"

const TUid  KUidMatrixMenuApp = { 0x101F4CD2 };

template <class T>

COomPluginList<T>::COomPluginList()

    {

    FUNC_LOG;

    }

template <class T>

COomPluginList<T>::~COomPluginList()

    {

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

COomPluginList<T>::TPlugin::TPlugin()

: iImpl(0)

    {

    FUNC_LOG;

   }

template <class T>

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

    {

    FUNC_LOG;

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

    CleanupStack::PushL(self);

    self->ConstructL(aInterfaceUid);

    CleanupStack::Pop(self);

    return self;

    }

COomActionList* COomActionList::NewL(CMemoryMonitor& aMonitor, CMemoryMonitorServer& aServer, RWsSession& aWs, COomConfig& aConfig)

    {

    FUNC_LOG;

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

    CleanupStack::PushL(self);

    self->ConstructL(aConfig);

    CleanupStack::Pop(self);

    return self;

    }

COomActionList::~COomActionList()

    {

    FUNC_LOG;

    iCloseAppActions.ResetAndDestroy(); 

    iCloseAppActions.Close();

    iRunPluginActions.ResetAndDestroy(); 

    iRunPluginActions.Close();

    iActionRefs.Close();

    delete iPluginList;

    delete iPluginListV2;

    }

// 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 COomActionList::BuildActionListL(COomWindowGroupList& aWindowGroupList, COomConfig& aConfig)

    {

    FUNC_LOG;

    if (iFreeingMemory)

        {

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

        return;

        }

    iActionRefs.Reset();

    iCurrentActionIndex = 0;

    aWindowGroupList.RefreshL();

    TInt actionsIndex = 0;

    // we rely on the two pluginlists not having changed since construction

    BuildPluginActionsL(*iPluginList, aWindowGroupList, aConfig, actionsIndex);

    BuildPluginActionsL(*iPluginListV2, aWindowGroupList, aConfig, actionsIndex);

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

    TUint wgIndex = aWindowGroupList.Count() - 1;

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

    TUint stopIndex = 0;

    TUid foregroundUid = TUid::Uid(aWindowGroupList.AppId(0));

    if ( KUidFastSwap == foregroundUid || KUidPenInputServer == foregroundUid)

        {

        stopIndex = 1;

        }

    while (wgIndex > stopIndex) // Don't go down to entry stopIndex because this is the foreground window

        {

        COomCloseAppConfig* appCloseConfig = NULL;

        CApaWindowGroupName* wgName = aWindowGroupList.WgName();

        __ASSERT_DEBUG(wgName, OomMonitorPanic(KInvalidWgName));    

        // Get the app ID for the wglist item

        // This sets the window group name

        TInt32 appId = aWindowGroupList.AppId(wgIndex);    

        if ( !appId || wgName->IsSystem() || wgName->Hidden() )

            {

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

            //Matrix Menu is temporarily hardcoded here as a system app that can be closed

            TUid appUid = TUid::Uid(aWindowGroupList.AppId(wgIndex, ETrue));

            if ( KUidMatrixMenuApp == appUid)

                {   

                TRACES2("BuildActionListL: System App is Matrix Menu; UID = %x, wgIndex = %d", aWindowGroupList.AppId(wgIndex, ETrue),wgIndex);

                // Find the app close config for Menu App

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

                }

            else

                {

                TRACES2("BuildActionListL: Not adding process to action list; UID = %x, wgIndex = %d", aWindowGroupList.AppId(wgIndex, ETrue),wgIndex);                

                TRACES2("BuildActionListL: IsSystem = %d, Hidden = %d", wgName->IsSystem() ? 1 : 0, wgName->Hidden() ? 1 : 0);                

                wgIndex--;

                continue;

                }

            }

        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(KOomBusyAppId).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(KOomHighPriorityAppId).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();        

            }

        //If the app close config is NULL it is because there is an app specific threshold for this 

        //app but no specific close config. Use the default app close config

        if (!appCloseConfig)

            {

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

            }

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

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

        TOomSyncMode syncMode = appCloseConfig->iSyncMode;

        TInt ramEstimate = appCloseConfig->iRamEstimate;

        TActionRef ref = TActionRef(TActionRef::EAppClose, priority, syncMode, ramEstimate, wgId, wgIndex);

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

    }

template <class T>

void COomActionList::BuildPluginActionsL(COomPluginList<T>& aPluginList, COomWindowGroupList& aWindowGroupList, COomConfig& aConfig, TInt& aActionsIndex)

    {

    TInt pluginIndex = aPluginList.Count();

    while (pluginIndex--)

        {

        // Get the config for this plugin

        COomRunPluginConfig& pluginConfig = aConfig.GetPluginConfig(aPluginList.Uid(pluginIndex));

        TActionRef::TActionType actionType;

        if (pluginConfig.PluginType() == EOomAppPlugin)

            {

            if (pluginConfig.CallIfTargetAppNotRunning() == EFalse)

                {

                //loop through wg group and if find can't find the target app, don't add this plugin

                TInt index = aWindowGroupList.Count() - 1;

                TUint targetApp = pluginConfig.TargetApp();

                TBool targetAppFound = EFalse;

                while (index >= 0)

                    {

                    if (aWindowGroupList.AppId(index) == targetApp)

                        {

                        targetAppFound = ETrue;

                        break;

                        }

                    index--;

                    }

                if (targetAppFound == EFalse)

                    {

                    aActionsIndex++;

                    continue;

                    }

                }

            actionType = TActionRef::EAppPlugin;

            }

        else

            {

            actionType = TActionRef::ESystemPlugin;

            }

        TInt priority = pluginConfig.CalculatePluginPriority(aWindowGroupList);

        TOomSyncMode syncMode = pluginConfig.iSyncMode;

        TInt ramEstimate = pluginConfig.iRamEstimate;

        __ASSERT_DEBUG(aActionsIndex < iRunPluginActions.Count(), OomMonitorPanic(KPluginArrayIndexOutOfBounds));    

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

        //It is valid to have plugins with equal priority

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

        aActionsIndex++;

        }

    }

// Execute the OOM actions according to their priority

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

void COomActionList::FreeMemory(TInt aMaxPriority)

    {

    FUNC_LOG;

    if (iFreeingMemory)

        {

        TRACES("COomActionList::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 COomGlobalConfig& globalConfig = CMemoryMonitor::GlobalConfig();

    TInt maxBatchSize = globalConfig.iMaxCloseAppBatch;

    TInt numberOfRunningActions = 0;

    TInt freeRamEstimate = 0; // The amount of free memory we expect to be free after the currently initiated operations

    HAL::Get(HALData::EMemoryRAMFree, freeRamEstimate);

    TUint64 freeSwapEstimate = 0;

    if (iSwapUsageMonitored)

        {

        SVMSwapInfo swapInfo;

        UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo, 0);

        freeSwapEstimate = swapInfo.iSwapFree;

        }

    while (iCurrentActionIndex < iActionRefs.Count() 

            && iActionRefs[iCurrentActionIndex].Priority() <= aMaxPriority)

        {

        TActionRef ref = iActionRefs[iCurrentActionIndex];

        COomAction* action = NULL;

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

            {

            action = iCloseAppActions[numberOfRunningActions];

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

            }

        else 

            {

            action = &(ref.RunPlugin());

            }

        iFreeingMemory = ETrue;

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

        iMonitor.SetMemoryMonitorStatusProperty(EFreeingMemory);

        // At the moment the actions don't make any difference between freeing

        // RAM and freeing swap. So we try to free the biggest of the two.

        // Until the plugins are updated to make a distinction between swap and RAM this is the best

        // we can do. For application close actions the amount to try to free is ignored anyway.

        TUint amountToTryToFree = 0;

		if (iCurrentRamTarget > freeRamEstimate)

			{

			amountToTryToFree = iCurrentRamTarget - freeRamEstimate;

			}

        if (iSwapUsageMonitored && (iCurrentSwapTarget > freeSwapEstimate) && ((iCurrentSwapTarget - freeSwapEstimate) > amountToTryToFree))

            {

            amountToTryToFree = iCurrentSwapTarget - freeSwapEstimate;

            }

        action->FreeMemory(amountToTryToFree, iMonitor.iDataPaged);

        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

        freeRamEstimate += 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)

            && (freeRamEstimate >= iCurrentRamTarget))

            {

            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 COomActionList::StateChanged()) when the running actions complete

            TRACES("COomActionList::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("COomActionList::FreeMemory: No usable memory freeing action has been found");

        iMonitor.ResetTargets();

        TInt freeMemory = 0;

        iMonitor.GetFreeMemory(freeMemory);

        TInt freeSwap = 0;

        if (iSwapUsageMonitored)

            {

            iMonitor.GetFreeSwapSpace(freeSwap);

            }

        if ((freeMemory >= iCurrentRamTarget) &&

            ((!iSwapUsageMonitored) || (freeSwap >= iCurrentSwapTarget)))

            {

            SwitchOffPlugins();

            iMonitor.SetMemoryMonitorStatusProperty(EAboveTreshHold);

            }

        else

            {

            if (iMonitor.ActionTrigger() == EClientServerRequestOptionalRam)

                {

                //We always switch off the plugins after an optional RAM request

                SwitchOffPlugins();

                }

            iMonitor.SetMemoryMonitorStatusProperty(EBelowTreshHold);

            }

#ifdef CLIENT_REQUEST_QUEUE        

        iMonitor.ActionsCompleted(freeMemory, EFalse);

#else

        iServer.CloseAppsFinished(freeMemory, EFalse);

#endif

        }

    }

void COomActionList::SwitchOffPlugins()

    {

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

            }

        }

    }

TInt COomActionList::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;

			}