/*

* 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:  This class is used by db plugin to add episodes into DB or

*                remove episodes from DB

*

*/

// INCLUDE FILES

#include <PCRes.rsg>

#include <bautils.h>

#include <MetaDataUtility.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#include <pathinfo.h>

#endif //RD_MULTIPLE_DRIVE

#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 "mpxdbcommondef.h"

#include "mpxresource.h"

#include "mpxdbcommonutil.h"

#include "mpxdbutil.h"

#include "mpxpodcastcollectiondbdef.h"

#include "mpxpodcastdbmanager.h"

#include "mpxdbcategory.h"

#include "mpxdbauxiliary.h"

#include "mpxpodcastdbhandler.h"

#include "mpxpodcastdbpluginqueries.h"

// CONSTANTS

#if defined (__MTP_PROTOCOL_SUPPORT)

#include <centralrepository.h>

const TUid KMPXMtpSettings = {0x101FFC53};    // MTP CenRep Key UID

const TUint32 KMPXMtpSaveDeletedRecordFlag = 0x00000001;      // MTP CenRep Key for Delete contents

#endif

const TInt KSqlDbCorrupted = -321;

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

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

// Two-phased constructor.

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

//

CMPXPodcastDbHandler* CMPXPodcastDbHandler::NewL(

    RFs& aFs,

    CMPXResource& aResource)

    {

    MPX_FUNC("CMPXPodcastDbHandler::NewL");

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

    CleanupStack::Pop(self);

    return self;

    }

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

// Two-phased constructor.

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

//

CMPXPodcastDbHandler* CMPXPodcastDbHandler::NewLC(

    RFs& aFs,

    CMPXResource& aResource)

    {

    MPX_FUNC("CMPXPodcastDbHandler::NewLC");

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CMPXPodcastDbHandler::~CMPXPodcastDbHandler()

    {

    MPX_FUNC("CMPXPodcastDbHandler::~CMPXPodcastDbHandler");

    delete iDbPodcast;

    delete iDbArtist;

    delete iDbAlbum;

    delete iDbGenre;

    delete iDbComposer;

    delete iDbAuxiliary;

    delete iDbManager;

    delete iPodcastPublishDateCat;

    iPodcastPublishDateIds.Close();

    iDbDrives.Close();

    }

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

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

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

//

CMPXPodcastDbHandler::CMPXPodcastDbHandler(

    RFs& aFs,

    CMPXResource& aResource) :

    iFs(aFs),

    iResource(aResource)

    {

    MPX_FUNC("CMPXPodcastDbHandler::CMPXPodcastDbHandler");

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXPodcastDbHandler::ConstructL()

    {

    MPX_FUNC("CMPXPodcastDbHandler::ConstructL");

    iPodcastPublishDateCat = iResource.ReadMenuArrayL(R_MPX_QTN_NMP_PUBLISH_DATE_ARRAY,

        iPodcastPublishDateIds);

    //create db manager

    iDbManager = CMPXPodcastDbManager::NewL(iFs);

    CDesCArrayFlat* podcastFolders =

#ifdef RD_MULTIPLE_DRIVE

		GetPodcastFoldersL();

#else

    	iResource.ReadDesCArrayL(R_MC_DEFAULT_MUSIC_FOLDERS);

#endif

    // create the podcast folders and initialize iDbDrives

    CleanupStack::PushL(podcastFolders);

    ProcessPodcastFoldersL(*podcastFolders);

    CleanupStack::PopAndDestroy(podcastFolders);

    // create the db infrastructure

    iDbPodcast = CMPXDbPodcast::NewL(*iDbManager, iResource, *this);

    iDbArtist = CMPXDbCategory::NewL(*iDbManager, EMPXArtist);

    iDbAlbum = CMPXDbCategory::NewL(*iDbManager, EMPXAlbum);

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

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

    iDbAuxiliary = CMPXDbAuxiliary::NewL(*iDbManager);

    // make sure all databases are created and valid

    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 ID Matches

    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;

        }

    // iDbManager->PrintDatabaseL();

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

    }

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

// Add episode into collection

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

//

TUint32 CMPXPodcastDbHandler::AddEpisodeL(

    const CMPXMedia& aMedia)

    {

    MPX_FUNC("CMPXPodcastDbHandler::AddEpisodeL");

    BeginTransactionL();

    TUint32 episodeId(0);

    MPX_TRAPD(err, episodeId = DoAddEpisodeL(aMedia));

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

        {

        err = KErrDiskFull;

        }

    EndTransactionL(err);

    return episodeId;

    }

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

// Update a episode in the collection

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

//

CMPXDbActiveTask::TChangeVisibility CMPXPodcastDbHandler::UpdateEpisodeL(

    const CMPXMedia& aMedia,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXPodcastDbHandler::UpdateEpisodeL");

    BeginTransactionL();

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

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

    EndTransactionL(err);

    return visibleChange;

    }

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

// Remove the entire podcast collection database

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

//

void CMPXPodcastDbHandler::RemoveEntireCollectionL()

    {

    MPX_FUNC("CMPXPodcastDbHandler::RemoveEntireCollectionL");

    BeginTransactionL();

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

    EndTransactionL(err);

    }

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

// Delete a episode from collection

// The function notifies collection model to perform deletion

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

//

void CMPXPodcastDbHandler::RemoveEpisodeL(

    TUint32 aEpisodeId,

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages,

    TBool aDeleteRecord)

    {

    MPX_FUNC("CMPXPodcastDbHandler::RemoveEpisodeL");

    BeginTransactionL();

    MPX_TRAPD(err, DoRemoveEpisodeL(aEpisodeId, aUriArray, aItemChangedMessages, aDeleteRecord));

    EndTransactionL(err);

    }

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

// Removes a category of episodes from the podcast collection, and its

// corresponding category in the lookup table

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

//

void CMPXPodcastDbHandler::RemoveEpisodesMatchingCategoryL(

    TMPXGeneralCategory aCategory,

    TUint32 aCategoryId,

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXPodcastDbHandler::RemoveEpisodesMatchingCategoryL");

    BeginTransactionL();

    MPX_TRAPD(err, DoRemoveEpisodesMatchingCategoryL(aCategory, aCategoryId,

        aUriArray, aItemChangedMessages));

    EndTransactionL(err);

    }

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

// Delete episode(s) from collection belonging to specified publish date category

// The function notifies collection model to perform deletion

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

//

void CMPXPodcastDbHandler::RemoveEpisodesMatchingPublishDateCategoryL(

    TUint32 aCategoryId,

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXPodcastDbHandler::RemoveEpisodesMatchingPublishDateCategoryL");

    BeginTransactionL();

    MPX_TRAPD(err, DoRemoveEpisodesMatchingPublishDateCategoryL(aCategoryId,

        aUriArray, aItemChangedMessages));

    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 CMPXPodcastDbHandler::CleanupDeletedRecordsL()

    {

    MPX_FUNC("CMPXPodcastDbHandler::CleanupDeletedRecordsL");

    BeginTransactionL();

    MPX_TRAPD(err, DoCleanupDeletedRecordsL());

    EndTransactionL(err);

    }

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

//  Read all episodes and cache them into an array ordered by episode name

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

//

void CMPXPodcastDbHandler::GetAllEpisodesL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray)

    {

    MPX_FUNC("CMPXPodcastDbHandler::GetAllEpisodesL");

    iDbPodcast->GetAllEpisodesL(aAttrs, aMediaArray);

    }

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

// Retrieve the episode(s) with the specified title

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

//

void CMPXPodcastDbHandler::GetEpisodesMatchingTitleL(

    TUint aTitleId,

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray)

    {

    MPX_FUNC("CMPXPodcastDbHandler::GetEpisodesMatchingTitleL");

    iDbPodcast->GetEpisodesForCategoryL(EMPXAlbum, aTitleId, aAttrs,

                                        aMediaArray, ETrue);

    }

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

// Retrieve the episode(s) belonging to the specified playlist

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

//

void CMPXPodcastDbHandler::GetEpisodesMatchingPlaylistL(

    TUint aPlaylistId,

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray,

    TInt& aIndexOfCurrentlyPlayingItem)

    {

    MPX_FUNC("CMPXPodcastDbHandler::GetEpisodesMatchingPlaylistL");

    switch (aPlaylistId)

        {

        case KRecentlyAddedPlaylistUID:

            {

            iDbPodcast->GetRecentlyAddedPlaylistEpisodesL(aAttrs, aMediaArray,

                aIndexOfCurrentlyPlayingItem);

            break;

            }

        case KNotPlayedPlaylistUID:

            {

            iDbPodcast->GetNotYetPlayedPlaylistEpisodesL(aAttrs, aMediaArray,

                aIndexOfCurrentlyPlayingItem);

            break;

            }

        default:

            {

            User::Leave(KErrNotSupported);

            }

        }

    }

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

// Retrieve the episode with the specified ID

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

//

void CMPXPodcastDbHandler::GetEpisodeL(

    TUint32 aEpisodeId,

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray)

    {

    MPX_FUNC("CMPXPodcastDbHandler::GetEpisodeL");

    CMPXMedia* media = CMPXMedia::NewL();

    CleanupStack::PushL(media);

    GetEpisodeL(aEpisodeId, aAttrs, *media);

    aMediaArray.AppendL(*media);

    CleanupStack::PopAndDestroy(media);

    }

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

// Retrieve the episode with the specified ID

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

//

void CMPXPodcastDbHandler::GetEpisodeL(

    TUint32 aEpisodeId,

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMedia& aMedia)

    {

    MPX_FUNC("CMPXPodcastDbHandler::GetEpisodeL");

    iDbPodcast->GetEpisodeL(aEpisodeId, aAttrs, aMedia);

    }

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

// Retrieve the episode with the specified URI

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

//

TUint32 CMPXPodcastDbHandler::GetEpisodeIdMatchingUriL(

    const TDesC& aUri)

    {

    MPX_FUNC("CMPXPodcastDbHandler::GetEpisodeIdMatchingUriL");

    return MPXDbCommonUtil::GenerateUniqueIdL(iFs, EMPXCollection, aUri, EFalse);

    }

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

// Return all podcast title names

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

//

void CMPXPodcastDbHandler::GetAllPodcastTitlesL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray)

    {

    MPX_FUNC("CMPXPodcastDbHandler::GetAllPodcastTitlesL");

    iDbAlbum->GetAllCategoryItemsL(aAttrs, aMediaArray);

    }

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

// Retrieve episodes matching the specified publish playlist id

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

//

TInt CMPXPodcastDbHandler::GetEpisodesMatchingPublishPlaylistL(

    TUint aPlaylistId,

    const TArray<TMPXAttribute>& aAttrs,

    TBool aPendingCategoryDeletionFlag,

    CMPXMediaArray& aMediaArray)

    {

    MPX_FUNC("CMPXPodcastDbHandler::GetEpisodesMatchingPublishPlaylistL");

    TInt numEpisodes(0);

    TMPXItemId podcastPublishDateCatId = 0;

    // the deletion helper is retrieving all the media within this category

    // to delete it so need to record category id within last item so

    // that the HandleChangeL callback can cause OpenL to be called after the

    // last item within the category is deleted

    if (aPendingCategoryDeletionFlag)

        {

        TInt categoryID(EMPXOther);

        // pass in the category Id so that the helper method can add

        // the category Id to the last item in this category to aid

        // in deletion of a category

        podcastPublishDateCatId = (aPlaylistId - KPublishTodayPlaylistUID) | (categoryID << 28);

        }

    switch (aPlaylistId)

        {

        case KPublishAllPlaylistUID:

            {

            TInt itemCount(iPodcastPublishDateCat->Count());

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

                {

                TMPXItemId itemId = iPodcastPublishDateIds[i];

                TInt count(0);

                switch (iPodcastPublishDateIds[i] + KPublishTodayPlaylistUID)

                    {

                    case KPublishTodayPlaylistUID:

                        count = iDbPodcast->GetTodayEpisodesCountL();

                        break;

                    case KPublishYesterdayPlaylistUID:

                        count = iDbPodcast->GetYesterdayEpisodesCountL();

                        break;

                    case KPublishThisWeekPlaylistUID:

                        count = iDbPodcast->GetThisWeekEpisodesCountL();

                        break;

                    case KPublishLastWeekPlaylistUID:

                        count = iDbPodcast->GetLastWeekEpisodesCountL();

                        break;

                    case KPublish2WeeksAgoPlaylistUID:

                        count = iDbPodcast->Get2WeeksAgoEpisodesCountL();

                        break;

                    case KPublish3WeeksAgoPlaylistUID:

                        count = iDbPodcast->Get3WeeksAgoEpisodesCountL();

                        break;

                    case KPublishLastMonthPlaylistUID:

                        count = iDbPodcast->GetLastMonthEpisodesCountL();

                        break;

                    case KPublishEarlierPlaylistUID:

                        count = iDbPodcast->GetEarlierEpisodesCountL();

                        break;

                    case KPublishUnknownPlaylistUID:

                        count = iDbPodcast->GetUnknownEpisodesCountL();

                        break;

                    default:

                        User::Leave(KErrNotFound);

                        break;

                    };

                if (count > 0)

                    {

                    numEpisodes += count;

                    MPXDbUtil::AppendMediaL(aMediaArray, iPodcastPublishDateCat->MdcaPoint(i),

                        EMPXGroup, EMPXPlaylist, EMPXPodcastGroup, EMPXPubDate, itemId);

                    }

                }

            break;

            }

        case KPublishTodayPlaylistUID:

            MPX_DEBUG1 (_L("CMPXPodcastDbHandler::GetEpisodesMatchingPublishPlaylistL: Published Today"));

            iDbPodcast->GetTodayEpisodesL(podcastPublishDateCatId, aAttrs, aMediaArray);

            break;

        case KPublishYesterdayPlaylistUID:

            MPX_DEBUG1 (_L("CMPXPodcastDbHandler::GetEpisodesMatchingPublishPlaylistL: Published Yesterday"));

            iDbPodcast->GetYesterdayEpisodesL(podcastPublishDateCatId, aAttrs, aMediaArray);

            break;

        case KPublishThisWeekPlaylistUID:

            MPX_DEBUG1 (_L("CMPXPodcastDbHandler::GetEpisodesMatchingPublishPlaylistL: Published This Week"));