/*

* Copyright (c) 2009 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:  

*

*/

#include "GeneralsPlugin.h"	

#include <piprofiler/EngineUIDs.h>

#include <piprofiler/ProfilerTraces.h>

const TInt KMaxSamplerAmount = 20;

// LITERALS

_LIT8(KEnabled, "enabled");

_LIT8(KSamplingPeriod, "sampling_period_ms");

_LIT8(KBracketOpen, "[");

_LIT8(KBracketClose, "]");

/*

 *	

 *	class CGeneralsPlugin implementation

 * 

 */

CGeneralsPlugin* CGeneralsPlugin::NewL(const TUid aImplementationUid, TAny* /*aInitParams*/)

    {

	LOGTEXT(_L("CGeneralsPlugin::NewL() - entry"));

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

	LOGTEXT(_L("CGeneralsPlugin::NewL() - exit"));

    return self;

    }

CGeneralsPlugin::CGeneralsPlugin() :

	iVersionDescriptor(&(this->iVersion[1]),0,19)

	{

	iSamplerType = PROFILER_KERNEL_MODE_SAMPLER;

	iSamplerId = PROFILER_GENERALS_SAMPLER_ID;

	iBufferHandler = NULL;

    iEnabled = EFalse;

	LOGTEXT(_L("CGeneralsPlugin::CGeneralsPlugin() - constructor"));

	}

void CGeneralsPlugin::ConstructL() 

    {

	LOGTEXT(_L("CGeneralsPlugin::ConstructL() - entry"));

	// create attribute array

	iSamplerAttributes = new(ELeave) CArrayFixFlat<TSamplerAttributes>(KSubSamplerCount);

	TInt err = InitiateSamplerL();

	if( err != KErrNone )

		{

			LOGTEXT(_L("CGeneralsPlugin::ConstructL - LEAVING, failed to load open sampler device"));

			User::Leave(err);

		}

	// initiate sampler attributes, i.e. settings for modification

	InitiateSamplerAttributesL();

	LOGTEXT(_L("CGeneralsPlugin::ConstructL() - exit"));

    }

CGeneralsPlugin::~CGeneralsPlugin()

	{

	// clean all the members

	CleanSampler();	// clean the created sampler

	}

TInt CGeneralsPlugin::InitiateSamplerL()

	{

	RThread me;

	LOGTEXT(_L("CGeneralsPlugin::InitiateSamplerL - #1"));

	me.SetPriority(EPriorityRealTime);

	LOGTEXT(_L("CGeneralsPlugin::InitiateSamplerL - #2"));

	// create 

	User::FreeLogicalDevice(KPluginSamplerName);

	TInt err(KErrGeneral);

	LOGTEXT(_L("CGeneralsPlugin::InitiateSamplerL - #3"));

    err = User::LoadLogicalDevice(KPluginSamplerName);

    if(err != KErrNone)

        {

        User::Leave(err);

        }

	LOGTEXT(_L("CGeneralsPlugin::InitiateSamplerL - #4"));

	err = KErrGeneral;

    err = iGeneralsSampler.Open();

    if(err != KErrNone)

        {

        LOGSTRING2("CGeneralsPlugin::InitiateSamplerL - Could not open sampler device - waiting and trying again: %d", err);

        User::Leave(err);

        }

	LOGTEXT(_L("CGeneralsPlugin::InitiateSamplerL - #5"));

	return err;

	}

/* 

 * 

 * Default sampler attributes

 * 

 */

void CGeneralsPlugin::InitiateSamplerAttributesL()

    {

    // 

    for(TInt i(0);i<KMaxSamplerAmount;i++)

        {

        switch(i)

            {

// Usage:

//            TSamplerAttributes(TUint32 aUid,

//                    const TDesC8& aShortName,

//                    const TDesC& aName,

//                    const TDesC& aDescription,

//                    TInt aSampleRate,

//                    TBool aEnabled,

//                    TBool aHidden,

//                    TUint32 aItemCount);

            case PROFILER_GPP_SAMPLER_ID:

                {

                TSamplerAttributes attr(KSamplerGppPluginUid.iUid,

                        KGPPShortName(),

                        KGPPLongName(),

                        KGPPDescription(),

                        1,

                        ETrue,

                        ETrue,

                        0);

                iSamplerAttributes->AppendL(attr);

                break;

                }

            case PROFILER_GFC_SAMPLER_ID:

                {

                TSamplerAttributes attr2(KSamplerGfcPluginUid.iUid,

                        KGFCShortName(),

                        KGFCLongName(),

                        KGFCDescription(),

                        -1,

                        EFalse,

                        EFalse,

                        0);

                this->iSamplerAttributes->AppendL(attr2);

                break;

                }

            case PROFILER_ITT_SAMPLER_ID:

                {

                TSamplerAttributes attr3(KSamplerIttPluginUid.iUid,

                        KITTShortName(),

                        KITTLongName(),

                        KITTDescription(),

                        -1,

                        EFalse,

                        EFalse,

                        0);

                this->iSamplerAttributes->AppendL(attr3);

                break;

                }

            case PROFILER_MEM_SAMPLER_ID:

                {

                TSamplerAttributes attr4(KSamplerMemPluginUid.iUid,

                        KMEMShortName(),

                        KMEMLongName(),

                        KMEMDescription(),

                        3000,

                        EFalse,

                        EFalse,

                        0);

                this->iSamplerAttributes->AppendL(attr4);

                break;

                }

            case PROFILER_PRI_SAMPLER_ID:

                {

                TSamplerAttributes attr5(KSamplerPriPluginUid.iUid,

                        KPRIShortName(),

                        KPRILongName(),

                        KPRIDescription(),

                        3000,

                        EFalse,

                        EFalse,

                        0);

                this->iSamplerAttributes->AppendL(attr5);

                break;

                }

            }

        }

    }

TInt CGeneralsPlugin::CleanSampler()

	{

    LOGTEXT(_L("CGeneralsPlugin::CleanSampler() - deleting buffer handler"));

    // release the buffer handler

    if(iBufferHandler)

        {

        iBufferHandler->Cancel();

        delete iBufferHandler;

        iBufferHandler = NULL;

        }

    LOGTEXT(_L("CGeneralsPlugin::CleanSampler() - closing sampler"));

	iGeneralsSampler.Close();

	LOGTEXT(_L("CGeneralsPlugin::CleanSampler() - Freeing sampler device"));

	User::FreeLogicalDevice(KPluginSamplerName);

	// release attribute array

	if(iSamplerAttributes)

	    {

	    iSamplerAttributes->Reset();

	    }

    delete iSamplerAttributes;

    iSamplerAttributes = NULL;

	LOGTEXT(_L("CGeneralsPlugin::CleanSampler() - exit"));

	return KErrNone;

	}

// returns setting array

void CGeneralsPlugin::GetAttributesL(CArrayFixFlat<TSamplerAttributes>* aAttributes)

    {

    TInt count(iSamplerAttributes->Count());

    // append all sampler attributes to aAttributes array

    for(TInt i(0);i<count;i++)

        {

        aAttributes->AppendL(iSamplerAttributes->At(i));

        }

    }

TInt CGeneralsPlugin::SetAttributesL(TSamplerAttributes aAttributes)

    {

    TSamplerAttributes attr;

    TInt count(iSamplerAttributes->Count());

    // loop the sub sampler attributes (by UID)

    for(TInt i(0);i<count;i++)

        {

        attr = iSamplerAttributes->At(i);

        // if UIDs match replace the old 

        if(attr.iUid == aAttributes.iUid)

            {

            // replace the old attribute container

            iSamplerAttributes->Delete(i);

            iSamplerAttributes->InsertL(i, aAttributes);

            return KErrNone;

            }

        }

    return KErrNotFound;

    }

/* 

 * Method for parsing and transforming text array settings into TSamplerAttributes (per each sub sampler),

 * called by CSamplerController class

 * 

 * @param array of raw text setting lines, e.g. [gpp]\nenabled=true\nsampling_period_ms=1\n

 */

TInt CGeneralsPlugin::ConvertRawSettingsToAttributes(CDesC8ArrayFlat* aAllSettingsArray)

    {

    // local literals

    _LIT8(KGPPShort, "gpp");

    _LIT8(KGFCShort, "gfc");

    _LIT8(KITTShort, "itt");

    _LIT8(KMEMShort, "mem");

    _LIT8(KPRIShort, "pri");

    TInt err(KErrNone);

    TBuf8<16> samplerSearchName;

    // loop previous settings, update value if changed

    for(TInt i(0);i<KSubSamplerCount;i++)

        {

        // go through all the sub samplers

        switch (i)

            {

            case 0:

                samplerSearchName.Copy(KGPPShort);

                break;

            case 1:

                samplerSearchName.Copy(KGFCShort);

                break;

            case 2:

                samplerSearchName.Copy(KITTShort);

                break;

            case 3:

                samplerSearchName.Copy(KMEMShort);

                break;

            case 4:

                samplerSearchName.Copy(KPRIShort);

                break;

            }

        // get sampler specific settings  

        err = DoSetSamplerSettings(aAllSettingsArray, samplerSearchName, i);

        }

    // returns KErrNone if settings found, otherwise KErrNotFound

    return err;

    }

/**

 * Method for searching sampler specific settings among all settings (raw setting lines read from settings file)

 * 

 * @param aAllSettings array of all settings from settings file

 * @param aSamplerName short name of sampler to be searched among the settings

 * @param aIndex index number of sampler specific sampler attributes (TSamplerAttributes)

 * @return KErrNone if settings found ok else KErrNotFound

 */

TInt CGeneralsPlugin::DoSetSamplerSettings(CDesC8ArrayFlat* aAllSettings, TDesC8& aSamplerName, TInt aIndex)

    {

    // sampler name to be searched among the all settings

    TBuf8<16> samplerSearch;

    samplerSearch.Copy(KBracketOpen);

    samplerSearch.Append(aSamplerName);

    samplerSearch.Append(KBracketClose);

    // read a line from ALL settings array

    for (TInt i(0); i<aAllSettings->MdcaCount(); i++)

        {

        // check if this line has a setting block start, i.e. contains [xxx] in it

        if (aAllSettings->MdcaPoint(i).CompareF(samplerSearch) == 0)

            {

            // right settings block found, now loop until the next block is found

            for(TInt j(i+1);j<aAllSettings->MdcaCount();j++)

                {

                // check if the next settings block was found

                if(aAllSettings->MdcaPoint(j).Left(1).CompareF(KBracketOpen) != 0)

                    {

                    // save found setting value directly to its owners attributes

                    SaveSettingToAttributes(aAllSettings->MdcaPoint(j), aIndex);

                    }

                else

                    {

                    // next block found, return KErrNone

                    return KErrNone;

                    }

                }

            }

        }

    // no settings found for specific sampler

    return KErrNotFound;

    }

/**

 * Method for setting a specific descriptor (from settings file) to attribute structure

 * 

 * @param aSetting  

 * @param aName  

 */

void CGeneralsPlugin::SaveSettingToAttributes(const TDesC8& aSetting, TInt aIndex)

    {

    // local literals

    _LIT8(KSettingItemSeparator, "=");

    // find the equal mark from the setting line

    TInt sepPos = aSetting.Find(KSettingItemSeparator);

    // check that '=' is found

    if (sepPos > 0)

        {

        // check that the element matches

        if (aSetting.Left(sepPos).CompareF(KEnabled) == 0)

            {

            TBool en;

            CSamplerPluginInterface::Str2Bool(aSetting.Right(aSetting.Length()-sepPos-1), en);

            if(en != iSamplerAttributes->At(aIndex).iEnabled)

                {

                iSamplerAttributes->At(aIndex).iEnabled = en;

                }

            }

        else if (aSetting.Left(sepPos).CompareF(KSamplingPeriod) == 0)

            {

            TInt sr;

            CSamplerPluginInterface::Str2Int(aSetting.Right(aSetting.Length()-sepPos-1), sr);

            if(sr != iSamplerAttributes->At(aIndex).iSampleRate)

                {

                iSamplerAttributes->At(aIndex).iSampleRate = sr;

                }

            }

        }

    }

TUid CGeneralsPlugin::Id(TInt aSubId) const

	{

		if(aSubId == PROFILER_GPP_SAMPLER_ID)		

			return KSamplerGppPluginUid;

		else if (aSubId == PROFILER_GFC_SAMPLER_ID)		

			return KSamplerGfcPluginUid;

		else if (aSubId == PROFILER_ITT_SAMPLER_ID)		

			return KSamplerIttPluginUid;

		else if (aSubId == PROFILER_MEM_SAMPLER_ID)		

			return KSamplerMemPluginUid;

		else if (aSubId == PROFILER_PRI_SAMPLER_ID)		

			return KSamplerPriPluginUid;

		else

			return KSamplerGeneralsPluginUid;

	}

TInt CGeneralsPlugin::SubId(TUid aId) const

	{

/* definitions from ProfilerConfig.h:

 * 	#define		PROFILER_GPP_SAMPLER_ID			1

	#define		PROFILER_GFC_SAMPLER_ID			2

	#define		PROFILER_ITT_SAMPLER_ID			3

	#define		PROFILER_MEM_SAMPLER_ID			4

	#define		PROFILER_PRI_SAMPLER_ID			5

 */

		if(aId == KSamplerGppPluginUid)		

			return PROFILER_GPP_SAMPLER_ID;

		else if (aId == KSamplerGfcPluginUid)		

			return PROFILER_GFC_SAMPLER_ID;

		else if (aId == KSamplerIttPluginUid)		

			return PROFILER_ITT_SAMPLER_ID;

		else if (aId == KSamplerMemPluginUid)		

			return PROFILER_MEM_SAMPLER_ID;

		else if (aId == KSamplerPriPluginUid)		

			return PROFILER_PRI_SAMPLER_ID;

		else

			return KErrNotFound;

	}

TInt CGeneralsPlugin::GetSamplerType()

	{

	return iSamplerType;

	}

//TInt CGeneralsPlugin::GetSubCount()

//	{

//	return (TInt)KSubSamplerCount;

//	}

TInt CGeneralsPlugin::GetSamplerUidByName(TDesC8& aName)

	{

	if(aName.Compare(KGPPShortName) == 0)

		{

			LOGTEXT(_L("GPP trace option"));

			return KSamplerGppPluginUid.iUid;

		}

	else if(aName.Compare(KGFCShortName) == 0)

		{

			LOGTEXT(_L("GFC trace option"));

			return KSamplerGfcPluginUid.iUid;

		}

	else if(aName.Compare(KITTShortName) == 0)

		{

			LOGTEXT(_L("ITT trace option"));

			return KSamplerIttPluginUid.iUid;

		}

	else if(aName.Compare(KMEMShortName) == 0)

		{

			LOGTEXT(_L("MEM trace option"));

			return KSamplerMemPluginUid.iUid;

		}

	else if(aName.Compare(KPRIShortName) == 0)

		{

			LOGTEXT(_L("PRI trace option"));

			return KSamplerPriPluginUid.iUid;

		}

	return -1;

	}

void CGeneralsPlugin::GetCaption( TDes& aCaption, TInt aType, TInt aSubId ) const

    {

    if(aSubId == -1)

    	{

    	aCaption.Copy(_L(""));

    	return;

    	}

    else if(aSubId == KSamplerGppPluginUid.iUid)

    	{

		aCaption.Copy(KGPPShortName);

    	}

    else if(aSubId == KSamplerIttPluginUid.iUid)

    	{

    	aCaption.Copy(KITTShortName);

    	}

    else if(aSubId == KSamplerGfcPluginUid.iUid)

    	{

    	aCaption.Copy(KGFCShortName);

    	}

    else if(aSubId == KSamplerMemPluginUid.iUid)

    	{

    	aCaption.Copy(KMEMShortName);

    	}

    else if(aSubId == KSamplerPriPluginUid.iUid)

    	{

		aCaption.Copy(KPRIShortName);

    	}

    else

    	{

    	aCaption.Copy(KGENShortName);

    	}

    aCaption.TrimRight();

    LOGSTRING2("CGeneralsPlugin::GetCaptionL() - plug-in name: %S", &aCaption);

    }

void CGeneralsPlugin::InstallStreamForActiveTraces(RGeneralsSampler& sampler, CProfilerSampleStream& aStream)

	{