/*
* 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 media base class
*
*/


#include <mpxlog.h>
#include <mpxuser.h>
#include "mpxmediabase.h"


// -----------------------------------------------------------------------------
// C++ Constructor.
// -----------------------------------------------------------------------------
//
CMPXMediaBase::CMPXMediaBase()
    {
    // Open the global chunk and return the handle of the global chunk.
    // If called for the first time, creates the global chunk and heap manager.
    iClientHandle=MMPXData::ClientHandle();
    MMPXData::AddClientRef(iClientHandle);  // Ref for this thread
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CMPXMediaBase::~CMPXMediaBase()
    {
    ResetLocal();
    iValues.Close();
    if (iData)
        {
        iData->Release(iClientHandle);
        MMPXData::ReleaseClient(iClientHandle); // This thread's reference count
        }
    }

// -----------------------------------------------------------------------------
// CMPXMediaBase::ConstructL
// -----------------------------------------------------------------------------
//
void CMPXMediaBase::ConstructL()
    {
    MMPXData* d=MMPXData::NewL(iClientHandle);
    TInt dh=d->DataHandle(iClientHandle);
    ConstructL(dh,*d);
    }

// -----------------------------------------------------------------------------
// CMPXMediaBase::ConstructL
// -----------------------------------------------------------------------------
//
void CMPXMediaBase::ConstructL(const CMPXMediaBase& aBase)
    {
    ConstructL(aBase.iDataHandle,*aBase.iData);
    }

// -----------------------------------------------------------------------------
// CMPXMediaBase::CopyConstructL
// -----------------------------------------------------------------------------
//
void CMPXMediaBase::CopyConstructL(const CMPXMediaBase& aBase)
    {
    MMPXData* d=MMPXData::NewL(iClientHandle,*aBase.iData);
    TInt dh=d->DataHandle(iClientHandle);
    ConstructL(dh,*d);
    }

// -----------------------------------------------------------------------------
// CMPXMediaBase::ConstructL
// -----------------------------------------------------------------------------
//
void CMPXMediaBase::ConstructL(TInt aDataHandle)
    {
    MMPXData* d=MMPXData::Data(iClientHandle,aDataHandle);
    ConstructL(aDataHandle,*d);
    }

// -----------------------------------------------------------------------------
// CMPXMediaBase::ConstructL
// -----------------------------------------------------------------------------
//
void CMPXMediaBase::ConstructL(TInt aDataHandle,MMPXData& aData)
    {
    MPX_ASSERT(!iData&&!iDataHandle&&aDataHandle);
    if (aDataHandle==0)
        {
        User::Leave(KErrArgument);
        }
    iDataHandle=aDataHandle;
    iData=&aData;
    iData->AddRef(iClientHandle);
    iValues.ReserveL(Count());
    }

// -----------------------------------------------------------------------------
// CMPXMediaBase::Clear
// -----------------------------------------------------------------------------
//
void CMPXMediaBase::Clear()
    {
    if (iData)
        {
        ResetLocal(); // remove local data only, keep heap data for other media objects
        iData->Release(iClientHandle); // MMPXData's reference count
        iData=NULL;
        iDataHandle=0;
        }
    }

// -----------------------------------------------------------------------------
// CMPXMediaBase::ResetLocal
// -----------------------------------------------------------------------------
//
void CMPXMediaBase::ResetLocal()
    {
    THashMapIter<TInt, TValue> iter(iValues);
    const TValue* v = NULL;
    while ((v = iter.NextValue())!=NULL) 
        {
        DeletePtr(v->iValue, v->iType);
        iter.RemoveCurrent();
        }
    iValues.Close();
    } 

TInt CMPXMediaBase::SetLocal(const TValue& aValue)
    {
    DeleteLocalByUid(aValue.iUid);
    return iValues.Insert(aValue.iUid, aValue);
    }
    
// -----------------------------------------------------------------------------
// CMPXMediaBase::LocalIndex
// -----------------------------------------------------------------------------
//
const CMPXMediaBase::TValue* CMPXMediaBase::LocalValue(TInt aUid) const
    {
    return iValues.Find(aUid);
    }

// -----------------------------------------------------------------------------
// CMPXMediaBase::DeleteLocal
// -----------------------------------------------------------------------------
//
void CMPXMediaBase::DeleteLocalByUid(const TInt aUid)
    {
    TValue* val = iValues.Find(aUid);
    if (val)
        {
        DeletePtr(val->iValue,val->iType);
        iValues.Remove(aUid);
        }
    }

// -----------------------------------------------------------------------------
// CMPXMediaBase::DeleteLocal
// -----------------------------------------------------------------------------
//
void CMPXMediaBase::DeleteLocal(TInt aIndex)
    {
    MPX_ASSERT(KErrNotFound != aIndex);
    TInt uid = iData->Uid(iClientHandle,aIndex);
    DeleteLocalByUid(uid);
    }

// -----------------------------------------------------------------------------
// CMPXMediaBase::DeletePtr
// -----------------------------------------------------------------------------
//
void CMPXMediaBase::DeletePtr(TAny* aValue,TMPXAttributeType aType)
    {
    switch(aType)
        {
        case EMPXTypeCObject:
            delete static_cast<CBase*>(aValue);
            break;
        default:
            // Both T objects and text are held in TPtrC8 which are
            // allocated on the heap.
            //
            User::Free(aValue);
            break;
        }
    }

// -----------------------------------------------------------------------------
// Externalize
// -----------------------------------------------------------------------------
//
void CMPXMediaBase::DoExternalizeL(
    RWriteStream& aStream,
    MMPXData::TMPXObjectType aType) const
    {
    //
    // NB: Client must persist the object until after it has been
    // internalized, i.e. there must always be at least one object
    // in existance for Internalize to work!
    //
    MPX_ASSERT(iDataHandle);
    //
    aStream.WriteInt32L(aType);
    aStream.WriteUint32L(iDataHandle);
    }

// -----------------------------------------------------------------------------
// 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.
// -----------------------------------------------------------------------------
//
void CMPXMediaBase::DoInternalizeL(
    RReadStream& aStream,
    MMPXData::TMPXObjectType /*aType*/)
    {
    MPX_ASSERT(iClientHandle);
    //
    Clear();  // Clear local data only from this object
    TInt type( aStream.ReadInt32L() ); // object type
    if ( type != MMPXData::EMedia &&
         type != MMPXData::EMediaArray)
        {
        MPX_DEBUG1("CMPXMediaBase::DoInternalizeL(): Invalid Type");
        User::Leave( KErrArgument );
        }
    //
    iDataHandle=aStream.ReadUint32L();
    iData=MMPXData::Data(iClientHandle,iDataHandle);
    iData->AddRef(iClientHandle);
    }

// ----------------------------------------------------------------------------
// CMPXMediaBase::LockHeapLC
// ----------------------------------------------------------------------------
//
void CMPXMediaBase::LockHeapLC() const
    {
    MMPXData::LockHeap( iClientHandle );
    CleanupStack::PushL(TCleanupItem(UnlockHeap, const_cast<CMPXMediaBase*>(this)));
    }

// ----------------------------------------------------------------------------
// CMPXMediaBase::UnlockHeap
//
// Executed when the cleanup stack item is destroyed as a result of
// CleanupStack::PopAndDestroy being called. This could either be called
// manually or as a result of a leave being generated and trapped.
//
// This is a static method.
// ----------------------------------------------------------------------------
//
void CMPXMediaBase::UnlockHeap(TAny* aMediaBase)
    {
    CMPXMediaBase* base = static_cast<CMPXMediaBase*>(aMediaBase);
    MMPXData::UnlockHeap(base->iClientHandle);
    }

// END OF FILE