// Copyright (c) 2003-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:

// Name          : SdpAttributeField.h

// Part of       : SDP Codec

// Version       : 1.0

//

#include <s32strm.h>

#include <uri8.h>

#include "SdpAttributeField.h"

#include "SdpAttributeFieldPtrs.h"

#include "SdpFmtAttributeField.h"

#include "SdpUtil.h"

#include "SDPCodec.pan"

#include "sdpcodecstringconstants.h"

#include "SdpCodecConstants.h"

#include "SdpCodecStringPool.h"

#include "SdpRtpmapValue.h"

#include "SdpCodecErr.h"

#include "_sdpdefs.h"

// CONSTANTS

const TInt KHeaderIndex = 0;

const TInt KAttributeIndex = 1;

const TInt KMinAttributeNum = 2;

const TInt KMaxSubtagLength = 8;

const TInt KMaxPrimarySubtagLength = 8;

// Valid property attribute strings

const TInt KPropertyStringNum = 4;

const SdpCodecStringConstants::TStrings 

    KValidPropertyStrings[KPropertyStringNum] =

    {

    SdpCodecStringConstants::EAttributeRecvonly,

    SdpCodecStringConstants::EAttributeSendrecv,

    SdpCodecStringConstants::EAttributeSendonly,

    SdpCodecStringConstants::EAttributeInactive

    };

// Valid value attribute strings

const TInt KValueStringNum = 22;

const SdpCodecStringConstants::TStrings KValidValueStrings[KValueStringNum] =

    {

    SdpCodecStringConstants::EAttributeCat,

    SdpCodecStringConstants::EAttributeKeywds,

    SdpCodecStringConstants::EAttributeTool,

    SdpCodecStringConstants::EAttributePtime,

    SdpCodecStringConstants::EAttributeMaxptime,

    SdpCodecStringConstants::EAttributeRtpmap,

    SdpCodecStringConstants::EAttributeOrient,

    SdpCodecStringConstants::EAttributeType,

    SdpCodecStringConstants::EAttributeCharset,

    SdpCodecStringConstants::EAttributeSdplang,

    SdpCodecStringConstants::EAttributeLang,

    SdpCodecStringConstants::EAttributeFramerate,

    SdpCodecStringConstants::EAttributeQuality,    

    SdpCodecStringConstants::EAttributeFmtp,

    SdpCodecStringConstants::EAttributeControl,

    SdpCodecStringConstants::EAttributeEtag,

    SdpCodecStringConstants::EAttributeMid,

    SdpCodecStringConstants::EAttributeGroup,

    SdpCodecStringConstants::EAttributeCurr,

    SdpCodecStringConstants::EAttributeDes,

    SdpCodecStringConstants::EAttributeConf,

    SdpCodecStringConstants::EAttributeRange

    };

// Valid orient value strings

const TInt KValidOrientStringNum = 3;

static const TText8* const KOrientStrings[KValidOrientStringNum] = 

    {

    _S8("portrait\0"),

    _S8("landscape\0"),

    _S8("seascape\0")

    };

const TInt KValidGroupSemanticsNum = 3;

static const TText8* const KGroupSemantics[KValidGroupSemanticsNum] =

    {

    _S8("LS"),

    _S8("FID"),

    _S8("SRF")

    };

const TInt KValidStatusTypeNum = 3;

static const TText8* const KStatusTypes[KValidStatusTypeNum] =

    {

    _S8("e2e"),

    _S8("local"),

    _S8("remote")

    };

const TInt KValidDirectionTagsNum = 4;

static const TText8* const KDirectionTags[KValidDirectionTagsNum] =

    {

    _S8("none"),

    _S8("send"),

    _S8("recv"),

    _S8("sendrecv")

    };

const TInt KValidStrengthTagsNum = 5;

static const TText8* const KStrengthTags[KValidStrengthTagsNum] =

    {

    _S8("mandatory"),

    _S8("optional"),

    _S8("none"),

    _S8("failure"),

    _S8("unknown")

    };

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

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

// CSdpAttributeField::CSdpAttributeField

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

// might leave.

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

//

CSdpAttributeField::CSdpAttributeField()

	{

	}

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

// CSdpAttributeField::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSdpAttributeField::ConstructL( const TDesC8& aText )

	{

    // aText should be in format

    // a=<attribute> or a=<attribute>:<value> or 

    // a=<attribute>:<value> <value specific attributes>

    __ASSERT_ALWAYS(aText.Length() > 0, User::Leave(KErrSdpCodecAttributeField));

    iPool = SdpCodecStringPool::StringPoolL();

    CreateAttributeFieldPtrsL();

    RArray<TPtrC8> array;

    TInt length = aText.Length();

    if ( aText[aText.Length() - 1] == KLFChar )

        {

        if ( length > 1 && aText[aText.Length() - 2] == KCRChar )

            {

            length--;

            }

        length--;

        }  

    TPtrC8 restValue( aText.Left( length ));

    __ASSERT_ALWAYS(SdpUtil::IsByteString(restValue) 

            || SdpUtil::IsToken(restValue)

            || SdpUtil::IsValidChars(KEqualStr, restValue),

            User::Leave(KErrSdpCodecAttributeField));

    array = SdpUtil::GetElementsFromLineL( aText, KErrSdpCodecAttributeField );

    CleanupClosePushL( array );

    RStringF origHeader =  iPool.StringF( SdpCodecStringConstants::EAttribute, 

                                          SdpCodecStringConstants::Table );

    // We need to have at least two tokens (and this should be always the case,

    // unless TSdpUtil::GetElementsFromLineL() gets modified)

    __ASSERT_ALWAYS( origHeader.DesC().Compare( array[KHeaderIndex] ) == 0

                    && array.Count() >= KMinAttributeNum,

        User::Leave( KErrSdpCodecAttributeField ) );

    if ( array[KAttributeIndex].Locate( KColonChar ) == KErrNotFound )

        {

        // For property attributes exactly two attributes are needed

        __ASSERT_ALWAYS( array.Count() == KMinAttributeNum,

            User::Leave( KErrSdpCodecAttributeField ));

        FormatProperyAttributeL( array[KAttributeIndex] );  

        }

    else

        {    

        HBufC8* attribute = NULL;

        HBufC8* value = NULL;             

        CreateAttributeAndValueStringsLC( array, attribute, value );

        FormatValueAttributeL( *attribute, *value );

        CleanupStack::PopAndDestroy( 2 );   // attribute, value

        }

    CleanupStack::PopAndDestroy();  // array

    __TEST_INVARIANT;

	}

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

// CSdpAttributeField::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSdpAttributeField::ConstructL( RStringF aAttribute, 

                                    const TDesC8& aValue )

	{	

    iPool = SdpCodecStringPool::StringPoolL();

    CreateAttributeFieldPtrsL();

    TBool property( EFalse );

    for ( TInt i( 0 ); i < KPropertyStringNum && !property; i++ )

        {

        if ( aAttribute == 

             iPool.StringF( KValidPropertyStrings[i], 

                            SdpCodecStringConstants::Table ) )

            {

            property = ETrue;

            }

        }

    if ( property || aValue.Length() == 0)

        {

        // For property attributes, no value is valid value

        __ASSERT_ALWAYS( aValue.Length() == 0, 

            User::Leave( KErrSdpCodecAttributeField ));

        FormatProperyAttributeL( aAttribute.DesC() );  

        }

    else

        {   

        FormatValueAttributeL( aAttribute.DesC(), aValue );        

        }        

    __TEST_INVARIANT;

	}

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

// CSdpAttributeField::DecodeL

// Two-phased constructor.

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

//

EXPORT_C CSdpAttributeField* CSdpAttributeField::DecodeL( const TDesC8& aText )

	{

	CSdpAttributeField* obj = DecodeLC( aText );

	CleanupStack::Pop();

	return obj;

	}

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

// CSdpAttributeField::DecodeLC

// Two-phased constructor.

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

//

EXPORT_C CSdpAttributeField* CSdpAttributeField::DecodeLC( 

    const TDesC8& aText )

	{

	CSdpAttributeField* obj = new ( ELeave ) CSdpAttributeField;

	CleanupStack::PushL( obj );

	obj->ConstructL( aText );

	return obj;

	}

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

// CSdpAttributeField::NewL

// Two-phased constructor.

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

//

EXPORT_C CSdpAttributeField* CSdpAttributeField::NewL( RStringF aAttribute, 

                                                    const TDesC8& aValue )

	{

	CSdpAttributeField* obj = NewLC( aAttribute, aValue );

	CleanupStack::Pop();

	return obj;

	}

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

// CSdpAttributeField::NewLC

// Two-phased constructor.

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

//

EXPORT_C CSdpAttributeField* CSdpAttributeField::NewLC( RStringF aAttribute,

                                                        const TDesC8& aValue )

	{

	CSdpAttributeField* obj = new ( ELeave ) CSdpAttributeField;

	CleanupStack::PushL(obj);

	obj->ConstructL( aAttribute, aValue );

	return obj;

	}

// Destructor

EXPORT_C CSdpAttributeField::~CSdpAttributeField()

	{    

    iAttribute.Close();

    CSdpAttributeFieldPtrs* tmp = 

        reinterpret_cast< CSdpAttributeFieldPtrs* >( iValue ); 

	delete tmp;

	}

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

// CSdpAttributeField::EncodeL

// Encodes a string into valid output string format

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

//

EXPORT_C void CSdpAttributeField::EncodeL( RWriteStream& aStream ) const

	{

	__TEST_INVARIANT;

    RStringF header = iPool.StringF( SdpCodecStringConstants::EAttribute, 

                                     SdpCodecStringConstants::Table );

    aStream.WriteL( header.DesC() );

    aStream.WriteL( iAttribute.DesC() );

    TPtrC8 value( AttributeFieldPtrs().Value() );

    if ( value.Length() > 0 )

        {

        aStream.WriteL( KColonStr );

        aStream.WriteL( value );

        }

    aStream.WriteL( KCRLFStr );

	}

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

// CSdpAttributeField::CloneL

// Clones an object and returns the new attribute field

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

//

EXPORT_C CSdpAttributeField * CSdpAttributeField::CloneL() const

	{

	__TEST_INVARIANT;

    CSdpAttributeField* obj = 

        CSdpAttributeField::NewL( iAttribute, AttributeFieldPtrs().Value() );

	__ASSERT_DEBUG( *this == *obj, 

                    User::Panic(KSdpCodecPanicCat, KSdpCodecPanicInternal) );

	return obj;

	}

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

// CSdpAttributeField::operator==

// Checks if the two attribute fields are equal

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

//

EXPORT_C TBool CSdpAttributeField::operator== (

    const CSdpAttributeField& aObj ) const

	{

	__TEST_INVARIANT;

    return ( iAttribute == aObj.Attribute() && 

             AttributeFieldPtrs().Value().CompareF( aObj.Value() ) == 0 );

	}

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

// CSdpAttributeField::Attribute

// Returns attribute part of attribute field

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

//

EXPORT_C RStringF CSdpAttributeField::Attribute() const

	{

    __TEST_INVARIANT;

    return iAttribute;

	}

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

// CSdpAttributeField::Value

// Returns value part of attribute field

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

//

EXPORT_C const TDesC8& CSdpAttributeField::Value() const

	{

    __TEST_INVARIANT;

    return AttributeFieldPtrs().Value();

	}

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

// CSdpAttributeField::SetL

// Sets new attribute field values

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

//

EXPORT_C void CSdpAttributeField::SetL( RStringF aAttribute, 

                                        const TDesC8& aValue )

	{

    __TEST_INVARIANT;

    ConstructL( aAttribute, aValue ); 

    __TEST_INVARIANT;  

	}

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

// CSdpAttributeField::AssignTo

// Assigns attribute to a format attribute

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

//

EXPORT_C void CSdpAttributeField::AssignTo(

    const CSdpFmtAttributeField& aFmtAttribute)

	{

	AttributeFieldPtrs().SetFmtAttribute(&aFmtAttribute);

	}

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

// CSdpAttributeField::BelongsTo

// Check if the attribute field belongs to the format attribute

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

//

EXPORT_C TBool CSdpAttributeField::BelongsTo(

    const CSdpFmtAttributeField& aFmtAttribute) const

	{

	return ( AttributeFieldPtrs().FmtAttribute() == &aFmtAttribute );

	}

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

// CSdpAttributeField::ExternalizeL

// Externalizes the object to stream

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

//

void CSdpAttributeField::ExternalizeL( RWriteStream& aStream ) const

	{

    // Attribute

    aStream.WriteUint32L( iAttribute.DesC().Length() );

    aStream.WriteL( iAttribute.DesC() );

    // Value

    TPtrC8 value( AttributeFieldPtrs().Value() );

    aStream.WriteUint32L( value.Length() );

    if ( value.Length() > 0 )

        {

        aStream.WriteL( value, value.Length() );

        }

	}

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

// CSdpAttributeField::InternalizeL

// Internalizes the object from stream

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

//

CSdpAttributeField* CSdpAttributeField::InternalizeL( RReadStream& aStream )

	{

    RStringPool pool = SdpCodecStringPool::StringPoolL();

	// Attribute

    HBufC8* tmpBuf2;

    TUint32 length = aStream.ReadUint32L();

    HBufC8* tmpBuf = HBufC8::NewLC( length );

    TPtr8 ptr( tmpBuf->Des() );

    aStream.ReadL( ptr, length ); 

    RStringF attribute = pool.OpenFStringL( ptr );

    CleanupClosePushL( attribute );

    length = aStream.ReadUint32L();

    if ( length > 0 )

        {

        tmpBuf2 = HBufC8::NewLC( length );

        TPtr8 ptr2( tmpBuf2->Des() );

        aStream.ReadL( ptr2, length );

        }

    else

        {

        tmpBuf2 = KNullDesC8().AllocLC();

        }

    CSdpAttributeField* obj = CSdpAttributeField::NewL( attribute, *tmpBuf2 );

    CleanupStack::PopAndDestroy( 3 );  // attribute, tmpBuf, tmpBuf2

    return obj;

	}

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

// CSdpAttributeField::FormatPropertyAttributeL

// Formats and initializes class to be a property attribute

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

//

void CSdpAttributeField::FormatProperyAttributeL( const TDesC8& aAttribute )

    {

    __ASSERT_ALWAYS( SdpUtil::IsToken( aAttribute ), 

        User::Leave( KErrSdpCodecAttributeField ));

    TBool found( EFalse );

    for ( TInt i( 0 ); i < KPropertyStringNum && !found; i++ )

        {

        RStringF attrString = 

            iPool.StringF( KValidPropertyStrings[i], 

                        SdpCodecStringConstants::Table );

        if ( attrString.DesC().CompareF( aAttribute ) == 0 )

            {

            AttributeFieldPtrs().SetValueL( KNullDesC8 );

            iAttribute.Close();           

            iAttribute = attrString.Copy();            

            iPropertyAttribute = ETrue;            

            found = ETrue;

            }                                       

        }

    if ( !found )

        {

        HBufC8* tempValue = KNullDesC8().AllocLC();

        SetNotPredefinedAttributeL(aAttribute, *tempValue);

        CleanupStack::PopAndDestroy(); // tempValue

        }

    }

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

// CSdpAttributeField::FormatValueAttributeL

// Formats and initializes class to be a value attribute

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

//

void CSdpAttributeField::FormatValueAttributeL( const TDesC8& aAttribute,

                                                const TDesC8& aValue )

    {

    TBool found( EFalse ); 

    __ASSERT_ALWAYS( SdpUtil::IsToken( aAttribute ) 

                && SdpUtil::IsByteString( aValue ),

            User::Leave( KErrSdpCodecAttributeField ) );

    TInt i = 0;

    for( i = 0; i < KPropertyStringNum && !found; i++)

        {

        RStringF attrString = 

            iPool.StringF( KValidPropertyStrings[i], 

                        SdpCodecStringConstants::Table );