/*
* 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:      a data class for client-server comms
*
*/






// INCLUDE FILES

#include "upnpavrequest.h"

#include <upnpitem.h>

// CONSTANTS
_LIT( KURIRequestPanicText, "CUpnpAVRequest" );
const TInt KMaxStringLen = 256;
const TInt KMaxStringLenLong = 1024;
const TInt KBufferGranularity = 100;    

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

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

// --------------------------------------------------------------------------
// CUpnpAVRequest::ConstructL
// Symbian 2nd phase constructor can leave.
// --------------------------------------------------------------------------
inline void CUpnpAVRequest::ConstructL()
    {
    iId = KNullDesC8().AllocL();
    iUuid = KNullDesC8().AllocL();
    iFilePath = KNullDesC().AllocL();;
    iURI = KNullDesC8().AllocL(); 
    //iItem = CUpnpItem::NewL();                              
    }

// --------------------------------------------------------------------------
// CUpnpAVRequest::NewL
// Two-phased constructor.
// --------------------------------------------------------------------------
inline CUpnpAVRequest* CUpnpAVRequest::NewL()
    {
    CUpnpAVRequest* self = NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// --------------------------------------------------------------------------
// CUpnpAVRequest::NewLC
// Two-phased constructor.
// --------------------------------------------------------------------------
inline CUpnpAVRequest* CUpnpAVRequest::NewLC()
    {
    CUpnpAVRequest* self = new( ELeave )
        CUpnpAVRequest;    
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

    
// --------------------------------------------------------------------------
// CUpnpAVRequest::~CUpnpAVRequest
// Destructor
// --------------------------------------------------------------------------
inline CUpnpAVRequest::~CUpnpAVRequest()
    {
    delete iId;
    delete iUuid;
    delete iFilePath;
    delete iURI;
    }

// --------------------------------------------------------------------------
// CUpnpAVRequest::ExternalizeL
// Externatizes object
// --------------------------------------------------------------------------
inline void CUpnpAVRequest::ExternalizeL( RWriteStream& aStream ) const
    {    
    aStream << *iId;
    aStream << *iUuid;
    aStream << *iFilePath;
    aStream << *iURI;
    aStream.WriteInt16L( (TInt)iRequiresBrowse );
    aStream.WriteInt16L( (TInt)iMemoryType );
    aStream.WriteInt16L( (TInt)iFileSharing );
    }

// --------------------------------------------------------------------------
// CUpnpAVRequest::InternalizeL
// Internalizes object
// --------------------------------------------------------------------------    
inline void CUpnpAVRequest::InternalizeL( RReadStream& aStream )
    {
    delete iId; iId = NULL;
    iId = HBufC8::NewL( aStream, KMaxStringLen );

    delete iUuid; iUuid = NULL;
    iUuid = HBufC8::NewL( aStream, KMaxStringLen );
    
    delete iFilePath; iFilePath = NULL;
    iFilePath = HBufC::NewL( aStream, KMaxStringLen );

    delete iURI; iURI = NULL;
    iURI = HBufC8::NewL( aStream, KMaxStringLenLong );
    
    iRequiresBrowse = (TBool)aStream.ReadInt16L();
    
    iMemoryType = (MUPnPAVBrowsingSession::TMemoryType)aStream.ReadInt16L();
    
    iFileSharing = (MUPnPAVBrowsingSession::TFileSharing)
        aStream.ReadInt16L();
    }

// --------------------------------------------------------------------------
// CUpnpAVRequest::ToDes8L
// Externalizes object to a heap descriptor
// --------------------------------------------------------------------------
inline HBufC8* CUpnpAVRequest::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;
    }

// --------------------------------------------------------------------------
// CUpnpAVRequest::SetIdL
// Sets id
// --------------------------------------------------------------------------
inline void CUpnpAVRequest::SetIdL( const TDesC8& aId )
    {
    HBufC8* tempBuf = aId.AllocL();
    delete iId;
    iId = tempBuf;
    }

// --------------------------------------------------------------------------
// CUpnpAVRequest::Id
// Returns id
// --------------------------------------------------------------------------    
inline const TDesC8& CUpnpAVRequest::Id()
    {
    if( iId )
        {
        return *iId;
        }
    else
        {
        return KNullDesC8;
        }    
    }

// --------------------------------------------------------------------------
// CUpnpAVRequest::SetUuidL
// Sets uuid
// --------------------------------------------------------------------------
inline void CUpnpAVRequest::SetUuidL( const TDesC8& aUuid )
    {
    HBufC8* tempBuf = aUuid.AllocL();
    delete iUuid;
    iUuid = tempBuf;    
    }
    
// --------------------------------------------------------------------------
// CUpnpAVRequest::Uuid
// Returns uuid
// --------------------------------------------------------------------------
inline const TDesC8& CUpnpAVRequest::Uuid()
    {    
    if( iUuid )
        {
        return *iUuid;
        }
    else
        {
        return KNullDesC8;
        }        
    }

// --------------------------------------------------------------------------
// CUpnpAVRequest::SetFilePathL
// Sets filepath
// --------------------------------------------------------------------------
inline void CUpnpAVRequest::SetFilePathL( const TDesC& aFilePath )
    {
    HBufC* tempBuf = aFilePath.AllocL();
    delete iFilePath;
    iFilePath = tempBuf;    
    }
    
// --------------------------------------------------------------------------
// CUpnpAVRequest::FilePath
// Returns filepath
// --------------------------------------------------------------------------
inline const TDesC& CUpnpAVRequest::FilePath()
    {
    if( iFilePath )
        {
        return *iFilePath;
        }
    else
        {
        return KNullDesC;
        }
    }

// --------------------------------------------------------------------------
// CUpnpAVRequest::SetURIL
// Sets URI
// --------------------------------------------------------------------------
inline void CUpnpAVRequest::SetURIL( const TDesC8& aURI )
    {
    HBufC8* tempBuf = aURI.AllocL();
    delete iURI;
    iURI = tempBuf;    
    }
    
// --------------------------------------------------------------------------
// CUpnpAVRequest::URI
// Returns URI
// --------------------------------------------------------------------------
inline const TDesC8& CUpnpAVRequest::URI()
    {
    if( iURI )
        {
        return *iURI;
        }
    else
        {
        return KNullDesC8;
        }
    }

// --------------------------------------------------------------------------
// CUpnpAVRequest::SetRequiresBrowse
// 
// --------------------------------------------------------------------------
inline void CUpnpAVRequest::SetRequiresBrowse( TBool aBrowse )
    {
    iRequiresBrowse = aBrowse;
    }
    
// --------------------------------------------------------------------------
// CUpnpAVRequest::RequiresBrowse
// 
// --------------------------------------------------------------------------
inline TBool CUpnpAVRequest::RequiresBrowse()
    {
    return iRequiresBrowse;
    }

// --------------------------------------------------------------------------
// CUpnpAVRequest::SetMemoryType
// Sets used memory type
// --------------------------------------------------------------------------
inline void CUpnpAVRequest::SetMemoryType(
    MUPnPAVBrowsingSession::TMemoryType aMemoryType )
    {
    iMemoryType = aMemoryType;
    }
    
// --------------------------------------------------------------------------
// CUpnpAVRequest::MemoryType
// Returns used memory type
// --------------------------------------------------------------------------
inline MUPnPAVBrowsingSession::TMemoryType CUpnpAVRequest::MemoryType()
    {
    return iMemoryType;
    }

// --------------------------------------------------------------------------
// CUpnpAVRequest::SetFileSharing
// Sets the state of filesharing
// --------------------------------------------------------------------------
inline void CUpnpAVRequest::SetFileSharing(
    MUPnPAVBrowsingSession::TFileSharing aFileSharing )
    {
    iFileSharing = aFileSharing;
    }
    
// --------------------------------------------------------------------------
// CUpnpAVRequest::FileSharing
// Returns the state of filesharing
// --------------------------------------------------------------------------
inline MUPnPAVBrowsingSession::TFileSharing CUpnpAVRequest::FileSharing()
    {
    return iFileSharing;
    }

// End of File