/*

* Copyright (c) 2007 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:  This class is responsible for the functionality related to

*                playlist songs. The class operates on two tables: PlaylistSongs

*                and PlaylistSongInfo.

*

*                The PlaylistSongs table contains records for all song instances in

*                playlists. For example if a playlist contains 7 songs, there will be 7

*                corresponding records in the PlaylistSongs table, even if one song has

*                multiple instances in the playlist.

*

*                The PlaylistSongInfo table contains one record for each song included

*                in at least one playlist. Redundant song information is stored in this

*                table to help with songs on different drives than the playlist.

*

*

*/

#ifndef MPXDBPLAYLISTSONGS_H

#define MPXDBPLAYLISTSONGS_H

// INCLUDES

#include "mpxdbtable.h"

// CLASS FORWARDS

class CMPXMedia;

class CMPXMediaArray;

// CLASS DECLARATION

/**

* Responsible for managing the music table

*

* @lib MPXDbPlugin.lib

*/

class CMPXDbPlaylistSongs :

    public CMPXDbTable

    {

    public:

        /**

        * Two-phased constructor.

        * @param aDbManager database manager to use for database interactions

        * @return New CMPXDbPlaylistSongs instance.

        */

        static CMPXDbPlaylistSongs* NewL(CMPXDbManager& aDbManager);

        /**

        * Two-phased constructor.

        * @param aDbManager database manager to use for database interactions

        * @return New CMPXDbPlaylistSongs instance on the cleanup stack.

        */

        static CMPXDbPlaylistSongs* NewLC(CMPXDbManager& aDbManager);

        /**

        * Destructor

        */

        virtual ~CMPXDbPlaylistSongs();

    public:

        /**

        * Add a song/songs to the given playlist

        * @param aPlaylistId playlist id

        * @param aMediaArray media array which contains the tracks to be added to the playlist

        * @param aDriveId Drive Id of corresponding playlist

        */

        void AddSongsL(TUint32 aPlaylistId, const CMPXMediaArray& aMediaArray, TInt aDriveId);

        /**

        * Add a song to playlist songs table for the given playlist

        * @param aPlaylistId id of the playlist to add the song to

        * @param aDriveId drive the song is on

        * @param aMedia song media to be added to the playlist songs table for the playlist

        * @return song ID

        */

        TUint32 AddSongL(TUint32 aPlaylistId, const CMPXMedia& aMedia, TInt aDriveId);

        /**

        * Add a song to playlist songs table for the given playlist

        * @param aPlaylistId id of the playlist to add the song to

        * @param aOrdinal ordinal of the song to be added

        * @param aDriveId drive the song is on

        * @param aMedia song media to be added to the playlist songs table for the playlist

        * @return song ID

        */

        TUint32 AddSongL(TUint32 aPlaylistId, TInt aOrdinal, const CMPXMedia& aMedia,

            TInt aDriveId);

        /**

        * Update song info for a song in the playlist songs table

        * @param aSongId identifies the song

        * @param aMedia song information

        * @param aResetFlags indicates whether the song db flags should be reset or just updated

        * @param aUpdated returns ETrue if the song information has changed

        */

        TBool UpdateSongL(TUint32 aSongId, const CMPXMedia& aMedia, TBool aResetFlags,

            TBool& aUpdated);

        /**

        * Update songs in a playlist to reflect playlist id change

        * @param aPlaylistId identifies the songs in the playlist

        * @param aNewPlaylistId specifies the new playlist id the songs should be associated with

        */

        void UpdateSongsL(TUint32 aPlaylistId, TUint32 aNewPlaylistId);

        /**

        * Reorder the song in the playlist

        * @param aPlaylistId id of the playlist which contains the song to be reordered

        * @param aSongId id of the song to be reordered

        * @param aOriginalOrdinal the original ordinal of the song within the playlist.

        *        Ordinal starts from 0.

        * @param aNewOrdinal the new ordinal of the song within the playlist. Ordinal

        *        starts from 0.

        */

        void ReorderSongL(const TMPXItemId& aPlaylistId, const TMPXItemId& aSongId,

            TUint aOriginalOrdinal, TUint aNewOrdinal);

        /**

        * Remove the given song from all playlists

        * @param aSongId ID of the song to remove

        * @param aDriveId identifies the database to be updated

        */

        void DeleteSongL(TUint32 aSongId);

        /**

        * Remove a song from the playlist.

        * @param aPlaylistId ID of the playlist to remove the song from

        * @param aSongId Id of the song in the playlist to be removed

        * @param aOrdinal the ordinal of the song in the playlist. This uniquely

        *        identifies which song in the playlist to be removed; whereas song

        *        ID doesn't because duplicate tracks in the playlist are allowed.

        *        The position is relative to zero, i.e. zero implies that the song

        *        at the beginning of the playlist is to be removed.

        * @param aDriveId identifies the database to be updated

        */

        void DeleteSongL(TUint32 aPlaylistId, TUint32 aSongId, TInt aOrdinal, TInt aDriveId);

        /**

        * Remove all songs from the specified playlist

        * @param aPlaylistId ID of the playlist.

        * @param aDriveId identifies the database.

        */

        void DeleteSongsL(TUint32 aPlaylistId, TInt aDriveId);

        /**

        * Remove the songs for a given category from all playlists.

        * @param aCategory identifies the category

        * @param aCategoryId identifies the category item

        * @param aDriveId identifies the database to be updated

        */

        void DeleteSongsForCategoryL(TMPXGeneralCategory aCategory, TUint32 aCategoryId,

            TInt aDriveId);

        /**

        * Remove the songs for a given category from all playlists.

        * @param aCategory identifies the category

        * @param aCategoryId identifies the category item

        * @param aDriveId identifies the database to be updated

        */

        void DeleteSongsForArtistAndAlbumL(TUint32 aArtistId, TUint32 aAlbumId, TInt aDriveId);

        /**

        * Remove all songs from the playlist songs table

        */

        void DeleteAllSongsL();

        /**

        * Get ids of all songs in a playlist

        * @param aPlaylistId identifies the playlist

        * @param aMediaArray returns songs' id

        */

        void GetSongsL(TUint32 aPlaylistId, CMPXMediaArray& aMediaArray);

        /**

        * Get ids of all songs in a playlist

        * @param aPlaylistId identifies the playlist

        * @param aAttrs attributes to return

        * @param aMediaArray returns songs' id

        */

        TBool GetSongsL( TUint32 aPlaylistId,

            const TArray<TMPXAttribute>& aAttrs, CMPXMediaArray& aMediaArray);

        /**

        * Get information on a song in a playlist

        * @param aPlaylistId identifies the playlist

        * @param aSongId identifies the song

        * @param aAttrs attributes to return

        * @param aMedia returns song info

        */

        TBool GetSongL(TUint32 aPlaylistId, TUint32 aSongId,

            const TArray<TMPXAttribute>& aAttrs, CMPXMedia& aMedia);

        /**

        * Get information on a song

        * @param aSongId identifies the song

        * @param aAttrs attributes to return

        * @param aMedia returns song info

        */

        TBool GetSongL(const TMPXItemId& aSongId, const TArray<TMPXAttribute>& aAttrs,

            CMPXMedia*& aMedia);

        /**

        * Get the number of songs for a playlist

        * @param aPlaylistId identifies the playlist

        * @param aDriveId identifies the database to be query

        * @return number of songs

        */

        TInt CountL(TUint32 aPlaylistId, TInt aDriveId);     

    private:

        /**

        * Update the media from the table

        * @param aRecord playlist table view

        * @param aAttrs the attributes to return

        * @param aMedia updated with the playlist song info

        */

        void UpdateMediaL(RSqlStatement& aRecord, const TArray<TMPXAttribute>& aAttrs,

            CMPXMedia& aMedia);

        /**

        * Get the number of instances of a song in a playlist

        * @param aPlaylistId identifies the playlist

        * @param aSongId identifies the song

        * @return number of instances

        */

        TInt SongInstanceCountL(TUint32 aPlaylistId, TUint32 aSongId);

        /**

        * Get the number of instances of a song in the PlaylistSongs table.

        * @param aSongId identifies the song

        * @return number of instances

        */

        TInt SongCountL(TUint32 aSongId);

        /**

        * Checks if the specified song exists in the PlaylisySongInfo table.

        * @param aDriveId drive to check or KDbManagerAllDrives

        * @param aSongId identifies the song

        * @return ETrue if it exists, EFalse otherwise

        */

        TBool SongInfoExistsL(TInt aDriveId, TUint32 aSongId);

        /**

        * Deletes all orphaned records in the PlaylistSongInfo table

        * (songs not included in any playlist).

        * @param aDriveId database to cleanup

        */

        void CleanupSongInfoL(TInt aDriveId);

    private:    // from MMPXTable

        /**

        * @see MMPXTable

        */

        virtual void CreateTableL(RSqlDatabase& aDatabase, TBool aCorruptTable);

        /**

        * @see MMPXTable

        */

        virtual void DropTableL(RSqlDatabase& aDatabase);

        /**

        * @see MMPXTable

        */

        virtual TBool CheckTableL(RSqlDatabase& aDatabase);

    private:

        /**

        * C++ constructor

        * @param aDbManager database manager to use for database interactions

        */

        CMPXDbPlaylistSongs(CMPXDbManager& aDbManager);

        /**

        * Safely construct things that can leave

        */

        void ConstructL();

    private:

        /**

        * Column indexes in the playlist songs query

        */

        enum TPlaylistSongsColumns

            {

            EPlaylistSongsUniqueId = KMPXTableDefaultIndex,

            EPlaylistSongsSongId,

            EPlaylistSongsPlaylistId,

            EPlaylistSongsOrdinal,

            EPlaylistSongsVolumeId,

            EPlaylistSongsDbFlag,

            EPlaylistSongsUri,

            EPlaylistSongsTitle

            };

        /**

        * Column indexes in the playlist song info table

        */

        enum TPlaylistSongInfoColumns

            {

            EPlaylistSongInfoSongId = KMPXTableDefaultIndex,

            EPlaylistSongInfoVolumeId,

            EPlaylistSongInfoDbFlag,

            EPlaylistSongInfoUri,

            EPlaylistSongInfoTitle

            };

    };

#endif // MPXDBPLAYLISTSONGS_H

// End of File