1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Implementation of data

    15 *

    16 */

    17 

    18 #include <mpxlog.h>

    19 #include "mpxheapmanager.h"

    20 #include "mpxmedia.h"

    21 #include "mpxmediaarray.h"

    22 #include "mpxfixedarray.h"

    23 #include "mpxmediadataarray.h"

    24 #include "mpxdata.h"

    25 

    26 /**

    27 *  Class RMPXData. Implementation of MMPXData interface

    28 */

    29 NONSHARABLE_CLASS( RMPXData ) : public MMPXData

    30     {

    31 public:

    32     /**

    33      * C++ default constructor.

    34      */

    35     RMPXData();

    36 public:

    37     /**

    38     * Copies contents of aData to this object, deleting any

    39     * existing data

    40     */

    41     TInt Copy(TUint aClientHandle,const RMPXData& aData);

    42 

    43 private: // From MMPXData

    44     TUint DataHandle(TUint aClientHandle);

    45     void AddRef(TUint aClientHandle);

    46     void Release(TUint aClientHandle);

    47     void AddClientRef(TUint aClientHandle);

    48     TPtrC8 Value(TUint aClientHandle,TInt aIndex);

    49     const TMPXAttribute& Attribute(TUint aClientHandle,TInt aIndex);

    50     TMPXAttributeType AttributeType(TUint aClientHandle,TInt aIndex);

    51     TArray<TInt> SupportedIds(TUint aClientHandle);

    52     TInt SetSupportedIds(TUint aClientHandle,const TArray<TInt>& aSupportedIds);

    53     void Delete(TUint aClientHandle,TInt aIndex);

    54     void Set(TUint aClientHandle,const TMPXAttribute& aAttr,

    55              TMPXAttributeType aType,const TDesC8& aData,TInt aIndex);

    56     TInt Insert(TUint aClientHandle,const TMPXAttribute& aAttr,

    57                 TMPXAttributeType aType,const TDesC8& aData,TInt aIndex);

    58     TInt Append(TUint aClientHandle,const TMPXAttribute& aAttr,

    59                 TMPXAttributeType aType,const TDesC8& aData);

    60     void Reset(TUint aClientHandle);

    61     TInt Count(TUint aClientHandle);

    62     TInt Index(TUint aClientHandle,const TMPXAttribute& aAttr);

    63     TInt Index(TUint aClientHandle,TInt aUid);

    64     TInt Uid(TUint aClientHandle,TInt aIndex);

    65 

    66 private:

    67     /**

    68     * Number of clients (for example CMPXMedia) sharing this object

    69     */

    70     TInt iRef;

    71     /**

    72     * Array of data items

    73     */

    74     RMPXMediaDataItemArray iDataArray;

    75     /**

    76     * The IDs supported by the source of the data

    77     */

    78     RMPXFixedArray<TInt> iSupportedIds;

    79     };

    80 

    81 

    82 // -----------------------------------------------------------------------------

    83 // MMPXData::NewL

    84 // -----------------------------------------------------------------------------

    85 //

    86 MMPXData* MMPXData::NewL(TUint aClientHandle)

    87     {

    88     RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

    89     m.Lock(aClientHandle);

    90     MMPXData* d=m.Alloc<RMPXData>(aClientHandle);

    91     m.Unlock(aClientHandle);

    92     User::LeaveIfNull(d);

    93     return d;

    94     }

    95 

    96 // -----------------------------------------------------------------------------

    97 // MMPXData::NewL

    98 // -----------------------------------------------------------------------------

    99 //

   100 MMPXData* MMPXData::NewL(TUint aClientHandle,const MMPXData& aData)

   101     {

   102     RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

   103     m.Lock(aClientHandle);

   104     RMPXData* d1=m.Alloc<RMPXData>(aClientHandle); // Create empty one

   105     TInt r=KErrNone;

   106     if (d1)

   107         { // Now copy data from old one

   108         const RMPXData& d2=static_cast<const RMPXData&>(aData);

   109         r=d1->Copy(aClientHandle,d2);

   110         }

   111     m.Unlock(aClientHandle);

   112     User::LeaveIfNull(d1);

   113     User::LeaveIfError(r);

   114     return d1;

   115     }

   116 

   117 // -----------------------------------------------------------------------------

   118 // MMPXData::Data

   119 // -----------------------------------------------------------------------------

   120 //

   121 MMPXData* MMPXData::Data(TUint aClientHandle,TAny* aData,TInt aSize)

   122     {

   123     MMPXData* d=NULL;

   124     //

   125     // Check its the right size, and it's on a word boundary first:

   126     // if either is not true, then its not an MMPXData implementation

   127     // for sure

   128     //

   129     TBool aligned=((TUint)aData&3)==0;

   130     const TInt KDataSize=sizeof(TInt)+sizeof(TUint);

   131 

   132     if (aSize==KDataSize&&aligned)

   133         {

   134         TUint* ptr=(TUint*)aData;

   135         MMPXData::TMPXObjectType t=*(MMPXData::TMPXObjectType*)ptr;

   136         switch(t)

   137             {

   138             case MMPXData::EMedia:

   139             case MMPXData::EMediaArray:

   140                 d=MMPXData::Data(aClientHandle,*++ptr);

   141                 MPX_ASSERT(d);

   142                 MPX_ASSERT_WORD_ALIGNED(d);

   143                 break;

   144                 //

   145             default:

   146                 break;

   147             }

   148         }

   149     return d;

   150     }

   151 

   152 // -----------------------------------------------------------------------------

   153 // MMPXData::Data

   154 // -----------------------------------------------------------------------------

   155 //

   156 MMPXData* MMPXData::Data(TUint aClientHandle,const TDesC8& aData)

   157     {

   158     return Data(aClientHandle,(TAny*)aData.Ptr(),aData.Size());

   159     }

   160 

   161 // -----------------------------------------------------------------------------

   162 // MMPXData::Data

   163 // -----------------------------------------------------------------------------

   164 //

   165 MMPXData* MMPXData::Data(TUint aClientHandle,TUint aDataHandle)

   166     {

   167     return RMPXHeapManager::Ptr<RMPXData>(aClientHandle,aDataHandle);

   168     }

   169 

   170 // -----------------------------------------------------------------------------

   171 // MMPXData::ClientHandle

   172 // -----------------------------------------------------------------------------

   173 //

   174 TUint MMPXData::ClientHandle()

   175     {

   176     // Already protected by the mutex

   177     return RMPXHeapManager::ClientHandle();

   178     }

   179 

   180 // -----------------------------------------------------------------------------

   181 // MMPXData::AddClientRef

   182 // -----------------------------------------------------------------------------

   183 //

   184 void MMPXData::AddClientRef(TUint aClientHandle)

   185     {

   186     RMPXHeapManager::HeapManager(aClientHandle).AddRef(aClientHandle);

   187     }

   188 

   189 

   190 // -----------------------------------------------------------------------------

   191 // MMPXData::ReleaseClient

   192 // -----------------------------------------------------------------------------

   193 //

   194 void MMPXData::ReleaseClient(TUint aClientHandle)

   195     {

   196     RMPXHeapManager::HeapManager(aClientHandle).Release(aClientHandle);

   197     }

   198 

   199 // -----------------------------------------------------------------------------

   200 // MMPXData::HeapMemoryInfoL

   201 // -----------------------------------------------------------------------------

   202 //

   203 void MMPXData::HeapMemoryInfoL( TInt& aTotal, TInt& aUsed )

   204     {

   205     return RMPXHeapManager::HeapMemoryInfoL( aTotal, aUsed );

   206     }

   207 

   208 // -----------------------------------------------------------------------------

   209 // RMPXData::LockHeap

   210 // -----------------------------------------------------------------------------

   211 //

   212 void MMPXData::LockHeap(TUint aClientHandle)

   213     {

   214     RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

   215     m.Lock(aClientHandle);

   216     }

   217 

   218 // -----------------------------------------------------------------------------

   219 // RMPXData::UnlockHeap

   220 // -----------------------------------------------------------------------------

   221 //

   222 void MMPXData::UnlockHeap(TUint aClientHandle)

   223     {

   224     RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

   225     m.Unlock(aClientHandle);

   226     }

   227 

   228 // -----------------------------------------------------------------------------

   229 // RMPXData::RMPXData

   230 // -----------------------------------------------------------------------------

   231 //

   232 RMPXData::RMPXData()

   233     :iRef(0)

   234     {

   235     }

   236 

   237 // -----------------------------------------------------------------------------

   238 // RMPXData::DataHandle

   239 // -----------------------------------------------------------------------------

   240 //

   241 TUint RMPXData::DataHandle(TUint aClientHandle)

   242     {

   243     return RMPXHeapManager::Offset(aClientHandle,this);

   244     }

   245 

   246 // -----------------------------------------------------------------------------

   247 // RMPXData::AddRef

   248 // -----------------------------------------------------------------------------

   249 //

   250 void RMPXData::AddRef(TUint aClientHandle)

   251     {

   252 #ifdef __ENABLE_MPX_GARBAGE_COLLECTOR

   253     TUint dataHandle=DataHandle(aClientHandle); //GC

   254     (void)RMPXHeapManager::HeapManager(aClientHandle).AddData(aClientHandle,dataHandle);//GC

   255 #else

   256     (void) aClientHandle;

   257 #endif // __ENABLE_MPX_GARBAGE_COLLECTOR

   258     ++iRef;

   259     }

   260 

   261 // -----------------------------------------------------------------------------

   262 // RMPXData::Release

   263 // -----------------------------------------------------------------------------

   264 //

   265 void RMPXData::Release(TUint aClientHandle)

   266     {

   267     --iRef;

   268     RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

   269 #ifdef __ENABLE_MPX_GARBAGE_COLLECTOR

   270     TUint dataHandle=DataHandle(aClientHandle); //GC

   271     // if the reference of the data is zero, remove all reference from all

   272     // clients.

   273     (void)m.RemoveData(aClientHandle,dataHandle,iRef==0); //GC

   274 #endif // __ENABLE_MPX_GARBAGE_COLLECTOR

   275     if(iRef==0)

   276         {

   277         m.Lock(aClientHandle);

   278         iDataArray.Close(aClientHandle);

   279         iSupportedIds.Close(aClientHandle);

   280         m.Free(aClientHandle,this);

   281         m.Unlock(aClientHandle);

   282         }

   283     }

   284 

   285 // -----------------------------------------------------------------------------

   286 // RMPXData::Value

   287 // -----------------------------------------------------------------------------

   288 //

   289 TPtrC8 RMPXData::Value(TUint aClientHandle,TInt aIndex)

   290     {

   291     return iDataArray.Data(aClientHandle,aIndex);

   292     }

   293 

   294 // -----------------------------------------------------------------------------

   295 // RMPXData::Attribute

   296 // -----------------------------------------------------------------------------

   297 //

   298 const TMPXAttribute& RMPXData::Attribute(TUint aClientHandle,TInt aIndex)

   299     {

   300     return iDataArray.MediaDataItem(aClientHandle,aIndex)->Attribute();

   301     }

   302 

   303 // -----------------------------------------------------------------------------

   304 // RMPXData::AttributeType

   305 // -----------------------------------------------------------------------------

   306 //

   307 TMPXAttributeType RMPXData::AttributeType(TUint aClientHandle,TInt aIndex)

   308     {

   309     return iDataArray.MediaDataItem(aClientHandle,aIndex)->Type();

   310     }

   311 

   312 // -----------------------------------------------------------------------------

   313 // RMPXData::SupportedIds

   314 // -----------------------------------------------------------------------------

   315 //

   316 TArray<TInt> RMPXData::SupportedIds(TUint aClientHandle)

   317     {

   318     return iSupportedIds.Array(aClientHandle);

   319     }

   320 

   321 // -----------------------------------------------------------------------------

   322 // RMPXData::SetSupportedIds

   323 // -----------------------------------------------------------------------------

   324 //

   325 TInt RMPXData::SetSupportedIds(TUint aClientHandle,const TArray<TInt>& aSupportedIds)

   326     {

   327     RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

   328     m.Lock(aClientHandle);

   329     TInt r=iSupportedIds.Copy(aClientHandle,aSupportedIds);

   330     m.Unlock(aClientHandle);

   331     return r;

   332     }

   333 

   334 // -----------------------------------------------------------------------------

   335 // RMPXData::Delete

   336 // -----------------------------------------------------------------------------

   337 //

   338 void RMPXData::Delete(TUint aClientHandle,TInt aIndex)

   339     {

   340     RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

   341     m.Lock(aClientHandle);

   342     iDataArray.Remove(aClientHandle,aIndex);

   343     m.Unlock(aClientHandle);

   344     }

   345 

   346 // -----------------------------------------------------------------------------

   347 // RMPXData::Set

   348 // -----------------------------------------------------------------------------

   349 //

   350 void RMPXData::Set(

   351     TUint aClientHandle,

   352     const TMPXAttribute& aAttr,

   353     TMPXAttributeType aType,

   354     const TDesC8& aData,

   355     TInt aIndex)

   356     {

   357     RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

   358     m.Lock(aClientHandle);

   359     iDataArray.Set(aClientHandle,aAttr,aType,aData,aIndex);

   360     m.Unlock(aClientHandle);

   361     }

   362 

   363 // -----------------------------------------------------------------------------

   364 // RMPXData::Insert

   365 // -----------------------------------------------------------------------------

   366 //

   367 TInt RMPXData::Insert(

   368     TUint aClientHandle,

   369     const TMPXAttribute& aAttr,

   370     TMPXAttributeType aType,

   371     const TDesC8& aData,

   372     TInt aIndex)

   373     {

   374     RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

   375     m.Lock(aClientHandle);

   376     TInt r=iDataArray.Insert(aClientHandle,aAttr,aType,aData,aIndex);

   377     m.Unlock(aClientHandle);

   378     return r;

   379     }

   380 

   381 // -----------------------------------------------------------------------------

   382 // RMPXData::Append

   383 // -----------------------------------------------------------------------------

   384 //

   385 TInt RMPXData::Append(

   386     TUint aClientHandle,

   387     const TMPXAttribute& aAttr,

   388     TMPXAttributeType aType,

   389     const TDesC8& aData)

   390     {

   391     RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

   392     m.Lock(aClientHandle);

   393     TInt r=iDataArray.Append(aClientHandle,aAttr,aType,aData);

   394     m.Unlock(aClientHandle);

   395     return r;

   396     }

   397 

   398 // -----------------------------------------------------------------------------

   399 // RMPXData::Reset

   400 // -----------------------------------------------------------------------------

   401 //

   402 void RMPXData::Reset(TUint aClientHandle)

   403     {

   404     RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

   405     m.Lock(aClientHandle);

   406     iDataArray.Reset(aClientHandle);

   407     m.Unlock(aClientHandle);

   408     }

   409 

   410 // -----------------------------------------------------------------------------

   411 // RMPXData::Count

   412 // -----------------------------------------------------------------------------

   413 //

   414 TInt RMPXData::Count(TUint /*aClientHandle*/)

   415     {

   416     return iDataArray.Count();

   417     }

   418 

   419 // -----------------------------------------------------------------------------

   420 // RMPXData::Index

   421 // -----------------------------------------------------------------------------

   422 //

   423 TInt RMPXData::Index(TUint aClientHandle,const TMPXAttribute& aAttr)

   424     {

   425     return iDataArray.Index(aClientHandle,aAttr);

   426     }

   427 

   428 // -----------------------------------------------------------------------------

   429 // RMPXData::Index

   430 // -----------------------------------------------------------------------------

   431 //

   432 TInt RMPXData::Index(TUint aClientHandle,TInt aUid)

   433     {

   434     TInt ret(KErrNotFound);

   435     for (TInt i=iDataArray.Count();--i>=0;)

   436         {

   437         RMPXMediaDataItem* item=iDataArray.MediaDataItem(aClientHandle,i);

   438         if (item->Uid()==aUid)

   439             {

   440             ret = i;

   441             break;

   442             }

   443         }

   444     return ret;

   445     }

   446 

   447 // -----------------------------------------------------------------------------

   448 // RMPXData::Uid

   449 // -----------------------------------------------------------------------------

   450 //

   451 TInt RMPXData::Uid(TUint aClientHandle,TInt aIndex)

   452     {

   453     RMPXMediaDataItem* item=iDataArray.MediaDataItem(aClientHandle,aIndex);

   454     return item->Uid();

   455     }

   456 

   457 // -----------------------------------------------------------------------------

   458 // RMPXData::Copy

   459 // -----------------------------------------------------------------------------

   460 //

   461 TInt RMPXData::Copy(TUint aClientHandle,const RMPXData& aData)

   462     {

   463     // Now copy data from old one. The data members are iDataArray

   464     // and iSupportedIds that need duplicating, and any values that they

   465     // now hold are deleted; iRef remains the same

   466     //

   467     TInt r(KErrNone);

   468     if (aData.iSupportedIds.Count())

   469         {

   470         r=iSupportedIds.RMPXFixedArrayBase::Copy(aClientHandle,aData.iSupportedIds);

   471         }

   472     return r==KErrNone?iDataArray.Copy(aClientHandle,aData.iDataArray):r;

   473     }

   474 

   475 // End of file