/** @file
* Copyright (c) 2005-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:  UPnPObject implementation
*
*/


// INCLUDE FILES
#include "upnpobject.h" 


_LIT8(KContainer,"container"); 
_LIT8(KItem,"item");
_LIT8(KRes,"res");
_LIT8(KProtocolinfo,"protocolInfo");


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

// -----------------------------------------------------------------------------
// CUpnpObject::CUpnpObject
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CUpnpObject::CUpnpObject()
    {
    iRestricted = ETrue;
    }
    
// Destructor
EXPORT_C CUpnpObject::~CUpnpObject()
    {
    delete iId;
    delete iParentId;
    delete iTitle;
    delete iObjectClass;
    iElements.ResetAndDestroy();
    iElements.Close();
    }

// -----------------------------------------------------------------------------
// CUpnpObject::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CUpnpObject::ConstructL(  )
    {
    iId = KNullDesC8().AllocL();
    iParentId = KNullDesC8().AllocL();
    iTitle = KNullDesC8().AllocL();
    iObjectClass = KNullDesC8().AllocL();
    }

// -----------------------------------------------------------------------------
// CUpnpObject::SetIdL
// Sets Object Id
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpObject::SetIdL( const TDesC8& aId )
    {
    HBufC8* tmp = aId.AllocL();
    delete iId;
    iId = tmp;    
    }

// -----------------------------------------------------------------------------
// CUpnpObject::Id
// Returns Id of the object. If null, returns KNullDesC8
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CUpnpObject::Id() const
    {
    return *iId; 
    }

// -----------------------------------------------------------------------------
// CUpnpObject::SetParentIdL
// Sets Parent Id for the object.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpObject::SetParentIdL( const TDesC8& aParentId )
    {
    HBufC8* tmp = aParentId.AllocL();
    delete iParentId;
    iParentId = tmp;
    }
       
// -----------------------------------------------------------------------------
// CUpnpObject::ParentId
// Returns Parent Id of the object. If null, returns KNullDesC8
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C  const TDesC8& CUpnpObject::ParentId() const
    {
    return *iParentId;
    }
  
// -----------------------------------------------------------------------------
// CUpnpObject::AddElementL
// Returns name of the object. If null, returns KNullDesC8
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpObject::AddElementL( CUpnpElement* aNewElement )
    {
    if ( aNewElement )
        {
        iElements.AppendL( aNewElement );
        }
    }

// -----------------------------------------------------------------------------
// CUpnpObject::Name
// Returns name of the object. If null, returns KNullDesC8
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpObject::RemoveElementL( const CUpnpElement* aNewElement )
    {
    for ( TInt index(0); index < iElements.Count(); index++ )
        {
        if ( iElements[index] == aNewElement )
            {
            iElements.Remove( index );
           break;
            }
        }
    }  
// -----------------------------------------------------------------------------
// CUpnpObject::GetElements
// Returns name of the object. If null, returns KNullDesC8
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C const RUPnPElementsArray& CUpnpObject::GetElements()
    {
    return iElements;
    }
    
// -----------------------------------------------------------------------------
// CUpnpObject::SetNameL
// Sets name for the object.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpObject::SetTitleL( const TDesC8& aTitle )
    {
    HBufC8* tmp = aTitle.AllocL();
    delete iTitle;
    iTitle = tmp;  
    }
      
// -----------------------------------------------------------------------------
// CUpnpObject::Name
// Returns name of the object. If null, returns KNullDesC8
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CUpnpObject::Title() const
    {
    return *iTitle;
    }
// -----------------------------------------------------------------------------
// CUpnpObject::SetObjectClassL
// Sets class object for the object.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpObject::SetObjectClassL( const TDesC8& aObjectClass )
    {
    ValidateClassL(aObjectClass); // leaves on error
    HBufC8* tmp = aObjectClass.AllocL();
    delete iObjectClass;
    iObjectClass = tmp;  
    }
// -----------------------------------------------------------------------------
// CUpnpObject::ValidateClassL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CUpnpObject::ValidateClassL(const TDesC8& aObjectClass)   
{
    // verify the class
    if( ObjectType() == EUPnPContainer )
    { // it must contains "container" string
        if( aObjectClass.Find(KContainer) == KErrNotFound )
        {
            User::Leave(KErrArgument);
        }
    }
    else if(ObjectType() == EUPnPItem)
    {// it must contains "item" string
        if( aObjectClass.Find(KItem) == KErrNotFound )
        {
            User::Leave(KErrArgument);
        }
    }
    else
    { // should never happen
        User::Invariant();
    }
}
// -----------------------------------------------------------------------------
// CUpnpObject::ObjectClass
// Returns objectclass of the object. If null, returns KNullDesC8
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CUpnpObject::ObjectClass() const
    {
    return *iObjectClass;
    }

// -----------------------------------------------------------------------------
// CUpnpObject::SetRestriction()
// Sets the restriction info. 
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpObject::SetRestricted( TBool aRestriction )
    {
    iRestricted = aRestriction;
    }
   
// -----------------------------------------------------------------------------
// CUpnpObject::Restriction()
// Gets the restriction info. 
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CUpnpObject::Restricted() const
    {
    return iRestricted;
    }

// -----------------------------------------------------------------------------
// CUpnpObject::SetWriteStatus()
// Sets the restriction info. 
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpObject::SetWriteStatus( TBool aWriteStatus )
    {
    iWriteStatus = aWriteStatus;
    }
   
// -----------------------------------------------------------------------------
// CUpnpObject::Restriction()
// Gets the restriction info. 
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CUpnpObject::WriteStatus() const
    {
    return iWriteStatus;
    }
    
// -----------------------------------------------------------------------------
// CUpnpObject::CopyL
// Copies the content from parameter CUpnpObject to this
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpObject::CopyL( const CUpnpObject& aObject )
    {
    // Check that parameter type is also item
    if ( aObject.ObjectType() != ObjectType() )
        {
        User::Leave( KErrArgument );
        }
        
    CBufFlat* buffer = CBufFlat::NewL( sizeof( aObject ) );
    CleanupStack::PushL( buffer );

    RBufWriteStream outStream;
    outStream.Open( *buffer );
    CleanupClosePushL( outStream );
	
    RBufReadStream inStream;
    inStream.Open( *buffer );
    CleanupClosePushL( inStream );
	
    aObject.ExternalizeL( outStream );
    InternalizeL( inStream );
	
    CleanupStack::PopAndDestroy( 3 );   // inStream && outStream && buffer
    }

// -----------------------------------------------------------------------------
// CUpnpObject::BaseExternalizeL
// Writes the content to stream.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CUpnpObject::BaseExternalizeL( RWriteStream& aStream ) const 
    { 
		
    SafeExternalizeL(aStream, Id(), KMaxUpnpObjStringLen);
    SafeExternalizeL(aStream, ParentId(), KMaxUpnpObjStringLen);
    
    aStream.WriteInt8L(Restricted());
            
    SafeExternalizeL(aStream, Title(), KMaxUpnpObjStringLen);                            
    SafeExternalizeL(aStream, ObjectClass(), KMaxUpnpObjStringLen);
    
    // Elements
    aStream.WriteInt16L( iElements.Count() );
    for ( TInt index(0); index < iElements.Count(); index++ )
        {
        iElements[index]->ExternalizeL( aStream );
        }
    }
// -----------------------------------------------------------------------------
// CUpnpObject::SafeExternalizeL
// Writes safely aNumber of characters from the content to the stream.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CUpnpObject::SafeExternalizeL(RWriteStream& aStream, const TDesC8& aDesc, const TInt aNumber) const
{	
    if( aDesc.Length() > aNumber )    
		aStream << aDesc.Mid(0, aNumber);
    else
		aStream << aDesc;    
}

// -----------------------------------------------------------------------------
// CUpnpObject::BaseInternalizeL
// Fills item information from stream
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//	
void CUpnpObject::BaseInternalizeL( RReadStream& aStream )
    {
    delete iId;
    iId = NULL;
    iId = HBufC8::NewL( aStream, KMaxUpnpObjStringLen  );
    
    delete iParentId;
    iParentId = NULL;
    iParentId = HBufC8::NewL( aStream, KMaxUpnpObjStringLen );
    iRestricted = aStream.ReadInt8L();
    
    // Name (title)
    delete iTitle;
    iTitle = NULL;
    iTitle = HBufC8::NewL( aStream, KMaxUpnpObjStringLen );
    
    // ObjectClass
    delete iObjectClass;
    iObjectClass = NULL;
    iObjectClass = HBufC8::NewL( aStream, KMaxUpnpObjStringLen );	
            
    // Elements internalization
    iElements.ResetAndDestroy();
    
    // Elements count
    TInt elementsCount = aStream.ReadInt16L();	
    // Then internalize them from the stream one by one
    for (TInt index = 0; index < elementsCount; index++ )
        {
        CUpnpElement* newElement = CUpnpElement::NewLC();
        newElement->InternalizeL( aStream );
        iElements.AppendL( newElement );
        CleanupStack::Pop( newElement ); 
        }
	    
    }
// -----------------------------------------------------------------------------
// CUpnpObject::ToDes8L
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//	
EXPORT_C HBufC8* CUpnpObject::ToDes8L() const
{
    // serialize object
    CBufFlat* buf = CBufFlat::NewL(KDefBufferGranularity);
    CleanupStack::PushL(buf);
    RBufWriteStream stream(*buf);
    CleanupClosePushL(stream);
    
    stream << *this;
    
    // create heap descriptor
    HBufC8* hbuf = HBufC8::NewLC(buf->Size());
    TPtr8 ptr(hbuf->Des());
    buf->Read(0, ptr, buf->Size());
    
    // clean up
    CleanupStack::Pop(hbuf);
    CleanupStack::PopAndDestroy(&stream);
    CleanupStack::PopAndDestroy(buf);
    
    return hbuf;
}

// -----------------------------------------------------------------------------
// CUpnpObject::AddResourceL
// Attaches proper <res> element (resource associated with an UPnP object) to protocolInfo
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpObject::AddResourceL( const TDesC16& aFilename,const TDesC8& aProtocolinfo )
    {
	CUpnpElement* elRes = CUpnpElement::NewL(KRes);
    CleanupStack::PushL( elRes ); 
    elRes->SetFilePathL(aFilename); 
   
    CUpnpAttribute* atImportUri =
    CUpnpAttribute::NewL(KProtocolinfo);
    CleanupStack::PushL(atImportUri);
    atImportUri->SetValueL(aProtocolinfo);
    elRes->AddAttributeL(atImportUri);
    CleanupStack::Pop(atImportUri);        
      
    AddElementL( elRes );
    CleanupStack::Pop( elRes );  
    }
//  End of File