/*

* 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 collection Database Plugin interface

*

*/

#ifndef MPXDBPLUGIN_H

#define MPXDBPLUGIN_H

// INCLUDES

#include <badesca.h>

#include <mpxcommonframeworkdefs.h>

#include <mpxcollectionframeworkdefs.h>

#include <mpxcollectionplugin.h>

#include <mpxcollectionpath.h>

#include <mpxmediageneraldefs.h>

#include <mpxmessage2.h>

#include "mpxdbactivetask.h"

#include "mpxcollectiondb.hrh"

// FORWARD DECLARATIONS

class CMPXMedia;

class CMPXDbHandler;

class CMPXDrmMediaUtility;

class CMPXMediaArray;

class CMPXResource;

struct TMPXOpenDataBlock;

// CLASS DECLARATION

/**

* CMPXDbPlugin class

* Implements the plugin interface.

*

* @lib MPXDbPlugin.lib

*/

NONSHARABLE_CLASS(CMPXDbPlugin) :

    public CMPXCollectionPlugin,

    public MMPXDbActiveTaskObserver

    {

public: // Constructors and destructor

    /**

    * Two-phased constructor

    * @param aInitParams: initialization parameters

    * @return object constructed

    */

    static CMPXDbPlugin* NewL (TAny* aInitParams);

    /**

    * Destructor

    */

    virtual ~CMPXDbPlugin();

public: // from base classes

    /**

    * 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 aAttrs 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 item (song or playlist) to the collection

    * @param aMedia Properties of the item

    */

    void AddL(const CMPXMedia& aMedia);

    /**

    * From CMPXCollectionPlugin

    * 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

    *

    */

    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);

    /**

    * From CMPXCollectionPlugin

    * 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

    */

    CMPXDbPlugin();

    /**

    * 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 aFilter CMPXFilter Object

    * @return ETrue if the open is for a song, EFalse otherwise

    */

    TBool DoOpenL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,

        CMPXMedia& aEntries, CMPXFilter* aFilter );

    /**

    * 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 a song, EFalse otherwise

    */

    TBool DoOpenBrowseAllL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,

        CMPXMedia& aEntries, CMPXMediaArray* aArray);

    /**

    * Process the OpenL(EBrowseArtist) 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 a song, EFalse otherwise

    */

    TBool DoOpenBrowseArtistL(const CMPXCollectionPath& aPath,

        const TArray<TMPXAttribute>& aAttrs, CMPXMedia& aEntries, CMPXMediaArray* aArray);

    /**

    * Process the OpenL(EBrowseAlbum) 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 a song, EFalse otherwise

    */

    TBool DoOpenBrowseAlbumL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,

        CMPXMedia& aEntries, CMPXMediaArray* aArray);

    /**

    * Process the OpenL(EBrowsePlaylist) 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 a song, EFalse otherwise

    */

    TBool DoOpenBrowsePlaylistL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,

        CMPXMedia& aEntries, CMPXMediaArray* aArray);

    /**

    * Process the OpenL(EBrowseGenre) 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 a song, EFalse otherwise

    */

    TBool DoOpenBrowseGenreL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,

       CMPXMedia& aEntries, CMPXMediaArray* aArray);

    /**

    * Process the OpenL(EBrowseComposer) 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 a song, EFalse otherwise

    */

    TBool DoOpenBrowseComposerL(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

    * @return CMPXCollectionPath* which is the new valid browse path

    */

    CMPXCollectionPath* DoOpenPlaylistL( const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs );

    /**

    * 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 SONGS category

    * @param aPath path that leads to a media under ALL SONGS

    * @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 DoAllSongsMediaL(const CMPXCollectionPath& aPath,

                            const TArray<TMPXAttribute>& aAttrs,

                            CMPXMedia& aEntries,

                            CMPXMediaArray& aMediaArray);

    /**

    * Get the media under ARTISTS category

    * @param aPath path that leads to a media under ARTISTS

    * @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 DoArtistMediaL(const CMPXCollectionPath& aPath,

                          const TArray<TMPXAttribute>& aAttrs,

                          CMPXMedia& aEntries,

                          CMPXMediaArray& aMediaArray);

    /**

    * Get the root media under ALBUMS/PLAYLISTS/GENRES/COMPOSERS

    * @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. Will be either EMPXAlbum, EMPXPlaylist,

    *        EMPXGenre, or EMPXComposer

    * @param aEntries the media referred by the path

    */

    void DoRootCategoryMediaL(const TArray<TMPXAttribute>& aAttrs,

                               TMPXItemId aRootCategoryId,

                               TMPXGeneralCategory aCategory,

                               CMPXMedia& aEntries);

    /**

    * Get the media under album/playlist/genre/composer category

    * @param aPath path that leads to a media under ALBUMS/PLAYLISTS/GENRES/COMPOSERS

    * @param aAttrs attributes of media to find

    * @param aCategory specifies the category. Will be either EMPXAlbum, EMPXPlaylist,

    *        EMPXGenre, or EMPXComposer

    * @param aEntries the media referred by the path

    * @param aMediaArray medias contained in the media referred by the path

    */

    void DoCategoryMediaL(const CMPXCollectionPath& aPath,

                           const TArray<TMPXAttribute>& aAttrs,

                           TMPXGeneralCategory aCategory,

                           CMPXMedia& aEntries,

                           CMPXMediaArray& aMediaArray);

    /**

    * 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 song 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 GetSongInfoL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs,

        CMPXMedia& aEntry, CMPXMediaArray& aMediaArray);

    /**

    * Add media objects to the array with attributes from song details

    * @param aAttrs requested attributes

    * @param aEntryId song ID

    * @param aPlaylistId corresponding playlist ID, if 0 the attributes will be read from

    *        the songs table, otherwise they will be read from the playlist table.

    * @param aEntry media to contain information about the container if it contains

    *        than one entry

    */

    void DoGetSongInfoL(const TArray<TMPXAttribute>& aAttrs, TInt aEntryId, TInt aPlaylistId,

        CMPXMedia& aEntry);

    /**

    * Get the collection details from the db

    * @param aAttrs, attributes to find

    * @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(s) to be

    *        removed. This method should be called until all the selected items are

    *        removed. When that happens, EMPXCommandCompleted flag is set to ETrue.

    *        see KMPXCommandIdCollectionRemove in mpxcollectioncommanddefs.h

    */

    void DoRemovePathL(CMPXCommand& aCmd);

    /**

    * Remove a media/medias 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/medias from all songs view

    * @param aPath, collection path that points to the media items 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

    *        song removals

    */

    void DoRemoveFromAllSongsL(const CMPXCollectionPath& aPath,

                               const TArray<TMPXItemId>& aSelections,

                               CDesCArray& aUriArray,

                               CMPXMessageArray& aItemChangedMessages);

    /**

    * Remove a media/medias from artists view

    * @param aPath, collection path that points to the media(s) to be removed

    * @param aSelections, multiple media items selected. This array contains the id

    *        of the selected media.

    * @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

    *        song removals

    */

    void DoRemoveFromArtistsL(const CMPXCollectionPath& aPath,

                              const TArray<TMPXItemId>& aSelections,

                              CDesCArray& aUriArray,

                              CMPXMessageArray& aItemChangedMessages);

    /**

    * Remove a media/medias from artists view

    * @param aPath, collection path that points to the media(s) to be removed

    * @param aItemId media item to be removed.

    * @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

    *        song removals

    */

    void RemoveFromArtistsL(const CMPXCollectionPath& aPath,

                                TUint32 aItemId,

                                CDesCArray& aUriArray,

                                CMPXMessageArray& aItemChangedMessages);

    /**

    * Remove a media entry/entries from albums/genres/composers view

    * @param aPath, collection path that points to the media entry/entries to be removed

    * @param aSelections, multiple media entries 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(s) of the deleted file(s)

    * @param aItemChangedMessages: a list of change events as a result of the

    *        song removals

    */

    void DoRemoveFromCategoriesL(const CMPXCollectionPath& aPath,

                                 const TArray<TMPXItemId>& aSelections,

                                 TMPXGeneralCategory aCategory,

                                 CDesCArray& aUriArray,

                                 CMPXMessageArray& aItemChangedMessages);

    /**

    * Remove a media entry from albums/genres/composers view

    * @param aPath, collection path that points to the media entry/entries to be removed

    * @param aItemId item ID 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

    *        song removals

    */

    void RemoveFromCategoriesL(const CMPXCollectionPath& aPath,

                                TUint32 aItemId,

                                TMPXGeneralCategory aCategory,

                                CDesCArray& aUriArray,

                                CMPXMessageArray& aItemChangedMessages);

    /**

    * Remove a media entry/entries from playlists 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 aUriArray: a descriptor array to contain the URI of the deleted file

    * @param aItemChangedMessages: a list of change events as a result of the

    *        song removals

    */

    void DoRemoveFromPlaylistsL(const CMPXCollectionPath& aPath,

                                const TArray<TMPXItemId>& aSelections,

                                CDesCArray& aUriArray,

                                CMPXMessageArray& aItemChangedMessages);

    /**

    * Remove a media entry/entries from playlists view

    * @param aPath, collection path that points to the media(s) to be removed

    * @param aItemId item to be removed

    * @param aIndex item index to be removed

    * @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

    *        song removals