/*
* Copyright (c) 2002-2003 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 <e32math.h>
#include <e32hal.h>
#include "rtputil.h"

// ================= MEMBER FUNCTIONS =======================

// ---------------------------------------------------------------------------
// Parameters:
//  x   16-LSB of a positive integer
//  y   16-LSB of a positive integer  
//
// Function: The function is taking care of wrap. If the distance
//           these two number is longer than 1 << 15, then we assume
//           the larger one is the min16 of these two numbers.
//           
// Returns:
//    the min of the two input values 
// ---------------------------------------------------------------------------
TUint16 TRtpUtil::Min16( TUint16 aX, TUint16 aY )
    {
    if ( ( aX <= aY && aX > aY - ( 1 << 15 ) ) || ( aX >= aY + ( 1 << 15 ) ) )
        {
        return aX;
        }
    else
       {
        return aY;
       }
    }

// ---------------------------------------------------------------------------
// Parameters:
//  x   16-bit unsigned int 
//  y   16-bit unsigned int   
//
// Function: if the distance between aX and aY is longer than 1 << 15,
//           we assume these two number are wrapped.
// Returns:
//    1 if there is wrap around between this two values 
// ---------------------------------------------------------------------------
TUint16 TRtpUtil::Wrap16( TUint16 aX, TUint16 aY )
    {
    if ( aX < aY - ( 1 << 15 ) || aY < aX - ( 1 << 15 ) )
        {
        return 1;
        }
    else
        {
        return 0;
        }
    }

// ---------------------------------------------------------------------------
// Parameters:
//  x   32-LSB of a positive integer
//  y   32-LSB of a positive integer 
// ---------------------------------------------------------------------------
TUint32 TRtpUtil::Sub32( TUint32 aX, TUint32 aY )
    {
    if ( aX < aY )
        return ( 0xFFFFFFFF - ( aY - aX ) + 1 );
    else
        return ( aX - aY );
    }

// ---------------------------------------------------------------------------
// TUint8* TRtpUtil::Strcpy()
// 
// ---------------------------------------------------------------------------
//
TUint8* TRtpUtil::Strcpy( TUint8* aTarget, const TUint8* aSource )
    {
    TPtr8 ptrTarget( aTarget, ( User::StringLength( aSource ) ) + 1 );

    ptrTarget.SetMax();
    ptrTarget.Copy( _L8( aSource ) );
    ptrTarget.ZeroTerminate();

    return aTarget;
    }

// ---------------------------------------------------------------------------
// TUint TRtpUtil::GtGetTime()
// Return time elapse from 01/01/1970 in tenth of millsecond
// ---------------------------------------------------------------------------
//
TUint TRtpUtil::GtGetTime()
    {
    TTimeIntervalMicroSeconds32 uspertick;     // scale factor: number of microseconds per system tick
    UserHal::TickPeriod( uspertick );
    return static_cast<TUint>( uspertick.Int() // number of '1us periods' per system tick 
            * User::TickCount()                // number of system ticks
            / 100 );                           // in tenths of ms, note still wraps after 5 days.
    }

// ---------------------------------------------------------------------------
// TUint32 TRtpUtil::Random()
// 
// ---------------------------------------------------------------------------
//
TUint32 TRtpUtil::Random( TInt64& aSeed )
    {
    TInt32 rand = Math::Rand( aSeed );
    return Abs( rand );
    }

// ---------------------------------------------------------------------------
// TReal TRtpUtil::FloatRandom()
// 
// ---------------------------------------------------------------------------
//
TReal TRtpUtil::FloatRandom( TInt64& aSeed )
    {
    TReal rand = Math::FRand( aSeed );
    return Abs( rand );
    }


#ifdef _DEBUG 
// ---------------------------------------------------------------------------
// TInt TRtpUtil::Print()
// 
// ---------------------------------------------------------------------------
//
void TRtpUtil::Print(  const TDesC8& aP )
    {
    const TUint KPrintLength = 5;
    const TUint KPrintExtLength = 20;
    TChar notAllowed('%');
	if ( aP.Locate( notAllowed ) == KErrNotFound )
		{
		HBufC8* msg = NULL;
	    TRAPD( msgError, msg = HBufC8::NewL( aP.Length() + KPrintExtLength ) );
	    if ( msgError != KErrNone )
	        return ;

	    TPtr8 b( msg->Des() );

	    b.Append( _L8( "RTP : " ) );
	    //    b = p;
	    //apend current time
	    b.AppendFormat( _L8( "%u - " ), ( TUint * ) ( TRtpUtil::GtGetTime() ) );

	    b.Append( aP );
	    b.Append( _L8( "\n" ) );

	    TInt ptrSize = static_cast <TInt>( b.Size() );
	    TBuf<256> buf;
	    if ( ptrSize < buf.MaxSize() )
	    	{
	   	    buf.Copy( b );
		    RDebug::Print( buf );
	    	}
	    else
	    	{
	    	_LIT(KRTPWarning, "RTP: Text is too long to be print all");
	    	RDebug::Print( KRTPWarning );	
	    	buf.Copy( b.Left( buf.MaxSize() - KPrintLength ));
	    	}
	    delete msg;
		}
	else
		{
		_LIT(KRTPWarning, "RTP: Text contains not allowed characters, log ignored");
		RDebug::Print( KRTPWarning );							
		}	

    }

// ---------------------------------------------------------------------------
// TInt TRtpUtil::Print()
// 
// ---------------------------------------------------------------------------
//
void TRtpUtil::Print(  const TDesC8& aP, TInt aValue )
    {
    const TUint KPrintLength = 5;
    const TUint KPrintExtLength = 106;
    TChar notAllowed('%');
	if ( aP.Locate( notAllowed ) == KErrNotFound )
		{
		HBufC8* msg = NULL;
	    TRAPD( msgError, msg = HBufC8::NewL( aP.Length() + KPrintExtLength ) );
	    if ( msgError != KErrNone )
	        return;

	    TPtr8 b( msg->Des() );
	    b.Append( _L8( "RTP : " ) );

	    //    b = p;
	    //apend current time
	    b.AppendFormat( _L8( "%u - " ), ( TUint * ) ( TRtpUtil::GtGetTime() ) );
	    b.Append( aP );
	    b.AppendFormat( _L8( "= <%d> " ), aValue );
	    b.Append( _L8( "\n" ) );

		TInt ptrSize = static_cast <TInt>( b.Size() );
	    TBuf<256> buf;
	    if ( ptrSize < buf.MaxSize() )
	    	{
	   	    buf.Copy( b );
		    RDebug::Print( buf );
	    	}
	    else
	    	{
	    	_LIT(KRTPWarning, "RTP: Text is too long to be print all");
	    	RDebug::Print( KRTPWarning );	
	    	buf.Copy( b.Left( buf.MaxSize() - KPrintLength ));
	    	}
	    delete msg;
		}
	else
		{
		_LIT(KRTPWarning, "RTP: Text contains not allowed characters, log ignored");
		RDebug::Print( KRTPWarning );							
		}	
    }
   
    
#endif


#ifdef _RTP_LOG_FILE 

// ---------------------------------------------------------------------------
// TInt TRtpUtil::Print()
// 
// ---------------------------------------------------------------------------
//
void TRtpUtil::Print( const TDesC& aName, const TDesC8& aP )
    {
    HBufC8* msg = NULL;
    TRAPD( msgError, msg = HBufC8::NewL( aP.Length() + 20 ) );
    if ( msgError != KErrNone )
        return;

    TPtr8 b( msg->Des() );

    b.Append( _L8( "RTP : " ) );
    //    b = p;
    //apend current time
    b.AppendFormat( _L8( "%u - " ), ( TUint * ) ( TRtpUtil::GtGetTime() ) );

    b.Append( aP );
    b.Append( _L8( "\n" ) );

    TFileUtil::LogMessage( aName, b );

    delete msg;
    }

// ---------------------------------------------------------------------------
// TInt TRtpUtil::Print()
// 
// ---------------------------------------------------------------------------
//
void TRtpUtil::Print( const TDesC& aName, const TDesC8& aP, TUint32 aValue )
    {
    HBufC8* msg = NULL;
    TRAPD( msgError, msg = HBufC8::NewL( aP.Length() + 106 ) );
    if ( msgError != KErrNone )
        return;

    TPtr8 b( msg->Des() );
    b.Append( _L8( "RTP : " ) );

    //    b = p;
    //apend current time
    b.AppendFormat( _L8( "%u - " ), ( TUint * ) ( TRtpUtil::GtGetTime() ) );
    b.Append( aP );
    b.AppendFormat( _L8( "<%d> " ), aValue );
    b.Append( _L8( "\n" ) );

    TFileUtil::LogMessage( aName, b );


    delete msg;
	}

// ---------------------------------------------------------------------------
// TInt TFileUtil::LogMessage()
// 
// ---------------------------------------------------------------------------
//
TInt TFileUtil::LogMessage( const TFileName& name, const TDesC8& mess )
    {
    RFs fs;
    RFile file;
    TFileName nameWithPath;

    nameWithPath = KDefaultPath;
    nameWithPath.Append( name );
    nameWithPath.ZeroTerminate();
    TInt err = fs.Connect();

    if ( err != KErrNone )
        return err;

    err = file.Open( fs, nameWithPath, EFileStream | EFileWrite | EFileShareExclusive );
    if ( err == KErrNotFound )
        err = file.Create( fs, nameWithPath, EFileStream | EFileWrite | EFileShareExclusive );
    if ( err != KErrNone )
        return err;

    TInt off( 0 );
    err = file.Seek( ESeekEnd, off );
    if ( err != KErrNone )
        return err;

    file.Write( mess );
    file.Flush();
    file.Close();
    fs.Close();

    return KErrNone;
    }

// ---------------------------------------------------------------------------
// TInt TFileUtil::InitLogFile()
// 
// ---------------------------------------------------------------------------
//
TInt TFileUtil::InitLogFile( const TFileName& name )
    {
    RFs fs;
    RFile file;
    TFileName nameWithPath;

    nameWithPath = KDefaultPath;
    nameWithPath.Append( name );
    nameWithPath.ZeroTerminate();
    TInt err = fs.Connect();

    if ( err != KErrNone )
        return err;

    err = file.Replace( fs, nameWithPath, EFileStream | EFileWrite | EFileShareExclusive );
    if ( err != KErrNone )
        return err;

    file.Close();
    fs.Close();

    return KErrNone;
    }
#endif



//  End of File