// 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

//

#ifndef __TRACECORE_H__

#define __TRACECORE_H__

// Include files

#include <kernel/kernel.h>

#include "TraceCoreWriter.h"

// Forward declarations

class DTraceCoreSendReceive;

class DTraceCoreNotifier;

class DTraceCoreConfiguration;

class DTraceCoreInternalMessageHandler;

class DTraceCoreRouter;

class DTraceCoreHandler;

class DTraceCoreBTraceHandler;

class DTraceCorePrintfTraceHandler;

class DTraceCoreSettings;

class MTraceCoreActivation;

/**

 * TraceCore main class

 */

NONSHARABLE_CLASS( DTraceCore ) : public DBase

    {

public:

    /**

     * Gets the TraceCore instance.

     * NULL is returned when no instance is created.

     */

    IMPORT_C static DTraceCore* GetInstance();

    /**

     * Returns ETrue if tracecore is loaded already EFalse otherwies

     */

    IMPORT_C static TBool IsLoaded();

    /*

     * Destroy the static instance of tracecore and sets the instance to null

     */

    IMPORT_C static void DestroyTraceCore();

    /**

     * Gets the BTrace handler

     */

    static DTraceCoreBTraceHandler* GetBTraceHandler();

    /**

     * Gets the router

     */

    inline DTraceCoreRouter& GetRouter();

    /**

     * Gets the send-receive interface

     */

    inline DTraceCoreSendReceive& GetSendReceive();

    /**

     * Gets the trace core notifier

     */

    inline DTraceCoreNotifier& GetNotifier();

    /**

     * Registers a handler to TraceCore.

     *

     * @param aHandler The handler to be registered

     */

    TInt RegisterHandler( DTraceCoreHandler& aHandler );

    /**

     * Unregisters a handler from TraceCore.

     *

     * @param aHandler The handler to be unregistered

     */

    void UnregisterHandler( DTraceCoreHandler& aHandler );

    /**

     * Registers a writer to TraceCore.

     *

     * @param aWriter The writer to be registered

     */

    TInt RegisterWriter( DTraceCoreWriter& aWriter );

    /**

     * Unregisters a writer from TraceCore.

     *

     * @param aWriter The writer to be unregistered

     */

    void UnregisterWriter( DTraceCoreWriter& aWriter );

    /**

     * Registers a settings saver to TraceCore.

     *

     * @param aSettings The settings (saver) to be registered

     */

    TInt RegisterSettings( DTraceCoreSettings& aSettings );

    /**

     * Unregisters a settings saver from TraceCore.

     *

     * @param aSettings The Settings to be unregistered

     */

    void UnregisterSettings( DTraceCoreSettings& aSettings );

    /**

     * Registers an activation interface

     * 

     * @param aActivation The activation interface

     */

    TInt RegisterActivation( MTraceCoreActivation& aActivation );

    /**

     * Gets an activation interface for a specific component ID

     * 

     * @param aComponentID The component ID

     * @return The activation interface or NULL if none exist

     */

    MTraceCoreActivation* GetActivation( TUint32 aComponentID );

    /**

     * Starts to use the specific writer

     * 

     * @return KErrNone if successful, KErrNotSupported if type is not valid

     */

    IMPORT_C TInt SwitchToWriter( TWriterType aWriterType );     

    /**

     * Get current writer type

     * 

     * @return Current writer type

     */

    IMPORT_C TInt GetCurrentWriterType();

    /**

     * Returns pointer to TraceCore owned activation / deactivation TDfcQue object.

     */

    inline TDynamicDfcQue* ActivationQ() {

        return iActivationQ;

        }

    /**

     * Static method that returns pointer to TraceCore activation / deactivation dfc queue.

     */

    static TDynamicDfcQue* GetActivationQ() {

        DTraceCore* tCore = DTraceCore::GetInstance();

        if(tCore)

            return tCore->ActivationQ();

        else

            return NULL;

        }

    /**

     * @internalTechnology 

     * Sets the "Trace Dropped" flag

     * @param aTraceDropped ETrue if Trace Dropped, EFalse Otherwise

     */

    IMPORT_C void SetPreviousTraceDropped(TBool aTraceDropped);

    /**

     * @internalTechnology 

     * returns the state of the  "Trace Dropped" flag

     * @param none

     */

    IMPORT_C TBool PreviousTraceDropped() const; 

    /**

     * @internalTechnology

     * @return DTraceCore instance or NULL if creation failed.

     */

    IMPORT_C static DTraceCore* CreateInstance();

    /**

     * Reactivate all currently activated traces

     * @param none

     * @return KErrNone if refresh successful

     */

    TInt RefreshActivations();

    /**

     * Returns whether or not tracing is certified.

     * The certification status is checked when TraceCore is initialised and then stored for later use.

     * This stored value is used throughout the session, even if the status of the certificate changes.

     * This is done to avoid performance issues when performing the check with every trace outputted. 

     * @param none

     * @return ETrue if tracing is certified, EFalse otherwise

     */

    inline TBool IsTraceCertified() { return iTraceCertified; };

    /**

     * Get the active writer

     * @param none

     * @return a pointer to the current

     */

    IMPORT_C DTraceCoreWriter* GetActiveWriter(); 

private:

    /**

     * Constructor

     */

	DTraceCore();

	/**

	 * Destructor

	 */

	~DTraceCore();

    /**

     * Initializes trace core

     */

    TInt Init();

    /**

     * Starts the BTrace handler

     */

    TInt StartBTrace();

    /**

     * Starts the Printf trace handler

     */

    TInt StartPrintfTraceHandler();

    /**

     * Starts to use the first writer from the writers list

     */

    void SwitchToFirstWriter();

    /**

     * Forwards the active writer to handlers

     */

    void SetWriterToHandlers();

private:

    /**

     * TraceCore instance

     */

    static DTraceCore* iInstance;

    /**

     * List of writers

     */

    RPointerArray< DTraceCoreWriter > iWriters;

    /**

     * List of handlers

     */

    RPointerArray< DTraceCoreHandler > iHandlers;

    /**

     * List of activation interfaces

     */

    RPointerArray< MTraceCoreActivation > iActivations;

    /**

     * Message router

     */

    DTraceCoreRouter* iRouter;

    /**

     * Message sender / receiver

     */

    DTraceCoreSendReceive* iSendReceive;

    /**

     * Activation notifier

     */

    DTraceCoreNotifier* iNotifier;    

    /**

     * Configuration

     */

    DTraceCoreConfiguration* iConfiguration;    

    /**

     * Internal message handler

     */

    DTraceCoreInternalMessageHandler* iInternalMessageHandler;    

    /**

     * BTrace handler

     */

    DTraceCoreBTraceHandler* iBTrace;

    /**

     * Printf trace handler

     */

    DTraceCorePrintfTraceHandler* iPrintf;

    /**

     * TraceCore settings

     */

    DTraceCoreSettings* iTraceCoreSettings;

    /**

     * Writer that is currently active

     */

    DTraceCoreWriter* iActiveWriter;

    /**

     * Activation / Deactivation DFC queue.

     */

    TDynamicDfcQue* iActivationQ;

    /**

     * Previous missing trace flag

     */

    TBool iPreviousTraceDropped;

    /**

     * Trace certified flag.

     * The certification status is checked when TraceCore is initialised and then stored in this variable.

     * This stored value is used throughout the session, even if the status of the certificate changes.

     * This is done to avoid performance issues when performing the check with every trace outputted. 

     */

    TBool iTraceCertified;

    };

#endif

#include "TraceCore.inl"

// End of File