/*

* 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 used by db plugin for all database related

*                functionality. The main responsibilities are:

*

*/

// INCLUDE FILES

#include <bautils.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#include <pathinfo.h>

#endif //RD_MULTIPLE_DRIVE

#include <mpxcollectiondbres.rsg>

#include <mpxmediageneraldefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxcollectionpath.h>

#include <mpxlog.h>

#include "mpxresource.h"

#include "mpxdbcommonutil.h"

#include "mpxdbutil.h"

#include "mpxcollectiondbdef.h"

#include "mpxdbpluginqueries.h"

#include "mpxcollectiondbmanager.h"

#include "mpxdbplaylist.h"

#include "mpxdbplaylistsongs.h"

#include "mpxdbcategory.h"

#include "mpxdbauxiliary.h"

#include "mpxdbautoplaylist.h"

#include "mpxdbhandler.h"

#include "mpxdbartist.h"

#include "mpxdbalbum.h"

#include "mpxdbgenre.h"

#include "mpxdbcomposer.h"

// CONSTANTS

_LIT(KMPXVirtualPlaylistExt, ".vir");

static const TInt KMaxOpInTransaction = 100;

const TInt KSqlDbCorrupted = -321;

#if defined (__MTP_PROTOCOL_SUPPORT)

#include <centralrepository.h>

// MTP CenRep Key UID

const TUid KMPXMtpSettings = {0x101FFC53};

// MTP CenRep Key for Delete contents

const TUint32 KMPXMtpSaveDeletedRecordFlag = 0x00000001;

#endif

// ============================ MEMBER FUNCTIONS ==============================

// ----------------------------------------------------------------------------

// Two-phased constructor.

// ----------------------------------------------------------------------------

//

CMPXDbHandler* CMPXDbHandler::NewL(

    RFs& aFs,

    CMPXResource& aResource)

    {

    MPX_FUNC("CMPXDbHandler::NewL");

    CMPXDbHandler* self = CMPXDbHandler::NewLC(aFs, aResource);

    CleanupStack::Pop(self);

    return self;

    }

// ----------------------------------------------------------------------------

// Two-phased constructor.

// ----------------------------------------------------------------------------

//

CMPXDbHandler* CMPXDbHandler::NewLC(

    RFs& aFs,

    CMPXResource& aResource)

    {

    MPX_FUNC("CMPXDbHandler::NewLC");

    CMPXDbHandler* self = new (ELeave) CMPXDbHandler(aFs, aResource);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

// ----------------------------------------------------------------------------

// Destructor

// ----------------------------------------------------------------------------

//

CMPXDbHandler::~CMPXDbHandler()

    {

    MPX_FUNC("CMPXDbHandler::~CMPXDbHandler");

    delete iAutoPlaylist;

    delete iDbMusic;

    delete iDbPlaylist;

    delete iDbArtist;

    delete iDbAlbum;

    delete iDbGenre;

    delete iDbComposer;

    delete iDbAuxiliary;

    delete iDbManager;

    delete iMimeTypes;

    delete iExtensions;

    delete iExtensionsMime;

    delete iExtensionsDrm;

    iDbDrives.Close();

    }

// ----------------------------------------------------------------------------

// C++ default constructor can NOT contain any code, that might leave

// ----------------------------------------------------------------------------

//

CMPXDbHandler::CMPXDbHandler(

    RFs& aFs,

    CMPXResource& aResource) :

    iFs(aFs),

    iResource(aResource)

    {

    MPX_FUNC("CMPXDbHandler::CMPXDbHandler");

    }

// ----------------------------------------------------------------------------

// Symbian 2nd phase constructor can leave.

// ----------------------------------------------------------------------------

//

void CMPXDbHandler::ConstructL()

    {

    MPX_FUNC("CMPXDbHandler::ConstructL");

    iMimeTypes = iResource.ReadDesCArrayL(R_MC_MIME_TYPES);

    iExtensions = iResource.ReadDesCArrayL(R_MC_MUSIC_FILE_EXTENSIONS);

    iExtensionsMime = iResource.ReadDesCArrayL(R_MC_FILE_EXTENSIONS_MIME);

    iExtensionsDrm = iResource.ReadDesCArrayL(R_MC_FILE_EXTENSIONS_DRM);

    // make sure all databases are created and valid

    iDbManager = CMPXCollectionDbManager::NewL(iFs);

    CDesCArrayFlat* musicFolders =

#ifdef RD_MULTIPLE_DRIVE

        GetMusicFoldersL();

#else

        iResource.ReadDesCArrayL(R_MC_DEFAULT_MUSIC_FOLDERS);

#endif

    // create the music folders and initialize iDbDrives

    CleanupStack::PushL(musicFolders);

    ProcessMusicFoldersL(*musicFolders);

    CleanupStack::PopAndDestroy(musicFolders);

    // Create the db infrastructure, 

    //

    iDbMusic = CMPXDbMusic::NewL(*iDbManager, iResource, *this);

    iDbPlaylist = CMPXDbPlaylist::NewL(*iDbManager, *this);

    iDbArtist = CMPXDbArtist::NewL(*iDbManager, EMPXArtist, *this);

	iDbAlbum = CMPXDbAlbum::NewL(*iDbManager, EMPXAlbum, *this);

    iDbGenre = CMPXDbGenre::NewL(*iDbManager, EMPXGenre);

    iDbComposer = CMPXDbComposer::NewL(*iDbManager, EMPXComposer);

    iAutoPlaylist = CMPXDbAutoPlaylist::NewL(*iDbManager, iFs, iResource);

    iDbAuxiliary = CMPXDbAuxiliary::NewL(*iDbManager);

    MPX_TRAPD(err, iDbManager->InitDatabasesL(iDbDrives));

    iCollectionOpen = ETrue;

    // If KErrCorrupt is returned, a database file was found to be corrupted

    // and was replaced with a new one.  The db plugin can ignore this error and continue

    // because a new db file was successfully created in a subsequent retry.

    if ((err != KErrNone) && (err != KErrCorrupt) && (err != KErrDiskFull))

        {

        // leave to signal the caller that there was an error why creating and opening

        // one or more of the databases

        User::Leave(err);

        }

    else if (err == KErrDiskFull)

        {

        iOutOfDisk = ETrue;

        }

    else

        {

        // do nothing

        }

    // Verify the volume ids of each drive matches the database

    MPX_TRAP(err,VerifyVolumeIdL());

    if ((err != KErrNone) && (err != KErrDiskFull))

        {

        // leave to signal the caller that there was an error why creating and opening

        // one or more of the databases

        User::Leave(err);

        }

    else if (err == KErrDiskFull)

        {

        iOutOfDisk = ETrue;

        }

//#ifdef _DEBUG

//    iDbManager->PrintDatabaseL();    // PREQ2536 the files sqlrowsetutil.h and sqlrowsetutil.cpp has been removed

//#endif

    MPX_DEBUG2("CMPXDbHandler::ConstructL DbCount[%d]", iDbManager->DatabaseCount());

    }

// ----------------------------------------------------------------------------

// Add song to collection

// ----------------------------------------------------------------------------

//

TUint32 CMPXDbHandler::AddSongL(

    const CMPXMedia& aMedia,

    CMPXMessageArray* aMessageArray)

    {

    MPX_FUNC("CMPXDbHandler::AddSongL");

    BeginTransactionL();

    TUint32 songId(0);

    MPX_TRAPD(err, songId = DoAddSongL(aMedia,aMessageArray));

    if (iOutOfDisk && (err == KErrNotFound))

        {

        err = KErrDiskFull;

        }

    EndTransactionL(err);

    return songId;

    }

// ----------------------------------------------------------------------------

// Add song to collection with no database transaction

// ----------------------------------------------------------------------------

//

TUint32 CMPXDbHandler::AddSongWithNoTransactionL(

    const CMPXMedia& aMedia,

    CMPXMessageArray* aMessageArray)

    {

    MPX_FUNC("CMPXDbHandler::AddSongWithNoTransactionL");

    TUint32 songId(0);

    MPX_TRAPD(err, songId = DoAddSongL(aMedia,aMessageArray));

    if (iOutOfDisk && (err == KErrNotFound))

        {

        err = KErrDiskFull;

        }

    User::LeaveIfError(err);

    return songId;

    }

// ----------------------------------------------------------------------------

// Add playlist to collection

// ----------------------------------------------------------------------------

//

TUint32 CMPXDbHandler::AddPlaylistL(

    const CMPXMedia& aMedia)

    {

    MPX_FUNC("CMPXDbHandler::AddPlaylistL");

    BeginTransactionL();

    TUint32 playlistId(0);

    MPX_TRAPD(err, playlistId = DoAddPlaylistL(aMedia));

    EndTransactionL(err);

    return playlistId;

    }

// ----------------------------------------------------------------------------

// Add song to playlist

// ----------------------------------------------------------------------------

//

TUint32 CMPXDbHandler::AddSongToPlaylistL(

    const CMPXMedia& aMedia)

    {

    MPX_FUNC("CMPXDbHandler::AddSongToPlaylistL");

    BeginTransactionL();

    TUint32 playlistId(0);

    MPX_TRAPD(err, playlistId = DoAddSongToPlaylistL(aMedia));

    EndTransactionL(err);

    return playlistId;

    }

// ----------------------------------------------------------------------------

// Update a song in the collection

// ----------------------------------------------------------------------------

//

CMPXDbActiveTask::TChangeVisibility CMPXDbHandler::UpdateSongL(

    const CMPXMedia& aMedia,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbHandler::UpdateSongL");

    BeginTransactionL();

    CMPXDbActiveTask::TChangeVisibility visibleChange(CMPXDbActiveTask::ENotVisibile);

    MPX_TRAPD(err, visibleChange = DoUpdateSongL(aMedia, aItemChangedMessages));

    EndTransactionL(err);

    return visibleChange;

    }

// ----------------------------------------------------------------------------

// Update a playlist in the collection

// ----------------------------------------------------------------------------

//

void CMPXDbHandler::UpdatePlaylistL(

    const CMPXMedia& aMedia,

    CMPXMessageArray& aMessageArray)

    {

    MPX_FUNC("CMPXDbHandler::UpdatePlaylistL");

    BeginTransactionL();

    MPX_TRAPD(err, DoUpdatePlaylistL(aMedia, aMessageArray));

    EndTransactionL(err);

    }

// ----------------------------------------------------------------------------

// Updates the playlist songs

// ----------------------------------------------------------------------------

//

void CMPXDbHandler::UpdatePlaylistSongsL(

    const CMPXMedia& aMedia,

    CMPXMessage& aMessage)

    {

    MPX_FUNC("CMPXDbHandler::UpdatePlaylistSongsL");

    BeginTransactionL();

    MPX_TRAPD(err, DoUpdatePlaylistSongsL(aMedia, aMessage));

    EndTransactionL(err);

    }

// ----------------------------------------------------------------------------

// Reorder a song in a playlist

// ----------------------------------------------------------------------------

//

void CMPXDbHandler::ReorderPlaylistL(

    const TMPXItemId& aPlaylistId,

    const TMPXItemId& aSongId,

    TUint aOriginalOrdinal,

    TUint aNewOrdinal,

    CMPXMessage& aMessage)

    {

    MPX_DEBUG5("-->CMPXDbHandler::ReorderPlaylistL(0x%x, 0x%x, %d, %d)",

               aPlaylistId.iId2, aSongId.iId2, aOriginalOrdinal, aNewOrdinal);

    BeginTransactionL();

    MPX_TRAPD(err, DoReorderPlaylistL(aPlaylistId, aSongId, aOriginalOrdinal, aNewOrdinal, aMessage));

    EndTransactionL(err);

    MPX_DEBUG2("<--CMPXDbHandler::ReorderPlaylistL() error=%d", err);

    }

// ----------------------------------------------------------------------------

// Remove the entire music collection database

// ----------------------------------------------------------------------------

//

void CMPXDbHandler::RemoveEntireCollectionL()

    {

    MPX_FUNC("CMPXDbHandler::RemoveEntireCollectionL");

    BeginTransactionL();

    MPX_TRAPD(err, iDbManager->RecreateAllDatabasesL());

    EndTransactionL(err);

    }

// ----------------------------------------------------------------------------

// Delete a song from collection

// The function notifies collection model to perform deletion

// ----------------------------------------------------------------------------

//

void CMPXDbHandler::RemoveSongL(

    TUint32 aSongId,

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages,

    TBool aDeleteRecord)

    {

    MPX_FUNC("CMPXDbHandler::RemoveSongL");

    MPX_TRAPD(err, DoRemoveSongL(aSongId, aUriArray, aItemChangedMessages, aDeleteRecord));

    MPX_TRAP(err, DoRemoveSongFromPlaylistL(aSongId,aItemChangedMessages));

    }

// ----------------------------------------------------------------------------

// Removes a category of songs from the music collection,

// and its corresponding category in the lookup table

// ----------------------------------------------------------------------------

//

void CMPXDbHandler::RemoveSongsMatchingCategoryL(

    TMPXGeneralCategory aCategory,

    TUint32 aCategoryId,

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbHandler::RemoveSongsMatchingCategoryL");

    BeginTransactionL();

    MPX_TRAPD(err, DoRemoveSongsMatchingCategoryL(aCategory, aCategoryId, aUriArray, aItemChangedMessages));

    EndTransactionL(err);

    }

// ----------------------------------------------------------------------------------------------------------

// Delete songs for the specified artist and album from collection

// The function notifies collection model to perform deletion

// ----------------------------------------------------------------------------------------------------------

//

void CMPXDbHandler::RemoveSongsMatchingArtistAndAlbumL(

    TUint32 aArtistId,

    TUint32 aAlbumId,

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbHandler::RemoveSongsMatchingArtistAndAlbumL");

    BeginTransactionL();

    MPX_TRAPD(err, DoRemoveSongsMatchingArtistAndAlbumL(aArtistId, aAlbumId, aUriArray,

        aItemChangedMessages));

    EndTransactionL(err);

    }

// ----------------------------------------------------------------------------

// Remove all playlists from collection

// ----------------------------------------------------------------------------

//

void CMPXDbHandler::RemoveAllPlaylistsL()

    {

    MPX_FUNC("CMPXDbHandler::RemoveAllPlaylistsL");

    BeginTransactionL();

    MPX_TRAPD(err, DoRemoveAllPlaylistsL());

    EndTransactionL(err);

    }

// ----------------------------------------------------------------------------

// Remove specified playlist

// ----------------------------------------------------------------------------

//

void CMPXDbHandler::RemovePlaylistL(

    TUint32 aPlaylistId,

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbHandler::RemovePlaylistL");

    BeginTransactionL();

    MPX_TRAPD(err, DoRemovePlaylistL(aPlaylistId, aUriArray, aItemChangedMessages));

    EndTransactionL(err);

    }

// ----------------------------------------------------------------------------

// Remove song from playlist songs table

// ----------------------------------------------------------------------------

//

void CMPXDbHandler::RemoveSongFromPlaylistL(

    TUint32 aPlaylistId,

    const TMPXItemId& aSongId,

    TInt aOrdinal,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbHandler::RemoveSongFromPlaylistL");

    MPX_DEBUG5("CMPXDbHandler::RemoveSongFromPlaylistL(playlist 0x%x, songId [0x%x,0x%x], ordinal %d)",

        aPlaylistId, aSongId.iId1, aSongId.iId2, aOrdinal);

    MPX_TRAPD(err, DoRemoveSongFromPlaylistL(aPlaylistId, aSongId, aOrdinal, aItemChangedMessages));

    if ( err && InTransaction() )

        {

        // only end transaction if there's an error

        EndTransactionL( err );

        }

    }

// ----------------------------------------------------------------------------

// Cleanup records marked as deleted. This is designated for MTP to clean up records marked as deleted

// at the end of its session.

// ----------------------------------------------------------------------------

//

void CMPXDbHandler::CleanupDeletedRecordsL()

    {

    MPX_FUNC("CMPXDbHandler::CleanupDeletedRecordsL");

    BeginTransactionL();

    MPX_TRAPD(err, DoCleanupDeletedRecordsL());

    EndTransactionL(err);

    }

// ----------------------------------------------------------------------------

//  Read all songs and cache them into an array ordered by song name

// ----------------------------------------------------------------------------

//

void CMPXDbHandler::GetAllSongsL(

    CMPXMediaArray* aMediaArray,

    const TArray<TMPXAttribute>& aAttrs)

    {

    MPX_FUNC("CMPXDbHandler::GetAllSongsL");

    iDbMusic->GetAllSongsL(aAttrs, *aMediaArray);

    }

// ----------------------------------------------------------------------------

//  Read a limited # of songs and cache them into an array ordered by song name

// ----------------------------------------------------------------------------

//

void CMPXDbHandler::GetAllSongsLimitedL(const TArray<TMPXAttribute>& aAttrs,

                                        CMPXMediaArray& aMediaArray, TInt aLimit)

    {

    MPX_FUNC("CMPXDbHandler::GetAllSongsLimitedL");

    iDbMusic->GetAllSongsLimitedL( aAttrs, aMediaArray, aLimit );

    }

// ----------------------------------------------------------------------------

//  Read all songs and cache them into an array ordered by song name

// ----------------------------------------------------------------------------

//