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 common playback view implementation

    15 *  Version     : %version: da1mmcf#41.1.6.1.1.1.8 % << Don't touch! Updated by Synergy at check-out.

    16 *

    17 */

    18 

    19 

    20 

    21 #ifndef CMPXCOMMONPLAYBACKVIEWIMP_H

    22 #define CMPXCOMMONPLAYBACKVIEWIMP_H

    23 

    24 

    25 // INCLUDES

    26 #include <aknview.h>

    27 #include <AknServerApp.h>

    28 #include <AknProgressDialog.h>  // MProgressDialogCallback

    29 #include <mpxplaybackobserver.h>

    30 #include <mpxcollectionobserver.h>

    31 #include <mpxcollectionuihelper.h>

    32 #include <mpxcollectionuihelperobserver.h>

    33 #include <mpxpskeyobserver.h>   // MMPXPSKeyObserver

    34 #include <mpxcenrepobserver.h>  // MMPXCenRepObserver

    35 #include <mpxviewactivationobserver.h>  // MMPXViewActivationObserver

    36 

    37 #include "mpxlayoutswitchobserver.h"

    38 #include "mpxplaybackframeworkdefs.h" // TMPXPlaybackPlayerType

    39 

    40 #include "../../../inc/musicplayerbldvariant.hrh"

    41 

    42 // FORWARD DECLARATIONS

    43 class CMPXCommonPlaybackViewContainer;

    44 class MMPXPlaybackUtility;

    45 class CMPXAlbumArtUtil;

    46 class CMPXCommonUiHelper;

    47 class MMPXViewUtility;

    48 class CMPXCollectionPlaylist;

    49 class CMPXCommonPlaybackViewLayout;

    50 class MMPXPlayerManager;

    51 class MMPXCollectionUtility;

    52 class CMPXPSKeyWatcher;

    53 class CMPXCenRepWatcher;

    54 #ifdef IAD_INCLUDE_BACKSTEPPING

    55 class MMPXBackSteppingUtility;

    56 #endif // IAD_INCLUDE_BACKSTEPPING

    57 class CAiwServiceHandler;

    58 class CMediaRecognizer;

    59 class CAiwGenericParamList;

    60 #ifdef IAD_INCLUDE_UPNP

    61 class CUpnpCopyCommand;

    62 #endif

    63 // CLASS DECLARATION

    64 

    65 /**

    66  *  MPX playback view.

    67  *

    68  *  @lib mpxplaybackview.lib

    69  *  @since S60 v3.0

    70  */

    71 class CMPXCommonPlaybackViewImp : public CAknView,

    72                                   public MMPXPlaybackObserver,

    73                                   public MMPXPlaybackCallback,

    74                                   public MAknServerAppExitObserver,

    75                                   public MMPXLayoutSwitchObserver,

    76                                   public MCoeViewActivationObserver,

    77                                   public MMPXCHelperObserver,

    78                                   public MMPXPSKeyObserver,

    79                                   public MMPXCenRepObserver,

    80                                   public MProgressDialogCallback,

    81                                   public MMPXViewActivationObserver,

    82                                   public MMPXCollectionObserver

    83     {

    84 public:

    85     enum TCommandSender

    86         {

    87         ECsUnknown,

    88         ECsMediaKey,

    89         ECsRenderer

    90         };

    91 public:

    92     /**

    93      * Destructor.

    94      */

    95     IMPORT_C virtual ~CMPXCommonPlaybackViewImp();

    96 

    97 protected:

    98     /**

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

   100      */

   101     IMPORT_C virtual void ConstructL();

   102 

   103     /**

   104      * Updates playback view.

   105      */

   106     IMPORT_C virtual void UpdateViewL();

   107 

   108     /**

   109      * Updates track info field.

   110      *

   111      * @param aMedia Media's properties. If NULL, default info will

   112      *                    be shown.

   113      */

   114     IMPORT_C virtual void UpdateTrackInfoL(

   115         const CMPXMedia* aMedia );

   116 

   117     /**

   118      * Update current playback state.

   119      *

   120      * @param aPlaybackState Current playback state.

   121      */

   122     IMPORT_C virtual void UpdatePlaybackState(

   123         TMPXPlaybackState aPlaybackState );

   124 

   125     /**

   126      * Updates track's playback position.

   127      *

   128      * @param  aPos, New playback postions in seconds

   129      * @param  aDuration, Track duration in seconds

   130      */

   131     IMPORT_C virtual void UpdateTrackPlaybackPositionL(

   132         TInt aPos,

   133         TInt aDuration );

   134 

   135     /**

   136      * Updates track's album art.

   137      *

   138      * @param aMedia Media's properties. If NULL, default album art

   139      *                    will be shown.

   140      */

   141     IMPORT_C virtual void UpdateAlbumArtL(

   142         const CMPXMedia* aMedia );

   143 

   144     /**

   145      * Updates track position in playlist field.

   146      */

   147     IMPORT_C virtual void UpdateTrackPosInPlaylistL();

   148 

   149     /**

   150      * Updates download state label.

   151      */

   152     IMPORT_C virtual void UpdateDownloadStateLabelL();

   153 

   154     /**

   155      * Updates the title pane

   156      */

   157     IMPORT_C virtual void UpdateTitlePaneL();

   158 

   159     /**

   160      * Updates FM Transmitter Info

   161      */

   162     IMPORT_C virtual void UpdateFMTransmitterInfoL(

   163         TBool aForceUpdate = EFalse );

   164 

   165     /**

   166      *  Handle playback message

   167      *

   168      *  @param aMsg playback message

   169      */

   170     IMPORT_C virtual void DoHandlePlaybackMessageL(

   171         const CMPXMessage& aMessage );

   172 

   173     /**

   174      *  Handle playback property

   175      *

   176      *  @param aProperty the property

   177      *  @param aValue the value of the property

   178      *  @param aError error code

   179      */

   180     IMPORT_C virtual void DoHandlePropertyL(

   181         TMPXPlaybackProperty aProperty,

   182         TInt aValue,

   183         TInt aError );

   184 

   185     /**

   186      *  Handle media properties.

   187      *

   188      *  @param aMedia media properties

   189      *  @param aError error code

   190      */

   191     IMPORT_C virtual void DoHandleMediaL(

   192         const CMPXMedia& aMedia,

   193         TInt aError );

   194 

   195     /**

   196      *  Handle playback state changed.

   197      *

   198      *  @param aState New Playback state

   199      *  @param aData Extra data parameter, used for any extra information

   200      *               along with the state change message

   201      */

   202     IMPORT_C virtual void DoHandleStateChangedL(

   203         TMPXPlaybackState aState,

   204         TInt aData );

   205 

   206     /**

   207      * Get simple embedded mode.

   208      *

   209      * @return ETrue if the player is in the embedded mode (i.e. launched

   210      *         from Browser or Message Centre).

   211      */

   212     IMPORT_C virtual TBool SimpleEmbeddedMode() const;

   213 

   214     /**

   215      * Get embedded status.

   216      *

   217      * @return ETrue if in embedded mode. Otherwise, EFalse.

   218      */

   219     IMPORT_C virtual TBool IsEmbedded() const;

   220 

   221     /**

   222      * Displays error notes.

   223      *

   224      * @param aError Error ID to be handled.

   225      */

   226     IMPORT_C virtual void HandleErrorL( TInt aError );

   227 

   228     /**

   229      * Displays error note for when all tracks are invalid,

   230      * and goes back to collection list view

   231      */

   232     IMPORT_C virtual void HandleAllTracksInvalidL();

   233 

   234     /**

   235      * Checks whether or not to skip to next track on an error

   236      *

   237      * @param aCurrentIndex Current index

   238      */

   239     IMPORT_C virtual void SkipOnErrorL( TInt aCurrentIndex, TInt aCount );

   240 

   241     /**

   242      * Function to display information notes

   243      *

   244      * @param aResourceId Resource ID of the text string.

   245      */

   246     IMPORT_C virtual void DisplayInfoNoteL( TInt aResourceId );

   247 

   248     /**

   249      * Function to display confirmation notes

   250      *

   251      * @param aResourceId Resource ID of the text string.

   252      */

   253     IMPORT_C virtual void DisplayConfirmionNoteL( TInt aResourceId );

   254 

   255     /**

   256      * Set process priority.

   257      */

   258     IMPORT_C virtual void SetProcessPriority();

   259 

   260     /**

   261      * Launch equalizer dialog.

   262      */

   263     IMPORT_C virtual void LaunchEqualizerL();

   264 

   265     /**

   266      * Launch Music Settings view.

   267      */

   268     IMPORT_C virtual void LaunchMusicSettingsL();

   269 

   270     /**

   271      * Launch FM Transmitter

   272      */

   273     IMPORT_C virtual void LaunchFMTransmitterL();

   274 

   275     /**

   276      * Request for the media object

   277      * aDrm Flag whether or not to request all DRM info as well

   278      */

   279     IMPORT_C virtual void RequestMediaL( TBool aDrm=EFalse );

   280 

   281     /**

   282     * Prepare status pane for full-screen playback view.

   283     */

   284     void PrepareStatusPaneForPlaybackViewL();

   285 

   286     /**

   287     * Restore status pane to it's normal state.

   288     */

   289     void PrepareStatusPaneForExitingViewL();

   290 

   291     /**

   292      * Checks if UPnP AP is defined

   293      */

   294     IMPORT_C virtual TBool IsUpnpVisible();

   295 

   296     /**

   297      * Displays the available players in the Play via submenu

   298      */

   299     IMPORT_C virtual void AddPlayersNamesToMenuL( CEikMenuPane& aMenuPane );

   300 

   301     /**

   302      * Adds one player type to the Play via submenu

   303      * @param aMenuPane Menu pane

   304      * @param aCommandId Command id

   305      * @param aPlayerManager Playback Utility manager

   306      * @param aPlayerType Current player type (Local, Remote)

   307      * @param aMenuText Text to be added to the menu

   308      */

   309     IMPORT_C virtual void AddPlayerNameToMenuL( CEikMenuPane& aMenuPane,

   310                                 TInt aCommandId,

   311                                 MMPXPlayerManager& aPlayerManager,

   312                                 TMPXPlaybackPlayerType& aPlayerType,

   313                                 const TDesC& aMenuText = KNullDesC );

   314 

   315     /**

   316      * Retrieves the current player name and type

   317      */

   318     IMPORT_C virtual void GetCurrentPlayerDetails();

   319 

   320     /**

   321      * Selects a new player for audio playback

   322      */

   323     IMPORT_C virtual void SelectNewPlayerL( TInt aCommand );

   324 

   325     /**

   326      * Adds current item to a saved playlist

   327      */

   328     IMPORT_C virtual void AddToSavedPlaylistL();

   329 

   330     /**

   331      * Adds current item to a new playlist

   332      */

   333     IMPORT_C virtual void AddToNewPlaylistL();

   334 

   335     /**

   336      * Prepares media for adding to a playlist

   337      * @return Media object for adding to playlist.  Caller is

   338      * responsible for deleting and popping off cleanupstack

   339      */

   340     IMPORT_C virtual CMPXMedia* PrepareMediaForPlaylistLC(

   341         const CMPXMedia& aMedia );

   342 

   343     /**

   344      * Check if the command is supported by the remote player

   345      * @return TBool whether the command is supported or not

   346      */

   347     IMPORT_C virtual TBool IsCommandSupportedL();

   348 

   349 // from base class MProgressDialogCallback

   350     /**

   351      * From MProgressDialogCallback

   352      * Callback method

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

   354      */

   355     IMPORT_C virtual void DialogDismissedL( TInt aButtonId );

   356 

   357     /*

   358      * From MMPXCHelperObserver

   359      * Handles the completion of any collection helper event.

   360      *

   361      * @param aOperation, operation completed

   362      * @param aErr. the error code

   363      * @param aArgument Argument returned from the operation

   364      */

   365     IMPORT_C virtual void HandleOperationCompleteL( TCHelperOperation aOperation,

   366                                                     TInt aError,

   367                                                     void* aArgument );

   368 

   369 // from base class MMPXPlaybackObserver

   370 

   371     /**

   372      * From MMPXPlaybackObserver

   373      * Handle playback message

   374      *

   375      * @since 3.1

   376      * @param aMessage Playback Message

   377      * @param aErr system error code.

   378      */

   379     IMPORT_C virtual void HandlePlaybackMessage(

   380         CMPXMessage* aMessage, TInt aError );

   381 

   382 // from base class MMPXPlaybackCallback

   383 

   384     /**

   385      * From MMPXPlaybackCallback

   386      * Handle playback property

   387      *

   388      * @since 3.0

   389      * @param aProperty the property

   390      * @param aValue the value of the property

   391      * @param aError error code

   392      */

   393     IMPORT_C virtual void HandlePropertyL(

   394         TMPXPlaybackProperty aProperty,

   395         TInt aValue,

   396         TInt aError );

   397 

   398     /**

   399      * From MMPXPlaybackCallback

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

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

   402      * Only new items are passed each time

   403      *

   404      * @since 3.0

   405      * @param aPlayer UID of the subplayer

   406      * @param aSubPlayers a list of sub players

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

   408      *                  expected

   409      * @param aError error code

   410      */

   411     IMPORT_C virtual void HandleSubPlayerNamesL(

   412         TUid aPlayer,

   413         const MDesCArray* aSubPlayers,

   414         TBool aComplete,

   415         TInt aError );

   416 

   417     /**

   418      * From MMPXPlaybackCallback

   419      * Handle media properties

   420      *

   421      * @since 3.0

   422      * @param aMedia media

   423      * @param aError error code

   424      */

   425     IMPORT_C virtual void HandleMediaL(

   426         const CMPXMedia& aMedia,

   427         TInt aError );

   428 

   429 // from base class MMPXCollectionMediaObserver

   430     /**

   431     *  Handle extended media properties

   432     *

   433     *  @param aMedia media

   434     *  @param aError error code

   435     */

   436     IMPORT_C virtual void HandleCollectionMediaL(

   437         const CMPXMedia& aMedia,

   438         TInt aError);

   439 

   440 

   441 // from base class CAknView

   442 

   443     /**

   444      * From CAknView

   445      * Command handling function.

   446      *

   447      * @since 3.0

   448      * @param aCommand Command which is handled

   449      */

   450     IMPORT_C virtual void HandleCommandL( TInt aCommand );

   451 

   452     /**

   453      * From CAknView

   454      * Processes user commands.

   455      *

   456      * @since 3.0

   457      * @param aCommand ID of the command to respond to.

   458      */

   459     IMPORT_C virtual void ProcessCommandL( TInt aCommand );

   460 

   461     /**

   462      * From CAknView

   463      * Event handler for status pane size changes.

   464      *

   465      * @since 3.0

   466      */

   467     virtual void HandleStatusPaneSizeChange();

   468 

   469     /**

   470      * From CAknView

   471      * Handles a view activation.

   472      *

   473      * @param aPrevViewId Specifies the view previously active.

   474      * @param aCustomMessageId Specifies the message type.

   475      * @param aCustomMessage The activation message.

   476      */

   477     IMPORT_C virtual void DoActivateL(

   478         const TVwsViewId& aPrevViewId,

   479         TUid aCustomMessageId,

   480         const TDesC8& aCustomMessage );

   481 

   482     /**

   483      * From CAknView

   484      * View deactivation function.

   485      */

   486     IMPORT_C virtual void DoDeactivate();

   487 

   488     /**

   489      * From CAknView

   490      * Foreground event handling function.

   491      *

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

   493      */

   494     IMPORT_C virtual void HandleForegroundEventL( TBool aForeground );

   495 

   496 // from base class MEikMenuObserver

   497 

   498     /**

   499      * From MEikMenuObserver

   500      * Dynamically initialises a menu pane.

   501      *

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

   503      * @param aMenuPane The menu pane itself.

   504      */

   505     IMPORT_C void DynInitMenuPaneL(

   506         TInt aResourceId,

   507         CEikMenuPane* aMenuPane );

   508 

   509 // from base class MMPXLayoutSwitchObserver

   510 

   511     /**

   512      * From MMPXLayoutSwitchObserver

   513      * Callback function when layout is changed.

   514      *

   515      * @since S60 v3.0

   516      */

   517     IMPORT_C virtual void HandleLayoutChange();

   518 

   519 // from base class MCoeViewDeactivationObserver

   520 

   521     /**

   522      * From MCoeViewDeactivationObserver

   523      * Handles the activation of the view aNewlyActivatedViewId before

   524      * the old view aViewIdToBeDeactivated is to be deactivated

   525      *

   526      * @param aNewlyActivatedViewId View ID that is newly activated.

   527      * @param aViewIdToBeDeactivated View ID to be deactivated.

   528      */

   529     IMPORT_C virtual void HandleViewActivation(

   530         const TVwsViewId& aNewlyActivatedViewId,

   531         const TVwsViewId& aViewIdToBeDeactivated );

   532 

   533 // from base class MMPXViewActivationObserver

   534 

   535     /**

   536      * From MMPXViewActivationObserver

   537      * Handle view activation.

   538      *

   539      * @param aCurrentViewType Current view type Uid.

   540      * @param aPreviousViewType Previous view type Uid.

   541      */

   542     IMPORT_C virtual void HandleViewActivation(

   543         const TUid& aCurrentViewType,

   544         const TUid& aPreviousViewType );

   545 

   546     /**

   547      * @see MMPXViewActivationObserver

   548      */

   549     IMPORT_C void HandleViewUpdate(

   550         TUid aViewUid,

   551         MMPXViewActivationObserver::TViewUpdateEvent aUpdateEvent,

   552         TBool aLoaded,

   553         TInt aData);

   554 

   555 // from base class MMPXPSKeyObserver

   556 

   557     /**

   558     * From MMPXPSKeyObserver

   559     * Handle PS event

   560     *

   561     * @param aUid The UID that identifies the property category

   562     * @param aKey The property sub-key

   563     */

   564     IMPORT_C virtual void HandlePSEvent(

   565         TUid aUid,

   566         TInt aKey );

   567 

   568 // from base class MMPXCenRepObserver

   569 

   570     /**

   571     * From MMPXCenRepObserver

   572     * Handle a change in a setting value.

   573     *

   574     * @param aRepositoryUid Central repository UID containing the setting

   575     * @param aSettingId Id of the setting

   576     */

   577     IMPORT_C virtual void HandleSettingChange(

   578         const TUid& aRepositoryUid,

   579         TUint32 aSettingId );

   580 

   581 // From base class MMPXCollectionObserver

   582 

   583     /**

   584     * From MMPXCollectionObserver

   585     */

   586     IMPORT_C virtual void HandleCollectionMessage(CMPXMessage* aMsg, TInt aErr);

   587 

   588     /**

   589     * From MMPXCollectionObserver

   590     */

   591     IMPORT_C virtual void HandleOpenL(const CMPXMedia& aEntries, TInt aIndex,

   592                                       TBool aComplete, TInt aError);

   593 

   594     /**

   595     * From MMPXCollectionObserver

   596     */

   597     IMPORT_C virtual void HandleOpenL(const CMPXCollectionPlaylist& aPlaylist,TInt aError);

   598 

   599     /**

   600     * From MMPXCollectionObserver

   601     */

   602     IMPORT_C virtual void HandleCommandComplete(CMPXCommand* aCommandResult,

   603                                                 TInt aError);

   604 

   605     void FillAiwParametersL( CAiwGenericParamList& aParamList, TBool aSaved = EFalse );

   606     /**

   607      * Updates the middle softkey display to a label or icon depending on the playback state

   608      * @param aMskId middle softkey command id

   609      */

   610     IMPORT_C void UpdateMiddleSoftKeyDisplayL();

   611     /**

   612      * Updates the middle (play/pause) toolbar control key icon based on playback state

   613      */

   614     IMPORT_C void UpdateToolbar();

   615 protected:

   616     static TInt DeferredAlbumArtExtractCallback( TAny* aPtr );

   617 

   618     /**

   619     * Callback function for delayed view deactivation

   620     * @param aPtr pointer to self

   621     */

   622     static TInt DelayedExit( TAny* aPtr);

   623 

   624 private:

   625     /**

   626      *  Handle playback error message

   627      *

   628      *  @param aErr system error code.

   629      */

   630     void DoHandleErrorPlaybackMessageL( TInt aError );

   631 

   632     /**

   633      *  Handle collection message

   634      *

   635      *  @param aMsg Message to handle.

   636      *  @param aErr system error code.

   637      */

   638     void DoHandleCollectionMessageL( CMPXMessage* aMsg, TInt aErr );

   639     

   640     /**

   641      * Callback function of timer to handle delayed error

   642      * @param aPtr pointer to self

   643      */

   644     static TInt HandleDelayedError( TAny* aPtr );

   645 

   646 protected:    // Data

   647 

   648     MMPXPlaybackUtility* iPlaybackUtility;  // not own

   649     CMPXCommonPlaybackViewContainer* iContainer;  // own

   650 

   651     CMPXAlbumArtUtil* iMPXUtility;   // own

   652     CMPXMedia* iMedia;  // own

   653 

   654     CMPXCommonUiHelper* iCommonUiHelper;    // own

   655 

   656     CMPXPSKeyWatcher*   iPSKeyWatcher;      // own

   657     CMPXCenRepWatcher*  iCRWatcher;         // own

   658     TInt                iFMTxFreqKHz;

   659 

   660     // View utility.

   661     MMPXViewUtility* iViewUtility;

   662 

   663     // Current playback states

   664     TInt iDuration; // in seconds

   665     TInt iPosition; // in seconds

   666     TMPXPlaybackState iPlaybackState;

   667     TInt iRandomMode;

   668     TInt iRepeatMode;

   669 

   670     TBool iEmbedded;

   671     TBool iSwitchingView;

   672     TBool iExitOptionHidden;

   673 

   674     // Feature flag for set as ringtone

   675     TBool iChangeRTForAllProfiles;

   676 

   677     // Error code to be handled at a later time

   678     TInt iDelayedError;

   679 

   680     CMPXCommonPlaybackViewLayout* iLayout;  // owned

   681 

   682 //#ifdef __UPNP_FRAMEWORK_2_0_

   683     RArray<TUid> iPlayersList;

   684     TMPXPlaybackPlayerType iCurrentPlayerType;

   685     HBufC* iSubPlayerName;

   686 //#endif //__UPNP_FRAMEWORK_2_0_

   687 

   688     CAknProgressDialog* iWaitNote;

   689 

   690     MMPXCollectionUtility* iCollectionUtility;

   691     MMPXCollectionUiHelper* iCollectionUiHelper;

   692 

   693     TInt iStartPlaybackIndex;

   694     TInt iLastSkipDirection;

   695     TBool iSkipping;

   696     TInt iPreviousStatusPaneLayout;

   697 

   698     // Flag whether or not this was the last playback view activated,

   699     // used for error handling

   700     TBool iLastPBViewActivated;

   701 

   702     // Flag used for disable error msg pop up when usb event happens

   703     TBool iIgnoredByUsbEvent;

   704 

   705     // Flag that next view to be activated is a playback view type

   706     TBool iPBViewToBeActivated;

   707     

   708     // Flag that indicates Camese SuperDistribution Support

   709     TBool iCameseSuperDistSupport;

   710 

   711     // Flag that indicates a new item has been opened from Collection View.

   712     // Used for Camese Superdistribution error handling.

   713     TBool iNewItemOpened;

   714 

   715     CIdle* iIdle;

   716 

   717     // Idle for delayed exit

   718     CIdle* iDelayedExit;

   719 

   720 private:    // Data

   721 

   722     TInt iResourceOffset;       // must be freed

   723 

   724     TInt iFMTXResourceOffset;   // must be freed

   725 

   726 #ifdef IAD_INCLUDE_BACKSTEPPING

   727     MMPXBackSteppingUtility* iBackSteppingUtility;

   728 #endif // BACKSTEPPING_INCLUDED

   729 

   730     CMPXMedia* iUserPlaylists;  // owned

   731     TBool iKeySoundDisabled;

   732     TBool iDatabaseNotReady;

   733     CAiwServiceHandler* iServiceHandler;

   734     CMediaRecognizer* iMediaRecognizer;

   735     TInt iErrorAttachAssignMenu;

   736     TBool iSkipBtnPressed;

   737 

   738 //#ifdef __UPNP_FRAMEWORK_2_0_

   739     TBool iUpnpFrameworkSupport;

   740 //#endif //__UPNP_FRAMEWORK_2_0_

   741 

   742     TInt iLastDelayedErr;

   743     TInt iErrIndex;

   744     CPeriodic* iDelayedErrorTimer;

   745     // Indicate FF button pressed or not

   746     TBool iIsffButtonPressed;

   747     TBool iBacking;

   748 #ifdef IAD_INCLUDE_UPNP    

   749 	CUpnpCopyCommand* iUpnpCopyCommand;

   750 #endif

   751 	TBool iUnsupportedNoteDisabled;

   752     HBufC* iOldUri;

   753 	TInt iOldPosition; // in seconds

   754 	TBool iIsTapped;

   755     TCommandSender iCommandSender;

   756     };

   757 

   758 #endif  // CMPXCOMMONPLAYBACKVIEWIMP_H

   759 

   760 // End of File