/*
* 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");
_LIT(KEmptyTitle, " ");
#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->RemoveObserver( this );
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 );
StartDeleteWaitNoteL();
TPtr buf = waitNoteText->Des();
UpdateProcessL(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;
iGoToNowPlaying = EFalse;
}
// ---------------------------------------------------------------------------
// 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_TITLE_UNKNOWN_PODCAST);
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 delete wait note
// ---------------------------------------------------------------------------
//
void CMPXPodcastCollectionViewImp::StartDeleteWaitNoteL()
{
iWaitDialog = new (ELeave) CAknWaitDialog(
(REINTERPRET_CAST(CEikDialog**, &iWaitDialog)),
ETrue);
iWaitDialog->PrepareLC(R_MPX_DELETE_WAIT_NOTE);
iWaitDialog->SetCallback(this);
iWaitDialog->RunLD();
}
// ---------------------------------------------------------------------------
// Update the delete wait note
// ---------------------------------------------------------------------------
//
void CMPXPodcastCollectionViewImp::UpdateProcessL(const TDesC& aDeleteNoteText)
{
if(iWaitDialog)
{
iWaitDialog->SetTextL(aDeleteNoteText);
}
}
// -----------------------------------------------------------------------------
// 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 ( !IsUpnpVisibleL() )
{
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::IsUpnpVisibleL()
{
MPX_FUNC( "CMPXPodcastCollectionViewImp::IsUpnpVisibleL" );
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 (iWaitDialog)
{
iWaitDialog->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 (iWaitDialog)
{
iWaitDialog->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 (iWaitDialog)
{
iWaitDialog->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 (iWaitDialog)
{
iWaitDialog->ProcessFinishedL();
}
HandleCommandL( EMPXCmdHandleExternalCommand );
iIsWaitNoteCanceled = EFalse;
}
HandleErrorL(aErr);
}
// else do nothing
iContainer->Common()->ClearLbxSelection();
// reopen collection
iCollectionUtility->Collection().OpenL();
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:
{
iGoToNowPlaying = ETrue;
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)
{
TInt val(0);
CRepository* repository = CRepository::NewL( KCRUidMPXMPFeatures );
repository->Get( KMPXMPLocalVariation, val );
TBool startInAlbumMenu = val&KMPXStartMusicPlayerinArtistsandAlbums ? ETrue : EFalse;
delete repository;
if ( startInAlbumMenu )
{
CMPXCollectionPath* path = CMPXCollectionPath::NewL();
CleanupStack::PushL( path );
path->AppendL(KMusicCollectionUid);
path->AppendL(3); // Artist & Albums
iCollectionUtility->Collection().OpenL( *path );
CleanupStack::PopAndDestroy( path );
// activate the collection view
RArray<TUid> uids;
CleanupClosePushL( uids );
uids.AppendL( TUid::Uid( KMPXPluginTypeCollectionUid ) );
uids.AppendL( TUid::Uid( KMusicCollectionUid ));
iViewUtility->ActivateViewL(uids);
CleanupStack::PopAndDestroy( &uids );
}
else
{
#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());
}
// for Avkon calling Deactivate, not manually hiding controls, reset iGoToNowPlaying
iGoToNowPlaying = EFalse;
}
// ---------------------------------------------------------------------------
// 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);
aMenuPane->SetItemDimmed(EMPXCmdLibraryDetails, 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()->HandleMarkableListDynInitMenuPaneL(
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);
// It is in episode list view and opens now playing view
if ( cpath->Levels() == 3 )
iGoToNowPlaying = ETrue;
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() );
}
else if ( ( aCurrentViewType.iUid == KMPXPluginTypePlaybackUid ) && ( iGoToNowPlaying == EFalse ) )
{
if ( iContainer )
{
iContainer->HideContainerWindow();
// set title to blank to avoid title flickering
CAknTitlePane* title( static_cast<CAknTitlePane*>
( StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle ))));
if ( title )
{
title->SetTextL(KEmptyTitle);
title->DrawNow();
}
}
}
}
// -----------------------------------------------------------------------------
// 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