1 /*

     2 * Copyright (c) 2008-2009 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:    List of media items

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 #include "glxmedialist.h"

    22 

    23 #include <glxcollectionplugintype.hrh>

    24 

    25 #include <glxassert.h>

    26 #include <glxcollectiongeneraldefs.h>

    27 #include <glxerrorposter.h>

    28 #include <mpxcollectionmessage.h>

    29 #include <mpxcollectionmessagedefs.h>

    30 #include <mpxcollectionutility.h>

    31 #include <mpxcommandgeneraldefs.h>

    32 #include <mpxmessagegeneraldefs.h>

    33 #include <glxtracer.h>

    34 #include <glxlog.h>

    35 #include "glxcachemanager.h"

    36 #include "glxmedialistarray.h"

    37 #include "glxnavigablelist.h"

    38 #include "mglxfetchcontext.h"

    39 #include "mglxmedialistobserver.h"

    40 #include "glxmediastaticitemdefs.h"

    41 

    42 namespace NGlxMediaList

    43     {

    44     /**

    45      * Interface to notify observers. Allows different notifications to use

    46      * the same (complicated) iteration loop

    47      */

    48     class TNotificationStrategy 

    49         {

    50         public:

    51             TNotificationStrategy( MGlxMediaList& aList )

    52                     : iList( aList )

    53                 {

    54                 }

    55                 

    56             /** 

    57              * Notify observer

    58              * @param aObserver Observer to notify 

    59              */

    60             virtual void NotifyL( MGlxMediaListObserver& aObserver ) = 0;

    61         

    62         protected:

    63             MGlxMediaList& iList;

    64         };

    65 

    66     /**

    67      * Notification strategy for items being added

    68      */

    69     class TItemsAddedNotificationStrategy : public TNotificationStrategy 

    70         {

    71         public:

    72             /**

    73              * Constructor 

    74              * @param aFirstAddedIndex Index of the first item added

    75              * @param aCount number of items added

    76              * @param aList Media list that sends the notification

    77              */

    78             TItemsAddedNotificationStrategy( TInt aFirstAddedIndex, 

    79                 TInt aCount, MGlxMediaList& aList )

    80                     : TNotificationStrategy( aList )

    81                 {

    82                 iFirstAddedIndex = aFirstAddedIndex;

    83                 iLastAddedIndex = aFirstAddedIndex + aCount - 1;

    84                 }

    85                 

    86             // From MGlxNotificationStrategy

    87             void NotifyL( MGlxMediaListObserver& aObserver )

    88                 {

    89                 aObserver.HandleItemAddedL( iFirstAddedIndex, iLastAddedIndex, 

    90                     &iList );

    91                 }        

    92                 

    93         private:

    94             /// Index of the first item added

    95             TInt iFirstAddedIndex;

    96             /// Index of the last item added

    97             TInt iLastAddedIndex;

    98         };

    99 

   100     /**

   101      * Notification strategy for items being removed

   102      */

   103     class TItemsRemovedNotificationStrategy : public TNotificationStrategy 

   104         {

   105         public:

   106             /**

   107              * Constructor 

   108              * @param aFirstRemovedIndex Index of the first item removed

   109              * @param aCount number of items removed

   110              * @param aList Media list that sends the notification

   111              */

   112             TItemsRemovedNotificationStrategy( TInt aFirstRemovedIndex, 

   113                 TInt aCount, MGlxMediaList& aList )

   114                     : TNotificationStrategy( aList )

   115                 {

   116                 iFirstRemovedIndex = aFirstRemovedIndex;

   117                 iLastRemovedIndex = aFirstRemovedIndex + aCount - 1;

   118                 }

   119                 

   120             // From MGlxNotificationStrategy

   121             void NotifyL( MGlxMediaListObserver& aObserver )

   122                 {

   123                 aObserver.HandleItemRemovedL( iFirstRemovedIndex, 

   124                     iLastRemovedIndex, &iList );

   125                 }        

   126                 

   127         private:

   128             /// Index of the first item removed

   129             TInt iFirstRemovedIndex;

   130             /// Index of the last item removed

   131             TInt iLastRemovedIndex;

   132         };

   133 

   134     /**

   135      * Notification strategy for focus being changed

   136      */

   137     class TFocusChangedNotificationStrategy : public TNotificationStrategy 

   138         {

   139         public:

   140             /**

   141              * Constructor 

   142              * @param aFirstRemovedIndex Index of the first item removed

   143              * @param aCount number of items removed

   144              * @param aList Media list that sends the notification

   145              */

   146             TFocusChangedNotificationStrategy( NGlxListDefs::TFocusChangeType aType, 

   147                 TInt aNewIndex, TInt aOldIndex, MGlxMediaList& aList )

   148                     : TNotificationStrategy( aList )

   149                 {

   150                 iType = aType;

   151                 iNewIndex = aNewIndex;

   152                 iOldIndex = aOldIndex;

   153                 }

   154                 

   155             // From MGlxNotificationStrategy

   156             void NotifyL( MGlxMediaListObserver& aObserver )

   157                 {

   158                 aObserver.HandleFocusChangedL( iType, iNewIndex, iOldIndex, &iList );

   159                 }        

   160                 

   161         private:

   162             /// Focus change type

   163             NGlxListDefs::TFocusChangeType iType;

   164             /// New focus index

   165             TInt iNewIndex;

   166             /// Old focus index

   167             TInt iOldIndex;

   168         };

   169 

   170     /**

   171      * Notification strategy for selection being changed

   172      */

   173     class TItemSelectedNotificationStrategy : public TNotificationStrategy 

   174         {

   175         public:

   176             /**

   177              * Constructor 

   178              * @param aIndex Index of item being selected/deselected

   179              * @param aSelected Selection/deselection info

   180              * @param aList Media list that sends the notification

   181              */

   182             TItemSelectedNotificationStrategy( TInt aIndex, TBool aSelected,

   183                 MGlxMediaList& aList )

   184                     : TNotificationStrategy( aList )

   185                 {

   186                 iIndex = aIndex;

   187                 iSelected = aSelected;

   188                 }

   189                 

   190             // From MGlxNotificationStrategy

   191             void NotifyL( MGlxMediaListObserver& aObserver )

   192                 {

   193                 aObserver.HandleItemSelectedL( iIndex, iSelected, &iList );

   194                 }        

   195                 

   196         private:

   197             /// Index of item being selected/deselected

   198             TInt iIndex;

   199             /// Selection/deselection info

   200             TBool iSelected;

   201         };    

   202 

   203     /**

   204      * Notification strategy for command being completed

   205      */

   206     class TCommandCompletedNotificationStrategy : public TNotificationStrategy 

   207         {

   208         public:

   209             /**

   210              * Constructor 

   211              * @param aSessionId Session id of client that issued the command

   212              * @param aCommand Command which was completed

   213              * @param aError Error code from execution of the command

   214              * @param aList Media list that sends the notification

   215              */

   216             TCommandCompletedNotificationStrategy( TAny* aSessionId, 

   217                 CMPXCommand* aCommand, TInt aError, MGlxMediaList& aList )

   218                     : TNotificationStrategy( aList )

   219                 {

   220                 iSessionId = aSessionId;

   221                 iCommand = aCommand;

   222                 iError = aError;

   223                 }

   224                 

   225             // From MGlxNotificationStrategy

   226             void NotifyL( MGlxMediaListObserver& aObserver )

   227                 {

   228                 /// @todo: make this call leaving

   229                 aObserver.HandleCommandCompleteL( iSessionId, iCommand, iError, &iList );

   230                 }        

   231 

   232         private:

   233             /// Session id of client that issued the command

   234             TAny* iSessionId;

   235             /// Command which was completed

   236             CMPXCommand* iCommand;

   237             /// Error code 

   238             TBool iError;

   239         };            

   240         

   241         

   242 

   243     /**

   244      * Notification strategy for list population

   245      */

   246     class TListPopulatedNotificationStrategy : public TNotificationStrategy 

   247         {

   248         public:

   249             /**

   250              * Constructor 

   251              * @param aList Media list that sends the notification

   252              */

   253             TListPopulatedNotificationStrategy ( MGlxMediaList& aList )

   254                     : TNotificationStrategy( aList )

   255                 {

   256                 }

   257                 

   258             // From MGlxNotificationStrategy

   259             void NotifyL( MGlxMediaListObserver& aObserver )

   260                 {

   261                 aObserver.HandlePopulatedL( &iList );

   262                 }        

   263         }; 

   264 

   265     /**

   266      * Notification strategy for messages

   267      */

   268     class TMessageNotificationStrategy : public TNotificationStrategy

   269         {

   270         public:

   271             /**

   272              * Constructor

   273              * @param aList Media list that sends the notification

   274              */

   275             TMessageNotificationStrategy ( const CMPXMessage& aMessage, MGlxMediaList& aList ) :

   276                     TNotificationStrategy( aList ),

   277                     iMessage( aMessage )

   278                 {

   279                 }

   280 

   281             // From MGlxNotificationStrategy

   282             void NotifyL( MGlxMediaListObserver& aObserver )

   283                 {

   284                 aObserver.HandleMessageL( iMessage, &iList );

   285                 }

   286 

   287         private:

   288             /// Message which was received

   289             const CMPXMessage& iMessage;

   290         };

   291     } // namespace NGlxMediaList

   292     

   293 using namespace NGlxMediaList;

   294 

   295 // -----------------------------------------------------------------------------

   296 // Returns a new/existing media list interface

   297 // -----------------------------------------------------------------------------

   298 CGlxMediaList* CGlxMediaList::InstanceL(const CMPXCollectionPath& aPath, 

   299         const TGlxHierarchyId& aHierarchyId, CMPXFilter* aFilter)

   300     {

   301     TRACER("CGlxMediaList::InstanceL" );

   302     

   303     CGlxMediaListArray* mediaListArray = CGlxMediaListArray::InstanceL();

   304     CleanupClosePushL(*mediaListArray);

   305     

   306     RPointerArray<CGlxMediaList>& mediaLists =  mediaListArray->Array();

   307 

   308     TInt matchIndex = KErrNotFound;

   309     CGlxMediaList* mediaListInstance = NULL; // List to return

   310 

   311     // Try to find an existing media list to return (by matching the path)

   312     TInt listCount = mediaLists.Count();

   313     for (TInt count = 0; count < listCount; ++count)

   314         {

   315         CGlxMediaList* mediaList = mediaLists[count];

   316 

   317         // See if path's and hierarchy id's match

   318         // Filter is ignored

   319         if (mediaList->Equals(aPath) && (mediaList->iHierarchyId == aHierarchyId))

   320             {

   321             // Found a match

   322             matchIndex = count;

   323             mediaListInstance = mediaList;

   324             break;

   325             }

   326         }

   327 

   328     // Create a new media list if could not use an existing one

   329     if (matchIndex == KErrNotFound)

   330         {

   331         __ASSERT_DEBUG(!mediaListInstance, Panic(EGlxPanicAlreadyInitialised));

   332 

   333         mediaListInstance = CGlxMediaList::NewLC(aHierarchyId);

   334 

   335         // Set specified filter (if any) before opening the collection to path

   336         mediaListInstance->SetFilterL(aFilter);

   337         mediaListInstance->OpenL(aPath);

   338 

   339         // Insert media list as highest priority

   340         mediaLists.InsertL(mediaListInstance, 0);

   341         CleanupStack::Pop(mediaListInstance);

   342         }

   343     else

   344         {

   345         __ASSERT_DEBUG(mediaListInstance, Panic(EGlxPanicNullPointer));

   346 

   347         // Match found, set as highest priority

   348         mediaLists.InsertL(mediaListInstance, 0);

   349         mediaLists.Remove(matchIndex + 1);

   350         }

   351 

   352     mediaListInstance->AddReference(); // Add user

   353 

   354     CleanupStack::PopAndDestroy(mediaListArray);

   355     

   356     return mediaListInstance;

   357     }

   358 

   359 // -----------------------------------------------------------------------------

   360 // Gives an array of all media lists in current use

   361 // -----------------------------------------------------------------------------

   362 RPointerArray<CGlxMediaList>& CGlxMediaList::MediaListsL()

   363     {

   364     TRACER("CGlxMediaList::MediaListsL" );

   365     

   366     CGlxMediaListArray* mediaListArray = CGlxMediaListArray::InstanceL();

   367     RPointerArray<CGlxMediaList>& array = mediaListArray->Array();

   368     mediaListArray->Close();

   369     return array;

   370     }

   371 

   372 // -----------------------------------------------------------------------------

   373 // OfferMedia

   374 // -----------------------------------------------------------------------------

   375 //

   376 void CGlxMediaList::OfferMedia(const TGlxIdSpaceId& aIdSpaceId, CGlxMedia* aMedia) 

   377     {

   378     TRACER("CGlxMediaList::OfferMedia" );

   379 

   380     // try to find the matching item in this list

   381     TInt index = Index( aIdSpaceId, aMedia->Id() );

   382     // if matching item found, link media object

   383     if ( KErrNotFound != index )

   384         {

   385         TGlxMedia& item = iItemList->Item( index );

   386 

   387         // static items should not be offered

   388         if ( !item.IsStatic() )

   389             {

   390             item.SetMedia( aMedia, *this, index );

   391             }

   392         }

   393     }

   394 

   395 // -----------------------------------------------------------------------------

   396 // NotifyThumbnailAvailableL

   397 // -----------------------------------------------------------------------------

   398 //

   399 void CGlxMediaList::HandleAttributesAvailableL(TInt aIndex, 

   400         const RArray<TMPXAttribute>& aAttributes)

   401     {

   402     TRACER("CGlxMediaList::HandleAttributesAvailableL" );

   403 

   404     __ASSERT_DEBUG(aIndex >= 0, Panic(EGlxPanicLogicError)); // Must exist

   405     // Need to get exact count of iItemListObservers at

   406     // every iteration because it is possible that 

   407     // RemoveMediaListObserver might call during this iteration

   408     for (TInt i = 0; i < iItemListObservers.Count(); i++)

   409         {

   410         iItemListObservers[i]->HandleAttributesAvailableL(aIndex, aAttributes, this);

   411         }

   412     }

   413 

   414 // -----------------------------------------------------------------------------

   415 // Ask if the list has any requests to place

   416 // -----------------------------------------------------------------------------

   417 //

   418 void CGlxMediaList::AttributeRequestL(RArray<TInt>& aItemIndexes,

   419 		RArray<TGlxMediaId>& aItemIds, 

   420         RArray<TMPXAttribute>& aAttributes, 

   421         CMPXAttributeSpecs*& aDetailedSpecs) const

   422     {

   423     TRACER("CGlxMediaList::AttributeRequestL" );

   424     

   425     // Find the highest priority context that has something to request

   426     TInt count = iContexts.Count();

   427     for (TInt i = 0; i < count; i++)

   428         {

   429         // Determine items (referenced by index) to request attributes for

   430         iContexts[i].iContext->AttributeRequestL(this, aItemIndexes, aAttributes, aDetailedSpecs);

   431 

   432         // Map item indices to item Ids

   433         TInt itemIndicesCount = aItemIndexes.Count();

   434         for (TInt itemIndicesCounter = 0; itemIndicesCounter < itemIndicesCount; ++itemIndicesCounter)

   435             {

   436             const TGlxMedia& item = iItemList->Item( aItemIndexes[itemIndicesCounter] );

   437             if (!item.IsStatic())

   438                 {

   439                 aItemIds.AppendL( item.Id() );

   440                 }

   441             }

   442 

   443         // break if context has something to request

   444         if (itemIndicesCount > 0)

   445             {

   446             break;

   447             }

   448         }

   449     }

   450 

   451 // ---------------------------------------------------------------------------

   452 // AllAttributesL

   453 // ---------------------------------------------------------------------------

   454 //

   455 void CGlxMediaList::GetRequiredAttributesL(TInt aIndex, RArray<TMPXAttribute>& aAttributes)

   456     {

   457     TRACER("CGlxMediaList::GetRequiredAttributesL" );

   458     

   459     TLinearOrder<TMPXAttribute> orderer (&AttributeOrder);

   460 

   461     // Determine all attributes to request for an item, for all contexts

   462     TInt contextCount = iContexts.Count();

   463     for ( TInt contextIndex = 0; contextIndex < contextCount; contextIndex++ )

   464         {

   465         const MGlxFetchContext* context = iContexts[contextIndex].iContext;

   466         if ( context )

   467             {

   468             // Determine all attributes to request for an item, for this context

   469             context->AllAttributesL(this, aIndex, aAttributes);

   470 

   471             }

   472         }

   473     }

   474 

   475 // ---------------------------------------------------------------------------

   476 // AttributeOrder

   477 // ---------------------------------------------------------------------------

   478 //

   479 TInt CGlxMediaList::AttributeOrder(const TMPXAttribute& aItem1, 

   480         const TMPXAttribute& aItem2) 

   481     {

   482     TRACER("CGlxMediaList::AttributeOrder");

   483             

   484     TInt contentId1 = aItem1.ContentId();

   485     TInt contentId2 = aItem2.ContentId();

   486 

   487     if (contentId1 < contentId2) 

   488         {

   489         return -1;

   490         }

   491 

   492     if (contentId1 > contentId2) 

   493         {

   494         return 1;

   495         }

   496 

   497     TUint attributeId1 = aItem1.AttributeId();

   498     TUint attributeId2 = aItem2.AttributeId();

   499 

   500     if (attributeId1 < attributeId2) 

   501         {

   502         return -1;

   503         }

   504 

   505     if (attributeId1 > attributeId2) 

   506         {

   507         return 1;

   508         }

   509 

   510     return 0;

   511     }

   512 

   513 // ---------------------------------------------------------------------------

   514 // AttributeOrderReversed

   515 // ---------------------------------------------------------------------------

   516 //

   517 TInt CGlxMediaList::AttributeOrderReversed(const TMPXAttribute& aItem1, 

   518         const TMPXAttribute& aItem2) 

   519     {

   520     TRACER("CGlxMediaList::AttributeOrderReversed");

   521     

   522     return -AttributeOrder(aItem1, aItem2);

   523     }

   524 

   525 // ---------------------------------------------------------------------------

   526 // Remore references to the media object

   527 // ---------------------------------------------------------------------------

   528 //

   529 void CGlxMediaList::RemoveReference( TInt aIndex )

   530     {

   531     TRACER( "CGlxMediaList::RemoveReference" );

   532     GLX_ASSERT_DEBUG( iItemList, Panic( EGlxPanicNotInitialised ), 

   533         "not ready to remove references" );

   534     

   535     GLX_LOG_INFO1( "CGlxMediaList::RemoveReference %d", aIndex );

   536     iItemList->RemoveReference( aIndex );

   537     }

   538 

   539 // ---------------------------------------------------------------------------

   540 // HandleError

   541 // ---------------------------------------------------------------------------

   542 //

   543 void CGlxMediaList::HandleError(TInt aError)

   544     {

   545     TRACER( "CGlxMediaList::HandleError");    

   546     GLX_LOG_INFO1( "CGlxMediaList::HandleError %d", aError );

   547     TInt obsCount = iItemListObservers.Count();

   548     for (TInt obsIdx = 0; obsIdx < obsCount; ++obsIdx)

   549         {

   550         iItemListObservers[obsIdx]->HandleError(aError);

   551         }

   552     }

   553 

   554 // -----------------------------------------------------------------------------

   555 // Releases a media list interface

   556 // -----------------------------------------------------------------------------

   557 void CGlxMediaList::Close()

   558     {

   559     TRACER( "CGlxMediaList::Close" );

   560     

   561     RPointerArray<CGlxMediaList>& mediaLists = iMediaListArray->Array();

   562 

   563     TInt listCount = mediaLists.Count();

   564     for (TInt count = 0; count < listCount; ++count)

   565         {

   566         CGlxMediaList* mediaList = mediaLists[count];

   567 

   568         if (mediaList == this)

   569             {

   570             TInt referenceCount = mediaList->RemoveReference();

   571             if (referenceCount == 0)

   572                 {

   573                 mediaLists.Remove(count);

   574                 mediaLists.Compress();

   575 

   576                 delete mediaList;

   577                 break;

   578                 }

   579             }

   580         }

   581     }

   582 

   583 // -----------------------------------------------------------------------------

   584 // Id

   585 // From MGlxMediaList

   586 // -----------------------------------------------------------------------------

   587 //

   588 TGlxMediaListId CGlxMediaList::Id() const

   589     {

   590     TRACER( "CGlxMediaList::Id" );

   591     

   592     return TGlxMediaListId((unsigned int)(void*)this);	

   593     }

   594 

   595 // -----------------------------------------------------------------------------

   596 // Count

   597 // From MGlxMediaList

   598 // -----------------------------------------------------------------------------

   599 //

   600 TInt CGlxMediaList::Count(NGlxListDefs::TCountType aType) const

   601     {

   602     TRACER("CGlxMediaList::Count");

   603     

   604     return iItemList->Count( aType );    

   605     }

   606 

   607 // -----------------------------------------------------------------------------

   608 // FocusIndex

   609 // From MGlxMediaList

   610 // -----------------------------------------------------------------------------

   611 //

   612 TInt CGlxMediaList::FocusIndex() const

   613     {

   614     TRACER("CGlxMediaList::FocusIndex");

   615     

   616     return iItemList->FocusIndex();    

   617     }

   618 

   619 // -----------------------------------------------------------------------------

   620 // SetFocusL

   621 // -----------------------------------------------------------------------------

   622 //

   623 void CGlxMediaList::SetFocusL(NGlxListDefs::TFocusSetType aType, TInt aValue)

   624     {

   625     TRACER("CGlxMediaList::SetFocusL");

   626     

   627     GLX_LOG_INFO1( "CGlxMediaList::SetFocusL %d", aValue );

   628     iItemList->SetFocus( aType, aValue );

   629     }

   630 

   631 // -----------------------------------------------------------------------------

   632 // Item

   633 // From MGlxMediaList

   634 // -----------------------------------------------------------------------------

   635 //

   636 const TGlxMedia& CGlxMediaList::Item(TInt aIndex) const

   637     {

   638     TRACER("CGlxMediaList::Item");

   639     

   640     return iItemList->Item( aIndex );    

   641     }

   642 

   643 // -----------------------------------------------------------------------------

   644 // Index

   645 // From MGlxMediaList

   646 // -----------------------------------------------------------------------------

   647 //

   648 TInt CGlxMediaList::Index(const TGlxIdSpaceId& aIdSpaceId, const TGlxMediaId& aId) const

   649     {

   650     TRACER("CGlxMediaList::Index");

   651     

   652     return iItemList->Index( aIdSpaceId, aId );    

   653     }

   654 

   655 // -----------------------------------------------------------------------------

   656 // AddMediaListObserverL

   657 // From MGlxMediaList

   658 // -----------------------------------------------------------------------------

   659 //

   660 void CGlxMediaList::AddMediaListObserverL(MGlxMediaListObserver* aObserver)

   661     {

   662     TRACER("CGlxMediaList::AddMediaListObserverL");    

   663     GLX_LOG_INFO1( "CGlxMediaList::AddMediaListObserverL(0x%x)", aObserver );

   664 

   665     // Make sure the observer is not already in the array

   666     __ASSERT_DEBUG(iItemListObservers.Find(aObserver) == -1, Panic(EGlxPanicIllegalArgument)); // Observer already added

   667 

   668     iItemListObservers.AppendL(aObserver);

   669     }

   670 

   671 // -----------------------------------------------------------------------------

   672 // RemoveMediaListObserver

   673 // From MGlxMediaList

   674 // -----------------------------------------------------------------------------

   675 //	

   676 void CGlxMediaList::RemoveMediaListObserver(MGlxMediaListObserver* aObserver)

   677     {

   678     TRACER("CGlxMediaList::RemoveMediaListObserver");    

   679     GLX_LOG_INFO1( "CGlxMediaList::RemoveMediaListObserver(0x%x)", aObserver );

   680 

   681     TInt index = iItemListObservers.Find(aObserver);

   682 

   683     // Make sure the observer is in the array

   684     // LOG THIS! __ASSERT_DEBUG(index != -1, Panic(EGlxPanicIllegalArgument)); // No such observer

   685 

   686     if (index != KErrNotFound) 

   687         {

   688         iItemListObservers.Remove(index);	

   689         }

   690     }

   691 

   692 // -----------------------------------------------------------------------------

   693 // AddContextL

   694 // From MGlxMediaList

   695 // -----------------------------------------------------------------------------

   696 //	

   697 void CGlxMediaList::AddContextL(const MGlxFetchContext* aContext, 

   698         TInt aPriority)

   699     {

   700     TRACER("CGlxMediaList::AddContextL");    

   701     GLX_LOG_INFO1( "CGlxMediaList::AddContextL(0x%x)", aContext );

   702 

   703     if (!aContext)

   704         {

   705         return;

   706         }

   707 

   708     // Add the new context in priority order

   709     TContext context;

   710     context.iContext = aContext;

   711     context.iPriority = aPriority;

   712 

   713 #ifdef _DEBUG

   714 

   715     // Make sure no duplicate entries

   716     TIdentityRelation<CGlxMediaList::TContext> match (&CGlxMediaList::TContext::Match);

   717     __ASSERT_DEBUG(iContexts.Find(context, match) == KErrNotFound, Panic(EGlxPanicAlreadyAdded));

   718 

   719 #endif // _DEBUG

   720 

   721     TLinearOrder<CGlxMediaList::TContext> orderer (&CGlxMediaList::TContext::Compare);

   722     TInt ret = iContexts.InsertInOrderAllowRepeats(context, orderer); 

   723     User::LeaveIfError(ret);

   724 

   725     iManager->HandleWindowChangedL(this);

   726     }

   727 

   728 // -----------------------------------------------------------------------------

   729 // RemoveContext

   730 // From MGlxMediaList

   731 // -----------------------------------------------------------------------------

   732 //	

   733 void CGlxMediaList::RemoveContext(const MGlxFetchContext* aContext)

   734     {

   735     TRACER("CGlxMediaList::RemoveContext");    

   736     GLX_LOG_INFO1( "CGlxMediaList::RemoveContext(0x%x)", aContext );

   737 

   738     if (!aContext)

   739         {

   740         return;

   741         }

   742 

   743     TIdentityRelation<CGlxMediaList::TContext> match (&CGlxMediaList::TContext::Match);

   744     TContext context;

   745     context.iContext = aContext;

   746     context.iPriority = 0;

   747     TInt index = iContexts.Find(context, match);

   748 

   749     // remove the context if it was found, just ignore if its not found

   750     if (index != KErrNotFound) 

   751         {

   752         iContexts.Remove(index);

   753         // notify cache manager: garbage collection needs to be run to free the 

   754         // items that the removed context required

   755         TRAP_IGNORE( iManager->HandleWindowChangedL( this ) );

   756         }

   757     }

   758 

   759 // -----------------------------------------------------------------------------

   760 // Returns the isolated collection, that is used by this media list

   761 // -----------------------------------------------------------------------------

   762 //

   763 MMPXCollection& CGlxMediaList::Collection() const

   764     {

   765     TRACER("CGlxMediaList::Collection");

   766     __ASSERT_DEBUG(iCollectionUtility != NULL, Panic(EGlxPanicNullPointer));

   767     return iCollectionUtility->Collection();

   768     }

   769 

   770 // -----------------------------------------------------------------------------

   771 // Returns the current path

   772 // -----------------------------------------------------------------------------

   773 CMPXCollectionPath* CGlxMediaList::PathLC(NGlxListDefs::TPathType aType) const

   774     {

   775     TRACER("CGlxMediaList::PathLC");  

   776 

   777     CMPXCollectionPath* path = CMPXCollectionPath::NewL();

   778     CleanupStack::PushL(path);

   779 

   780     // Add navigation to parent

   781     PathPopulateParentL( *path );

   782 

   783     if ( aType == NGlxListDefs::EPathAllOrSelection ||

   784          aType == NGlxListDefs:: EPathFocusOrSelection )

   785         {

   786         // If selection exists, add only selection

   787         // Otherwise add all items or focused item

   788         if ( iItemList->SelectedItemIndices().Count() > 0 )

   789             {

   790             PathPopulateSelectionL( *path );

   791             }

   792         else

   793             {

   794             if ( aType == NGlxListDefs::EPathAllOrSelection )

   795                 {

   796                 PathPopulateAllL( *path );

   797                 }

   798             else if ( aType == NGlxListDefs:: EPathFocusOrSelection )

   799                 {

   800                 PathPopulateFocusL( *path );

   801                 }

   802             }

   803         }

   804 

   805     return path;

   806     }

   807 

   808 // -----------------------------------------------------------------------------

   809 // Determines if an item has been selected

   810 // -----------------------------------------------------------------------------

   811 TBool CGlxMediaList::IsSelected(TInt aIndex) const

   812     {

   813     TRACER("CGlxMediaList::IsSelected");    

   814     GLX_LOG_INFO1( "CGlxMediaList::IsSelected %d", aIndex );

   815     return iItemList->IsSelected( aIndex );

   816     }

   817 

   818 // -----------------------------------------------------------------------------

   819 // Handles item selection/deselection

   820 // -----------------------------------------------------------------------------

   821 void CGlxMediaList::SetSelectedL(TInt aIndex, TBool aSelected)

   822     {

   823     TRACER("CGlxMediaList::SetSelectedL");    

   824     GLX_LOG_INFO2( "CGlxMediaList::SetSelectedL %d:%d", aIndex, aSelected );

   825     iItemList->SetSelectedL( aIndex, aSelected );

   826     }

   827 

   828 // -----------------------------------------------------------------------------

   829 // Returns selection count

   830 // -----------------------------------------------------------------------------

   831 TInt CGlxMediaList::SelectionCount() const

   832     {

   833     TRACER("CGlxMediaList::SelectionCount");

   834     

   835     return iItemList->SelectedItemIndices().Count();

   836     }

   837 

   838 // -----------------------------------------------------------------------------

   839 // Returns selected item index from selection

   840 // -----------------------------------------------------------------------------

   841 TInt CGlxMediaList::SelectedItemIndex(TInt aSelectionIndex) const

   842     {

   843     TRACER("CGlxMediaList::SelectedItemIndex");    

   844     GLX_LOG_INFO1( "CGlxMediaList::SelectedItemIndex %d", aSelectionIndex );

   845     return iItemList->SelectedItemIndices()[ aSelectionIndex ];

   846     }

   847 

   848 // -----------------------------------------------------------------------------

   849 // Sends a command to the collection

   850 // -----------------------------------------------------------------------------

   851 void CGlxMediaList::CommandL(CMPXCommand& aCommand)

   852     {

   853     TRACER("CGlxMediaList::CommandL");

   854 

   855     // Multiple commands should not happen

   856     __ASSERT_DEBUG( !iCommandPending, Panic( EGlxPanicLogicError ) );

   857 

   858     // Send the command

   859     Collection().CommandL( aCommand );

   860 

   861     // Use the sessionId to indicate that a command is pending

   862     __ASSERT_DEBUG( aCommand.IsSupported( KMPXCommandGeneralSessionId ), 

   863                     Panic( EGlxPanicLogicError ) );

   864 

   865     iCommandPending = aCommand.ValueTObjectL<TAny*>( KMPXCommandGeneralSessionId );

   866     }

   867 

   868 // -----------------------------------------------------------------------------

   869 // Cancels a command on the collection

   870 // -----------------------------------------------------------------------------

   871 void CGlxMediaList::CancelCommand()

   872     {

   873     TRACER("CGlxMediaList::CancelCommand");

   874 

   875     // Cancelling a non issued command should not happen

   876     __ASSERT_DEBUG( iCommandPending, Panic( EGlxPanicLogicError ) );

   877 

   878     // Cancel command

   879     Collection().CancelRequest();

   880     iCommandPending = NULL;

   881     }

   882 

   883 // -----------------------------------------------------------------------------

   884 // Specify filter on the media list

   885 // -----------------------------------------------------------------------------

   886 void CGlxMediaList::SetFilterL(CMPXFilter* aFilter)

   887     {

   888     TRACER("CGlxMediaList::SetFilterL");

   889     

   890     // This method now takes a copy of the filter. It does not take ownership of aFilter

   891     

   892     CMPXFilter* tempFilter = NULL;

   893     

   894     if (aFilter)

   895         {

   896         // Create copy of filter

   897         tempFilter = CMPXFilter::NewL(*aFilter);

   898         CleanupStack::PushL(tempFilter);

   899         }

   900     

   901     // Set filter on the collection

   902     Collection().SetFilterL(aFilter);

   903 

   904     // Re-open collection if filter has been applied and list is already populated

   905     if ( iIsPopulated )

   906         {

   907         ReOpenL();

   908 

   909         iReorderPending = ETrue;

   910         }

   911 

   912     delete iFilter;

   913     iFilter = NULL;

   914 

   915     if (aFilter)

   916         {

   917         // SetFilterL did not leave. So take ownership of copy

   918         CleanupStack::Pop(tempFilter);

   919         iFilter = tempFilter;

   920         }

   921     }

   922 

   923 // -----------------------------------------------------------------------------

   924 // Returns filter on the media list

   925 // -----------------------------------------------------------------------------

   926 CMPXFilter* CGlxMediaList::Filter() const

   927     {

   928     TRACER("CGlxMediaList::Filter");

   929     

   930     return iFilter;

   931     }

   932 

   933 // ---------------------------------------------------------------------------

   934 // IdSpaceId

   935 // ---------------------------------------------------------------------------

   936 //

   937 TGlxIdSpaceId CGlxMediaList::IdSpaceId(TInt aIndex) const

   938     {

   939     TRACER("CGlxMediaList::IdSpaceId");

   940     

   941     ///@todo Delegate id space to item list.

   942     if (Count() && iItemList->Item(aIndex).IsStatic())

   943     	{

   944     	return KGlxStaticItemIdSpaceId;

   945     	}

   946     else

   947     	{

   948     	return iIdSpaceId;

   949     	}

   950     }

   951 

   952 // ---------------------------------------------------------------------------

   953 // CGlxMediaList::IsPopulated()

   954 // ---------------------------------------------------------------------------

   955 //

   956 TBool CGlxMediaList::IsPopulated() const

   957     {

   958     TRACER("CGlxMediaList::IsPopulated");

   959     

   960     return iIsPopulated;

   961     }

   962 

   963 

   964 // -----------------------------------------------------------------------------

   965 // Add a static item

   966 // -----------------------------------------------------------------------------

   967 //

   968 void CGlxMediaList::AddStaticItemL( CGlxMedia* aStaticItem, 

   969         NGlxListDefs::TInsertionPosition aTargetPosition )

   970     {

   971     TRACER("CGlxMediaList::AddStaticItemL");    

   972     

   973     iItemList->AddStaticItemL( aStaticItem, aTargetPosition );

   974     }

   975 

   976 // -----------------------------------------------------------------------------

   977 // Remove a static item

   978 // -----------------------------------------------------------------------------

   979 //

   980 void CGlxMediaList::RemoveStaticItem(const TGlxMediaId& aItemId)

   981 	{

   982 	TRACER("CGlxMediaList::RemoveStaticItem");

   983     

   984     iItemList->Remove(TGlxIdSpaceId(KGlxStaticItemIdSpaceId), aItemId);

   985 	}

   986 

   987 // -----------------------------------------------------------------------------

   988 // Enable/disable static items

   989 // -----------------------------------------------------------------------------

   990 //

   991 void CGlxMediaList::SetStaticItemsEnabled( TBool aEnabled )

   992     {

   993     TRACER("CGlxMediaList::SetStaticItemsEnabled");

   994     

   995     iItemList->SetStaticItemsEnabled( aEnabled );

   996     }

   997     

   998 // -----------------------------------------------------------------------------

   999 // return ETrue if static items are enabled

  1000 // -----------------------------------------------------------------------------

  1001 //

  1002 TBool CGlxMediaList::IsStaticItemsEnabled() const

  1003     {

  1004     TRACER("CGlxMediaList::IsStaticItemsEnabled");

  1005         

  1006     return iItemList->IsStaticItemsEnabled();

  1007     }

  1008 

  1009 // -----------------------------------------------------------------------------

  1010 // Sets the initial focus position

  1011 // -----------------------------------------------------------------------------

  1012 //

  1013 void CGlxMediaList::SetFocusInitialPosition(NGlxListDefs::TFocusInitialPosition aFocusInitialPosition)

  1014     {

  1015     TRACER("CGlxMediaList::SetFocusInitialPosition");    

  1016     

  1017     iItemList->SetFocusInitialPosition( aFocusInitialPosition );

  1018     }

  1019 

  1020 // -----------------------------------------------------------------------------

  1021 // Resets the focus to the initial position

  1022 // -----------------------------------------------------------------------------

  1023 //

  1024 void CGlxMediaList::ResetFocus()

  1025     {

  1026     TRACER("CGlxMediaList::ResetFocus");

  1027         

  1028     iItemList->ResetFocus();

  1029     }

  1030 

  1031 // ---------------------------------------------------------------------------

  1032 // From MMPXCollectionObserver

  1033 // Handle collection message

  1034 // ---------------------------------------------------------------------------

  1035 void CGlxMediaList::HandleCollectionMessageL(const CMPXMessage& aMessage)

  1036     {

  1037     TRACER("CGlxMediaList::HandleCollectionMessageL");

  1038     

  1039     

  1040     if (aMessage.IsSupported(KMPXMessageGeneralId))

  1041         {

  1042         TInt messageId = aMessage.ValueTObjectL<TInt>(KMPXMessageGeneralId);

  1043         if ( messageId == KMPXMessageGeneral )

  1044             {

  1045             if (!aMessage.IsSupported(KMPXMessageGeneralEvent) ||

  1046                 !aMessage.IsSupported(KMPXMessageGeneralType))

  1047                 {

  1048                 return;

  1049                 }

  1050 

  1051             TInt messageEvent = aMessage.ValueTObjectL<TInt>(KMPXMessageGeneralEvent);

  1052             if (messageEvent == TMPXCollectionMessage::EPathChanged)

  1053                 {

  1054                 GLX_LOG_INFO("CGlxMediaList::HandleCollectionMessageL() EPathChanged");

  1055 

  1056                 TInt messageType = aMessage.ValueTObjectL<TInt>(KMPXMessageGeneralType);

  1057                 switch (messageType)

  1058                     {

  1059                     case EMcPathChangedByOpen:

  1060                         {

  1061                         HandleOpenL();

  1062                         break;

  1063                         }

  1064                     case EMcPathChangedByCollectionChange:

  1065                         {

  1066                         break;

  1067                         }

  1068                     default:

  1069                         __ASSERT_DEBUG(EFalse, Panic(EGlxPanicLogicError));

  1070                         break;

  1071                     }

  1072                 }

  1073             }

  1074         else if (messageId == KMPXMessageIdItemChanged)

  1075             {

  1076             if (!aMessage.IsSupported(KMPXMessageMediaGeneralCategory) ||

  1077                 !aMessage.IsSupported(KMPXMessageChangeEventType) ||

  1078                 !aMessage.IsSupported(KMPXMessageMediaGeneralId))

  1079                 {

  1080                 return;

  1081                 }

  1082 

  1083             TMPXChangeEventType messageType = aMessage.ValueTObjectL<TMPXChangeEventType>(KMPXMessageChangeEventType);

  1084             switch (messageType)

  1085                 {

  1086                 case EMPXItemModified:

  1087                     {

  1088                     RArray<TMPXAttribute> attributes;

  1089                     CleanupClosePushL(attributes);

  1090                     TMPXItemId itemId = aMessage.ValueTObjectL<TMPXItemId>(KMPXMessageMediaGeneralId);

  1091                     HandleItemModifiedL(itemId, attributes);

  1092                     CleanupStack::PopAndDestroy(&attributes);

  1093                     iManager->HandleWindowChangedL(this);

  1094 

  1095                     // Drop through to perform sync, in case the order has changed

  1096                     }

  1097                 case EMPXItemInserted:

  1098                 case EMPXItemDeleted:

  1099                 default:

  1100                     // Items have changed, determine whether to sync now

  1101                     // or resync later if a sync is already pending after opening

  1102                     if ( iSyncStatus == KNonePending )

  1103                         {

  1104                         ReOpenL(); // force re-opens

  1105 

  1106                         iSyncStatus = KSyncPending;

  1107                         }

  1108                     else

  1109                         {

  1110                         iSyncStatus = KResyncPending;

  1111                         }

  1112                     break;

  1113                 }

  1114             }

  1115         else // received message isn't handled by media list

  1116             {

  1117             // Inform observers of message

  1118             TMessageNotificationStrategy strategy( aMessage, *this );

  1119             NotifyObservers( strategy );

  1120             }

  1121         }

  1122     }

  1123 

  1124 // ---------------------------------------------------------------------------

  1125 // From MMPXCollectionObserver

  1126 // Handles the collection entries being opened. Typically called

  1127 // when client has Open()'d a folder

  1128 // ---------------------------------------------------------------------------

  1129 //

  1130 void CGlxMediaList::HandleOpenL(const CMPXMedia& /*aEntries*/, TInt /*aIndex*/,

  1131         TBool /*aComplete*/, TInt aError)

  1132     {

  1133     TRACER("CGlxMediaList::HandleOpenL");

  1134