/*

* 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:  The parser for the Graphics OOM configuration file

*

*/

#include <e32base.h>

#include <xml/parser.h>

#include "goomconfigparser.h"

#include "goompanic.h"

#include "goomtraces.h"

#include "goomidletimerule.h"

#include "goomforegroundrule.h"

#include "goomconstants.hrh"

#include "goomapplicationconfig.h"

#include "goomcloseappconfig.h"

#include "goomconfig.h"

#include "goomrunpluginconfig.h"

enum

{

KGOomErrMoreThanOneGOomConfig = 0,

KGOomErrGlobalSettingsMustComeAfterRoot,

KGOomErrAppSettingsMustComeAfterGlobalSettings,

KGOomErrCloseAppSettingsMustComeAfterAppSettings,

KGOomErrAppIdleSettingsMustComeAfterAppCloseSettings,

KGOomErrLowRamErrorInGlobalSettings,

KGOomErrGoodRamErrorInGlobalSettings,

KGOomErrMaxCloseErrorInGlobalSettings,

KGOomErrDefaultPriorityErrorInGlobalSettings,

KGOomErrMissingUidFromAppCloseConfig,

KGOomErrMissingPriorityFromAppCloseConfig,

KGOomErrMissingSyncModeFromAppCloseConfig,

KGOomErrMissingEstimateFromAppCloseConfig,

KGOomErrInvalidSyncMode,

KGOomErrMissingSyncModeInAppCloseConfig,

KGOomErrBadOrMissingPriorityInAppIdleRule,

KGOomErrBadOrMissingIdleTimeInAppIdleRule,

KGOomErrBadOrMissingUidInAppIdleRule,

KGOomErrBadNeverCloseValue,

KGOomErrBadOrMissingUidInAppConfig,

KGOomErrBadOrMissingPriorityInAppCloseConfig,

KGOomErrBadLowThresholdValueForAppConfig,

KGOomErrBadGoodThresholdValueForAppConfig,

KGOomErrBadTargetFreeValueForAppConfig,

KGOomErrSystemPluginSettingsMustComeAfterAppCloseSettings,

KGOomErrAppPluginSettingsMustComeAfterSystemPluginSettings,

KGOomErrAppPluginIdleTimeRulesMustComeAfterAppPluginSettings,

KGOomErrBadOrMissingUidInAppCloseConfig,

KGOomErrBadOrMissingUidInSystemPluginConfig,

KGOomErrBadOrMissingPriorityInSystemPluginConfig,

KGOomErrBadOrMissingTargetAppIdInAppPluginConfig,

KGOomErrBadOrMissingUidInAppPluginConfig,

KGOomErrBadOrMissingPriorityInAppPluginConfig,

KGOomErrBadOrMissingPriorityInPluginIdleRule,

KGOomErrBadOrMissingIdleTimeInPluginIdleRule,

KGOomErrBadOrMissingUidInPluginIdleRule,

KGOomErrBadOrMissingUidInForegroundAppRule,

KGOomErrBadOrMissingPriorityInForegroundAppRule,

KGOomErrBadOrMissingTargetAppIdInForegroundAppRule,

KGOomErrDefaultWaitAfterPluginInGlobalSettings,

KGOomErrBadOrMissingPriorityInForceCheck,

KGOomErrGOomRulesMustComeLast,

KGOomErrBadPluginWaitTime,

KGOomErrBadXml,

KGOomErrAppCloseIdleRuleOutsideAppCloseElement,

KGOomErrForegroundAppRuleOutsideAppCloseElement,

KGOomErrPluginIdleRuleOutsideAppPluginElement,

KGOomErrPluginForegroundRuleOutsidePluginElement

};

const TInt KGOomXmlFileBufferSize = 1024;

using namespace Xml;

// Mime type of the parsed document

_LIT8(KXmlMimeType, "text/xml");

_LIT(KGOomConfigFilePath, ":\\private\\10207218\\goomconfig.xml");

_LIT(KRomDrive, "z");

// Element strings

// Root

_LIT8(KGOomConfigGOomConfig, "goom_config");

// Global settings

_LIT8(KGOomConfigGlobalSettings, "global_settings");

_LIT8(KGOomConfigForceCheckAtPriority, "force_check");

// App settings

_LIT8(KGOomConfigAppSettings, "app_specific_thresholds");

_LIT8(KGOomConfigApp, "app");

// App close settings

_LIT8(KGOomConfigAppCloseSettings, "app_close_settings");

_LIT8(KGOomConfigCloseApp, "close_app");

// App close idle time

_LIT8(KGOomConfigAppCloseIdlePriority, "app_close_idle_priority");

_LIT8(KGOomConfigForegroundAppPriority, "foreground_app_priority");

// Global settings attribute names

_LIT8(KGOomAttributeLowRamThreshold, "low_ram_threshold");

_LIT8(KGOomAttributeGoodRamThreshold, "good_ram_threshold");

_LIT8(KGOomAttributeMaxAppCloseBatch, "max_app_close_batch");

_LIT8(KGOomAttributeDefaultWaitAfterPlugin, "default_wait_after_plugin");

//App specific

_LIT8(KGOomAttributeTargetFreeOnStartup, "target_free_on_startup");

// System plugins 

_LIT8(KGOomAttributeSystemPluginSettings, "system_plugin_settings");

_LIT8(KGOomAttributeSystemPlugin, "system_plugin");

// Application plugins

_LIT8(KGOomAttributeAppPluginSettings, "app_plugin_settings");

_LIT8(KGOomAttributeAppPlugin, "app_plugin");

// Plugin idle time rules

_LIT8(KGOomAttributePluginIdlePriority, "plugin_idle_priority");

// Plugin foreground app rules

_LIT8(KGOomAttributePluginForegroundAppPriority, "plugin_foreground_app_priority");

// Atribute names

_LIT8(KGOomAttibuteUid, "uid");

_LIT8(KGOomAttibuteSyncMode, "sync_mode");

_LIT8(KGOomAttibutePriority, "priority");

_LIT8(KGOomAttibuteRamEstimate, "ram_estimate");

_LIT8(KGOomConfigSyncModeContinue, "continue");

_LIT8(KGOomConfigSyncModeCheck, "check");

_LIT8(KGOomConfigSyncModeEstimate, "estimate");

_LIT8(KGOomAttibuteIdleTime, "idle_time");

_LIT8(KGOomAttibuteIdlePriority, "priority");

_LIT8(KGOomAttibuteNeverClose, "NEVER_CLOSE");

_LIT8(KGOomAttributeTargetAppId, "target_app_id");

_LIT8(KGOomAttributeWait, "wait");

_LIT8(KGOomAttributeIfForegroundAppId, "if_foreground_app_id");

_LIT8(KGOomConfigDefaultAppUid, "DEFAULT_APP");

_LIT8(KGOomConfigDefaultPluginUid, "DEFAULT_PLUGIN");

_LIT8(KGOomConfigTargetAppValue, "TARGET_APP");

_LIT8(KGOomConfigBusyAppUid, "BUSY_APP");

_LIT8(KGOomConfigHighPriorityAppUid, "HIGH_PRIORITY_APP");

CGOomConfigParser::CGOomConfigParser(CGOomConfig& aConfig, RFs& aFs) : iConfig(aConfig), iFs(aFs), iState(EGOomParsingStateNone)

    {

    }

void CGOomConfigParser::ParseL()

    {

    FUNC_LOG;

    TRACES("CGOomConfigParser::ParseL: Parsing Config File");

    CParser* parser = CParser::NewLC(KXmlMimeType, *this);

    RFile configFile;

    TFileName configFileName;

    TChar driveChar = iFs.GetSystemDriveChar();

    configFileName.Append(driveChar);

    configFileName.Append(KGOomConfigFilePath);

    if (configFile.Open(iFs, configFileName, EFileShareExclusive) != KErrNone)

        {

        configFileName.Replace(0,1,KRomDrive); //replace 'c' with 'z'

        User::LeaveIfError(configFile.Open(iFs, configFileName, EFileShareExclusive));

        }

    CleanupClosePushL(configFile);

    TBuf8<KGOomXmlFileBufferSize> fileBuffer;

    TInt bytesRead;

    do

        {

        User::LeaveIfError(configFile.Read(fileBuffer));

        bytesRead = fileBuffer.Size();

        parser->ParseL(fileBuffer);

        } while (bytesRead != 0);

    CleanupStack::PopAndDestroy(2, parser); // config file - automatically closes it

                                            // parser

    TRACES("CGOomConfigParser::ParseL: Finished Parsing Config File");    

    }

void CGOomConfigParser::OnStartDocumentL(const RDocumentParameters&, TInt)

    {

    FUNC_LOG;

    }

void CGOomConfigParser::OnEndDocumentL(TInt)

    {

    FUNC_LOG;

    }

void CGOomConfigParser::OnEndElementL(const RTagInfo&, TInt)

    {

    }

void CGOomConfigParser::OnContentL(const TDesC8&, TInt)

    {

    }

void CGOomConfigParser::OnStartPrefixMappingL(const RString&, const RString&, 

                                   TInt)

    {

    }

void CGOomConfigParser::OnEndPrefixMappingL(const RString&, TInt)

    {

    }

void CGOomConfigParser::OnIgnorableWhiteSpaceL(const TDesC8&, TInt)

    {

    }

void CGOomConfigParser::OnSkippedEntityL(const RString&, TInt)

    {

    }

void CGOomConfigParser::OnProcessingInstructionL(const TDesC8&, const TDesC8&, 

                                      TInt)

    {

    }

void CGOomConfigParser::OnError(TInt)

    {

    }

TAny* CGOomConfigParser::GetExtendedInterface(const TInt32)

    {

    return 0;

    }

void CGOomConfigParser::OnStartElementL(const RTagInfo& aElement, const RAttributeArray& aAttributes, 

                             TInt aErrorCode)

    {

    if (aErrorCode != KErrNone)

        ConfigError(KGOomErrBadXml);

    StartElementL(aElement.LocalName().DesC(), aAttributes);

    }

TInt CGOomConfigParser::StartElementL(const TDesC8& aLocalName,

                                        const RAttributeArray& aAttributes)

    {

    // Root

    if (aLocalName == KGOomConfigGOomConfig)

        {

        if (iState != EGOomParsingStateNone)

            ConfigError(KGOomErrMoreThanOneGOomConfig);

        ChangeState(EGOomParsingStateRoot);

        }

    // Parse main elements

    else if (aLocalName == KGOomConfigGlobalSettings)

        {

        if (iState != EGOomParsingStateRoot)

            ConfigError(KGOomErrGlobalSettingsMustComeAfterRoot);

        SetGlobalSettings(aAttributes);

        ChangeState(EGOomParsingStateGlobalSettings);

        }

    else if (aLocalName == KGOomConfigAppSettings)

        {

        ChangeState(EGOomParsingStateAppSettings);

        }

    else if (aLocalName == KGOomConfigAppCloseSettings)

        {

        ChangeState(EGOomParsingStateAppCloseSettings);

        }

    else if (aLocalName == KGOomAttributeSystemPluginSettings)

        {

        ChangeState(EGOomParsingStateSystemPluginSettings);

        }

    else if (aLocalName == KGOomAttributeAppPluginSettings)

        {

        ChangeState(EGOomParsingStateAppPluginSettings);

        }

    // Parse actual configuration elements

    else if (aLocalName == KGOomConfigForceCheckAtPriority)

        {

        SetForceCheckConfigL(aAttributes);

        }

    else if (aLocalName == KGOomConfigApp)

        {

        SetAppConfigL(aAttributes);

        }

    else if (aLocalName == KGOomConfigCloseApp)

        {

        SetCloseAppConfigL(aAttributes);

        }

    else if (aLocalName == KGOomConfigAppCloseIdlePriority)

        {

        CheckState(EGOomParsingStateAppCloseSettings, KGOomErrAppCloseIdleRuleOutsideAppCloseElement);

        SetAppCloseIdlePriorityConfigL(aAttributes);

        }

    else if (aLocalName == KGOomConfigForegroundAppPriority)

        {

        CheckState(EGOomParsingStateAppCloseSettings, KGOomErrForegroundAppRuleOutsideAppCloseElement);

        SetForegroundAppPriorityL(aAttributes);

        }

    else if (aLocalName == KGOomAttributeSystemPlugin)

        {

        SetSystemPluginConfigL(aAttributes);

        }

    else if (aLocalName == KGOomAttributeAppPlugin)

        {

        SetAppPluginConfigL(aAttributes);

        }

    else if (aLocalName == KGOomAttributePluginIdlePriority)

        {

        CheckState(EGOomParsingStateAppPluginSettings, KGOomErrPluginIdleRuleOutsideAppPluginElement);

        SetPluginIdlePriorityL(aAttributes);

        }

    else if (aLocalName == KGOomAttributePluginForegroundAppPriority)

        {

        CheckState(EGOomParsingStateAppPluginSettings, EGOomParsingStateSystemPluginSettings, KGOomErrPluginForegroundRuleOutsidePluginElement);

        SetPluginForegroundAppPriorityL(aAttributes);

        }

    return KErrNone;

    }

void CGOomConfigParser::ConfigError(TInt aError)

    {

    GOomConfigParserPanic(aError);

    }

void CGOomConfigParser::SetGlobalSettings(const RAttributeArray& aAttributes)

    {

    TInt defaultLowMemoryThreshold;    

    TInt err = GetValueFromDecimalAttributeList(aAttributes, KGOomAttributeLowRamThreshold, defaultLowMemoryThreshold);

    if (err == KErrNone)

        iConfig.SetDefaultLowRamThreshold(defaultLowMemoryThreshold * 1024);

    else

        ConfigError(KGOomErrLowRamErrorInGlobalSettings);

    if (err == KErrNone)

        {

        TInt defaultGoodMemoryThreshold;    

        TInt err = GetValueFromDecimalAttributeList(aAttributes, KGOomAttributeGoodRamThreshold, defaultGoodMemoryThreshold);

        if (err == KErrNone)

            iConfig.SetDefaultGoodRamThreshold(defaultGoodMemoryThreshold * 1024);

        else

            ConfigError(KGOomErrGoodRamErrorInGlobalSettings);

        }

    if (err == KErrNone)

        {

        TInt defaultMaxCloseAppBatch;    

        TInt err = GetValueFromDecimalAttributeList(aAttributes, KGOomAttributeMaxAppCloseBatch, defaultMaxCloseAppBatch);

        if (err == KErrNone)

            iConfig.SetMaxCloseAppBatch(defaultMaxCloseAppBatch);

        else

            ConfigError(KGOomErrMaxCloseErrorInGlobalSettings);

        }

    if (err == KErrNone)

        {

        TInt defaultWaitAfterPlugin;    

        TInt err = GetValueFromDecimalAttributeList(aAttributes, KGOomAttributeDefaultWaitAfterPlugin, defaultWaitAfterPlugin);

        if (err == KErrNone)

            iConfig.SetDefaultWaitAfterPlugin(defaultWaitAfterPlugin);

        else

            ConfigError(KGOomErrDefaultWaitAfterPluginInGlobalSettings);

        }

    }

void CGOomConfigParser::SetForceCheckConfigL(const RAttributeArray& aAttributes)

    {

    TUint priority;

    TInt err = GetValueFromDecimalAttributeList(aAttributes, KGOomAttibutePriority, priority);

    if (err == KErrNone)

        {

        iConfig.GlobalConfig().AddForceCheckPriorityL(priority);

        }

    else

        {

        ConfigError(KGOomErrBadOrMissingPriorityInForceCheck);    

        }

    }

void CGOomConfigParser::SetAppConfigL(const RAttributeArray& aAttributes)

    {

    TUint uid;

    CGOomApplicationConfig* appConfig = NULL;

    TInt err = GetValueFromHexAttributeList(aAttributes, KGOomAttibuteUid, uid);

    if (err != KErrNone)

        {

        ConfigError(KGOomErrBadOrMissingUidInAppConfig);

        }

    else

        iParentUid = uid;

    appConfig = CGOomApplicationConfig::NewL(uid);

    CleanupStack::PushL(appConfig);    

    // Set the app specific memory thresholds (if they exist)

    // Get the app specific low threshold

    if (err == KErrNone)

        {

        TUint lowThreshold;

        err = GetValueFromDecimalAttributeList(aAttributes, KGOomAttributeLowRamThreshold, lowThreshold);

        if (err == KErrNone)

            {

            appConfig->iLowRamThreshold = lowThreshold * 1024; // The config files work in K, so we need to multiply by 1024

            }

        else if (err == KErrNotFound)

            err = KErrNone;

        if (err != KErrNone)

            ConfigError(KGOomErrBadLowThresholdValueForAppConfig);

        }

    // Get the app specific good threshold

    if (err == KErrNone)

        {

        TUint goodThreshold;

        err = GetValueFromDecimalAttributeList(aAttributes, KGOomAttributeGoodRamThreshold, goodThreshold);

        if (err == KErrNone)

            {

            appConfig->iGoodRamThreshold = goodThreshold * 1024; // The config files work in K, so we need to multiply by 1024

            }

        else if (err == KErrNotFound)

            err = KErrNone;

        if (err != KErrNone)

            ConfigError(KGOomErrBadGoodThresholdValueForAppConfig);

        }

    // Get the app specific TargetFreeOnStartup

        if (err == KErrNone)

            {

            TUint targetFree;

            err = GetValueFromDecimalAttributeList(aAttributes, KGOomAttributeTargetFreeOnStartup, targetFree);

            if (err == KErrNone)

                {

                appConfig->iTargetFree = targetFree * 1024; // The config files work in K, so we need to multiply by 1024

                }

            else if (err == KErrNotFound)

                err = KErrNone;

            if (err != KErrNone)

                ConfigError(KGOomErrBadTargetFreeValueForAppConfig);

            }

    // Add the applciation config to the main config

    if ((err == KErrNone) && (appConfig))

        {

        iConfig.AddApplicationConfigL(appConfig);

        }

    if (appConfig)

        CleanupStack::Pop(appConfig);

    }

void CGOomConfigParser::SetCloseAppConfigL(const RAttributeArray& aAttributes)

    {

    // Get and convert uid attribute to TInt

    TInt err = KErrNone;

    TUint uid;

    err = GetValueFromHexAttributeList(aAttributes, KGOomAttibuteUid, uid);

    if (err != KErrNone)

        {

        ConfigError(KGOomErrBadOrMissingUidInAppCloseConfig);    

        return;