mpxplugins/serviceplugins/collectionplugins/mpxsqlitepodcastdbplugin/inc/mpxpodcastdbplugin.h
changeset 0 ff3acec5bc43
equal deleted inserted replaced
-1:000000000000 0:ff3acec5bc43
       
     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:  Implementation of Podcast Collection Database Plugin interface
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 #ifndef MPXPODCASTDBPLUGIN_H
       
    20 #define MPXPODCASTDBPLUGIN_H
       
    21 
       
    22 // INCLUDES
       
    23 #include <badesca.h>
       
    24 
       
    25 #include <mpxcommonframeworkdefs.h>
       
    26 #include <mpxcollectionframeworkdefs.h>
       
    27 #include <mpxcollectionplugin.h>
       
    28 #include <mpxcollectionpath.h>
       
    29 #include <mpxmediageneraldefs.h>
       
    30 #include <mpxpodcastdefs.h>
       
    31 #include <mpxmessage2.h>
       
    32 
       
    33 #include "mpxdbactivetask.h"
       
    34 #include "mpxpodcastcollectiondb.hrh"
       
    35 
       
    36 // FORWARD DECLARATIONS
       
    37 class CMPXMedia;
       
    38 class CMPXPodcastDbHandler;
       
    39 class CMPXDrmMediaUtility;
       
    40 class CMPXMediaArray;
       
    41 class CMPXResource;
       
    42 
       
    43 // CONSTANTS
       
    44 
       
    45 // CLASS DECLARATION
       
    46 
       
    47 /**
       
    48 * Plug-in provides access to podcast collection.
       
    49 *
       
    50 * @lib mpxpodcastdbplugin.lib
       
    51 */
       
    52 NONSHARABLE_CLASS(CMPXPodcastDbPlugin) :
       
    53     public CMPXCollectionPlugin,
       
    54     public MMPXDbActiveTaskObserver
       
    55     {
       
    56 public: // Constructors and destructor
       
    57 
       
    58     /**
       
    59     * Two-phased constructor
       
    60     * @param aInitParams: initialization parameters
       
    61     * @return object constructed
       
    62     */
       
    63     static CMPXPodcastDbPlugin* NewL (TAny* aInitParams);
       
    64 
       
    65     /**
       
    66     * Destructor
       
    67     */
       
    68     virtual ~CMPXPodcastDbPlugin();
       
    69 
       
    70 public: // from base clase
       
    71     /**
       
    72     * From CMPXCollectionPlugin
       
    73     * Navigates to the given path.  This method is serviced
       
    74     * asynchronously and HandleOpenL is called upon completion
       
    75     * @param aPath a path
       
    76     * @param aAttrs attributes requested
       
    77     * @param aFilter filter to apply or NULL if none
       
    78     */
       
    79     void OpenL(const CMPXCollectionPath& aPath,
       
    80                const TArray<TMPXAttribute>& aAttrs,
       
    81                CMPXFilter* aFilter);
       
    82 
       
    83     /**
       
    84     * From CMPXCollectionPlugin
       
    85     * Get the extended properties of the item referred to by the
       
    86     * specified collection path.  This method is serviced asynchronously and
       
    87     * HandleMediaL is called upon completion
       
    88     * @param aPath a collection path referring to the item to retrieve the
       
    89     *               extended properties for
       
    90     * @param aAttr: array of attributes requested
       
    91     * @param aCaps platsec capabilities of client requesting media; plug-in
       
    92     *        should also verify its process capabilities (not yet supported)
       
    93     * @aParam aSpecs specifications for attributes (not yet supported)
       
    94     */
       
    95     void MediaL(const CMPXCollectionPath& aPath,
       
    96                 const TArray<TMPXAttribute>& aAttrs,
       
    97                 const TArray<TCapability>& aCaps,
       
    98                 CMPXAttributeSpecs* aSpecs);
       
    99 
       
   100     /**
       
   101     * From CMPXCollectionPlugin
       
   102     * Cancel outstanding request. Note*** CancelRequest is not currently
       
   103     * implemented because all requests are processed synchronously
       
   104     */
       
   105     void CancelRequest();
       
   106 
       
   107     /**
       
   108     * From CMPXCollectionPlugin
       
   109     * Executes the given TMPXCollectionCommand command on the collection
       
   110     * @param aCmd a command
       
   111     * @param aArg an argument
       
   112     */
       
   113     void CommandL(TMPXCollectionCommand aCmd, TInt aArg = 0);
       
   114 
       
   115     /**
       
   116     * From CMPXCollectionPlugin
       
   117     * Executes the given CMPXCommand command on the collection
       
   118     * @param aCmd a command
       
   119     */
       
   120     void CommandL(CMPXCommand& aCmd);
       
   121 
       
   122     /**
       
   123     * From CMPXCollectionPlugin
       
   124     * Adds an episode to the collection
       
   125     * @param aMedia Properties of the item
       
   126     */
       
   127     void AddL(const CMPXMedia& aMedia);
       
   128 
       
   129     /**
       
   130     * From CMPXCollectionPlugin
       
   131     * Remove an item(s) from the collection database using the given path
       
   132     * Note that the selection indices are hidden within the path
       
   133     * @param aPath: path to the item to be removed
       
   134     *
       
   135     */
       
   136     void RemoveL(const CMPXCollectionPath& aPath);
       
   137 
       
   138     /**
       
   139     *  Remove item(s) from the collection database using the given media properties
       
   140     *  @param aMedia Properties of the item(s) to be removed. May cantain a URI
       
   141     *                 or metadata. All item(s) matching the specified properties
       
   142     *                 will be removed.
       
   143     */
       
   144     void RemoveL(const CMPXMedia& aMedia);
       
   145 
       
   146     /**
       
   147     *  Sets/updates the specified media for an item in the collection.  Media
       
   148     *  is identified by specifying an ID or URI.
       
   149     *  @param aMedia: new property values for the item
       
   150     */
       
   151     void SetL(const CMPXMedia& aMedia);
       
   152 
       
   153     /**
       
   154     * From CMPXCollectionPlugin
       
   155     *  Find the items matching the media specifications.  This method is serviced
       
   156     *  asynchronously and HandleFindAllL is called upon completion
       
   157     *  @param aCriteria Properties of the item that is to be found
       
   158     *  @param aAttrs Requested attributes to return
       
   159     */
       
   160     void FindAllL(const CMPXMedia& aCriteria, const TArray<TMPXAttribute>& aAttrs);
       
   161 
       
   162     /**
       
   163     *  From CMPXCollectionPlugin
       
   164     *  Find the items matching the media specifications
       
   165     *  @param aCriteria Properties of the item that is to be found
       
   166     *  @param aAttrs Requested attributes to return
       
   167     *  @return results of the search. Method abandons ownership of results.
       
   168     */
       
   169     CMPXMedia* FindAllSyncL(const CMPXMedia& aCriteria,
       
   170                             const TArray<TMPXAttribute>& aAttrs);
       
   171 
       
   172     /**
       
   173     * Get the list of supported capabilities
       
   174     * @return TCollectionCapability, bitmask of supported capabilities
       
   175     */
       
   176     TCollectionCapability GetCapabilities();
       
   177 
       
   178     /**
       
   179     * From MMPXDbActiveTaskObserver
       
   180     */
       
   181     TBool HandleStepL();
       
   182 
       
   183     /**
       
   184     * From MMPXDbActiveTaskObserver
       
   185     */
       
   186     void HandleOperationCompleted( TInt aErr );
       
   187 
       
   188 private:
       
   189     /**
       
   190     * Constructor
       
   191     */
       
   192     CMPXPodcastDbPlugin ();
       
   193 
       
   194     /**
       
   195     * Symbian 2nd phase constructor.
       
   196     */
       
   197     void ConstructL ();
       
   198 
       
   199     /**
       
   200     * Process the OpenL command
       
   201     * @param aPath a path
       
   202     * @param aAttrs Requested attributes to return
       
   203     * @param aEntries (Output parameter) collection items containing media properties
       
   204     *                  of all items, returned if opening a group of items
       
   205     * @param aFlagToSignalToBePlayed: signals that item is opened to be played if type == episode
       
   206     * @return ETrue if the open is for a episode, EFalse otherwise
       
   207     */
       
   208     TBool DoOpenL(const CMPXCollectionPath& aPath,
       
   209                   const TArray<TMPXAttribute>& aAttrs,
       
   210                   CMPXMedia& aEntries,
       
   211                   TBool aFlagToSignalToBePlayed);
       
   212 
       
   213     /**
       
   214     * Process the OpenL(EBrowseAll) command
       
   215     * @param aPath Path
       
   216     * @param aAttrs Requested attributes to return
       
   217     * @param aEntries (Output parameter) collection items containing media properties
       
   218     *                  of all items, returned if opening a group of items
       
   219     * @param aArray (Output parameter) collection items
       
   220     * @return ETrue if the open is for an episode, EFalse otherwise
       
   221     */
       
   222     TBool DoOpenBrowseAllL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,
       
   223         CMPXMedia& aEntries, CMPXMediaArray& aArray);
       
   224 
       
   225     /**
       
   226     * Process the OpenL(EBrowsePubDate) command
       
   227     * @param aPath Path
       
   228     * @param aAttrs Requested attributes to return
       
   229     * @param aEntries (Output parameter) collection items containing media properties
       
   230     *                  of all items, returned if opening a group of items
       
   231     * @param aArray (Output parameter) collection items
       
   232     * @return ETrue if the open is for an episode, EFalse otherwise
       
   233     */
       
   234     TBool DoOpenBrowsePubDateL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,
       
   235         CMPXMedia& aEntries, CMPXMediaArray& aArray);
       
   236 
       
   237     /**
       
   238     * Process the OpenL(EBrowseTitle) command
       
   239     * @param aPath Path
       
   240     * @param aAttrs Requested attributes to return
       
   241     * @param aEntries (Output parameter) collection items containing media properties
       
   242     *                  of all items, returned if opening a group of items
       
   243     * @param aArray (Output parameter) collection items
       
   244     * @return ETrue if the open is for an episode, EFalse otherwise
       
   245     */
       
   246     TBool DoOpenBrowseTitleL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,
       
   247         CMPXMedia& aEntries, CMPXMediaArray& aArray);
       
   248 
       
   249     /**
       
   250     * Process the OpenL(EBrowseRecentlyAdded) command
       
   251     * @param aPath Path
       
   252     * @param aAttrs Requested attributes to return
       
   253     * @param aEntries (Output parameter) collection items containing media properties
       
   254     *                  of all items, returned if opening a group of items
       
   255     * @param aArray (Output parameter) collection items
       
   256     * @return ETrue if the open is for an episode, EFalse otherwise
       
   257     */
       
   258     TBool DoOpenBrowseRecentlyAddedL(const CMPXCollectionPath& aPath,
       
   259         const TArray<TMPXAttribute>& aAttrs, CMPXMedia& aEntries, CMPXMediaArray& aArray);
       
   260 
       
   261     /**
       
   262     * Process the OpenL(EBrowseNotPlayed) command
       
   263     * @param aPath Path
       
   264     * @param aAttrs Requested attributes to return
       
   265     * @param aEntries (Output parameter) collection items containing media properties
       
   266     *                  of all items, returned if opening a group of items
       
   267     * @param aArray (Output parameter) collection items
       
   268     * @return ETrue if the open is for an episode, EFalse otherwise
       
   269     */
       
   270     TBool DoOpenBrowseNotPlayedL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,
       
   271         CMPXMedia& aEntries, CMPXMediaArray& aArray);
       
   272 
       
   273    /**
       
   274     * Process an OpenL command with a EMPXOpenPlaylistOnly open mode
       
   275     * @param aPath path that we want to open
       
   276     * @param aAttrs default attributes to fetch
       
   277     * @param aFlagToSignalToBePlayed: signals that item is opened to be played if type == episode
       
   278     * @return CMPXCollectionPath* which is the new valid browse path
       
   279     *                             Method abandons ownership.
       
   280     */
       
   281     CMPXCollectionPath* DoOpenPlaylistL( const CMPXCollectionPath& aPath,
       
   282                                          const TArray<TMPXAttribute>& aAttrs,
       
   283                                          TBool aFlagToSignalToBePlayed);
       
   284 
       
   285     /**
       
   286     * Process the MediaL command
       
   287     * @param aPath a path
       
   288     * @param aAttrs Requested attributes to return
       
   289     * @param aEntries collection items containing media properties
       
   290     *                  of all items, returned if opening a group of items
       
   291     */
       
   292     void DoMediaL(const CMPXCollectionPath& aPath,
       
   293                    const TArray<TMPXAttribute>& aAttrs,
       
   294                    CMPXMedia& aEntries);
       
   295 
       
   296     /**
       
   297     * Get the plugin title, subtitle, icons for this plugin
       
   298     * @param aAttrs attributes to find
       
   299     * @param aMedia media object
       
   300     */
       
   301     void DoRootMediaL(const TArray<TMPXAttribute>& aAttrs, CMPXMedia& aMedia);
       
   302 
       
   303     /**
       
   304     * Get the media under ALL EPISODES category
       
   305     * @param aPath path that leads to a media under ALL EPISODES
       
   306     * @param aAttrs attributes of media to find
       
   307     * @param aEntries the media referred by the path
       
   308     * @param aMediaArray media entries contained in the media referred by the path
       
   309     */
       
   310     void DoAllEpisodesMediaL(const CMPXCollectionPath& aPath,
       
   311                             const TArray<TMPXAttribute>& aAttrs,
       
   312                             CMPXMedia& aEntries,
       
   313                             CMPXMediaArray& aMediaArray);
       
   314 
       
   315     /**
       
   316     * Find the collection media for by publish date category
       
   317     * @param aPath path that leads to a media under BY PUBLISH DATE
       
   318     * @param aAttrs attributes of media to find
       
   319     * @param aEntries the media referred by the path
       
   320     * @param aMediaArray media entries contained in the media referred by the path
       
   321     */
       
   322     void DoByPublishDateMediaL(const CMPXCollectionPath& aPath,
       
   323                                   const TArray<TMPXAttribute>& aAttrs,
       
   324                                   CMPXMedia& aEntries,
       
   325                                   CMPXMediaArray& aMediaArray);
       
   326 
       
   327     /**
       
   328     * Find the collection media for by titles category
       
   329     * @param aPath path that leads to a media under TITLES
       
   330     * @param aAttrs attributes of media to find
       
   331     * @param aEntries the media referred by the path
       
   332     * @param aMediaArray media entries contained in the media referred by the path
       
   333     */
       
   334     void DoTitlesMediaL(const CMPXCollectionPath& aPath,
       
   335                           const TArray<TMPXAttribute>& aAttrs,
       
   336                           CMPXMedia& aEntries,
       
   337                           CMPXMediaArray& aMediaArray);
       
   338 
       
   339     /**
       
   340     * Find the collection media for by recently added category
       
   341     * @param aPath path that leads to a media under RECENTLY ADDED
       
   342     * @param aAttrs attributes of media to find
       
   343     * @param aEntries the media referred by the path
       
   344     * @param aMediaArray medias contained in the media referred by the path
       
   345     */
       
   346     void DoRecentlyAddedMediaL(const CMPXCollectionPath& aPath,
       
   347                                  const TArray<TMPXAttribute>& aAttrs,
       
   348                                  CMPXMedia& aEntries,
       
   349                                  CMPXMediaArray& aMediaArray);
       
   350 
       
   351 
       
   352     /**
       
   353     * Find the collection media for by not yet played category
       
   354     * @param aPath path that leads to a media under NOT YET PLAYED
       
   355     * @param aAttrs attributes of media to find
       
   356     * @param aEntries the media referred by the path
       
   357     * @param aMediaArray medias contained in the media referred by the path
       
   358     */
       
   359     void DoNotYetPlayedMediaL(const CMPXCollectionPath& aPath,
       
   360                                 const TArray<TMPXAttribute>& aAttrs,
       
   361                                 CMPXMedia& aEntries,
       
   362                                 CMPXMediaArray& aMediaArray);
       
   363 
       
   364     /**
       
   365     * Get the root media.
       
   366     * @param aAttrs attributes of media to find
       
   367     * @param aRootCategoryId Id of the root media in the category, i.e. all albums,
       
   368     *        ...etc.
       
   369     * @param aCategory specifies the category.
       
   370     * @param aEntries the media referred by the path
       
   371     */
       
   372     void DoRootCategoryMediaL(const TArray<TMPXAttribute>& aAttrs,
       
   373                                TMPXItemId aRootCategoryId,
       
   374                                TMPXPodcastCategory aCategory,
       
   375                                CMPXMedia& aEntries);
       
   376 
       
   377     /**
       
   378     * Set all the attributes in CMPXMedia corresponding to KMPXMediaIdDrm
       
   379     * @param aMedia, media to update
       
   380     * @param aDrmAttributes, bitwise or of the flags we want
       
   381     * @param aLocation, full file path including filename
       
   382     */
       
   383     void DoSetMediaDrmL(CMPXMedia& aMedia, TUint aDrmAttributes, const TDesC& aLocation);
       
   384 
       
   385     /**
       
   386     * Add media objects to the array with attributes from episode details
       
   387     * @param aPath a path
       
   388     * @param aAttrs requested attributes
       
   389     * @param aEntry media to contain information about the container if it contains
       
   390     *        than one entry
       
   391     * @param aMediaArray array to contain all the media objects added
       
   392     */
       
   393     void GetEpisodeInfoL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,
       
   394         CMPXMedia& aEntry, CMPXMediaArray& aMediaArray);
       
   395 
       
   396     /**
       
   397     * Add media objects to the array with attributes from episode details
       
   398     * @param aAttrs requested attributes
       
   399     * @param aEntryId episode ID
       
   400     * @param aEntry media to contain information about the container if it contains
       
   401     *        than one entry
       
   402     */
       
   403     void DoGetEpisodeInfoL(const TArray<TMPXAttribute>& aAttrs, TInt aEntryId, CMPXMedia& aEntry);
       
   404 
       
   405     /**
       
   406     * Get the collection details from the db
       
   407     * @param aAttrs attributes to find
       
   408     * @param aPath path to be set if required
       
   409     * @param aMedia media object
       
   410     */
       
   411     void DoHandleOtherMediaAttributesL(const TArray<TMPXAttribute>& aAttrs,
       
   412         const CMPXCollectionPath& aPath, CMPXMedia& aMedia);
       
   413 
       
   414     /**
       
   415     * Remove an item from the collection database using the given path
       
   416     * Note that the selection indices are hidden within the path
       
   417     * @param aPath path to the item to be removed
       
   418     * @param aChangeMsgArray array to store change messages
       
   419     * @return an array of files associated with the removed media entries
       
   420     */
       
   421     CDesCArray* DoRemoveL(const CMPXCollectionPath& aPath,
       
   422                            CMPXMessageArray& aChangeMsgArray);
       
   423 
       
   424     /**
       
   425     * Remove an item/items from the collection database using the given media properties
       
   426     * @param aMedia Properties of the item that is to be removed. It may cantain URI only
       
   427     *                or meta data, all of items matched properties will be removed.
       
   428     * @param aDeleteRecord indicates whether the client has explictly requested
       
   429     *                to delete the records from the database. If ETrue, records
       
   430     *                associated with the media will be deleted from the database;
       
   431     *                if EFalse, whether to mark the records as deleted or to delete
       
   432     *                the records will be based on other deciding factors.
       
   433     */
       
   434     void DoRemoveL(const CMPXMedia& aMedia, TBool aDeleteRecord);
       
   435 
       
   436     /**
       
   437     * Remove an item from the collection database using a command
       
   438     * @param aCmd remove command which contains collection path to the media entries to be
       
   439     *        removed. This method should be called until all the selected items are
       
   440     *        removed. When that happens, EMPXCommandCompleted flag is set to ETrue.
       
   441     */
       
   442     void DoRemovePathL(CMPXCommand& aCmd);
       
   443 
       
   444     /**
       
   445     * Remove a media entry/entries from the collection database using a command
       
   446     * @param aCmd remove command which contains the media(s) to be removed. This
       
   447     *        will delete the records from the database rather than marking them
       
   448     *        as deleted. Designated caller is MTP.
       
   449     */
       
   450     void DoRemoveMediaL(CMPXCommand& aCmd);
       
   451 
       
   452     /**
       
   453     * Remove a media entry/entries from all episodes view
       
   454     * @param aPath collection path that points to the media entry/entries to be removed
       
   455     * @param aSelections multiple media items selected. This array contains the id
       
   456     *        of the selected media.
       
   457     * @param aUriArray a descriptor array containing the URI(s) of the deleted file(s)
       
   458     * @param aItemChangedMessages a list of change events as a result of the
       
   459     *        episode removals
       
   460     */
       
   461     void DoRemoveFromAllEpisodesL(const CMPXCollectionPath& aPath,
       
   462                                   const TArray<TMPXItemId>& aSelections,
       
   463                                   CDesCArray& aUriArray,
       
   464                                   CMPXMessageArray& aItemChangedMessages);
       
   465 
       
   466     /**
       
   467     * Remove media from Publish Date view
       
   468     * @param aPath collection path that points to the media entry/entries to be removed
       
   469     * @param aSelections multiple media entry/entries selected. This array contains the id
       
   470     *        of the selected media.
       
   471     * @param aUriArray a descriptor array to contain the URI(s) of the deleted file(s)
       
   472     * @param aItemChangedMessages a list of change events as a result of the
       
   473     *        episode removals
       
   474     */
       
   475     void DoRemoveFromPublishDateL(const CMPXCollectionPath& aPath,
       
   476                                   const TArray<TMPXItemId>& aSelections,
       
   477                                   CDesCArray& aUriArray,
       
   478                                   CMPXMessageArray& aItemChangedMessages);
       
   479 
       
   480     /**
       
   481     * Remove a media item from Publish Date view
       
   482     * @param aPath collection path that points to the media entry/entries to be removed
       
   483     * @param aItemId ID of the item to be removed
       
   484     * @param aUriArray a descriptor array to contain the URI(s) of the deleted file(s)
       
   485     * @param aItemChangedMessages a list of change events as a result of the
       
   486     *        episode removals
       
   487     */
       
   488     void RemoveFromPublishDateL(const CMPXCollectionPath& aPath, TInt aItemId,
       
   489         CDesCArray& aUriArray, CMPXMessageArray& aItemChangedMessages);
       
   490 
       
   491     /**
       
   492     * Remove a media/medias from albums/genres/composers view
       
   493     * @param aPath collection path that points to the media(s) to be removed
       
   494     * @param aSelections multiple medias selected. This array contains the id
       
   495     *        of the selected media.
       
   496     * @param aCategory indicates one of the 3 categories, EMPXAlbum, EMPXGenre, or
       
   497     *        EMPXComposer
       
   498     * @param aUriArray a descriptor array to contain the URI of the deleted file
       
   499     * @param aItemChangedMessages a list of change events as a result of the
       
   500     *        episode removals
       
   501     */
       
   502     void DoRemoveFromCategoriesL(const CMPXCollectionPath& aPath,
       
   503                                  const TArray<TMPXItemId>& aSelections,
       
   504                                  TMPXGeneralCategory aCategory,
       
   505                                  CDesCArray& aUriArray,
       
   506                                  CMPXMessageArray& aItemChangedMessages);
       
   507 
       
   508     /**
       
   509     * Remove a media item from albums/genres/composers view
       
   510     * @param aPath collection path that points to the media entry/entries to be removed
       
   511     * @param aItemId ID of the item to be removed
       
   512     * @param aCategory indicates one of the 3 categories, EMPXAlbum, EMPXGenre, or
       
   513     *        EMPXComposer
       
   514     * @param aUriArray a descriptor array to contain the URI(s) of the deleted file(s)
       
   515     * @param aItemChangedMessages a list of change events as a result of the
       
   516     *        episode removals
       
   517     */
       
   518     void RemoveFromCategoriesL(const CMPXCollectionPath& aPath, TInt aItemId,
       
   519         TMPXGeneralCategory aCategory, CDesCArray& aUriArray,
       
   520         CMPXMessageArray& aItemChangedMessages);
       
   521 
       
   522    /**
       
   523     * Fetch the duration for a specific category
       
   524     * @param aMedia a media object of which EMPXMediaGeneralDuration is to be
       
   525     *        populated with the duration calculated in this method
       
   526     * @param aCategory category of the ID
       
   527     * @param aId id for identifying which category to calculate the duration for
       
   528     */
       
   529     TInt DoDurationL(CMPXMedia& aMedia, TMPXPodcastCategory aCategory, TMPXItemId aId = 0);
       
   530 
       
   531     /**
       
   532     * Retrieves URIs associated with the path for file deletion
       
   533     * @param aCmd command to retrieve associated URIs for the given path. If
       
   534     *        path ends with a particular artist/album/genre/composer, the path
       
   535     *        will be updated to include all episodes in that category. If path
       
   536     *        ends with one or more medias in a particular playlist, an array
       
   537     *        of 0 elements will be returned to avoid client deleting them from
       
   538     *        the file system
       
   539     */
       
   540     void DoRetrieveUriForDeletionL(CMPXCommand& aCmd);
       
   541 
       
   542     /**
       
   543     * Deletes records which have been marked as deleted from the collection
       
   544     * @param aCmd command to cleanup deleted medias.
       
   545     *        see KMPXCommandIdCollectionCleanupDeletedMedias defined in
       
   546     *        mpxcollectioncommanddefs.h
       
   547     */
       
   548     void CleanupDeletedRecordsL(CMPXCommand& aCmd);
       
   549 
       
   550     /**
       
   551     * Append a collection level to the collection path
       
   552     * @param aPath path to append the level to
       
   553     * @param aMedia media to extract media ids from
       
   554     * @note: Selection will be put on the first episode in the collection path
       
   555     */
       
   556     TInt DoAppendLevelL(CMPXCollectionPath& aPath, CMPXMedia& aMedia);
       
   557 
       
   558     /* Append a collection level to the collection path with all episodes under the
       
   559     * selected category/categories (e.g. artist/artist-album/album/genre/composer).
       
   560     * Once the level is appended, all episodes under the selected category/categories
       
   561     * are selected.
       
   562     * @param aPath path to append the level to. Path remains unchanged if it's not
       
   563     *        one of the following:
       
   564     *        1) path ends at an artist or selected artists
       
   565     *        2) path ends at an album of an artist or selected albums of an artist
       
   566     *        3) path ends at an album or selected albums
       
   567     *        4) path ends at a genre or selected genres
       
   568     *        5) path ends at a composer or selected composers
       
   569     */
       
   570     void DoAppendLevelL(CMPXCollectionPath& aPath);
       
   571 
       
   572     /**
       
   573     * Execute a task step for an asynchronous add
       
   574     * @return ETrue if done
       
   575     */
       
   576     TBool DoAddAsyncL();
       
   577 
       
   578     /**
       
   579     * Add a media object to the collection
       
   580     * @param aMedia media to add
       
   581     * @return TUint32 item id of the item added
       
   582     */
       
   583     TUint32 DoAddL(const CMPXMedia& aMedia);
       
   584 
       
   585     /**
       
   586     * Add an item into the collection
       
   587     * @param aMedia media to add
       
   588     * @param aMessageArray change message array
       
   589     * @return TUint32 item id of the item added
       
   590     */
       
   591     TUint32 DoAddItemL(const CMPXMedia& aMedia, CMPXMessageArray& aMessageArray);
       
   592 
       
   593     /**
       
   594     * Set a media object to update the collection
       
   595     * @param aMedia media can be an item or a list. The item is treated as a list
       
   596     *               if it contains a media array
       
   597     */
       
   598     void DoSetL(const CMPXMedia& aMedia);
       
   599 
       
   600     /**
       
   601     * Execute a task step for an asynchronous set
       
   602     */
       
   603     TBool DoSetAsyncL();
       
   604 
       
   605     /**
       
   606     * Send a change message
       
   607     * @param aMessage a change message to be sent
       
   608     */
       
   609     void HandleChangeL(const CMPXMessage& aMessage);
       
   610 
       
   611     /**
       
   612     * Construct a CMPXMedia from the array parameter and call HandleChange
       
   613     * @param aItemChangedMessages array in the change message to be sent
       
   614     */
       
   615     void DoHandleChangeL(CMPXMessageArray* aItemChangedMessages);
       
   616 
       
   617     /**
       
   618     * Generates and calls back an out of disk CMPXMessage
       
   619     * This function will callback to the client context to
       
   620     * broadcast an out of disk event
       
   621     */
       
   622     void HandleOutOfDiskMessageL();
       
   623 
       
   624     /**
       
   625     * Leaving function to handle async op completion
       
   626     * @param aErr error code
       
   627     */
       
   628     void DoHandleOperationCompletedL(TInt aErr);
       
   629 
       
   630     /**
       
   631     * Complete a delete operation
       
   632     * Sends out change messages and compacts the database
       
   633     */
       
   634     void DoHandleDeleteCompleteL(CMPXCommand& aCmd);
       
   635 
       
   636     /**
       
   637     * Returns the category for a given browse type.
       
   638     * @param aBrowseType browse type
       
   639     * @return Category ID
       
   640     */
       
   641     TMPXPodcastCategory CategoryForBrowseType(TMCBrowseType aBrowseType);
       
   642 
       
   643     /**
       
   644     * Returns the browse type for a given category ID.
       
   645     * @param aCategory category ID
       
   646     * @return Browse type
       
   647     */
       
   648     TMCBrowseType BrowseTypeForCategory(TMPXPodcastCategory aCategory);
       
   649 
       
   650     /**
       
   651     * Sets the type, category and title attributes in the specified media.
       
   652     * @param aMedia media instance to be updated
       
   653     * @param aGeneralType general type attribute value
       
   654     * @param aType podcast type attribute value
       
   655     * @param aCategory category attribute value
       
   656     * @param aTitle title attribute value
       
   657     * @param aCount general count attribute value
       
   658     */
       
   659     void SetMediaGeneralAttributesL(CMPXMedia& aMedia, TMPXGeneralType aGeneralType,
       
   660         TMPXPodcastType aType, TMPXPodcastCategory aCategory, const TDesC& aTitle,
       
   661         TInt aCount = -1);
       
   662 
       
   663     /**
       
   664     * Sets the type, category and title attributes in the specified media.
       
   665     * @param aMedia media instance to be updated
       
   666     * @param aGeneralType general type attribute value
       
   667     * @param aType type attribute value
       
   668     * @param aCategory category attribute value
       
   669     * @param aId ID of the item to the title from
       
   670     * @param aCount general count attribute value
       
   671     */
       
   672     void SetMediaGeneralAttributesL(CMPXMedia& aMedia, TMPXGeneralType aGeneralType,
       
   673         TMPXPodcastType aType, TMPXPodcastCategory aCategory, TInt aId, TInt aCount = -1);
       
   674 
       
   675     /**
       
   676     * Get total podcasts count
       
   677     * @param aCmd command to return count
       
   678     *        see KMPXCommandCollectionGetCount defined in
       
   679     *        mpxcollectioncommanddefs.h
       
   680     */
       
   681     void DoGetCollectionCountL( const CMPXCommand& aCmd );
       
   682 
       
   683     /**
       
   684     * Get an array of URIs for all podcasts in a given db
       
   685     * @param aCmd command to return CDesCArray
       
   686     *        see KMPXCommandCollectionGetURIs defined in
       
   687     *        mpxcollectioncommanddefs.h
       
   688     */
       
   689     void DoGetCollectionUriL( const CMPXCommand& aCmd );
       
   690 
       
   691     /**
       
   692     * Set the attribute list according to current path
       
   693     * @param aPath a path
       
   694     * @param aAttrs attributes array to be filled
       
   695     * @param aSupportedIds array of supported content IDs to be filled
       
   696     */
       
   697     void SetAttributesL( const CMPXCollectionPath& aPath, RArray<TMPXAttribute>& aAttrs,
       
   698                          RArray<TInt>& aSupportedIds );
       
   699     
       
   700 #ifdef _DEBUG
       
   701     /**
       
   702     * Prints messages for debugging
       
   703     * @param aMessage message(s) to be printed
       
   704     */
       
   705     void PrintMessagesL(const CMPXMessage& aMessage);
       
   706 
       
   707     /**
       
   708     * Prints a single message for debugging
       
   709     * @param aMessage a message to be printed
       
   710     */
       
   711     void PrintMessage(const CMPXMessage& aMessage);
       
   712 #endif
       
   713 
       
   714 private:
       
   715 
       
   716     RFs                  iFs;
       
   717     CMPXResource*        iResource;
       
   718     CMPXPodcastDbHandler*iDbHandler;
       
   719     CMPXDrmMediaUtility* iDrmMediaUtility;
       
   720     CDesCArrayFlat*      iPodcastLibraryTitles;                 // podcast library view titles
       
   721     CDesCArrayFlat*      iPodcastLibraryMainMenuItemTitles;     // podcast library item menu item titles
       
   722     RArray<TInt>         iPodcastLibraryMainMenuItemIds;        // podcast library item menu IDs
       
   723     CDesCArrayFlat*      iPodcastTitlePublishDateCat;           // publish date view menu titles
       
   724     RArray<TInt>         iPodcastPublishDateIds;                // publish date view menu IDs
       
   725     CDesCArrayFlat*      iPodcastEpisodeViewPublishDateTitle;   // episodes view publish date titles
       
   726     RArray<TInt>         iPodcastEpisodeViewPublishDateIds;     // episodes view publish date title IDs
       
   727 
       
   728     HBufC*               iTitleMyPodcast;       // podcast menu view title string
       
   729     HBufC*               iTitleAllEpisodes;     // All Episodes title string
       
   730     HBufC*               iTitlePubDate;         // Published Date title string
       
   731     HBufC*               iTitleTitles;          // Titles title string
       
   732     HBufC*               iTitleAdded;           // Recently Added title string
       
   733     HBufC*               iTitleUnplayed;        // Not Yet played title string
       
   734 
       
   735     TInt                 iStateChangedDrive;    // drive number of the media has just opened/close
       
   736     TInt                 iStateChangedOldMaster;
       
   737     TBool                iStateChangedOpen;
       
   738     TBool                iMtpInUse;
       
   739     TBool                iRefreshing;
       
   740 
       
   741     TInt                 iNumberOfEpisodesInCurrentPublishDateCategory;
       
   742 
       
   743     CMPXDbActiveTask*    iActiveTask;
       
   744     RArray<TMPXItemId>   iSelections;   //selected items in the path
       
   745     TBool iFirstDeleteStep;
       
   746 
       
   747     };
       
   748 
       
   749 #endif   // MPXPODCASTDBPLUGIN_H
       
   750 
       
   751