diff -r 453dfc402455 -r 0aa8cc770c8a mtpdataproviders/mtpplaybackcontroldp/mtpplaybackmpximplementation/src/cmtpplaybackplaylisthelper.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mtpdataproviders/mtpplaybackcontroldp/mtpplaybackmpximplementation/src/cmtpplaybackplaylisthelper.cpp	Tue Aug 31 16:03:15 2010 +0300
@@ -0,0 +1,756 @@
+// Copyright (c) 2010 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:
+//
+
+/**
+ @file
+ @internalComponent
+*/
+
+#include <mpxmediamusicdefs.h>
+#include <mpxmediacontainerdefs.h>
+#include <mpxmessagegeneraldefs.h>
+#include <pathinfo.h>
+
+#include <mpxcollectionhelper.h>
+#include <mpxcollectionhelperfactory.h>
+#include <mpxcollectionuihelper.h>
+#include <mpxcollectionhelperfactory.h>
+
+#include <mpxcollectionutility.h>
+#include <mpxcollectionplaylist.h>
+#include <mpxcollectionmessage.h>
+#include <mpxcollectionpath.h>
+
+#include "cmtpplaybackcontrolimpl.h"
+#include "cmtpplaybackplaylisthelper.h"
+#include "mtpplaybackcontrolpanic.h"
+
+// Constants
+__FLOG_STMT(_LIT8(KComponent,"PlaybackPlaylistHelper");)
+
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::NewL
+// ---------------------------------------------------------------------------
+//
+CMTPPlaybackPlaylistHelper* CMTPPlaybackPlaylistHelper::NewL( CMTPPlaybackControlImpl& aControlImpl )
+    {
+    CMTPPlaybackPlaylistHelper* self = new ( ELeave ) 
+                CMTPPlaybackPlaylistHelper( aControlImpl );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::~CMTPPlaybackPlaylistHelper
+// ---------------------------------------------------------------------------
+//
+CMTPPlaybackPlaylistHelper::~CMTPPlaybackPlaylistHelper()
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::~CMTPPlaybackPlaylistHelper"));
+    
+    if( iCollectionUiHelper )
+        {
+        iCollectionUiHelper->Close();
+        }
+    
+    if ( iCollectionHelper )
+        {
+        iCollectionHelper->Close();
+        }
+    
+    if( iCollectionUtil ) 
+        {
+        iCollectionUtil->Close();
+        }
+    
+    delete iPlayObject;
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::~CMTPPlaybackPlaylistHelper"));
+    __FLOG_CLOSE;
+    }
+
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::GetPlayListFromCollectionL
+//// Get Playlist via aMedia
+// ---------------------------------------------------------------------------
+//
+void CMTPPlaybackPlaylistHelper::GetPlayListFromCollectionL( const TMTPPbDataSuid& aPlayObject )
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::GetPlayListFromCollectionL"));
+    
+    //Reset
+    ResetPlaySource();
+    
+    iPlayCategory = aPlayObject.Category();
+    iPlayObject = aPlayObject.Suid().AllocL();
+    
+    switch ( iPlayCategory )
+        {
+        case EMTPPbCatPlayList:
+            {
+            OpenMusicPlayListPathL();
+            }
+            break;
+        case EMTPPbCatAlbum:
+            {
+            OpenMusicAblumPathL();
+            }
+            break;
+        default:
+            {
+            Panic( EMTPPBCollectionErrCall );
+            }
+            break;
+        }
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::GetPlayListFromCollectionL"));
+    }
+
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::GetPlayListFromCollectionL
+// Get Playlist via index
+// ---------------------------------------------------------------------------
+//
+void CMTPPlaybackPlaylistHelper::GetPlayListFromCollectionL( TInt aIndex )
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::GetPlayListFromCollectionL"));
+    
+    iSongIndex = aIndex;
+    
+    UpdatePathAndOpenL();
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::GetPlayListFromCollectionL"));
+    }
+
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::GetMTPPBSuidFromCollectionL
+// ---------------------------------------------------------------------------
+//
+TMTPPbDataSuid CMTPPlaybackPlaylistHelper::GetMTPPBSuidFromCollectionL( 
+        const CMPXCollectionPlaylist& aPlaylist )
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::GetPlayListFromCollectionL"));
+    
+    CMPXCollectionPath* path = iCollectionUiHelper->MusicPlaylistPathL();
+    if ( path->Id() == aPlaylist.Path().Id( KMTPPlaybackPlaylistAblumLevel -1 ))
+        {
+        iPlayCategory = EMTPPbCatPlayList;
+        }
+    else
+        {
+        iPlayCategory = EMTPPbCatAlbum;
+        }
+    TFileName uri = ItemIdToUriL( aPlaylist.Path().Id( KMTPPlaybackPlaylistAblumLevel ));
+    TMTPPbDataSuid dataSuid( iPlayCategory, uri );
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::GetPlayListFromCollectionL"));
+    return dataSuid;
+    }
+
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::MTPPbCategory
+// ---------------------------------------------------------------------------
+//
+TMTPPbCategory CMTPPlaybackPlaylistHelper::MTPPbCategory() const
+    {
+    return iPlayCategory;
+    }
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::MTPPbSuid
+// ---------------------------------------------------------------------------
+//
+TFileName CMTPPlaybackPlaylistHelper::MTPPbSuid() const
+    {
+    return TFileName( *iPlayObject );
+    }
+
+// ---------------------------------------------------------------------------
+// From MMPXCollectionObserver
+// Handle completion of a asynchronous command
+// ---------------------------------------------------------------------------
+//
+void CMTPPlaybackPlaylistHelper::HandleCollectionMessage( CMPXMessage* aMsg, TInt aErr )
+    {
+    __FLOG_1(_L8("+CMTPPlaybackPlaylistHelper::HandleCollectionMessage( %d ) "), aErr );
+
+    if (( KErrNone == aErr ) && aMsg )
+        {
+        TRAP( aErr, DoHandleCollectionMessageL( *aMsg ));
+        }
+    
+    if ( KErrNone != aErr )
+        {
+        TInt error = MTPPlaybackControlImpl().MapError( aErr );
+        MTPPlaybackControlImpl().DoHandleError( error );
+        }
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::HandleCollectionMessage"));
+    }
+// ---------------------------------------------------------------------------
+// From MMPXCollectionObserver
+// ---------------------------------------------------------------------------  
+//
+void CMTPPlaybackPlaylistHelper::HandleOpenL( const CMPXMedia& aEntries, 
+        TInt /*aIndex*/, TBool /*aComplete*/, TInt aError )
+    {
+    __FLOG_1(_L8("+CMTPPlaybackPlaylistHelper::HandleOpenL( %d )"), aError );
+    
+    if ( KErrNone == aError )
+        {
+        TRAP( aError, DoHandleOpenL( aEntries ));
+        }
+    
+    if ( KErrNone != aError )
+        {
+        TInt error = MTPPlaybackControlImpl().MapError( aError );
+        MTPPlaybackControlImpl().DoHandleError( error );
+        }
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::HandleOpenL"));
+    }
+
+// ---------------------------------------------------------------------------
+// From MMPXCollectionObserver
+// ---------------------------------------------------------------------------  
+//
+void CMTPPlaybackPlaylistHelper::HandleOpenL( const CMPXCollectionPlaylist& aPlaylist,
+        TInt aError )
+    {
+    __FLOG_1(_L8("+CMTPPlaybackPlaylistHelper::HandleOpenL( aPlaylist, aError = %d )"), aError );
+    
+    if ( KErrNone == aError )
+        {
+        TRAP( aError, MTPPlaybackControlImpl().GetPlaylistFromCollectionCompleteL( aPlaylist ));
+        }
+    
+    if ( KErrNone != aError )
+        {
+        TInt error = MTPPlaybackControlImpl().MapError( aError );
+        MTPPlaybackControlImpl().DoHandleError( error );
+        }
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::HandleOpenL( aPlaylist, aError )"));
+    }
+
+// ---------------------------------------------------------------------------
+// From MMPXCollectionMediaObserver
+// ---------------------------------------------------------------------------
+void CMTPPlaybackPlaylistHelper::HandleCollectionMediaL( const CMPXMedia& /*aMedia*/, TInt /*aError*/ )
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::HandleCollectionMediaL"));
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::HandleCollectionMediaL"));
+    }
+
+//
+// CMTPPlaybackPlaylistHelper::CMTPPlaybackPlaylistHelper
+// ---------------------------------------------------------------------------
+//
+CMTPPlaybackPlaylistHelper::CMTPPlaybackPlaylistHelper( CMTPPlaybackControlImpl& aControlImpl )
+        : iCollectionUiHelper( NULL ),
+          iCollectionHelper( NULL ),
+          iCollectionUtil( NULL ),
+          iPlayObject( NULL ),
+          iMTPPlaybackControl( aControlImpl )
+    {
+    }
+
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::ConstructL
+// ---------------------------------------------------------------------------
+//
+void CMTPPlaybackPlaylistHelper::ConstructL()
+    {
+    __FLOG_OPEN(KMTPSubsystem, KComponent);
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::ConstructL"));
+    
+    iCollectionUiHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL();
+    iCollectionUtil = MMPXCollectionUtility::NewL( this, KMcModeDefault );
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::ConstructL"));
+    }
+
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::DoHandleCollectionMessage
+// ---------------------------------------------------------------------------
+//
+void CMTPPlaybackPlaylistHelper::DoHandleCollectionMessageL( const CMPXMessage& aMsg )
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::DoHandleCollectionMessage"));
+    
+    TMPXMessageId id( aMsg.ValueTObjectL<TMPXMessageId>( KMPXMessageGeneralId ) );
+
+    if ( KMPXMessageGeneral == id )
+        {
+        TInt event( aMsg.ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) );
+        TInt type( aMsg.ValueTObjectL<TInt>( KMPXMessageGeneralType ) );
+        TInt data( aMsg.ValueTObjectL<TInt>( KMPXMessageGeneralData ) );
+        
+        __FLOG_VA((_L8("Event code is 0x%X, type code is 0x%X"), event, type ));
+        __FLOG_1(_L8("Data code is 0x%X"), data );
+        
+        if ( event == TMPXCollectionMessage::EPathChanged &&
+             type == EMcPathChangedByOpen && 
+             data == EMcContainerOpened )
+            {
+            iCollectionUtil->Collection().OpenL();
+            }
+        else if ( event == TMPXCollectionMessage::EPathChanged &&
+                  type == EMcPathChangedByOpen &&
+                  data == EMcItemOpened )
+            {
+            iCollectionUtil->Collection().OpenL();
+            }
+        else if ( event == TMPXCollectionMessage::ECollectionChanged )
+            {
+            __FLOG(_L8("Ignore this event"));
+            }
+        }
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::DoHandleCollectionMessage"));
+    }
+
+// ----------------------------------------------------
+// CMTPPlaybackPlaylistHelper::DoHandleOpenL
+// ----------------------------------------------------
+//
+void CMTPPlaybackPlaylistHelper::DoHandleOpenL( const CMPXMedia& aEntries )
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::DoHandleOpenL( const CMPXMedia )"));
+    
+    if ( EMTPPbCatAlbum == iPlayCategory )
+        {
+        UpdateAlbumPathAndOpenL();
+        }
+    else
+        {
+        //playlist
+        if ( -1 == iPathIndex )
+            {
+            //first, the top path
+            UpdatePlaylistPathIndexL( aEntries );
+                
+            if ( -1 == iPathIndex )
+                {
+                MTPPlaybackControlImpl().DoHandleError( KPlaybackErrParamInvalid );
+                }
+            else
+                {
+                iCollectionUtil->Collection().OpenL( iPathIndex );
+                }
+                }
+        else
+            {
+            //open the first song when initObject
+            iCollectionUtil->Collection().OpenL( iSongIndex );
+            }
+        }
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::DoHandleOpenL( const CMPXMedia )"));
+    }
+
+// ----------------------------------------------------
+// CMTPPlaybackPlaylistHelper::OpenMusicPlayListPathL
+// ----------------------------------------------------
+//
+void CMTPPlaybackPlaylistHelper::OpenMusicPlayListPathL()
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::OpenMusicPlayListPathL"));
+    
+    CMPXCollectionPath* path = iCollectionUiHelper->MusicPlaylistPathL();
+    CleanupStack::PushL( path );
+    iCollectionUtil->Collection().OpenL( *path );
+    CleanupStack::PopAndDestroy( path );
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::OpenMusicPlayListPathL"));
+    }
+
+// ----------------------------------------------------
+// CMTPPlaybackPlaylistHelper::OpenMusicAblumPathL
+// ----------------------------------------------------
+//
+void CMTPPlaybackPlaylistHelper::OpenMusicAblumPathL()
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::OpenMusicAblumPathL"));
+    
+    CMPXCollectionPath* path = iCollectionUiHelper->MusicMenuPathL();
+    CleanupStack::PushL( path );
+    path->AppendL(KMPXCollectionArtistAlbum);
+    iCollectionUtil->Collection().OpenL( *path );
+    CleanupStack::PopAndDestroy( path );
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::OpenMusicAblumPathL"));
+    }
+
+// ----------------------------------------------------
+// CMTPPlaybackPlaylistHelper::ResetPlaySource
+// ----------------------------------------------------
+//
+void CMTPPlaybackPlaylistHelper::ResetPlaySource()
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::ResetPlaySourceL"));
+    
+    iPathIndex = -1;
+    iSongIndex = 0;
+    delete iPlayObject;
+    iPlayObject = NULL;
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::ResetPlaySourceL"));
+    }
+
+// ----------------------------------------------------
+// CMTPPlaybackPlaylistHelper::UpdatePlaylistPathIndexL
+// ----------------------------------------------------
+//
+void CMTPPlaybackPlaylistHelper::UpdatePlaylistPathIndexL( const CMPXMedia& aEntries )
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::UpdatePlaylistPathIndexL"));
+    __ASSERT_DEBUG( iPlayCategory == EMTPPbCatPlayList, Panic( EMTPPBCollectionErrCall ));
+    
+    const CMPXMediaArray* refArray = aEntries.Value<CMPXMediaArray> ( KMPXMediaArrayContents );
+    TInt count = refArray->Count();
+    const TMPXItemId playlistId = UriToItemIdL();
+    
+    for ( TInt i=0; i<count; ++i )
+        {
+        CMPXMedia* container = refArray->AtL(i);
+        /**
+         * Try to find out the next path according to the 
+         * playlist's ItemId
+         */
+        if ( container->IsSupported( KMPXMediaGeneralId ))
+            {
+            const TMPXItemId tempId = container->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
+            if ( tempId == playlistId )
+                {
+                iPathIndex = i;
+                break;
+                }
+            }
+       }
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::UpdatePlaylistPathIndexL"));
+    }
+
+// ---------------------------------------------------------------------------
+// return instance of CollectionHelper.
+// ---------------------------------------------------------------------------
+//
+MMPXCollectionHelper* CMTPPlaybackPlaylistHelper::CollectionHelperL()
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::CollectionHelperL"));
+    
+    if ( iCollectionHelper == NULL )
+        {
+        iCollectionHelper = CMPXCollectionHelperFactory::NewCollectionCachedHelperL();
+            
+        // Do a search for a song ID that does not exist
+        RArray<TInt> contentIDs;
+        CleanupClosePushL( contentIDs ); // + contentIDs
+        contentIDs.AppendL( KMPXMediaIdGeneral );
+            
+        CMPXMedia* searchMedia = CMPXMedia::NewL( contentIDs.Array() );
+        CleanupStack::PopAndDestroy( &contentIDs ); // - contentIDs
+        CleanupStack::PushL( searchMedia ); // + searchMedia
+            
+        searchMedia->SetTObjectValueL( KMPXMediaGeneralType, EMPXItem );
+        searchMedia->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXSong );
+        searchMedia->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId,
+                KMTPPlaybackInvalidSongID );
+            
+        /*
+        * store root
+        */
+        TChar driveChar = 'c';
+        TInt driveNumber;
+        User::LeaveIfError( RFs::CharToDrive( driveChar, driveNumber ) );
+            
+        // get root path
+        TBuf<KStorageRootMaxLength> storeRoot;
+        User::LeaveIfError( PathInfo::GetRootPath( storeRoot, driveNumber ) );
+            
+        searchMedia->SetTextValueL( KMPXMediaGeneralDrive, storeRoot );
+            
+        RArray<TMPXAttribute> songAttributes;
+        CleanupClosePushL( songAttributes ); // + songAttributes
+        songAttributes.AppendL( KMPXMediaGeneralId );
+            
+        CMPXMedia* foundMedia = NULL;
+        TRAPD( err, foundMedia = iCollectionHelper->FindAllL(
+                *searchMedia,
+                songAttributes.Array() ) );
+            
+        CleanupStack::PopAndDestroy( &songAttributes ); // - songAttributes
+        CleanupStack::PopAndDestroy( searchMedia ); // - searchMedia
+            
+        CleanupStack::PushL( foundMedia ); // + foundMedia
+            
+        if ( err != KErrNone )
+            {
+            iCollectionHelper->Close();
+            iCollectionHelper = NULL;
+            User::Leave( KErrGeneral );
+            }
+        CleanupStack::PopAndDestroy( foundMedia ); // - foundMedia
+        }
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::CollectionHelperL"));
+    return iCollectionHelper;
+    }
+
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::UriToItemIdL
+// ---------------------------------------------------------------------------
+//
+const TMPXItemId CMTPPlaybackPlaylistHelper::UriToItemIdL()
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::UriToItemIdL"));
+    
+
+    TMPXItemId itemId( KMPXInvalidItemId );
+    TInt error = KErrNone;
+    CMPXMedia* result = NULL;
+    
+    RArray<TMPXAttribute> atts; 
+    CleanupClosePushL( atts );
+    atts.AppendL( KMPXMediaGeneralId );
+    
+    if ( EMTPPbCatPlayList == iPlayCategory )
+        {
+        TRAP( error, result = CollectionHelperL()->GetL( *iPlayObject, atts.Array(), EMPXPlaylist ));
+        }
+    else
+        {
+        TRAP( error, result = CollectionHelperL()->GetL( *iPlayObject, atts.Array(), EMPXAbstractAlbum ));
+        }
+    
+    if ( error != KErrNone )
+        {
+        CleanupStack::PopAndDestroy( &atts );
+        }
+    else
+        {
+        CleanupStack::PushL( result );
+        itemId = result->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
+        CleanupStack::PopAndDestroy( result );
+        CleanupStack::PopAndDestroy( &atts );
+        }
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::UriToItemIdL"));
+    return itemId;
+    }
+
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::ItemIdToUriL.
+// ---------------------------------------------------------------------------
+//
+const TFileName CMTPPlaybackPlaylistHelper::ItemIdToUriL( const TMPXItemId& aId )
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::ItemIdToUriL"));
+    
+    TFileName itemUri( KNullDesC );
+    
+    RArray<TInt> contentIDs;
+    CleanupClosePushL( contentIDs ); // + contentIDs
+    contentIDs.AppendL( KMPXMediaIdGeneral );
+    
+    CMPXMedia* searchMedia = CMPXMedia::NewL( contentIDs.Array() );
+    CleanupStack::PopAndDestroy( &contentIDs ); // - contentIDs
+    CleanupStack::PushL( searchMedia ); // + searchMedia
+        
+    searchMedia->SetTObjectValueL( KMPXMediaGeneralType, EMPXItem );
+    if ( iPlayCategory == EMTPPbCatPlayList )
+        {
+        searchMedia->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXPlaylist );
+        }
+    else
+        {
+        searchMedia->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXAbstractAlbum );
+        }
+    searchMedia->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId, aId );
+    
+    RArray<TMPXAttribute> resultAttributes;
+    CleanupClosePushL( resultAttributes ); // + resultAttributes
+    resultAttributes.AppendL( KMPXMediaGeneralUri );
+    
+    CMPXMedia* foundMedia = CollectionHelperL()->FindAllL(
+                    *searchMedia,
+                    resultAttributes.Array() );
+                    
+    CleanupStack::PopAndDestroy( &resultAttributes ); // - resultAttributes
+    CleanupStack::PopAndDestroy( searchMedia ); // - searchMedia
+    
+    CleanupStack::PushL( foundMedia ); // + foundMedia
+    if ( !foundMedia->IsSupported( KMPXMediaArrayCount ))
+        {
+        User::Leave( KErrNotSupported );
+        }
+    else if ( *foundMedia->Value<TInt>( KMPXMediaArrayCount ) != 1 )
+        {
+        User::Leave( KErrNotSupported );
+        }
+    
+    const CMPXMediaArray* tracksArray = foundMedia->Value<CMPXMediaArray> ( KMPXMediaArrayContents );
+    CMPXMedia* item = tracksArray->AtL(0);
+    
+    if ( item->IsSupported( KMPXMediaGeneralUri ))
+        {
+        itemUri = item->ValueText(KMPXMediaGeneralUri);
+        }
+    
+    CleanupStack::PopAndDestroy( foundMedia ); // - foundMedia
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::ItemIdToUriL"));
+    return itemUri;
+    }
+
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::FindAlbumSongsL
+// ---------------------------------------------------------------------------
+//
+CMPXMedia* CMTPPlaybackPlaylistHelper::FindAlbumSongsL( const TMPXItemId& aAlbumId )
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::FindAlbumSongsL"));
+    
+    // Fetch the songs for the selected album
+    CMPXMedia* findCriteria = CMPXMedia::NewL();
+    CleanupStack::PushL( findCriteria );
+    findCriteria->SetTObjectValueL<TMPXGeneralType>( KMPXMediaGeneralType, EMPXGroup );
+    findCriteria->SetTObjectValueL<TMPXGeneralCategory>( KMPXMediaGeneralCategory, EMPXSong );
+    findCriteria->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId, aAlbumId );
+    RArray<TMPXAttribute> attrs;
+    CleanupClosePushL( attrs );
+    attrs.Append( TMPXAttribute( KMPXMediaIdGeneral,
+                                 EMPXMediaGeneralTitle |
+                                 EMPXMediaGeneralId ) );
+    attrs.Append( KMPXMediaMusicAlbumTrack );
+    
+    CMPXMedia* foundMedia = CollectionHelperL()->FindAllL( *findCriteria,
+            attrs.Array() );
+    CleanupStack::PopAndDestroy( &attrs );
+    CleanupStack::PopAndDestroy( findCriteria );
+    
+    if ( !foundMedia->IsSupported( KMPXMediaArrayCount ) )
+        {
+        User::Leave( KErrNotSupported );
+        }
+    TInt foundItemCount = *foundMedia->Value<TInt>( KMPXMediaArrayCount );
+    if ( foundItemCount == 0 )
+        {
+        User::Leave( KErrNotFound );
+        }
+    if ( !foundMedia->IsSupported( KMPXMediaArrayContents ) )
+        {
+        User::Leave( KErrNotSupported );
+        }
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::FindAlbumSongsL"));
+    return foundMedia;
+    }
+
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::UpdatePathAndOpenL.
+// aParam: const CMPXMedia& aAlbums
+// ---------------------------------------------------------------------------
+//
+void CMTPPlaybackPlaylistHelper::UpdateAlbumPathAndOpenL()
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::UpdateAlbumPathAndOpenL"));
+    
+    RArray<TMPXItemId> ids;
+    CleanupClosePushL(ids);
+    
+    CMPXCollectionPath* cpath = iCollectionUtil->Collection().PathL();
+    CleanupStack::PushL( cpath );
+    
+    if (cpath->Levels() == 3)
+        {
+        // go back one level before amending path with new levels
+        cpath->Back();
+        }
+    
+    const TMPXItemId id = UriToItemIdL();
+    if ( KMPXInvalidItemId == id )
+        {
+        MTPPlaybackControlImpl().DoHandleError( KPlaybackErrParamInvalid );
+        CleanupStack::PopAndDestroy( cpath );
+        CleanupStack::PopAndDestroy(&ids);
+        return;
+        }
+    
+    ids.AppendL(id);
+    cpath->AppendL( ids.Array() ); // top level items
+    cpath->Set( 0 );
+    ids.Reset();
+    
+    CMPXMedia* songs = FindAlbumSongsL( id );
+    CleanupStack::PushL( songs );
+    const CMPXMediaArray* tracksArray = songs->Value<CMPXMediaArray> ( KMPXMediaArrayContents );
+    User::LeaveIfNull(const_cast<CMPXMediaArray*>(tracksArray));
+    TUint count = tracksArray->Count();
+    for (TInt i=0; i<count; ++i)
+        {
+        CMPXMedia* song = tracksArray->AtL(i);
+        const TMPXItemId id = song->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
+        ids.AppendL(id);
+        }
+
+    cpath->AppendL(ids.Array()); // top level items
+    cpath->Set( iSongIndex );
+    
+    iCollectionUtil->Collection().OpenL(*cpath);
+    CleanupStack::PopAndDestroy( songs );    
+    CleanupStack::PopAndDestroy( cpath );
+    CleanupStack::PopAndDestroy(&ids);
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::UpdateAlbumPathAndOpenL"));
+    }
+
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::UpdatePathAndOpenL.
+// ---------------------------------------------------------------------------
+//
+void CMTPPlaybackPlaylistHelper::UpdatePathAndOpenL()
+    {
+    __FLOG(_L8("+CMTPPlaybackPlaylistHelper::UpdatePathAndOpenL()"));
+    
+    RArray<TMPXItemId> ids;
+    CleanupClosePushL(ids);
+    
+    CMPXCollectionPath* cpath = iCollectionUtil->Collection().PathL();
+    CleanupStack::PushL( cpath );
+    
+    cpath->Set( iSongIndex );
+    
+    iCollectionUtil->Collection().OpenL(*cpath);  
+    CleanupStack::PopAndDestroy( cpath );
+    CleanupStack::PopAndDestroy(&ids);
+    
+    __FLOG(_L8("-CMTPPlaybackPlaylistHelper::UpdatePathAndOpenL( aSong Index )"));
+    }
+
+// ---------------------------------------------------------------------------
+// CMTPPlaybackPlaylistHelper::MTPPlaybackControlImpl.
+// ---------------------------------------------------------------------------
+//
+CMTPPlaybackControlImpl& CMTPPlaybackPlaylistHelper::MTPPlaybackControlImpl()
+    {
+    return iMTPPlaybackControl;
+    }
+
+