/*

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

#include "DebOutWriterPlugin.h"	

#include <e32base.h>

//#include <piprofiler/EngineUIDs.h>

#include <piprofiler/ProfilerTraces.h>

#ifdef OST_TRACE_COMPILER_IN_USE

#include <OpenSystemTrace.h>

#include "DebOutWriterPluginTraces.h"

#endif

// engine properties

const TUid KEngineStatusPropertyCat={0x2001E5AD};

enum TEnginePropertyKeys

    {

    EProfilerEngineStatus = 8,

    EProfilerErrorStatus

    };

// CONSTANTS

// own UID

const TUid KDebOutWriterPluginUid = { 0x2001E5BA };

//  Member Functions

/*

 *

 *	Class CDebOutWriterPlugin implementation

 *

 */

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

{

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

	CDebOutWriterPlugin* self = new (ELeave) CDebOutWriterPlugin(KDebOutWriterPluginUid);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

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

    return self;

}

CDebOutWriterPlugin::CDebOutWriterPlugin(const TUid aImplementationUid) :

	iWriterType(aImplementationUid.iUid)

    {

    LOGTEXT(_L("CDebOutWriterPlugin::CDebOutWriterPlugin - entry"));

    isEnabled = EFalse;

    iWriterId = Id().iUid;

    LOGTEXT(_L("CDebOutWriterPlugin::CDebOutWriterPlugin - exit"));

    }

CDebOutWriterPlugin::~CDebOutWriterPlugin()

    {

    LOGTEXT(_L("CDebOutWriterPlugin::~CDebOutWriterPlugin - entry"));

    iErrorStatus.Close();

    if(iWriterHandler)

        {

        iWriterHandler->Cancel();

        delete iWriterHandler;

        }

    LOGTEXT(_L("CDebOutWriterPlugin::~CDebOutWriterPlugin - exit"));

    }    

void CDebOutWriterPlugin::ConstructL()

	{

	// second phase constructor, anything that may leave must be constructed here

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

	iWriterHandler = CDebOutWriterHandler::NewL(this);

    User::LeaveIfError(iErrorStatus.Attach(KEngineStatusPropertyCat, EProfilerErrorStatus));

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

	}

TInt CDebOutWriterPlugin::Start()

	{

	LOGTEXT(_L("CDebOutWriterPlugin::Start() - entry"));

#ifdef OST_TRACE_COMPILER_IN_USE

    TInt err(KErrNone);

	// activate traces on TraceCore

    RTcDriverParameters tcdp_ThreadIdentification;

    tcdp_ThreadIdentification.iComponentId = KOstTraceComponentID;

    tcdp_ThreadIdentification.iGroupId = CDEBOUTWRITERPLUGIN_PRINTDESCRIPTORASBASE64START;

    err = tcldd.ActivateTrace(tcdp_ThreadIdentification);

    tcdp_ThreadIdentification.iGroupId = CDEBOUTWRITERPLUGIN_PRINTDESCRIPTORASBASE64LINE;

    err = tcldd.ActivateTrace(tcdp_ThreadIdentification);

    tcdp_ThreadIdentification.iGroupId = CDEBOUTWRITERPLUGIN_PRINTDESCRIPTORASBASE64FIN;

    err = tcldd.ActivateTrace(tcdp_ThreadIdentification);

    tcdp_ThreadIdentification.iGroupId = CDEBOUTWRITERPLUGIN_PRINTDESCRIPTORASBASE64END;

    err = tcldd.ActivateTrace(tcdp_ThreadIdentification);

    RDebug::Print(_L("Debug output activated"));

    if(err != KErrNone)

        RDebug::Print(_L("TraceCore LDD API responded: %d"), err);

#endif

	LOGTEXT(_L("CDebOutWriterPlugin::Start() - exit"));

	return KErrNone;

	}

void CDebOutWriterPlugin::Stop()

	{

	LOGTEXT(_L("CDebOutWriterPlugin::Stop() - entry"));

	iWriterHandler->Stop();

#ifdef OST_TRACE_COMPILER_IN_USE

	TInt err(KErrNone);

    // activate traces on TraceCore

    RTcDriverParameters tcdp_ThreadIdentification;

    tcdp_ThreadIdentification.iComponentId = KOstTraceComponentID;

    tcdp_ThreadIdentification.iGroupId = CDEBOUTWRITERPLUGIN_PRINTDESCRIPTORASBASE64START;

    err = tcldd.DeactivateTrace(tcdp_ThreadIdentification);

    tcdp_ThreadIdentification.iGroupId = CDEBOUTWRITERPLUGIN_PRINTDESCRIPTORASBASE64LINE;

    err = tcldd.DeactivateTrace(tcdp_ThreadIdentification);

    tcdp_ThreadIdentification.iGroupId = CDEBOUTWRITERPLUGIN_PRINTDESCRIPTORASBASE64FIN;

    err = tcldd.DeactivateTrace(tcdp_ThreadIdentification);

    tcdp_ThreadIdentification.iGroupId = CDEBOUTWRITERPLUGIN_PRINTDESCRIPTORASBASE64END;

    err = tcldd.DeactivateTrace(tcdp_ThreadIdentification);

    RDebug::Print(_L("Debug output deactivated"));

    if(err != KErrNone)

        RDebug::Print(_L("TraceCore LDD API responded: %d"), err);

#endif

	LOGTEXT(_L("CDebOutWriterPlugin::Stop() - exit"));

	}

TUid CDebOutWriterPlugin::Id() const

	{

    LOGSTRING2("CDebOutWriterPlugin::Id(): 0x%X", KDebOutWriterPluginUid.iUid );

    return KDebOutWriterPluginUid;

	//return iDtor_ID_Key;

	}

TBool CDebOutWriterPlugin::GetEnabled()

	{

	return isEnabled;

	}

void CDebOutWriterPlugin::SetValue( const TWriterPluginValueKeys aKey,

                                    TDes& aValue )

    {

    TRAP_IGNORE( SetValueL( aKey, aValue ) );

    }

void CDebOutWriterPlugin::GetValue( const TWriterPluginValueKeys aKey,

                                    TDes& aValue )

    {

    TRAP_IGNORE( GetValueL( aKey, aValue ) );

    }

void CDebOutWriterPlugin::SetValueL( const TWriterPluginValueKeys aKey, TDes& /*aValue*/ )

{

	LOGTEXT(_L("CDebOutWriterPlugin::SetValueL - entry"));	

    switch( aKey )

        {

        case EWriterPluginEnabled:

            isEnabled = ETrue;

        	LOGTEXT(_L("CDebOutWriterPlugin::SetValueL - plugin enabled"));

        	break;

        case EWriterPluginDisabled:

            isEnabled = EFalse;

        	LOGTEXT(_L("CDebOutWriterPlugin::SetValueL - plugin disabled"));	

            break;

        case EWriterPluginSettings:

        	//result = StringLoader::LoadL(PROFILER_KERNEL_MODE_SAMPLER);

        	LOGTEXT(_L("CDebOutWriterPlugin::SetValueL - setting plugin settings"));	

        	break;

        default:

        	break;

        }

	LOGTEXT(_L("CDebOutWriterPlugin::SetValueL - exit"));	

}

TUint32 CDebOutWriterPlugin::GetWriterType()

	{

	return iWriterType;

	}

void CDebOutWriterPlugin::GetValueL( const TWriterPluginValueKeys aKey, TDes& aValue )

    {

    switch( aKey )

        {

        case EWriterPluginVersion:

        	GetWriterVersion(&aValue);

        	break;

        case EWriterPluginType:

        	break;

           default:

                break;

        }

    }

void CDebOutWriterPlugin::GetWriterVersion(TDes* aDes)

	{

	_LIT(KDebugOutputWriterVersion, "1.0.0");

	aDes->Append(KDebugOutputWriterVersion);

	}

void CDebOutWriterPlugin::DoCancel()

{

	LOGTEXT(_L("CDebOutWriterPlugin::DoCancel - entry"));

}

void CDebOutWriterPlugin::WriteData()

    {

    // Activate handler to write data from buffer to output

    LOGTEXT(_L("CDiskWriterPlugin::WriteData() - entry"));

    TRAP_IGNORE(iWriterHandler->StartL());

    LOGTEXT(_L("CDiskWriterPlugin::WriteData() - exit"));

    }

void CDebOutWriterPlugin::HandleError(TInt aError)

    {

    TInt err(KErrNone);

    err = iErrorStatus.Set(aError);

    if(err != KErrNone)

        {

        RDebug::Print(_L("CDiskWriterPlugin::HandleError() - error: %d"), err);

        }

    }

void CDebOutWriterPlugin::PrintDescriptorAsBase64(	TDesC8& aDes,

                                                    TRequestStatus* aStatus,

													TUint32 sampleTime,

													TBool aEmptying)

{

	LOGTEXT(_L("CDebOutWriterPlugin::PrintDescriptorAsBase64() - entry"));

	TUint len = aDes.Length();

	// we must wait for the sample tick to be printed, in case

	// prints are performed at user side, otherwise the kernel

	// prints will corrupt the data

	if(sampleTime != 0xffffffff)

	{

		TUint32 remains = sampleTime%1000;

		if(remains > 800) 

		{

			TTimeIntervalMicroSeconds32 timeToWait = ((1050-remains)*1000);

			User::After(timeToWait);

		}

	}

	TBuf16<75> buf;

	// Header

#ifdef OST_TRACE_COMPILER_IN_USE

    OstTrace0( PIPROFILER_TRACE_OUT, CDEBOUTWRITERPLUGIN_PRINTDESCRIPTORASBASE64START, 

            "<PIPROF>=================================================================" );

#else

	RDebug::Print(_L("<PIPROF>================================================================="));

#endif

	buf.Zero();

	// base64 encoding table

	const char uu_base64[64] =

	{

		'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',

		'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',

		'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',

		'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',

		'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',

		'o', 'p', 'q', 'r', 's', 't', 'u', 'v',

		'w', 'x', 'y', 'z', '0', '1', '2', '3',

		'4', '5', '6', '7', '8', '9', '+', '/'

	};

	TChar byte1, byte2, byte3, byte4;

	TUint8 count = 0x30;

	// base64 encoding 

	for(TUint i = 0, j = 0; i < len; i += 3, j = (j + 1) % 18) 

	{

    // byte 1

		byte1 = uu_base64[(aDes[i] >> 2) & 0x3F];

		// byte 2

		if(i+1 < len)

			byte2 = uu_base64[(aDes[i] << 4) & 0x3f | (aDes[i+1] >> 4)];

		else

			byte2 = uu_base64[(aDes[i] << 4) & 0x3f];

		// byte 3

		if(i+1 < len && i+2 < len)

			byte3 = uu_base64[(aDes[i+1] << 2) & 0x3f | (aDes[i+2] >> 6)];

		else if(i+1 < len)

			byte3 = uu_base64[(aDes[i+1] << 2) & 0x3f];

		else

			byte3 = '=';

		// byte 4

		if(i+2 < len) 

			byte4 = uu_base64[aDes[i+2] & 0x3f];

		else

			byte4 = '=';

		// append to buffer

		buf.Append(byte1);

		buf.Append(byte2);

		buf.Append(byte3);

		buf.Append(byte4);

		// output 72 chars / line

		if(j == 17) 

		{		

			// add check number at the end of line

			buf.Append(count);

#ifdef OST_TRACE_COMPILER_IN_USE

			OstTraceExt1( PIPROFILER_TRACE_OUT, CDEBOUTWRITERPLUGIN_PRINTDESCRIPTORASBASE64LINE, "<PIPROF>%S", &buf );

#else

			RDebug::Print(_L("<PIPROF>%S"),&buf);

#endif

			count++;

			if(count > 0x39)

				count = 0x30;

			buf.Zero();

		}

	}

#ifdef OST_TRACE_COMPILER_IN_USE

	OstTraceExt1( PIPROFILER_TRACE_OUT, CDEBOUTWRITERPLUGIN_PRINTDESCRIPTORASBASE64FIN, "<PIPROF>%S", &buf );

#else

	RDebug::Print(_L("<PIPROF>%S"),&buf);

#endif

	buf.Zero();

	// footer

#ifdef OST_TRACE_COMPILER_IN_USE

	OstTrace0( PIPROFILER_TRACE_OUT, CDEBOUTWRITERPLUGIN_PRINTDESCRIPTORASBASE64END, 

	        "<PIPROF>=================================================================" );

#else

	RDebug::Print(_L("<PIPROF>================================================================="));

#endif

	if(!aEmptying)

	    {

        if(aStatus != 0) 

            User::RequestComplete(aStatus,0);

	    }

	LOGTEXT(_L("CDebOutWriterPlugin::PrintDescriptorAsBase64() - exit"));

}

/*

 * 

 * Implementation of class CDebOutWriterHandler

 * 

 */

CDebOutWriterHandler::CDebOutWriterHandler(CDebOutWriterPlugin* aWriter) :

    CActive(EPriorityStandard)

    {

    LOGTEXT(_L("CDebOutWriterHandler::CDebOutWriterHandler - entry"));

    iWriter = aWriter;

    // set initial mode to non-stopping

    iStopping = EFalse;

    // add the handler to the active scheduler

    CActiveScheduler::Add(this);

    LOGTEXT(_L("CDebOutWriterHandler::CDebOutWriterHandler - exit"));

    }

CDebOutWriterHandler* CDebOutWriterHandler::NewL(CDebOutWriterPlugin* aWriter)

{

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

	CDebOutWriterHandler* self = new (ELeave) CDebOutWriterHandler(aWriter);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

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

    return self;

}

CDebOutWriterHandler::~CDebOutWriterHandler()

    {

	LOGTEXT(_L("CDebOutWriterHandler::~CDebOutWriterHandler - entry"));

    LOGTEXT(_L("CDebOutWriterHandler::~CDebOutWriterHandler - exit"));

    }    

void CDebOutWriterHandler::ConstructL()

	{

	}

void CDebOutWriterHandler::StartL()

	{

	LOGTEXT(_L("CDebOutWriterHandler::StartL - entry"));

    if(!IsActive())

        {

        LOGTEXT(_L("CDiskWriterHandler::StartL - is not active"));

        TBapBuf* nextBuf = iWriter->iStream->GetNextFilledBuffer();

        LOGSTRING2("CDiskWriterHandler::StartL - got next filled 0x%x",nextBuf);

        if(nextBuf != 0)

            {

            LOGTEXT(_L("CDiskWriterHandler::StartL - writing to file"));

            WriteBufferToOutput(nextBuf);

            }

        }

	LOGTEXT(_L("CDebOutWriterHandler::StartL - entry"));

	}

void CDebOutWriterHandler::Stop()

	{

	LOGTEXT(_L("CDebOutWriterHandler::Stop - entry"));

	// do write once more to write the logged data to output

    // set to stopping mode, needed for emptying the remaining full buffers

    iStopping = ETrue;

    // stop the timer

    Reset();

    // set mode back to non-stopping

    iStopping = EFalse;

	LOGTEXT(_L("CDebOutWriterHandler::Stop - exit"));

	}

void CDebOutWriterHandler::Reset()

    {

    // start writing new buffer if there is one available

    TBapBuf* nextBuf = iWriter->iStream->GetNextFilledBuffer();

    // empty the rest of the buffers synchronously

    while(nextBuf != 0)

        {

        if(nextBuf->iDataSize != 0)

            {

            LOGTEXT(_L("CDiskWriterHandler::Reset - writing to file"));

            iWriter->PrintDescriptorAsBase64(*(nextBuf->iBufDes),&iStatus,0xffffffff, iStopping);

            }

        // empty buffers when profiling stopped

        iWriter->iStream->AddToFreeBuffers(nextBuf);

        LOGTEXT(_L("CDiskWriterHandler::Reset - get next full buffer"));

        // start writing new buffer if there is one available

        nextBuf = iWriter->iStream->GetNextFilledBuffer();

        LOGSTRING2("CDiskWriterHandler::Reset - got next filled 0x%x",nextBuf);

        }

    }

void CDebOutWriterHandler::HandleFullBuffers()

    {

    LOGTEXT(_L("CDiskWriterHandler::HandleFullBuffers - entry"));

    // previous write operation has finished

    // release the previous buffer 

    iWriter->iStream->AddToFreeBuffers(iBufferBeingWritten);

    LOGTEXT(_L("CDiskWriterHandler::HandleFullBuffers - get next full buffer"));

    // start writing new buffer if there is one available

    TBapBuf* nextBuf = iWriter->iStream->GetNextFilledBuffer();

    if(nextBuf != 0)

        {

        LOGTEXT(_L("CDiskWriterHandler::HandleFullBuffers - writing to file"));

        if(nextBuf->iDataSize != 0)

            {

            WriteBufferToOutput(nextBuf);

            }

        } 

    LOGTEXT(_L("CDiskWriterHandler::HandleFullBuffers - exit"));

    }

void CDebOutWriterHandler::RunL()

    {

    // call function to complete full buffer handling

    HandleFullBuffers();

    }

void CDebOutWriterHandler::DoCancel()

    {

    }

void CDebOutWriterHandler::WriteBufferToOutput(TBapBuf* aBuf)

    {

    LOGTEXT(_L("CDebOutWriterHandler::WriteBufferToOutput - entry"));

    iBufferBeingWritten = aBuf;

    // set the data length just to be sure

    iBufferBeingWritten->iBufDes->SetLength(aBuf->iDataSize);

    LOGTEXT(_L("CDiskWriterPlugin::WriteBufferToOutput - writing to file"));

//    PrintBufferToOutput(iBufferBeingWritten, iStatus);

    iWriter->PrintDescriptorAsBase64(*(iBufferBeingWritten->iBufDes),&iStatus,0xffffffff, iStopping);

    // set AO back to active, until filled buffers are emptied 

    SetActive();

    LOGTEXT(_L("CDebOutWriterHandler::WriteBufferToOutput - exit"));

    }

// private