/*
* Copyright (c) 2002 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 class CDownloadDataClient.   
*      
*
*/


// INCLUDE FILES

#include <s32mem.h>
#include "DownloadDataClient.h"
#include "CodData.h"
#include "CodUtil.h"

// ================= CONSTANTS =======================


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

    
// ---------------------------------------------------------
// CMediaDataClient::NewL()
// ---------------------------------------------------------
//
CMediaDataClient* CMediaDataClient::NewL()
    {
    CMediaDataClient* data = new (ELeave) CMediaDataClient();
    CleanupStack::PushL( data );
    data->ConstructL();
    CleanupStack::Pop(); //data
    return data;
    }
    
// ---------------------------------------------------------
// CMediaDataClient::NewLC()
// ---------------------------------------------------------
//
CMediaDataClient* CMediaDataClient::NewLC()
    {
    CMediaDataClient* data = new (ELeave) CMediaDataClient();
    CleanupStack::PushL( data );
    data->ConstructL();
    return data;
    }

// ---------------------------------------------------------
// CMediaDataClient::~CMediaDataClient()
// ---------------------------------------------------------
//    
CMediaDataClient::~CMediaDataClient()
    {
    delete iName;
    delete iUrl;
    delete iIcon;
    delete iSourceUri;
    delete iRedirUrl;
    delete iDestFilename;
    delete iTempFilename;
    }
    
// ---------------------------------------------------------
// CMediaDataClient::ConstructL()
// ---------------------------------------------------------
//
void CMediaDataClient::ConstructL()
    {
    iName = HBufC::NewL( 0 );
    iUrl = HBufC8::NewL( 0 );
    iTypes = new (ELeave) CDesC8ArrayFlat( KTypeGranularity );
    iIcon = HBufC8::NewL( 0 );
    iSourceUri = HBufC8::NewL( 0 );
    iRedirUrl = HBufC8::NewL( 0 );
    iDestFilename = HBufC::NewL( 0 );
    iTempFilename = HBufC::NewL( 0 );
    }
    
// ---------------------------------------------------------
// CMediaDataClient::Bytes()
// ---------------------------------------------------------
//
TInt CMediaDataClient::Bytes() const
    {
    TInt bytes = 0;
    
    bytes += iName->Size();
    bytes += iUrl->Size();
    bytes += sizeof(iSize);
    bytes += iIcon->Size();
    bytes += iSourceUri->Size();
    bytes += sizeof(iProgressiveDl);
    bytes += sizeof(iState);
    
    bytes += iRedirUrl->Size();
    bytes += sizeof(iMethod);
    bytes += sizeof(iRedirected);
    bytes += iDestFilename->Size();
    bytes += sizeof(iDownloadedSize);
    bytes += sizeof(iDesRemovable);
    bytes += sizeof(iLastErrorId);
    bytes += sizeof(iGlobalErrorId);
    bytes += sizeof(iPausable);
    bytes += iTempFilename->Size();
    
    // iTypes array elements
    for (TInt index = 0; index < iTypes->MdcaCount(); ++index)
        bytes += iTypes->MdcaPoint(index).Size();
    
    return bytes;
    }

// ---------------------------------------------------------
// CMediaDataClient::SetNameL()
// ---------------------------------------------------------
//
TBool CMediaDataClient::SetNameL( const TDesC& aName )
    {
    return SetStringAttrL( iName, aName, COD_NAME_MAX_LEN );
    }

// ---------------------------------------------------------
// CMediaDataClient::SetUrlL()
// ---------------------------------------------------------
//
TBool CMediaDataClient::SetUrlL( const TDesC8& aUrl )
    {
    return SetStringAttrL( iUrl, aUrl, COD_URL_MAX_LEN );
    }

// ---------------------------------------------------------
// CMediaDataClient::SetSize()
// ---------------------------------------------------------
//
TBool CMediaDataClient::SetSize( TUint aSize )
    {
    if( aSize <= 0 )
        {
        return EFalse;
        }
    iSize = aSize;
    return ETrue;
    }

// ---------------------------------------------------------
// CMediaDataClient::SetTypeL()
// ---------------------------------------------------------
//
TBool CMediaDataClient::SetTypeL( const TDesC8& aType )
    {
    // Backwards-compatible deprecated method.
    iTypes->Reset();    // Replace all, support only one type.
    return AddTypeL( aType );
    }

// ---------------------------------------------------------
// CMediaDataClient::AddTypeL()
// ---------------------------------------------------------
//
TBool CMediaDataClient::AddTypeL( const TDesC8& aType )
    {
    if ( aType.Length() > COD_TYPE_MAX_LEN || !aType.Length() )
        {
        return EFalse;
        }
    HBufC8* type8 = aType.AllocLC();
    iTypes->AppendL( *type8 );
    CleanupStack::PopAndDestroy(); //type8
    return ETrue;
    }
    
// ---------------------------------------------------------
// CMediaDataClient::ResetTypes()
// ---------------------------------------------------------
//
void CMediaDataClient::ResetTypes()
	{
	iTypes->Reset();
	}

// ---------------------------------------------------------
// CMediaDataClient::SetIconL()
// ---------------------------------------------------------
//
TBool CMediaDataClient::SetIconL( const TDesC8& aIcon )
    {
    return SetStringAttrL( iIcon, aIcon, COD_ICON_MAX_LEN );
    }

// ---------------------------------------------------------
// CMediaDataClient::SetSourceUriL()
// ---------------------------------------------------------
//
void CMediaDataClient::SetSourceUriL( const TDesC8& aSourceUri )
    {
    HBufC8* buf = aSourceUri.AllocL();
    delete iSourceUri;
    iSourceUri = buf;
    }

// ---------------------------------------------------------
// CMediaDataClient::SetProgressiveDownload()
// ---------------------------------------------------------
//
void CMediaDataClient::SetProgressiveDownload( TBool aProgressiveDl )
    {
    iProgressiveDl = aProgressiveDl;
    }

// ---------------------------------------------------------
// CMediaDataClient::SetState()
// ---------------------------------------------------------
//
void CMediaDataClient::SetState( TMediaObjectState aState )
    {
    iState = aState;
    }

// ---------------------------------------------------------
// CMediaDataClient::SetResult()
// ---------------------------------------------------------
//
void CMediaDataClient::SetResult( TInt aResult )
    {
    iResult = aResult;
    }
// ---------------------------------------------------------
// CMediaDataClient::SetStatusCode()
// ---------------------------------------------------------
//
void CMediaDataClient::SetStatusCode( TInt aStatusCode )
    {
    iStatusCode = aStatusCode;
    }

// ---------------------------------------------------------
// CMediaDataClient::SetRedirUrlL()
// ---------------------------------------------------------
//
TBool CMediaDataClient::SetRedirUrlL( const TDesC8& aRedirUrl )
	{
	return SetStringAttrL( iRedirUrl, aRedirUrl, COD_URL_MAX_LEN );
	}

// ---------------------------------------------------------
// CMediaDataClient::SetMethod()
// ---------------------------------------------------------
//
void CMediaDataClient::SetMethod( TInt aMethod )
	{
	iMethod = aMethod;
	}

// ---------------------------------------------------------
// CMediaDataClient::SetRedirected()
// ---------------------------------------------------------
//
void CMediaDataClient::SetRedirected( TBool aRedirected )
	{
	iRedirected = aRedirected;
	}

// ---------------------------------------------------------
// CMediaDataClient::SetDestFilenameL()
// ---------------------------------------------------------
//
TBool CMediaDataClient::SetDestFilenameL( const TDesC& aDestFilename )
	{
	return SetStringAttrL( iDestFilename, aDestFilename, KMaxFileName );
	}
	
// ---------------------------------------------------------
// CMediaDataClient::SetTempFilenameL()
// ---------------------------------------------------------
//
TBool CMediaDataClient::SetTempFilenameL( const TDesC& aTempFilename )
	{
	return SetStringAttrL( iTempFilename, aTempFilename, KMaxFileName );
	}

// ---------------------------------------------------------
// CMediaDataClient::SetDownloadedSize()
// ---------------------------------------------------------
//
TBool CMediaDataClient::SetDownloadedSize( TInt aDownloadedSize )
	{
	if( aDownloadedSize <= 0 )
        {
        return EFalse;
        }
    iDownloadedSize = aDownloadedSize;
    return ETrue;
	}

// ---------------------------------------------------------
// CMediaDataClient::SetDesRemovable()
// ---------------------------------------------------------
//
void CMediaDataClient::SetDesRemovable( TBool aDesRemovable )
	{
	iDesRemovable = aDesRemovable;
	}

// ---------------------------------------------------------
// CMediaDataClient::SetLastErrorId()
// ---------------------------------------------------------
//
void CMediaDataClient::SetLastErrorId( TInt aLastErrorId )
	{
	iLastErrorId = aLastErrorId;
	}

// ---------------------------------------------------------
// CMediaDataClient::SetGlobalErrorId()
// ---------------------------------------------------------
//
void CMediaDataClient::SetGlobalErrorId( TInt aGlobalErrorId )
	{
	iGlobalErrorId = aGlobalErrorId;
	}

// ---------------------------------------------------------
// CMediaDataClient::SetPausable()
// ---------------------------------------------------------
//
void CMediaDataClient::SetPausable( TBool aPausable )
	{
	iPausable = aPausable;
	}
	
// ---------------------------------------------------------
// CMediaDataClient::SetStringAttrL()
// ---------------------------------------------------------
//
TBool CMediaDataClient::SetStringAttrL
( HBufC*& aBuf, const TDesC& aString, TInt aMaxLength )
    {
    if ( aString.Length() > aMaxLength )
        {
        return EFalse;
        }
    HBufC* buf = aString.AllocL();
    delete aBuf;
    aBuf = buf;
    return ETrue;
    }

// ---------------------------------------------------------
// CMediaDataClient::SetStringAttrL()
// ---------------------------------------------------------
//
TBool CMediaDataClient::SetStringAttrL
( HBufC8*& aBuf, const TDesC& aString, TInt aMaxLength )
    {
    if ( aString.Length() > aMaxLength )
        {
        return EFalse;
        }
        
    HBufC8* buf = CodUtil::ConvertL( aString );
    delete aBuf;
    aBuf = buf;
    return ETrue;
    }

// ---------------------------------------------------------
// CMediaDataClient::SetStringAttrL()
// ---------------------------------------------------------
//
TBool CMediaDataClient::SetStringAttrL
( HBufC8*& aBuf, const TDesC8& aString, TInt aMaxLength )
    {
    if ( aString.Length() > aMaxLength )
        {
        return EFalse;
        }
    HBufC8* buf = aString.AllocL();
    delete aBuf;
    aBuf = buf;
    return ETrue;
    }

// ---------------------------------------------------------
// CMediaDataClient::MarshalDataL()
// ---------------------------------------------------------
//
HBufC8* CMediaDataClient::MarshalDataL() const
    {
    TInt bufLen = Bytes();      // Size of class including iMediaArray elements.
                                //  Note that this includes actual bytes occupied by
                                //  contents of descriptors and pointers.
                                
    bufLen += sizeof(TInt);  	// We include the count of elements in iTypes array
                                //  while externalizing.
                                
    
    // Dynamic data buffer
    CBufFlat* buf = CBufFlat::NewL(bufLen);
    CleanupStack::PushL(buf);
    // Stream over the buffer
    RBufWriteStream stream(*buf);
    CleanupClosePushL(stream);
    
    ExternalizeL(stream);
    CleanupStack::PopAndDestroy(); //stream
    
    // Create a heap descriptor from the buffer
    HBufC8* des = HBufC8::NewL(buf->Size());
    TPtr8 ptr(des->Des());
    buf->Read(0, ptr, buf->Size());
    CleanupStack::PopAndDestroy(); //buf
    
    return des;
    }

// ---------------------------------------------------------
// CMediaDataClient::ExternalizeL()
// ---------------------------------------------------------
//	
void CMediaDataClient::ExternalizeL(RWriteStream& aStream) const
    {
    // iName
    if (iName)
        aStream << *iName;
    else
        aStream << KNullDesC;
    
    // iUrl
    if (iUrl)
        aStream << *iUrl;
    else
        aStream << KNullDesC;
    
    // iSize
    aStream.WriteUint32L(iSize);
    
    // Number of elements in iTypes array
    if (iTypes)
        {
        TInt count = iTypes->MdcaCount();
        aStream.WriteInt32L(count);
        // Elements of iTypes array
        for (TInt index = 0; index < count; ++index)
            aStream << iTypes->MdcaPoint(index);
        }
    else
        {
        aStream.WriteInt32L(0);
        }
    
    // iIcon
    if (iIcon)
        aStream << *iIcon;
    else
        aStream << KNullDesC;
    
    // iSourceUri
    if (iSourceUri)
        aStream << *iSourceUri;
    else
        aStream << KNullDesC;
    
    // iProgressiveDl
    aStream.WriteInt32L(iProgressiveDl);
    
    // iState
    aStream.WriteInt32L(iState);
    
    // iResult
    aStream.WriteInt32L(iResult);
    
    // iRedirUrl
    if (iRedirUrl)
        aStream << *iRedirUrl;
    else
        aStream << KNullDesC;
    
    // iMethod
    aStream.WriteInt32L(iMethod);
    
    // iRedirected
    aStream.WriteInt32L(iRedirected);
    
    // iDestFilename
    if (iIcon)
        aStream << *iDestFilename;
    else
        aStream << KNullDesC;
    
    // iDownloadedSize
    aStream.WriteInt32L(iDownloadedSize);
    
    // iDesRemovable
    aStream.WriteInt32L(iDesRemovable);
    
    // iLastErrorId
    aStream.WriteInt32L(iLastErrorId);
    
    // iGlobalErrorId
    aStream.WriteInt32L(iGlobalErrorId);
    
    // iPausable
    aStream.WriteInt32L(iPausable);
    // iStatusCode
    aStream.WriteInt32L(iStatusCode);
    }

void CMediaDataClient::InternalizeL(RReadStream& /*aStream*/)
    {
    }

// ---------------------------------------------------------
// CDownloadDataClient::NewL()
// ---------------------------------------------------------
//
CDownloadDataClient* CDownloadDataClient::NewL()
    {
    CDownloadDataClient* data = new (ELeave) CDownloadDataClient();
    CleanupStack::PushL( data );
    data->ConstructL();
    CleanupStack::Pop(); //data
    return data;
    }

// ---------------------------------------------------------
// CDownloadDataClient::NewLC()
// ---------------------------------------------------------
//
CDownloadDataClient* CDownloadDataClient::NewLC()
    {
    CDownloadDataClient* data = new (ELeave) CDownloadDataClient();
    CleanupStack::PushL( data );
    data->ConstructL();
    return data;
    }

// ---------------------------------------------------------
// CDownloadDataClient::~CDownloadDataClient()
// ---------------------------------------------------------
//
CDownloadDataClient::~CDownloadDataClient()
    {
    delete iName;
    delete iIcon;
	delete iUpdatedDDUri;
    
    iMediaArray.ResetAndDestroy();
    }

// ---------------------------------------------------------
// CDownloadDataClient::ConstructL()
// ---------------------------------------------------------
//
void CDownloadDataClient::ConstructL()
    {
    iName = HBufC::NewL( 0 );
    iSize = 0;
    iIcon = HBufC8::NewL( 0 );
	iUpdatedDDUri = HBufC8::NewL( 0 );
    }

// ---------------------------------------------------------
// CDownloadDataClient::Bytes()
// ---------------------------------------------------------
//
TInt CDownloadDataClient::Bytes() const
    {
    TInt bytes = 0;
    
    bytes += iName->Size();
    bytes += sizeof(iSize);
    bytes += iIcon->Size();
    bytes += iUpdatedDDUri->Size();
    
    // iMediaArray elements 
    for (TInt index = 0; index < iMediaArray.Count(); ++index)
        bytes += iMediaArray[index]->Bytes();
    
    return bytes;
    }

// ---------------------------------------------------------
// CDownloadDataClient::SetNameL()
// ---------------------------------------------------------
//
TBool CDownloadDataClient::SetNameL( const TDesC& aName )
    {
    return SetStringAttrL( iName, aName, COD_NAME_MAX_LEN );
    }

// ---------------------------------------------------------
// CDownloadDataClient::SetSize()
// ---------------------------------------------------------
//
TBool CDownloadDataClient::SetSize( TUint aSize )
    {
    if( aSize <= 0 )
        {
        return EFalse;
        }
    iSize = aSize;
    return ETrue;
    }

// ---------------------------------------------------------
// CDownloadDataClient::SetIconL()
// ---------------------------------------------------------
//
TBool CDownloadDataClient::SetIconL( const TDesC8& aIcon )
    {
    return SetStringAttrL( iIcon, aIcon, COD_ICON_MAX_LEN );
    }
    
// ---------------------------------------------------------
// CDownloadDataClient::SetUpdatedDDURI()
// ---------------------------------------------------------
//
TBool CDownloadDataClient::SetUpdatedDDURI( const TDesC8& aUrl)
    {
    return SetStringAttrL( iUpdatedDDUri, aUrl, COD_URL_MAX_LEN );
    }    

// ---------------------------------------------------------
// CDownloadDataClient::SetStringAttrL()
// ---------------------------------------------------------
//
TBool CDownloadDataClient::SetStringAttrL
( HBufC*& aBuf, const TDesC& aString, TInt aMaxLength )
    {
    if ( aString.Length() > aMaxLength )
        {
        return EFalse;
        }
    HBufC* buf = aString.AllocL();
    delete aBuf;
    aBuf = buf;
    return ETrue;
    }

// ---------------------------------------------------------
// CDownloadDataClient::SetStringAttrL()
// ---------------------------------------------------------
//
TBool CDownloadDataClient::SetStringAttrL
( HBufC8*& aBuf, const TDesC& aString, TInt aMaxLength )
    {
    if ( aString.Length() > aMaxLength )
        {
        return EFalse;
        }
    HBufC8* buf = CodUtil::ConvertL( aString );
    delete aBuf;
    aBuf = buf;
    return ETrue;
    }

// ---------------------------------------------------------
// CDownloadDataClient::SetStringAttrL()
// ---------------------------------------------------------
//
TBool CDownloadDataClient::SetStringAttrL
( HBufC8*& aBuf, const TDesC8& aString, TInt aMaxLength )
    {
    if ( aString.Length() > aMaxLength )
        {
        return EFalse;
        }
    HBufC8* buf = aString.AllocL();
    delete aBuf;
    aBuf = buf;
    return ETrue;
    }
	
// ---------------------------------------------------------
// CDownloadDataClient::AppendMediaData()
// ---------------------------------------------------------
//
TInt CDownloadDataClient::AppendMediaData( CMediaDataClient *aMO )
    {
    iMediaArray.AppendL( aMO );
    // return item index
    return iMediaArray.Count();    
    }
    
// ---------------------------------------------------------
// CDownloadDataClient::operator[]
// ---------------------------------------------------------
//

CMediaDataBase* CDownloadDataClient::operator[]( TInt aIndex )
    {
    //Check if the media object exits at specified index. Return the same if it is.
    if( aIndex >= 0 && aIndex < iMediaArray.Count() )
        {
        return iMediaArray[aIndex];
        }
    return NULL;    
    }

// ---------------------------------------------------------
// CDownloadDataClient::operator[]
// ---------------------------------------------------------
//

CMediaDataBase* CDownloadDataClient::operator[]( TInt aIndex ) const
    {
    //Check if the media object exits at specified index. Return the same if it is.
    if( aIndex >= 0 && aIndex < iMediaArray.Count() )
        {
        return iMediaArray[aIndex];
        }
    return NULL;    
    }

// ---------------------------------------------------------
// CDownloadDataClient::MarshalDataL()
// ---------------------------------------------------------
//
HBufC8* CDownloadDataClient::MarshalDataL() const
    {
    TInt bufLen = Bytes();      // Size of class including iMediaArray elements.
                                //  Note that this includes actual bytes occupied by
                                //  contents of descriptors and pointers.
                                
    bufLen += sizeof(TInt);  // We include the count of elements in iMediaArray
                                //  while externalizing.
                                
    bufLen += sizeof(TInt) * iMediaArray.Count();
                                // iMediaArray has an array iTypes. We are including
                                //  count of elements in iTypes array while externalizing
                                //  each element of iMediaArray.
    
    // Dynamic data buffer
    CBufFlat* buf = CBufFlat::NewL(bufLen);
    CleanupStack::PushL(buf);
    // Stream over the buffer
    RBufWriteStream stream(*buf);
    CleanupClosePushL(stream);
    
    ExternalizeL(stream);
    CleanupStack::PopAndDestroy(); //stream
    
    // Create a heap descriptor from the buffer
    HBufC8* des = HBufC8::NewL(buf->Size());
    TPtr8 ptr(des->Des());
    buf->Read(0, ptr, buf->Size());
    CleanupStack::PopAndDestroy(); //buf
    
    return des;
    }

// ---------------------------------------------------------
// CDownloadDataClient::ExternalizeL()
// ---------------------------------------------------------
//
void CDownloadDataClient::ExternalizeL(RWriteStream& aStream) const
    {
    // iName
    if (iName)
        aStream << *iName;
    else
        aStream << KNullDesC;
    
    // iSize
    aStream.WriteUint32L(iSize);
    
    // iIcon
    if (iIcon)
        aStream << *iIcon;
    else
        aStream << KNullDesC;
    
    // iUpdatedDDUri
    if (iUpdatedDDUri)
        aStream << *iUpdatedDDUri;
    else
        aStream << KNullDesC;
    
    // iMediaArray elements 
    TInt count = iMediaArray.Count();
    aStream.WriteInt32L(count);
    for (TInt index = 0; index < count; ++index)
        iMediaArray[index]->ExternalizeL(aStream);
   
    }