/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:    Implementation of the Common Recording Engine RTP convertions.*
*/




// INCLUDE FILES
#include <ipvideo/CRtpUtil.h>
#include <mmtsy_names.h>
#include <bsp.h>
#include "videoserviceutilsLogger.h"

// CONSTANTS
// None

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

// -----------------------------------------------------------------------------
// CRtpUtil::NewL()
// 
// -----------------------------------------------------------------------------
//
EXPORT_C CRtpUtil* CRtpUtil::NewL()
    {
    CRtpUtil* self = CRtpUtil::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CRtpUtil::NewLC()
// 
// -----------------------------------------------------------------------------
//
EXPORT_C CRtpUtil* CRtpUtil::NewLC()
    {
    CRtpUtil* self = new ( ELeave ) CRtpUtil;
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// -----------------------------------------------------------------------------
// CRtpUtil::CRtpUtil
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CRtpUtil::CRtpUtil()
    {
    // None
    }

// -----------------------------------------------------------------------------
// CRtpUtil::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CRtpUtil::ConstructL()
    {
    // None
    }

// -----------------------------------------------------------------------------
// Destructor
//
EXPORT_C CRtpUtil::~CRtpUtil()
// -----------------------------------------------------------------------------
    {
    // None
    }

// -----------------------------------------------------------------------------
// CRtpUtil::MakeBytesLC
// Returns: Buffer of four bytes where integer is stored
// -----------------------------------------------------------------------------
//
EXPORT_C HBufC8* CRtpUtil::MakeBytesLC( const TInt& aValue )
    {
    HBufC8* bytes = HBufC8::NewLC( KIntegerBytes );
    TPtr8 ptr( bytes->Des() );
    MakeBytesL( aValue, ptr );
    return bytes;
    }

// -----------------------------------------------------------------------------
// CRtpUtil::MakeBytes
// -----------------------------------------------------------------------------
//
EXPORT_C void CRtpUtil::MakeBytesL( const TInt& aValue, TDes8& aBuf )
    {
    User::LeaveIfError( MakeBytes( aValue, aBuf ) );
    }

// -----------------------------------------------------------------------------
// CRtpUtil::MakeBytes
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CRtpUtil::MakeBytes( const TInt& aValue, TDes8& aBuf )
    {
    if ( aBuf.MaxLength() >= KIntegerBytes )
        {
        aBuf.SetLength( KIntegerBytes );
        aBuf[0] = ( TUint8 )( aValue >> 24 );
        aBuf[1] = ( TUint8 )( aValue >> 16 );
        aBuf[2] = ( TUint8 )( aValue >> 8 );
        aBuf[3] = ( TUint8 )( aValue );
        return KErrNone;
        }
    
    return KErrUnderflow;
    }

// -----------------------------------------------------------------------------
// CRtpUtil::GetValueL
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CRtpUtil::GetValueL( const TDesC8& aBytes )
    {
    TInt value( KErrNotFound );
    GetValueL( aBytes, value );
    return value;
    }
    
// -----------------------------------------------------------------------------
// CRtpUtil::GetValueL
// -----------------------------------------------------------------------------
//
EXPORT_C void CRtpUtil::GetValueL( const TDesC8& aBytes, TInt& aValue )
    {
    User::LeaveIfError( GetValue( aBytes, aValue ) );
    }
    
// -----------------------------------------------------------------------------
// CRtpUtil::GetValue
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CRtpUtil::GetValue( const TDesC8& aBytes, TInt& aValue )
    {
    TUint value( 0 );
    TInt err( GetValue( aBytes, value ) );
    aValue = ( TInt )( value );
    return err;
    }
    
// -----------------------------------------------------------------------------
// CRtpUtil::GetValue
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CRtpUtil::GetValue( const TDesC8& aBytes, TUint& aValue )
    {
    if ( aBytes.Length() >= KIntegerBytes )
        {
        aValue = ( TUint )( aBytes[0] );
        aValue <<= 8;
        aValue |= ( TUint )( aBytes[1] );
        aValue <<= 8;
        aValue |= ( TUint )( aBytes[2] );
        aValue <<= 8;
        aValue |= ( TUint )( aBytes[3] );
        return KErrNone;
        }

    return KErrUnderflow;
    }
    
// -----------------------------------------------------------------------------
// CRtpUtil::SpecialPacketL
// Generates new special packet.
// -----------------------------------------------------------------------------
//
EXPORT_C HBufC8* CRtpUtil::SpecialPacketL( const TInt aType ) 
    {
    // Create buffer
    HBufC8* packet = HBufC8::NewLC( KSpecialPacketLength );
    TPtr8 ptr( packet->Des() );

    // Packet length (PTL)
    HBufC8* bytes = MakeBytesLC( KSpecialPacketLength );
    ptr.Copy( bytes->Des() );
    CleanupStack::PopAndDestroy( bytes );
            
    // Packet type
    ptr.Append( KCharSpace );
    ptr[KPacketTypeBytePoint] = ( TUint8 )( aType );
    
    // Dummy payload
    bytes = MakeBytesLC( KMaxTUint );
    ptr.Append( bytes->Des() );
    CleanupStack::PopAndDestroy( bytes );
    
    CleanupStack::Pop( packet );
    return packet;
    }

// -----------------------------------------------------------------------------
// CRtpUtil::GetMimeInfo
// Mime type info of propriatary RTP clip.
// -----------------------------------------------------------------------------
//
EXPORT_C void CRtpUtil::GetMimeInfo( TDes& aMime )
    {
    // Meta header has constant room as user info (IMSI) in old clips
    aMime.Copy( KRtpClipMimetype().Right( KUserIdLength ) );
    }

// -----------------------------------------------------------------------------
// CRtpUtil::GetMimeInfo
// Mime type info of propriatary RTP clip.
// -----------------------------------------------------------------------------
//
EXPORT_C void CRtpUtil::GetMimeInfo( TDes8& aMime )
    {
    // Meta header has constant room as user info (IMSI) in old clips
    aMime.Copy( KRtpClipMimetype().Right( KUserIdLength ) );
    }

// -----------------------------------------------------------------------------
// CRtpUtil::GetImeiL
// Read IMEI on phone HW, use dummy under WINS
// -----------------------------------------------------------------------------
//
EXPORT_C void CRtpUtil::GetImeiL( TDes& aImei )
    {
    aImei.Zero();  

#if defined( __WINS__ ) || defined( __WINSCW__ )
    _LIT( KEmulatorImei, "147407051877780445" );
    aImei.Copy( KEmulatorImei);
#else // __WINS__ || __WINSCW__

    RTelServer server;
    CleanupClosePushL( server );
    RMobilePhone phone;
    CleanupClosePushL( phone );
    GetMobilePhoneInfoL( server, phone );
    
    // Get IMEI code
    TRequestStatus status;
    RMobilePhone::TMobilePhoneIdentityV1 phoneIdentity;
    phone.GetPhoneId( status, phoneIdentity );
    User::WaitForRequest( status );
    if ( !status.Int() )
        {
        TPtrC imei( phoneIdentity.iSerialNumber );
        for ( TInt i( 0 ); i < imei.Length() && i < aImei.MaxLength(); i++ )
            {
            if ( TChar( imei[i] ).IsDigit() )
                {
                aImei.Append( TChar( imei[i] ) );
                }
            }
        }

    CleanupStack::PopAndDestroy( &phone );
    CleanupStack::PopAndDestroy( &server );

#endif // __WINS__ || __WINSCW__
    }
    
//-----------------------------------------------------------------------------
// CRtpUtil::GetMobilePhoneInfo
//-----------------------------------------------------------------------------
//    
void CRtpUtil::GetMobilePhoneInfoL( 
    RTelServer& aServer,
    RMobilePhone& aPhone )
    {
    TInt numPhone( 0 );
    RTelServer::TPhoneInfo phoneInfo;
    User::LeaveIfError( aServer.Connect() );
    User::LeaveIfError( aServer.LoadPhoneModule( KMmTsyModuleName ) );
    User::LeaveIfError( aServer.EnumeratePhones( numPhone ) );

    TInt found( KErrNotFound );
    TName tsyName( KNullDesC );
    for ( TInt i( 0 ); i < numPhone && found == KErrNotFound; i++ )
        {
        User::LeaveIfError( aServer.GetPhoneInfo( i, phoneInfo ) );
        User::LeaveIfError( aServer.GetTsyName( i, tsyName ) );
        if ( tsyName.CompareF( KMmTsyModuleName ) == 0 )
            {
            found = KErrNone;
            }
        }
        
    User::LeaveIfError( found );
    User::LeaveIfError( aPhone.Open( aServer, phoneInfo.iName ) );
    }
    
// End of File