/*

* Copyright (c) 2006 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:      The device object

*

*/

// INCLUDE FILES

#include "upnpavdevice.h"

// CONSTANTS

const TInt KMaxStringLen = 255;

const TInt KBufferGranularity = 100;

_LIT( KComponentLogfile, "upnpavcontrollerclient.txt");

#include "upnplog.h"

// CONSTANTS

_LIT8( KAudioSupport,        "audio/" );

_LIT8( KImageSupport,        "image/" );

_LIT8( KVideoSupport,        "video/" );

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

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

// CUpnpAVDevice::CUpnpAVDevice

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

// might leave.

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

EXPORT_C CUpnpAVDevice::CUpnpAVDevice()

    {    

    }

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

// CUpnpAVDevice::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CUpnpAVDevice::ConstructL()

    {                           

    }

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

// CUpnpAVDevice::NewL

// Two-phased constructor.

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

EXPORT_C CUpnpAVDevice* CUpnpAVDevice::NewL()

    {

    CUpnpAVDevice* self = NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpAVDevice::NewL

// Two-phased constructor.

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

EXPORT_C CUpnpAVDevice* CUpnpAVDevice::NewL( const CUpnpAVDevice& aDevice )

    {

    CUpnpAVDevice* self = NewLC();

    self->CopyFromL( aDevice );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpAVDevice::NewLC

// Two-phased constructor.

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

EXPORT_C CUpnpAVDevice* CUpnpAVDevice::NewLC()

    {

    CUpnpAVDevice* self = new( ELeave )

        CUpnpAVDevice;    

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CUpnpAVDevice::~CUpnpAVDevice

// Destructor

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

EXPORT_C CUpnpAVDevice::~CUpnpAVDevice()

    {

    delete iName;

    delete iUuid;            

    }

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

// CUpnpAVDevice::ExternalizeL

// See upnpavdevice.h

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

EXPORT_C void CUpnpAVDevice::ExternalizeL( RWriteStream& aStream ) const

    {

    __ASSERTD( iUuid, __FILE__, __LINE__ );

    __ASSERTD( iName, __FILE__, __LINE__ );

    aStream << *iUuid;

    aStream << *iName;

    aStream.WriteInt32L( (TInt)iDeviceType );

    aStream.WriteInt32L( (TInt)iCopyCapability );

    aStream.WriteInt32L( (TInt)iSearchCapability );

    aStream.WriteInt32L( (TInt)iPauseCapability );

    aStream.WriteInt32L( (TInt)iVolumeCapability );

    aStream.WriteInt32L( (TInt)iMuteCapability );

    aStream.WriteInt32L( (TInt)iAudioMediaCapability );

    aStream.WriteInt32L( (TInt)iImageMediaCapability );

    aStream.WriteInt32L( (TInt)iVideoMediaCapability );

    aStream.WriteInt32L( (TInt)iNextAVTransportUri );

    aStream.WriteInt32L( (TInt)iMaxVolume );

    aStream.WriteInt32L( (TInt)iDlnaCompatible );

    }

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

// CUpnpAVDevice::InternalizeL

// See upnpavdevice.h

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

EXPORT_C void CUpnpAVDevice::InternalizeL( RReadStream& aStream )

    {

    delete iUuid;

    iUuid = NULL;

    iUuid = HBufC8::NewL( aStream, KMaxStringLen );

    delete iName;

    iName = NULL;

    iName = HBufC8::NewL( aStream, KMaxStringLen );

    iDeviceType = (TUpnpAVDeviceType)aStream.ReadInt32L();

    iCopyCapability = (TBool)aStream.ReadInt32L();

    iSearchCapability = (TBool)aStream.ReadInt32L();

    iPauseCapability = (TBool)aStream.ReadInt32L();

    iVolumeCapability = (TBool)aStream.ReadInt32L();

    iMuteCapability = (TBool)aStream.ReadInt32L();

    iAudioMediaCapability = (TBool)aStream.ReadInt32L();

    iImageMediaCapability = (TBool)aStream.ReadInt32L();

    iVideoMediaCapability = (TBool)aStream.ReadInt32L();

    iNextAVTransportUri = (TBool)aStream.ReadInt32L();

    iMaxVolume = (TInt)aStream.ReadInt32L();

    iDlnaCompatible = (TBool)aStream.ReadInt32L();

    }

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

// CUpnpAVDevice::ToDes8L

// See upnpavdevice.h

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

EXPORT_C HBufC8* CUpnpAVDevice::ToDes8L() const

    {

    // serialize object

    CBufFlat* tempFlatBuf = CBufFlat::NewL( KBufferGranularity );

    CleanupStack::PushL( tempFlatBuf );

    RBufWriteStream stream( *tempFlatBuf );

    CleanupClosePushL( stream );

    stream << *this;

    // create heap descriptor

    HBufC8* tempBuf = HBufC8::NewLC( tempFlatBuf->Size() );

    TPtr8 ptr( tempBuf->Des() );

    tempFlatBuf->Read( 0, ptr, tempFlatBuf->Size() );

    // clean up

    CleanupStack::Pop( tempBuf );

    CleanupStack::PopAndDestroy( &stream );

    CleanupStack::PopAndDestroy( tempFlatBuf );

    return tempBuf;

    }

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

// CUpnpAVDevice::CopyFromL

// See upnpavdevice.h

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

EXPORT_C void CUpnpAVDevice::CopyFromL( const CUpnpAVDevice& aDevice )

    {

    iDeviceType = aDevice.DeviceType();

    SetFriendlyNameL( aDevice.FriendlyName() );

    SetUuidL( aDevice.Uuid() );

    iCopyCapability = aDevice.CopyCapability();

    iSearchCapability = aDevice.SearchCapability();

    iPauseCapability = aDevice.PauseCapability();

    iVolumeCapability = aDevice.VolumeCapability();

    iMuteCapability = aDevice.MuteCapability();

    iAudioMediaCapability = aDevice.AudioCapability();

    iImageMediaCapability = aDevice.ImageCapability();

    iVideoMediaCapability = aDevice.VideoCapability();

    iNextAVTransportUri = aDevice.NextAVTransportUri();

    iMaxVolume = aDevice.MaxVolume();

    iDlnaCompatible = aDevice.DlnaCompatible();

    }

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

// CUpnpAVDevice::SetFriendlyNameL

// See upnpavdevice.h

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

EXPORT_C void CUpnpAVDevice::SetFriendlyNameL( const TDesC8& aName )

    {

    HBufC8* tempBuf = aName.AllocL();

    delete iName;

    iName = tempBuf;    

    }

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

// CUpnpAVDevice::FriendlyName

// See upnpavdevice.h

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

EXPORT_C const TDesC8& CUpnpAVDevice::FriendlyName() const

    {

    if( iName )

        {

        return *iName;

        }

    else

        {

        return KNullDesC8;

        }        

    }

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

// CUpnpAVDevice::SetUuidL

// See upnpavdevice.h

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

EXPORT_C void CUpnpAVDevice::SetUuidL( const TDesC8& aUuid )

    {

    HBufC8* tempBuf = aUuid.AllocL();

    delete iUuid;

    iUuid = tempBuf;

    }

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

// CUpnpAVDevice::Uuid

// See upnpavdevice.h

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

EXPORT_C const TDesC8& CUpnpAVDevice::Uuid() const

    {

    if( iUuid )

        {

        return *iUuid;

        }

    else

        {

        return KNullDesC8;

        }    

    }

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

// CUpnpAVDevice::SetDeviceType

// See upnpavdevice.h

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

EXPORT_C void CUpnpAVDevice::SetDeviceType( TUpnpAVDeviceType aDeviceType )

    {

    iDeviceType = aDeviceType;

    }

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

// CUpnpAVDevice::DeviceType

// See upnpavdevice.h

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

EXPORT_C CUpnpAVDevice::TUpnpAVDeviceType CUpnpAVDevice::DeviceType() const

    {

    return iDeviceType;

    }

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

// CUpnpAVDevice::SetCapabilitiesBySupportedMimeTypesL

// See upnpavdevice.h

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

EXPORT_C void CUpnpAVDevice::SetCapabilitiesBySupportedMimeTypesL(

                                const TDesC8& aListOfMimeTypes )

    {

    if( aListOfMimeTypes == KNullDesC8 )

        {

        User::Leave( KErrArgument );

        }

    else

        {

        // Update the audio media capability

        if( aListOfMimeTypes.Find( KAudioSupport ) >= 0 )

            {

            iAudioMediaCapability = ETrue;

            }

        else

            {

            iAudioMediaCapability = EFalse;

            }

        // Update the image media capability

        if( aListOfMimeTypes.Find( KImageSupport ) >= 0 )

            {

            iImageMediaCapability = ETrue;

            }

        else

            {

            iImageMediaCapability = EFalse;

            }

        // Update the video media capability

        if( aListOfMimeTypes.Find( KVideoSupport ) >= 0 )

            {

            iVideoMediaCapability = ETrue;

            }

        else

            {

            iVideoMediaCapability = EFalse;

            }

        }

    }

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

// CUpnpAVDevice::LinkOffset

// See upnpavdevice.h

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

EXPORT_C TInt CUpnpAVDevice::LinkOffset()

    {

    return _FOFF( CUpnpAVDevice, iSlink );

    }

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

// CUpnpAVDevice::SetCopyCapability

// Sets the copy capability of the device

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

EXPORT_C void CUpnpAVDevice::SetCopyCapability( TBool aCopyCap )

    {

    iCopyCapability = aCopyCap;

    }

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

// CUpnpAVDevice::CopyCapability

// Gets the copy capability of the device

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

EXPORT_C TBool CUpnpAVDevice::CopyCapability() const

    {

    return iCopyCapability;

    }

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

// CUpnpAVDevice::SetSearchCapability

// Sets the search capability of the device

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

EXPORT_C void CUpnpAVDevice::SetSearchCapability( TBool aSearchCap )

    {

    iSearchCapability = aSearchCap;

    }

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

// CUpnpAVDevice::SearchCapability

// Gets the search capability of the device

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

EXPORT_C TBool CUpnpAVDevice::SearchCapability() const

    {

    return iSearchCapability;

    }

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

// CUpnpAVDevice::SetPauseCapability

// Sets the pause capability of the device

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

EXPORT_C void CUpnpAVDevice::SetPauseCapability( TBool aPauseCap )

    {

    iPauseCapability = aPauseCap;

    }

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

// CUpnpAVDevice::PauseCapability

// Gets the pause capability of the device

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

EXPORT_C TBool CUpnpAVDevice::PauseCapability() const

    {

    return iPauseCapability;

    }

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

// CUpnpAVDevice::SetVolumeCapability

// Sets the volume capability of the device

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

EXPORT_C void CUpnpAVDevice::SetVolumeCapability( TBool aVolumeCap )

    {

    iVolumeCapability = aVolumeCap;

    }

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

// CUpnpAVDevice::VolumeCapability

// Gets the volume capability of the device

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

EXPORT_C TBool CUpnpAVDevice::VolumeCapability() const

    {

    return iVolumeCapability;

    }

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

// CUpnpAVDevice::SetMuteCapability

// Sets the mute capability of the device

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

EXPORT_C void CUpnpAVDevice::SetMuteCapability( TBool aMuteCap )

    {

    iMuteCapability = aMuteCap;

    }

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

// CUpnpAVDevice::MuteCapability

// Gets the mute capability of the device

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

EXPORT_C TBool CUpnpAVDevice::MuteCapability() const

    {

    return iMuteCapability;

    }

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

// CUpnpAVDevice::SetMaxVolume

// Sets the maximum volume of the device

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

EXPORT_C void CUpnpAVDevice::SetMaxVolume( TInt aVolume )

    {

    iMaxVolume = aVolume;

    }

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

// CUpnpAVDevice::MaxVolume

// Gets the maximum volume of the device

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

EXPORT_C TInt CUpnpAVDevice::MaxVolume() const

    {

    return iMaxVolume;

    }

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

// CUpnpAVDevice::SetNextAVTransportUri

// See upnpavdevice.h

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

EXPORT_C void CUpnpAVDevice::SetNextAVTransportUri( TBool aCap )

    {

    iNextAVTransportUri = aCap;

    __LOG1( "CUpnpAVDevice::SetNextAVTransportUri: iNextAVTransportUri %d",

            iNextAVTransportUri );

    }

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

// CUpnpAVDevice::NextAVTransportUri

// See upnpavdevice.h

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

EXPORT_C TBool CUpnpAVDevice::NextAVTransportUri() const

    {

    __LOG1( "CUpnpAVDevice::NextAVTransportUri: iNextAVTransportUri %d",

            iNextAVTransportUri );

    // Do not support NextAVTransportUri for now

    __LOG( "return EFalse" );

    return EFalse;

    }           

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

// CUpnpAVDevice::SetAudioCapability

// See upnpavdevice.h

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

EXPORT_C void CUpnpAVDevice::SetAudioCapability( TBool aCap )

    {

    iAudioMediaCapability = aCap;

    }

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

// CUpnpAVDevice::AudioCapability

// See upnpavdevice.h

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

EXPORT_C TBool CUpnpAVDevice::AudioCapability() const

    {

    return iAudioMediaCapability;

    }

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

// CUpnpAVDevice::SetImageCapability

// See upnpavdevice.h

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

EXPORT_C void CUpnpAVDevice::SetImageCapability( TBool aCap )

    {

    iImageMediaCapability = aCap;

    }

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

// CUpnpAVDevice::ImageCapability

// See upnpavdevice.h

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

EXPORT_C TBool CUpnpAVDevice::ImageCapability() const

    {

    return iImageMediaCapability;

    }

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

// CUpnpAVDevice::SetVideoCapability

// See upnpavdevice.h

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

EXPORT_C void CUpnpAVDevice::SetVideoCapability( TBool aCap )

    {

    iVideoMediaCapability = aCap;

    }

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

// CUpnpAVDevice::VideoCapability

// See upnpavdevice.h

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

EXPORT_C TBool CUpnpAVDevice::VideoCapability() const

    {

    return iVideoMediaCapability;     

    }

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

// CUpnpAVDevice::SetDlnaCompatible

// See upnpavdeviceextended.h

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

EXPORT_C void CUpnpAVDevice::SetDlnaCompatible( TBool aDlnaCompatible )