/*

* 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:  Responsible for interation with the category tables:

*                Artist, Album, Genre, Composer and AbstractAlbum

*

*/

// INCLUDE FILES

#include <mpxlog.h>

#include <bautils.h>

#include <mpxmediamusicdefs.h>

#include "mpxdbabstractalbum.h"

#include "mpxdbpluginqueries.h"

#include "mpxdbmanager.h"

#include "mpxdbcommonutil.h"

#include "mpxcollectiondbstd.h"

#include "mpxdbcommondef.h"

#include "mpxcollectiondbdef.h"

#ifdef RD_MPX_TNM_INTEGRATION

_LIT( KImageFileType, "image/jpeg" );

#endif //RD_MPX_TNM_INTEGRATION

// CONSTANTS

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

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

// Two-phased constructor.

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

//

CMPXDbAbstractAlbum* CMPXDbAbstractAlbum::NewL(

    CMPXDbManager& aDbManager,

    {

    MPX_FUNC("CMPXDbAbstractAlbum::NewL");

    CleanupStack::Pop(self);

    return self;

    }

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

// Two-phased constructor.

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

//

CMPXDbAbstractAlbum* CMPXDbAbstractAlbum::NewLC(

    CMPXDbManager& aDbManager,

    {

    MPX_FUNC("CMPXDbAbstractAlbum::NewLC");

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CMPXDbAbstractAlbum::~CMPXDbAbstractAlbum()

    {

    MPX_FUNC("CMPXDbAbstractAlbum::~CMPXDbAbstractAlbum");

#ifdef RD_MPX_TNM_INTEGRATION

    delete iTNManager;

#endif //RD_MPX_TNM_INTEGRATION

    }

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

// CMPXDbAbstractAlbum::GetDriveIdL

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

//

TInt CMPXDbAbstractAlbum::GetDriveIdL(

    TUint32 aAbstractAlbumId)

    {

    MPX_FUNC("CMPXDbAbstractAlbum::GetDriveIdL");

    return MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(),

        ExecuteIntQueryL(KCriterionCategoryVolumeId, aAbstractAlbumId));

    }

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

// CMPXDbAbstractAlbum::AddItemL

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

//

TUint32 CMPXDbAbstractAlbum::AddItemL(

    const TDesC& aName,

    const TDesC& aAlbumArtist,

    TInt aDriveId,

    TBool& aNewRecord,

    TBool aCaseSensitive)

    {

    MPX_FUNC("CMPXDbAbstractAlbum::AddItemL");

    TUint32 rowId(MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), EMPXAbstractAlbum,

    if ( aNewRecord )

        {

        HBufC* name = MPXDbCommonUtil::ProcessSingleQuotesLC(aName);

        HBufC* albumartist = MPXDbCommonUtil::ProcessSingleQuotesLC(aAlbumArtist);

        }

    else

        {

        // increment the number of songs for the category

        HBufC* query = PreProcessStringLC(KQueryCategoryIncrementSongCount);

        iDbManager.ExecuteQueryL(aDriveId, *query, rowId);

        CleanupStack::PopAndDestroy(query);

        }

    return rowId;

    }

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

// CMPXDbAbstractAlbum::DecrementSongsForCategoryL

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

//

void CMPXDbAbstractAlbum::DecrementSongsForCategoryL(

    const TUint32 aId,

    TInt aDriveId,

    CMPXMessageArray* aItemChangedMessages,

    TBool& aItemExist,

    TBool aMtpInUse)

    {

    MPX_FUNC("CMPXDbAbstractAlbum::DecrementSongsForCategoryL");

    TInt songCount = GetSongsCountL(aDriveId, aId);

    if ( songCount > 0 )

        {

        aItemExist = ETrue;

        // decrement the number of songs for the category

        HBufC* query = PreProcessStringLC(KQueryCategoryDecrementSongCount);

        iDbManager.ExecuteQueryL(aDriveId, *query, aId);

        CleanupStack::PopAndDestroy(query);

        songCount--;

        }

        {

            {

    }

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

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

//

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

// CMPXDbAbstractAlbum::UpdateItemL

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

//

void CMPXDbAbstractAlbum::UpdateItemL(

    TUint32 aId,

    const CMPXMedia& aMedia,

    TInt aDriveId,

    CMPXMessageArray* aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbAbstractAlbum::UpdateItemL");

    CDesCArrayFlat* fields = new (ELeave) CDesCArrayFlat(EAbstractAlbumFieldCount);

    CleanupStack::PushL(fields);

    CDesCArrayFlat* values = new (ELeave) CDesCArrayFlat(EAbstractAlbumFieldCount);

    CleanupStack::PushL(values);

    // process the media parameter and construct the fields and values array

    GenerateAbstractAlbumFieldsValuesL(aMedia, *fields, *values);

    // construct the SET string

    HBufC* setStr = MPXDbCommonUtil::StringFromArraysLC(*fields, *values, KMCEqualSign, KMCCommaSign);

    if (setStr->Length())

        {

        // execute the query

        iDbManager.ExecuteQueryL(aDriveId, KQueryAbstractAlbumUpdate, setStr, aId);

        MPXDbCommonUtil::AddItemAlbumChangedMessageL(*aItemChangedMessages, aId, EMPXItemModified,

                EMPXAbstractAlbum, KDBPluginUid, ETrue, 0 );

        }

    CleanupStack::PopAndDestroy(setStr);

    CleanupStack::PopAndDestroy(values);

    CleanupStack::PopAndDestroy(fields);

    }

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

// CMPXDbAbstractAlbum::UpdateMediaL

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

//

void CMPXDbAbstractAlbum::UpdateMediaL(

    RSqlStatement& aRecord,

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMedia& aMedia)

    {

           if (contentId == KMPXMediaIdGeneral)

               {

               if (attributeId & EMPXMediaGeneralId)

                   {

                   aMedia.SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId,

                       aRecord.ColumnInt64(EAbstractAlbumUniqueId));

                   }

               if (attributeId & EMPXMediaGeneralTitle)

                   {

                   TPtrC title(MPXDbCommonUtil::GetColumnTextL(aRecord, EAbstractAlbumName));

                   aMedia.SetTextValueL(KMPXMediaGeneralTitle, title);

                   MPX_DEBUG2("    AbstractAlbumName[%S]", &title);

               if (attributeId & EMPXMediaGeneralCount)

                   {

                   TInt songCount = GetSongsCountL(KDbManagerAllDrives,

                                aRecord.ColumnInt64(EAbstractAlbumUniqueId));

                   aMedia.SetTObjectValueL<TInt>(KMPXMediaGeneralCount, songCount );

                   }

                   TUint32 volId(aRecord.ColumnInt64(EAbstractAlbumVolumeId));

                   TInt driveId = MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(), volId);

                   MPX_DEBUG3("volId = %d, driveId = %d", volId, driveId);

                   // handle possibly delay from framework notification

                   if (driveId < 0)

                       {

                       MPX_DEBUG1("invalid driveId, leave with KErrNotReady");

                       User::Leave(KErrNotReady);

                       }

                   TDriveUnit driveUnit(driveId);

           else if ( contentId == KMPXMediaIdMusic)

               {

               if (attributeId & EMPXMediaMusicAlbumArtist)

                   TPtrC albumartist(MPXDbCommonUtil::GetColumnTextL(aRecord, EAbstractAlbumArtist));

                   aMedia.SetTextValueL(KMPXMediaMusicAlbumArtist, albumartist);

                   MPX_DEBUG2("    albumartist[%S]", &albumartist);

                   }

               }

           } // end for

       aMedia.SetTObjectValueL<TMPXGeneralType>(KMPXMediaGeneralType, EMPXItem);

       aMedia.SetTObjectValueL<TMPXGeneralCategory>(KMPXMediaGeneralCategory, EMPXAbstractAlbum);

    }

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

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

//

void CMPXDbAbstractAlbum::GenerateAbstractAlbumFieldsValuesL(const CMPXMedia& aMedia, CDesCArray& aFields, CDesCArray& aValues)

    {

    MPX_FUNC("CMPXDbAbstractAlbum::GenerateAbstractAlbumFieldsValuesL");

        {

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

        MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCCategoryName, truncatedName);

        }

        {

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

        MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCMusicAlbumArtist, truncatedAlbumArtist);

        }

        {

        }

    }

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

// CMPXDbAlbum::CreateTableL

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

//

void CMPXDbAbstractAlbum::CreateTableL(

    RSqlDatabase& aDatabase,

    TBool /* aCorruptTable */)

    {

    MPX_FUNC("CMPXDbAbstractAlbum::CreateTableL");

    // create the table

    HBufC* query = PreProcessStringLC(KAbstractAlbumCreateTable);

    User::LeaveIfError(aDatabase.Exec(*query));

    CleanupStack::PopAndDestroy(query);

    // do not create an index on the Name field

    // as it only slows down the insert/update queries overall

    }

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

// CMPXDbAlbum::CheckTableL

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

//

TBool CMPXDbAbstractAlbum::CheckTableL(

    RSqlDatabase& aDatabase)