mpxplugins/viewplugins/views/podcastview/src/mpxpodcastcollectionviewimp.cpp
changeset 0 ff3acec5bc43
child 1 8118492f1bdf
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mpxplugins/viewplugins/views/podcastview/src/mpxpodcastcollectionviewimp.cpp	Thu Dec 17 08:45:05 2009 +0200
@@ -0,0 +1,4501 @@
+/*
+* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:  Implementation of Podcast Collection view
+*
+*/
+
+
+// INCLUDE FILES
+#include <aknlists.h>
+#include <aknViewAppUi.h>
+#include <eikmenub.h>
+#include <StringLoader.h>
+#include <aknnavilabel.h>
+#include <aknnavide.h>
+#include <eikapp.h>
+#include <AknUtils.h>
+#include <AknsUtils.h>
+#include <AknIconUtils.h>   // Icon no skin
+#include <akntitle.h>
+#include <aknconsts.h>
+#include <avkon.mbg>
+#include <textresolver.h>
+#include <aknnotewrappers.h>
+#include <aknnavi.h>
+#include <hlplch.h>
+#include <bautils.h>
+#include <eikspmod.h>
+#include <eikclb.h>
+#include <avkon.hrh>
+#include <avkon.rsg>
+#include <sendui.h>
+#include <CMessageData.h>
+#include <centralrepository.h>
+#include <avkon.rsg>
+#include <eikbtgpc.h>
+#include <AknWaitDialog.h>
+#include <apgcli.h>     // RApaLsSession
+#include <akncontext.h> // Context Pane
+#include <fbs.h>        // CFbsBitmap
+#include <bldvariant.hrh>
+#include <coeutils.h>
+#include <AknDlgShut.h>
+#ifdef RD_MULTIPLE_DRIVE
+#include <driveinfo.h>
+#endif //RD_MULTIPLE_DRIVE
+#include <mpxuser.h>
+
+#ifdef UPNP_INCLUDED
+#include <upnpcopycommand.h>
+#endif
+#include <e32const.h>
+#include <AiwServiceHandler.h>  //Copy to remote feature
+
+//#ifdef __COVER_DISPLAY
+#include <aknSDData.h>
+#include <AknMediatorFacade.h>
+#include "mplayersecondarydisplayapi.h"
+//#endif
+
+#include <mpxappui.hrh>
+#include <data_caging_path_literals.hrh>
+#include <layoutmetadata.cdl.h>
+#include <mpxplaybackframeworkdefs.h>
+#include <mpxcollectionmessage.h>
+#include <mpxviewutility.h>
+#include <mpxmusicplayerviewplugin.hrh>
+#include <mpxpodcastcollectionview.rsg>
+#include <mpxcollectionview.mbg>
+#include <mpxcollectionutility.h>
+#include <mpxplaybackutility.h>
+#include <mpxplaybackmessage.h>
+#include <mpxmedia.h>
+#include <mpxcollectionhelperfactory.h>
+#include <mpxcollectionplaylist.h>
+#include <mpxmediacontainerdefs.h>
+#include <mpxmediacollectiondetaildefs.h>
+#include <mpxmediadrmdefs.h>
+#include <mpxmediaarray.h>
+#include <mpxpodcastdefs.h> // Podcast specific
+#include <mpxmessagegeneraldefs.h>
+#include <mpxcommandgeneraldefs.h>
+#include <mpxcollectioncommanddefs.h>
+#include <mpxconstants.h>
+#include "mpxwaitnotedefs.h"
+
+#include <mpxinternalcrkeys.h>
+#include "mpxpodcastcollectionviewlistboxarray.h"
+#include "mpxcommoncontainer.hrh"
+#include "mpxcommoncontainer.h"
+#include "mpxcommonuihelper.h"
+#include "mpxpodcastcollectionviewcontainer.h"
+#include "mpxpodcastcollectionview.hrh"
+#include "mpxpodcastcollectionview.hlp.hrh"
+#include "mpxpodcastcollectionviewimp.h"
+#include "mpxlog.h"
+#include "mpxviewprivatepskeys.h"
+
+
+// CONSTANTS
+_LIT(KMPXPodcastCollectionRscPath, "mpxpodcastcollectionview.rsc");
+
+// Nokia Podcasting Application Uid
+const TUid KNPodAppUid = { 0x1028190B };
+
+const TInt KMilliSecondsToSeconds(1000);
+const TInt KMPXMaxBufferLength(160);
+const TInt KMPXMaxTimeLength(36);
+const TInt KMPXDurationDisplayResvLen(10);
+const TInt KPodcastCollectionMenuLevel( 2 );
+
+//#ifdef __UPNP_FRAMEWORK_2_0_
+const TInt KMPXLastDirectoryLevel( 2 );
+//#endif //__UPNP_FRAMEWORK_2_0_
+// MACROS
+_LIT(KMPXCollDetailsItemsFormat, "%S\t%S");
+
+const TInt KProgressBarMaxValue = 100; // Max Value for the Progress Info bar
+#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
+#define KMusicCollectionUid 0x101FFC3A
+#endif
+
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+// Two-phased constructor.
+// ---------------------------------------------------------------------------
+//
+CMPXPodcastCollectionViewImp* CMPXPodcastCollectionViewImp::NewL()
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::NewL");
+    CMPXPodcastCollectionViewImp* self = CMPXPodcastCollectionViewImp::NewLC();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+// ---------------------------------------------------------------------------
+// Two-phased constructor.
+// ---------------------------------------------------------------------------
+//
+CMPXPodcastCollectionViewImp* CMPXPodcastCollectionViewImp::NewLC()
+    {
+    CMPXPodcastCollectionViewImp* self = new (ELeave) CMPXPodcastCollectionViewImp();
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    return self;
+    }
+
+// ---------------------------------------------------------------------------
+// Destructor
+// ---------------------------------------------------------------------------
+//
+CMPXPodcastCollectionViewImp::~CMPXPodcastCollectionViewImp()
+    {
+    MPX_DEBUG1("CMPXPodcastCollectionViewImp::~CMPXPodcastCollectionViewImp entering");
+
+    if (iCollectionUtility)
+        {
+        iCollectionUtility->Close();
+        }
+
+    if (iPlaybackUtility)
+        {
+        TRAP_IGNORE( iPlaybackUtility->RemoveObserverL( *this ) );
+        iPlaybackUtility->Close();
+        }
+
+    if (iViewUtility)
+        {
+        iViewUtility->Close();
+        }
+
+    if (iCollectionUiHelper)
+        {
+        iCollectionUiHelper->Close();
+        }
+
+    if ( iUpnpFrameworkSupport )
+        {
+        MPX_DEBUG1(_L("CMPXCollectionViewImp::~CMPXCollectionViewImp Detaching 'Copy to external' menu service..."));
+        if ((iServiceHandler) &&
+             (iCurrentlyAttachedCopyToMenuPane != KErrNotFound))
+            {
+            iServiceHandler->DetachMenu(iCurrentlyAttachedCopyToMenuPane,
+                                 R_MPX_UPNP_COPY_TO_EXTERNAL_MENU_INTEREST);
+            }
+        delete iServiceHandler;
+        iPlayersList.Close();
+        delete iSubPlayerName;
+        }
+#ifdef UPNP_INCLUDED
+    if (iUpnpCopyCommand)
+        {
+        delete iUpnpCopyCommand;
+        }
+#endif
+    if (iResourceOffset)
+        {
+        iEikonEnv->DeleteResourceFile(iResourceOffset);
+        }
+
+    if (iContainer)
+        {
+        AppUi()->RemoveFromStack( iContainer->Common()->CoeControl() );
+        delete iContainer;
+        }
+
+    if (iNaviDecorator)
+        {
+        delete iNaviDecorator;
+        }
+
+    if (iMediaToSet)
+        {
+        delete iMediaToSet;
+        }
+
+    delete iCommonUiHelper;
+    delete iSendUi;
+    delete iTitle;
+    delete iNumEpisode;
+    delete iDuration;
+    delete iOriginalTitle;
+    delete iOriginalDuration;
+    delete iBottomIndex;
+    delete iCba;
+
+
+    MPX_DEBUG1("CMPXPodcastCollectionViewImp::~CMPXPodcastCollectionViewImp exiting");
+    }
+
+// ---------------------------------------------------------------------------
+// Delete the selected items
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::DeleteSelectedItemsL()
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::DeleteSelectedItemsL");
+
+    TBool isIgnore(EFalse);
+    if (iContainer->Common()->CurrentListItemCount() == 0)
+        {
+        // list is empty
+        isIgnore = ETrue;
+        }
+
+    if (!isIgnore)
+        {
+        CMPXCommonListBoxArrayBase* listboxArray =
+            iContainer->Common()->ListBoxArray();
+        TInt currentIndex = iContainer->Common()->CurrentLbxItemIndex();
+        // Create a copy of collection path
+        CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();
+        CleanupStack::PushL(path);
+        CAknQueryDialog* confirmationDlg = NULL;
+        HBufC* promptTxt = NULL;
+        HBufC* waitNoteText = NULL;
+//        TInt waitNoteCBA = R_AVKON_SOFTKEYS_EMPTY;
+
+        // Marked indicies
+        const CArrayFix<TInt>* array =
+            iContainer->Common()->CurrentSelectionIndicesL();
+        TInt arrayCount = array->Count();
+        MPX_DEBUG2("CMPXPodcastCollectionViewImp::DeleteSelectedItemsL delete array count = %d", arrayCount);
+
+        if ( arrayCount > 1 )
+            {
+            waitNoteText = StringLoader::LoadLC(
+                R_MPX_QTN_NMP_DEL_SONGS_WAIT_NOTE);
+            promptTxt = StringLoader::LoadLC(
+                R_MPX_QTN_NMP_DEL_SONGS_QUERY,
+                    arrayCount);
+//            waitNoteCBA = R_MPX_COLLECTION_WAITNOTE_SOFTKEYS_EMPTY_STOP;
+            confirmationDlg = CAknQueryDialog::NewL(
+                CAknQueryDialog::EConfirmationTone);
+            CleanupStack::PushL(confirmationDlg);
+
+//#ifdef __COVER_DISPLAY
+            confirmationDlg->PublishDialogL(
+                EMPlayerQueryDeleteTracks,
+                KMPlayerNoteCategory);
+            CAknMediatorFacade* covercl =
+                AknMediatorFacade(confirmationDlg);
+            if (covercl)
+                {
+                covercl->BufStream().WriteInt32L(arrayCount);
+                }
+//#endif //__COVER_DISPLAY
+
+            for (TInt i = 0; i < arrayCount; i++)
+                {
+                MPX_DEBUG2("CMPXPodcastCollectionViewImp::DeleteSelectedItemsL delete array index = %d", array->At(i));
+                path->SelectL(array->At(i));
+                }
+            }
+        else
+            {
+            const CMPXMedia& media( listboxArray->MediaL(
+                ( arrayCount > 0 ) ? array->At( 0 ) : currentIndex ) );
+            const TDesC& title = media.ValueText(KMPXMediaGeneralTitle);
+
+            TMPXGeneralType type = EMPXNoType;
+            TMPXGeneralCategory category = EMPXNoCategory;
+
+            if (media.IsSupported(KMPXMediaGeneralType))
+                {
+                type =
+                    media.ValueTObjectL<TMPXGeneralType>(KMPXMediaGeneralType);
+                }
+            if (media.IsSupported(KMPXMediaGeneralCategory))
+                {
+                category =
+                    media.ValueTObjectL<TMPXGeneralCategory>(KMPXMediaGeneralCategory);
+                }
+
+            if (type == EMPXItem && category == EMPXPodcast)
+                {
+                // tracks level
+                waitNoteText = StringLoader::LoadLC(
+                        R_MPX_QTN_ALBUM_WAITING_DELETING, title);
+                promptTxt = StringLoader::LoadLC(
+                    R_MPX_QTN_QUERY_COMMON_CONF_DELETE,
+                    title);
+                }
+            else
+                {
+                waitNoteText = StringLoader::LoadLC(
+                        R_MPX_QTN_MUS_QUERY_CONF_DELETE_ALL, title);
+//                waitNoteCBA = R_MPX_COLLECTION_WAITNOTE_SOFTKEYS_EMPTY_STOP;
+                promptTxt = StringLoader::LoadLC(
+                    R_MPX_QTN_NMP_QUERY_CONF_DELETE_GROUP,
+                    title);
+                }
+            confirmationDlg = CAknQueryDialog::NewL(
+                CAknQueryDialog::EConfirmationTone);
+            CleanupStack::PushL(confirmationDlg);
+//#ifdef __COVER_DISPLAY
+            if (type == EMPXItem && category == EMPXPodcast)
+                {
+                // tracks level
+                confirmationDlg->PublishDialogL(
+                    EMPlayerQueryDeleteCategory,
+                    KMPlayerNoteCategory);
+                }
+            else
+                {
+                confirmationDlg->PublishDialogL(
+                    EMPlayerQueryDeleteTrack,
+                    KMPlayerNoteCategory);
+                }
+            CAknMediatorFacade* covercl =
+                AknMediatorFacade(confirmationDlg);
+            if (covercl)
+                {
+                covercl->BufStream() << title;
+                }
+//#endif //__COVER_DISPLAY
+            path->Set( arrayCount > 0 ? array->At( 0 ) : currentIndex );
+            }
+        confirmationDlg->SetPromptL(*promptTxt);
+        CleanupStack::Pop(confirmationDlg);
+        CleanupStack::PopAndDestroy(promptTxt);
+        if (confirmationDlg->ExecuteLD(R_MPX_CUI_DELETE_CONFIRMATION_QUERY))
+            {
+            HandleCommandL( EMPXCmdIgnoreExternalCommand );
+            StartProgressNoteL();
+            TPtr buf = waitNoteText->Des();
+			UpdateProcessL(0, buf);
+            iCollectionUiHelper->DeleteL(*path, this);
+            iIsDeleting = ETrue;
+
+          }
+        CleanupStack::PopAndDestroy(waitNoteText);
+        CleanupStack::PopAndDestroy(path);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// ---------------------------------------------------------------------------
+//
+CMPXPodcastCollectionViewImp::CMPXPodcastCollectionViewImp()
+    : iMediaToSet(NULL)
+    , iCurrNotYetPlayedListIndex(-1)
+#ifdef __ENABLE_MSK
+    , iCurrentMskId(KErrNotFound)
+    , iShowContextMenu(EFalse)
+#endif // __ENABLE_MSK
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::CMPXPodcastCollectionViewImp");
+    }
+
+// ---------------------------------------------------------------------------
+// Symbian 2nd phase constructor can leave.
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::ConstructL()
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::ConstructL");
+
+    CCoeEnv* coeEnv( iEikonEnv );
+    TParse parse;
+    parse.Set(KMPXPodcastCollectionRscPath, &KDC_APP_RESOURCE_DIR, NULL);
+    TFileName resourceFile(parse.FullName());
+    User::LeaveIfError(MPXUser::CompleteWithDllPath(resourceFile));
+    BaflUtils::NearestLanguageFile(coeEnv->FsSession(), resourceFile);
+    iResourceOffset = coeEnv->AddResourceFileL(resourceFile);
+
+    BaseConstructL(R_MPX_PODCAST_COLLECTION_VIEW);
+
+    // Get the collection utility instance from engine.
+    iCollectionUtility = MMPXCollectionUtility::NewL(this, KMcModeDefault);
+    iBackOneLevel = EFalse;
+    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( KPbModeDefault );
+    iPlaybackUtility->AddObserverL( *this );
+    iViewUtility = MMPXViewUtility::UtilityL();
+    iViewUtility->AddObserverL(this);
+    iBottomIndex = new (ELeave) CArrayFixFlat<TInt>(1);
+
+    iCommonUiHelper = CMPXCommonUiHelper::NewL(iCollectionUtility);
+    iCollectionUiHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL();
+
+    // Monitor for view activation
+    AppUi()->AddViewActivationObserverL( this );
+#ifdef UPNP_INCLUDED
+  	if(!iUpnpCopyCommand)
+  	    {
+  	    MPX_TRAPD ( error, iUpnpCopyCommand = CUpnpCopyCommand::NewL() );   
+		    if ( error == KErrNone )
+            {
+            iUpnpFrameworkSupport = ETrue;
+            iServiceHandler = CAiwServiceHandler::NewL();
+            MPX_DEBUG1("CMPXPodcastCollectionViewImp::ConstructL() Attaching 'Copy to external' menu service...");
+            MPX_TRAP(iErrorAttachCopyMenu, iServiceHandler->AttachMenuL(R_MPX_PODCAST_COLLECTION_VIEW_MENU_1,
+                                                   R_MPX_UPNP_COPY_TO_EXTERNAL_MENU_INTEREST));
+            if ( iErrorAttachCopyMenu == KErrNotSupported )
+                {
+                // when CCoeEnv is not available
+                User::Leave( iErrorAttachCopyMenu );
+                }
+            MPX_DEBUG2("CMPXPodcastCollectionViewImp::ConstructL(): attach Copy menu error: %d", iErrorAttachCopyMenu);
+            }
+        else
+            {
+            iUpnpFrameworkSupport = EFalse;
+			iUpnpCopyCommand = NULL;
+            }
+        }
+#endif
+
+    TUid naviPaneUid;
+    naviPaneUid.iUid = EEikStatusPaneUidNavi;
+    iNaviPane =
+        static_cast<CAknNavigationControlContainer*>
+        (iAvkonViewAppUi->StatusPane()->ControlL(naviPaneUid));
+    iNaviDecorator = iNaviPane->CreateNavigationLabelL(KNullDesC);
+    //Create label to change text in Navi pane
+    iNaviLabel = static_cast<CAknNaviLabel*>
+            (iNaviDecorator->DecoratedControl());
+
+    TInt flags(0);
+    CRepository* repository = CRepository::NewL(KCRUidMPXMPFeatures);
+    repository->Get(KMPXMPLocalVariation, flags);
+    delete repository;
+    iChangeRTForAllProfiles =
+        static_cast<TBool>(flags & KMPXChangeRTForAll);
+
+    iLastDepth = 1;
+    MPX_DEBUG2("CMPXPodcastCollectionViewImp::ConstructL iLastDepth = %d", iLastDepth);
+    iBottomIndex->AppendL(0);
+
+#ifdef _DEBUG
+    iExitOptionHidden = EFalse;
+#else // _DEBUG
+    iExitOptionHidden = iCommonUiHelper->ExitOptionHiddenL();
+#endif // _DEBUG
+
+    // used to know if HandleOpen was called -> we cannot update the playback
+    // status of listbox items before the list box is updated in HandleOpen
+    iHandleOpenProcessed = EFalse;
+    iSelectedItem = KMPXInvalidItemId;
+    }
+
+// ---------------------------------------------------------------------------
+// Updates list box
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::UpdateListBoxL(
+    CMPXMedia& aEntries,
+    TInt aIndex)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::UpdateListBox");
+    MPX_DEBUG2("CMPXPodcastCollectionViewImp::UpdateListBox aIndex = %d", aIndex);
+    if (iContainer)
+        {
+        CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();
+        CleanupStack::PushL(cpath);
+
+        CMPXCommonListBoxArrayBase* array =
+            iContainer->Common()->ListBoxArray();
+        array->ResetMediaArrayL();
+        iContainer->Common()->HandleLbxItemRemovalL();
+
+
+        array->AppendMediaL(aEntries);
+        // this needs to be before HandleLbxItemAdditionL so that the items
+        // are redrawn properly after playback status has been updated.
+        UpdatePlaybackStatusL(EFalse);
+
+        iContainer->Common()->HandleLbxItemAdditionL();
+        MPX_DEBUG2("CMPXPodcastCollectionViewImp::UpdateListBox List box contains %d items", iContainer->Common()->TotalListItemCount());
+
+        // Display empty List Box string if list box is empty
+        // Display different empty string if Podcast App does not exist
+        HBufC* emptyText = NULL;
+        if (CheckPodcastAppL() == KErrNone)
+            {
+            emptyText = StringLoader::LoadLC(
+                R_MPX_QTN_NMP_NO_EPISODES_GO_TO_APP);
+            }
+        else
+            {
+            emptyText = StringLoader::LoadLC(
+                R_MPX_QTN_NMP_NO_EPISODES);
+            }
+        iContainer->Common()->SetLbxEmptyTextL(*emptyText);
+        CleanupStack::PopAndDestroy(emptyText);
+
+        if (iBackOneLevel || iPossibleJump)
+            {
+            if (cpath->Levels() == (iLastDepth))
+                {
+                iLastDepth--;
+                TInt topIndex = iContainer->Common()->CalculateTopIndex(
+                    iBottomIndex->At(iLastDepth));
+                iContainer->Common()->SetLbxTopItemIndex(topIndex);
+                iContainer->Common()->SetLbxCurrentItemIndexAndDraw(aIndex);
+                iBottomIndex->Delete(iLastDepth);
+                }
+            else
+                {
+                MPX_DEBUG1("CMPXPodcastCollectionViewImp::UpdateListBox Invalid history, rebuilding");
+                // invalid path, rebuild with all 0. possibily caused by a jump in views
+                iBottomIndex->Reset();
+                iLastDepth = cpath->Levels();
+                for (TInt i = 0; i < iLastDepth; i++)
+                    {
+                    iBottomIndex->AppendL(0);
+                    }
+                iContainer->Common()->SetLbxCurrentItemIndexAndDraw(aIndex);
+                }
+            iPossibleJump = EFalse;
+            iBackOneLevel = EFalse;
+            }
+        else
+            {
+            if ((aIndex > 0) &&
+                (aIndex < iContainer->Common()->CurrentListItemCount()))
+                {
+                iContainer->Common()->SetLbxCurrentItemIndexAndDraw(aIndex);
+                }
+            else if(aIndex == 0 &&
+                    iCurrNotYetPlayedListIndex > 0 &&
+                    iCurrNotYetPlayedListIndex < iContainer->Common()->CurrentListItemCount())
+                {
+                iContainer->Common()->SetLbxCurrentItemIndexAndDraw(iCurrNotYetPlayedListIndex);
+                }
+            else
+                {
+                if ( iSelectedItem != KMPXInvalidItemId )
+                    {
+                    iContainer->Common()->SetLbxCurrentItemIndexAndDraw(cpath->IndexOfId(iSelectedItem));
+                    }
+                else
+                    {
+                    iContainer->Common()->SetLbxCurrentItemIndexAndDraw(0);
+                    }
+                }
+            iCurrNotYetPlayedListIndex = -1;
+            }
+        CleanupStack::PopAndDestroy(cpath);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Displays error notes.
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandleErrorL(TInt aError)
+    {
+    MPX_DEBUG2( "CMPXPodcastCollectionViewImp::HandleError(%d)", aError );
+    ASSERT( aError );
+
+    // only display error message if postcastcollection view is in the foreground
+    if ( iContainer )
+        {
+        TRAP_IGNORE( iCommonUiHelper->HandleErrorL( aError ) );
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Updates the navi pane
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::UpdateNaviPaneL()
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::UpdateNaviPaneL");
+    TUid activeView = iViewUtility->ActiveViewType();
+    if (activeView == TUid::Uid(KMPXPluginTypeCollectionUid) ||
+        activeView == TUid::Uid(KMPXPluginTypeWaitNoteDialogUid)) // the harvester
+                                                           // might have a
+                                                           // scanning note
+                                                           // displayed
+        {
+        MPX_DEBUG2("CMPXPodcastCollectionViewImp::UpdateNaviPaneL updating %d", iNumEpisode);
+        if (iNumEpisode)
+            {
+            iNaviLabel->SetTextL(*iNumEpisode);
+            iNaviPane->PushL(*iNaviDecorator);
+            }
+        else
+            {
+            iNaviPane->Pop(iNaviDecorator);
+            }
+        iNaviPane->DrawNow();
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Updates the title pane
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::UpdateTitlePaneL()
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::UpdateTitlePaneL");
+    // Set title
+    TUid activeView = iViewUtility->ActiveViewType();
+    if (activeView == TUid::Uid(KMPXPluginTypeCollectionUid))
+        {
+        CAknTitlePane* title(NULL);
+
+        TRAP_IGNORE(
+            {
+            title = static_cast<CAknTitlePane*>
+                (StatusPane()->ControlL(TUid::Uid(EEikStatusPaneUidTitle)));
+            });
+
+        if (title)
+            {
+            if (iTitle)
+                {
+                MPX_DEBUG2("CMPXPodcastCollectionViewImp::UpdateTitlePaneL Title is %S", iTitle);
+                if (iTitle->Length() == 0)
+                    {
+                    HBufC* titleText = StringLoader::LoadLC(R_MPX_QTN_NMP_UNKNOWN_TITLE);
+                    title->SetTextL(*titleText);
+                    CleanupStack::PopAndDestroy(titleText);
+                    }
+                else
+                    {
+                    title->SetTextL(*iTitle);
+                    }
+                }
+            else
+                {
+                CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();
+                CleanupStack::PushL(cpath);
+                TInt currentDepth = cpath->Levels();
+                if(currentDepth == 2)
+                    {
+                    // use default title if no metadata is available
+                    HBufC* titleText = StringLoader::LoadLC(
+                        R_MPX_PODCAST_COLLECTION_VIEW_TITLE);
+                    title->SetTextL(*titleText);
+                    CleanupStack::PopAndDestroy(titleText);
+                    }
+                CleanupStack::PopAndDestroy(cpath);
+                } // if (iTitle)
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Updates the option menu
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::UpdateOptionMenuL()
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::UpdateOptionMenuL");
+    if(iContainer)
+        {
+        // Check collection path level and change title resource id
+        CEikMenuBar* menubar = MenuBar();
+        TInt attachCopyToMenu = KErrNotFound;
+
+        if ( menubar )
+            {
+            CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();
+            CleanupStack::PushL(cpath);
+            MPX_DEBUG_PATH(*cpath);
+            TInt depth = cpath->Levels();
+            MPX_DEBUG2("CMPXPodcastCollectionViewImp::UpdateOptionMenuL cpath depth = %d", depth);
+            // root
+            if ( depth == 2 )
+                {
+                iContainer->Common()->EnableMarking( EFalse );
+                iContainer->SetCurrentView(EMPXTitlesView);
+                menubar->SetMenuTitleResourceId(R_MPX_PODCAST_COLLECTION_TITLES_VIEW_MENUBAR);
+                if ( iUpnpFrameworkSupport )
+                    {
+                    attachCopyToMenu = R_MPX_PODCAST_COLLECTION_VIEW_MENU_1;
+                    }
+                }
+            else if ( depth == 3 )
+                {
+#ifdef SINGLE_CLICK_INCLUDED
+                iContainer->Common()->EnableMarking( EFalse );
+#else
+                iContainer->Common()->EnableMarking( ETrue );
+#endif
+                iContainer->SetCurrentView(EMPXEpisodesView);
+#ifdef SINGLE_CLICK_INCLUDED
+                menubar->SetMenuTitleResourceId(R_MPX_PODCAST_COLLECTION_EPISODES_VIEW_NO_MARKING);
+#else
+                menubar->SetMenuTitleResourceId(R_MPX_PODCAST_COLLECTION_EPISODES_VIEW_MENUBAR);
+#endif
+                if ( iUpnpFrameworkSupport )
+                    {
+                    attachCopyToMenu = R_MPX_PODCAST_COLLECTION_VIEW_MENU_2;
+                    }
+                }
+            else // (depth > 3)
+                {
+                MPX_DEBUG1("CMPXPodcastCollectionViewImp::UpdateOptionMenuL ERROR cpath depth > 3");
+                ASSERT(0);
+                }
+            CleanupStack::PopAndDestroy(cpath);
+            }
+
+        if ( iUpnpFrameworkSupport )
+            {
+            UpdateCopyToRemoteMenu(attachCopyToMenu);
+            }
+        }
+    else
+        {
+        MPX_DEBUG1("CMPXPodcastCollectionViewImp::UpdateOptionMenuL NULL iContainer");
+        }
+    }
+
+//#ifdef __UPNP_FRAMEWORK_2_0_
+// ---------------------------------------------------------------------------
+// Updates the copy to remote menu attachment
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::UpdateCopyToRemoteMenu(TInt aMenuPane)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::UpdateCopyToRemoteMenu");
+    MPX_DEBUG3("CMPXPodcastCollectionViewImp::UpdateCopyToRemoteMenu(): aMenuPane %d, iCurrentlyAttachedCopyToMenuPane %d", aMenuPane, iCurrentlyAttachedCopyToMenuPane);
+
+    if (iServiceHandler &&
+         (iCurrentlyAttachedCopyToMenuPane != aMenuPane))
+        {
+        if (iCurrentlyAttachedCopyToMenuPane != KErrNotFound)
+            {
+            MPX_DEBUG1(_L("CMPXCollectionViewImp::UpdateCopyToRemoteMenu() Detaching 'Copy to external' menu service..."));
+            iServiceHandler->DetachMenu(iCurrentlyAttachedCopyToMenuPane,
+                                 R_MPX_UPNP_COPY_TO_EXTERNAL_MENU_INTEREST);
+            }
+
+        if (aMenuPane != KErrNotFound)
+            {
+            MPX_DEBUG1("CMPXPodcastCollectionViewImp::UpdateCopyToRemoteMenu() Attaching 'Copy to external' menu service...");
+            MPX_TRAP(iErrorAttachCopyMenu, iServiceHandler->AttachMenuL(aMenuPane,
+                                                       R_MPX_UPNP_COPY_TO_EXTERNAL_MENU_INTEREST));
+            if (iErrorAttachCopyMenu == KErrNone)
+                {
+                iCurrentlyAttachedCopyToMenuPane = aMenuPane;
+                }
+            else
+                {
+                iCurrentlyAttachedCopyToMenuPane = KErrNotFound;
+                }
+            MPX_DEBUG2("CMPXPodcastCollectionViewImp::UpdateCopyToRemoteMenu(): iErrorAttachCopyMenu: %d", iErrorAttachCopyMenu);
+            }
+        else
+            {
+            iCurrentlyAttachedCopyToMenuPane = aMenuPane;
+            }
+        }
+    }
+//#endif //__UPNP_FRAMEWORK_2_0_
+
+// ---------------------------------------------------------------------------
+// Updates playback status indicatior
+// ---------------------------------------------------------------------------
+//
+TInt CMPXPodcastCollectionViewImp::UpdatePlaybackStatusL(TBool aStatusChangeFlag)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::UpdatePlaybackStatusL");
+    TInt ret( KErrNotFound );  // default selection
+    if ( iContainer )
+        {
+        TMPXPlaybackState pbState( EPbStateNotInitialised );
+        TInt selectedIndex( KErrNotFound );
+        TMPXItemId selectedItemId( KMPXInvalidItemId );
+        CMPXCollectionPath* cpath( iCollectionUtility->Collection().PathL() );
+        CleanupStack::PushL( cpath );
+
+        MMPXSource* source( iPlaybackUtility->Source() );
+        if ( source )
+            {
+            CMPXCollectionPlaylist* playlist( source->PlaylistL() );
+            if ( playlist )
+                {
+                CleanupStack::PushL( playlist );
+                CMPXCollectionPath* pbPath(
+                    CMPXCollectionPath::NewL( playlist->Path() ) );
+                CleanupStack::PushL( pbPath );
+                TInt playbackPathCount( pbPath->Levels() );
+                if ( cpath->Levels() == playbackPathCount )
+                    {
+                    // not comparing the index
+                    TBool isEqual( ETrue );
+                    for ( TInt i = 0; i < playbackPathCount - 1; i++ )
+                        {
+                        if ( cpath->Id( i ) != pbPath->Id( i ) )
+                            {
+                            isEqual = EFalse;
+                            break;
+                            }
+                        }
+                    if ( isEqual )
+                        {
+                        selectedIndex = pbPath->Index();
+                        selectedItemId = pbPath->Id();
+                        ret = selectedIndex;
+                        pbState = iPlaybackUtility->StateL();
+                        }
+                    }
+                CleanupStack::PopAndDestroy( pbPath );
+                CleanupStack::PopAndDestroy( playlist );
+                }
+            }
+        CleanupStack::PopAndDestroy( cpath );
+
+        CMPXCommonListBoxArrayBase* listboxArray =
+            iContainer->Common()->ListBoxArray();
+        const CMPXMedia* containerMedia = &listboxArray->ContainerMedia();
+
+        if (!containerMedia ||
+            !containerMedia->IsSupported(KMPXMediaPodcastCategoryGroup) ||
+            EMPXNotYetPlayed != containerMedia->ValueTObjectL<TMPXPodcastCategory>(KMPXMediaPodcastCategoryGroup))
+            {
+            if ( iHandleOpenProcessed )
+                {
+                // Might make performance worse if there are lots of episodes
+                iContainer->SetPlaybackStatusByIdL( selectedItemId, pbState );
+                }
+            }
+
+        if (iMediaToSet &&
+            aStatusChangeFlag &&
+            (pbState == EPbStateStopped ||
+             pbState == EPbStateNotInitialised))
+            {
+            DoSetCollectionL(iMediaToSet, EFalse );
+            delete iMediaToSet;
+            iMediaToSet = NULL;
+            }
+        }
+    return ret;
+    }
+
+// ---------------------------------------------------------------------------
+// Start a Progress note
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::StartProgressNoteL()	
+	{
+	iProgressDialog = new (ELeave) CAknProgressDialog(
+		(REINTERPRET_CAST(CEikDialog**, &iProgressDialog)),
+		ETrue);
+	iProgressDialog->PrepareLC(R_MPX_PROGRESS_NOTE);
+	iProgressInfo = iProgressDialog->GetProgressInfoL();
+    iProgressDialog->SetCallback(this);
+    iProgressDialog->RunLD();
+	iProgressInfo->SetFinalValue(KProgressBarMaxValue);	
+	}
+ 
+// ---------------------------------------------------------------------------
+// Update the Progress note
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::UpdateProcessL(TInt aProgress,const TDesC& aProgressText)
+	{
+	if(iProgressDialog)
+		{
+		iProgressDialog->SetTextL(aProgressText);
+		iProgressInfo->SetAndDraw(aProgress);	
+    	}
+	}
+
+// -----------------------------------------------------------------------------
+// Change the button group
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::SetNewCbaL(TInt aResId)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::SetNewCbaL");
+    if (!iCba)
+        {
+        CCoeControl* coeControl = iContainer->Common()->CoeControl();
+        iCba = CEikButtonGroupContainer::NewL(
+            CEikButtonGroupContainer::ECba,
+            CEikButtonGroupContainer::EHorizontal,
+            this,
+            aResId, *coeControl );
+        }
+    else
+        {
+        iCba->SetCommandSetL(aResId);
+        iCba->DrawDeferred();
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// Display collection details
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::ShowCollectionDetailsL(const CMPXMedia& aMedia)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::ShowCollectionDetailsL");
+    CAknSingleHeadingPopupMenuStyleListBox* list =
+        new (ELeave) CAknSingleHeadingPopupMenuStyleListBox;
+
+    CleanupStack::PushL(list);
+    CAknPopupList* popupList = CAknPopupList::NewL(
+        list, R_AVKON_SOFTKEYS_OK_EMPTY,
+        AknPopupLayouts::EMenuGraphicHeadingWindow);
+
+    CleanupStack::PushL(popupList);
+    list->ConstructL(popupList, CEikListBox::ELeftDownInViewRect);
+    list->CreateScrollBarFrameL(ETrue);
+    list->ScrollBarFrame()->SetScrollBarVisibilityL(
+        CEikScrollBarFrame::EOff,
+        CEikScrollBarFrame::EAuto);
+
+    CDesCArrayFlat* dataArray =
+        new (ELeave) CDesCArrayFlat(EMPXCollectionDetailsCount);
+    CleanupStack::PushL(dataArray);
+
+    // Enable Marquee
+    static_cast<CEikFormattedCellListBox*>(list)->ItemDrawer()->ColumnData()->
+        EnableMarqueeL(ETrue);
+
+    // number of items
+    HBufC* dataToAppend = HBufC::NewLC(KMPXMaxBufferLength);
+    TInt songsCount = 0;
+    if (aMedia.IsSupported(KMPXMediaColDetailNumberOfItems))
+        {
+        songsCount = aMedia.ValueTObjectL<TInt>(KMPXMediaColDetailNumberOfItems);
+        }
+    TPtr ptr = dataToAppend->Des();
+    ptr.AppendNum(songsCount);
+    AknTextUtils::LanguageSpecificNumberConversion(ptr);
+    dataArray->AppendL(ptr);
+    CleanupStack::PopAndDestroy(dataToAppend);
+    dataToAppend = NULL;
+
+    // total duration
+    TInt duration = 0;
+    if (aMedia.IsSupported(KMPXMediaColDetailDuration))
+        {
+        duration = aMedia.ValueTObjectL<TInt>(KMPXMediaColDetailDuration);
+        }
+    if (duration > 0)
+        {
+        dataToAppend = iCommonUiHelper->DisplayableDurationInTextL(duration/KMilliSecondsToSeconds);
+        CleanupStack::PushL(dataToAppend);
+        ptr.Set(dataToAppend->Des());
+        AknTextUtils::LanguageSpecificNumberConversion(ptr);
+        dataArray->AppendL(ptr);
+        CleanupStack::PopAndDestroy(dataToAppend);
+        dataToAppend = NULL;
+        }
+    else
+        {
+        dataArray->AppendL(KNullDesC);
+        }
+
+#ifdef RD_MULTIPLE_DRIVE
+    RFs& fileSession( iCoeEnv->FsSession() );
+    TDriveList driveList;
+    TInt driveCount(0);
+    TInt64 freePhoneMemory(KErrNotFound);
+    TInt64 freeInternalMemory(KErrNotFound);
+    TInt64 freeExternalMemory(KErrNotFound);
+    TVolumeInfo volInfo;
+
+    // Get all visible drives
+    User::LeaveIfError( DriveInfo::GetUserVisibleDrives(
+           fileSession, driveList, driveCount ) );
+    MPX_DEBUG2 ("CMPXCollectionViewImp::ShowCollectionDetailsL - driveCount = %d", driveCount);
+
+    for( TInt driveNum = EDriveA; driveNum <= EDriveZ; driveNum++ )
+        {
+        if (driveList[driveNum])
+            {
+            // Get the volume information
+            if ( fileSession.Volume( volInfo, driveNum ) == KErrNone )
+                {
+                // Get the drive status
+                TUint driveStatus(0);
+                DriveInfo::GetDriveStatus( fileSession, driveNum, driveStatus );
+
+                // Add up free memory depending on memory location
+                if ( driveNum == EDriveC )
+                    {
+                    if ( freePhoneMemory == KErrNotFound )
+                        {
+                        freePhoneMemory = 0;
+                        }
+                    freePhoneMemory += volInfo.iFree;
+                    }
+                else if ( driveStatus & DriveInfo::EDriveInternal )
+                    {
+                    if ( freeInternalMemory == KErrNotFound )
+                        {
+                        freeInternalMemory = 0;
+                        }
+                    freeInternalMemory += volInfo.iFree;
+                    }
+                else if ( driveStatus &
+                    (DriveInfo::EDriveRemovable | DriveInfo::EDriveRemote) )
+                    {
+                    if ( freeExternalMemory == KErrNotFound )
+                        {
+                        freeExternalMemory = 0;
+                        }
+                    freeExternalMemory += volInfo.iFree;
+                    }
+                }
+            }
+        }
+
+    // phone memory free
+    if ( freePhoneMemory != KErrNotFound )
+        {
+        dataToAppend = iCommonUiHelper->UnitConversionL(
+            freePhoneMemory, ETrue );
+        ptr.Set(dataToAppend->Des());
+        AknTextUtils::LanguageSpecificNumberConversion( ptr);
+        }
+    else
+        {
+        dataToAppend = StringLoader::LoadL(
+            R_MPX_CUI_COLLECTION_DETAILS_MEMORY_UNAVAILABLE );
+        ptr.Set(dataToAppend->Des());
+        }
+
+    CleanupStack::PushL( dataToAppend );
+    dataArray->AppendL( ptr );
+    CleanupStack::PopAndDestroy( dataToAppend );
+
+    // internal memory (mass storage) free
+    if ( freeInternalMemory != KErrNotFound )
+        {
+        dataToAppend = iCommonUiHelper->UnitConversionL(
+            freeInternalMemory, ETrue );
+        ptr.Set(dataToAppend->Des());
+        AknTextUtils::LanguageSpecificNumberConversion( ptr); 
+        }
+    else
+        {
+        dataToAppend = StringLoader::LoadL(
+            R_MPX_CUI_COLLECTION_DETAILS_MEMORY_UNAVAILABLE );
+        ptr.Set(dataToAppend->Des());
+        }
+
+    CleanupStack::PushL( dataToAppend );
+    dataArray->AppendL( ptr );
+    CleanupStack::PopAndDestroy( dataToAppend );
+
+    // removable/remote (memory card) memory free
+    if ( freeExternalMemory != KErrNotFound )
+        {
+        dataToAppend = iCommonUiHelper->UnitConversionL(
+            freeExternalMemory, ETrue );
+        ptr.Set(dataToAppend->Des());
+        AknTextUtils::LanguageSpecificNumberConversion( ptr); 
+        }
+    else
+        {
+        dataToAppend = StringLoader::LoadL(
+            R_MPX_CUI_COLLECTION_DETAILS_CARD_UNAVAILABLE_ITEM );
+        ptr.Set(dataToAppend->Des());
+        }
+    CleanupStack::PushL( dataToAppend );
+    dataArray->AppendL( ptr );
+    CleanupStack::PopAndDestroy( dataToAppend );
+#else
+    // phone memory free
+    HBufC* driveLetter = StringLoader::LoadLC(R_MPX_COLLECTION_PHONE_MEMORY_ROOT_PATH);
+    CEikonEnv* coeEnv = CEikonEnv::Static();
+    RFs& fileSession = coeEnv->FsSession();
+    TVolumeInfo volInfo;
+    TDriveUnit driveUnit(*driveLetter); // Get the drive
+    CleanupStack::PopAndDestroy(driveLetter);
+    driveLetter = NULL;
+    TInt err = fileSession.Volume(volInfo, (TInt)driveUnit);
+    MPX_DEBUG2("CMPXCollectionViewImp::ShowCollectionDetailsL phonemem err = %d", err);
+    if (KErrNone == err)
+        {
+        dataToAppend = iCommonUiHelper->UnitConversionL(volInfo.iFree, ETrue);
+        ptr.Set(dataToAppend->Des());
+        AknTextUtils::LanguageSpecificNumberConversion( ptr);
+        }
+    else
+        {
+        dataToAppend = StringLoader::LoadL(
+            R_MPX_CUI_COLLECTION_DETAILS_CARD_UNAVAILABLE_ITEM);
+        ptr.Set(dataToAppend->Des());
+        }
+    CleanupStack::PushL(dataToAppend);
+    dataArray->AppendL( ptr );
+    CleanupStack::PopAndDestroy(dataToAppend);
+    dataToAppend = NULL;
+
+    // memory card
+    driveLetter = StringLoader::LoadLC(R_MPX_COLLECTION_MEMORY_CARD_ROOT_PATH);
+    driveUnit = *driveLetter; // Get the drive
+    CleanupStack::PopAndDestroy(driveLetter);
+    driveLetter = NULL;
+    err = fileSession.Volume(volInfo, (TInt)driveUnit);
+    MPX_DEBUG2("CMPXPodcastCollectionViewImp::ShowCollectionDetailsL memcard err = %d", err);
+    if (err == KErrNone)
+        {
+        dataToAppend = iCommonUiHelper->UnitConversionL(volInfo.iFree, ETrue);
+        ptr.Set(dataToAppend->Des());
+        AknTextUtils::LanguageSpecificNumberConversion( ptr); 
+        }
+    else if (err == KErrNotReady || err == KErrCorrupt)
+        {
+        dataToAppend = StringLoader::LoadLC(
+            R_MPX_CUI_COLLECTION_DETAILS_CARD_UNAVAILABLE_ITEM);
+        ptr.Set(dataToAppend->Des());
+        }
+    // else ignore
+    CleanupStack::PushL( dataToAppend );
+
+    dataArray->AppendL( ptr );
+    CleanupStack::PopAndDestroy(dataToAppend);
+    dataToAppend = NULL;
+#endif // RD_MULTIPLE_DRIVE
+
+    // last refreshed
+    TInt64 lastRefreshed( 0 );
+    if (aMedia.IsSupported(KMPXMediaColDetailLastRefreshed))
+        {
+        lastRefreshed = aMedia.ValueTObjectL<TInt64>(KMPXMediaColDetailLastRefreshed);
+        }
+    TTime time(lastRefreshed);
+    dataToAppend = HBufC::NewLC(
+        KMPXMaxTimeLength + KMPXDurationDisplayResvLen);
+    HBufC* format = StringLoader::LoadLC(R_QTN_DATE_USUAL_WITH_ZERO);
+    TPtr modDatePtr = dataToAppend->Des();
+    time.FormatL(modDatePtr, *format);
+    CleanupStack::PopAndDestroy(format);
+    format = NULL;
+    AknTextUtils::LanguageSpecificNumberConversion( modDatePtr ); 
+    dataArray->AppendL(modDatePtr);
+    CleanupStack::PopAndDestroy(dataToAppend);
+    dataToAppend = NULL;
+
+    // Retrieve heading array
+    CDesCArrayFlat* headingsArray = NULL;
+    headingsArray = iCoeEnv->ReadDesCArrayResourceL(
+            R_MPX_PODCAST_CUI_COLLECTION_DETAILS_HEADINGS);
+    CleanupStack::PushL(headingsArray);
+
+    // Item array combines heading array and data array
+    CDesCArrayFlat* itemArray =
+        new (ELeave) CDesCArrayFlat(headingsArray->Count());
+    CleanupStack::PushL(itemArray);
+
+    for (TInt i = 0; i < headingsArray->Count(); i++)
+        {
+        HBufC *item = HBufC::NewLC(
+            headingsArray->MdcaPoint(i).Length() +
+            dataArray->MdcaPoint(i).Length() +
+            KMPXDurationDisplayResvLen);
+
+        TPtrC tempPtr1 = headingsArray->MdcaPoint(i);
+        TPtrC tempPtr2 = dataArray->MdcaPoint(i);
+
+        item->Des().Format(KMPXCollDetailsItemsFormat,
+                            &tempPtr1,
+                            &tempPtr2);
+
+        itemArray->AppendL(*item);
+        CleanupStack::PopAndDestroy(item);
+        }
+
+    CleanupStack::Pop(itemArray);
+    CleanupStack::PopAndDestroy(headingsArray);
+    CleanupStack::PopAndDestroy(dataArray);
+
+    // Set list items
+    CTextListBoxModel* model = list->Model();
+    model->SetOwnershipType(ELbmOwnsItemArray);
+    model->SetItemTextArray(itemArray);
+
+    // Set title
+    HBufC* title =
+        StringLoader::LoadLC(R_MPX_QTN_NMP_TITLE_COLLECTION_DETAILS);
+    popupList->SetTitleL(*title);
+    CleanupStack::PopAndDestroy(title);
+
+    // Show popup list
+    CleanupStack::Pop(popupList);
+    popupList->ExecuteLD();
+    CleanupStack::PopAndDestroy(list);
+    }
+
+//#ifdef __UPNP_FRAMEWORK_2_0_
+// ---------------------------------------------------------------------------
+// Handles Upnp menus from DynInitMenuPaneL()
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandleDynInitUpnpL(
+    TInt aResourceId,
+    CEikMenuPane& aMenuPane )
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::HandleDynInitUpnpL()");
+
+    if ( !IsUpnpVisible() )
+        {
+        GetCurrentPlayerDetails();
+
+        if ( iCurrentPlayerType == EPbLocal )
+            {
+            aMenuPane.SetItemDimmed(
+                EMPXCmdUpnpPlayVia,
+                ETrue);
+            }
+        aMenuPane.SetItemDimmed(
+            EMPXCmdUPnPAiwCmdCopyToExternalCriteria,
+            ETrue);
+        }
+    else
+        {
+        MPX_DEBUG1("CMPXPodcastCollectionViewImp::HandleDynInitUpnpL(): UPnP visible and media");
+        TInt currentItem( iContainer->Common()->CurrentLbxItemIndex() );
+
+        const CMPXMedia& media =
+            (iContainer->Common()->ListBoxArray())->MediaL( currentItem );
+        TMPXGeneralType type( EMPXNoType );
+        if (media.IsSupported(KMPXMediaGeneralType))
+            {
+            type =
+                media.ValueTObjectL<TMPXGeneralType>(KMPXMediaGeneralType);
+            }
+
+        if ( ( type == EMPXItem ) ||
+             ( type == EMPXGroup ) )
+            {
+            MPX_DEBUG1("CMPXPodcastCollectionViewImp::HandleDynInitUpnpL(): folder or song");
+            if (iErrorAttachCopyMenu != KErrNone)
+                {
+                MPX_DEBUG1("CMPXPodcastCollectionViewImp::HandleDynInitUpnpL(): error, Dim Copy");
+                aMenuPane.SetItemDimmed(
+                    EMPXCmdUPnPAiwCmdCopyToExternalCriteria,
+                    ETrue);
+                }
+            else
+                {
+                if (iServiceHandler->HandleSubmenuL(aMenuPane))
+                    {
+                    return;
+                    }
+
+                if (iServiceHandler->IsAiwMenu(aResourceId))
+                    {
+                    MPX_DEBUG1("CMPXPodcastCollectionViewImp::HandleDynInitUpnpL(): Aiw menu");
+                    CAiwGenericParamList& in = iServiceHandler->InParamListL();
+
+                    iServiceHandler->InitializeMenuPaneL(aMenuPane, aResourceId, EMPXCmdUPnPAiwCmdCopyToExternalCriteria, in);
+                    MPX_DEBUG1("CMPXPodcastCollectionViewImp::HandleDynInitUpnpL(): after InitializeMenuPaneL");
+                    }
+                }
+            }
+         else
+            {
+            aMenuPane.SetItemDimmed(
+                EMPXCmdUpnpPlayVia,
+                ETrue);
+            aMenuPane.SetItemDimmed(
+                EMPXCmdUPnPAiwCmdCopyToExternalCriteria,
+                ETrue);
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMPXPodcastCollectionViewImp::IsUpnpVisible
+// Checks if UPnP access point is defined
+// -----------------------------------------------------------------------------
+//
+TBool CMPXPodcastCollectionViewImp::IsUpnpVisible()
+    {
+    MPX_FUNC( "CMPXPodcastCollectionViewImp::IsUpnpVisible" );
+    
+    TBool returnValue = EFalse;
+#ifdef UPNP_INCLUDED
+   	if ( iUpnpCopyCommand && iUpnpFrameworkSupport ) 	  
+        {
+        returnValue = iUpnpCopyCommand->IsAvailableL();   
+        }
+#endif
+    return returnValue; 
+    
+    }
+
+// -----------------------------------------------------------------------------
+// CMPXPodcastCollectionViewImp::AddPlayersNamesToMenuL
+// Taken from Gallery upnp support implementation
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::AddPlayersNamesToMenuL(CEikMenuPane& aMenuPane)
+    {
+    RArray<TMPXPlaybackPlayerType> playerTypes;
+    CleanupClosePushL(playerTypes);
+
+    MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager();
+    manager.GetPlayerTypesL(playerTypes);
+
+    GetCurrentPlayerDetails();
+
+    TInt countPlayersTypes( playerTypes.Count() );
+    TInt countLocalType(0);
+    TInt countRemoteType(0);
+
+    if ( countPlayersTypes >= 1 )
+        {
+        iPlayersList.Close();
+
+        for ( TInt i = 0; i < countPlayersTypes; i++ )
+            {
+            MPX_DEBUG3( "playerTypes[%d]: %d", i, playerTypes[i] );
+            switch (playerTypes[i])
+                {
+                case EPbLocal:
+                    {
+                    // we only show 1 specific type once in the menu
+                    if ( countLocalType == 0 )
+                        {
+                        AddPlayerNameToMenuL( aMenuPane,
+                                            EMPXCmdUpnpPlayViaLocal,
+                                            manager,
+                                            playerTypes[i] );
+
+                        countLocalType++;
+                        }
+                    break;
+                    }
+                case EPbRemote:
+                    {
+                    // we only show 1 specific type once in the menu
+                    if ( countRemoteType == 0 )
+                        {
+                        AddPlayerNameToMenuL( aMenuPane,
+                                            EMPXCmdUpnpPlayViaRemotePlayer,
+                                            manager,
+                                            playerTypes[i] );
+                        countRemoteType++;
+                        }
+                    break;
+                    }
+                default:
+                    {
+                    // default case is handled in the next loop, we want
+                    // to add any "other" player at the end of the list
+                    break;
+                    }
+                }
+            } // for loop
+
+        for ( TInt i = 0; i < countPlayersTypes; i++ )
+            {
+            MPX_DEBUG3( "playerTypes[%d]: %d", i, playerTypes[i] );
+            // EPbLocal and EPbRemote were already added to the
+            // submenu in the previous loop
+            if ( playerTypes[i] != EPbLocal &&
+                 playerTypes[i] != EPbRemote )
+                {
+                // EPbUnknown or else
+                TBool alreadyInTheList( EFalse );
+
+                for ( TInt j = 0; j < i; j++)
+                    {
+                    // if the new playertype is already in the list
+                    if ( playerTypes[i] == playerTypes[j] )
+                        {
+                        alreadyInTheList = ETrue;
+                        break;
+                        }
+                    }
+
+                if ( !alreadyInTheList )
+                    {
+                    HBufC* buf = manager.PlayerTypeDisplayNameL(playerTypes[i]);
+
+                    if ( buf )
+                        {
+                        CleanupStack::PushL(buf);
+                        AddPlayerNameToMenuL( aMenuPane,
+                                            EMPXCmdUpnpPlayViaRemotePlayer,
+                                            manager,
+                                            playerTypes[i],
+                                            *buf );
+                        CleanupStack::PopAndDestroy(buf);
+                        }
+                    // else we don't do anything. other player type is not
+                    // currently supported. Implementation will be finalized
+                    // when the requirement is defined.
+                    }
+                }
+            }
+        }
+
+    CleanupStack::PopAndDestroy(&playerTypes);
+
+    if ( iPlayersList.Count() <= 1 )
+        {
+        aMenuPane.SetItemDimmed( EMPXCmdUpnpPlayViaRemotePlayer,
+                                  ETrue );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMPXPodcastCollectionViewImp::AddPlayerNameToMenuL
+// Taken from Gallery upnp support implementation
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::AddPlayerNameToMenuL(CEikMenuPane& aMenuPane,
+                                                TInt aCommandId,
+                                                MMPXPlayerManager& aPlayerManager,
+                                                TMPXPlaybackPlayerType& aPlayerType,
+                                                const TDesC& aMenuText)
+    {
+    RArray<TUid> players;
+    CleanupClosePushL(players);
+    aPlayerManager.GetPlayerListL(players, aPlayerType);
+
+    // For now we only keep the first player we find
+    // Local player is always the first one in the list
+    // Ui spec limitation
+    MPX_DEBUG2( "players[0]: %d", players[0].iUid );
+    if ( aCommandId == EMPXCmdUpnpPlayViaLocal )
+        {
+        iPlayersList.Insert(players[0], 0);
+        }
+    else if ( ( aCommandId == EMPXCmdUpnpPlayViaRemotePlayer ) &&
+              (iPlayersList.Count() > 1) )
+        {
+        iPlayersList.Insert(players[0], 1);
+        }
+    else
+        {
+        iPlayersList.AppendL(players[0]);
+        }
+    CleanupStack::PopAndDestroy(&players);
+
+    // if the player is of unknown type
+    if ( ( aCommandId != EMPXCmdUpnpPlayViaRemotePlayer ) &&
+         ( aCommandId != EMPXCmdUpnpPlayViaLocal ) )
+        {
+        CEikMenuPaneItem::SData menuItem;
+        menuItem.iText.Copy( aMenuText );
+        menuItem.iCascadeId = 0;
+        menuItem.iFlags = EEikMenuItemRadioEnd;
+
+        menuItem.iCommandId = aCommandId + (iPlayersList.Count() - 1);
+        aCommandId = menuItem.iCommandId;
+
+        aMenuPane.AddMenuItemL( menuItem );
+        }
+
+    if ( iCurrentPlayerType == aPlayerType )
+        {
+        aMenuPane.SetItemButtonState( aCommandId, EEikMenuItemSymbolOn );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMPXPodcastCollectionViewImp::GetCurrentPlayerDetails
+// Retrieves the current player name and type
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::GetCurrentPlayerDetails()
+    {
+    MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager();
+    TUid currentlyUsedPlayer;
+    TInt currentlyUsedSubPlayer;
+    iCurrentPlayerType = EPbLocal;
+    delete iSubPlayerName;
+    iSubPlayerName = NULL;
+    TRAP_IGNORE( manager.GetSelectionL( iCurrentPlayerType,
+                                        currentlyUsedPlayer,
+                                        currentlyUsedSubPlayer,
+                                        iSubPlayerName));
+    }
+
+// -----------------------------------------------------------------------------
+// CMPXPodcastCollectionViewImp::SelectNewPlayerL
+// Selects a new player for audio playback
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::SelectNewPlayerL(TInt aCommand)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::SelectNewPlayerL()");
+    MPX_DEBUG2("CMPXPodcastCollectionViewImp::SelectNewPlayerL(%d)", aCommand);
+
+    TInt errorSelectPlayer( KErrCancel );
+
+    switch (aCommand)
+        {
+        case EMPXCmdUpnpPlayViaLocal:
+            {
+            // if Local is not already the current player, select it
+            if ( iCurrentPlayerType != EPbLocal )
+                {
+                MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager();
+                MPX_TRAP( errorSelectPlayer, manager.ClearSelectPlayersL() );
+                }
+            else // no need to reselect it but always start playback
+                {
+                errorSelectPlayer = KErrNone;
+                }
+            break;
+            }
+        default:
+            {
+            if ( aCommand >= EMPXCmdUpnpPlayViaRemotePlayer )
+                {
+                HBufC* buf = HBufC::NewLC( KMaxUidName );
+                buf->Des().AppendNum(
+                     (iPlayersList[aCommand -
+                                   EMPXCmdUpnpPlayViaLocal]).iUid );
+
+                // ActivateViewL leaves with KErrCancel if the dialog is
+                // cancelled
+                // ActivateViewL leaves with KErrInUse if the selected player
+                // is already the active player
+                MPX_TRAP(errorSelectPlayer, iViewUtility->ActivateViewL(
+                                TUid::Uid( KMPXPluginTypeUPnPBrowseDialogUid ),
+                                buf ));
+                CleanupStack::PopAndDestroy( buf );
+                }
+            break;
+            }
+        }
+
+    GetCurrentPlayerDetails();
+
+    // If InUse, the player selected is already the current one, we start playback anyway
+    // contrary to Playback view
+    if ( ( errorSelectPlayer == KErrNone ) ||
+         ( errorSelectPlayer == KErrInUse ) )
+        {
+        // Starts playback by calling OpenL() for the selected track
+        CMPXCommonListBoxArrayBase* array = iContainer->Common()->ListBoxArray();
+        if ( array )
+            {
+            MPX_DEBUG1("CMPXPodcastCollectionViewImp::SelectNewPlayerL() before MediaL()");
+
+            TInt currentListBoxItemIndex(
+                iContainer->Common()->CurrentLbxItemIndex() );
+
+            if ( currentListBoxItemIndex >= 0 )
+                {
+                const CMPXMedia& media = array->MediaL( currentListBoxItemIndex );
+
+                TMPXGeneralType type( EMPXNoType );
+                TMPXGeneralCategory category( EMPXNoCategory );
+
+                if ( media.IsSupported( KMPXMediaGeneralType ) )
+                    {
+                    type = media.ValueTObjectL<TMPXGeneralType>( KMPXMediaGeneralType );
+                    }
+
+                if ( media.IsSupported( KMPXMediaGeneralCategory ) )
+                    {
+                    category = media.ValueTObjectL<TMPXGeneralCategory>(
+                                    KMPXMediaGeneralCategory );
+                    }
+
+                // Needed to reset the status of iPreservedState
+                iPlaybackUtility->CommandL(EPbCmdResetPreserveState);
+                RArray<TMPXAttribute> attrs;
+                CleanupClosePushL(attrs);
+				// Append the signal to set IsPlaying flag
+                MPX_DEBUG2("CMPXPodcastCollectionViewImp::SelectNewPlayerL() currentIndex %d", currentListBoxItemIndex );
+
+                if ((type == EMPXItem) && (category == EMPXPodcast))
+                    {
+                    MPX_DEBUG1("CMPXPodcastCollectionViewImp::SelectNewPlayerL() type is EMPXItem");
+                    iCollectionUtility->Collection().OpenL( currentListBoxItemIndex, attrs.Array() );
+                    }
+                else // if a folder is selected
+                    {
+                    MPX_DEBUG1("CMPXPodcastCollectionViewImp::SelectNewPlayerL() type is EMPXGroup");
+                    iCollectionUtility->Collection().OpenL( currentListBoxItemIndex,
+                                                            EMPXOpenPlaylistOnly);
+                    }
+                CleanupStack::PopAndDestroy(&attrs);
+                }
+            }
+        }
+    else if ( errorSelectPlayer != KErrCancel )
+        {
+        User::LeaveIfError(errorSelectPlayer);
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMPXPodcastCollectionViewImp::CopySelectedItemsToRemoteL
+// Copies selected file(s) to remote player
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::CopySelectedItemsToRemoteL()
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::CopySelectedItemsToRemoteL()");
+
+    TInt index( iContainer->Common()->CurrentLbxItemIndex() );
+    if ( index >= 0 )
+        {
+        CMPXCommonListBoxArrayBase* array =
+            iContainer->Common()->ListBoxArray();
+        const CMPXMedia& media = array->MediaL( index );
+
+        TMPXGeneralType type( EMPXNoType );
+        TMPXGeneralCategory category( EMPXNoCategory );
+
+       if ( media.IsSupported( KMPXMediaGeneralType ) )
+            {
+            type =
+                media.ValueTObjectL<TMPXGeneralType>( KMPXMediaGeneralType );
+            }
+        if ( media.IsSupported( KMPXMediaGeneralCategory ) )
+            {
+            category =
+                media.ValueTObjectL<TMPXGeneralCategory>( KMPXMediaGeneralCategory );
+            }
+
+        CMPXCollectionPath* cpath =
+                              iCollectionUtility->Collection().PathL();
+        CleanupStack::PushL( cpath );
+
+        if ( ( type == EMPXItem ) && ( category == EMPXPodcast ) )
+            {
+            const CArrayFix<TInt>* arrayIndex =
+                iContainer->Common()->CurrentSelectionIndicesL();
+            TInt arrayCount( arrayIndex->Count() );
+
+            cpath->ClearSelection();
+            if ( arrayCount > 0 )
+                {
+                for (TInt index=0; index < arrayCount; index++)
+                    {
+                    cpath->SelectL(arrayIndex->At(index));
+                    }
+                }
+            else
+                {
+                cpath->Set( index );
+                }
+
+            // Ask for the list of selected song paths: will return in HandleMedia()
+            ASSERT( iCurrentMediaLOp == EMPXOpMediaLIdle );
+            RArray<TMPXAttribute> attrs;
+            CleanupClosePushL(attrs);
+            attrs.Append( KMPXMediaGeneralUri );
+            iCollectionUtility->Collection().MediaL( *cpath, attrs.Array() );
+            iCurrentMediaLOp = EMPXOpMediaLCopyToRemote;
+            CleanupStack::PopAndDestroy( &attrs );
+            }
+        else // if a folder is selected
+            {
+            TMPXItemId id(0);
+            if ( media.IsSupported( KMPXMediaGeneralId ) )
+                {
+                id = media.ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );
+                }
+
+            RArray<TInt> supportedIds;
+            CleanupClosePushL(supportedIds);
+            supportedIds.AppendL(KMPXMediaIdGeneral);
+
+            CMPXMedia* entry = CMPXMedia::NewL(supportedIds.Array());
+            CleanupStack::PushL(entry);
+            entry->SetTObjectValueL( KMPXMediaGeneralType, EMPXGroup );
+
+            entry->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXPodcast );
+
+            entry->SetTObjectValueL( KMPXMediaGeneralId, id );
+
+            TInt depth( cpath->Levels() );
+            // last level, we need to specify the container Id for the search
+            if(depth > KMPXLastDirectoryLevel)
+                {
+                const TMPXItemId& containerId = cpath->Id(depth-1);
+                entry->SetTObjectValueL( KMPXMediaGeneralContainerId,
+                                            containerId);
+                }
+
+            RArray<TMPXAttribute> attrs;
+            CleanupClosePushL(attrs);
+            attrs.Append( KMPXMediaGeneralUri );
+
+            ASSERT( iCurrentFindAllLOp == EMPXOpFindAllLIdle );
+            iCollectionUtility->Collection().FindAllL( *entry,
+                                                       attrs.Array(),
+                                                       *this );
+            iCurrentFindAllLOp = EMPXOpFindAllLUpnp;
+
+            CleanupStack::PopAndDestroy( &attrs );
+            CleanupStack::PopAndDestroy( entry );
+            CleanupStack::PopAndDestroy( &supportedIds );
+            }
+        CleanupStack::PopAndDestroy( cpath );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMPXPodcastCollectionViewImp::DoHandleCopyToRemoteL
+// Handle call back from collectionframework for Copy to Remote command
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::DoHandleCopyToRemoteL(
+    const CMPXMedia& aMedia, TBool aComplete )
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::DoHandleCopyToRemoteL()");
+
+    CMPXMediaArray* mediaArray( NULL );
+    TInt fileCount( 0 );
+
+    if ( aMedia.IsSupported( KMPXMediaArrayContents ) )
+        {
+        mediaArray =
+            aMedia.Value<CMPXMediaArray>( KMPXMediaArrayContents );
+        if ( mediaArray )
+            {
+            fileCount = mediaArray->Count();
+            }
+        }
+    MPX_DEBUG2("CMPXPodcastCollectionViewImp::DoHandleCopyToRemoteL Entry count = %d", fileCount);
+
+    // Change this to Global will be needed if FindAll() is called
+    // repeatedly until aComplete is ETrue (Inc9?)
+    CAiwGenericParamList* aiwCopyInParamList = CAiwGenericParamList::NewLC();
+
+    // multiple files or folder
+    if ( fileCount > 0 )
+        {
+        if ( mediaArray )
+            {
+            for ( TInt i = 0; i < fileCount; i++ )
+                {
+                CMPXMedia* media( mediaArray->AtL( i ) );
+
+                if ( media->IsSupported( KMPXMediaGeneralUri ) )
+                    {
+                    const TDesC& location =
+                        media->ValueText( KMPXMediaGeneralUri );
+                        MPX_DEBUG3( "CMPXPodcastCollectionViewImp::DoHandleCopyToRemote %d filePath = %S", i, &location );
+
+                    TAiwVariant path( location );
+                    TAiwGenericParam fileParameter( EGenericParamFile,
+                                                    path );
+                    aiwCopyInParamList->AppendL( fileParameter );
+                    }
+                }
+            }
+        }
+    else // single file
+        {
+        TMPXGeneralType type( EMPXNoType );
+
+        if ( aMedia.IsSupported( KMPXMediaGeneralType ) )
+            {
+            type = aMedia.ValueTObjectL<TMPXGeneralType>( KMPXMediaGeneralType );
+            }
+
+        if ( type == EMPXItem )
+            {
+            if ( aMedia.IsSupported( KMPXMediaGeneralUri ) )
+                {
+                const TDesC& location =
+                    aMedia.ValueText( KMPXMediaGeneralUri );
+                TAiwVariant path( location );
+                MPX_DEBUG2( "CMPXPodcastCollectionViewImp::DoHandleCopyToRemote filePath = %S", &location );
+
+                TAiwGenericParam fileParameter( EGenericParamFile, path );
+                aiwCopyInParamList->AppendL( fileParameter );
+                }
+            }
+        }
+
+    if ( ( aiwCopyInParamList->Count() > 0 ) &&
+         aComplete )
+        {
+        CAiwGenericParamList* outParamList = CAiwGenericParamList::NewLC();
+        // do not allow the copy dialog to be dismissed by external command
+        HandleCommandL( EMPXCmdIgnoreExternalCommand );
+        iServiceHandler->ExecuteMenuCmdL(
+                  EMPXCmdUPnPAiwCmdCopyToExternalCriteria, /* command id */
+                  *aiwCopyInParamList,   /* in parameters */
+                  *outParamList,          /* out parameters */
+                  0,                      /* options */
+                  NULL );                 /* call back */
+        HandleCommandL( EMPXCmdHandleExternalCommand );
+
+        CleanupStack::PopAndDestroy( outParamList );
+        }
+
+    // Clear selection
+    if( iContainer )
+        {
+        iContainer->Common()->ClearLbxSelection();
+        }
+
+    CleanupStack::PopAndDestroy( aiwCopyInParamList );
+    }
+//#endif //__UPNP_FRAMEWORK_2_0_
+
+// -----------------------------------------------------------------------------
+// checks if send option should be shown the option is selected.
+// -----------------------------------------------------------------------------
+//
+TBool CMPXPodcastCollectionViewImp::SendOptionVisibilityL()
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::SendOptionVisibilityL");
+    TBool isHidden( iContainer->Common()->TotalListItemCount() < 1 );
+
+    if ( !isHidden )
+        {
+        CMPXCommonListBoxArrayBase* baseArray =
+            iContainer->Common()->ListBoxArray();
+        CMPXPodcastCollectionViewListBoxArray* array =
+            static_cast<CMPXPodcastCollectionViewListBoxArray*>( baseArray );
+        const CArrayFix<TInt>* selectedIndexArray =
+            iContainer->Common()->CurrentSelectionIndicesL();
+        TInt selectionCount( selectedIndexArray->Count() );
+
+        if ( selectionCount > 0 )
+            {
+            TBool isValid( EFalse );
+            for ( TInt i = 0; i < selectionCount && !isValid; i++ )
+                {
+                // multiple selection
+                // corrupted song can be sent in this case
+                isValid = !array->IsItemBrokenLinkL(
+                    selectedIndexArray->At( i ) ) &&
+                    !array->IsItemCorruptedL(
+                    selectedIndexArray->At( i ) );
+                }
+            // if anything is valid, display the item
+            isHidden = !isValid;
+            }
+        else
+            {
+            //single selection
+            TInt currentItem( iContainer->Common()->CurrentLbxItemIndex() );
+            isHidden = array->IsItemBrokenLinkL( currentItem ) ||
+                array->IsItemCorruptedL( currentItem );
+            }
+        }
+
+    return isHidden;
+    }
+
+// -----------------------------------------------------------------------------
+// Checks if file details option should be shown
+// -----------------------------------------------------------------------------
+//
+TBool CMPXPodcastCollectionViewImp::FileDetailsOptionVisibilityL()
+    {
+    MPX_FUNC( "CMPXPodcastCollectionViewImp::FileDetailsOptionVisibilityL" );
+    TBool isHidden( iContainer->Common()->TotalListItemCount() < 1 ||
+        iContainer->Common()->CurrentSelectionIndicesL()->Count() );
+    if ( !isHidden )
+        {
+        CMPXPodcastCollectionViewListBoxArray* array =
+            static_cast<CMPXPodcastCollectionViewListBoxArray*>(
+            iContainer->Common()->ListBoxArray() );
+        const CMPXMedia& media =
+            array->MediaL( iContainer->Common()->CurrentLbxItemIndex() );
+
+        if ( media.IsSupported( KMPXMediaGeneralFlags ) )
+            {
+            TUint flags( media.ValueTObjectL<TUint>( KMPXMediaGeneralFlags ) );
+            if ( ( flags ) & ( KMPXMediaGeneralFlagsIsMissingDetails ) )
+                {
+                isHidden = ETrue;
+                }
+            }
+        }
+    return isHidden;
+    }
+// -----------------------------------------------------------------------------
+// Handle send command.
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::DoSendL()
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::DoSendL");
+    iCurrentMediaLOp = EMPXOpMediaLSend;
+    CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();
+    CleanupStack::PushL(path);
+
+    // Marked indicies
+    const CArrayFix<TInt>* array =
+        iContainer->Common()->CurrentSelectionIndicesL();
+    TInt arrayCount = array->Count();
+    MPX_DEBUG2("CMPXPodcastCollectionViewImp::DoSendL array count = %d", arrayCount);
+    if (arrayCount > 1)
+        {
+        // if more than 1 selected
+        for (TInt i = 0; i < arrayCount; i++)
+            {
+            MPX_DEBUG2("CMPXCollectionViewImp::DoSendL array index = %d", array->At(i));
+            path->SelectL(array->At(i));
+            }
+        }
+    else if (arrayCount == 1)
+        {
+        // if only 1 item is marked, treat it as single selection
+        path->Set(array->At(0));
+        }
+    else
+        {
+        path->Set(iContainer->Common()->CurrentLbxItemIndex());
+        }
+
+
+    RArray<TMPXAttribute> attrs;
+    CleanupClosePushL(attrs);
+    attrs.Append(
+        TMPXAttribute(KMPXMediaIdGeneral,
+            EMPXMediaGeneralUri |
+            EMPXMediaGeneralSize |
+            EMPXMediaGeneralCollectionId |
+            EMPXMediaGeneralFlags |
+            EMPXMediaGeneralId |
+            EMPXMediaGeneralType |
+            EMPXMediaGeneralCategory));
+    iCollectionUtility->Collection().MediaL(*path, attrs.Array());
+    CleanupStack::PopAndDestroy(&attrs);
+    CleanupStack::PopAndDestroy(path);
+    }
+
+
+// -----------------------------------------------------------------------------
+// Handle call back from collectionframework for send command
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::DoHandleSendL(
+    const CMPXMedia& aMedia, TInt aError)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::DoHandleSendL");
+    if (aError == KErrNone)
+        {
+        TInt invalidFileCount(0);
+        TInt corruptedFileCount(0);
+        TInt maxSize(0);
+        CMessageData* messageData = CMessageData::NewLC();
+
+        TInt fileCount(0);
+        if(aMedia.IsSupported(KMPXMediaArrayContents))
+            {
+            const CMPXMediaArray* mediaArray =
+                aMedia.Value<CMPXMediaArray>(KMPXMediaArrayContents);
+            User::LeaveIfNull(const_cast<CMPXMediaArray*>(mediaArray));
+            
+            fileCount = mediaArray->Count();
+            }
+        MPX_DEBUG2("CMPXCollectionViewImp::DoHandleSendL Entry count = %d", fileCount);
+
+        if (fileCount > 0)
+            {
+            const CMPXMediaArray* mediaArray =
+                aMedia.Value<CMPXMediaArray>(KMPXMediaArrayContents);
+            User::LeaveIfNull(const_cast<CMPXMediaArray*>(mediaArray));
+            
+            for (TInt i = 0; i < fileCount; i++)
+                {
+                CMPXMedia* media( mediaArray->AtL( i ) );
+                TUint flags = 0;
+
+                if (aMedia.IsSupported(KMPXMediaGeneralFlags))
+                    {
+                    flags = media->ValueTObjectL<TUint>(KMPXMediaGeneralFlags);
+                    }
+
+                TUint isCorrupted( ( flags ) & ( KMPXMediaGeneralFlagsIsCorrupted ) );
+                TUint isInvalid( ( flags ) & ( KMPXMediaGeneralFlagsIsInvalid ) );
+                const TDesC& location = media->ValueText(KMPXMediaGeneralUri);
+
+                if (!isCorrupted && !isInvalid && ConeUtils::FileExists(location))
+                    {
+                    TInt fileSize = 0;
+                    if (isCorrupted)
+                        {
+                        corruptedFileCount++;
+                        }
+                    if (aMedia.IsSupported(KMPXMediaGeneralSize))
+                        {
+                        fileSize = media->ValueTObjectL<TInt>(KMPXMediaGeneralSize);
+                        }
+                    else
+                        {
+                        RFs& fileSession = iCoeEnv->FsSession();
+                        TEntry pl;
+                        fileSession.Entry(location, pl);
+                        fileSize = pl.iSize;
+                        }
+
+                    if (maxSize < fileSize)
+                        {
+                        maxSize = fileSize;
+                        }
+                    messageData->AppendAttachmentL(location);
+                    }
+                else
+                    {
+                    UpdateDatabaseFlagL(KErrNotFound, *media,
+                        KMPXMediaGeneralFlagsIsInvalid, ETrue, EFalse);
+                    invalidFileCount++;
+                    }
+                }
+            }
+        else
+            {
+            // single file
+            fileCount = 1;
+            TUint flags = 0;
+
+            if (aMedia.IsSupported(KMPXMediaGeneralFlags))
+                {
+                flags = aMedia.ValueTObjectL<TUint>(KMPXMediaGeneralFlags);
+                }
+
+            TUint isCorrupted( ( flags ) & ( KMPXMediaGeneralFlagsIsCorrupted ) );
+            TUint isInvalid( ( flags ) & ( KMPXMediaGeneralFlagsIsInvalid ) );
+            const TDesC& location = aMedia.ValueText(KMPXMediaGeneralUri);
+
+            if (!isInvalid && ConeUtils::FileExists(location))
+                {
+                TInt fileSize(0);
+                if (isCorrupted)
+                    {
+                    corruptedFileCount++;
+                    }
+                if (aMedia.IsSupported(KMPXMediaGeneralSize))
+                    {
+                    fileSize = aMedia.ValueTObjectL<TInt>(KMPXMediaGeneralSize);
+                    }
+                else
+                    {
+                    RFs& fileSession = iCoeEnv->FsSession();
+                    TEntry pl;
+                    fileSession.Entry(location, pl);
+                    fileSize = pl.iSize;
+                    }
+
+                if (maxSize < fileSize)
+                    {
+                    maxSize = fileSize;
+                    }
+                messageData->AppendAttachmentL(location);
+                }
+            else
+                {
+                UpdateDatabaseFlagL(KErrNotFound, aMedia,
+                    KMPXMediaGeneralFlagsIsInvalid, ETrue, EFalse);
+                invalidFileCount++;
+                }
+            }
+
+        TBool confirmOk = EFalse;
+        MPX_DEBUG4("CMPXCollectionViewImp::DoHandleSendL Invalid Count = %d, Corrupted Count = %d, Total Count = %d", invalidFileCount, corruptedFileCount, fileCount);
+        if (invalidFileCount || corruptedFileCount)
+            {
+            if (invalidFileCount == fileCount)
+                {
+                // all files are invalid
+                if (invalidFileCount == 1)
+                    {
+                    iCommonUiHelper->DisplayInfoNoteL(
+                        R_MPX_COLLECTION_INFO_FILE_NOT_FOUND);
+                    }
+                else
+                    {
+                    // Show information note if all files are invalid
+                    iCommonUiHelper->DisplayInfoNoteL(
+                        R_MPX_COLLECTION_SEND_ALL_INVALID_SONGS_NOTE_TXT);
+                    }
+                }
+            else
+                {
+                // Show confirmation query if invalid/corrupted file found
+                HBufC* queryTxt = StringLoader::LoadLC(
+                    R_MPX_COLLECTION_QUERY_SEND_INVALID_SONGS_TXT);
+                CAknQueryDialog* query = CAknQueryDialog::NewL(
+                    CAknQueryDialog::EConfirmationTone);
+//#ifdef __COVER_DISPLAY
+                CleanupStack::PushL(query);
+                query->PublishDialogL(EMPlayerNoteSendInvalidSongs,
+                                    KMPlayerNoteCategory);
+                CleanupStack::Pop(query);
+//#endif  //__COVER_DISPLAY
+                if (query->ExecuteLD(
+                    R_MPX_COLLECTION_GENERIC_CONFIRMATION_QUERY,
+                    *queryTxt))
+                    {
+                    confirmOk = ETrue;
+                    }
+                CleanupStack::PopAndDestroy(queryTxt);
+                }
+            }
+
+        if ((!invalidFileCount && !corruptedFileCount) || // everything is ok
+            (invalidFileCount && confirmOk) || // invalid files exist
+            (corruptedFileCount && confirmOk)) // courrupt files exist
+            {
+            if (!iSendUi)
+                {
+                iSendUi = CSendUi::NewL();
+                }
+            TSendingCapabilities capabilities(
+                0,
+                maxSize,
+                TSendingCapabilities::ESupportsAttachments);
+            HandleCommandL( EMPXCmdIgnoreExternalCommand );
+            MPX_TRAPD(err, iSendUi->ShowQueryAndSendL(messageData, capabilities));
+            if ( err != KErrNone )
+                {
+                HandleErrorL( err );
+                }
+            HandleCommandL( EMPXCmdHandleExternalCommand );
+            }
+
+        // Clear selection
+        if (iContainer)
+            {
+            iContainer->Common()->ClearLbxSelection();
+            }
+        CleanupStack::PopAndDestroy(messageData);
+        }
+    else
+        {
+        HandleErrorL(aError);
+        }
+    }
+
+
+// -----------------------------------------------------------------------------
+// Prepares media object for selected items
+// -----------------------------------------------------------------------------
+//
+TInt CMPXPodcastCollectionViewImp::PrepareMediaForSelectedItemsL(CMPXMedia* aMedia)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::PrepareMediaForSelectedItemsL");
+    TInt ret(KErrNone);
+
+    if (aMedia)
+        {
+        CMPXMediaArray* mediaArray = CMPXMediaArray::NewL();
+        CleanupStack::PushL(mediaArray);
+        const CArrayFix<TInt>* array =
+            iContainer->Common()->CurrentSelectionIndicesL();
+        CMPXCommonListBoxArrayBase* listBoxArray =
+            iContainer->Common()->ListBoxArray();
+        TInt count = array->Count();
+        CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();
+        CleanupStack::PushL(path);
+        TMPXItemId id = path->Id(0);
+        MPX_DEBUG2("CMPXCollectionViewImp::PrepareMediaForSelectedItemsL collection ID = 0x%x", id.iId1);
+        CleanupStack::PopAndDestroy(path);
+        if (count > 0)
+            {
+            for (TInt i = 0; i < count; i++)
+                {
+                const CMPXMedia& listBoxMedia = listBoxArray->MediaL(array->At(i));
+                CMPXMedia* entry = CMPXMedia::NewL();
+                CleanupStack::PushL(entry);
+                entry->SetTextValueL(KMPXMediaGeneralTitle,
+                    listBoxMedia.ValueText(KMPXMediaGeneralTitle));
+                entry->SetTObjectValueL(KMPXMediaGeneralType, EMPXItem);
+                entry->SetTObjectValueL(KMPXMediaGeneralCategory,
+                    EMPXSong);
+
+                if (listBoxMedia.IsSupported(KMPXMediaGeneralId))
+                    {
+                    entry->SetTObjectValueL(
+                        KMPXMediaGeneralId,
+                        listBoxMedia.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));
+                    }
+                else
+                    {
+                    User::Leave(KErrArgument);
+                    }
+
+                entry->SetTObjectValueL(KMPXMediaGeneralCollectionId, id);
+
+                mediaArray->AppendL(entry);
+                CleanupStack::Pop(entry);
+                }
+            }
+        else
+            {
+            count = 1;
+            TInt currentItem = iContainer->Common()->CurrentLbxItemIndex();
+            const CMPXMedia& listBoxMedia = listBoxArray->MediaL(currentItem);
+            CMPXMedia* entry = CMPXMedia::NewL();
+            CleanupStack::PushL(entry);
+            entry->SetTextValueL(
+                KMPXMediaGeneralTitle,
+                listBoxMedia.ValueText(
+                    KMPXMediaGeneralTitle));
+            entry->SetTObjectValueL(KMPXMediaGeneralType, EMPXItem);
+            entry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXSong);
+
+            if (listBoxMedia.IsSupported(KMPXMediaGeneralId))
+                {
+                entry->SetTObjectValueL(KMPXMediaGeneralId,
+                    listBoxMedia.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));
+                }
+            else
+                {
+                User::Leave(KErrArgument);
+                }
+
+            entry->SetTObjectValueL(KMPXMediaGeneralCollectionId, id);
+
+            mediaArray->AppendL(entry);
+            CleanupStack::Pop(entry);
+            }
+        aMedia->SetTObjectValueL(KMPXMediaGeneralCollectionId, id);
+
+        aMedia->SetCObjectValueL(KMPXMediaArrayContents,
+            mediaArray);
+        aMedia->SetTObjectValueL(KMPXMediaArrayCount,
+            mediaArray->Count());
+        CleanupStack::PopAndDestroy(mediaArray);
+        }
+    else
+        {
+        ret = KErrArgument;
+        }
+    return ret;
+    }
+
+// ---------------------------------------------------------------------------
+// Set/clears the flags for item in database
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::UpdateDatabaseFlagL(TInt aIndex,
+                                                       const CMPXMedia& aMedia,
+                                                       TUint aFlag,
+                                                       TBool aSet,
+                                                       TBool aEnableInfoDialog)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::UpdateDatabaseFlagL");
+    CMPXCommonListBoxArrayBase* array = iContainer->Common()->ListBoxArray();
+    if (array)
+        {
+        // set the item as invalid
+        TUint flags(0);
+        if (aSet)
+            {
+            flags = KMPXMediaGeneralFlagsSetOrUnsetBit;
+            }
+        flags |= aFlag;
+
+        MPX_DEBUG2("CMPXPodcastCollectionViewImp::UpdateDatabaseFlagL flag after 0x%x", flags);
+        CMPXMedia* entry = CMPXMedia::NewL();
+        CleanupStack::PushL(entry);
+        if (aIndex > KErrNotFound)
+            {
+            MPX_DEBUG2("CMPXPodcastCollectionViewImp::UpdateDatabaseFlagL using aIndex = %d", aIndex);
+            const CMPXMedia& media = array->MediaL(aIndex);
+
+            TMPXItemId id( 0 );
+            TMPXGeneralType type( EMPXNoType );
+            TMPXGeneralCategory category( EMPXNoCategory );
+
+            if (media.IsSupported(KMPXMediaGeneralId))
+                {
+                id = media.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
+                }
+
+            if (media.IsSupported(KMPXMediaGeneralType))
+                {
+                type =
+                    media.ValueTObjectL<TMPXGeneralType>(KMPXMediaGeneralType);
+                }
+
+            if (media.IsSupported(KMPXMediaGeneralCategory))
+                {
+                category =
+                    media.ValueTObjectL<TMPXGeneralCategory>(KMPXMediaGeneralCategory);
+                }
+
+            entry->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, id);
+            entry->SetTObjectValueL<TMPXGeneralType>(
+                KMPXMediaGeneralType,
+                type);
+            entry->SetTObjectValueL<TMPXGeneralCategory>(KMPXMediaGeneralCategory,
+                category);
+            }
+        else
+            {
+            // try to look for the info inside aMedia
+            if (aMedia.IsSupported(KMPXMediaGeneralId))
+                {
+                TMPXItemId id( aMedia.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId) );
+                entry->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, id);
+                }
+            if (aMedia.IsSupported(KMPXMediaGeneralType))
+                {
+                TMPXGeneralType type(
+                    aMedia.ValueTObjectL<TMPXGeneralType>(
+                        KMPXMediaGeneralType) );
+                entry->SetTObjectValueL<TMPXGeneralType>(
+                    KMPXMediaGeneralType,
+                    type);
+                }
+            if (aMedia.IsSupported(KMPXMediaGeneralCategory))
+                {
+                TMPXGeneralCategory category(
+                    aMedia.ValueTObjectL<TMPXGeneralCategory>(KMPXMediaGeneralCategory) );
+                entry->SetTObjectValueL<TMPXGeneralCategory>(KMPXMediaGeneralCategory,
+                    category);
+                }
+            }
+
+        TUid collectionId = TUid::Uid(0);
+        if (aMedia.IsSupported(KMPXMediaGeneralCollectionId))
+            {
+            collectionId = aMedia.ValueTObjectL<TUid>(KMPXMediaGeneralCollectionId);
+            }
+        else
+            {
+            User::Leave(KErrArgument);
+            }
+
+        entry->SetTObjectValueL<TUid>(KMPXMediaGeneralCollectionId,
+            collectionId);
+        entry->SetTObjectValueL<TUint>(KMPXMediaGeneralFlags, flags);
+        DoSetCollectionL( entry, ETrue );
+        CleanupStack::PopAndDestroy(entry);
+        }
+    if (aEnableInfoDialog)
+        {
+        if (KMPXMediaGeneralFlagsIsInvalid == aFlag)
+            {
+            iCommonUiHelper->DisplayInfoNoteL(R_MPX_COLLECTION_INFO_FILE_NOT_FOUND);
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// Handle playback message
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::DoHandlePlaybackMessageL( const CMPXMessage& aMessage )
+    {
+    MPX_FUNC( "CMPXPodcastCollectionViewImp::DoHandlePlaybackMessageL" );
+    TMPXMessageId id( aMessage.ValueTObjectL<TMPXMessageId>( KMPXMessageGeneralId ) );
+    if ( KMPXMessageGeneral == id )
+        {
+        TInt type( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralType ) );
+        TInt data( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralData ) );
+        switch ( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) )
+            {
+            case TMPXPlaybackMessage::EActivePlayerChanged:
+            case TMPXPlaybackMessage::EStateChanged:
+                {
+                MPX_DEBUG2("CMPXPodcastCollectionViewImp::DoHandlePlaybackMessageL - EStateChanged(%d)", type );
+                UpdatePlaybackStatusL(ETrue);
+                break;
+                }
+            case TMPXPlaybackMessage::EError:
+                {
+                if (iCommonUiHelper)
+                    {
+                    iCommonUiHelper->DismissWaitNoteL();
+                    HandleCommandL( EMPXCmdHandleExternalCommand );
+                    }
+                if (iProgressDialog)
+					{
+					iProgressDialog->ProcessFinishedL();
+					}
+                if (iIsDeleting)
+                    {
+                    iCollectionUiHelper->Cancel();
+                    iIsDeleting = EFalse;
+                    // if delete is interrupted, reopen
+                    iCollectionUtility->Collection().OpenL();
+                    }
+                MPX_DEBUG2("CMPXCollectionViewImp::DoHandlePlaybackMessageL Error = %d", data );
+                break;
+                }
+            case TMPXPlaybackMessage::EPlayerUnavailable:
+                {
+//#ifdef __UPNP_FRAMEWORK_2_0_
+                if ( iUpnpFrameworkSupport )
+                    {
+                    if ( data == KErrNotFound)
+                        {
+                        if ( iViewUtility->ActiveViewType() ==
+                            TUid::Uid( KMPXPluginTypeCollectionUid ) )
+                            {
+                            if ( iSubPlayerName )
+                                {
+                                HBufC* dialogText = StringLoader::LoadLC(
+                                    R_MPX_COLLECTION_NOTE_REMOTE_CONNECTION_FAILED,
+                                    *iSubPlayerName);
+                                CAknErrorNote* errNote = new(ELeave) CAknErrorNote(ETrue);
+                                errNote->SetTimeout(CAknNoteDialog::ELongTimeout);
+                                errNote->ExecuteLD( *dialogText );
+                                CleanupStack::PopAndDestroy( dialogText );
+                                }
+                            }
+                        }
+                    }
+//#endif // __UPNP_FRAMEWORK_2_0_
+                break;
+                }
+            default:
+                {
+                break;
+                }
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// Handle collection message
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::DoHandleCollectionMessageL( const CMPXMessage& aMessage )
+    {
+    MPX_FUNC( "CMPXPodcastCollectionViewImp::DoHandleCollectionMessageL" );
+    TMPXMessageId id( aMessage.ValueTObjectL<TMPXMessageId>( KMPXMessageGeneralId ) );
+    if ( KMPXMessageGeneral == id )
+        {
+        TInt event( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) );
+        TInt type( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralType ) );
+        TInt data( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralData ) );
+        MPX_DEBUG3( "CMPXPodcastCollectionViewImp::HandleCollectionMessage Event = %d, Type() = %d",
+            event, type );
+
+        // Only handle collection messages while collection view is in focus
+        // and not transitioning views
+        if( iContainer )
+            {
+            if ( event == TMPXCollectionMessage::EPathChanged &&
+                type == EMcPathChangedByOpen &&
+                data == EMcContainerOpened)
+                { // Open new entries
+                iCollectionUtility->Collection().OpenL();
+                }
+            else if ( event == TMPXCollectionMessage::EPathChanged &&
+                     type == EMcPathChangedByCollectionChange)
+                {
+                if(!iIsDeleting)
+                    {
+                     // Re-Fetch entries only if we are in playlist
+                    iCollectionUtility->Collection().OpenL();
+                    }
+                }
+            else if ( event == TMPXCollectionMessage::EPathChanged &&
+                     type == EMcPathChangedByOpen &&
+                     data == EMcItemOpened)
+                {
+                // opened a song, revert back one level
+                iBackOneLevel = ETrue;
+                }
+            else if( event == TMPXCollectionMessage::EBroadcastEvent &&
+                     iViewUtility->ActiveViewType() != TUid::Uid(KMPXPluginTypeWaitNoteDialogUid))
+                {
+                MPX_DEBUG2( "CMPXPodcastCollectionViewImp::DoHandleCollectionMessageL - broadcast type = %d", type );
+                if ( type == EMcMsgDiskRemoved )
+                    {
+                    AknDialogShutter::ShutDialogsL( *CEikonEnv::Static() );
+                    }
+                }
+#ifdef __COVER_DISPLAY                          
+            else if ( event == TMPXCollectionMessage::EFocusChanged )
+                {
+                if ( data != KErrNotFound &&
+                    data < iContainer->Common()->CurrentListItemCount() &&
+                    !iIgnoreNextFocusChangedMessage )
+                    {
+                    iContainer->Common()->SetLbxCurrentItemIndexAndDraw( data );
+                    }
+                iIgnoreNextFocusChangedMessage = EFalse;
+                }
+#endif // __COVER_DISPLAY                            
+            // else ignore
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMPXAlbumArtEditorDialog::DoSetCollectionL
+// Perform a set operation
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::DoSetCollectionL( CMPXMedia* aMedia, TBool aSync )
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::DoSetCollectionL");
+    CMPXCommand* cmd = CMPXCommand::NewL();
+    CleanupStack::PushL( cmd );
+
+    cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdCollectionSet );
+    cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, aSync );
+    TUid colId( aMedia->ValueTObjectL<TUid>(KMPXMediaGeneralCollectionId) );
+    cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, colId.iUid );
+    cmd->SetCObjectValueL<CMPXMedia>( KMPXCommandColSetMedia, aMedia );
+
+    iCollectionUtility->Collection().CommandL( *cmd );
+    CleanupStack::PopAndDestroy( cmd );
+    }
+
+#ifdef __ENABLE_MSK
+// ---------------------------------------------------------------------------
+// Updates the middle softkey display
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::UpdateMiddleSoftKeyDisplayL(TInt aMskId)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::UpdateMiddleSoftKeyDisplayL");
+    if (iContainer)
+        {
+        CEikButtonGroupContainer* cba = Cba();
+        if (cba)
+            {
+            if (!iContainer->Common()->CurrentListItemCount()) // list is empty
+                {
+                iCommonUiHelper->RemoveMiddleSoftKeyLabel(*cba);
+                MPX_DEBUG1("CMPXPodcastCollectionViewImp::UpdateMiddleSoftKeyDisplayL - remove label, list is empty");
+                }
+            else if (iContainer->Common()->CurrentSelectionIndicesL()->Count()) // marked items
+			{
+            CFbsBitmap* bitmap = NULL;
+            CFbsBitmap* mask = NULL;
+            AknsUtils::CreateColorIconL(
+                AknsUtils::SkinInstance(), 
+                KAknsIIDQgnPropMskMenu, 
+                KAknsIIDQsnComponentColors, 
+                EAknsCIQsnComponentColorsCG13,
+                bitmap, 
+                mask,
+                AknIconUtils::AvkonIconFileName(),
+                EMbmAvkonQgn_prop_msk_menu, 
+                EMbmAvkonQgn_prop_msk_menu_mask, 
+                KRgbBlack); 
+
+            CleanupStack::PushL(bitmap);
+            CleanupStack::PushL(mask);
+        
+            // set middle softkey icon 
+            iCommonUiHelper->SetMiddleSoftKeyIconL(*cba, bitmap, mask);
+        
+            CleanupStack::PopAndDestroy(2, bitmap);
+            MPX_DEBUG1("CMPXPodcastCollectionViewImp::UpdateMiddleSoftKeyDisplayL - items marked, show icon");
+			}
+            else
+                {
+                iCommonUiHelper->SetMiddleSoftKeyLabelL(
+                    *cba,
+                    aMskId,
+                    EAknSoftkeyForwardKeyEvent);
+                iCurrentMskId = aMskId;
+                MPX_DEBUG1("CMPXPodcastCollectionViewImp::UpdateMiddleSoftKeyDisplayL - new label displayed");
+                }
+            cba->DrawDeferred();
+            }
+        }
+    }
+#endif // __ENABLE_MSK
+
+// ---------------------------------------------------------------------------
+// From MProgressDialogCallback
+// Callback method. Get's called when a dialog is dismissed
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::DialogDismissedL(TInt aButtonId)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::DialogDismissedL");
+    switch (aButtonId)
+        {
+        case EAknSoftkeyCancel:
+            {
+            iIsWaitNoteCanceled = ETrue;
+            if(iIsDeleting)
+                {
+                iCollectionUiHelper->Cancel();
+                iIsDeleting = EFalse;
+                // if delete is interrupted, reopen
+                iCollectionUtility->Collection().OpenL();
+                }
+
+            break;
+            }
+        default:
+            {
+            break;
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// From MMPXCollectionObserver
+// Handle collection message
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandleCollectionMessage(
+    CMPXMessage* aMessage, TInt aError )
+    {
+    if ( aError == KErrNone && aMessage )
+        {
+        TRAP_IGNORE( DoHandleCollectionMessageL( *aMessage ) );
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// From MMPXCollectionObserver
+// Handles the collection entries being opened. Typically called
+// when client has Open()'d a folder
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandleOpenL(
+    const CMPXMedia& aEntries,
+    TInt aIndex,
+    TBool /*aComplete*/,
+    TInt aError)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::HandleOpenL 4");
+    iHandlingKeyEvent = EFalse;
+
+    if(aError == KErrNone)
+        {
+        if ( !iContainer )
+            {
+            // View is not active. Ignore.
+            return;
+            }
+#ifdef __ENABLE_MSK
+        TInt mskId(R_QTN_MSK_OPEN);
+    TMPXPodcastCategory pCategory = aEntries.ValueTObjectL<TMPXPodcastCategory>(KMPXMediaPodcastCategoryGroup);
+    TMPXPodcastType pType = aEntries.ValueTObjectL<TMPXPodcastType>(KMPXMediaPodcastType);
+    if ((pCategory == EMPXAll) || (pCategory == EMPXRecentlyAdded) ||
+        (pCategory == EMPXNotYetPlayed)||
+        ((pCategory == EMPXEpisode) && (pType == EMPXPodcastItem)))
+        {
+		    mskId = R_QTN_MSK_PLAY;
+		    }
+#endif // __ENABLE_MSK
+        UpdateOptionMenuL();
+        MPX_DEBUG2("CMPXPodcastCollectionViewImp::HandleOpenL Number of Entries: %d", aEntries.Count());
+        UpdateListBoxL(const_cast<CMPXMedia&>(aEntries), aIndex);
+
+        delete iNumEpisode;
+        iNumEpisode = NULL;
+
+        if(aEntries.IsSupported(KMPXMediaGeneralCount))
+            {
+            CMPXMediaArray* mediaArray =
+                const_cast<CMPXMediaArray*>(aEntries.Value<CMPXMediaArray>(KMPXMediaArrayContents));
+            User::LeaveIfNull(const_cast<CMPXMediaArray*>(mediaArray));
+             
+            TInt number( mediaArray->Count() );
+            HBufC* text( NULL );
+
+            if (number == 1)
+                {
+                text = StringLoader::LoadLC(R_MPX_QTN_NMP_ONE_EPISODE);
+                }
+            else if (number > 1)
+                {
+                text = StringLoader::LoadLC(R_MPX_QTN_NMP_NUM_EPISODES, number);
+                }
+            // else ignore
+
+            if ((mskId == R_QTN_MSK_PLAY) && (number <= 0))
+                    {
+                    mskId = 0;
+                    }
+            if (number >= 1)
+                {
+#ifdef __ENABLE_MSK
+#endif // __ENABLE_MSK
+                iNumEpisode = text->Alloc();
+                CleanupStack::PopAndDestroy(text);
+                }
+            }
+
+        UpdateNaviPaneL();
+
+        if ( iContainer )
+            {
+            // this has to be done after the list box media is properly
+            // updated
+            if ( !iContainer->Common()->FindBoxVisibility() )
+                {
+                MPX_DEBUG1( "CMPXPodcastCollectionViewImp::HandleOpenL find box not visible" );
+
+                CEikButtonGroupContainer* cba = Cba();
+                if ( cba )
+                    {
+#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
+                    cba->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK );
+#else
+                    cba->SetCommandSetL(
+                        ( iViewUtility->ViewHistoryDepth() == 1) ?
+                        R_AVKON_SOFTKEYS_OPTIONS_EXIT : R_AVKON_SOFTKEYS_OPTIONS_BACK );
+
+#endif
+
+    #ifdef __ENABLE_MSK
+                    if (mskId != 0)
+                        {
+                        UpdateMiddleSoftKeyDisplayL(mskId);
+                        }
+    #endif // __ENABLE_MSK
+
+                    cba->DrawDeferred();
+                    }
+                }
+            else
+                {
+                MPX_DEBUG1( "CMPXPodcastCollectionViewImp::HandleOpenL find box visible" );
+                }
+
+            CMPXCommonListBoxArrayBase* array(
+                iContainer->Common()->ListBoxArray() );
+            const CMPXMedia& containerMedia = array->ContainerMedia();
+
+            delete iTitle;
+            iTitle = NULL;
+
+            if (containerMedia.IsSupported( KMPXMediaGeneralTitle ))
+                {
+                iTitle =
+                    containerMedia.ValueText( KMPXMediaGeneralTitle ).AllocL();
+                }
+            UpdateTitlePaneL();
+            }
+
+        iHandleOpenProcessed = ETrue;
+        }
+    else
+        {
+		if ( iContainer )
+            {
+            CEikButtonGroupContainer* cba = Cba();
+            if ( cba )
+                {
+#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
+                cba->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK );
+#else
+                cba->SetCommandSetL(
+                    ( iViewUtility->ViewHistoryDepth() == 1 ) ?
+                    R_AVKON_SOFTKEYS_OPTIONS_EXIT : R_AVKON_SOFTKEYS_OPTIONS_BACK );
+#endif
+                cba->DrawDeferred();
+                }
+            }
+
+        HandleErrorL(aError);
+        }
+
+    if (iIsDeleting)
+        {
+        // nothing else to delete
+        iIsDeleting = EFalse;
+        if (iProgressDialog)
+			{
+			iProgressDialog->ProcessFinishedL();
+			}
+        HandleCommandL( EMPXCmdHandleExternalCommand );
+        }
+    MPX_PERF_CHECKPT("Collection View opened");
+    }
+
+// ---------------------------------------------------------------------------
+// From MMPXCollectionObserver
+// Handles the collection entries being opened. Typically called
+// when client has Open()'d an item. Client typically responds by
+// 'playing' the item
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandleOpenL(
+    const CMPXCollectionPlaylist& /*aPlaylist*/,
+    TInt /*aError*/)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::HandleOpenL 2");
+    iHandlingKeyEvent = EFalse;
+    // Do Nothing: playback/fetch client should handle this stage
+    }
+
+// ---------------------------------------------------------------------------
+// From MMPXCollectionObserver
+// Handle media properties
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandleCollectionMediaL(
+    const CMPXMedia& aMedia,
+    TInt aError)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::HandleCollectionMediaL");
+    if (aError == KErrNone)
+        {
+        switch (iCurrentMediaLOp)
+            {
+            case EMPXOpMediaLGetContainerInfo:
+                {
+                delete iTitle;
+                iTitle = NULL;
+
+                TMPXGeneralType type = EMPXNoType;
+                if (aMedia.IsSupported(KMPXMediaGeneralType))
+                    {
+                    type =
+                        aMedia.ValueTObjectL<TMPXGeneralType>(KMPXMediaGeneralType);
+                    }
+
+                if (aMedia.IsSupported(KMPXMediaGeneralTitle) &&
+                    type != EMPXItem)
+                    {
+                    iTitle = aMedia.ValueText(KMPXMediaGeneralTitle).AllocL();
+                    MPX_DEBUG2("CMPXPodcastCollectionViewImp::HandleCollectionMediaL Title is %S", iTitle);
+                    }
+                UpdateTitlePaneL();
+                break;
+                }
+            case EMPXOpMediaLSongDetailsFileCheck:
+                {
+                const TDesC& location = aMedia.ValueText(KMPXMediaGeneralUri);
+
+                TInt currentLbxItemIndex(
+                    iContainer->Common()->CurrentLbxItemIndex());
+
+                if (location.Length() == 0 || ConeUtils::FileExists(location))
+                    {
+                    HBufC* buf = HBufC::NewLC(5); // magic number
+                    buf->Des().AppendNum(currentLbxItemIndex);
+                    // Activate metadata editor dialog via View Framework
+                    iViewUtility->ActivateViewL(
+                        TUid::Uid(KMPXPluginTypeMetadataEditorUid), buf);
+                    CleanupStack::PopAndDestroy(buf);
+                    }
+                else
+                    {
+                    // mark database for invalid
+                    UpdateDatabaseFlagL(currentLbxItemIndex,
+                        aMedia, KMPXMediaGeneralFlagsIsInvalid, ETrue);
+                    }
+                break;
+                }
+            case EMPXOpMediaLSend:
+                {
+                DoHandleSendL(aMedia, aError);
+                break;
+                }
+            case EMPXOpMediaLCollectionDetails:
+                {
+                ShowCollectionDetailsL(aMedia);
+                break;
+                }
+//#ifdef __UPNP_FRAMEWORK_2_0_
+            case EMPXOpMediaLCopyToRemote:
+                {
+                if ( iUpnpFrameworkSupport )
+                    {
+                    DoHandleCopyToRemoteL( aMedia );
+                    }
+                break;
+                }
+//#endif //__UPNP_FRAMEWORK_2_0_
+            default:
+                {
+                break;
+                }
+            }
+        }
+    else
+        {
+        HandleErrorL(aError);
+        }
+    iCurrentMediaLOp = EMPXOpMediaLIdle;
+    }
+
+// ---------------------------------------------------------------------------
+// From MMPXCHelperObserver
+// Handles the completion of helper events
+// ---------------------------------------------------------------------------
+//
+
+void CMPXPodcastCollectionViewImp::HandleOperationCompleteL(
+                                           TCHelperOperation aOperation,
+                                           TInt aErr,
+                                           void* aArgument)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::HandleOperationCompleteL");
+    switch(aOperation)
+        {
+        case EDeleteOp:
+            {
+            // do not dismiss the wait note until HandleOpenL is called,
+            if(aErr == KErrInUse)
+                {
+                iIsDeleting = EFalse;
+				if (iProgressDialog)
+					{
+					iProgressDialog->ProcessFinishedL();
+					}
+                HandleCommandL( EMPXCmdHandleExternalCommand );
+                aErr = KErrNone; //handled here
+                HBufC* text(NULL);
+                if(iContainer->Common()->CurrentSelectionIndicesL()->Count() == 0)
+                    {
+                    // Single selection
+                    text = StringLoader::LoadLC(R_MPX_COLLECTION_NOTE_DELETE_FAIL);
+                    }
+                else
+                    {
+                    // Multi selection
+                    text = StringLoader::LoadLC(
+                        R_MPX_COLLECTION_NOTE_DELETE_FAIL_MULTI_SELECTION);
+                    }
+
+                CAknErrorNote* dlg = new (ELeave) CAknErrorNote(ETrue);
+                dlg->ExecuteLD(*text);
+                CleanupStack::PopAndDestroy(text);
+                }
+            else if (aErr != KErrNone)
+                {
+                iIsDeleting = EFalse;
+                if(!iIsWaitNoteCanceled)
+                    {
+                    if (iProgressDialog)
+                    	{
+						iProgressDialog->ProcessFinishedL();
+						}
+                    HandleCommandL( EMPXCmdHandleExternalCommand );
+                    iIsWaitNoteCanceled = EFalse;
+                    }
+
+                HandleErrorL(aErr);
+                }
+            // else do nothing
+
+            iContainer->Common()->ClearLbxSelection();
+
+             // reopen collection
+            iCollectionUtility->Collection().OpenL();
+            break;
+            }
+        case EDeleteStatusOp:
+            {
+            if ( aArgument )
+                {
+                CMPXMedia* media = (CMPXMedia*)aArgument;
+                CleanupStack::PushL( media );
+                if ( media->IsSupported( KMPXMediaGeneralCount ) )
+                    {
+                    TInt deletePercent = media->ValueTObjectL<TInt>( KMPXMediaGeneralCount );
+                    MPX_DEBUG2( "CMPXCollectionViewImp::HandleOperationCompleteL % Files Deleted: %d", deletePercent );
+                    // update WaitNote dialog.
+                    HBufC* string = StringLoader::LoadLC(R_MPX_QTN_NMP_DEL_BATCH_SONGS_WAIT_NOTE, deletePercent);
+                    TPtr buf = string->Des();
+
+                    UpdateProcessL(deletePercent, buf);
+                    CleanupStack::PopAndDestroy( string );
+                    }
+                CleanupStack::PopAndDestroy( media );
+                aArgument = NULL;
+                }
+            break;
+            }
+        case ERenameOp: // fall through
+        case ESetOp:
+        case EAddOp:
+        default:
+        break;
+        }
+
+
+    if(aArgument)
+        {
+        delete (CBase*)aArgument;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// From MMPXPlaybackObserver
+// Handle playback message.
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandlePlaybackMessage(
+    CMPXMessage* aMessage, TInt aError )
+    {
+    if ( aError == KErrNone && aMessage )
+        {
+        TRAP_IGNORE( DoHandlePlaybackMessageL( *aMessage ) );
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// From MMPXPlaybackCallback
+// Handle playback property.
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandlePropertyL(
+    TMPXPlaybackProperty /*aProperty*/,
+    TInt /*aValue*/,
+    TInt /*aError*/)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::HandlePropertyL");
+    }
+
+// ---------------------------------------------------------------------------
+// From MMPXPlaybackCallback
+// Method is called continously until aComplete=ETrue, signifying that
+// it is done and there will be no more callbacks
+// Only new items are passed each time
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandleSubPlayerNamesL(
+    TUid /* aPlayer */,
+    const MDesCArray* /* aSubPlayers */,
+    TBool /* aComplete */,
+    TInt /* aError */)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::HandleSubPlayerNamesL");
+    // do nothing
+    }
+
+// ---------------------------------------------------------------------------
+// From MMPXPlaybackCallback
+// Handle media event.
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandleMediaL(
+    const CMPXMedia& /*aMedia*/,
+    TInt /*aError*/)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::HandleMediaL");
+    // do nothing
+    }
+
+// ---------------------------------------------------------------------------
+// From CAknView
+// Returns views id.
+// ---------------------------------------------------------------------------
+//
+TUid CMPXPodcastCollectionViewImp::Id() const
+    {
+    return TUid::Uid(KMPXPodcastCollectionViewId);
+    }
+
+// ---------------------------------------------------------------------------
+// From CAknView
+// Command handling function.
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandleCommandL(TInt aCommand)
+    {
+    MPX_DEBUG2("CMPXPodcastCollectionViewImp::HandleCommandL(%d) entering",
+        aCommand);
+
+    switch (aCommand)
+        {
+        case EAknCmdMark:
+        case EAknCmdUnmark:
+        case EAknMarkAll:
+        case EAknUnmarkAll:
+            {
+            // Custom handling of markable lists
+            iContainer->Common()->HandleMarkableListProcessCommandL(
+                aCommand );
+#ifdef __ENABLE_MSK
+            // Determine middle soft key labeling
+            UpdateMiddleSoftKeyDisplayL(iCurrentMskId);
+#endif // __ENABLE_MSK
+            break;
+            }
+        case EMPXCmdGoToNowPlaying:
+            {
+            AppUi()->HandleCommandL( aCommand );
+            break;
+            }
+        case EMPXCmdAddSongs:
+            {
+            iViewUtility->ActivateViewL(
+                TUid::Uid(KMPXPluginTypeAddSongsEditorUid));
+            iCollectionUtility->Collection().OpenL();
+            break;
+            }
+        case EMPXCmdDelete: // fall through
+        case EMPXCmdRemove:
+            {
+            StoreListboxItemIndexL();
+            DeleteSelectedItemsL();
+            break;
+            }
+        case EMPXCmdSend:
+            {
+            DoSendL();
+            break;
+            }
+        case EMPXCmdEpisodeDetails:
+            {
+            StoreListboxItemIndexL();
+            
+            iCurrentMediaLOp = EMPXOpMediaLSongDetailsFileCheck;
+
+            iSelectedItem = KMPXInvalidItemId;
+            TInt currentIndex = iContainer->Common()->CurrentLbxItemIndex();
+            CMPXCommonListBoxArrayBase* listboxArray = iContainer->Common()->ListBoxArray();
+            const CMPXMedia& currentSelectedMedia = listboxArray->MediaL(currentIndex);
+            iSelectedItem = currentSelectedMedia.ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );
+            CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();
+            CleanupStack::PushL(path);
+
+            path->Set(iContainer->Common()->CurrentLbxItemIndex());
+
+            RArray<TMPXAttribute> attrs;
+            CleanupClosePushL(attrs);
+            attrs.Append(
+                TMPXAttribute(KMPXMediaIdGeneral,
+                    EMPXMediaGeneralUri | EMPXMediaGeneralCollectionId));
+            iCollectionUtility->Collection().MediaL(*path, attrs.Array());
+            CleanupStack::PopAndDestroy(&attrs);
+            CleanupStack::PopAndDestroy(path);
+            break;
+            }
+        case EMPXCmdPodcasting:
+            {
+            LaunchPodcastAppL();
+            break;
+            }
+        case EMPXCmdLibraryDetails:
+            {
+            iCurrentMediaLOp = EMPXOpMediaLCollectionDetails;
+            CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();
+            CleanupStack::PushL(path);
+            RArray<TMPXAttribute> attrs;
+            CleanupClosePushL(attrs);
+            attrs.Append(KMPXMediaColDetailNumberOfItems);
+            attrs.Append(KMPXMediaColDetailDuration);
+            attrs.Append(KMPXMediaColDetailLastRefreshed);
+            path->Back();
+            iCollectionUtility->Collection().MediaL(*path, attrs.Array());
+            CleanupStack::PopAndDestroy(&attrs);
+            CleanupStack::PopAndDestroy(path);
+            break;
+            }
+         case EMPXCmdSetPlayed:
+            {
+            SetPlayedStatusL( ETrue );
+            break;
+            }
+        case EMPXCmdSetUnplayed:
+            {
+            SetPlayedStatusL( EFalse );
+            break;
+            }
+        case EAknCmdHelp:
+            {
+            HlpLauncher::LaunchHelpApplicationL(
+                iEikonEnv->WsSession(),
+                AppUi()->AppHelpContextL());
+            break;
+            }
+        case EAknSoftkeyBack:
+            {
+            if(!iHandlingKeyEvent)
+                {
+                iContainer->Common()->ClearLbxSelection();
+                CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();
+                CleanupStack::PushL(cpath);
+                TInt currentDepth = cpath->Levels();
+                cpath->Back();
+                cpath->Back();
+
+#ifndef __ENABLE_PODCAST_IN_MUSIC_MENU
+                iCollectionUtility->Collection().BackL();
+#endif
+
+                if (currentDepth == 2)
+                    {
+#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
+                    // open the podcast collection db plugin
+                    CMPXCollectionPath* mainPodcastMenu = CMPXCollectionPath::NewL();
+                    CleanupStack::PushL( mainPodcastMenu );
+                    mainPodcastMenu->AppendL(KMusicCollectionUid);
+                    iCollectionUtility->Collection().OpenL( *mainPodcastMenu );
+                    CleanupStack::PopAndDestroy( mainPodcastMenu );
+
+                    // activate the podcast collection view
+                    RArray<TUid> uids;
+                    CleanupClosePushL( uids );
+                    uids.AppendL( TUid::Uid( KMPXPluginTypeCollectionUid ) );
+                    uids.AppendL( TUid::Uid( KMusicCollectionUid ));
+                    iViewUtility->ActivateViewL(uids);
+
+                    CleanupStack::PopAndDestroy( &uids );
+#else
+                    AppUi()->HandleCommandL(aCommand);
+#endif
+                    }
+                else if (currentDepth == 3) // jumping back to the main podcast menu
+                    {
+#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
+                    iCollectionUtility->Collection().BackL();
+#endif
+                    RArray<TMPXAttribute> attrs;
+                    CleanupClosePushL(attrs);
+                    iHandlingKeyEvent = ETrue;
+                    iCurrentMediaLOp = EMPXOpMediaLGetContainerInfo;
+                    attrs.Append(
+                        TMPXAttribute(KMPXMediaIdGeneral,
+                            EMPXMediaGeneralDuration|
+                            EMPXMediaGeneralCount));
+                    attrs.Append(
+                        TMPXAttribute(KMPXMediaIdPodcast,
+                            EMPXMediaPodcastType|
+                            EMPXMediaPodcastCategoryGroup));
+                    iCollectionUtility->Collection().MediaL(*cpath, attrs.Array());
+                    CleanupStack::PopAndDestroy(&attrs);
+                    iBackOneLevel = ETrue;
+                    }
+                else
+                    {
+#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
+                    iCollectionUtility->Collection().BackL();
+#endif
+                    RArray<TMPXAttribute> attrs;
+                    CleanupClosePushL(attrs);
+                    iHandlingKeyEvent = ETrue;
+                    iCurrentMediaLOp = EMPXOpMediaLGetContainerInfo;
+                    attrs.Append(
+                        TMPXAttribute(KMPXMediaIdGeneral,
+                            EMPXMediaGeneralTitle |
+                            EMPXMediaGeneralDuration |
+                            EMPXMediaGeneralCount));
+                    attrs.Append(
+                        TMPXAttribute(KMPXMediaIdPodcast,
+                            EMPXMediaPodcastType |
+                            EMPXMediaPodcastCategoryGroup));
+                    iCollectionUtility->Collection().MediaL(*cpath, attrs.Array());
+                    CleanupStack::PopAndDestroy(&attrs);
+                    iBackOneLevel = ETrue;
+                    }
+                CleanupStack::PopAndDestroy(cpath);
+                }
+            else
+                {
+                MPX_DEBUG1("CMPXPodcastCollectionViewImp::HandleCommandL Busy, ignoring command");
+                }
+            break;
+            }
+        case EAknCmdExit:
+        case EAknSoftkeyExit:
+            {
+            AppUi()->HandleCommandL( aCommand );
+            break;
+            }
+//#ifdef __UPNP_FRAMEWORK_2_0_
+        case EMPXCmdUpnpPlayViaLocal:
+            {
+            if ( iUpnpFrameworkSupport )
+                {
+                SelectNewPlayerL( aCommand );
+                }
+            break;
+            }
+        case EMPXCmdUPnPAiwCmdCopyToExternalCriteria:
+            {
+            if ( iUpnpFrameworkSupport )
+                {
+                CopySelectedItemsToRemoteL();
+                }
+            break;
+            }
+//#endif //__UPNP_FRAMEWORK_2_0_
+        case EMPXCmdPlay:
+        case EMPXCmdPlayPause:
+            {
+            TMPXPlaybackState state(iPlaybackUtility->StateL());
+            if ((EPbStateNotInitialised == state ||
+                EPbStateStopped == state) &&
+                iContainer->Common()->CurrentListItemCount() > 0)
+                {
+                // Needed to reset the status of iPreservedState
+                if ( EPbStateStopped == state )
+                    {
+                    iPlaybackUtility->CommandL(EPbCmdResetPreserveState);
+                    }
+
+                RArray<TMPXAttribute> attrs;
+                CleanupClosePushL(attrs);
+
+                // specifying this attribute acts as a signal to the
+                // podcast collection plugin that this media file
+                // is currently being played
+
+                TInt currentItem(iContainer->Common()->CurrentLbxItemIndex());
+                MPX_DEBUG2("CMPXPodcastCollectionViewImp::HandleCommandL playing index %d", currentItem);
+                if (currentItem != KErrNotFound)
+                    {
+                    iCollectionUtility->Collection().OpenL(currentItem, attrs.Array(), EMPXOpenPlaylistOnly);
+                    }
+                // else ignore
+                CleanupStack::PopAndDestroy(&attrs);
+                }
+            else
+                {
+                AppUi()->HandleCommandL(aCommand);
+                }
+            break;
+            }
+        case EMPXCmdPause:
+        case EMPXCmdStop:
+        case EMPXCmdNext:
+        case EMPXCmdPrevious:
+        case EMPXCmdSeekForward:
+        case EMPXCmdSeekBackward:
+        case EMPXCmdStopSeeking:
+        case EMPXCmdVolumeUp:
+        case EMPXCmdVolumeDown:
+            {
+            AppUi()->HandleCommandL(aCommand);
+            break;
+            }
+        default:
+            {
+            MPX_PERF_CHECKPT("Handle Collection view unknown command");
+//#ifdef __UPNP_FRAMEWORK_2_0_
+            if ( iUpnpFrameworkSupport )
+                {
+                if (aCommand >= EMPXCmdUpnpPlayViaRemotePlayer  &&
+                     aCommand < EMPXCmdUpnpLastCommandId)
+                    {
+                    SelectNewPlayerL(aCommand);
+                    }
+                else
+                    {
+                    AppUi()->HandleCommandL(aCommand);
+                    }
+                }
+            else
+                {
+                AppUi()->HandleCommandL(aCommand);
+                }
+//#endif //__UPNP_FRAMEWORK_2_0_
+            break;
+            }
+        }
+    MPX_DEBUG1("CMPXPodcastCollectionViewImp::HandleCommandL() exiting");
+    }
+
+// ---------------------------------------------------------------------------
+// From CAknView
+// Handles a view activation.
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::DoActivateL(
+    const TVwsViewId& /* aPrevViewId */,
+    TUid /* aCustomMessageId */,
+    const TDesC8& /* aCustomMessage */)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::DoActivateL()");
+
+    iHandleOpenProcessed = EFalse;
+
+    // Add view deactivation observer
+    AppUi()->AddViewDeactivationObserverL( this );
+
+    // Set status pane layout if switched here directly from another view,
+    // such as when using the AnyKey
+    StatusPane()->MakeVisible(ETrue);
+    if ( StatusPane()->CurrentLayoutResId() != R_AVKON_STATUS_PANE_LAYOUT_USUAL )
+        {
+        StatusPane()->SwitchLayoutL(R_AVKON_STATUS_PANE_LAYOUT_USUAL);
+        }
+
+    if ( !iContainer )
+        {
+        iContainer = CMPXPodcastCollectionViewContainer::NewL(this, this);
+        }
+    CCoeControl* coeControl = iContainer->Common()->CoeControl();
+    coeControl->SetMopParent( this );
+    AppUi()->AddToStackL( *this, coeControl );
+    coeControl->SetRect( ClientRect() );
+    iContainer->Common()->SetLbxEmptyTextL(KNullDesC);
+    iContainer->Common()->ActivateContainerL();
+
+	// media is not valid until the first HandleOpenL call
+    CEikButtonGroupContainer* cba = Cba();
+    if ( cba )
+        {
+#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
+        cba->SetCommandSetL( R_MPX_OPTIONS_BACK_CBA_NO_ACTION );
+#else
+        cba->SetCommandSetL(
+            ( iViewUtility->ViewHistoryDepth() == 1 ) ?
+            R_MPX_OPTIONS_EXIT_CBA_NO_ACTION : R_MPX_OPTIONS_BACK_CBA_NO_ACTION );
+#endif
+        cba->DrawDeferred();
+        }
+
+    UpdateTitlePaneL();
+    UpdateNaviPaneL();
+
+    CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();
+    CleanupStack::PushL(cpath);
+    if (iViewUtility->PreviousViewType().iUid == KMPXPluginTypePlaybackUid)
+        {
+        // return back from playback view and in episodes level,
+        // highlight the new playing song
+        MMPXSource* source = iPlaybackUtility->Source();
+
+        if (source)
+            {
+            CMPXCollectionPlaylist* playlist = source->PlaylistL();
+            if (playlist)
+                {
+                CleanupStack::PushL(playlist);
+                CMPXCollectionPath* plPath =
+                    CMPXCollectionPath::NewL(playlist->Path());
+                CleanupStack::PushL(plPath);
+
+                // Going from NPV -> Collection, same collection level
+                if(plPath->Levels()  == cpath->Levels())
+                    {
+                    iPossibleJump = ETrue;
+                    }
+                CleanupStack::PopAndDestroy(plPath);
+                CleanupStack::PopAndDestroy(playlist);
+                }
+            }
+
+        if (cpath->Levels() > 1)
+            {
+            // valid path in collection
+            cpath->Back();
+            RArray<TMPXAttribute> attrs;
+            CleanupClosePushL(attrs);
+            iCurrentMediaLOp = EMPXOpMediaLGetContainerInfo;
+
+            // don't ask for the title if jumping back to the
+            // main podcast menu, since the default title
+            // will be used
+            if(cpath->Levels() == 1)
+                {
+                attrs.Append(KMPXMediaGeneralDuration);
+                }
+            else
+                {
+                attrs.Append(
+                    TMPXAttribute(KMPXMediaIdGeneral,
+                        EMPXMediaGeneralTitle |
+                        EMPXMediaGeneralDuration));
+                }
+
+            iCollectionUtility->Collection().MediaL(*cpath, attrs.Array());
+            CleanupStack::PopAndDestroy(&attrs);
+            iCollectionUtility->Collection().OpenL();
+            }
+        else
+            {
+            TUid defaultView = iViewUtility->DefaultViewUid();
+            if (defaultView != KNullUid)
+                {
+                MPX_DEBUG2("CMPXCollectionViewImp::DoActivateL() Activating default view 0x%x", defaultView.iUid);
+                iViewUtility->ActivateViewL(defaultView);
+                }
+            else
+                {
+                MPX_DEBUG1("CMPXCollectionViewImp::DoActivateL() Activating main view");
+                iViewUtility->ActivateViewL(TUid::Uid(KMPXPluginTypeMainUid));
+                }
+            }
+        }
+    else
+        {
+        cpath->Back();
+        RArray<TMPXAttribute> attrs;
+        CleanupClosePushL(attrs);
+        iCurrentMediaLOp = EMPXOpMediaLGetContainerInfo;
+        attrs.Append(KMPXMediaGeneralDuration);
+        attrs.Append(
+            TMPXAttribute(KMPXMediaIdPodcast,
+                EMPXMediaPodcastType |
+                EMPXMediaPodcastCategoryGroup));
+        iCollectionUtility->Collection().MediaL(*cpath, attrs.Array());
+        CleanupStack::PopAndDestroy(&attrs);
+        iCollectionUtility->Collection().OpenL();
+        }
+    CleanupStack::PopAndDestroy(cpath);
+    }
+
+// ---------------------------------------------------------------------------
+// From CAknView
+// View deactivation function.
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::DoDeactivate()
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::DoDeactivate");
+    if (iContainer)
+        {
+        AppUi()->RemoveFromStack( iContainer->Common()->CoeControl() );
+        delete iContainer;
+        iContainer = NULL;
+        }
+
+    if (iNumEpisode)
+        {
+        delete iNumEpisode;
+        iNumEpisode = NULL;
+        TRAP_IGNORE(UpdateNaviPaneL());
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// From CAknView
+// Foreground event handling function.
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandleForegroundEventL(TBool aForeground)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::HandleForegroundEventL");
+    CAknView::HandleForegroundEventL(aForeground);
+    }
+
+// ---------------------------------------------------------------------------
+// From MEikMenuObserver
+// Dynamically initialises a menu pane.
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::DynInitMenuPaneL(
+    TInt aResourceId,
+    CEikMenuPane* aMenuPane)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::DynInitMenuPaneL");
+
+    // check number of items on the list
+    TInt count = iContainer->Common()->TotalListItemCount();
+    MPX_DEBUG2("CMPXPodcastCollectionViewImp::DynInitMenuPaneL() %d items on list", count);
+
+    TInt currentItem( iContainer->Common()->CurrentLbxItemIndex() );
+    TBool isListEmpty( currentItem < 0 );
+
+    // check number of marked items on the list
+    TInt marked = iContainer->Common()->CurrentSelectionIndicesL()->Count();
+    MPX_DEBUG2("CMPXPodcastCollectionViewImp::DynInitMenuPaneL() %d items marked", marked);
+
+    TInt usbUnblockingStatus;
+    RProperty::Get( KMPXViewPSUid,
+                    KMPXUSBUnblockingPSStatus, 
+                    usbUnblockingStatus);
+
+    switch (aResourceId)
+        {
+        case R_MPX_PODCAST_COLLECTION_VIEW_PODCAST_MENU:
+            {
+            if ( !iPlaybackUtility->Source() )
+                {
+                aMenuPane->SetItemDimmed( EMPXCmdGoToNowPlaying, ETrue );
+                }
+            // Dim "Go to Podcasting" if Podcasting App is not installed on device
+            if (CheckPodcastAppL() == KErrNotFound)
+                {
+                // Not displayed if Podcasting App is not installed
+                aMenuPane->SetItemDimmed(EMPXCmdPodcasting, ETrue);
+                }
+
+            aMenuPane->SetItemDimmed( EAknCmdExit, iExitOptionHidden );
+            break;
+            }
+        case R_MPX_PODCAST_COLLECTION_VIEW_MENU_1:
+            {
+            aMenuPane->SetItemDimmed(EMPXCmdFind, ETrue);
+            if ( !iPlaybackUtility->Source() )
+                {
+                aMenuPane->SetItemDimmed( EMPXCmdGoToNowPlaying, ETrue );
+                }
+            if (usbUnblockingStatus == EMPXUSBUnblockingPSStatusActive)
+                {
+                MPX_DEBUG1("CMPXPodcastCollectionViewImp::DynInitMenuPaneL() dimmed Delete");
+                aMenuPane->SetItemDimmed(EMPXCmdDelete, ETrue);               
+                }
+            // Delete is displayed only if list is not empty
+            if (count == 0 || isListEmpty)
+                {
+                MPX_DEBUG1("CMPXPodcastCollectionViewImp::DynInitMenuPaneL() dimmed Delete");
+                aMenuPane->SetItemDimmed(EMPXCmdDelete, ETrue);
+                // UPNP options will be displayed if list is not empty
+                aMenuPane->SetItemDimmed(EMPXCmdUpnpPlayVia, ETrue);
+                aMenuPane->SetItemDimmed(EMPXCmdUPnPAiwCmdCopyToExternalCriteria, ETrue);
+                }
+            else
+                {
+//#ifdef __UPNP_FRAMEWORK_2_0_
+                if ( iUpnpFrameworkSupport )
+                    {
+                    HandleDynInitUpnpL(aResourceId, *aMenuPane);
+                    }
+                else
+                    {
+                    aMenuPane->SetItemDimmed(EMPXCmdUpnpPlayVia, ETrue);
+                    aMenuPane->SetItemDimmed(EMPXCmdUPnPAiwCmdCopyToExternalCriteria, ETrue);
+                    }
+//#endif //__UPNP_FRAMEWORK_2_0_
+                }
+
+            // Dim "Go to Podcasting" if Podcasting App is not installed on device
+            if (CheckPodcastAppL() == KErrNotFound)
+                {
+                // Not displayed if Podcasting App is not installed
+                aMenuPane->SetItemDimmed(EMPXCmdPodcasting, ETrue);
+                }
+            aMenuPane->SetItemDimmed( EAknCmdExit, iExitOptionHidden );
+            break;
+            }
+        case R_MPX_PODCAST_COLLECTION_VIEW_MENU_2:
+            {
+            aMenuPane->SetItemDimmed(EMPXCmdFind, ETrue);
+            if ( !iPlaybackUtility->Source() )
+                {
+                aMenuPane->SetItemDimmed( EMPXCmdGoToNowPlaying, ETrue );
+                }
+#ifdef __ENABLE_MSK
+            // multiple selection in episodes view
+            if (marked && iShowContextMenu)
+                {
+                MenuBar()->SetMenuType(CEikMenuBar::EMenuContext);
+                iShowContextMenu = EFalse;
+                }
+            else
+                {
+                MenuBar()->SetMenuType(CEikMenuBar::EMenuOptions);
+                }
+#endif //__ENABLE_MSK
+                       
+            if (usbUnblockingStatus == EMPXUSBUnblockingPSStatusActive)
+                {
+                aMenuPane->SetItemDimmed(EMPXCmdDelete, ETrue);
+                aMenuPane->SetItemDimmed(EMPXCmdSetPlayed, ETrue);	
+                aMenuPane->SetItemDimmed(EMPXCmdSetUnplayed, ETrue);
+                }
+
+            // Delete is not displayed if list is empty
+            // Mark/Unmark is not displayed if list is empty
+            if ( count == 0 || isListEmpty)
+                {
+                MPX_DEBUG1("CMPXPodcastCollectionViewImp::DynInitMenuPaneL() dimmed Send");
+                aMenuPane->SetItemDimmed(EMPXCmdSend, ETrue);
+
+                MPX_DEBUG1("CMPXPodcastCollectionViewImp::DynInitMenuPaneL() dimmed Delete");
+                aMenuPane->SetItemDimmed(EMPXCmdDelete, ETrue);
+
+                MPX_DEBUG1("CMPXPodcastCollectionViewImp::DynInitMenuPaneL() dimmed Set to played");
+                aMenuPane->SetItemDimmed(EMPXCmdSetPlayed, ETrue);
+
+                MPX_DEBUG1("CMPXPodcastCollectionViewImp::DynInitMenuPaneL() dimmed Set to unplayed");
+                aMenuPane->SetItemDimmed(EMPXCmdSetUnplayed, ETrue);
+
+                // UPNP options will be displayed if list is not empty
+                aMenuPane->SetItemDimmed(EMPXCmdUpnpPlayVia, ETrue);
+                aMenuPane->SetItemDimmed(EMPXCmdUPnPAiwCmdCopyToExternalCriteria, ETrue);
+                }
+            else
+                {
+//#ifdef __UPNP_FRAMEWORK_2_0_
+                if ( iUpnpFrameworkSupport )
+                    {
+                    HandleDynInitUpnpL(aResourceId, *aMenuPane);
+                    }
+                else
+                    {
+                    aMenuPane->SetItemDimmed(EMPXCmdUpnpPlayVia, ETrue);
+                    aMenuPane->SetItemDimmed(EMPXCmdUPnPAiwCmdCopyToExternalCriteria, ETrue);
+                    }
+//#endif //__UPNP_FRAMEWORK_2_0_
+
+                TInt completePlayed = 0;
+                // check episode state: New, partially played or completely played
+                CMPXCommonListBoxArrayBase* baseArray =
+                    iContainer->Common()->ListBoxArray();
+                CMPXPodcastCollectionViewListBoxArray* array =
+                    static_cast<CMPXPodcastCollectionViewListBoxArray*>(baseArray);
+                TInt currentItem = iContainer->Common()->CurrentLbxItemIndex();
+                const CMPXMedia& media = array->MediaL(currentItem);
+                TUint32 playCount = 0;
+
+                if (media.IsSupported(KMPXMediaGeneralPlayCount))
+                    {
+                    playCount =
+                        media.ValueTObjectL<TUint32>(KMPXMediaGeneralPlayCount);
+                    }
+
+                MPX_DEBUG2("CMPXCollectionViewImp::DynInitMenuPaneL item PlayCount = %d", playCount);
+
+                // playback engine increments the playcount after a song has finished playing
+                if (playCount >= 1)
+                    {
+                    completePlayed = 1;
+                    MPX_DEBUG1("CMPXPodcastCollectionViewImp::DynInitMenuPaneL() item is completely played");
+                    }
+
+                // Set to played.
+                // If marking is off, only displayed if podcast is New Podcast or
+                // Partially Played states.
+                if (!marked && completePlayed)
+                    {
+                    MPX_DEBUG1("CMPXPodcastCollectionViewImp::DynInitMenuPaneL() dimmed Set to played");
+                    aMenuPane->SetItemDimmed(EMPXCmdSetPlayed, ETrue);
+                    }
+
+                // Set to unplayed.
+                // If marking is off, only displayed if podcast is Completely
+                // Played states.
+                if (!marked && !completePlayed)
+                    {
+                    MPX_DEBUG1("CMPXPodcastCollectionViewImp::DynInitMenuPaneL() dimmed Set to unplayed");
+                    aMenuPane->SetItemDimmed(EMPXCmdSetUnplayed, ETrue);
+                    }
+                aMenuPane->SetItemDimmed(EMPXCmdSend, SendOptionVisibilityL());
+                TBool isInvalid = array->IsItemBrokenLinkL(currentItem);
+                TBool isCorrupted = array->IsItemCorruptedL(currentItem);
+                if (isInvalid || isCorrupted)
+                    {
+                    aMenuPane->SetItemDimmed(EMPXCmdSetUnplayed, ETrue);
+                    aMenuPane->SetItemDimmed(EMPXCmdSetPlayed, ETrue);
+                    }
+                }
+            break;
+            }
+        case R_AVKON_MENUPANE_MARKABLE_LIST:
+            {
+            // Mark/Unmark submenu is displayed only if list is not empty
+            if (count == 0 ||
+                usbUnblockingStatus == EMPXUSBUnblockingPSStatusActive ||
+                isListEmpty)
+                {
+                MPX_DEBUG1("CMPXPodcastCollectionViewImp::DynInitMenuPaneL() dimmed Mark/Unmark submenu");
+                aMenuPane->SetItemDimmed(EAknCmdEditListMenu, ETrue);
+                }
+            break;
+            }
+        case R_MPX_PODCAST_COLLECTION_VIEW_MENU_3:
+            {
+            CMPXCommonListBoxArrayBase* baseArray =
+                iContainer->Common()->ListBoxArray();
+            CMPXPodcastCollectionViewListBoxArray* array =
+                static_cast<CMPXPodcastCollectionViewListBoxArray*>(baseArray);
+            TInt currentItem = iContainer->Common()->CurrentLbxItemIndex();
+
+            // Episode details is not displayed if list is empty.
+            // Not displayed if marking is on.
+            // TODO: Not displayed if item in active focus is tagged as unavailable
+            // or corrupt.
+            if(isListEmpty)
+                {
+                aMenuPane->SetItemDimmed( EMPXCmdEpisodeDetails,
+                    ETrue);
+                }
+            else if (count == 0 || marked )
+                {
+                MPX_DEBUG1("CMPXPodcastCollectionViewImp::DynInitMenuPaneL() dimmed Episode details");
+                aMenuPane->SetItemDimmed( EMPXCmdEpisodeDetails,
+                    FileDetailsOptionVisibilityL() );
+                }
+            else
+                {
+                TBool isInvalid = array->IsItemBrokenLinkL(currentItem);
+                TBool isCorrupted = array->IsItemCorruptedL(currentItem);
+                if (isInvalid || isCorrupted)
+                    {
+                    aMenuPane->SetItemDimmed( EMPXCmdEpisodeDetails,
+                        ETrue);
+                    }
+                else
+                    {
+                    aMenuPane->SetItemDimmed( EMPXCmdEpisodeDetails,
+                        FileDetailsOptionVisibilityL() );
+                    }
+                }
+
+            // Dim "Go to Podcasting" if Podcasting App is not installed on device
+            if (CheckPodcastAppL() == KErrNotFound)
+                {
+                // Not displayed if Podcasting App is not installed
+                aMenuPane->SetItemDimmed(EMPXCmdPodcasting, ETrue);
+                }
+
+            aMenuPane->SetItemDimmed( EAknCmdExit, iExitOptionHidden );
+
+            break;
+            }
+//#ifdef __UPNP_FRAMEWORK_2_0_
+        case R_MPX_PODCAST_COLLECTION_PLAY_VIA_SUB_MENU:
+            {
+            if ( iUpnpFrameworkSupport )
+                {
+                AddPlayersNamesToMenuL( *aMenuPane );
+                }
+            break;
+            }
+//#endif //__UPNP_FRAMEWORK_2_0_
+        default:
+            {
+            // Do nothing
+            break;
+            }
+        }
+
+    if (!(aResourceId == R_AVKON_MENUPANE_MARKABLE_LIST && usbUnblockingStatus == EMPXUSBUnblockingPSStatusActive))
+        {
+        // Custom handling of menu pane for markable lists
+        iContainer->Common()->HandleMarkableListDynInitMenuPane(
+            aResourceId,
+            aMenuPane );
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// From MEikListBoxObserver
+// Handles listbox events.
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandleListBoxEventL(
+    CEikListBox* /*aListBox*/,
+    TListBoxEvent aEventType)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::HandleListBoxEventL");
+    MPX_DEBUG2("CMPXPodcastCollectionViewImp::HandleListBoxEventL iLastDepth = %d", iLastDepth);
+    MPX_PERF_CHECKPT("Select collection item to open");
+
+    //handle this thouch screen event to tell to engine the index of selected song
+	//to keep/change focus on right song in rename/remove
+#ifdef SINGLE_CLICK_INCLUDED
+    if ( aEventType == EEventItemSingleClicked )
+#else
+	if ( aEventType == EEventItemClicked )
+#endif
+		{
+		if ( !iHandlingKeyEvent )
+			{
+			CMPXCommonListBoxArrayBase* listboxArray( iContainer->Common()->ListBoxArray() );
+			TInt currentIndex( iContainer->Common()->CurrentLbxItemIndex() );
+
+			CMPXCommand* command = CMPXCommand::NewL();
+			CleanupStack::PushL( command );
+			command->SetTObjectValueL<TMPXCommandId>( KMPXCommandGeneralId,
+													  KMPXCommandIdCollectionSelect );
+			command->SetTObjectValueL( KMPXCommandCollectionSelectIndex, currentIndex );
+			command->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
+			iCollectionUtility->Collection().CommandL( *command );
+			CleanupStack::PopAndDestroy( command );
+			}
+		}
+
+    if (aEventType == EEventEnterKeyPressed|| aEventType == EEventItemDoubleClicked
+#ifdef SINGLE_CLICK_INCLUDED
+        || aEventType == EEventItemSingleClicked            
+#endif
+        )
+        {
+        if (!iHandlingKeyEvent)
+            {
+            TMPXPlaybackState pbState( iPlaybackUtility->StateL() );
+            TBool isEqual( EFalse );
+            if ( pbState == EPbStatePlaying || pbState == EPbStatePaused )
+                {
+                // in currently playing view, check if current item is playing
+                if ( iContainer->Common()->CurrentLbxItemIndex() ==
+                    iContainer->PlaybackIndex() )
+                    {
+                    isEqual = ETrue;
+                    }
+                }
+
+            if ( isEqual )
+                {
+                MPX_DEBUG1( "CMPXPodcastCollectionViewImp::HandleListBoxEventL going to now playing view" );
+                if ( pbState == EPbStatePaused )
+                    {
+                    MPX_DEBUG1( "CMPXPodcastCollectionViewImp::HandleListBoxEventL resuming playback" );
+                    iPlaybackUtility->CommandL( EPbCmdPlay );
+                    }
+                HandleCommandL( EMPXCmdGoToNowPlaying );
+                }
+            else
+                {
+                CMPXCommonListBoxArrayBase* listboxArray =
+                    iContainer->Common()->ListBoxArray();
+                TInt currentItem = iContainer->Common()->CurrentLbxItemIndex();
+                const CMPXMedia& containerMedia = listboxArray->ContainerMedia();
+
+                CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();
+                CleanupStack::PushL(cpath);
+
+                MPX_DEBUG_PATH(*cpath);
+                if (cpath->Levels() == (iLastDepth + 1))
+                    {
+                    // navigated in one level
+                    iLastDepth++;
+                    iBottomIndex->AppendL(
+                        iContainer->Common()->BottomLbxItemIndex());
+                    }
+                else
+                    {
+                    // invalid path, rebuild with all 0
+                    iBottomIndex->Reset();
+                    iLastDepth = cpath->Levels();
+                    for (TInt i = 0; i < iLastDepth; i++)
+                        {
+                        iBottomIndex->AppendL(0);
+                        }
+                    }
+                CleanupStack::PopAndDestroy(cpath);
+
+                MPX_DEBUG2("CMPXPodcastCollectionViewImp::HandleListBoxEventL Opening Item: %d", currentItem);
+                iHandlingKeyEvent = ETrue;
+
+                // Needed to reset the status of iPreservedState
+                if ( EPbStateStopped == iPlaybackUtility->StateL() )
+                    {
+                    iPlaybackUtility->CommandL(EPbCmdResetPreserveState);
+                    }
+
+                RArray<TMPXAttribute> attrs;
+                CleanupClosePushL(attrs);
+
+                iCollectionUtility->Collection().OpenL(currentItem,
+                                                       attrs.Array(),
+                                                       EMPXOpenDefault);
+
+                CleanupStack::PopAndDestroy(&attrs);
+
+                }
+            }
+        else
+            {
+            MPX_DEBUG1("CMPXPodcastCollectionViewImp::HandleListBoxEventL Busy, ignoring command");
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// From MEikCommandObserver
+// Processes user commands.
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::ProcessCommandL(TInt aCommandId)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::ProcessCommandL");
+
+    switch(aCommandId)
+        {
+        case EMPXCmdUpArrow:
+        case EMPXCmdDownArrow:
+            {
+#ifdef __COVER_DISPLAY                         	
+            iIgnoreNextFocusChangedMessage = ETrue;
+#endif                        
+            break;
+            }
+        case EMPXCmdCommonDelete:
+            {
+            CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();
+	        CleanupStack::PushL(cpath);
+	        TInt depth = cpath->Levels();
+#ifndef __HG_COLLECTIONVIEW
+	        if(depth > 2) // 'C' key is invalid within the main Podcast Collection
+	                      // View menu
+#endif // __HG_COLLECTIONVIEW
+	            {
+	            StoreListboxItemIndexL();
+            	DeleteSelectedItemsL();
+            	}
+            CleanupStack::PopAndDestroy(cpath);
+            break;
+            }
+        case EMPXCmdCommonResourceChange:
+            {
+            iContainer->Common()->CoeControl()->SetRect( ClientRect() );
+            break;
+            }
+        case EAknSoftkeyEmpty:
+            {
+            // do nothing.  handled to avoid "unsupported" message
+            break;
+            }
+        case EMPXCmdCommonEnterKey:
+            {
+            // Handle list box event for enter key pressed
+            TInt currentItem = iContainer->Common()->CurrentLbxItemIndex();
+            if( currentItem >= 0 )
+                {
+                HandleListBoxEventL(
+                    NULL, // ignore
+                    EEventEnterKeyPressed );
+                }
+            break;
+            }
+#ifdef __ENABLE_MSK
+        case EMPXCmdCommonUpdateMiddleSoftKey:
+            {
+            // Determine middle soft key labeling
+            UpdateMiddleSoftKeyDisplayL(iCurrentMskId);
+            break;
+            }
+        case EAknSoftkeyContextOptions :
+            {
+            // set context menu flag
+            iShowContextMenu = ETrue;
+            // open context menu (by processing "Options" command)
+            CAknView::ProcessCommandL(EAknSoftkeyOptions);
+            break;
+            }
+#endif // __ENABLE_MSK
+		case EAknCmdExit:
+			{
+			HandleCommandL( aCommandId );
+			}
+        default:
+            {
+            CAknView::ProcessCommandL(aCommandId);
+            break;
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMPXCollectionViewImp::HandleFindAllL
+// Handle callback for "find" operation
+// -----------------------------------------------------------------------------
+//
+//#ifdef __UPNP_FRAMEWORK_2_0_
+void CMPXPodcastCollectionViewImp::HandleFindAllL(
+    const CMPXMedia& aResults,
+    TBool aComplete,
+    TInt aError)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::HandleFindAllL");
+    if (aError == KErrNone)
+        {
+        switch (iCurrentFindAllLOp)
+            {
+//#ifdef __UPNP_FRAMEWORK_2_0_
+            case EMPXOpFindAllLUpnp:
+                {
+                if ( iUpnpFrameworkSupport )
+                    {
+                    DoHandleCopyToRemoteL( aResults, aComplete );
+                    }
+                break;
+                }
+//#endif //__UPNP_FRAMEWORK_2_0_
+            default:
+                {
+                break;
+                }
+            }
+        }
+    else
+        {
+        HandleErrorL(aError);
+        }
+    iCurrentFindAllLOp = EMPXOpFindAllLIdle;
+
+//#ifndef __UPNP_FRAMEWORK_2_0_
+    if ( !iUpnpFrameworkSupport )
+        {
+        // Remove compilation warnings
+        (void)aComplete;
+        }
+//#endif  //__UPNP_FRAMEWORK_2_0_
+    }
+
+// ---------------------------------------------------------------------------
+// Check presence of Nokia Podcasting Application.
+// ---------------------------------------------------------------------------
+//
+TInt CMPXPodcastCollectionViewImp::CheckPodcastAppL()
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::CheckPodcastAppL");
+
+    TApaAppInfo appInfo;
+    RApaLsSession session;
+    User::LeaveIfError( session.Connect() );
+    CleanupClosePushL(session);
+    // Check Nokia Podcasting Application
+    TInt err = session.GetAppInfo(appInfo, KNPodAppUid);
+    CleanupStack::PopAndDestroy(); // Close RApaLsSession session
+    if (err == KErrNone)
+        {
+        MPX_DEBUG2("CMPXPodcastCollectionViewImp::CheckPodcastAppL() found %S", &appInfo.iFullName);
+        }
+    else if (err == KErrNotFound)
+        {
+        MPX_DEBUG1("CMPXPodcastCollectionViewImp::CheckPodcastAppL() Podcast app does not exist");
+        }
+    // else ignore
+
+    return err;
+    }
+
+// ---------------------------------------------------------------------------
+// Launch Nokia Podcasting Application.
+// ---------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::LaunchPodcastAppL()
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::LaunchPodcastAppL");
+    TApaTaskList tasList(iEikonEnv->WsSession());
+    TApaTask task = tasList.FindApp(KNPodAppUid);
+
+    // The check for whether task exists or not is not needed. The reason is that when
+    // process.create() is called, CAknApplicaiton class will first check if an instance of the
+    // applicaiton is present. If an instance is present, it will invoke/activate the
+    // existing application and then exit.
+
+    //if (task.Exists())
+    //    {
+    //    MPX_DEBUG1("CMPXPodcastCollectionViewImp::DynInitMenuPaneL() Podcast app exist");
+        // Bring Podcast App to foreground
+    //    task.BringToForeground();
+    //    }
+    //else
+    //    {
+
+        // Launch Nokia Podcasting Application
+        TApaAppInfo appInfo;
+        RApaLsSession session;
+        User::LeaveIfError( session.Connect() );
+        CleanupClosePushL(session);
+        TInt err = session.GetAppInfo(appInfo, KNPodAppUid);
+        if (err == KErrNone)
+            {
+            MPX_TRAP(err,
+            {
+            CApaCommandLine* commandLine = CApaCommandLine::NewLC();
+            commandLine->SetDocumentNameL(KNullDesC);
+            commandLine->SetExecutableNameL(appInfo.iFullName);
+            session.StartApp(*commandLine);
+            CleanupStack::PopAndDestroy();
+            });
+            }
+        CleanupStack::PopAndDestroy(); // Close RApaLsSession session
+    //    }
+    }
+
+// ---------------------------------------------------------------------------
+// Helper method that checks to see if the specified item is currently playing
+// ---------------------------------------------------------------------------
+//
+TBool CMPXPodcastCollectionViewImp::IsCurrentlyPlayingL(const TMPXItemId& aItem)
+    {
+    MPX_FUNC("CMPXPodcastCollectionViewImp::IsCurrentlyPlaying");
+
+    TBool currentlyPlaying(EFalse);
+
+    if ( (iPlaybackUtility->StateL() == EPbStatePlaying ||
+          iPlaybackUtility->StateL() == EPbStatePaused) &&
+          iContainer )
+        {
+        MMPXSource* source( iPlaybackUtility->Source() );
+        if ( source )
+            {
+            CMPXCollectionPlaylist* playlist( source->PlaylistL() );
+            if ( playlist )
+                {
+                CleanupStack::PushL( playlist );
+                CMPXCollectionPath* pbPath(
+                    CMPXCollectionPath::NewL( playlist->Path() ) );
+                CleanupStack::PushL( pbPath );
+
+                if (aItem == pbPath->IdOfIndex( playlist->Index() ) )
+                    {
+                    currentlyPlaying =  ETrue;
+                    }
+                CleanupStack::PopAndDestroy( pbPath );
+                CleanupStack::PopAndDestroy( playlist );
+                }
+            }
+        }
+    return currentlyPlaying;
+    }
+
+// -----------------------------------------------------------------------------
+// CMPXPodcastCollectionViewImp::HandleViewActivation
+// Handle view activation
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandleViewActivation(
+    const TUid& aCurrentViewType,
+    const TUid& /*aPreviousViewType*/ )
+    {
+    MPX_FUNC( "CMPXPodcastCollectionViewImp::HandleViewActivation" );
+    if ( aCurrentViewType.iUid == KMPXPluginTypeCollectionUid )
+        {
+        TRAP_IGNORE( UpdateNaviPaneL() );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMPXPodcastCollectionViewImp::HandleViewActivation
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandleViewActivation(
+    const TVwsViewId& aNewlyActivatedViewId,
+    const TVwsViewId& /*aViewIdToBeDeactivated */)
+    {
+    if( aNewlyActivatedViewId.iAppUid == TUid::Uid(KMusicPlayerAppUidConstant) &&
+        aNewlyActivatedViewId.iViewUid == Id() )
+        {
+        TRAP_IGNORE( UpdateNaviPaneL() );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMPXPodcastCollectionViewImp::HandleViewDeactivation
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::HandleViewDeactivation(const TVwsViewId& aViewIdToBeDeactivated,
+	                                               const TVwsViewId& /*aNewlyActivatedViewId*/)
+    {
+    if( aViewIdToBeDeactivated.iAppUid == TUid::Uid(KMusicPlayerAppUidConstant) &&
+        aViewIdToBeDeactivated.iViewUid == Id() )
+        {
+        if( iContainer )
+            {
+            if ( iNaviPane && iNaviDecorator )
+                {
+                iNaviPane->Pop( iNaviDecorator );
+                }
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMPXPodcastCollectionViewImp::SetPlayedStatusL
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::SetPlayedStatusL( TBool aPlayed )
+    {
+    MPX_FUNC( "CMPXPodcastCollectionViewImp::SetPlayedStatus" );
+
+    const CArrayFix<TInt>* array =
+        iContainer->Common()->CurrentSelectionIndicesL();
+    TInt arrayCount = array->Count();
+
+    CMPXCommonListBoxArrayBase* listboxArray =
+        iContainer->Common()->ListBoxArray();
+
+    TMPXGeneralType type = EMPXNoType;
+    TMPXGeneralCategory category = EMPXNoCategory;
+
+    if (arrayCount > 0)
+        {
+        CMPXMediaArray* setArray( CMPXMediaArray::NewL() );
+        CleanupStack::PushL( setArray );
+
+        // playback needs to be stopped only once
+        TBool checkIfPlaying(ETrue);
+
+        // iterate through and toggle the episode state for each selection
+        for (TInt i = 0; i < arrayCount; i++)
+            {
+            /*CMPXPodcastCollectionViewListBoxArray* podcastArray =
+                static_cast<CMPXPodcastCollectionViewListBoxArray*>(listboxArray);
+            TBool isInvalid = podcastArray->IsItemBrokenLinkL(array->At(i));
+            TBool isCorrupted = podcastArray->IsItemCorruptedL(array->At(i));
+
+            if ( !isInvalid && !isCorrupted )
+                {*/
+            CMPXMedia* currentSelectedMedia =
+                CMPXMedia::NewL(listboxArray->MediaL(array->At(i)));
+            CleanupStack::PushL(currentSelectedMedia);
+
+            if (currentSelectedMedia->IsSupported(KMPXMediaGeneralType))
+                {
+                type =
+                    currentSelectedMedia->ValueTObjectL<TMPXGeneralType>(
+                    KMPXMediaGeneralType);
+                }
+            if (currentSelectedMedia->IsSupported(KMPXMediaGeneralCategory))
+                {
+                category =
+                    currentSelectedMedia->ValueTObjectL<TMPXGeneralCategory>(
+                    KMPXMediaGeneralCategory);
+                }
+
+            if (( type == EMPXItem ) && ( category == EMPXPodcast ))
+                {
+                TUint32 playCount = aPlayed;
+                TInt lastPlayPos = 0;
+
+                if ( checkIfPlaying &&
+                     currentSelectedMedia->IsSupported(KMPXMediaGeneralId) &&
+                     IsCurrentlyPlayingL(
+                        currentSelectedMedia->ValueTObjectL<TMPXItemId>(
+                            KMPXMediaGeneralId)))
+                    {
+                    iPlaybackUtility->CommandL(EPbCmdStop);
+                    checkIfPlaying = EFalse;
+
+                    // save off a copy of the media so Set can
+                    // be run after EPbCmdStop returns
+                    if(iMediaToSet)
+                        {
+                        delete iMediaToSet;
+                        iMediaToSet = NULL;
+                        }
+
+                    iMediaToSet = CMPXMedia::NewL();
+                    iMediaToSet->SetTObjectValueL( KMPXMediaGeneralType,
+                    	EMPXItem );
+                    iMediaToSet->SetTObjectValueL( KMPXMediaGeneralCategory,
+                    	EMPXPodcast);
+                    iMediaToSet->SetTObjectValueL( KMPXMediaGeneralCollectionId,
+                        currentSelectedMedia->ValueTObjectL<TUid>(
+                            KMPXMediaGeneralCollectionId));
+                    iMediaToSet->SetTObjectValueL( KMPXMediaGeneralId,
+                        currentSelectedMedia->ValueTObjectL<TMPXItemId>(
+                            KMPXMediaGeneralId));
+
+                    iMediaToSet->SetTObjectValueL<TUint32> (
+                        KMPXMediaGeneralPlayCount, playCount);
+                    iMediaToSet->SetTObjectValueL (
+                        KMPXMediaGeneralLastPlaybackPosition, lastPlayPos);
+                    iMediaToSet->SetTObjectValueL<TBool> (
+                        KMPXMediaPodcastIsPlaying, EFalse);
+                    }
+                else
+                    {
+                    currentSelectedMedia->SetTObjectValueL<TUint32> (
+                        KMPXMediaGeneralPlayCount, playCount);
+                    currentSelectedMedia->SetTObjectValueL (
+                        KMPXMediaGeneralLastPlaybackPosition, lastPlayPos);
+                    currentSelectedMedia->SetTObjectValueL<TBool> (
+                        KMPXMediaPodcastIsPlaying, EFalse);
+
+                    setArray->AppendL( *currentSelectedMedia );
+                    //DoSetCollectionL( currentSelectedMedia, ETrue );
+                    }
+                }
+
+            CleanupStack::PopAndDestroy(currentSelectedMedia);
+                /*}*/
+            }
+
+        if( setArray->Count() > 0 )
+            {
+            CMPXMedia* groupMedia( CMPXMedia::NewL() );
+            CleanupStack::PushL( groupMedia );
+            groupMedia->SetTObjectValueL<TMPXGeneralType>(KMPXMediaGeneralType, EMPXGroup);
+            groupMedia->SetCObjectValueL<CMPXMediaArray>(KMPXMediaArrayContents, setArray );
+            CMPXMedia* first( setArray->AtL( 0 ) );
+            TUid colId( first->ValueTObjectL<TUid>(KMPXMediaGeneralCollectionId) );
+            groupMedia->SetTObjectValueL<TUid>( KMPXMediaGeneralCollectionId, colId );
+            DoSetCollectionL( groupMedia, EFalse );
+            CleanupStack::PopAndDestroy( groupMedia );
+            }
+        CleanupStack::PopAndDestroy( setArray );
+        }
+    else
+        {
+        TInt currentIndex = iContainer->Common()->CurrentLbxItemIndex();
+        CMPXMedia* currentSelectedMedia =
+            CMPXMedia::NewL(listboxArray->MediaL(currentIndex));
+        CleanupStack::PushL(currentSelectedMedia);
+
+        if (currentSelectedMedia->IsSupported(KMPXMediaGeneralType))
+            {
+            type =
+                currentSelectedMedia->ValueTObjectL<TMPXGeneralType>(
+                    KMPXMediaGeneralType);
+            }
+        if (currentSelectedMedia->IsSupported(KMPXMediaGeneralCategory))
+            {
+            category =
+                currentSelectedMedia->ValueTObjectL<TMPXGeneralCategory>(
+                    KMPXMediaGeneralCategory);
+            }
+
+        if ((type == EMPXItem) && (category == EMPXPodcast))
+            {
+            TUint32 playCount = aPlayed;
+            TInt lastPlayPos = 0;
+
+            if ( currentSelectedMedia->IsSupported(KMPXMediaGeneralId) &&
+                 IsCurrentlyPlayingL(
+                    currentSelectedMedia->ValueTObjectL<TMPXItemId>(
+                        KMPXMediaGeneralId)) )
+                {
+                iPlaybackUtility->CommandL(EPbCmdStop);
+
+                // save off a copy of the media so Set can
+                // be run after EPbCmdStop returns
+                if(iMediaToSet)
+                    {
+                    delete iMediaToSet;
+                    iMediaToSet = NULL;
+                    }
+
+                iMediaToSet = CMPXMedia::NewL();
+                iMediaToSet->SetTObjectValueL( KMPXMediaGeneralType,
+					EMPXItem );
+                iMediaToSet->SetTObjectValueL( KMPXMediaGeneralCategory,
+                	EMPXPodcast);
+                iMediaToSet->SetTObjectValueL( KMPXMediaGeneralCollectionId,
+                    currentSelectedMedia->ValueTObjectL<TUid>(
+                        KMPXMediaGeneralCollectionId));
+                iMediaToSet->SetTObjectValueL( KMPXMediaGeneralId,
+                    currentSelectedMedia->ValueTObjectL<TMPXItemId>(
+                        KMPXMediaGeneralId));
+
+                iMediaToSet->SetTObjectValueL<TUint32> (
+                    KMPXMediaGeneralPlayCount, playCount);
+                iMediaToSet->SetTObjectValueL (
+                    KMPXMediaGeneralLastPlaybackPosition, lastPlayPos);
+                iMediaToSet->SetTObjectValueL<TBool> (
+                    KMPXMediaPodcastIsPlaying, EFalse);
+                }
+            else
+                {
+                currentSelectedMedia->SetTObjectValueL<TUint32> (
+                    KMPXMediaGeneralPlayCount, playCount);
+                currentSelectedMedia->SetTObjectValueL (
+                    KMPXMediaGeneralLastPlaybackPosition, lastPlayPos);
+                currentSelectedMedia->SetTObjectValueL<TBool> (
+                    KMPXMediaPodcastIsPlaying, EFalse);
+
+                DoSetCollectionL( currentSelectedMedia, EFalse );
+                }
+            }
+        CleanupStack::PopAndDestroy(currentSelectedMedia);
+        }
+
+    // Clear selection
+    if(iContainer)
+        {
+        iContainer->Common()->ClearLbxSelection();
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMPXPodcastCollectionViewImp::StoreListboxItemIndexL
+// -----------------------------------------------------------------------------
+//
+void CMPXPodcastCollectionViewImp::StoreListboxItemIndexL()
+	{
+    TInt currentIndex( iContainer->Common()->CurrentLbxItemIndex() );
+
+	CMPXCommand* command = CMPXCommand::NewL();
+	CleanupStack::PushL( command );
+	command->SetTObjectValueL<TMPXCommandId>( KMPXCommandGeneralId,
+											  KMPXCommandIdCollectionSelect );
+	command->SetTObjectValueL( KMPXCommandCollectionSelectIndex, currentIndex );
+	command->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
+	iCollectionUtility->Collection().CommandL( *command );
+	CleanupStack::PopAndDestroy( command );
+	}
+
+//  End of File