/*

* 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 OOM configuration file.

*

*/

#include <e32base.h>

#include <xml/parser.h>

#include "oomconfigparser.h"

#include "oompanic.h"

#include "OomTraces.h"

#include "oomidletimerule.h"

#include "oomforegroundrule.h"

#include "oomconstants.hrh"

#include "oomapplicationconfig.h"

#include "oomcloseappconfig.h"

#include "oomconfig.h"

#include "oomrunpluginconfig.h"

enum TOomConfigParserPanic

{

KOomErrMoreThanOneOomConfig = 0,

KOomErrGlobalSettingsMustComeAfterRoot,

KOomErrAppSettingsMustComeAfterGlobalSettings,

KOomErrCloseAppSettingsMustComeAfterAppSettings,

KOomErrAppIdleSettingsMustComeAfterAppCloseSettings,

KOomErrLowRamErrorInGlobalSettings,

KOomErrGoodRamErrorInGlobalSettings,

KOomErrMaxCloseErrorInGlobalSettings,

KOomErrDefaultPriorityErrorInGlobalSettings,

KOomErrMissingUidFromAppCloseConfig,

KOomErrMissingPriorityFromAppCloseConfig,

KOomErrMissingSyncModeFromAppCloseConfig,

KOomErrMissingEstimateFromAppCloseConfig,

KOomErrInvalidSyncMode,

KOomErrMissingSyncModeInAppCloseConfig,

KOomErrBadOrMissingPriorityInAppIdleRule,

KOomErrBadOrMissingIdleTimeInAppIdleRule,

KOomErrBadOrMissingUidInAppIdleRule,

KOomErrBadNeverCloseValue,

KOomErrBadOrMissingUidInAppConfig,

KOomErrBadOrMissingPriorityInAppCloseConfig,

KOomErrBadLowThresholdValueForAppConfig,

KOomErrBadGoodThresholdValueForAppConfig,

KOomErrSystemPluginSettingsMustComeAfterAppCloseSettings,

KOomErrAppPluginSettingsMustComeAfterSystemPluginSettings,

KOomErrAppPluginIdleTimeRulesMustComeAfterAppPluginSettings,

KOomErrBadOrMissingUidInAppCloseConfig,

KOomErrBadOrMissingUidInSystemPluginConfig,

KOomErrBadOrMissingPriorityInSystemPluginConfig,

KOomErrBadOrMissingTargetAppIdInAppPluginConfig,

KOomErrBadOrMissingUidInAppPluginConfig,

KOomErrBadOrMissingPriorityInAppPluginConfig,

KOomErrBadOrMissingPriorityInPluginIdleRule,

KOomErrBadOrMissingIdleTimeInPluginIdleRule,

KOomErrBadOrMissingUidInPluginIdleRule,

KOomErrBadOrMissingUidInForegroundAppRule,

KOomErrBadOrMissingPriorityInForegroundAppRule,

KOomErrBadOrMissingTargetAppIdInForegroundAppRule,

KOomErrDefaultWaitAfterPluginInGlobalSettings,

KOomErrBadOrMissingPriorityInForceCheck,

KOomErrOomRulesMustComeLast,

KOomErrBadPluginWaitTime,

KOomErrBadXml,

KOomErrAppCloseIdleRuleOutsideAppCloseElement,

KOomErrForegroundAppRuleOutsideAppCloseElement,

KOomErrPluginIdleRuleOutsideAppPluginElement,

KOomErrPluginForegroundRuleOutsidePluginElement,

KOomErrBadCallIfTargetAppNotRunning

};

const TInt KOomXmlFileBufferSize = 1024;

const TInt KOomMaxAppExitTime = 2000;

const TInt KBytesInMegabyte = 1024;

#ifdef __WINS__

const TInt KEmulatorTickDivisor = 5; // The tick is 5 times slower on the emulator than on the phone

#endif

using namespace Xml;

// Mime type of the parsed document

_LIT8(KXmlMimeType, "text/xml");

_LIT(KOomConfigFilePath, ":\\private\\10207218\\oomconfig.xml");

_LIT(KRomDrive, "z");

// Element strings

// Root

_LIT8(KOomConfigOomConfig, "oom_config");

// Global settings

_LIT8(KOomConfigGlobalSettings, "global_settings");

_LIT8(KOomConfigForceCheckAtPriority, "force_check");

// App settings

_LIT8(KOomConfigAppSettings, "app_specific_thresholds");

_LIT8(KOomConfigApp, "app");

// App close settings

_LIT8(KOomConfigAppCloseSettings, "app_close_settings");

_LIT8(KOomConfigCloseApp, "close_app");

// App close idle time

_LIT8(KOomConfigAppCloseIdlePriority, "app_close_idle_priority");

_LIT8(KOomConfigForegroundAppPriority, "foreground_app_priority");

// Global settings attribute names

_LIT8(KOomAttributeLowRamThreshold, "low_ram_threshold");

_LIT8(KOomAttributeGoodRamThreshold, "good_ram_threshold");

_LIT8(KOomAttributeMaxAppCloseBatch, "max_app_close_batch");

_LIT8(KOomAttributeDefaultWaitAfterPlugin, "default_wait_after_plugin");

_LIT8(KOomAttributeMaxAppExitTime , "max_app_exit_time");

// System plugins 

_LIT8(KOomAttributeSystemPluginSettings, "system_plugin_settings");

_LIT8(KOomAttributeSystemPlugin, "system_plugin");

// Application plugins

_LIT8(KOomAttributeAppPluginSettings, "app_plugin_settings");

_LIT8(KOomAttributeAppPlugin, "app_plugin");

// Plugin idle time rules

_LIT8(KOomAttributePluginIdlePriority, "plugin_idle_priority");

// Plugin foreground app rules

_LIT8(KOomAttributePluginForegroundAppPriority, "plugin_foreground_app_priority");

// Atribute names

_LIT8(KOomAttibuteUid, "uid");

_LIT8(KOomAttibuteSyncMode, "sync_mode");

_LIT8(KOomAttibutePriority, "priority");

_LIT8(KOomAttibuteRamEstimate, "ram_estimate");

_LIT8(KOomConfigSyncModeContinue, "continue");

_LIT8(KOomConfigSyncModeCheck, "check");

_LIT8(KOomConfigSyncModeEstimate, "estimate");

_LIT8(KOomAttibuteIdleTime, "idle_time");

_LIT8(KOomAttibuteIdlePriority, "priority");

_LIT8(KOomAttibuteNeverClose, "NEVER_CLOSE");

_LIT8(KOomAttributeTargetAppId, "target_app_id");

_LIT8(KOomAttributeWait, "wait");

_LIT8(KOomAttributeIfForegroundAppId, "if_foreground_app_id");

_LIT8(KOomAttributeCallIfTargetAppNotRunning, "call_if_target_app_not_running");

_LIT8(KOomAttributeTrue, "true");

_LIT8(KOomAttributeFalse, "false");

_LIT8(KOomAttribute0, "0");

_LIT8(KOomAttribute1, "1");

_LIT8(KOomConfigDefaultAppUid, "DEFAULT_APP");

_LIT8(KOomConfigDefaultPluginUid, "DEFAULT_PLUGIN");

_LIT8(KOomConfigTargetAppValue, "TARGET_APP");

_LIT8(KOomConfigBusyAppUid, "BUSY_APP");

_LIT8(KOomConfigHighPriorityAppUid, "HIGH_PRIORITY_APP");

COomConfigParser::COomConfigParser(COomConfig& aConfig, RFs& aFs) : iConfig(aConfig), iFs(aFs), iState(EOomParsingStateNone)

    {

    }

void COomConfigParser::ParseL()

    {

    FUNC_LOG;

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

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

    RFile configFile;

    TFileName configFileName;

    TChar driveChar = iFs.GetSystemDriveChar();

    configFileName.Append(driveChar);

    configFileName.Append(KOomConfigFilePath);

    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<KOomXmlFileBufferSize> 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("COomConfigParser::ParseL: Finished Parsing Config File");    

    }

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

    {

    FUNC_LOG;

    }

void COomConfigParser::OnEndDocumentL(TInt)

    {

    FUNC_LOG;

    }

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

    {

    }

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

    {

    }

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

                                   TInt)

    {

    }

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

    {

    }

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

    {

    }

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

    {

    }

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

                                      TInt)

    {

    }

void COomConfigParser::OnError(TInt)

    {

    }

TAny* COomConfigParser::GetExtendedInterface(const TInt32)

    {

    return 0;

    }

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

                             TInt aErrorCode)

    {

    if (aErrorCode != KErrNone)

        ConfigError(KOomErrBadXml);

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

    }

void COomConfigParser::StartElementL(const TDesC8& aLocalName,

                                        const RAttributeArray& aAttributes)

    {

    // Root

    if (aLocalName == KOomConfigOomConfig)

        {

        if (iState != EOomParsingStateNone)

            ConfigError(KOomErrMoreThanOneOomConfig);

        ChangeState(EOomParsingStateRoot);

        }

    // Parse main elements

    else if (aLocalName == KOomConfigGlobalSettings)

        {

        if (iState != EOomParsingStateRoot)

            ConfigError(KOomErrGlobalSettingsMustComeAfterRoot);

        SetGlobalSettings(aAttributes);

        ChangeState(EOomParsingStateGlobalSettings);

        }

    else if (aLocalName == KOomConfigAppSettings)

        {

        ChangeState(EOomParsingStateAppSettings);

        }

    else if (aLocalName == KOomConfigAppCloseSettings)

        {

        ChangeState(EOomParsingStateAppCloseSettings);

        }

    else if (aLocalName == KOomAttributeSystemPluginSettings)

        {

        ChangeState(EOomParsingStateSystemPluginSettings);

        }

    else if (aLocalName == KOomAttributeAppPluginSettings)

        {

        ChangeState(EOomParsingStateAppPluginSettings);

        }

    // Parse actual configuration elements

    else if (aLocalName == KOomConfigForceCheckAtPriority)

        {

        SetForceCheckConfigL(aAttributes);

        }

    else if (aLocalName == KOomConfigApp)

        {

        SetAppConfigL(aAttributes);

        }

    else if (aLocalName == KOomConfigCloseApp)

        {

        SetCloseAppConfigL(aAttributes);

        }

    else if (aLocalName == KOomConfigAppCloseIdlePriority)

        {

        CheckState(EOomParsingStateAppCloseSettings, KOomErrAppCloseIdleRuleOutsideAppCloseElement);

        SetAppCloseIdlePriorityConfigL(aAttributes);

        }

    else if (aLocalName == KOomConfigForegroundAppPriority)

        {

        CheckState(EOomParsingStateAppCloseSettings, KOomErrForegroundAppRuleOutsideAppCloseElement);

        SetForegroundAppPriorityL(aAttributes);

        }

    else if (aLocalName == KOomAttributeSystemPlugin)

        {

        SetSystemPluginConfigL(aAttributes);

        }

    else if (aLocalName == KOomAttributeAppPlugin)

        {

        SetAppPluginConfigL(aAttributes);

        }

    else if (aLocalName == KOomAttributePluginIdlePriority)

        {

        CheckState(EOomParsingStateAppPluginSettings, KOomErrPluginIdleRuleOutsideAppPluginElement);

        SetPluginIdlePriorityL(aAttributes);

        }

    else if (aLocalName == KOomAttributePluginForegroundAppPriority)

        {

        CheckState(EOomParsingStateAppPluginSettings, EOomParsingStateSystemPluginSettings, KOomErrPluginForegroundRuleOutsidePluginElement);

        SetPluginForegroundAppPriorityL(aAttributes);

        }

    }

void COomConfigParser::ConfigError(TInt aError)

    {

    OomConfigParserPanic(aError);

    }

void COomConfigParser::SetGlobalSettings(const RAttributeArray& aAttributes)

    {

    TInt defaultLowMemoryThreshold;    

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

    if (err == KErrNone)

        iConfig.SetDefaultLowRamThreshold(defaultLowMemoryThreshold * KBytesInMegabyte);

    else

        ConfigError(KOomErrLowRamErrorInGlobalSettings);

    if (err == KErrNone)

        {

        TInt defaultGoodMemoryThreshold;    

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

        if (err == KErrNone)

            iConfig.SetDefaultGoodRamThreshold(defaultGoodMemoryThreshold * KBytesInMegabyte);

        else

            ConfigError(KOomErrGoodRamErrorInGlobalSettings);

        }

    if (err == KErrNone)

        {

        TInt defaultMaxCloseAppBatch;    

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

        if (err == KErrNone)

            iConfig.SetMaxCloseAppBatch(defaultMaxCloseAppBatch);

        else

            ConfigError(KOomErrMaxCloseErrorInGlobalSettings);

        }

    if (err == KErrNone)

        {

        TInt defaultWaitAfterPlugin;    

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

        if (err == KErrNone)

            iConfig.SetDefaultWaitAfterPlugin(defaultWaitAfterPlugin);

        else

            ConfigError(KOomErrDefaultWaitAfterPluginInGlobalSettings);

        }

    if (err == KErrNone)

        {

        TInt maxAppExitTime;    

        TInt err = GetValueFromDecimalAttributeList(aAttributes, KOomAttributeMaxAppExitTime, maxAppExitTime);

        if (err == KErrNone)

            iConfig.SetMaxAppExitTime(maxAppExitTime);

        else

            iConfig.SetMaxAppExitTime(KOomMaxAppExitTime);

        }

    }

void COomConfigParser::SetForceCheckConfigL(const RAttributeArray& aAttributes)

    {

    TUint priority;

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

    if (err == KErrNone)

        {

        iConfig.GlobalConfig().AddForceCheckPriorityL(priority);

        }

    else

        {

        ConfigError(KOomErrBadOrMissingPriorityInForceCheck);    

        }

    }

void COomConfigParser::SetAppConfigL(const RAttributeArray& aAttributes)

    {

    TUint uid;

    COomApplicationConfig* appConfig = NULL;

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

    if (err != KErrNone)

        {

        ConfigError(KOomErrBadOrMissingUidInAppConfig);

        }

    else

        iParentUid = uid;

    appConfig = COomApplicationConfig::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, KOomAttributeLowRamThreshold, lowThreshold);

        if (err == KErrNone)

            {

            appConfig->iLowRamThreshold = lowThreshold * KBytesInMegabyte;

            }

        else if (err == KErrNotFound)

            err = KErrNone;

        if (err != KErrNone)

            ConfigError(KOomErrBadLowThresholdValueForAppConfig);

        }

    // Get the app specific good threshold

    if (err == KErrNone)

        {

        TUint goodThreshold;

        err = GetValueFromDecimalAttributeList(aAttributes, KOomAttributeGoodRamThreshold, goodThreshold);

        if (err == KErrNone)

            {

            appConfig->iGoodRamThreshold = goodThreshold * KBytesInMegabyte;

            }

        else if (err == KErrNotFound)

            err = KErrNone;

        if (err != KErrNone)

            ConfigError(KOomErrBadGoodThresholdValueForAppConfig);

        }