/*

* 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 RTP file recognizer class.*

*/

// INCLUDE FILES

#include "CRtpClipRecognizer.h"

#include <ecom/ImplementationProxy.h>

#include <mmtsy_names.h>

// CONSTANTS

const TInt KIntegerBytes( 4 );

const TInt KStringLengthBytes( 1 );

const TInt KMaxMetaHeaderLength( 2048 );

const TInt KMetaLengthPoint( 0 );

const TInt KVersionFieldShift( 4 );

const TInt KPostRuleFieldShift( 16 );

const TInt KAttributesPoint( KMetaLengthPoint + KIntegerBytes ); // 4

const TInt KPlayCountPoint( KAttributesPoint + KIntegerBytes );	 // 8

const TInt KPlaySpotPoint( KPlayCountPoint + KIntegerBytes );	 // 12

const TInt KReservedPoint1( KPlaySpotPoint + KIntegerBytes );	 // 16

const TInt KReservedPoint2( KReservedPoint1 + KIntegerBytes );	 // 20

const TInt KReservedPoint3( KReservedPoint2 + KIntegerBytes );	 // 24

const TInt KReservedPoint4( KReservedPoint3 + KIntegerBytes );	 // 28

const TInt KStartTimePoint( KReservedPoint4 + KIntegerBytes );	 // 32

const TInt KEndTimePoint( KStartTimePoint + 2 * KIntegerBytes ); // 40

const TInt KDurationPoint( KEndTimePoint + 2 * KIntegerBytes );	 // 48

const TInt KSeekArrayPoint( KDurationPoint + KIntegerBytes );	 // 52

const TInt KUserIdPoint( KSeekArrayPoint + KIntegerBytes );		 // 56

const TInt KDeviceInfoPoint( KUserIdPoint + KStringLengthBytes + // 72

                             KUserIdLength );

const TInt KMaxRtpPostRule( 3 );

const TInt KMinRtpVersion( 2 );

const TInt KMaxRtpVersion( 8 );

const TInt KMaxDuration( 24 * 60 * 60 * 1000 );

const TInt KMaxDurationError( 60 * 1000 );

const TInt EContentRightsLockToDevice( 2 );

const TInt KSupportedMimeTypes( 1 );

const TInt KRtpClipRecogImplUIDValue( 0x10208446 );

const TUid KUidMimeRtpClipRecognizer = { 0x10208445 };

const TUint KNeededMetaBytes( KDeviceInfoPoint + KDeviceIdLength );

// Result of: TInt64( 1000 * 60 * 60 * 24 ) * TInt64( 365 * 2000 )

const TInt64 KSecondInMillenium( 63072000000000 );

_LIT8( KRtpClipMimetype, "application/x-nokia-teh-rtp" );

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

// -----------------------------------------------------------------------------

// CRtpClipRecognizer::CreateRecognizerL

// Static method to create instance of CRtpClipRecognizer

// -----------------------------------------------------------------------------

//

CApaDataRecognizerType* CRtpClipRecognizer::CreateRecognizerL()

    {

    CApaDataRecognizerType* rtpRecogType = NULL;

    rtpRecogType = new( ELeave ) CRtpClipRecognizer();

    return rtpRecogType; // NULL if new failed

    }

// -----------------------------------------------------------------------------

// CRtpClipRecognizer::CRtpClipRecognizer

// C++ default constructor can NOT contain any code, that might leave.

// -----------------------------------------------------------------------------

//

CRtpClipRecognizer::CRtpClipRecognizer()

  : CApaDataRecognizerType( KUidMimeRtpClipRecognizer,

                            CApaDataRecognizerType::EHigh )

    {

    iImei.Zero();

    iCountDataTypes = KSupportedMimeTypes;

    }

// -----------------------------------------------------------------------------

// CRtpClipRecognizer::PreferredBufSize

// Overwritten method from CApaDataRecognizerType

// -----------------------------------------------------------------------------

//

TUint CRtpClipRecognizer::PreferredBufSize()

    {

    return KNeededMetaBytes;

    }

// -----------------------------------------------------------------------------

// CRtpClipRecognizer::SupportedDataTypeL

// Overwritten method from CApaDataRecognizerType

// -----------------------------------------------------------------------------

//

TDataType CRtpClipRecognizer::SupportedDataTypeL( TInt aIndex ) const

    {

    __ASSERT_DEBUG( aIndex >= 0 &&

                    aIndex < KSupportedMimeTypes, User::Invariant() );

    switch ( aIndex )

        {

        case 0:

            {

            TDataType type( KRtpClipMimetype );

            return type;

            }

        default:

            break;

        }

    return TDataType();

    }

// -----------------------------------------------------------------------------

// CRtpClipRecognizer::DoRecognizeL

// Overwritten method from CApaDataRecognizerType

// -----------------------------------------------------------------------------

//

void CRtpClipRecognizer::DoRecognizeL(

    const TDesC& /*aName*/,

    const TDesC8& aBuffer )

    {

    iConfidence = ENotRecognized;

    iDataType = TDataType();

    // Verify invest buffer length

    if ( aBuffer.Length() < KNeededMetaBytes )

        {

        return; // Nothing to recognize 

        }

    // Meta length

    const TInt metaLength( GetValueL( 

        aBuffer.Mid( KMetaLengthPoint, KIntegerBytes ) ) );

    if ( metaLength > KErrNotFound && metaLength < KMaxMetaHeaderLength )

        {

        // Attributes

        TUint attr( GetValueL( 

            aBuffer.Mid( KAttributesPoint, KIntegerBytes ) ) );

        TUint8 ver( ( TUint8 )( ( attr >> KVersionFieldShift ) & 0xF ) );

        TUint8 post( ( TUint8 )( ( attr >> KPostRuleFieldShift ) & KMaxTUint8 ) );

        // Atributes valid?

        if ( post <= KMaxRtpPostRule && 

             ver >= KMinRtpVersion && ver <= KMaxRtpVersion )

            {

            // Verify mime

            TBool certain( EFalse );

            TBuf8<KUserIdLength> info( KNullDesC8 );

            GetMimeInfo( info );

            const TInt len( aBuffer[KUserIdPoint] );

            if ( len == KUserIdLength )

                {

                TPtrC8 mime( aBuffer.Mid( KUserIdPoint + KStringLengthBytes, len ) );

                if ( !mime.Compare( info ) )

                    {

                    certain = ETrue;

                    }

                else // old clip without mime in meta header

                    {

                    // Star time, end time, duration

                    TInt64 start( GetTInt64L( 

                        aBuffer.Mid( KStartTimePoint, KIntegerBytes * 2 ) ) );

                    TInt64 end( GetTInt64L(

                        aBuffer.Mid( KEndTimePoint, KIntegerBytes * 2 ) ) );

                    TUint dur( GetValueL( 

                        aBuffer.Mid( KDurationPoint, KIntegerBytes ) ) );

                    const TInt delta( TInt( ( end - start ) / 1000 ) );

                    if ( start > KSecondInMillenium &&

                         end > KSecondInMillenium && 

                         delta > 0 && dur < KMaxDuration && 

                         delta > ( ( dur > KMaxDurationError )? 

                                     dur - KMaxDurationError: 0 ) )

                        {

                        certain = ETrue;

                        }

                    }

                }

            // Verify content rights

            if ( certain && post == EContentRightsLockToDevice )

                {

                // IMSI from the phone

                if ( !iImei.Length() )

                    {

                    TBuf<KDeviceIdLength> buf;

                    GetImeiL( buf );

                    iImei.Copy( buf );

                    }

                // Verify IMEI

                const TInt len( aBuffer[KDeviceInfoPoint] );

                TPtrC8 imei( NULL, 0 );

                if ( len == KDeviceIdLength )

                    {

                    imei.Set( aBuffer.Mid( KDeviceInfoPoint + 

                                           KStringLengthBytes, len ) );

                    }

                if ( len != KDeviceIdLength || imei.Compare( iImei ) )

                    {

                    certain = EFalse;

                    }

                }

            // Set confidence and mime

            if ( certain )

                {

                iConfidence = ECertain;

                iDataType = TDataType( KRtpClipMimetype );

                }

            }

        }

    }

// -----------------------------------------------------------------------------

// CRtpClipRecognizer::GetValueL

// -----------------------------------------------------------------------------

//

TInt CRtpClipRecognizer::GetValueL( const TDesC8& aBytes )

    {

    TInt value( KErrNotFound );

    GetValueL( aBytes, value );

    return value;

    }

// -----------------------------------------------------------------------------

// CRtpClipRecognizer::GetValueL

// -----------------------------------------------------------------------------

//

void CRtpClipRecognizer::GetValueL( const TDesC8& aBytes, TInt& aValue )

    {

    User::LeaveIfError( GetValue( aBytes, aValue ) );

    }

// -----------------------------------------------------------------------------

// CRtpClipRecognizer::GetValue

// -----------------------------------------------------------------------------

//

TInt CRtpClipRecognizer::GetValue( const TDesC8& aBytes, TInt& aValue )

    {

    TUint value( 0 );

    TInt err( GetValue( aBytes, value ) );

    aValue = ( TInt )( value );

    return err;

    }

// -----------------------------------------------------------------------------

// CRtpClipRecognizer::GetValue

// -----------------------------------------------------------------------------

//

TInt CRtpClipRecognizer::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;

    }

// -----------------------------------------------------------------------------

// CRtpClipRecognizer::GetTInt64L

// Reads 64 bits integer from descriptor.

// -----------------------------------------------------------------------------

//

TInt64 CRtpClipRecognizer::GetTInt64L( const TDesC8& aBytes )

    {

    TUint low( GetValueL( aBytes.Mid( 0, KIntegerBytes ) ) );

    TUint high( GetValueL( aBytes.Mid( KIntegerBytes, 

                                                 KIntegerBytes ) ) );

    return TInt64( MAKE_TINT64( high, low ) );

    }

// -----------------------------------------------------------------------------

// CRtpClipRecognizer::GetMimeInfo

// Mime type info of propriatary RTP clip.

// -----------------------------------------------------------------------------

//

void CRtpClipRecognizer::GetMimeInfo( TDes8& aMime )

    {

    // Meta header has constant room as user info (IMSI) in old clips

    aMime.Copy( KRtpClipMimetype().Right( KUserIdLength ) );

    }

// -----------------------------------------------------------------------------

// CRtpClipRecognizer::GetImeiL

// Read IMEI on phone HW, use dummy under WINS

// -----------------------------------------------------------------------------

//

void CRtpClipRecognizer::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__

    }

//-----------------------------------------------------------------------------

// CRtpClipRecognizer::GetMobilePhoneInfo

//-----------------------------------------------------------------------------

//    

void CRtpClipRecognizer::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 ) );

    }

// -----------------------------------------------------------------------------

// CRtpClipRecognizer::ImplementationTable

// Table containing the data concerning CRtpClipRecognizer 

// -----------------------------------------------------------------------------

//

const TImplementationProxy ImplementationTable[] =

    {

    IMPLEMENTATION_PROXY_ENTRY( KRtpClipRecogImplUIDValue,

                                CRtpClipRecognizer::CreateRecognizerL )

    };

// -----------------------------------------------------------------------------

// CRtpClipRecognizer::ImplementationGroupProxy

// Function called by framework to return data about this recognizer

// -----------------------------------------------------------------------------

//

EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )

    {

    aTableCount = sizeof( ImplementationTable ) / 

                  sizeof( TImplementationProxy );

    return ImplementationTable;

    }

//  End of File