/*

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

*

*/

#include "afentry.h"

#include <s32mem.h>

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

/**

 * Two-phase constructor. Create and initialize instance

 * @return entry instance

 */

CAfEntry* CAfEntry::NewL()

{

    CAfEntry *self = CAfEntry::NewLC();

    CleanupStack::Pop(self);

    return self;

}

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

/**

 * Two-phase constructor. Create, initialize and push instance into cleanup stack

 * @return entry instance

 */

CAfEntry* CAfEntry::NewLC()

{

    CAfEntry *self = new (ELeave)CAfEntry();

    CleanupStack::PushL(self);

    return self;

}

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

/**

 * Two-phase constructor. Create and initialize instance

 * @param flags - entry flags

 * @param applicationId - application unique identifier

 * @param activityId - activity unique identifier

 * @param imgSrc - thumbanail source

 * @param privateData - privated application data

 * @param publicData - public activity data

 * @return entry instance

 */

CAfEntry* CAfEntry::NewL(TInt flags,

                         TInt applicationId,

                         const TDesC &activityId,

                         const TDesC &imgSrc,

                         const TDesC8 &privateData,

                         const TDesC8 &publicData)

{

    CAfEntry* self = CAfEntry::NewLC(flags, 

                                     applicationId, 

                                     activityId, 

                                     imgSrc, 

                                     privateData, 

                                     publicData);

    CleanupStack::Pop(self);

    return self;

}

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

/**

 * Two-phase constructor. Create, initialize and push instance into cleanup stack

 * @param flags - entry flags

 * @param applicationId - application unique identifier

 * @param activityId - activity unique identifier

 * @param imgSrc - thumbanail source

 * @param privateData - privated application data

 * @param publicData - public activity data

 * @return entry instance

 */

CAfEntry* CAfEntry::NewLC(TInt flags,

                          TInt applicationId,

                          const TDesC &activityId,

                          const TDesC &imgSrc,

                          const TDesC8 &privateData,

                          const TDesC8 &publicData)

{

    CAfEntry *self = CAfEntry::NewLC();

    self->ConstructL(flags, 

                     applicationId, 

                     activityId, 

                     imgSrc, 

                     privateData, 

                     publicData);

    return self;

}

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

/**

 * First phase constructor

 */

CAfEntry::CAfEntry()

{

}

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

/**

 * Second phase constructor. Initialize instance

 * @param flags - entry flags

 * @param applicationId - application unique identifier

 * @param activityId - activity unique identifier

 * @param imgSrc - thumbanail source

 * @param privateData - privated application data

 * @param publicData - public activity data 

 */

void CAfEntry::ConstructL(TInt flags,

                          TInt applicationId,

                          const TDesC &activityId,

                          const TDesC &imgSrc,

                          const TDesC8 &privateData,

                          const TDesC8 &publicData)

{

    mFlags = flags;

    mAppId = applicationId;

    CopyL(mActivityId, activityId);

    CopyL(mImgSrc, imgSrc);

    CopyL(mPrivateData, privateData);

    CopyL(mPublicData, publicData);

}

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

/**

 * Destructor. Release allocated resources 

 */

CAfEntry::~CAfEntry()

{

    mActivityId.Close();

    mPrivateData.Close();

    mPublicData.Close();

    mImgSrc.Close();

}

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

/**

 * Provide size of serialized entry

 * @return size of serialized entry instance

 */

TInt CAfEntry::Size() const

{

    return (sizeof(TInt) * 3) + //flags + appId + actId size info 

           mActivityId.Size() + //actId content size

           DataSize(); //data size

}

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

/**

 * Provide size of serialized entry

 * @return size of serialized entry instance

 */

TInt CAfEntry::DataSize() const

{

    return (sizeof(TInt) * 3) + //privData size info + pubData size info + imgSrc size info

            mImgSrc.Size() + //imgSize content size

            mPrivateData.Size() + //privData content size

            mPublicData.Size(); //pubData content size 

}

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

/**

 * Serialize entry content into output stream.

 * @param stream - output stream

 */

void CAfEntry::ExternalizeL(RWriteStream &stream) const

{

    stream.WriteInt32L(mFlags);

    stream.WriteInt32L(mAppId);

    ExternalizeL(stream, mActivityId);

    ExternalizeDataOnlyL(stream);

}

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

/**

 * Deserialize entry content from input stream

 * @param stream - input stream

 */

void CAfEntry::InternalizeL(RReadStream &stream)

{

    mFlags = stream.ReadInt32L();

    mAppId = stream.ReadInt32L();

    InternalizeL(mActivityId, stream);

    InternalizeDataOnlyL(stream);

}

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

/**

 * Serialize entry content into output stream.

 * @param stream - output stream

 */

void CAfEntry::ExternalizeDataOnlyL(RWriteStream &stream) const

{

    ExternalizeL(stream, mImgSrc);

    ExternalizeL(stream, mPrivateData);

    ExternalizeL(stream, mPublicData);

}

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

/**

 * Deserialize entry content from input stream

 * @param stream - input stream

 */

void CAfEntry::InternalizeDataOnlyL(RReadStream &stream)

{

    InternalizeL(mImgSrc, stream);

    InternalizeL(mPrivateData, stream);

    InternalizeL(mPublicData, stream);

}

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

/**

 * Provide access to activity flags

 * @return activity flags 

 */

TInt CAfEntry::Flags() const

{

    return mFlags;

}

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

/**

 * Provide access to activity identifier.

 * @return activity identifier

 */

TInt CAfEntry::ApplicationId() const

{

    return mAppId;

}

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

/**

 * Provide access to activity identifier.

 * @return activity identifier

 */

const TDesC& CAfEntry::ActivityId() const

{

    return mActivityId;

}

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

/**

 * Provide access to activity data.

 * @param rights - type of requested data

 * @return activity data

 */

const TDesC8& CAfEntry::Data(CAfEntry::AccessRights rights) const

{

    return Private == rights ? mPrivateData : mPublicData;

}

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

/**

 * Provide access to activity data.

 * @param rights - type of requested data

 * @return activity data

 */

void CAfEntry::SetDataL(const TDesC8& src, CAfEntry::AccessRights rights)

{

    CopyL(Private == rights ? mPrivateData : mPublicData, src);

}

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

/**

 * Provide access to activity thumbail path

 * @return path to activity thumbnail 

 */

const TDesC& CAfEntry::ImageSrc() const

{

    return mImgSrc;

}

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

/**

 * Set new value of image source

 */

void CAfEntry::SetImageSrcL(const TDesC& src)

{

    CopyL(mImgSrc, src);

}

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

/**

 * Reallocate blob buffer to requested size

 * @param dst - destination buffer

 * @param length - requested length

 */

void CAfEntry::ReallocL(RBuf8 &dst,TInt length)

{

    if (0 < length) {

        if (dst.MaxLength() < length) {

            dst.ReAllocL(length);

        }

    } else {

        dst.Close();

    }

}

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

/**

 * Reallocate text buffer to requested size

 * @param dst - destination buffer

 * @param length - requested length

 */

void CAfEntry::ReallocL(RBuf &dst,TInt length)

{

    if (0 < length) {

        if (dst.MaxLength() < length) {

            dst.ReAllocL(length);

        }

    } else {

        dst.Close();

    }

}

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

/**

 * Copy blob content from input stream

 * @param dst - destination buffer

 * @param src - source buffer

 */

void CAfEntry::CopyL(RBuf8 &dst,const TDesC8 &src)

{

    ReallocL(dst, src.Length());

    if(0 < src.Length()) {

        dst.Copy(src);

    }

}

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

/**

 * Copy text content from input buffer

 * @param dst - destination buffer

 * @param src - source buffer

 */

void CAfEntry::CopyL(RBuf &dst,const TDesC &src)

{

    ReallocL(dst, src.Length());

    if(0 < src.Length()) {

        dst.Copy(src);

    }

}

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

/**

 * Deserialize blob content from input stream

 * @param dst - destination buffer

 * @param src - input stream

 */

void CAfEntry::InternalizeL(RBuf8 &dst, RReadStream &src)

{

    const TInt length(src.ReadInt32L());

    ReallocL(dst, length);

    if (0 < length) {

        src.ReadL(dst, length);

    }

}

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

/**

 * Deserialize text content from input stream

 * @param dst - destination buffer

 * @param src - input stream

 */

void CAfEntry::InternalizeL(RBuf &dst, RReadStream &src)

{

    const TInt length(src.ReadInt32L());

    ReallocL(dst, length);

    if (0 < length) {

        src.ReadL(dst, length);

    }

}

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

/**

 * Serialize blob content into output stream

 * @param dst - destination stream

 * @param src - input buffer

 */

void CAfEntry::ExternalizeL(RWriteStream &dst,const TDesC8 & src)

{

    dst.WriteInt32L(src.Length());

    if (src.Length()) {

        dst.WriteL(src, src.Length());

    }

}

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

/**

 * Serialize text content into output stream

 * @param dst - destination stream

 * @param src - input buffer

 */

void CAfEntry::ExternalizeL(RWriteStream &dst,const TDesC& src)

{

    dst.WriteInt32L(src.Length());

    if (src.Length()) {

        dst.WriteL(src, src.Length());

    }

}

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

RPointerArray<CAfEntry>& operator <<(RPointerArray<CAfEntry>& dst, const TDesC8 &src)

{

    dst.ResetAndDestroy();

    RDesReadStream srcStream(src);

    CleanupClosePushL(srcStream);

    int numOfItems(srcStream.ReadInt32L());

    for (int i(0); i < numOfItems; ++i) {

        CAfEntry *entry = CAfEntry::NewLC();

        srcStream >> (*entry);

        dst.AppendL(entry);

        CleanupStack::Pop(entry);

    }

    CleanupStack::PopAndDestroy(&srcStream);

    return dst;

}

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

RBuf8& operator <<(RBuf8 &dst, const RPointerArray<CAfEntry>& src)

{

    int iter(0), 

        requiredSize(sizeof(int));

    for(iter =0; iter< src.Count(); ++iter) {

        requiredSize += src[iter]->Size();

    }

    CAfEntry::ReallocL(dst, requiredSize);

    RDesWriteStream dstStream(dst);

    CleanupClosePushL(dstStream);

    dstStream.WriteInt32L(src.Count());

    for (iter =0; iter < src.Count(); ++iter) {

        dstStream << *(src[iter]);

    }

    CleanupStack::PopAndDestroy(&dstStream);

    return dst;

}