/*
* 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:  Implementation of array of media objects
*
*/


#include "mpxmediaarray.h"
#include "mpxmedia.h"
#include "mpxcmn.h"

// CONSTANTS
//
// Media attribute for the media object added to array
//
const TMPXAttributeData KMPXMediaArrayItem= {0x101FFC12, 0X01};

// -----------------------------------------------------------------------------
// CMPXMediaArray::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CMPXMediaArray* CMPXMediaArray::NewL()
    {
    CMPXMediaArray* a=new(ELeave)CMPXMediaArray();
    CleanupStack::PushL(a);
    a->ConstructL();
    CleanupStack::Pop(a);
    return a;
    }

// -----------------------------------------------------------------------------
// CMPXMediaArray::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CMPXMediaArray* CMPXMediaArray::NewL(const CMPXMediaArray& aArray)
    {
    CMPXMediaArray* a=new(ELeave)CMPXMediaArray();
    CleanupStack::PushL(a);
    a->ConstructL(aArray);
    CleanupStack::Pop(a);
    return a;
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
EXPORT_C CMPXMediaArray::~CMPXMediaArray()
    {
    }

// -----------------------------------------------------------------------------
// Externalize
// -----------------------------------------------------------------------------
//
EXPORT_C void CMPXMediaArray::ExternalizeL(RWriteStream& aStream) const
    {
    DoExternalizeL(aStream,MMPXData::EMediaArray);
    }

// -----------------------------------------------------------------------------
// Internalize. ConstructL() will have been called prior to this so there
// will definitely be a iClientHandle, iDataHandle and iData, though there may or
// may not be any data added. Either way, the data should be reset.
// -----------------------------------------------------------------------------
//
EXPORT_C void CMPXMediaArray::InternalizeL(RReadStream& aStream)
    {
    DoInternalizeL(aStream,MMPXData::EMediaArray);
    }

// -----------------------------------------------------------------------------
// Total number of objects contained in array
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CMPXMediaArray::Count() const
    {
    return CMPXMediaBase::Count();
    }

// -----------------------------------------------------------------------------
// Array assessor
// -----------------------------------------------------------------------------
//
EXPORT_C CMPXMedia* CMPXMediaArray::operator[](TInt aIndex) const
    {
    return Value(aIndex);
    }

// -----------------------------------------------------------------------------
// Get a pointer to the media object at the specified position within the array
// -----------------------------------------------------------------------------
//
EXPORT_C CMPXMedia* CMPXMediaArray::AtL(TInt aIndex) const
    {
    return ValueL(aIndex);
    }

// -----------------------------------------------------------------------------
// Appends media object to array
// Takes the ownship of aMedia
// -----------------------------------------------------------------------------
//
EXPORT_C void CMPXMediaArray::AppendL(const CMPXMedia* aMedia)
    {
    AppendL(*aMedia);
    delete const_cast<CMPXMedia*>(aMedia);
    }

// -----------------------------------------------------------------------------
// Appends media object to array
// -----------------------------------------------------------------------------
//
EXPORT_C void CMPXMediaArray::AppendL(const CMPXMedia& aMedia)
    {
    User::LeaveIfError(AddToArray(aMedia,CMPXMediaBase::Count()));
    }

// -----------------------------------------------------------------------------
// Resets the media array
// -----------------------------------------------------------------------------
//
EXPORT_C void CMPXMediaArray::Reset()
    {
    MPX_ASSERT(iClientHandle&&iData);
    //
    ResetLocal(); // Local data
    iData->Reset(iClientHandle); // Clears heap data for this object
    }

// -----------------------------------------------------------------------------
// Removes the specified media from the array
// -----------------------------------------------------------------------------
//
EXPORT_C void CMPXMediaArray::Remove(TInt aIndex)
    {
    MPX_ASSERT(iData&&iClientHandle&&aIndex>=0&&aIndex<Count());
    DeleteLocal(aIndex);
    iData->Delete(iClientHandle,aIndex); // And data for this object
    }

// -----------------------------------------------------------------------------
// Inserts the specified media into the array at the specified position
// Takes the ownership of aMedia
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CMPXMediaArray::Insert(const CMPXMedia *aMedia, TInt aPos)
    {
    TInt r=AddToArray(*aMedia,aPos);
    if (r==KErrNone)
        {
        delete const_cast<CMPXMedia*>(aMedia);
        }
    return r;
    }

// -----------------------------------------------------------------------------
// Inserts the specified media into the array at the specified position
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CMPXMediaArray::Insert(const CMPXMedia& aMedia, TInt aPos)
    {
    return AddToArray(aMedia,aPos);
    }

// -----------------------------------------------------------------------------
// Sets the specified media into the array at the specified position
// -----------------------------------------------------------------------------
//
EXPORT_C void CMPXMediaArray::Set(const CMPXMedia& aMedia, TInt aPos)
    {
    MMPXData::LockHeap( iClientHandle );
    DeleteLocal(aPos);
    (void)AddToArray(aMedia,aPos,ETrue);
    MMPXData::UnlockHeap( iClientHandle );
    }

// -----------------------------------------------------------------------------
// Inserts the specified media into the array at the specified position and
// leave if an error is encountered
// Takes ownership of the aMedia
// -----------------------------------------------------------------------------
//
EXPORT_C void CMPXMediaArray::InsertL(const CMPXMedia *aMedia, TInt aPos)
    {
    User::LeaveIfError(Insert(aMedia,aPos));
    }

// -----------------------------------------------------------------------------
// Inserts the specified media into the array at the specified position and
// leave if an error is encountered
// -----------------------------------------------------------------------------
//
EXPORT_C void CMPXMediaArray::InsertL(const CMPXMedia& aMedia, TInt aPos)
    {
    User::LeaveIfError(AddToArray(aMedia,aPos));
    }


// -----------------------------------------------------------------------------
// The value for a specific index
// -----------------------------------------------------------------------------
//
CMPXMedia* CMPXMediaArray::Value(TInt aIndex) const
    {
    CMPXMedia* m=NULL;
    TRAP_IGNORE(m=ValueL(aIndex));
    return m;
    }

// -----------------------------------------------------------------------------
// The value for a specific index
// -----------------------------------------------------------------------------
//
CMPXMedia* CMPXMediaArray::ValueL(TInt aIndex) const
    {
    MPX_ASSERT(iData&&iClientHandle&&aIndex>=0&&aIndex<Count());
    //
    CMPXMedia* obj=NULL;
    //
    // Check local values to see if there and current
    //
    LockHeapLC();
    TInt uid=iData->Uid(iClientHandle,aIndex);
    const TValue* v=LocalValue(uid);
    if (!v)
        {
        TPtrC8 data=iData->Value(iClientHandle,aIndex);
        TUint* ptr=(TUint*)data.Ptr();
        //
        // Check that it's really a media object
        //
        MPX_ASSERT(*(MMPXData::TMPXObjectType*)ptr==MMPXData::EMedia);
        MPX_ASSERT(sizeof(TUint)+sizeof(TInt)==data.Size());
        //
        ++ptr; // Actual data offset
        obj=CMPXMedia::NewL(*ptr); // new media object from the data
        CleanupStack::PushL(obj);
        CMPXMediaArray& theArray=*const_cast<CMPXMediaArray*>(this);
        User::LeaveIfError(theArray.SetLocal(TValue(obj,uid,EMPXTypeCObject)));
        CleanupStack::Pop(obj);
        }
    else
        {
        obj=static_cast<CMPXMedia*>(v->iValue);
        }
    CleanupStack::PopAndDestroy(); // unlock the heap
    return obj;
    }

// -----------------------------------------------------------------------------
// Inserts the specified media into the array at the specified position
// -----------------------------------------------------------------------------
//
TInt CMPXMediaArray::AddToArray(const CMPXMedia& aMedia,TInt aPos,TBool aReplace)
    {
    MPX_ASSERT(iData&&iDataHandle&&iClientHandle);
    const TInt KMediaStreamLen=sizeof(MMPXData::TMPXObjectType)+sizeof(TUint);
    TBuf8<KMediaStreamLen> buf;
    TUint* p=(TUint*)buf.Ptr();
    *p=MMPXData::EMedia;
    *++p=aMedia.Data();
    buf.SetLength(KMediaStreamLen);
    TInt r(KErrNone);
    if (aReplace)
        {
        iData->Set(iClientHandle,KMPXMediaArrayItem,EMPXTypeCObject,buf,aPos);
        }
    else if (aPos==CMPXMediaBase::Count())
        {
        r=iData->Append(iClientHandle,KMPXMediaArrayItem,EMPXTypeCObject,buf);
        }
    else
        {
        r=iData->Insert(iClientHandle,KMPXMediaArrayItem,EMPXTypeCObject,buf,aPos);
        }
    return r;
    }

// END OF FILE