/*

* 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:  

*

*/

#ifndef __PROFILER_SESSION_H__

#define __PROFILER_SESSION_H__

#include <e32base.h>

#include <e32svr.h>

#include <piprofiler/ProfilerConfig.h>

#include <piprofiler/ProfilerVersion.h>

#include <piprofiler/ProfilerTraces.h>

#include <piprofiler/ProfilerAttributes.h>

_LIT(KProfilerName,"PIProfilerEngine");

/**

 * The RProfiler class provides a functional interface to the sampling profiler.

 *

 * The engine must already be running for this interface to work, this can be

 * achieved by executing PIProfilerEngine.exe. The control methods are all static, and 

 * require no other context.

 */

NONSHARABLE_CLASS( RProfiler ) : public RSessionBase

	{

public:

	enum TCommand {	

		// profiler controls

		EStartSampling = 1,

		EStartTimedSampling,

		EStopSampling,

//		ELoadSettings,

		EExitProfiler,

		EFinalise,

		EAttachClient,

		ERemoveClient,

		// general attributes

		EGetGeneralAttributes,

		EGetSamplerAttributes,

		EGetSamplerAttributeCount,

		ESetGeneralAttributes,

		ESetSamplerAttributes,

		// generic settings

		ESetTraceFilePrefix, 

		ESetTraceFileDrive,

		EGetSamplerVersion,

		EGetFileName,

		EGetActiveWriter,

		ERefreshProfilerStatus

		};

	enum TSamplerState {

		EIdle = 0, 

		EInitializing, 

		ERunning, 

		EStopping, 

		EStopped

		};

	enum TProfilingMode

	    {

	    EProfilingModeNormal = 0,

	    EProfilingModeTimed

	    };

public:

	/*

	 * 

	 *  Methods for commanding Profiler Engine

	 *   

	 */

	// get general settings

	static inline TInt GetGeneralAttributes(TGeneralAttributes& aAttributes);

	// get samplers; names, settings, states, descriptions etc. in one array containing all sampler attributes

	static inline TInt GetSamplerAttributes(CArrayFixFlat<TSamplerAttributes>& aAttributeArray);

	// save settings back to engine and plugins

	static inline TInt SetGeneralAttributes(TGeneralAttributes aAttributes);

	// save settings back to engine and plugins

    static inline TInt SetSamplerAttributes(TSamplerAttributes aAttributes);

    // refresh profiler engine status

    static inline TInt RefreshProfilerStatus();	

    /** Start sampling */

	static inline TInt StartSampling(TProfilingMode aProfilingMode = EProfilingModeNormal);

	/** Stop sampling */

	static inline TInt StopSampling();

    /** Load settings */

//    static inline TInt LoadSettings(TDesC& aSettingsFile);

	/** Exit profiler */

	static inline TInt ExitProfiler();

	/** Get file name */

	static inline TInt GetFileName(TDes&);

    /** Get active writer */

    static inline TInt GetActiveWriter(TDes&);

	/** Perform a test case */

	static inline TInt Test(TUint32 testCase);

	/** Issue a control request to the engine without data*/

	static inline TInt ControlState(TCommand aRequest);

	/** Issue a control request to the engine with descriptor data to write there*/

	static inline TInt ControlWrite(TCommand aRequest,TDesC& data);

	/** Issue a control request to the engine with numeric and descriptor data to write there*/

	static inline TInt ControlWrite(TCommand aRequest,TInt numData, TDesC& data);

	/** Issue a control request to read descriptor data from the engine*/

	static inline TInt ControlRead(TCommand aRequest,TDes& data);

	/** Actually sends the message to profiler engine*/	

	static inline TInt PerformControl(	TCommand aRequest,

										TDesC* fromDescriptor = NULL,

										TUint32 numData1 = 0,

										TDes* toDescriptor = NULL,

										TUint32 numData2 = 0xffffffff);

	static inline TInt AttachClient();

	static inline TInt RemoveClient();

private:

	inline RProfiler();

	};

inline RProfiler::RProfiler()

	{}

//

// Connect to the profiler engine, and issue the control request if successful

//

inline TInt RProfiler::ControlState(TCommand aRequest)

    { return PerformControl(aRequest); }

//

// Connect to the profiler engine, and issue the control request if successful

//

inline TInt RProfiler::ControlWrite(TCommand aRequest,TDesC& data)

    { return PerformControl(aRequest,&data,0); }

//

// Connect to the profiler engine, and issue the control request if successful

//

inline TInt RProfiler::ControlWrite(TCommand aRequest,TInt numData, TDesC& data)

    { return PerformControl(aRequest,&data,numData); }

//

// Connect to the profiler engine, and issue the control request if successful

//

inline TInt RProfiler::ControlRead(TCommand aRequest,TDes& data)

    { return PerformControl(aRequest,0,0,&data); }

inline TInt RProfiler::PerformControl(TCommand aRequest,TDesC* fromDescriptor,TUint32 numData1,TDes* toDescriptor,TUint32 numData2)

	{

	LOGTEXT(_L("Creating a session to profiler"));

	RProfiler p;

	TUint count(0);

	TInt r(KErrNone);

	// in boot measurement mode, count until 30s

	#ifdef PROFILER_BOOT_MEASUREMENT

	while(count < 60)

	#else

	while(count < 6)

	#endif

		{

		r = p.CreateSession(KProfilerName, TVersion(), 0);

		if (r == KErrNone)

			{

			LOGSTRING2("Succeeded, sending a message %d", aRequest);

			LOGSTRING5(" - parameters 0x%x 0x%x 0x%x 0x%x",fromDescriptor,numData1,toDescriptor,numData2);

			TInt err = KErrNone;

			TIpcArgs a;

			a.Set(0,fromDescriptor);

			a.Set(1,numData1);

			a.Set(2,toDescriptor);

			a.Set(3,numData2);

			err = p.SendReceive(aRequest,a);

			p.RSessionBase::Close();

			if(err != KErrNone)

				{

				LOGSTRING2("Profiler responded with an error - code %d !!",err);		

				return err;

				}

			else

				{ 

				LOGTEXT(_L("OK, message sent, closing"));

				return KErrNone;

				}

			}

		LOGSTRING2("Error in opening session to profiler - code %d !!",r);

		//#ifdef PROFILER_BOOT_MEASUREMENT

		// there was an error contacting the Profiler

		// indicates that the server is most probably not up

		// however, since it should be(unless some resource is not yet ready)

		// we can just wait

		User::After(500000); // wait 1/2 s

		count++;

		//#else

		// exit immediately on error

		//return r;

		//#endif

		}

	return r;

	}

// the new UI access methods

inline TInt RProfiler::GetGeneralAttributes(TGeneralAttributes& aAttributes)

    {

#ifdef _TEST_

    _LIT(KDefaultTraceOutput,"debug_output");

    _LIT(KDefaultTraceFilePrefix,"PIProfiler_#");

    _LIT(KDefaultTraceFileSaveDrive,"E:\\");

    aAttributes.iTraceOutput.Copy(KDefaultTraceOutput);

    aAttributes.iTraceFilePrefix.Copy(KDefaultTraceFilePrefix);

    aAttributes.iSaveFileDrive.Copy(KDefaultTraceFileSaveDrive);

#else

    LOGTEXT(_L("Creating a session to profiler"));

    RProfiler p;

    TInt r(KErrNone);

    r = p.CreateSession(KProfilerName, TVersion(), 0);

    if (r == KErrNone)

        {

        LOGSTRING2("Succeeded, sending a message %d", EGetGeneralAttributes);

        TPckg<TGeneralAttributes> attrPckg(aAttributes);

        TIpcArgs a(&attrPckg);

        r = p.SendReceive(RProfiler::EGetGeneralAttributes,a);

        p.RSessionBase::Close();

        if(r != KErrNone)

            {

            LOGSTRING2("Profiler responded with an error - code %d !!",r);        

            return r;

            }

        else

            { 

            LOGTEXT(_L("OK, message sent, closing"));

            return KErrNone;

            }

        }

#endif

    return r;   // return error code  

    }

inline TInt RProfiler::GetSamplerAttributes(CArrayFixFlat<TSamplerAttributes>& aAttributes)

    {

#ifdef _TEST_

    _LIT(KDefaultTraceOutput,"debug_output");

    _LIT(KDefaultTraceFilePrefix,"PIProfiler_#");

    _LIT(KDefaultTraceFileSaveDrive,"E:\\");

    aAttributes.iTraceOutput.Copy(KDefaultTraceOutput);

    aAttributes.iTraceFilePrefix.Copy(KDefaultTraceFilePrefix);

    aAttributes.iSaveFileDrive.Copy(KDefaultTraceFileSaveDrive);

#else

    // do receive stream of TSamplerAttributes

    LOGTEXT(_L("Creating a session to profiler"));

    RProfiler p;

    TInt r(KErrNone);

    r = p.CreateSession(KProfilerName, TVersion(), 0);

    if (r == KErrNone)

        {

        TInt attrCount(0);

        TPckg<TInt> pckg(attrCount);

        TIpcArgs args(&pckg);

        r = p.SendReceive(RProfiler::EGetSamplerAttributeCount, args);

        HBufC8* buffer = HBufC8::NewL(attrCount*sizeof(TSamplerAttributes));

        TPtr8 ptr(buffer->Des());

        TIpcArgs args2(&ptr);

        r = p.SendReceive(RProfiler::EGetSamplerAttributes, args2);

        TInt len(ptr.Length());

        TInt pos(0);

        while (pos != len)

           {

           TPckgBuf<TSamplerAttributes> attrPckg;

           attrPckg.Copy(ptr.Mid(pos, attrPckg.Length()));

           pos += attrPckg.Length();

           aAttributes.AppendL(attrPckg());

           }

        p.RSessionBase::Close();

        if(r != KErrNone)

            {

            LOGSTRING2("Profiler responded with an error - code %d !!",r);        

            return r;

            }

        else

            { 

            LOGTEXT(_L("OK, message sent, closing"));

            return KErrNone;

            }

        }

#endif

    return KErrNone; 

    }

inline TInt RProfiler::SetGeneralAttributes(TGeneralAttributes aAttributes)

    {

    // do receive stream of TSamplerAttributes

    LOGTEXT(_L("Creating a session to profiler"));

    RProfiler p;

    TInt r(KErrNone);

    r = p.CreateSession(KProfilerName, TVersion(), 0);

    if (r == KErrNone)

        {

        TPckg<TGeneralAttributes> attrPckg(aAttributes);

        TIpcArgs a(&attrPckg);

        r = p.SendReceive(RProfiler::ESetGeneralAttributes,a);

        p.RSessionBase::Close();

        if(r != KErrNone)

            {

            LOGSTRING2("Profiler responded with an error - code %d !!",r);        

            return r;

            }

        else

            { 

            LOGTEXT(_L("OK, message sent, closing"));

            return KErrNone;

            }

        }

    return r; 

    }

// save settings back to engine and plugins

inline TInt RProfiler::SetSamplerAttributes(TSamplerAttributes aAttributes)

    {

    // do receive stream of TSamplerAttributes

    LOGTEXT(_L("Creating a session to profiler"));

    RProfiler p;

    TInt r(KErrNone);

    r = p.CreateSession(KProfilerName, TVersion(), 0);

    if (r == KErrNone)

        {

        TPckg<TSamplerAttributes> attrPckg(aAttributes);

        TIpcArgs a;

        a.Set(0,&attrPckg);

        r = p.SendReceive(RProfiler::ESetSamplerAttributes,a);

        p.RSessionBase::Close();

        if(r != KErrNone)

            {

            LOGSTRING2("Profiler responded with an error - code %d !!",r);        

            return r;

            }

        else

            { 

            LOGTEXT(_L("OK, message sent, closing"));

            return KErrNone;

            }

        }

    return r; 

    }

inline TInt RProfiler::RefreshProfilerStatus()

    {return ControlState(RProfiler::ERefreshProfilerStatus); }

inline TInt RProfiler::StartSampling(RProfiler::TProfilingMode aProfilingMode)

	{

    RProfiler::TCommand command = RProfiler::EStartSampling;

    if( aProfilingMode == RProfiler::EProfilingModeTimed )

        {

        command = RProfiler::EStartTimedSampling;

        }    

    return ControlState(command);

	}

inline TInt RProfiler::StopSampling()

	{return ControlState(RProfiler::EStopSampling);}

inline TInt RProfiler::ExitProfiler()

	{return ControlState(RProfiler::EExitProfiler);}

inline TInt RProfiler::AttachClient()

    {return ControlState(RProfiler::EAttachClient);}

inline TInt RProfiler::RemoveClient()

    {return ControlState(RProfiler::ERemoveClient);}

inline TInt RProfiler::GetFileName(TDes& fileName)

	{return ControlRead(EGetFileName,fileName);}

inline TInt RProfiler::GetActiveWriter(TDes& writerDes)

    {return ControlRead(EGetActiveWriter,writerDes);}

#endif // __PROFILER_SESSION_H__