/*

* 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:  Main classes for Out of Memory Monitor.

*

*/

#include <hal.h>

#include <UikonInternalPSKeys.h>

#include "oommemorymonitor.h"

#include "oommonitorplugin.h"

#include "oomsubscribehelper.h"

#include "oomconfig.h"

#include "oommemorymonitorserver.h"

#include "oomconfigparser.h"

#include "oomactionlist.h"

#include "oomlog.h"

#include "OomTraces.h"

#include "oomoutofmemorywatcher.h"

#include "oomwserveventreceiver.h"

#include "oomconstants.hrh"

#include "oomrunpluginconfig.h"

#include "oomapplicationconfig.h"

#include "oomclientrequestqueue.h"

#ifndef CLIENT_REQUEST_QUEUE

const TInt KOomWatchDogStatusIdle = -1;

#endif

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

// class CMemoryMonitor

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

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

//

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

//

CMemoryMonitor* CMemoryMonitor::NewL()

    { // static

    FUNC_LOG;

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CMemoryMonitor::CMemoryMonitor()

    {

    FUNC_LOG;

    SetMemoryMonitorTls(this);

    }

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

//

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

//

CMemoryMonitor::~CMemoryMonitor()

    {

    FUNC_LOG;

#ifndef CLIENT_REQUEST_QUEUE

    if (iWatchdogStatusSubscriber)

        {

        iWatchdogStatusSubscriber->StopSubscribe();

        }

    iWatchdogStatusProperty.Close();

    delete iWatchdogStatusSubscriber;

#endif

    delete iServer;

    delete iWservEventReceiver;

    delete iOOMWatcher;

    iFs.Close();

    iWs.Close();

    delete iOomWindowGroupList;

    delete iOomActionList;

    delete iConfig;

#ifdef CLIENT_REQUEST_QUEUE

    delete iQueue;

#endif

#ifdef _DEBUG    

    delete iLogger;

#endif

    }

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

//

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

//

void CMemoryMonitor::ConstructL()

    {

    FUNC_LOG;

    User::LeaveIfError(iWs.Connect());

    iOomWindowGroupList = COomWindowGroupList::NewL(iWs);

    iConfig = COomConfig::NewL(); 

#ifdef CLIENT_REQUEST_QUEUE

    iQueue = COomClientRequestQueue::NewL(*this);

    iServer = CMemoryMonitorServer::NewL(*iQueue);

#else

    iServer = CMemoryMonitorServer::NewL(*this);    

#endif

   // Load up threshold & OOM app lists from resource.

    User::LeaveIfError(iFs.Connect());    

    COomConfigParser* oomConfigParser = new (ELeave) COomConfigParser(*iConfig, iFs);

    CleanupStack::PushL(oomConfigParser);

    oomConfigParser->ParseL();

    CleanupStack::PopAndDestroy(oomConfigParser);

    iOomActionList = COomActionList::NewL(*this, *iServer, iWs, *iConfig);

#ifdef _DEBUG    

    iLogger = COomLogger::NewL(iWs, iFs);

#endif

    // Get the thresholds based on the current foreground app and the config

    RefreshThresholds();

    _LIT_SECURITY_POLICY_S0(KOomMemoryMonitorPolicyWrite, KOomMemoryMonitorStatusPropertyCategory.iUid);

    _LIT_SECURITY_POLICY_PASS(KOomMemoryMonitorPolicyRead);

    // Define MemoryMonitorStatusProperty. set to "above treshhold".

    TInt err = RProperty::Define(KOomMemoryMonitorStatusPropertyCategory, KOomMemoryMonitorStatusPropertyKey, RProperty::EInt, KOomMemoryMonitorPolicyRead, KOomMemoryMonitorPolicyWrite);

    TRACES1("CMemoryMonitor::ConstructL: KOomMemoryMonitorStatusProperty: Define err = %d", err);

    err = RProperty::Set(KOomMemoryMonitorStatusPropertyCategory, KOomMemoryMonitorStatusPropertyKey, EAboveTreshHold);

    TRACES1("CMemoryMonitor::ConstructL:  KOomMemoryMonitorStatusProperty: Set err = %d", err);            

#ifndef CLIENT_REQUEST_QUEUE

    err = iWatchdogStatusProperty.Attach(KPSUidUikon, KUikOOMWatchdogStatus);

    TRACES1("CMemoryMonitor::ConstructL: KUikOOMWatchdogStatus err = %d", err);

    err = iWatchdogStatusProperty.Set(KOomWatchDogStatusIdle);

    iWatchdogStatusSubscriber = new (ELeave) CSubscribeHelper(TCallBack(WatchdogStatusStatusChanged, this), iWatchdogStatusProperty);

    iWatchdogStatusSubscriber->Subscribe();

#endif

    iOOMWatcher->Start();

    iWservEventReceiver = new(ELeave) CWservEventReceiver(*this, iWs);

    iWservEventReceiver->ConstructL();

    }

const COomGlobalConfig& CMemoryMonitor::GlobalConfig()

    {

    CMemoryMonitor* globalMemoryMonitor = static_cast<CMemoryMonitor*>(Dll::Tls());

    return globalMemoryMonitor->iConfig->GlobalConfig();

    }

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

//

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

//

void CMemoryMonitor::FreeMemThresholdCrossedL()

    {

    FUNC_LOG;

    iActionTrigger = ERamRotation;

    }

void CMemoryMonitor::HandleFocusedWgChangeL()

    {

    FUNC_LOG;

    // Refresh the low and good memory thresholds as they may have changed due to the new foreground application

    RefreshThresholds();

        // If the thresholds have changed then update the memory watched

        {

        }

    // If the available memory is less than the low memory threshold then free some RAM

    User::CompressAllHeaps();

        {

        iActionTrigger = ERamRotation;

        }

    }

    {

    }

    {

    FUNC_LOG;

    // Update the target if new target is higher. If the target is lower than the current target and memory 

    // is currently being freed then we do not want to reduce the amount of memory this operation frees.

    // check if there is enough free memory already.

    GetFreeMemory(freeMemory);

        {

        if (iLastMemoryMonitorStatusProperty != EFreeingMemory)

            {

        ResetTargets();

        iOomActionList->SwitchOffPlugins();

        SetMemoryMonitorStatusProperty(EAboveTreshHold);

#ifdef CLIENT_REQUEST_QUEUE        

        iQueue->ActionsCompleted(freeMemory, ETrue);

#else        

        iServer->CloseAppsFinished(freeMemory, ETrue);

#endif        

            }

        return;

        }

#ifdef _DEBUG    

    iLogger->StartL();

#endif

    // Build the list of memory freeing actions

    iOomActionList->BuildActionListL(*iOomWindowGroupList, *iConfig);

    // Run the memory freeing actions

    iOomActionList->FreeMemory(aMaxPriority);

    }

void CMemoryMonitor::RequestFreeMemoryPandSL(TInt aBytesRequested)

    {

    FUNC_LOG;

    iActionTrigger = EPublishAndSubscribe;

    }

    {

    FUNC_LOG;

    iActionTrigger = EClientServerRequestFreeMemory;

    }

    {

    FUNC_LOG;

    iActionTrigger = EClientServerRequestOptionalRam;

    // Calculate the priority of the allocation (the priority of the plugin that will clear it up - 1)

    TInt priorityOfAllocation = iConfig->GetPluginConfig(aPluginId).CalculatePluginPriority(*iOomWindowGroupList) - 1;

    }

void CMemoryMonitor::GetFreeMemory(TInt& aCurrentFreeMemory)

    {

    FUNC_LOG;

    // may cause some extra load but allows more precise action

    User::CompressAllHeaps();

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

    TRACES1("CMemoryMonitor::GetFreeMemory: Free RAM now %d", aCurrentFreeMemory);

    }

#ifndef CLIENT_REQUEST_QUEUE 

TInt CMemoryMonitor::WatchdogStatusStatusChanged(TAny* aPtr)

    {

    FUNC_LOG;

    CMemoryMonitor* self = STATIC_CAST(CMemoryMonitor*,aPtr);

    if (self)

        self->HandleWatchdogStatusCallBack();

    return KErrNone;

    }

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

//

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

//

void CMemoryMonitor::HandleWatchdogStatusCallBack()

    {

    FUNC_LOG;

    // Someone has set the key to request some free memory.

    TInt memoryRequested = 0;

    iWatchdogStatusProperty.Get(memoryRequested);

    // Try to free the RAM.

    if (memoryRequested >= 1)

        {

        iOOMWatcher->Cancel();              // Pause memory notifys.

        TRAP_IGNORE(RequestFreeMemoryPandSL(memoryRequested + iLowThreshold)); // This call could take a few seconds to do its stuff.

        iOOMWatcher->Start();               // Restarts memory monitoring.

        }

    // Set the key back to KOomWatchDogStatusIdle to indicate we're done.

    iWatchdogStatusProperty.Set(KOomWatchDogStatusIdle);

    }

#endif //CLIENT_REQUEST_QUEUE

void CMemoryMonitor::AppNotExiting(TInt aWgId)

    {

    FUNC_LOG;

    iOomActionList->AppNotExiting(aWgId);

    }

void CMemoryMonitor::RefreshThresholds()

    {

    FUNC_LOG;

    iOomWindowGroupList->Refresh();

    // Calculate the desired good threshold, this could be the globally configured value...

#ifdef _DEBUG

    TRACES("CMemoryMonitor::RefreshThresholds: Dumping Window Group List");

    TInt wgIndex = iOomWindowGroupList->Count() - 1;

    while (wgIndex >= 0)        

        {

        TInt32 appId = iOomWindowGroupList->AppId(wgIndex, ETrue);    

        TInt wgId = iOomWindowGroupList->WgId(wgIndex).iId;

        TInt parentId = iOomWindowGroupList->WgId(wgIndex).iId;        

        TRACES4("CMemoryMonitor::RefreshThresholds: wgIndex=%d, oom uid=%x, wgId(child)=%d, parentId=%d", wgIndex, appId, wgId, parentId);    

        wgIndex--;

        }

#endif

    // The global value can be overridden by an app specific value

    // Find the application config entry for the foreground application

    if (iOomWindowGroupList->Count())

        {

        TUint foregroundAppId = iOomWindowGroupList->AppId(0, ETrue);

        TUid foregroundAppUid = TUid::Uid(foregroundAppId);

        if ( (foregroundAppUid == KUidPenInputServer || foregroundAppUid == KUidFastSwap) &&

             iOomWindowGroupList->Count() > 1 )

            {

            // pen input server puts itself to the foreground when the web browser is active

            // fast swap should not reset the thresholds for the app behind it

            foregroundAppId = iOomWindowGroupList->AppId(1, ETrue);

            }

        // If this application configuration overrides the good_ram_threshold then set it

        if (iConfig->GetApplicationConfig(foregroundAppId).iGoodRamThreshold != KOomThresholdUnset)

            {

            }

        // If this application configuration overrides the low_ram_threshold then set it

        if (iConfig->GetApplicationConfig(foregroundAppId).iLowRamThreshold != KOomThresholdUnset)

            {

            }

        }

    }

// SetMemoryMonitorStatusProperty - updates the property value only if it has changed

void CMemoryMonitor::SetMemoryMonitorStatusProperty(const TMemoryMonitorStatusPropertyValues aValue)

    {

    if (iLastMemoryMonitorStatusProperty != aValue)

        {

        TInt err = RProperty::Set(KOomMemoryMonitorStatusPropertyCategory, KOomMemoryMonitorStatusPropertyKey, aValue);

        TRACES1("CMemoryMonitor::SetMemoryMonitorStatusProperty: err = %d", err);

        iLastMemoryMonitorStatusProperty = aValue;

        }

    }

void CMemoryMonitor::ResetTargets()

    {

    FUNC_LOG;

    //we reset the target when a memory free operation completes, to deal with the case 

    //where the operation was initiated with a target larger than the current good threshold

    }

void CMemoryMonitor::SetPriorityBusy(TInt aWgId)

    {

    FUNC_LOG;

    iOomWindowGroupList->SetPriorityBusy(aWgId);

    }

void CMemoryMonitor::SetPriorityNormal(TInt aWgId)

    {

    FUNC_LOG;

    iOomWindowGroupList->SetPriorityNormal(aWgId);

    }

void CMemoryMonitor::SetPriorityHigh(TInt aWgId)

    {

    iOomWindowGroupList->SetPriorityHigh(aWgId);

    }

TActionTriggerType CMemoryMonitor::ActionTrigger() const

    {

    return iActionTrigger;

    }

#ifdef CLIENT_REQUEST_QUEUE 

    {

    }

    {

    }