// Copyright (c) 2007-2010 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:

// Trace Core

// 

#include "TraceCore.h"

#include "TraceCoreOstLddIf.h" 

#include "TraceCoreDebug.h"

#include "TraceCoreMediaIfCallback.h"

#include "TraceCoreSubscriber.h"

#include "TraceCoreMessageUtils.h"

#include "TraceCoreOstHeader.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "TraceCoreOstLddIfTraces.h"

#endif

/** 

 * Default DFC queue priority

 */

const TUint8 KDefaultDfcPriority = 3;

/**

 * Prints a message

 *

 * @param aMsg Reference to a message. 

 */

static void DebugPrintMsg( const TDesC8& /*aMsg*/ )            

    {

    // Message structure print

    }

static DTraceCoreOstLddIf* TraceCoreOstLddIf = NULL;

/**

 * Constructor

 */

DTraceCoreOstLddIf::DTraceCoreOstLddIf()

: DTraceCoreMediaIf( KMediaIfSendSupported | KMediaIfSendTraceSupported  )

, iReceiveDfc( DTraceCoreOstLddIf::ReceiveDfc, this, DTraceCore::GetActivationQ(), KDefaultDfcPriority )

, iStatus( 0 )

, iTraceCoreOstConnectionRegistered( EFalse )

, iTraceCoreOstConnection( NULL )

    {

    // No implementation in constructor

    }

/**

 * Destructor

 */

DTraceCoreOstLddIf::~DTraceCoreOstLddIf()

    {

    iCallback = NULL; 

    }

/**

 * Initializes the OstLddIf

 *

 * @param aCallBack Callback to TraceCore

 */

TInt DTraceCoreOstLddIf::Init( MTraceCoreMediaIfCallback& aCallback )

    {

    iCallback = &aCallback;

    TraceCoreOstLddIf = this;

    return KErrNone;

    }

/**

 * Handle incoming messages from OstConnection

 * 

 * @param aPtr Pointer to DTraceCoreOstLddIf class.

 */

void DTraceCoreOstLddIf::ReceiveDfc( TAny* aPtr )

    {

    DTraceCoreOstLddIf* TraceCoreOstLddIf = static_cast< DTraceCoreOstLddIf* >( aPtr );

    __ASSERT_DEBUG( TraceCoreOstLddIf != NULL, Kern::Fault( "DTraceCoreOstLddIf::ReceiveDfc - NULL", KErrGeneral ) );

    TraceCoreOstLddIf->ReceiveDfc();

    }

/**

 * Processes incoming OST messages

 */

void DTraceCoreOstLddIf::ReceiveDfc()

    {

    // Determine the message we received

    if ( iReceiveBuffer.Length() > OstHeader::OstBaseProtocol::KOstHeaderLengthOffset )

        {

        DebugPrintMsg ( iReceiveBuffer );

        if ( iCallback != NULL )

            {

            NotifyCallback();

            }

        }

    }

/**

 * Notifies the callback with the incoming message

 * 

 * @return one of symbian error codes

 */

void DTraceCoreOstLddIf::NotifyCallback()

    {

    // Header length is header size + remainders

    TInt headerLength = OstHeader::OstBaseProtocol::KOstBaseHeaderSize;

    // Check message ID

    TTraceMessage traceMsg;

    traceMsg.iMessageId = iReceiveBuffer[ OstHeader::OstBaseProtocol::KOstHeaderProtocolIdOffset ];

    // If message ID is TraceCore Protocol, the header is longer and the message ID might be in different place

    if (traceMsg.iMessageId == OstConstants::OstBaseProtocol::KOstTraceCoreProtocol)

        {

        headerLength += OstHeader::OstTraceCoreProtocol::KHeaderSize;

        // Subscriber protocol

        if (iReceiveBuffer[ OstHeader::OstBaseProtocol::KOstBaseHeaderSize + 

                            OstHeader::OstTraceCoreProtocol::KProtocolIdOffset ] == 

                OstHeader::OstTraceCoreProtocol::KSubscriberProtocol)

            {

            traceMsg.iMessageId = iReceiveBuffer[ OstHeader::OstBaseProtocol::KOstBaseHeaderSize + 

                                                  OstHeader::OstTraceCoreProtocol::KSubscriberIdOffset ];

            }

        }

    if ( iReceiveBuffer.Length() < headerLength ) 

        {

        headerLength = iReceiveBuffer.Length();

        }

    // Create TraceMessage

    TPtrC header( iReceiveBuffer.Ptr(), headerLength );

    TPtrC data( NULL, 0 );

    if ( iReceiveBuffer.Length() > headerLength ) {

        data.Set( iReceiveBuffer.Ptr() + headerLength, iReceiveBuffer.Length() - headerLength );

    }

    traceMsg.iMsgFormat = EMessageHeaderFormatOst;

    traceMsg.iHeader = &header;

    traceMsg.iData = &data;

    // Set Sender media to be same as receiver

    iCallback->SetSenderMedia(this);

    iCallback->MessageReceived( traceMsg );

    }

/**

 * Sends messages to USB OstConnection

 * 

 * @param aMsg Message to be sent.

 * @return KErrNone if send successful

 */

TInt DTraceCoreOstLddIf::Send( TTraceMessage& aMsg )

    {

    TInt ret = KErrArgument;

    if ( aMsg.iData != NULL )

        {

        ret = TTraceCoreMessageUtils::GetMessageLength( aMsg );

        if ( ret > 0 )

            {

            // First send the phone formatted start character

            // Send trace data and end trace

            SendData( aMsg );

            if ( aMsg.iHeader != NULL ) 

                {

                DebugPrintMsg( iSendBuffer );

                }

            else

                {

                DebugPrintMsg( *aMsg.iData );

                }

            }

        else

            {

            ret = KErrArgument;

            }

        }

    return ret;

    }

/**

 * Sends message to TraceCoreOstLdd

 * 

 * @param aMsg Message to be sent.

 */

void DTraceCoreOstLddIf::SendData( TTraceMessage& aMsg )

    {

    if ( aMsg.iHeader != NULL )

        {

        // Utility function is used to merge the data

        TInt ret = TTraceCoreMessageUtils::MergeHeaderAndData( aMsg, iSendBuffer );

        if ( ret == KErrNone )

            {

            if(iTraceCoreOstConnection)

                {

                iTraceCoreOstConnection->TxMessage( iSendBuffer );

                }

            }

        }

    else

        {

         // Header doesn't exists, all data is in data part

        }

    }

/**

 * Similar to send, except does not generate traces, since they would loop back to this function

 * 

 * @param aMsg Message to be sent.

 * @return KErrNone if send successful

 */

TInt DTraceCoreOstLddIf::SendTrace(const TDesC8& aMsg)

    {

    TInt ret(KErrNone);

    if ( iTraceCoreOstConnection && iTraceCoreOstConnectionRegistered )

        {

        iTraceCoreOstConnection->TxMessage(aMsg);

        }

    else

        {

        ret = KErrGeneral;

        }

    return ret;

    }

/**

 * GetSet

 * 

 * @param aFunc Function choosed (@see ETraceCoreOstLddIfGetSet)

 * @return TDfc* if aFunc is EGetDfc, TDes8* EGetBuf and 0 with ESetWriter.

 */

EXPORT_C TUint32 DTraceCoreOstLddIf::GetSet(TTraceCoreOstLddIfGetSet aFunc, TUint32 aParam)

    {

    OstTraceExt2( TRACE_FLOW, DTRACECOREOSTLDDIF_GETSET_ENTRY, "> DTraceCoreOstLddIf::GetSet aFunc:%d, aParam:%d", aFunc, aParam );

    TUint32 ret(0);

    switch(aFunc)

        {

        case EGetDfc:

            {

            TraceCoreOstLddIf->iTraceCoreOstConnectionRegistered = ETrue;

            ret = reinterpret_cast<TUint32>(&(TraceCoreOstLddIf->iReceiveDfc));

            break;

            }

        case EGetBuf:

            {

            ret = reinterpret_cast<TUint32>(&(TraceCoreOstLddIf->iReceiveBuffer));

            break;

            }

        case ESetWriter:

            {

            // Set Writer to XTI if parameter is 0, otherwise USB

            DTraceCore* traceCore = DTraceCore::GetInstance();

            if ( traceCore != NULL )

                {

                // TraceSwitch uses 0 for XTI writer and 1 to OST writer

                // So it is not mapping one to one to enum found in TraceCoreWriter.h

                // for example to EWriterTypeXTI = 1

                // See TraceCoreWriter.h

                if(aParam==0)

                    {

                    traceCore->SwitchToWriter(EWriterTypeXTI);

                    }

                else if(aParam==1)

                    {

                    traceCore->SwitchToWriter(EWriterTypeUSBPhonet);

                    }

                // For other writers (>2) we use same as the enum

                else if(aParam > EWriterTypeUSBPhonet)

                    {

                    traceCore->SwitchToWriter((TWriterType) aParam);

                    }

                }

            break;

            }

        case ERegister:

            {

            TraceCoreOstLddIf->iTraceCoreOstConnection = (MTraceCoreOstConnectionIf*)aParam;

            break;

            }    

        default:

            __ASSERT_DEBUG( EFalse, Kern::Fault( "DTraceCoreOstLddIf::GetSet: Default case!", KErrArgument ) );

            break;

        }

    return ret;

    }

// End of File