diff -r 2a40e88564c8 -r 4e84c994a771 mpviewplugins/mpcollectionviewplugin/src/mpmpxframeworkwrapper_p.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mpviewplugins/mpcollectionviewplugin/src/mpmpxframeworkwrapper_p.cpp	Fri Mar 19 09:28:13 2010 +0200
@@ -0,0 +1,917 @@
+/*
+* Copyright (c) 2009 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: Wrapper for mpx framework utilities - private implementation.
+*
+*/
+
+#include <QStringList>
+
+#include <s32strm.h>
+#include <s32mem.h>
+#include <apgcli.h>
+#include <apacmdln.h>
+
+#include <mpxplaybackutility.h>
+#include <mpxcollectionutility.h>
+#include <mpxharvesterutility.h>
+#include <mpxcollectionpath.h>
+#include <mpxcollectionmessage.h>
+#include <mpxcollectionplaylist.h>
+#include <mpxmessagecontainerdefs.h>
+#include <mpxmediacollectiondetaildefs.h>
+#include <mpxmediamusicdefs.h>
+#include <mpxmediageneraldefs.h>
+#include <mpxcollectionplugin.hrh>
+#include <mpxmessagegeneraldefs.h>
+#include <mpxmediacontainerdefs.h>
+#include <mpxcollectionmessagedefs.h>
+#include <mpxparameter.h>
+#include <mpxcollectionhelperfactory.h>
+#include <mpxcollectionuihelper.h>
+#include <mpxcollectionopenutility.h>
+#include <mpxmediaarray.h>
+#include <mpxmedia.h>
+#include <mpxlog.h>
+
+#include "mpmpxframeworkwrapper_p.h"
+#include "mpmpxframeworkwrapper.h"
+#include "mpmpxcollectiondata.h"
+#include "mpcommondefs.h"
+#include "mptrace.h"
+#include "mpsettingsmanager.h"
+
+const TInt KIncrementalDelayNone = 0;
+const TInt KIncrementalDelayHalfSecond = 1000000;
+const TInt KIncrementalFetchBlockSize = 40;
+
+const TInt KMPXChunkSize = 100;  // number of songs added in each chunk, IncAddL
+_LIT( KPlaylistPath, "C:\\Data\\Playlists\\" ); // Todo
+
+/*!
+    \class MpMpxFrameworkWrapperPrivate
+    \brief Wrapper for mpx framework utilities - private implementation.
+
+    This is a private implementation of the mpx framework wrapper utilties interface.
+*/
+
+/*!
+ \internal
+ */
+MpMpxFrameworkWrapperPrivate::MpMpxFrameworkWrapperPrivate( MpMpxFrameworkWrapper *wrapper )
+    : q_ptr(wrapper),
+      iCollectionUtility(0),
+      iCollectionUiHelper(0),
+      iIncrementalOpenUtil(0),
+      iPlaybackUtility(0),
+      iHarvesterUtility(0),
+      iCollectionData(0),
+      iFirstIncrementalOpen(EFalse),
+      iUserPlaylists(0)
+{
+    TX_LOG
+}
+
+/*!
+ \internal
+ */
+MpMpxFrameworkWrapperPrivate::~MpMpxFrameworkWrapperPrivate()
+{
+    TX_ENTRY
+    delete iCollectionData;
+
+    if ( iCollectionUtility ) {
+        iCollectionUtility->Collection().CancelRequest();
+        iCollectionUtility->Close();
+    }
+
+    if ( iCollectionUiHelper ) {
+        iCollectionUiHelper->Close();
+    }
+
+	if ( iPlaybackUtility ) {
+        iPlaybackUtility->Close();
+    }
+
+    if ( iHarvesterUtility ) {
+        iHarvesterUtility->Close();
+    }
+
+    delete iIncrementalOpenUtil;
+    delete iUserPlaylists;
+
+    TX_EXIT
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::init( MpCommon::MpViewMode viewMode )
+{
+
+    iViewMode = viewMode;
+    TRAPD(err, DoInitL());
+    if ( err != KErrNone ) {
+        TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::openCollection( TCollectionContext context )
+{
+    TRAPD(err, DoOpenCollectionL(context));
+    if ( err != KErrNone ) {
+        TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::openCollectionItem( int index )
+{
+    TRAPD(err, DoOpenCollectionItemL(index));
+    if ( err != KErrNone ) {
+        TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::reopenCollection()
+{
+    TRAPD(err, DoReopenCollectionL());
+    if ( err != KErrNone ) {
+        TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::back()
+{
+    TRAPD(err, DoBackL());
+    if ( err != KErrNone ) {
+        TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::findPlaylists( QStringList &playlists )
+{
+    TRAPD(err, DoFindPlaylistsL(playlists));
+    if ( err != KErrNone ) {
+        TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::createPlaylist( QString playlistName, QList<int> selection )
+{
+    TRAPD(err, DoCreatePlaylistL(playlistName, selection));
+    if ( err != KErrNone ) {
+        TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::saveToPlaylist( int playlistIndex, QList<int> selection )
+{
+    TRAPD(err, DoSaveToPlaylistL(playlistIndex, selection));
+    if ( err != KErrNone ) {
+        TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::deleteSongs( QList<int> selection )
+{
+    TRAPD(err, DoDeleteSongsL(selection));
+    if ( err != KErrNone ) {
+        TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::renamePlaylist( QString newName, int index )
+{      
+    TRAPD(err, DoRenamePlaylistL(newName, index));
+    if ( err != KErrNone ) {
+    TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::renamePlaylist( QString newName )
+{      
+    TRAPD(err, DoRenamePlaylistL(newName));
+    if ( err != KErrNone ) {
+    TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::setShuffle( bool active )
+{
+    TRAPD(err, DoSetShuffleL(active));
+    if ( err != KErrNone ) {
+        TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::scan()
+{
+    TRAPD(err, DoScanL());
+    if ( err != KErrNone ) {
+        TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::cancelScan()
+{
+    TRAPD(err, DoCancelScanL());
+    if ( err != KErrNone ) {
+        TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::previewItem( int index )
+{
+    TRAPD(err, DoPreviewItemL(index));
+    if ( err != KErrNone ) {
+        TX_LOG_ARGS("Error: " << err << "; should never get here.");
+    }
+}
+
+/*!
+ \internal
+ */
+MpMpxCollectionData *MpMpxFrameworkWrapperPrivate::collectionData()
+{
+    return iCollectionData;
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::HandleOpenL(
+    const CMPXMedia& aEntries,
+    TInt aIndex,
+    TBool aComplete,
+    TInt aError )
+{
+    Q_UNUSED(aIndex);
+    TX_UNUSED(aComplete);
+    TX_ENTRY_ARGS("aError=" << aError << "aComplete=" << aComplete);
+    if ( aError == KErrNone ) {
+        if ( iFirstIncrementalOpen ) {
+            iCollectionData->setMpxMedia(aEntries);
+            iFirstIncrementalOpen = EFalse;
+        }
+    }
+    else {
+        TX_LOG_ARGS("Error: " << aError << "; should never get here.");
+    }
+    TX_EXIT
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::HandleOpenL(
+    const CMPXCollectionPlaylist& aPlaylist,
+    TInt aError )
+{
+    TX_ENTRY_ARGS("aError=" << aError);
+
+    if ( aError == KErrNone ) {
+        if ( !iPlaybackUtility ) {
+            iPlaybackUtility = MMPXPlaybackUtility::UtilityL( TUid::Uid(MpCommon::KMusicPlayerUid) );
+            if ( iViewMode == MpCommon::DefaultView ) {
+                iPlaybackUtility->SetL( EPbPropertyRandomMode, MpSettingsManager::shuffle() ? ETrue : EFalse );
+                iPlaybackUtility->SetL( EPbPropertyRepeatMode, MpSettingsManager::repeat() ? EPbRepeatAll : EPbRepeatOff);
+            }
+        }
+        iPlaybackUtility->InitL( aPlaylist, ETrue );
+        emit q_ptr->collectionPlaylistOpened();
+    }
+    else {
+        TX_LOG_ARGS("Error: " << aError << "; should never get here.");
+    }
+    TX_EXIT
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::HandleCollectionMessage(
+    CMPXMessage* aMsg,
+    TInt aErr )
+{
+    TX_ENTRY_ARGS("aErr=" << aErr);
+    if ( aErr == KErrNone && aMsg )
+        {
+        TRAP_IGNORE( DoHandleCollectionMessageL( *aMsg ) );
+    }
+    TX_EXIT
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::HandleCollectionMediaL(
+    const CMPXMedia& aMedia,
+    TInt aError )
+{
+    Q_UNUSED(aMedia);
+    Q_UNUSED(aError);
+}
+
+/*!
+ \internal
+ Handles the completion of any collection helper event.
+ */
+void MpMpxFrameworkWrapperPrivate::HandleOperationCompleteL(
+    TCHelperOperation aOperation,
+    TInt aErr,
+    void* aArgument )
+{
+    TX_ENTRY_ARGS("aErr=" << aErr);
+    switch( aOperation ) {
+    case EDeleteOp:
+        if ( KErrNone == aErr ) {
+            emit q_ptr->songsDeleted(true);
+        }
+        else {
+            emit q_ptr->songsDeleted(false);
+        }
+        break;
+    case EAddOp:
+        if ( KErrNone == aErr ) {
+            emit q_ptr->playlistSaved(true);
+        }
+        else {
+            emit q_ptr->playlistSaved(false);
+        }
+        break;
+    case ERenameOp:
+        if ( KErrNone == aErr ) {
+            emit q_ptr->playlistsRenamed(true);
+        }
+        else {
+            emit q_ptr->playlistsRenamed(false);
+        }
+        break;
+    default:
+        break;
+    }
+
+    if ( aArgument ) {
+        delete ( CBase* )aArgument;
+    }
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoInitL()
+{
+    TX_ENTRY
+    iCollectionUtility = MMPXCollectionUtility::NewL( this, KMcModeDefault );
+    iCollectionUiHelper = CMPXCollectionHelperFactory:: NewCollectionUiHelperL();
+    iIncrementalOpenUtil = CMPXCollectionOpenUtility::NewL( this );
+
+    iHarvesterUtility = CMPXHarvesterFactory::NewL();
+    iHarvesterUtility->CheckForSystemEventsL();
+
+    iCollectionData = new MpMpxCollectionData();
+    TX_EXIT
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoOpenCollectionL(
+    TCollectionContext aContext )
+{
+    TX_ENTRY_ARGS("aContext=" << aContext);
+
+    switch ( aContext ) {
+    case ECollectionContextAllSongs:
+        {
+        CMPXCollectionPath* cpath = iCollectionUiHelper->MusicAllSongsPathL();
+        CleanupStack::PushL( cpath );
+        iCollectionUtility->Collection().OpenL( *cpath );
+        CleanupStack::PopAndDestroy( cpath );
+        break;
+        }
+    case ECollectionContextArtistAlbums:
+        {
+        CMPXCollectionPath* cpath = iCollectionUiHelper->MusicMenuPathL();
+        CleanupStack::PushL( cpath );
+        cpath->AppendL( 3 );
+        iCollectionUtility->Collection().OpenL( *cpath );
+        CleanupStack::PopAndDestroy( cpath );
+        break;
+        }
+    case ECollectionContextPlaylists:
+        {
+        CMPXCollectionPath* cpath = iCollectionUiHelper->MusicPlaylistPathL();
+        CleanupStack::PushL( cpath );
+        iCollectionUtility->Collection().OpenL( *cpath );
+        CleanupStack::PopAndDestroy( cpath );
+        break;
+        }
+    case ECollectionContextGenres:
+        {
+        CMPXCollectionPath* cpath = iCollectionUiHelper->MusicMenuPathL();
+        CleanupStack::PushL( cpath );
+        // Temp
+        cpath->AppendL( 5 );
+        iCollectionUtility->Collection().OpenL( *cpath );
+        CleanupStack::PopAndDestroy( cpath );
+        break;
+        }
+    default:
+        TX_LOG_ARGS("Error: Unexpected context; should never get here.");
+        break;
+    }
+    TX_EXIT
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoOpenCollectionItemL( TInt aIndex )
+    {
+    TX_ENTRY_ARGS("aIndex=" << aIndex);
+    iCollectionUtility->Collection().OpenL( aIndex );
+    TX_EXIT
+    }
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoIncrementalOpenL()
+{
+    TX_ENTRY
+    // Cancel any reads
+    iIncrementalOpenUtil->Stop();
+
+    // Start the read
+    iFirstIncrementalOpen = ETrue;
+    RArray<TMPXAttribute> attrs;
+    CleanupClosePushL( attrs );
+    TArray<TMPXAttribute> ary = attrs.Array();
+    iIncrementalOpenUtil->SetDelay( KIncrementalDelayNone );
+    iIncrementalOpenUtil->StartL( ary, KIncrementalFetchBlockSize,
+                                  KErrNotFound, CMPXCollectionOpenUtility::EFetchNormal );
+    iIncrementalOpenUtil->SetDelay( KIncrementalDelayHalfSecond );
+    CleanupStack::PopAndDestroy( &attrs );
+    TX_EXIT
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoReopenCollectionL()
+{
+    TX_ENTRY
+    CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();
+    CleanupStack::PushL( cpath );
+    cpath->Back();
+    iCollectionUtility->Collection().OpenL(*cpath);
+    CleanupStack::PopAndDestroy( cpath );
+    TX_EXIT
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoBackL()
+{
+    TX_ENTRY
+    iCollectionUtility->Collection().BackL();
+    TX_EXIT
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoFindPlaylistsL( QStringList &playlists )
+{
+    TX_ENTRY
+    delete iUserPlaylists;
+    iUserPlaylists = NULL;
+
+    RArray<TMPXAttribute> attrs;
+    CleanupClosePushL( attrs );
+    attrs.Append( KMPXMediaGeneralId );
+    attrs.Append( KMPXMediaGeneralTitle );
+
+    CMPXMedia* criteria = CMPXMedia::NewL();
+    CleanupStack::PushL( criteria );
+    criteria->SetTObjectValueL<TMPXGeneralType>(
+        KMPXMediaGeneralType, EMPXGroup );
+    criteria->SetTObjectValueL<TMPXGeneralCategory>(
+        KMPXMediaGeneralCategory, EMPXPlaylist );
+
+    // Look up collection UID and set to criteria
+    RArray<TUid> ary;
+    CleanupClosePushL( ary );
+    ary.AppendL( TUid::Uid(EMPXCollectionPluginMusic) );
+    TUid musicCollection = iCollectionUtility->CollectionIDL( ary.Array() );
+    CleanupStack::PopAndDestroy( &ary );
+
+    criteria->SetTObjectValueL<TUid>( KMPXMediaGeneralCollectionId, musicCollection );
+
+    iUserPlaylists = iCollectionUtility->Collection().FindAllL( *criteria, attrs.Array() );
+    CleanupStack::PopAndDestroy( criteria );
+    CleanupStack::PopAndDestroy( &attrs );
+
+    if ( iUserPlaylists ) {
+        const CMPXMediaArray* mediaArray =
+            iUserPlaylists->Value<CMPXMediaArray>( KMPXMediaArrayContents );
+        User::LeaveIfNull(const_cast<CMPXMediaArray*>(mediaArray));
+        TInt count = mediaArray->Count();
+        for ( TInt i = 0; i < count; i++ ) {
+            CMPXMedia* media( mediaArray->AtL(i) );
+            const TDesC& titleText = media->ValueText( KMPXMediaGeneralTitle );
+            if ( titleText.Compare( KNullDesC ) != 0 ) {
+            playlists += QString::fromUtf16( titleText.Ptr(), titleText.Length() );
+            }
+        }
+    }
+    TX_EXIT
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoCreatePlaylistL( QString playlistName, QList<int> selection )
+{
+    TX_ENTRY_ARGS("playlistName=" << playlistName);
+    CMPXMedia* tracks = CMPXMedia::NewL();
+    CleanupStack::PushL( tracks );
+
+    TPtrC ptr(reinterpret_cast<const TText*>(playlistName.constData()));
+    tracks->SetTextValueL( KMPXMediaGeneralTitle, ptr );
+    tracks->SetTextValueL( KMPXMediaGeneralUri, KPlaylistPath );
+    PreparePlaylistMediaL(*tracks, selection);
+
+    iCollectionUiHelper->IncAddL( *tracks, this, KMPXChunkSize );
+    CleanupStack::PopAndDestroy( tracks );
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoSaveToPlaylistL( int playlistIndex, QList<int> selection )
+{
+    TX_ENTRY_ARGS("playlistIndex=" << playlistIndex);
+    CMPXMedia* tracks = CMPXMedia::NewL();
+    CleanupStack::PushL( tracks );
+
+    const CMPXMediaArray* mediaArray =
+        iUserPlaylists->Value<CMPXMediaArray>( KMPXMediaArrayContents );
+    User::LeaveIfNull( const_cast<CMPXMediaArray*>( mediaArray ));
+    CMPXMedia* media( mediaArray->AtL(playlistIndex) );
+    TMPXItemId playlistId = media->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );
+
+    RArray<TUid> ary;
+    CleanupClosePushL( ary );
+    ary.AppendL( TUid::Uid(EMPXCollectionPluginMusic) );
+    TUid musicCollection = iCollectionUtility->CollectionIDL( ary.Array() );
+    CleanupStack::PopAndDestroy( &ary );
+
+    tracks->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId, playlistId );
+    tracks->SetTObjectValueL<TUid>( KMPXMediaGeneralCollectionId, musicCollection );
+    PreparePlaylistMediaL(*tracks, selection);
+
+    iCollectionUiHelper->IncAddL( *tracks, this, KMPXChunkSize );
+    CleanupStack::PopAndDestroy( tracks );
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoDeleteSongsL( QList<int> selection )
+{
+    int count = selection.count();
+    TX_ENTRY_ARGS("selection count=" << count);
+
+    CMPXCollectionPath* path( iCollectionUtility->Collection().PathL() );
+    CleanupStack::PushL( path );
+
+    for ( TInt i = 0; i < count; i++ ) {
+        path->SelectL( selection.at(i) );
+    }
+    iCollectionUiHelper->DeleteL( *path, this );
+    CleanupStack::PopAndDestroy( path );
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoRenamePlaylistL( QString newName, int index)
+{
+    CMPXMediaArray *mediaArray;  
+    const CMPXMedia& container = iCollectionData->containerMedia();
+    mediaArray = const_cast<CMPXMediaArray*>(container.Value<CMPXMediaArray>( KMPXMediaArrayContents ) );
+    CMPXMedia* currentPlaylistMedia( mediaArray->AtL( index ) );
+    TMPXItemId id( currentPlaylistMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );
+    DoRenamePlaylistL( id, newName );
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoRenamePlaylistL( QString newName )
+{
+    const CMPXMedia& container = iCollectionData->containerMedia();
+    TMPXItemId id( container.ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );
+    DoRenamePlaylistL( id, newName );
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoRenamePlaylistL( TMPXItemId id, QString newName )
+ {
+     CMPXMedia* media = CMPXMedia::NewL();
+     CleanupStack::PushL( media );
+     media->SetTObjectValueL<TMPXGeneralType>(
+     KMPXMediaGeneralType, EMPXItem );
+     media->SetTObjectValueL<TMPXGeneralCategory>(
+     KMPXMediaGeneralCategory, EMPXPlaylist );
+     media->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId, id );
+     TPtrC ptr(reinterpret_cast<const TText*>(newName.constData()));
+     media->SetTextValueL( KMPXMediaGeneralTitle, ptr );
+     iCollectionUiHelper->RenameL( *media, this );
+     CleanupStack::PopAndDestroy( media );
+ }     
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoSetShuffleL( bool active )
+{
+    TX_ENTRY
+
+    if ( iPlaybackUtility ) {
+        iPlaybackUtility->SetL( EPbPropertyRandomMode, active );
+    }
+    TX_EXIT
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoScanL()
+{
+    TX_ENTRY
+    iNumItemsAdded = 0;
+    iHarvesterUtility->ScanL();
+    TX_EXIT
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoCancelScanL()
+{
+    TX_ENTRY
+    // If harvester crashes, restart it.
+    TRAPD( err, iHarvesterUtility->CancelScanL() );
+    if ( err != KErrNone ) {
+        iHarvesterUtility->Close();
+        iHarvesterUtility = NULL;
+        iHarvesterUtility = CMPXHarvesterFactory::NewL();
+        iHarvesterUtility->CheckForSystemEventsL();
+    }
+    TX_EXIT
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoPreviewItemL( int index )
+{
+    TX_ENTRY
+    if ( !iPlaybackUtility ) {
+        iPlaybackUtility = MMPXPlaybackUtility::UtilityL( TUid::Uid(MpCommon::KMusicPlayerUid) );
+    }
+
+    // Get the current path
+    CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();
+    CleanupStack::PushL( cpath );
+    MPX_DEBUG_PATH(*cpath);
+    cpath->Back();
+
+    CMPXMediaArray *mediaArray;
+    const CMPXMedia& container = iCollectionData->containerMedia();
+    mediaArray = const_cast<CMPXMediaArray*>(container.Value<CMPXMediaArray>( KMPXMediaArrayContents ) );
+    CMPXMedia* currentMedia( mediaArray->AtL( index ) );
+    TMPXItemId id( currentMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );
+
+    cpath->AppendL(id); // Top level items of songs
+    cpath->Set(0); 		// Select 1st song
+
+    CMPXCollectionPlaylist* playList = CMPXCollectionPlaylist::NewL( *cpath );
+    CleanupStack::PushL( playList );
+    playList->SetToFirst();
+
+    iPlaybackUtility->InitL( *playList, ETrue );
+    emit q_ptr->collectionPlaylistOpened();
+
+    CleanupStack::PopAndDestroy( playList );
+    CleanupStack::PopAndDestroy( cpath );
+    TX_EXIT
+}
+
+/*!
+ \internal
+ */
+void MpMpxFrameworkWrapperPrivate::DoHandleCollectionMessageL(
+    const CMPXMessage& aMsg )
+{
+    TX_ENTRY
+    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 ) );
+        TX_LOG_ARGS("event=" << event << ", type=" << type << ", data=" << data);
+
+        if ( event == TMPXCollectionMessage::EPathChanged &&
+             type == EMcPathChangedByOpen &&
+             data == EMcContainerOpened ) {
+            // Incremental Open when browsing to the next level
+            DoIncrementalOpenL();
+        }
+        else if ( event == TMPXCollectionMessage::EPathChanged &&
+                  type == EMcPathChangedByOpen &&
+                  data == EMcItemOpened ) {
+            // Opened a song
+            // This will result in HandleOpenL with CMPXCollectionPlaylist
+            iCollectionUtility->Collection().OpenL();
+        }
+
+        if ( event == TMPXCollectionMessage::EBroadcastEvent ) {
+            switch (type) {
+                case EMcMsgRefreshStart:
+                    emit q_ptr->scanStarted();
+                    break;
+                case EMcMsgRefreshEnd:
+                case EMcMsgDiskInserted:
+                    emit q_ptr->scanEnded();
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    else if( KMPXMessageIdItemChanged == id ) {
+        if ( aMsg.IsSupported(KMPXMessageArrayContents) ) {
+            // Loop through messages for arrays
+            const CMPXMessageArray* messageArray =
+                        aMsg.Value<CMPXMessageArray>(KMPXMessageArrayContents);
+            User::LeaveIfNull(const_cast<CMPXMessageArray*>(messageArray));
+
+            for ( TInt i=0; i<messageArray->Count(); ++i ) {
+                  HandleCollectionMessage( messageArray->AtL( i ), KErrNone );
+            }
+            emit q_ptr->scanCountChanged(iNumItemsAdded);
+        }
+        else {
+            // Single item
+            TMPXChangeEventType changeType( aMsg.ValueTObjectL<TMPXChangeEventType>( KMPXMessageChangeEventType ) );
+            TMPXGeneralCategory cat(aMsg.ValueTObjectL<TMPXGeneralCategory>(KMPXMessageMediaGeneralCategory));
+            if( changeType == EMPXItemInserted &&
+                (cat == EMPXSong || cat == EMPXPlaylist || cat == EMPXPodcast) ) {
+                iNumItemsAdded++;
+            }
+        }
+    }
+    TX_EXIT
+}
+
+void MpMpxFrameworkWrapperPrivate::PreparePlaylistMediaL(
+    CMPXMedia& aMedia,
+    QList<int> selection )
+{
+    int count = selection.count();
+    TX_ENTRY_ARGS("selection count=" << count);
+
+    const CMPXMedia& container = iCollectionData->containerMedia();
+    const CMPXMediaArray* containerArray = container.Value<CMPXMediaArray>( KMPXMediaArrayContents );
+    User::LeaveIfNull( const_cast<CMPXMediaArray*>( containerArray ));
+    CMPXMediaArray* tracksArray( CMPXMediaArray::NewL() );
+    CleanupStack::PushL( tracksArray );
+
+    CMPXCollectionPath* path( iCollectionUtility->Collection().PathL() );
+    CleanupStack::PushL( path );
+    TMPXItemId collectionId( path->Id( 0 ) );
+    CleanupStack::PopAndDestroy( path );
+
+    if ( iCollectionData->context() == ECollectionContextArtistAlbums ) {
+        for ( TInt i = 0; i < count; i++ ) {
+            CMPXMedia* results;
+            CMPXMedia* album( containerArray->AtL( selection[i] ) );
+            // Fetch the songs for the selected album
+            TMPXItemId albumId = album->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
+            CMPXMedia* findCriteria = CMPXMedia::NewL();
+            CleanupStack::PushL( findCriteria );
+            findCriteria->SetTObjectValueL<TMPXGeneralType>( KMPXMediaGeneralType, EMPXGroup );
+            findCriteria->SetTObjectValueL<TMPXGeneralCategory>( KMPXMediaGeneralCategory, EMPXSong );
+            findCriteria->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId, albumId );
+            RArray<TMPXAttribute> attrs;
+            CleanupClosePushL( attrs );
+            attrs.Append( TMPXAttribute( KMPXMediaIdGeneral,
+                                         EMPXMediaGeneralTitle |
+                                         EMPXMediaGeneralId ) );
+            attrs.Append( KMPXMediaMusicAlbumTrack );
+            results = iCollectionUtility->Collection().FindAllL( *findCriteria, attrs.Array());
+            CleanupStack::PopAndDestroy( &attrs );
+            CleanupStack::PopAndDestroy( findCriteria );
+            CleanupStack::PushL( results );
+            
+            const CMPXMediaArray* resultsArray = results->Value<CMPXMediaArray>( KMPXMediaArrayContents );
+            User::LeaveIfNull( resultsArray );
+            for (int j = 0 ; j < resultsArray->Count();j++) {
+                CMPXMedia* media( resultsArray->AtL(j) );
+                CMPXMedia* entry = CMPXMedia::NewL();
+                CleanupStack::PushL( entry );
+                entry->SetTextValueL( KMPXMediaGeneralTitle,
+                    media->ValueText( KMPXMediaGeneralTitle ) );
+                entry->SetTObjectValueL( KMPXMediaGeneralType, EMPXItem);
+                entry->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXSong );
+                entry->SetTObjectValueL( KMPXMediaGeneralId,
+                    media->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );
+                entry->SetTObjectValueL( KMPXMediaGeneralCollectionId, collectionId );
+                tracksArray->AppendL( entry );
+                CleanupStack::Pop( entry );
+            }
+            CleanupStack::PopAndDestroy( results );
+        }
+        
+    }
+    else {   
+        for ( TInt i = 0; i < count; i++ ) {
+            CMPXMedia* media( containerArray->AtL(selection.at(i)) );
+            CMPXMedia* entry = CMPXMedia::NewL();
+            CleanupStack::PushL( entry );
+            entry->SetTextValueL( KMPXMediaGeneralTitle,
+                media->ValueText( KMPXMediaGeneralTitle ) );
+            entry->SetTObjectValueL( KMPXMediaGeneralType, EMPXItem);
+            entry->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXSong );
+            entry->SetTObjectValueL( KMPXMediaGeneralId,
+                media->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );
+            entry->SetTObjectValueL( KMPXMediaGeneralCollectionId, collectionId );
+            tracksArray->AppendL( entry );
+            CleanupStack::Pop( entry );
+        }
+    }
+    aMedia.SetTObjectValueL<TMPXGeneralType>( KMPXMediaGeneralType, EMPXItem );
+    aMedia.SetTObjectValueL<TMPXGeneralCategory>( KMPXMediaGeneralCategory, EMPXPlaylist );
+    aMedia.SetCObjectValueL( KMPXMediaArrayContents, tracksArray );
+    aMedia.SetTObjectValueL( KMPXMediaArrayCount, tracksArray->Count() );
+
+    CleanupStack::PopAndDestroy( tracksArray );
+    TX_EXIT
+}