1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  MPX podcast collection view implementation

    15 *

    16 */

    17 

    18 

    19 

    20 #ifndef C_CMPXPODCASTCOLLECTIONVIEWIMP_H

    21 #define C_CMPXPODCASTCOLLECTIONVIEWIMP_H

    22 

    23 

    24 // INCLUDES

    25 #include <eikspmod.h>

    26 #include <eikclb.h>

    27 #include <AknProgressDialog.h>  // MProgressDialogCallback

    28 #include <eikprogi.h>

    29 #include <AknWaitDialog.h>

    30 #include <mpxmediageneraldefs.h>

    31 #include <mpxcollectionobserver.h>

    32 #include <mpxplaybackobserver.h>

    33 #include <mpxcollectionuihelper.h>

    34 #include <mpxcollectionuihelperobserver.h>

    35 #include <mpxcollectionhelper.h>

    36 #include <mpxcollectionpath.h>  // TMPXItemId

    37 #include <mpxviewactivationobserver.h>

    38 #include "mpxpodcastcollectionview.h"

    39 

    40 #include "mpxplaybackframeworkdefs.h" // TMPXPlaybackPlayerType

    41 

    42 // FORWARD DECLARATIONS

    43 class CMPXPodcastCollectionViewContainer;

    44 class MMPXCollectionUtility;

    45 class CMPXCollectionPlaylist;

    46 class MMPXPlaybackUtility;

    47 class CMPXCommonUiHelper;

    48 class MMPXViewUtility;

    49 class CSendUi;

    50 class CAknNavigationDecorator;

    51 class CAknNaviLabel;

    52 class CAknNavigationControlContainer;

    53 class CEikButtonGroupContainer;

    54 

    55 class MMPXPlayerManager;

    56 class CAiwServiceHandler;

    57 #ifdef UPNP_INCLUDED

    58 class CUpnpCopyCommand;

    59 #endif

    60 // CLASS DECLARATION

    61 

    62 /**

    63  *  MPX Podcast Collection view.

    64  *

    65  *  @lib mpxpodcastcollectionview.lib

    66  *  @since S60 v3.0

    67  */

    68 NONSHARABLE_CLASS( CMPXPodcastCollectionViewImp ) : public CMPXPodcastCollectionView,

    69                                              public MMPXCollectionObserver,

    70                                              public MMPXPlaybackObserver,

    71                                              public MMPXPlaybackCallback,

    72                                              public MEikListBoxObserver,

    73                                              public MProgressDialogCallback,

    74                                              public MMPXCollectionFindObserver,

    75                                              public MMPXCHelperObserver,

    76                                              public MMPXViewActivationObserver,

    77                                              public MCoeViewDeactivationObserver,

    78                                              public MCoeViewActivationObserver

    79     {

    80 public:

    81 

    82     /**

    83      * Two-phased constructor.

    84      *

    85      * @since 3.0

    86      * @return Pointer to newly created object.

    87      */

    88     static CMPXPodcastCollectionViewImp* NewL();

    89 

    90     /**

    91      * Two-phased constructor.

    92      *

    93      * @since 3.0

    94      * @return Pointer to newly created object.

    95      */

    96     static CMPXPodcastCollectionViewImp* NewLC();

    97 

    98     /**

    99      * Destructor.

   100      */

   101     virtual ~CMPXPodcastCollectionViewImp();

   102 

   103     /**

   104      * Delete the selected items

   105      *

   106      * @ since 3.0

   107      */

   108     void DeleteSelectedItemsL();

   109 

   110 private:

   111 

   112     /**

   113      * C++ default constructor.

   114      */

   115     CMPXPodcastCollectionViewImp();

   116 

   117     /**

   118      * By default Symbian 2nd phase constructor is private.

   119      */

   120     void ConstructL();

   121 

   122     /**

   123      * Updates list box

   124      *

   125      * @param aEntries Podcast collection entries opened. Method may

   126      *                 update the entries array by removing the playing item

   127      *                 if currently within Never Played list view.

   128      * @param aIndex focused entry

   129      */

   130     void UpdateListBoxL(CMPXMedia& aEntries,

   131                         TInt aIndex );

   132 

   133     /**

   134      * Displays error notes.

   135      *

   136      * @param aError Error ID to be handled.

   137      */

   138     void HandleErrorL( TInt aError );

   139 

   140     /**

   141      * Updates the navi pane

   142      */

   143     void UpdateNaviPaneL();

   144 

   145     /**

   146      * Updates the title pane

   147      */

   148     void UpdateTitlePaneL();

   149 

   150     /**

   151      * Updates the option menu

   152      *

   153      */

   154     void UpdateOptionMenuL();

   155 

   156     /**

   157      * Start either the delete progress note

   158      */

   159     void StartProgressNoteL();

   160 

   161     /**

   162      * Updates the progress note text and progress bar

   163      * 

   164      * @param	aProgress 		Indicates the portion of the process completed

   165      * @param 	aProgressText	Text to be displayed on the progress note  	

   166      */

   167     void UpdateProcessL(TInt aProgress,const TDesC& aProgressText);

   168 

   169     /**

   170      * Updates the copy to remote menu attachment

   171      *

   172      */

   173     void UpdateCopyToRemoteMenu(TInt aMenuPane);

   174 

   175     /**

   176      * Updates playback status/indicatior

   177      * @param aStatusChangeFlag flag to indicate if a status change

   178      *        has indeed been detected

   179      * Returns the current selection index if the paths match

   180      */

   181     TInt UpdatePlaybackStatusL(TBool aStatusChangeFlag);

   182 

   183     /**

   184      * Change the button group

   185      *

   186      * @aResId resource ID

   187      */

   188     void SetNewCbaL( TInt aResId );

   189 

   190     /**

   191      * Display collection details

   192      *

   193      * @param aMedia media object containing the library details

   194      */

   195     void ShowCollectionDetailsL( const CMPXMedia& aMedia );

   196 

   197     /**

   198      * Handles Upnp menus from DynInitMenuPaneL()

   199      *

   200      * @param aResourceId the id of the resource being initialized

   201      * @param aMenuPane the menu pane the resource belongs to

   202      */

   203     void HandleDynInitUpnpL( TInt aResourceId, CEikMenuPane& aMenuPane );

   204 

   205     /**

   206      * Checks if UPnP AP is defined

   207      *

   208      * @return ETrue if visible, EFalse otherwise

   209      */

   210     TBool IsUpnpVisible();

   211 

   212     /**

   213      * Displays the available players in the Play via submenu

   214      *

   215      * @param aMenuPane Menu pane to put the sub menu items

   216      */

   217     void AddPlayersNamesToMenuL( CEikMenuPane& aMenuPane );

   218 

   219     /**

   220      * Adds one player type to the Play via submenu

   221      *

   222      * @param aMenuPane menu pane to add player name to

   223      * @param aCommandId ID of the command

   224      * @param aPlayerManager player manager

   225      * @param aPlayerType type of the player

   226      * @param aMenuText optional menu text

   227      */

   228     void AddPlayerNameToMenuL( CEikMenuPane& aMenuPane,

   229                                TInt aCommandId,

   230                                MMPXPlayerManager& aPlayerManager,

   231                                TMPXPlaybackPlayerType& aPlayerType,

   232                                const TDesC& aMenuText = KNullDesC );

   233 

   234     /**

   235      * Retrieves the current player name and type

   236      */

   237     void GetCurrentPlayerDetails();

   238 

   239     /**

   240      * Selects a new player for audio playback

   241      *

   242      * @param aCommand Command Id to identify which player to use

   243      */

   244     void SelectNewPlayerL( TInt aCommand );

   245 

   246     /**

   247      * Copies selected file(s) to remote player

   248      */

   249     void CopySelectedItemsToRemoteL();

   250 

   251     /**

   252      * Handle call back from collectionframework for Copy to Remote command

   253      *

   254      * @param aMedia media

   255      * @param aComplete all selected medias have been found

   256      */

   257     void DoHandleCopyToRemoteL(const CMPXMedia& aMedia,

   258                                TBool aComplete = ETrue );

   259 

   260 

   261     /**

   262      * checks if send option should be shown the option is selected

   263      *

   264      * @return ETrue if send command should be hided, EFalse if it should be shown

   265      */

   266     TBool SendOptionVisibilityL();

   267 

   268     /**

   269      * Checks if file details option should be shown

   270      *

   271      * @return ETrue if the command should be hiden, EFalse if it should be shown

   272      */

   273     TBool FileDetailsOptionVisibilityL();

   274 

   275     /**

   276      * Handle send command

   277      */

   278     void DoSendL();

   279 

   280     /**

   281      * Handle call back from collectionframework for send command

   282      *

   283      * @param aMedia media

   284      * @param aError error code

   285      */

   286     void DoHandleSendL(const CMPXMedia& aMedia, TInt aError );

   287     /**

   288      * Prepares media object for selected items

   289      *

   290      * @param aMedia on return, populates the media object with a media array

   291      *        containing info for currently selected items used by playlist

   292      *        does not own this object

   293      *

   294      * @return error code

   295      */

   296     TInt PrepareMediaForSelectedItemsL( CMPXMedia* aMedia );

   297 

   298     /**

   299      * Set/clears the flags for item in database

   300      * @param aIndex index of the item in the list box

   301      * @param aMedia media object containing at least the following attribute:

   302      *        TMPXAttribute( KMPXMediaIdGeneral,EMPXMediaGeneralCollectionId )

   303      * @param aFlag flag to set/clear

   304      * @param aSet ETrue to set the flag, EFalse to clear the flag

   305      * @param aEnableInfoDialog ETrue to enable info dialog display, EFalse to disable

   306      */

   307     void UpdateDatabaseFlagL( TInt aIndex,

   308                               const CMPXMedia& aMedia,

   309                               TUint aFlag,

   310                               TBool aSet,

   311                               TBool aEnableInfoDialog = ETrue );

   312 

   313     /**

   314      * Handle playback message

   315      *

   316      * @param aMessage playback message

   317      */

   318     void DoHandlePlaybackMessageL( const CMPXMessage& aMessage );

   319 

   320     /**

   321      * Handle collection message

   322      *

   323      * @param aMessage collection message

   324      */

   325     void DoHandleCollectionMessageL( const CMPXMessage& aMessage );

   326 

   327     /**

   328      * Updates a media to the collection

   329      * @param aMedia media to update

   330      * @param aSync synchronous operation or not

   331      */

   332     void DoSetCollectionL( CMPXMedia* aMedia, TBool aSync );

   333 

   334 #ifdef __ENABLE_MSK

   335     /**

   336      * Updates the middle softkey display to a label or icon depending on whether

   337      * there are marked indices

   338      * @param aMskId middle softkey command id

   339      */

   340     void UpdateMiddleSoftKeyDisplayL( TInt aMskId );

   341 #endif // __ENABLE_MSK

   342 

   343     /**

   344      * Changes the selected episode(s) status to Played /unplayed

   345      * @param aPlayed played status to set (EFalse: unplayed)

   346      */

   347     void SetPlayedStatusL( TBool aPlayed );

   348 

   349     /**

   350      * From MProgressDialogCallback

   351      * Callback method

   352      * Get's called when a dialog is dismissed.

   353      */

   354     void DialogDismissedL( TInt aButtonId );

   355 

   356     /**

   357      * From MMPXCollectionObserver

   358      * Handle collection message.

   359      *

   360      * @param aMessage Collection message

   361      * @param aErr system error code.

   362      */

   363     void HandleCollectionMessage(

   364         CMPXMessage* aMessage, TInt aError );

   365 

   366     /**

   367      *  From MMPXCollectionObserver

   368      *  Handles the collection entries being opened. Typically called

   369      *  when client has Open()'d a folder

   370      *

   371      *  @param aEntries collection entries opened

   372      *  @param aIndex focused entry

   373      *  @param aComplete ETrue no more entries. EFalse more entries

   374      *                   expected

   375      *  @param aError error code

   376      */

   377     void HandleOpenL(const CMPXMedia& aEntries,

   378                      TInt aIndex,

   379                      TBool aComplete,

   380                      TInt aError );

   381 

   382     /**

   383      *  From MMPXCollectionObserver

   384      *  Handles the collection entries being opened. Typically called

   385      *  when client has Open()'d an item. Client typically responds by

   386      *  'playing' the item

   387      *

   388      *  @param aPlaylist Podcast collection path to item

   389      *  @param aError error code

   390      */

   391     void HandleOpenL(const CMPXCollectionPlaylist& aPlaylist,

   392                      TInt aError );

   393 

   394     /**

   395      *

   396      *  From MMPXCollectionObserver

   397      *  Handle media properties

   398      *

   399      *  @param aMedia media

   400      *  @param aError error code

   401      */

   402     void HandleCollectionMediaL(const CMPXMedia& aMedia,

   403                                 TInt aError );

   404 

   405 // from base class MMPXCHelperObserver

   406 

   407     /**

   408      * From MMPXCHelperObserver

   409      * Handles the completion of any collection helper event.

   410      *

   411      * @param aOperation, operation completed

   412      * @param aErr. the error code

   413      * @param aArgument Argument returned from the operation

   414      */

   415     void HandleOperationCompleteL( TCHelperOperation aOperation,

   416                                    TInt aErr,

   417                                    void* aArgument );

   418 

   419 // from base class MMPXPlaybackObserver

   420 

   421     /**

   422      * From MMPXPlaybackObserver

   423      * Handle playback message

   424      *

   425      * @since 3.0

   426      * @param aMessage playback message

   427      * @param aErr system error code.

   428      */

   429     void HandlePlaybackMessage( CMPXMessage* aMessage, TInt aError );

   430 

   431 // from base class MMPXPlaybackCallback

   432 

   433     /**

   434      * From MMPXPlaybackCallback

   435      * Handle playback property

   436      *

   437      * @since 3.0

   438      * @param aProperty the property

   439      * @param aValue the value of the property

   440      * @param aError error code

   441      */

   442     void HandlePropertyL(TMPXPlaybackProperty aProperty,

   443                          TInt aValue,

   444                          TInt aError );

   445 

   446     /**

   447      * From MMPXPlaybackCallback

   448      * Method is called continously until aComplete=ETrue, signifying that

   449      * it is done and there will be no more callbacks

   450      * Only new items are passed each time

   451      *

   452      * @since 3.0

   453      * @param aPlayer UID of the subplayer

   454      * @param aSubPlayers a list of sub players

   455      * @param aComplete ETrue no more sub players. EFalse more subplayer

   456      *                  expected

   457      * @param aError error code

   458      */

   459     void HandleSubPlayerNamesL(TUid aPlayer,

   460                                const MDesCArray* aSubPlayers,

   461                                TBool aComplete,

   462                                TInt aError );

   463 

   464     /**

   465      * From MMPXPlaybackCallback

   466      * Handle media properties

   467      *

   468      * @since 3.0

   469      * @param aMedia media

   470      * @param aError error code

   471      */

   472     void HandleMediaL(const CMPXMedia& aMedia,

   473                       TInt aError );

   474 

   475 // from base class CAknView

   476 

   477     /**

   478      * From CAknView

   479      * Returns views id.

   480      *

   481      * @since 3.0

   482      * @return Views Uid

   483      */

   484     TUid Id() const;

   485 

   486     /**

   487      * From CAknView

   488      * Command handling function.

   489      *

   490      * @since 3.0

   491      * @param aCommand Command which is handled

   492      */

   493     void HandleCommandL( TInt aCommand );

   494 

   495     /**

   496      * From CAknView

   497      * Handles a view activation.

   498      *

   499      * @param aPrevViewId Specifies the view previously active.

   500      * @param aCustomMessageId Specifies the message type.

   501      * @param aCustomMessage The activation message.

   502      */

   503     void DoActivateL(const TVwsViewId& aPrevViewId,

   504                      TUid aCustomMessageId,

   505                      const TDesC8& aCustomMessage );

   506 

   507     /**

   508      * From CAknView

   509      * View deactivation function.

   510      */

   511     void DoDeactivate();

   512 

   513     /**

   514      * From CAknView

   515      * Foreground event handling function.

   516      *

   517      * @param aForeground Indicates the required focus state of the control.

   518      */

   519     void HandleForegroundEventL( TBool aForeground );

   520 

   521 // from base class MEikMenuObserver

   522 

   523     /**

   524      * From MEikMenuObserver

   525      * Dynamically initialises a menu pane.

   526      *

   527      * @param aResourceId The ID of the menu pane.

   528      * @param aMenuPane The menu pane itself.

   529      */

   530     void DynInitMenuPaneL(TInt aResourceId,

   531                           CEikMenuPane* aMenuPane );

   532 

   533 // from MEikListBoxObserver

   534 

   535     /**

   536      * Handles listbox events.

   537      *

   538      * @param aListBox Listbox where the event occurred.

   539      * @param aEventType Event type.

   540      */

   541      void HandleListBoxEventL(CEikListBox* aListBox,

   542                               TListBoxEvent aEventType );

   543 

   544 // from MEikCommandObserver

   545 

   546     /**

   547      * Processes user commands.

   548      *

   549      * @param aCommandId ID of the command to respond to.

   550      */

   551     virtual void ProcessCommandL(TInt aCommandId);

   552 

   553 // from MMPXCollectionFindObserver

   554 

   555     /**

   556     *  Handle callback for "find" operation

   557     *  @param aEntries, CMPXMedia to be returned

   558     *  @param aComplete ETrue no more entries. EFalse more entries

   559     *                   expected

   560     *  @param aError error code

   561     */

   562     virtual void HandleFindAllL(const CMPXMedia& aResults,

   563                                 TBool aComplete,TInt aError);

   564 

   565     /**

   566      * Launch Nokia Podcasting Application

   567      *

   568      */

   569     void LaunchPodcastAppL();

   570 

   571     /**

   572      * Launch Nokia Podcasting Application

   573      *

   574      */

   575     TInt CheckPodcastAppL();

   576 

   577     /**

   578      * Helper method that checks to see if the specified episode is

   579      * currently playing.

   580      *

   581      * @param aItem id of item to check if currently playing

   582      * @return ETrue if item currently playing else EFalse

   583      */

   584     TBool IsCurrentlyPlayingL(const TMPXItemId& aItem);

   585 

   586 // from MMPXViewActivationObserver

   587 

   588    /**

   589     * From MMPXViewActivationObserver

   590     * Handle view activation.

   591     *

   592     * @param aCurrentViewType Current view type Uid.

   593     * @param aPreviousViewType Previous view type Uid.

   594     */

   595     void HandleViewActivation(

   596         const TUid& aCurrentViewType,

   597         const TUid& aPreviousViewType );

   598 

   599 // from MCoeViewActivationObserver

   600 

   601    /**

   602     * From MCoeViewActivationObserver

   603     * Handle view activation.

   604     *

   605     * @param aNewlyActivatedViewId newly activated view id.

   606     * @param aViewIdToBeDeactivated deactivated view id.

   607     */

   608     void HandleViewActivation(

   609         const TVwsViewId& aNewlyActivatedViewId,

   610         const TVwsViewId& aViewIdToBeDeactivated );

   611 

   612 // from MCoeViewDeactivationObserver

   613    /**

   614     * Handles view deactivation notification from view server

   615     */

   616     void HandleViewDeactivation(const TVwsViewId& aViewIdToBeDeactivated,

   617                                 const TVwsViewId& aNewlyActivatedViewId);

   618     

   619     /**

   620      * Stores the current list box item index.

   621      */

   622     void StoreListboxItemIndexL();

   623 

   624 private:    // Data

   625 

   626     CMPXPodcastCollectionViewContainer* iContainer;  // own

   627     MMPXCollectionUtility*      iCollectionUtility;  // not own

   628     MMPXPlaybackUtility*        iPlaybackUtility;

   629     MMPXViewUtility*            iViewUtility;

   630     CMPXCommonUiHelper*         iCommonUiHelper;

   631     MMPXCollectionUiHelper*     iCollectionUiHelper;

   632     CMPXMedia*                  iMediaToSet; // own

   633 

   634     CSendUi*                    iSendUi;

   635     HBufC*                      iTitle;

   636     HBufC*                      iNumEpisode;

   637     HBufC*                      iDuration;

   638     HBufC*                      iOriginalTitle;

   639     HBufC*                      iOriginalDuration;

   640     CArrayFix<TInt>*            iBottomIndex;

   641 

   642     TBool                       iBackOneLevel;

   643     TBool                       iPossibleJump;

   644     TBool                       iChangeRTForAllProfiles;

   645     TBool                       iIsWaitNoteCanceled;

   646     TBool                       iIsDeleting;

   647     TBool                       iHandlingKeyEvent;

   648     TBool                       iExitOptionHidden;

   649     TBool                       iIgnoreNextFocusChangedMessage;

   650 

   651     // HandleOpen was called and listbox was updated, only EFalse

   652     // when view is activated

   653     TBool                       iHandleOpenProcessed;

   654 

   655     TInt                        iCurrentMediaLOp;   // current mediaL operation

   656     TInt                        iCurrentFindAllLOp; // current FindAllL operation

   657     TInt                        iLastDepth;

   658     TInt                        iLastSelectedIndex;

   659     TInt                        iCurrNotYetPlayedListIndex;

   660     TInt                        iResourceOffset;        // must be freed

   661 #ifdef __ENABLE_MSK

   662     TInt                        iCurrentMskId;

   663     TBool                       iShowContextMenu;

   664 #endif // __ENABLE_MSK

   665 

   666     CAknNavigationDecorator*        iNaviDecorator;

   667     CAknNaviLabel*                  iNaviLabel;

   668     CAknNavigationControlContainer* iNaviPane;

   669 

   670     CEikButtonGroupContainer*       iCba; // owned

   671 

   672     RArray<TUid> iPlayersList;

   673     CAiwServiceHandler* iServiceHandler;

   674     TInt iErrorAttachCopyMenu;

   675     TMPXPlaybackPlayerType iCurrentPlayerType;

   676     TInt iCurrentlyAttachedCopyToMenuPane;

   677     HBufC* iSubPlayerName;

   678     TBool iUpnpFrameworkSupport;

   679 

   680     TMPXItemId iSelectedItem;

   681     // Progress note for delete

   682     CAknProgressDialog*	iProgressDialog;

   683     CEikProgressInfo*	iProgressInfo;

   684 #ifdef UPNP_INCLUDED

   685     CUpnpCopyCommand* iUpnpCopyCommand; 

   686 #endif

   687     };

   688 

   689 #endif  // C_CMPXPODCASTCOLLECTIONVIEWIMP_H

   690 

   691 // End of File