/*

* 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 <mpxcollectiondbhgres.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;

#ifdef ABSTRACTAUDIOALBUM_INCLUDED

    delete iDbAbstractAlbum;

#endif // ABSTRACTAUDIOALBUM_INCLUDED

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

#ifdef ABSTRACTAUDIOALBUM_INCLUDED

    iDbAbstractAlbum = CMPXDbAbstractAlbum::NewL(*iDbManager, EMPXAbstractAlbum, iFs);

#endif // ABSTRACTAUDIOALBUM_INCLUDED

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

    iDbAuxiliary = CMPXDbAuxiliary::NewL(*iDbManager);

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

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

    }

#ifdef ABSTRACTAUDIOALBUM_INCLUDED

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

// Add AbstractAlbum to collection

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

//

TUint32 CMPXDbHandler::AddAbstractAlbumL(

    const CMPXMedia& aMedia,

    CMPXMessageArray* aMessageArray)

    {

    MPX_FUNC("CMPXDbHandler::AddAbstractAlbumL");

    BeginTransactionL();

    TBool newRecord(EFalse);

    TInt err(KErrNone);

    TDriveUnit drive(aMedia.ValueText(KMPXMediaGeneralUri));

    TPtrC uri(aMedia.ValueText(KMPXMediaGeneralUri).Left(KMCMaxTextLen));

    TPtrC name(aMedia.ValueText(KMPXMediaGeneralTitle).Left(KMCMaxTextLen));

    TPtrC albumartist(aMedia.ValueText(KMPXMediaMusicAlbumArtist).Left(KMCMaxTextLen));

    //only insert to AbstractAlbum table when it is new item

    TUint32 abstractAlbumId(MPXDbCommonUtil::GenerateUniqueIdL(iFs, EMPXAbstractAlbum, uri, EFalse));

    newRecord = !iDbAbstractAlbum->CategoryItemExistsL(drive, abstractAlbumId);

    if (newRecord)

        {

        MPX_TRAP(err, abstractAlbumId = iDbAbstractAlbum->AddItemL(uri, name, albumartist, drive, newRecord, EFalse));

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

            {

            err = KErrDiskFull;

            }

        if (aMessageArray)

            {

            MPXDbCommonUtil::AddItemChangedMessageL(*aMessageArray, abstractAlbumId, EMPXItemInserted,

            EMPXAbstractAlbum, KDBPluginUid);

            }

        }

    EndTransactionL(err);

    return abstractAlbumId;

    }

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

// Update abstractalbum info to AbstractAlbum table and all songs which associate 

// with AbstractAlbum in the collection

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

//

CMPXDbActiveTask::TChangeVisibility CMPXDbHandler::UpdateAbstractAlbumL(

    const CMPXMedia& aMedia,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbHandler::UpdateAbstractAlbumL");

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

    TUint32 itemId(0);

    if (aMedia.IsSupported(KMPXMediaGeneralUri))

        {

        const TDesC& uri(aMedia.ValueText (KMPXMediaGeneralUri));

        TDriveUnit drive(aMedia.ValueText(KMPXMediaGeneralUri));

        //get Id based on new uri

        itemId = MPXDbCommonUtil::GenerateUniqueIdL(iFs, EMPXAbstractAlbum, uri, EFalse);

        if (!itemId)

            {

            User::Leave(KErrNotSupported);

            }

        //if updating to new item, need do renaming for AbstractAlbum: delete old one and insert a new entry to AbstractAlbum table

        //if a new item, need update songs associated and renaming albstractalbum table

        if (aMedia.IsSupported(KMPXMediaGeneralId))

            {

            MPX_DEBUG1("CMPXDbHandler::UpdateAbstractAlbumL, rename case");

            BeginTransactionL();

            //get old id, for renaming

            TInt err(KErrNone);

            TUint32 oldId = (aMedia.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId)).iId2;

            if (oldId && (oldId != itemId) )  //pass the old UID for renaming, do not care if new itemId exist or not

                {

                //get old Uri based on old Id

                HBufC* oldUri = iDbAbstractAlbum->GetUriL(oldId);

                CleanupStack::PushL(oldUri);

                //add and update new item to AbstractAlbum table

                //old existing item field values need to be saved and added when adding new item                        

                MPX_TRAP(err, itemId = iDbAbstractAlbum->AddUpdatedItemL(oldId, uri ));

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

                    {

                    err = KErrDiskFull;

                    }

                MPXDbCommonUtil::AddItemChangedMessageL(aItemChangedMessages, itemId, EMPXItemInserted,

                EMPXAbstractAlbum, KDBPluginUid);

                //find and update all songs associated with oldId

                RArray<TMPXAttribute> songAttributes;

                CleanupClosePushL(songAttributes);

                songAttributes.AppendL(KMPXMediaGeneralId);

                CMPXMediaArray* mediaArray = CMPXMediaArray::NewL();

                CleanupStack::PushL(mediaArray);

                //get all songs associated

                MPX_TRAP(err, iDbMusic->GetAllSongsForAbstractAlbumL(oldId, songAttributes.Array(), *mediaArray));

                if (err == KErrNotFound)

                    {

                    // Leave with KErrNotFound

                    MPX_DEBUG1("CMPXDbHandler::UpdateAbstractAlbumL, leave with not found");

                    User::Leave(KErrNotFound);

                    }

                TInt count(mediaArray->Count());

                MPX_DEBUG2("CMPXDbHandler::UpdateAbstractAlbumL, [%d] songs associated", count);

                //go through all songs for updating

                for (TInt i = 0; i < count; i++)

                    {

                    CMPXMedia* song = mediaArray->AtL(i);

                    song->SetTextValueL(KMPXMediaMusicAlbumArtFileName, uri );

                    visibleChange = UpdateSongL(*song, aItemChangedMessages);

                    }

                CleanupStack::PopAndDestroy(mediaArray);

                CleanupStack::PopAndDestroy(&songAttributes);

                //rename TN

                iDbAbstractAlbum->HandleTNL(*oldUri, uri, 0);

                CleanupStack::PopAndDestroy(oldUri);

                }

            EndTransactionL(err);

            }//renaming

        //check if abstractAlbum exist in ABSTRACTALBUM table before update it

        else if (iDbAbstractAlbum->CategoryItemExistsL(drive, itemId))

            {

            //support updating Name, AlbumArtist fields for AbstractAlbum table

            iDbAbstractAlbum->UpdateItemL(itemId, aMedia, drive, &aItemChangedMessages);

            }

        }

    return visibleChange;

    }

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

// Update all songs which associate with AbstractAlbum to new AbstractAlbum info 

// in the collection

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

//

CMPXDbActiveTask::TChangeVisibility CMPXDbHandler::UpdateSongsAbstractAlbumInfoL(

    const CMPXMedia& aMedia,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbHandler::UpdateSongsAbstractAlbumInfoL");

    const TDesC& uri(aMedia.ValueText (KMPXMediaGeneralUri));

    //need to update songs information to music table

    CMPXMediaArray* mediaArray = aMedia.Value<CMPXMediaArray>(KMPXMediaArrayContents);

    User::LeaveIfNull(mediaArray);

    TInt count(mediaArray->Count());

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

    for (TInt i = 0; i < count; i++)

        {

        CMPXMedia* mediaSong = mediaArray->AtL(i);

        mediaSong->SetTextValueL(KMPXMediaMusicAlbumArtFileName, uri );

        visibleChange = UpdateSongL(*mediaSong, aItemChangedMessages);

        }

    return visibleChange;

    }

#endif // ABSTRACTAUDIOALBUM_INCLUDED

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

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

    {