/*

* 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 <e32cons.h>

#include <e32base.h>

#include <f32file.h>

#include <c32comm.h>

#include <s32file.h>

#include <pathinfo.h>

#include <s32mem.h>

#include <bautils.h>

#include <sysutil.h>

#include <piprofiler/ProfilerConfig.h>

#include "ProfilerEngine.h"

#include <piprofiler/ProfilerTraces.h>

// properties

const TUid KEngineStatusPropertyCat={0x2001E5AD};

enum TEnginePropertyKeys

	{

	EProfilerEngineStatus = 8,

	EProfilerErrorStatus

	};

static _LIT_SECURITY_POLICY_PASS( KAllowAllPolicy );

// CONSTANTS 

const TInt KStreamBufferSize = 32768;

const TInt KSavedLineCount = 64;

const TInt KFileNameBufSize = 128;

// Use this UID if plugin belongs to DebOutWriterPlugin:

const TUid KDebOutWriterPluginUid = { 0x2001E5BA };

// Use this UID if plugin belongs to MmcOutWriterPlugin:

const TUid KDiskWriterPluginUid = { 0x2001E5BB };

// LITERALS

_LIT8(KGenericTraceOutput, "output_type");

_LIT8(KGenericTraceFilePrefix, "file_prefix");

_LIT8(KGenericTraceFileSaveDrive, "save_file_location");

_LIT8(KGenericTimedProfilingPeriod, "profiling_period");

_LIT8(KEquals, "=");

_LIT8(KNewLineSeparator, "\n");

_LIT8(KProfilerVersionTag, "version");

_LIT8(KEndMark, "[end]");

_LIT8(KOutputToDebugOutput, "debug_output");

/** 

 * 

 * The controller class used to provide the Profiler functions. 

 * This runs as a server in the engine thread

 * 

 */

class CPServer : public CServer2, public MProfilerController

    {

public:

    static MProfilerController*		NewL(TInt aPriority, MProfilerEngine& aEngine);

private:

                        CPServer(TInt aPriority, MProfilerEngine& aEngine);

    void				Release();

    CSession2*			NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;

public:

    static TInt         iClientCount;

    };

TInt CPServer::iClientCount = 0;

// The session class used by the server controller

class CPSession : public CSession2

    {

private:

    inline const CPServer&	Server() const;

    void					ServiceL(const RMessage2& aMessage);

    };

/*

 *

 *	CProfiler class implementation

 *

 */

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

CProfiler* CProfiler::NewLC(const TDesC& aSettingsFile)

    {

	CProfiler* self = new(ELeave) CProfiler(aSettingsFile);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

    }

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

CProfiler::CProfiler(const TDesC& aSettingsFile) : 

    iSettingsFileLocation(aSettingsFile)

	{

	// define property for Profiler Engine status, UI may read it for control purposes

	if ( RProperty::Define(KEngineStatusPropertyCat, 

	        EProfilerEngineStatus, 

	        RProperty::EInt, 

	        KAllowAllPolicy, 

	        KAllowAllPolicy, 

	        0) != KErrAlreadyExists )

	    {

	    LOGTEXT(_L("CProfiler::CProfiler - status property already defined"));

	    }

	if ( RProperty::Define(KEngineStatusPropertyCat, 

	        EProfilerErrorStatus, 

            RProperty::EInt, 

            KAllowAllPolicy, 

            KAllowAllPolicy, 

            0) != KErrAlreadyExists )

        {

        LOGTEXT(_L("CProfiler::CProfiler - status property already defined"));

        }

	// attach to own property

	iEngineStatus.Attach(KEngineStatusPropertyCat, EProfilerEngineStatus);

	// set status idle

	iEngineStatus.Set(KEngineStatusPropertyCat, EProfilerEngineStatus, RProfiler::EIdle);

    // attach to own property

    iUpdateStatus.Attach(KEngineStatusPropertyCat, EProfilerErrorStatus);

    // set status idle

    iUpdateStatus.Set(KEngineStatusPropertyCat, EProfilerErrorStatus, EFalse);

	}

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

CProfiler::~CProfiler()

    {

	LOGTEXT(_L("CProfiler::~CProfiler - Enter"));

	// delete error checker

    if(iErrorChecker)

        {

        iErrorChecker->Cancel();

        delete iErrorChecker;

        iErrorChecker = NULL;

        }

	// delete settings array

	if(iDefaultSamplerAttributesArray)

	    {

	    iDefaultSamplerAttributesArray->Reset();

	    delete iDefaultSamplerAttributesArray;

	    iDefaultSamplerAttributesArray = NULL;

	    }

    // delete settings file raw line array

    if(iSavedLineArray)

        {

        iSavedLineArray->Reset();

        delete iSavedLineArray;

        iSavedLineArray = NULL;

        }

	// delete sampler controller, cleans up the sampler plugin instances

	if(iSamplerHandler)

		{

		delete iSamplerHandler;

		iSamplerHandler = NULL;

		}

	// delete writer controller, cleans up the writer plugin instances

	if(iWriterHandler)

		{

		delete iWriterHandler;

		iWriterHandler = NULL;

		}

    // delete user side sampler stream 

	if(iUserStream)

		{

		delete iUserStream;

		iUserStream = NULL;

		}

	// close engine status property

	iEngineStatus.Close();

	if (RProperty::Delete(KEngineStatusPropertyCat, EProfilerEngineStatus) != KErrNotFound)

	    {

	    LOGTEXT(_L("CProfiler::~CProfiler - cannot close status property"));

	    }

    // close engine update property

    iUpdateStatus.Close();

    if (RProperty::Delete(KEngineStatusPropertyCat, EProfilerErrorStatus) != KErrNotFound)

        {

        LOGTEXT(_L("CProfiler::~CProfiler - cannot close update property"));

        }

    // close server process

    if (iServer)

        {

        LOGTEXT(_L("CProfiler::~CProfiler - Releasing server"));

        iServer->Release();        

        }

    if( iTimer )

        {

        iTimer->Cancel();

        delete iTimer;

        iTimer = 0;

        }

	LOGTEXT(_L("CProfiler::~CProfiler - Finished"));

    }

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

void CProfiler::ConstructL()

    {

	LOGTEXT(_L("CProfiler::ConstructL - Enter"));

	TInt err(0);

	TLex lex;

	if ( iSettingsFileLocation.CompareF(KNullDesC) != 0 )

	    {

        lex=(iSettingsFileLocation);

        // parse the first command line argument, the command itself

        lex.Mark();

        lex.SkipCharacters();

        if(lex.TokenLength() != 0)

            {

            // there is another item in the list

            TPtrC filename = lex.MarkedToken();

            LOGSTRING2("filename %S", &filename);

            lex.SkipSpace();

            lex.Mark();

            lex.SkipCharacters();

            if(lex.TokenLength() != 0)

                {

                TPtrC boot = lex.MarkedToken();

                LOGTEXT(_L("boot mode"));

                }

            }

	    }

    // create new sampler stream instance

    iUserStream = CProfilerSampleStream::NewL(KStreamBufferSize);

    if(!iUserStream)

        {

        LOGTEXT(_L("Profiler engine cannot reserve memory"));

        User::Leave(KErrCancel);   // operation cancelled

        }

    // engine status checker

    iErrorChecker = CProfilerErrorChecker::NewL();

    iErrorChecker->SetObserver(this);

	// create and initiate plug-in controller instances

    iSamplerHandler = CSamplerController::NewL(*iUserStream);

    iWriterHandler = CWriterController::NewL(*iUserStream);

    iWriterHandler->InitialiseWriterListL();

    // set engine as an observer to sampler controller to get the notification of plugin load has ended

    iSamplerHandler->SetObserver(this);

    // default settings from sampler plugins, maximum 20 sampler plugins

    iDefaultSamplerAttributesArray = new(ELeave) CArrayFixFlat<TSamplerAttributes>(20); 

    // set profiler status to initializing

    iState = RProfiler::EInitializing;

	iEngineStatus.Set(RProfiler::EInitializing);

	// set default general settings, will be overdriven if changed in settings file

	iGeneralAttributes.iTraceOutput.Copy(KDefaultTraceOutput);

	iGeneralAttributes.iTraceFilePrefix.Copy(KDefaultTraceFilePrefix);

	iGeneralAttributes.iSaveFileDrive.Copy(KDefaultTraceFileSaveDrive);

	iGeneralAttributes.iTimedSamplingPeriod = KDefaultTimedSamplingPeriod;

	RThread me;

	me.SetPriority(EPriorityRealTime);

	err = KErrGeneral;

	TInt count = 0;

	while(err != KErrNone && count < 30)

	    {

		err = User::RenameThread(KProfilerName);

		if(err != KErrNone)

		    {

		    LOGSTRING2("CProfiler: error renaming the thread, err %d", err);

			User::Leave(err);

		    }

		else break;

	    }

	// set settings file loading preferences

	iSettingsFileLoaded = EFalse;

	// change status property to idle since initialization successfull

	iState = RProfiler::EIdle;

	if( iEngineStatus.Set((TInt)RProfiler::EIdle) != KErrNone )

	    {

	    LOGTEXT(_L("CProfiler::ConstructL - engine status property change failed"));

	    }

    if( iUpdateStatus.Set(EFalse) != KErrNone )

        {

        LOGTEXT(_L("CProfiler::ConstructL - engine status property change failed"));

        }

	// create a server instance for clients to communicate with 

	iServer = CPServer::NewL(10,*this);

	// close the handle 

	me.Close();

	iTimer = CProfilerTimer::NewL(CActive::EPriorityStandard, *this);

	LOGTEXT(_L("CProfiler::ConstructL - Exit"));

    }

CProfilerSampleStream* CProfiler::GetSamplerStream()

    {

    return iUserStream;

    }

void CProfiler::HandleSamplerControllerReadyL()

    {

    // load settings

    // check if settings file already loaded

    if(!iSettingsFileLoaded)

        {

        // load default settings file

        LoadSettingsL();

        iSettingsFileLoaded = ETrue;

        }

    // notify engine's launcher(UI or PIProfilerLauncher) to continue launch

    RProcess::Rendezvous(KErrNone); 

    }

void CProfiler::NotifyRequesterForSettingsUpdate()

    {

    // set update status P&S property true => update needed on UI side

    iUpdateStatus.Set(ETrue);

    }

void CProfiler::HandleProfilerErrorChangeL(TInt aError)

    {

    LOGSTRING2("CProfiler::HandleProfilerErrorChangeL() - error received, %d", aError);

    // check if profiler running

    if(iState == RProfiler::ERunning)

        {

        // stop profiler if error occurred during the trace

        iEngineStatus.Set(aError);

        // stop samplers, NOTE! Writer plugins not stopped since 

        iSamplerHandler->StopSamplerPlugins();

        // stop debug output plugin and write the rest of the trace data to output

        if(iGeneralAttributes.iTraceOutput.CompareF(KOutputToDebugOutput) == 0)   

            {

            // write the rest of trace data only if debug output selected

            iWriterHandler->StopSelectedPlugin();

            }

        LOGSTRING2("CProfiler::HandleProfilerErrorChangeL - sampling stopped, going to state %d", RProfiler::EIdle);

        }

    }

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

// Gets a value from settings file for certain attribute.

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

void CProfiler::DoGetValueFromSettingsArray(CDesC8ArrayFlat* aLineArray, const TDesC8& aAttribute, TDes8& aValue)

    {

    LOGTEXT(_L("CProfiler::DoGetValueFromSettingsFile()"));

    _LIT8(KSettingItemSeparator, "=");

    // read a line of given array

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

        {

        // check if this line has a separator

        TInt sepPos = aLineArray->MdcaPoint(i).Find(KSettingItemSeparator);

        if (sepPos > 0)

            {

            // check that the element matches

            if (aLineArray->MdcaPoint(i).Left(sepPos).CompareF(aAttribute) == 0)

                {

                // get the value

                aValue.Copy(aLineArray->MdcaPoint(i).Right(aLineArray->MdcaPoint(i).Length()-sepPos-1));

                break;

                }

            }

        }

    }

void CProfiler::DoGetValueFromSettingsArray(CDesC8ArrayFlat* aLineArray, const TDesC8& aAttribute, TInt& aValue)

    {

    LOGTEXT(_L("CProfiler::DoGetValueFromSettingsFile()"));

    _LIT8(KSettingItemSeparator, "=");

    // read a line of given array

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

        {

        // check if this line has a separator

        TInt sepPos = aLineArray->MdcaPoint(i).Find(KSettingItemSeparator);

        if (sepPos > 0)

            {

            // check that the element matches

            if (aLineArray->MdcaPoint(i).Left(sepPos).CompareF(aAttribute) == 0)

                {

                // get the value                

                TLex8 parser(aLineArray->MdcaPoint(i).Right(aLineArray->MdcaPoint(i).Length()-sepPos-1));

                parser.Val(aValue);

                break;

                }

            }

        }

    }

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

TInt CProfiler::GetSamplerAttributesL(const RMessage2& aMessage)

    {

    TInt err(KErrNone);

    TInt pos(0);

    // get sampler count

    TInt count(iDefaultSamplerAttributesArray->Count());

    // write each of the default sampler plugin setting attributes over client-server session 

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

       {

       TSamplerAttributes attr = iDefaultSamplerAttributesArray->At(i);

       TPckgC<TSamplerAttributes> attrPckg(attr);

       // write a TSamplerAttributes container at a time

       aMessage.WriteL(0, attrPckg, pos);

       pos += attrPckg.Length();

       }

    aMessage.Complete(err);

    return err;

    }

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

TInt CProfiler::SetSamplerAttributesL(const RMessage2& aMessage)

    {

    TSamplerAttributes attr;

    TPckg<TSamplerAttributes> inAttr(attr);

    TInt err = aMessage.Read(0, inAttr, 0);    

    // apply the changes directly to a plugin

    iSamplerHandler->SetSamplerSettingsL(attr.iUid, attr);

    aMessage.Complete(err);

    return err;

    }

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

TInt CProfiler::GetGeneralAttributesL(const RMessage2& aMessage)

    {

    TPckgBuf<TGeneralAttributes> generalSettings( iGeneralAttributes );

    // write general attributes over client-server session

    TInt err = aMessage.Write(0, generalSettings);

    aMessage.Complete(err);

    return err;

    }

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

TInt CProfiler::SetGeneralAttributesL(const RMessage2& aMessage)

    {

    // read the general settings from message

    TGeneralAttributes attr;

    TPckg<TGeneralAttributes> inPckg(attr);

    TInt err = aMessage.Read(0, inPckg, 0);

    // copy to the general attributes

    iGeneralAttributes.iSaveFileDrive.Copy(attr.iSaveFileDrive);

    iGeneralAttributes.iTraceFilePrefix.Copy(attr.iTraceFilePrefix);

    iGeneralAttributes.iTraceOutput.Copy(attr.iTraceOutput);

    iGeneralAttributes.iTimedSamplingPeriod = attr.iTimedSamplingPeriod;

    aMessage.Complete(err);

    return err;

    }

TInt CProfiler::GetSamplerAttributeCountL(const RMessage2& aMessage)

    {

    // get the plugin array count and wrap it to TPckgBuf<>

    TPckgBuf<TInt> attributeCount(iDefaultSamplerAttributesArray->Count());

    // write general attributes over client-server session

    TInt err = aMessage.Write(0, attributeCount);

    aMessage.Complete(err);

    return err;

    }

TInt CProfiler::RefreshStatus(const RMessage2& aMessage)

    {

    TInt err(KErrNone);

    // update profiler status for requester

    iEngineStatus.Set(iState);

    aMessage.Complete(err);

    return err;

    }

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

TInt CProfiler::LoadSettingsL(/*const TDesC& configFile*/)

    {

	RFs fileServer;

	RFile file;

	TInt err(KErrNone);

	// connect to file server 

	err = fileServer.Connect();