/*
* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Implementation of Podcast Collection Database Plugin interface
*
*/
#ifndef MPXPODCASTDBPLUGIN_H
#define MPXPODCASTDBPLUGIN_H
// INCLUDES
#include <badesca.h>
#include <mpxcommonframeworkdefs.h>
#include <mpxcollectionframeworkdefs.h>
#include <mpxcollectionplugin.h>
#include <mpxcollectionpath.h>
#include <mpxmediageneraldefs.h>
#include <mpxpodcastdefs.h>
#include <mpxmessage2.h>
#include "mpxdbactivetask.h"
#include "mpxpodcastcollectiondb.hrh"
// FORWARD DECLARATIONS
class CMPXMedia;
class CMPXPodcastDbHandler;
class CMPXDrmMediaUtility;
class CMPXMediaArray;
class CMPXResource;
// CONSTANTS
// CLASS DECLARATION
/**
* Plug-in provides access to podcast collection.
*
* @lib mpxpodcastdbplugin.lib
*/
NONSHARABLE_CLASS(CMPXPodcastDbPlugin) :
public CMPXCollectionPlugin,
public MMPXDbActiveTaskObserver
{
public: // Constructors and destructor
/**
* Two-phased constructor
* @param aInitParams: initialization parameters
* @return object constructed
*/
static CMPXPodcastDbPlugin* NewL (TAny* aInitParams);
/**
* Destructor
*/
virtual ~CMPXPodcastDbPlugin();
public: // from base clase
/**
* From CMPXCollectionPlugin
* Navigates to the given path. This method is serviced
* asynchronously and HandleOpenL is called upon completion
* @param aPath a path
* @param aAttrs attributes requested
* @param aFilter filter to apply or NULL if none
*/
void OpenL(const CMPXCollectionPath& aPath,
const TArray<TMPXAttribute>& aAttrs,
CMPXFilter* aFilter);
/**
* From CMPXCollectionPlugin
* Get the extended properties of the item referred to by the
* specified collection path. This method is serviced asynchronously and
* HandleMediaL is called upon completion
* @param aPath a collection path referring to the item to retrieve the
* extended properties for
* @param aAttr: array of attributes requested
* @param aCaps platsec capabilities of client requesting media; plug-in
* should also verify its process capabilities (not yet supported)
* @aParam aSpecs specifications for attributes (not yet supported)
*/
void MediaL(const CMPXCollectionPath& aPath,
const TArray<TMPXAttribute>& aAttrs,
const TArray<TCapability>& aCaps,
CMPXAttributeSpecs* aSpecs);
/**
* From CMPXCollectionPlugin
* Cancel outstanding request. Note*** CancelRequest is not currently
* implemented because all requests are processed synchronously
*/
void CancelRequest();
/**
* From CMPXCollectionPlugin
* Executes the given TMPXCollectionCommand command on the collection
* @param aCmd a command
* @param aArg an argument
*/
void CommandL(TMPXCollectionCommand aCmd, TInt aArg = 0);
/**
* From CMPXCollectionPlugin
* Executes the given CMPXCommand command on the collection
* @param aCmd a command
*/
void CommandL(CMPXCommand& aCmd);
/**
* From CMPXCollectionPlugin
* Adds an episode to the collection
* @param aMedia Properties of the item
*/
void AddL(const CMPXMedia& aMedia);
/**
* From CMPXCollectionPlugin
* Remove an item(s) from the collection database using the given path
* Note that the selection indices are hidden within the path
* @param aPath: path to the item to be removed
*
*/
void RemoveL(const CMPXCollectionPath& aPath);
/**
* Remove item(s) from the collection database using the given media properties
* @param aMedia Properties of the item(s) to be removed. May cantain a URI
* or metadata. All item(s) matching the specified properties
* will be removed.
*/
void RemoveL(const CMPXMedia& aMedia);
/**
* Sets/updates the specified media for an item in the collection. Media
* is identified by specifying an ID or URI.
* @param aMedia: new property values for the item
*/
void SetL(const CMPXMedia& aMedia);
/**
* From CMPXCollectionPlugin
* Find the items matching the media specifications. This method is serviced
* asynchronously and HandleFindAllL is called upon completion
* @param aCriteria Properties of the item that is to be found
* @param aAttrs Requested attributes to return
*/
void FindAllL(const CMPXMedia& aCriteria, const TArray<TMPXAttribute>& aAttrs);
/**
* From CMPXCollectionPlugin
* Find the items matching the media specifications
* @param aCriteria Properties of the item that is to be found
* @param aAttrs Requested attributes to return
* @return results of the search. Method abandons ownership of results.
*/
CMPXMedia* FindAllSyncL(const CMPXMedia& aCriteria,
const TArray<TMPXAttribute>& aAttrs);
/**
* Get the list of supported capabilities
* @return TCollectionCapability, bitmask of supported capabilities
*/
TCollectionCapability GetCapabilities();
/**
* From MMPXDbActiveTaskObserver
*/
TBool HandleStepL();
/**
* From MMPXDbActiveTaskObserver
*/
void HandleOperationCompleted( TInt aErr );
private:
/**
* Constructor
*/
CMPXPodcastDbPlugin ();
/**
* Symbian 2nd phase constructor.
*/
void ConstructL ();
/**
* Process the OpenL command
* @param aPath a path
* @param aAttrs Requested attributes to return
* @param aEntries (Output parameter) collection items containing media properties
* of all items, returned if opening a group of items
* @param aFlagToSignalToBePlayed: signals that item is opened to be played if type == episode
* @return ETrue if the open is for a episode, EFalse otherwise
*/
TBool DoOpenL(const CMPXCollectionPath& aPath,
const TArray<TMPXAttribute>& aAttrs,
CMPXMedia& aEntries,
TBool aFlagToSignalToBePlayed);
/**
* Process the OpenL(EBrowseAll) command
* @param aPath Path
* @param aAttrs Requested attributes to return
* @param aEntries (Output parameter) collection items containing media properties
* of all items, returned if opening a group of items
* @param aArray (Output parameter) collection items
* @return ETrue if the open is for an episode, EFalse otherwise
*/
TBool DoOpenBrowseAllL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,
CMPXMedia& aEntries, CMPXMediaArray& aArray);
/**
* Process the OpenL(EBrowsePubDate) command
* @param aPath Path
* @param aAttrs Requested attributes to return
* @param aEntries (Output parameter) collection items containing media properties
* of all items, returned if opening a group of items
* @param aArray (Output parameter) collection items
* @return ETrue if the open is for an episode, EFalse otherwise
*/
TBool DoOpenBrowsePubDateL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,
CMPXMedia& aEntries, CMPXMediaArray& aArray);
/**
* Process the OpenL(EBrowseTitle) command
* @param aPath Path
* @param aAttrs Requested attributes to return
* @param aEntries (Output parameter) collection items containing media properties
* of all items, returned if opening a group of items
* @param aArray (Output parameter) collection items
* @return ETrue if the open is for an episode, EFalse otherwise
*/
TBool DoOpenBrowseTitleL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,
CMPXMedia& aEntries, CMPXMediaArray& aArray);
/**
* Process the OpenL(EBrowseRecentlyAdded) command
* @param aPath Path
* @param aAttrs Requested attributes to return
* @param aEntries (Output parameter) collection items containing media properties
* of all items, returned if opening a group of items
* @param aArray (Output parameter) collection items
* @return ETrue if the open is for an episode, EFalse otherwise
*/
TBool DoOpenBrowseRecentlyAddedL(const CMPXCollectionPath& aPath,
const TArray<TMPXAttribute>& aAttrs, CMPXMedia& aEntries, CMPXMediaArray& aArray);
/**
* Process the OpenL(EBrowseNotPlayed) command
* @param aPath Path
* @param aAttrs Requested attributes to return
* @param aEntries (Output parameter) collection items containing media properties
* of all items, returned if opening a group of items
* @param aArray (Output parameter) collection items
* @return ETrue if the open is for an episode, EFalse otherwise
*/
TBool DoOpenBrowseNotPlayedL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,
CMPXMedia& aEntries, CMPXMediaArray& aArray);
/**
* Process an OpenL command with a EMPXOpenPlaylistOnly open mode
* @param aPath path that we want to open
* @param aAttrs default attributes to fetch
* @param aFlagToSignalToBePlayed: signals that item is opened to be played if type == episode
* @return CMPXCollectionPath* which is the new valid browse path
* Method abandons ownership.
*/
CMPXCollectionPath* DoOpenPlaylistL( const CMPXCollectionPath& aPath,
const TArray<TMPXAttribute>& aAttrs,
TBool aFlagToSignalToBePlayed);
/**
* Process the MediaL command
* @param aPath a path
* @param aAttrs Requested attributes to return
* @param aEntries collection items containing media properties
* of all items, returned if opening a group of items
*/
void DoMediaL(const CMPXCollectionPath& aPath,
const TArray<TMPXAttribute>& aAttrs,
CMPXMedia& aEntries);
/**
* Get the plugin title, subtitle, icons for this plugin
* @param aAttrs attributes to find
* @param aMedia media object
*/
void DoRootMediaL(const TArray<TMPXAttribute>& aAttrs, CMPXMedia& aMedia);
/**
* Get the media under ALL EPISODES category
* @param aPath path that leads to a media under ALL EPISODES
* @param aAttrs attributes of media to find
* @param aEntries the media referred by the path
* @param aMediaArray media entries contained in the media referred by the path
*/
void DoAllEpisodesMediaL(const CMPXCollectionPath& aPath,
const TArray<TMPXAttribute>& aAttrs,
CMPXMedia& aEntries,
CMPXMediaArray& aMediaArray);
/**
* Find the collection media for by publish date category
* @param aPath path that leads to a media under BY PUBLISH DATE
* @param aAttrs attributes of media to find
* @param aEntries the media referred by the path
* @param aMediaArray media entries contained in the media referred by the path
*/
void DoByPublishDateMediaL(const CMPXCollectionPath& aPath,
const TArray<TMPXAttribute>& aAttrs,
CMPXMedia& aEntries,
CMPXMediaArray& aMediaArray);
/**
* Find the collection media for by titles category
* @param aPath path that leads to a media under TITLES
* @param aAttrs attributes of media to find
* @param aEntries the media referred by the path
* @param aMediaArray media entries contained in the media referred by the path
*/
void DoTitlesMediaL(const CMPXCollectionPath& aPath,
const TArray<TMPXAttribute>& aAttrs,
CMPXMedia& aEntries,
CMPXMediaArray& aMediaArray);
/**
* Find the collection media for by recently added category
* @param aPath path that leads to a media under RECENTLY ADDED
* @param aAttrs attributes of media to find
* @param aEntries the media referred by the path
* @param aMediaArray medias contained in the media referred by the path
*/
void DoRecentlyAddedMediaL(const CMPXCollectionPath& aPath,
const TArray<TMPXAttribute>& aAttrs,
CMPXMedia& aEntries,
CMPXMediaArray& aMediaArray);
/**
* Find the collection media for by not yet played category
* @param aPath path that leads to a media under NOT YET PLAYED
* @param aAttrs attributes of media to find
* @param aEntries the media referred by the path
* @param aMediaArray medias contained in the media referred by the path
*/
void DoNotYetPlayedMediaL(const CMPXCollectionPath& aPath,
const TArray<TMPXAttribute>& aAttrs,
CMPXMedia& aEntries,
CMPXMediaArray& aMediaArray);
/**
* Get the root media.
* @param aAttrs attributes of media to find
* @param aRootCategoryId Id of the root media in the category, i.e. all albums,
* ...etc.
* @param aCategory specifies the category.
* @param aEntries the media referred by the path
*/
void DoRootCategoryMediaL(const TArray<TMPXAttribute>& aAttrs,
TMPXItemId aRootCategoryId,
TMPXPodcastCategory aCategory,
CMPXMedia& aEntries);
/**
* Set all the attributes in CMPXMedia corresponding to KMPXMediaIdDrm
* @param aMedia, media to update
* @param aDrmAttributes, bitwise or of the flags we want
* @param aLocation, full file path including filename
*/
void DoSetMediaDrmL(CMPXMedia& aMedia, TUint aDrmAttributes, const TDesC& aLocation);
/**
* Add media objects to the array with attributes from episode details
* @param aPath a path
* @param aAttrs requested attributes
* @param aEntry media to contain information about the container if it contains
* than one entry
* @param aMediaArray array to contain all the media objects added
*/
void GetEpisodeInfoL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,
CMPXMedia& aEntry, CMPXMediaArray& aMediaArray);
/**
* Add media objects to the array with attributes from episode details
* @param aAttrs requested attributes
* @param aEntryId episode ID
* @param aEntry media to contain information about the container if it contains
* than one entry
*/
void DoGetEpisodeInfoL(const TArray<TMPXAttribute>& aAttrs, TInt aEntryId, CMPXMedia& aEntry);
/**
* Get the collection details from the db
* @param aAttrs attributes to find
* @param aPath path to be set if required
* @param aMedia media object
*/
void DoHandleOtherMediaAttributesL(const TArray<TMPXAttribute>& aAttrs,
const CMPXCollectionPath& aPath, CMPXMedia& aMedia);
/**
* Remove an item from the collection database using the given path
* Note that the selection indices are hidden within the path
* @param aPath path to the item to be removed
* @param aChangeMsgArray array to store change messages
* @return an array of files associated with the removed media entries
*/
CDesCArray* DoRemoveL(const CMPXCollectionPath& aPath,
CMPXMessageArray& aChangeMsgArray);
/**
* Remove an item/items from the collection database using the given media properties
* @param aMedia Properties of the item that is to be removed. It may cantain URI only
* or meta data, all of items matched properties will be removed.
* @param aDeleteRecord indicates whether the client has explictly requested
* to delete the records from the database. If ETrue, records
* associated with the media will be deleted from the database;
* if EFalse, whether to mark the records as deleted or to delete
* the records will be based on other deciding factors.
*/
void DoRemoveL(const CMPXMedia& aMedia, TBool aDeleteRecord);
/**
* Remove an item from the collection database using a command
* @param aCmd remove command which contains collection path to the media entries to be
* removed. This method should be called until all the selected items are
* removed. When that happens, EMPXCommandCompleted flag is set to ETrue.
*/
void DoRemovePathL(CMPXCommand& aCmd);
/**
* Remove a media entry/entries from the collection database using a command
* @param aCmd remove command which contains the media(s) to be removed. This
* will delete the records from the database rather than marking them
* as deleted. Designated caller is MTP.
*/
void DoRemoveMediaL(CMPXCommand& aCmd);
/**
* Remove a media entry/entries from all episodes view
* @param aPath collection path that points to the media entry/entries to be removed
* @param aSelections multiple media items selected. This array contains the id
* of the selected media.
* @param aUriArray a descriptor array containing the URI(s) of the deleted file(s)
* @param aItemChangedMessages a list of change events as a result of the
* episode removals
*/
void DoRemoveFromAllEpisodesL(const CMPXCollectionPath& aPath,
const TArray<TMPXItemId>& aSelections,
CDesCArray& aUriArray,
CMPXMessageArray& aItemChangedMessages);
/**
* Remove media from Publish Date view
* @param aPath collection path that points to the media entry/entries to be removed
* @param aSelections multiple media entry/entries selected. This array contains the id
* of the selected media.
* @param aUriArray a descriptor array to contain the URI(s) of the deleted file(s)
* @param aItemChangedMessages a list of change events as a result of the
* episode removals
*/
void DoRemoveFromPublishDateL(const CMPXCollectionPath& aPath,
const TArray<TMPXItemId>& aSelections,
CDesCArray& aUriArray,
CMPXMessageArray& aItemChangedMessages);
/**
* Remove a media item from Publish Date view
* @param aPath collection path that points to the media entry/entries to be removed
* @param aItemId ID of the item to be removed
* @param aUriArray a descriptor array to contain the URI(s) of the deleted file(s)
* @param aItemChangedMessages a list of change events as a result of the
* episode removals
*/
void RemoveFromPublishDateL(const CMPXCollectionPath& aPath, TInt aItemId,
CDesCArray& aUriArray, CMPXMessageArray& aItemChangedMessages);
/**
* Remove a media/medias from albums/genres/composers view
* @param aPath collection path that points to the media(s) to be removed
* @param aSelections multiple medias selected. This array contains the id
* of the selected media.
* @param aCategory indicates one of the 3 categories, EMPXAlbum, EMPXGenre, or
* EMPXComposer
* @param aUriArray a descriptor array to contain the URI of the deleted file
* @param aItemChangedMessages a list of change events as a result of the
* episode removals
*/
void DoRemoveFromCategoriesL(const CMPXCollectionPath& aPath,
const TArray<TMPXItemId>& aSelections,
TMPXGeneralCategory aCategory,
CDesCArray& aUriArray,
CMPXMessageArray& aItemChangedMessages);
/**
* Remove a media item from albums/genres/composers view
* @param aPath collection path that points to the media entry/entries to be removed
* @param aItemId ID of the item to be removed
* @param aCategory indicates one of the 3 categories, EMPXAlbum, EMPXGenre, or
* EMPXComposer
* @param aUriArray a descriptor array to contain the URI(s) of the deleted file(s)
* @param aItemChangedMessages a list of change events as a result of the
* episode removals
*/
void RemoveFromCategoriesL(const CMPXCollectionPath& aPath, TInt aItemId,
TMPXGeneralCategory aCategory, CDesCArray& aUriArray,
CMPXMessageArray& aItemChangedMessages);
/**
* Fetch the duration for a specific category
* @param aMedia a media object of which EMPXMediaGeneralDuration is to be
* populated with the duration calculated in this method
* @param aCategory category of the ID
* @param aId id for identifying which category to calculate the duration for
*/
TInt DoDurationL(CMPXMedia& aMedia, TMPXPodcastCategory aCategory, TMPXItemId aId = 0);
/**
* Retrieves URIs associated with the path for file deletion
* @param aCmd command to retrieve associated URIs for the given path. If
* path ends with a particular artist/album/genre/composer, the path
* will be updated to include all episodes in that category. If path
* ends with one or more medias in a particular playlist, an array
* of 0 elements will be returned to avoid client deleting them from
* the file system
*/
void DoRetrieveUriForDeletionL(CMPXCommand& aCmd);
/**
* Deletes records which have been marked as deleted from the collection
* @param aCmd command to cleanup deleted medias.
* see KMPXCommandIdCollectionCleanupDeletedMedias defined in
* mpxcollectioncommanddefs.h
*/
void CleanupDeletedRecordsL(CMPXCommand& aCmd);
/**
* Append a collection level to the collection path
* @param aPath path to append the level to
* @param aMedia media to extract media ids from
* @note: Selection will be put on the first episode in the collection path
*/
TInt DoAppendLevelL(CMPXCollectionPath& aPath, CMPXMedia& aMedia);
/* Append a collection level to the collection path with all episodes under the
* selected category/categories (e.g. artist/artist-album/album/genre/composer).
* Once the level is appended, all episodes under the selected category/categories
* are selected.
* @param aPath path to append the level to. Path remains unchanged if it's not
* one of the following:
* 1) path ends at an artist or selected artists
* 2) path ends at an album of an artist or selected albums of an artist
* 3) path ends at an album or selected albums
* 4) path ends at a genre or selected genres
* 5) path ends at a composer or selected composers
*/
void DoAppendLevelL(CMPXCollectionPath& aPath);
/**
* Execute a task step for an asynchronous add
* @return ETrue if done
*/
TBool DoAddAsyncL();
/**
* Add a media object to the collection
* @param aMedia media to add
* @return TUint32 item id of the item added
*/
TUint32 DoAddL(const CMPXMedia& aMedia);
/**
* Add an item into the collection
* @param aMedia media to add
* @param aMessageArray change message array
* @return TUint32 item id of the item added
*/
TUint32 DoAddItemL(const CMPXMedia& aMedia, CMPXMessageArray& aMessageArray);
/**
* Set a media object to update the collection
* @param aMedia media can be an item or a list. The item is treated as a list
* if it contains a media array
*/
void DoSetL(const CMPXMedia& aMedia);
/**
* Execute a task step for an asynchronous set
*/
TBool DoSetAsyncL();
/**
* Send a change message
* @param aMessage a change message to be sent
*/
void HandleChangeL(const CMPXMessage& aMessage);
/**
* Construct a CMPXMedia from the array parameter and call HandleChange
* @param aItemChangedMessages array in the change message to be sent
*/
void DoHandleChangeL(CMPXMessageArray* aItemChangedMessages);
/**
* Generates and calls back an out of disk CMPXMessage
* This function will callback to the client context to
* broadcast an out of disk event
*/
void HandleOutOfDiskMessageL();
/**
* Leaving function to handle async op completion
* @param aErr error code
*/
void DoHandleOperationCompletedL(TInt aErr);
/**
* Complete a delete operation
* Sends out change messages and compacts the database
*/
void DoHandleDeleteCompleteL(CMPXCommand& aCmd);
/**
* Returns the category for a given browse type.
* @param aBrowseType browse type
* @return Category ID
*/
TMPXPodcastCategory CategoryForBrowseType(TMCBrowseType aBrowseType);
/**
* Returns the browse type for a given category ID.
* @param aCategory category ID
* @return Browse type
*/
TMCBrowseType BrowseTypeForCategory(TMPXPodcastCategory aCategory);
/**
* Sets the type, category and title attributes in the specified media.
* @param aMedia media instance to be updated
* @param aGeneralType general type attribute value
* @param aType podcast type attribute value
* @param aCategory category attribute value
* @param aTitle title attribute value
* @param aCount general count attribute value
*/
void SetMediaGeneralAttributesL(CMPXMedia& aMedia, TMPXGeneralType aGeneralType,
TMPXPodcastType aType, TMPXPodcastCategory aCategory, const TDesC& aTitle,
TInt aCount = -1);
/**
* Sets the type, category and title attributes in the specified media.
* @param aMedia media instance to be updated
* @param aGeneralType general type attribute value
* @param aType type attribute value
* @param aCategory category attribute value
* @param aId ID of the item to the title from
* @param aCount general count attribute value
*/
void SetMediaGeneralAttributesL(CMPXMedia& aMedia, TMPXGeneralType aGeneralType,
TMPXPodcastType aType, TMPXPodcastCategory aCategory, TInt aId, TInt aCount = -1);
/**
* Get total podcasts count
* @param aCmd command to return count
* see KMPXCommandCollectionGetCount defined in
* mpxcollectioncommanddefs.h
*/
void DoGetCollectionCountL( const CMPXCommand& aCmd );
/**
* Get an array of URIs for all podcasts in a given db
* @param aCmd command to return CDesCArray
* see KMPXCommandCollectionGetURIs defined in
* mpxcollectioncommanddefs.h
*/
void DoGetCollectionUriL( const CMPXCommand& aCmd );
/**
* Set the attribute list according to current path
* @param aPath a path
* @param aAttrs attributes array to be filled
* @param aSupportedIds array of supported content IDs to be filled
*/
void SetAttributesL( const CMPXCollectionPath& aPath, RArray<TMPXAttribute>& aAttrs,
RArray<TInt>& aSupportedIds );
#ifdef _DEBUG
/**
* Prints messages for debugging
* @param aMessage message(s) to be printed
*/
void PrintMessagesL(const CMPXMessage& aMessage);
/**
* Prints a single message for debugging
* @param aMessage a message to be printed
*/
void PrintMessage(const CMPXMessage& aMessage);
#endif
private:
RFs iFs;
CMPXResource* iResource;
CMPXPodcastDbHandler*iDbHandler;
CMPXDrmMediaUtility* iDrmMediaUtility;
CDesCArrayFlat* iPodcastLibraryTitles; // podcast library view titles
CDesCArrayFlat* iPodcastLibraryMainMenuItemTitles; // podcast library item menu item titles
RArray<TInt> iPodcastLibraryMainMenuItemIds; // podcast library item menu IDs
CDesCArrayFlat* iPodcastTitlePublishDateCat; // publish date view menu titles
RArray<TInt> iPodcastPublishDateIds; // publish date view menu IDs
CDesCArrayFlat* iPodcastEpisodeViewPublishDateTitle; // episodes view publish date titles
RArray<TInt> iPodcastEpisodeViewPublishDateIds; // episodes view publish date title IDs
HBufC* iTitleMyPodcast; // podcast menu view title string
HBufC* iTitleAllEpisodes; // All Episodes title string
HBufC* iTitlePubDate; // Published Date title string
HBufC* iTitleTitles; // Titles title string
HBufC* iTitleAdded; // Recently Added title string
HBufC* iTitleUnplayed; // Not Yet played title string
TInt iStateChangedDrive; // drive number of the media has just opened/close
TInt iStateChangedOldMaster;
TBool iStateChangedOpen;
TBool iMtpInUse;
TBool iRefreshing;
TInt iNumberOfEpisodesInCurrentPublishDateCategory;
CMPXDbActiveTask* iActiveTask;
RArray<TMPXItemId> iSelections; //selected items in the path
TBool iFirstDeleteStep;
};
#endif // MPXPODCASTDBPLUGIN_H