/*

* 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 <e32debug.h> // RDebug

#include <analyzetool/analyzetooltraceconstants.h>

#include "analyzetoolfastlog.h"

#include "atlog.h"

// Local time function.

TInt64 CurrentTime()

    {

    LOGSTR1( "ATFL CurrentTime()" );

    TTime time;

    time.UniversalTime();

    return time.Int64() - KMicroSecondsAt1970;

    }

TInt ATFastLogProcessStarted( const TDesC8& aProcessName,

                                 TUint aProcessId,

                                 TUint32 aIsDebug,

                                 const TDesC8& aAtoolVersion,

                                 const TDesC8& aApiVersion )

    {

    LOGSTR1( "ATFL ATFastLogProcessStarted()" );

    // PCS <Process name> <Process ID> <Time stamp> <Udeb> <Version>

    //Buffer to trace

    TBuf8<KProcessStartBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex );

    buffer.Append( KSpace );

    // PCS

    buffer.Append( KProcessStart );

    // process name

    buffer.Append( aProcessName );

    buffer.Append( KSpace );

    // process id

    buffer.AppendNum( aProcessId, EHex );

    buffer.Append( KSpace );

    // time stamp

    buffer.AppendNum( CurrentTime(), EHex ) ;

    buffer.Append( KSpace );

    // urel/udeb

    buffer.AppendNum( aIsDebug, EHex );

    buffer.Append( KSpace );

    // version

    buffer.AppendNum( KATTraceVersion, EHex );

    buffer.Append( KSpace );    

    // atool version

    buffer.Append( aAtoolVersion );

    buffer.Append( KSpace );

    // ATAPI version

    buffer.Append( aApiVersion );

    RDebug::RawPrint( buffer );

    return KErrNone;

    }

TInt ATFastLogProcessEnded( TUint aProcessId, 

                            TUint aHandleLeakCount )

    {

    LOGSTR1( "ATFL ATFastLogProcessEnded()" );

    // PCE

    if ( aHandleLeakCount > 0 )

    	{

        // HDL <Handle count>

        // Buffer to trace.

        TBuf8<KHandleLeakBufLength> buffer2;

        // AT indentifier

        buffer2.Append( KATIdentifier );

        // process id

        buffer2.AppendNum( aProcessId, EHex );

        buffer2.Append( KSpace );

        // HDL

        buffer2.Append( KHandleLeak );

        // leak count

        buffer2.AppendNum( aHandleLeakCount );

        RDebug::RawPrint( buffer2 );

    	}

    // Buffer to trace.

    TBuf8<KProcessEndBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex );

    buffer.Append( KSpace );

    // PCE

    buffer.Append( KProcessEnd );

    RDebug::RawPrint( buffer );

    return KErrNone;

    }

TInt ATFastLogDllLoaded( TUint aProcessId, 

                                        const TDesC8& aDllName,

                                        TUint32 aStartAddress,

                                        TUint32 aEndAddress )

    {

    LOGSTR1( "ATFL ATFastLogDllLoaded()" );

    // DLL <DLL name> <Memory start address> <Memory end address>

    // Buffer to trace.

    TBuf8<KDllLoadBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex  );

    buffer.Append( KSpace );

    // DLL

    buffer.Append( KDllLoad );

    // dll name

    buffer.Append( aDllName );

    buffer.Append( KSpace );

    // start adress

    buffer.AppendNum( aStartAddress, EHex );

    buffer.Append( KSpace );   

    //end adress

    buffer.AppendNum( aEndAddress, EHex );

    RDebug::RawPrint( buffer );

    return KErrNone;

    }

TInt ATFastLogDllUnloaded( TUint aProcessId, const TDesC8& aDllName, TUint32 aStartAddress,

                                       TUint32 aEndAddress )

    {

    LOGSTR1( "ATFL ATFastLogDllUnloaded()" );

    // DLU <DLL name> <Memory start address> <Memory end address>

    // Buffer to trace.

    TBuf8<KDllUnloadBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex  );

    buffer.Append( KSpace );

    // DLU

    buffer.Append( KDllUnload );

    // dll name

    buffer.Append( aDllName );

    buffer.Append( KSpace );

    // start adress

    buffer.AppendNum( aStartAddress, EHex );

    buffer.Append( KSpace );   

    //end adress

    buffer.AppendNum( aEndAddress, EHex );

    RDebug::RawPrint( buffer );

    return KErrNone;

    }

TInt ATFastLogMemoryAllocated( TUint aProcessId, TUint32 aMemAddress,

                                  TFixedArray<TUint32, KATMaxCallstackLength>& aCallstack,

                                  TInt aSize, TUint aThreadId )

    {

    LOGSTR1( "ATFL ATFastLogMemoryAllocated()" );

    // ALH <Memory address> <Allocation size> <Thread ID> 

    // <Call stack address count> <Call stack address> <Call stack address> ...

    // Buffer to trace.

    TBuf8<KMemAllocBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex  );

    buffer.Append( KSpace );

    // ALH

    buffer.Append( KMemoryAllocHeader );

    // memory adress

    buffer.AppendNum( aMemAddress, EHex );

    buffer.Append( KSpace );

    // allocation size

    buffer.AppendNum( aSize, EHex );

    buffer.Append( KSpace ); 

    // thread ID

    buffer.AppendNum( aThreadId, EHex );

    buffer.Append( KSpace );

    // Search call stack for address count.

	TInt addrCount(0);

	for ( TInt j = 0; j < aCallstack.Count() ; j++ )

		{

		if ( aCallstack.At(j) == 0 )

			break;

		addrCount++;

		}

	// Current position in call stack.

	TInt addrPos( 0 );

    // address count

    buffer.AppendNum( addrCount, EHex );

    TUint packetNumber( 1 );

    // Go through all call stack's memory addresses associated with

    // this memory allocation 

    for ( TInt j = 0; j < addrCount; j++ )

        {

        // ALF <Memory address> <Packet number> <Call stack address> <Call stack address> ...

        if ( buffer.Length() <= 0 )

            {

            // AT indentifier

            buffer.Append( KATIdentifier );

            // process id

            buffer.AppendNum( aProcessId, EHex  );

            buffer.Append( KSpace ); 

            // Create alloc fragment message header

            buffer.Append( KMemoryAllocFragment );

            buffer.AppendNum( aMemAddress, EHex );

            buffer.Append( KSpace );     

            buffer.AppendNum( packetNumber, EHex );

            // Increase packet number

            packetNumber++;

            }

        // Append call stack address.

        buffer.Append( KSpace );

        buffer.AppendNum( aCallstack.At( addrPos ), EHex );

        // Move the call stack position.

        addrPos++;

        // Check if buffer max length exceed

        if ( KLastItemLength + buffer.Length() >= KMemAllocBufLength )

            {

            // Log through debug channel 

            RDebug::RawPrint( buffer );

            // Empty trace buffer

            buffer.Delete( 0, buffer.MaxLength() );

            }

        }

    // Send last message if exists.

    if ( buffer.Length() > 0 )

        {

        RDebug::RawPrint( buffer );

        }

    return KErrNone;

    }

TInt ATFastLogMemoryFreed( TUint aProcessId, TUint32 aMemAddress, 

                              TFixedArray<TUint32, KATMaxFreeCallstackLength>& aFreeCallstack,

                              TUint aThreadId )

    {

    LOGSTR1( "ATFL ATFastLogMemoryFreed()" );

	// FRH <Memory address> <Thread ID> <Call stack address count> 

	// <Call stack address> <Call stack address> ...

	// Buffer to trace.

	TBuf8<KMemFreedBufLength> buffer;

	// AT indentifier

	buffer.Append( KATIdentifier );

	// process id

	buffer.AppendNum( aProcessId, EHex  );

	buffer.Append( KSpace );

	// FRH

	buffer.Append( KMemoryFreedHeader );

	// Append the start address of this allocation in the 32-bit (max 8 characters)

	// hexadecimal text format.

	buffer.AppendNum( aMemAddress, EHex );

	buffer.Append( KSpace );

	// thread ID

	buffer.AppendNum( aThreadId, EHex );

	buffer.Append( KSpace );

	// Search call stack for address count.

	TInt addrCount(0);

	for ( TInt j = 0; j < aFreeCallstack.Count() ; j++ )

		{

		if ( aFreeCallstack.At(j) == 0 )

			break;

		addrCount++;

		}

	// Current position in call stack.

	TInt addrPos( 0 );

	// address count.

	buffer.AppendNum( addrCount, EHex );

	TUint packetNumber( 1 );

	// Go through all call stack's memory addresses associated with

	// this memory allocation 

	for ( TInt j = 0; j < addrCount; j++ )

		{

		// FRF <Memory address> <Packet number> 

		// <Call stack address> <Call stack address> ...

		if ( buffer.Length() <= 0 )

			{               

			// Create alloc fragment message header

			buffer.Append( KMemoryFreedFragment );

			buffer.AppendNum( aMemAddress, EHex );

			buffer.Append( KSpace );

			buffer.AppendNum( packetNumber, EHex );

			// Increase packet number

			packetNumber++;

			}

		// Append call stack address.

		buffer.Append( KSpace );

		buffer.AppendNum( aFreeCallstack.At( addrPos ), EHex );

		// Move the call stack position.

		addrPos++;

		// Check if buffer max length exceed

		if ( KLastItemLength + buffer.Length() >= KMemFreedBufLength )

			{

			// Log through debug channel 

			RDebug::RawPrint( buffer );

			// Empty trace buffer

			buffer.Delete( 0, buffer.MaxLength() );

			}

		}

	// Send last message if exists.

	if ( buffer.Length() > 0 )

		{

		RDebug::RawPrint( buffer );

		}

    return KErrNone;   

    }

TInt ATFastLogMemoryReallocated( TUint aProcessId, TUint32 aMemAddressFree,  TUint32 aMemAddressAlloc,

                                  TFixedArray<TUint32, KATMaxCallstackLength>& aCallstack,

                                  TInt aSize, TUint aThreadId )

    {

    LOGSTR1( "ATFL ATFastLogMemoryReallocated()" );    

    // RAH <Freed memory address> <Allocated memory address> <Allocation size> <Thread ID>

    // <Call stack address count> <Call stack address> <Call stack address> ...

    // Buffer to trace.

    TBuf8<KMemReallocBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex  );

    buffer.Append( KSpace );

    // RAH

    buffer.Append( KMemoryReallocHeader );

    // memory adress freed

    buffer.AppendNum( aMemAddressFree, EHex );

    buffer.Append( KSpace );

    // memory adress allocated

    buffer.AppendNum( aMemAddressAlloc, EHex );

    buffer.Append( KSpace );

    // allocation size

    buffer.AppendNum( aSize, EHex );

    buffer.Append( KSpace ); 

    // thread ID

    buffer.AppendNum( aThreadId, EHex );

    buffer.Append( KSpace );

    // Search call stack for address count.

	TInt addrCount(0);

	for ( TInt j = 0; j < aCallstack.Count() ; j++ )

		{

		if ( aCallstack.At(j) == 0 )

			break;

		addrCount++;

		}

	// Current position in call stack.

	TInt addrPos( 0 );

    // address count

    buffer.AppendNum( addrCount, EHex );

    TUint packetNumber( 1 );

    // Go through all call stack's memory addresses associated with

    // this memory allocation 

    for ( TInt j = 0; j < addrCount; j++ )

        {

        // RAF <Freed memory address> <Allocated memory address> <Packet number>

        // <Call stack address> <Call stack address> ...

        if ( buffer.Length() <= 0 )

            {

            // AT indentifier

            buffer.Append( KATIdentifier );

            // process id

            buffer.AppendNum( aProcessId, EHex  );

            buffer.Append( KSpace ); 

            // Create alloc fragment message header

            buffer.Append( KMemoryReallocFragment );

            // memory adress freed

            buffer.AppendNum( aMemAddressFree, EHex );

            buffer.Append( KSpace );

            // memory adress allocated

            buffer.AppendNum( aMemAddressAlloc, EHex );

            buffer.Append( KSpace );

            // packet number

            buffer.AppendNum( packetNumber, EHex );

            // Increase packet number

            packetNumber++;

            }

        // Append call stack address.

        buffer.Append( KSpace );

        buffer.AppendNum( aCallstack.At( addrPos ), EHex );

        // Move the call stack position.

        addrPos++;

        // Check if buffer max length exceed

        if ( KLastItemLength + buffer.Length() >= KMemAllocBufLength )

            {

            // Log through debug channel 

            RDebug::RawPrint( buffer );

            // Empty trace buffer

            buffer.Delete( 0, buffer.MaxLength() );

            }

        }

    // Send last message if exists.

    if ( buffer.Length() > 0 )

        {

        RDebug::RawPrint( buffer);

        }

    return KErrNone;

    }

TInt ATFastLogThreadStarted( TUint aProcessId, TUint aThreadId )

    {

    LOGSTR1( "ATFL ATFastLogThreadStarted()" );

    // TDS <Thread ID>

    //Buffer to trace

    TBuf8<KThreadStartBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex  );

    buffer.Append( KSpace );

    // TDS

    buffer.Append( KThreadStart );

    // thread ID

    buffer.AppendNum( aThreadId, EHex );

    RDebug::RawPrint( buffer );

    return KErrNone;

    }

TInt ATFastLogThreadEnded( TUint aProcessId, TUint64 aThreadId )

    {

    LOGSTR1( "ATFL ATFastLogThreadEnded()" );

    // TDE <Thread ID>

    //Buffer to trace

    TBuf8<KThreadEndBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex  );

    buffer.Append( KSpace );

    // TDE

    buffer.Append( KThreadEnd );

    // thread ID

    buffer.AppendNum( aThreadId, EHex );

    RDebug::RawPrint( buffer );

    return KErrNone;

    }

TInt ATFastLogDeviceInfo( const TDesC8& aS60Version, const TDesC8& aChecksum)

    {

    LOGSTR1( "ATFL ATFastLogVersionsInfo()" );