/*
* 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:  Implementation of collection DB Plugin interface
*
*/


// INCLUDE FILES
#include <e32cmn.h>
#include <StringLoader.h>
#include <bautils.h>
#include <data_caging_path_literals.hrh>

#include <mpxcmn.h>
#include <mpxuser.h>
#include <mpxcollectionpluginobserver.h>
#include <mpxmediacontainerdefs.h>
#include <mpxmediamusicdefs.h>
#include <mpxmediaaudiodefs.h>
#include <mpxmediacollectiondetaildefs.h>
#include <mpxcommandgeneraldefs.h>
#include <mpxmessagegeneraldefs.h>
#include <mpxmessagecontainerdefs.h>
#include <mpxcollectioncommanddefs.h>
#include <mpxcollectionmessagedefs.h>
#include <mpxincrementalopendefs.h>
#include <mpxcollectionopenlresultdef.h>
#include <mpxmedia.h>
#include <mpxmediaarray.h>
#include <mpxdrmmediautility.h>
#include <mpxmediadrmdefs.h>
#include <mpxlog.h>
#include <mpxcollectiondbhgres.rsg>
#include <mpxdbhgplugin.mbg>
#include <centralrepository.h>

#ifdef RD_MULTIPLE_DRIVE
#include <driveinfo.h>
#endif //RD_MULTIPLE_DRIVE

#include "mpxresource.h"
#include "mpxdbcommondef.h"
#include "mpxdbcommonutil.h"

#include "mpxdbhandler.h"
#include "mpxdbutil.h"
#include "mpxcollectiondbdef.h"
#include "mpxdbplugin.h"

// CONSTANTS
_LIT(KMPlayerDbPluginMbmFile, "mpxdbhgplugin.mif");
const TInt KFirstFetchCount = 400;

const TUid KCRUIDMusicPlayerFeatures = { 0x101FFCD0 };
const TInt KMusicPlayerFeatures = 1;
const TInt KDisablePodcasting = 0x08;

const TInt KIncrementalDeleteCount = 400;

const TInt KSQLErrGeneral = -311; // SQL General error. Don't want to include sql header here
// ============================ MEMBER FUNCTIONS ==============================

// ----------------------------------------------------------------------------
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CMPXDbPlugin* CMPXDbPlugin::NewL(
    TAny* /*aInitParams*/)
    {
    MPX_FUNC("CMPXDbPlugin::NewL");

    CMPXDbPlugin* self = new (ELeave) CMPXDbPlugin();
    CleanupStack::PushL (self);
    self->ConstructL ();
    CleanupStack::Pop (self);
    return self;
    }

// ----------------------------------------------------------------------------
// Destructor.
// ----------------------------------------------------------------------------
//
CMPXDbPlugin::~CMPXDbPlugin()
    {
    MPX_FUNC("CMPXDbPlugin::~CMPXDbPlugin");

    iSelections.Reset();
    iSelections.Close();
    iFs.Close();
    delete iDbHandler;
    delete iDrmMediaUtility;
    if (iResource)
        {
        iResource->Release();
        }
    iMusicLibraryMenuIds.Close();
    delete iMusicLibraryMenuTitles;
    delete iMusicLibraryTitles;
    delete iAllSongsForArtistTitle;
    delete iMusicMenuTitle;

    if (iActiveTask)
        {
        iActiveTask->Cancel();
        delete iActiveTask;
        }
    }

// ----------------------------------------------------------------------------
// Constructor.
// ----------------------------------------------------------------------------
//
CMPXDbPlugin::CMPXDbPlugin()
    {
    MPX_FUNC("CMPXDbPlugin::CMPXDbPlugin");
    }

// ----------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::ConstructL()
    {
    MPX_FUNC("CMPXDbPlugin::ConstructL");
    iFirstDeleteStep = ETrue;
    User::LeaveIfError(iFs.Connect());
    iDrmMediaUtility = CMPXDrmMediaUtility::NewL();

    TParse parse;
    parse.Set( KMPXCollectionDbResourceFile, &KDC_APP_RESOURCE_DIR, NULL );
    TFileName resFile(parse.FullName());
    User::LeaveIfError(MPXUser::CompleteWithDllPath(resFile));
    BaflUtils::NearestLanguageFile(iFs, resFile);
    iResource = CMPXResource::NewL(resFile);

    iDbHandler = CMPXDbHandler::NewL(iFs, *iResource);
    iMusicLibraryMenuTitles = iResource->ReadMenuArrayL(R_MC_MENU_ITEMS_ARRAY, iMusicLibraryMenuIds);
    iMusicLibraryTitles = iResource->ReadMenuArrayL(R_MC_TITLE_ITEMS_ARRAY, iMusicLibraryMenuIds );
    iAllSongsForArtistTitle = iResource->ReadHBufCL(R_MC_ALL_SONGS_FOR_ARTIST);

#ifdef __ENABLE_MUSIC_TEXT_ALIGNMENT
    iMusicMenuTitle = iResource->ReadHBufCL(R_MPX_QTN_MP_TITLE_MY_MUSIC_MENU_NSERIES);
#else
    iMusicMenuTitle = iResource->ReadHBufCL(R_MPX_QTN_MUS_TITLE_MUSIC_MENU);
#endif // __ENABLE_MUSIC_TEXT_ALIGNMENT


    iActiveTask = CMPXDbActiveTask::NewL(*this);

    CRepository* cenrep(NULL);
    TRAPD( err, cenrep = CRepository::NewL( KCRUIDMusicPlayerFeatures ) );
    if( err == KErrNone )
        {
        TInt val(0);
        cenrep->Get( KMusicPlayerFeatures, val );
        iDisablePodcasting = val&KDisablePodcasting ? ETrue:EFalse;
        delete cenrep;
        }
    else
        {
        iDisablePodcasting = EFalse;
        }
    iAllSongsValid = ETrue;
    }

// ----------------------------------------------------------------------------
// Navigates to the given path
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::OpenL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& /*aAttrs*/,
    CMPXFilter* aFilter)
    {
    MPX_FUNC("CMPXDbPlugin::OpenL");
    MPX_DEBUG_PATH(aPath);
    //Create a path object to be returned.
    CMPXCollectionPath* path = CMPXCollectionPath::NewL(aPath);
    CleanupStack::PushL(path);
    RArray<TMPXAttribute> openAttrs;
    CleanupClosePushL(openAttrs);

    RArray<TInt> supportedIds;
    CleanupClosePushL(supportedIds);

    // Replace the attributes requested by the client with the ones below.
    // This will eventually have to be fixed
    SetAttributesL(aPath, openAttrs, supportedIds);

    CMPXMedia* entries = CMPXMedia::NewL(supportedIds.Array());
    CleanupStack::PopAndDestroy(&supportedIds);
    CleanupStack::PushL(entries);
    //Add returned path into media
    entries->SetTObjectValueL<TInt>(KMPXMediaGeneralValue, (TInt)path);

    TInt error(KErrNone);
    TBool isASong(EFalse);
    CMPXCollectionPath* newPath(NULL);

    // Make sure we handle open the correct open mode
    //
    TMPXOpenMode openmode = aPath.OpenNextMode();
    switch (openmode)
        {
        case EMPXOpenGroupOrPlaylist:
            {
            // Open By Path
            MPX_TRAP(error, isASong = DoOpenL(aPath, openAttrs.Array(), *entries, aFilter));
            break;
            }

        case EMPXOpenPlaylistOnly:
            {
            if (aPath.Count() > 0)
                {
                // Try to open
                MPX_TRAP(error, newPath = DoOpenPlaylistL(aPath, openAttrs.Array()));
                CleanupStack::PushL(newPath);
                isASong = ETrue;
                }
            else // no items
                {
                MPX_TRAP(error, isASong = DoOpenL(aPath, openAttrs.Array(), *entries, aFilter));
                }

            break;
            }

        default:
            // do nothing
            break;
        }

    // generate the callback
    if (isASong )
        {
        if (openmode == EMPXOpenGroupOrPlaylist)
            {
            iObs->HandleOpen(const_cast<CMPXCollectionPath*>(&aPath), error);
            }
        else  // openmode == EMPXOpenPlaylistOnly
            {
            iObs->HandleOpen(newPath, error);
            }
        }
    else
        {
        entries->SetCObjectValueL(KMPXMediaGeneralContainerPath,
            const_cast<CMPXCollectionPath*>(&aPath));
        entries->Delete(KMPXMediaGeneralValue);
        iObs->HandleOpen(entries, path, error);
        }

    if (newPath)
        {
        CleanupStack::PopAndDestroy(newPath);
        }

    CleanupStack::PopAndDestroy(entries);
    CleanupStack::PopAndDestroy(&openAttrs);
    CleanupStack::PopAndDestroy(path);
    }

// ----------------------------------------------------------------------------
// Get the extended properties of the current file (async)
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::MediaL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& aAttrs,
    const TArray<TCapability>& /*aCaps*/,
    CMPXAttributeSpecs* /*aSpecs*/)
    {
    MPX_FUNC("CMPXDbPlugin::MediaL");
    MPX_DEBUG_PATH(aPath);

    RArray<TInt> supportedIds;
    CleanupClosePushL(supportedIds);
    if (aPath.Selection().Count())
        {
        // it's a container if there are multiple selection, else it's not a container
        supportedIds.AppendL(KMPXMediaIdContainer);
        }
    MPXDbCommonUtil::FillInSupportedUIDsL(aAttrs, supportedIds);

    CMPXMedia* entries = CMPXMedia::NewL(supportedIds.Array());
    CleanupStack::PopAndDestroy(&supportedIds);
    CleanupStack::PushL(entries);

    DoMediaL(aPath, aAttrs, *entries);

    // Also fetch collection details and set the path if required
    DoHandleOtherMediaAttributesL(aAttrs, aPath, *entries);

    iObs->HandleMedia(entries, KErrNone);
    CleanupStack::PopAndDestroy(entries);
    }

// ----------------------------------------------------------------------------
// Cancel outstanding request
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::CancelRequest()
    {
    MPX_FUNC("CMPXDbPlugin::CancelRequest");
    iActiveTask->Cancel();
    }

// ----------------------------------------------------------------------------
// Executes the given command on the collection
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::CommandL(
    TMPXCollectionCommand aCmd,
    TInt aArg /* = 0 */)
    {
    MPX_FUNC("CMPXDbPlugin::CommandL");
    MPX_DEBUG2("CMPXDbPlugin::CommandL %d", aCmd);
    iAllSongsValid = ETrue;
    switch (aCmd)
        {
        case EMcCmdRemoveAll:
            {
            MPX_DEBUG1("CMPXDbPlugin::CommandL - EMcCmdRemoveAll");
            // Remove EVERYthing from the collection
            iDbHandler->RemoveEntireCollectionL();
            break;
            }
        case EMcCmdClose:
        	  // called before destructing this plug-in: no actions required
        	  break;
        case EMcCloseCollection:
            {
            MPX_DEBUG2("CMPXDbPlugin::CommandL - EMcCloseCollection %d", aArg);
            // Close the specified database
            TRAP_IGNORE(iDbHandler->PreCloseCollectionL());
 #ifdef RD_MULTIPLE_DRIVE
            MPX_DEBUG1("Multiple drives closing databases");
            if ( aArg <0)
                {
                DriveInfo::TDriveArray driveArray;
                User::LeaveIfError ( DriveInfo::GetUserVisibleDrives( iFs, driveArray));
                TInt count( driveArray.Count ());
                for (TInt i=0; i<count; ++i)
                    {
                    MPX_DEBUG2("At drive %i", driveArray[i]);
                    if (( driveArray[i] != EDriveC) && (!iDbHandler->IsRemoteDrive(static_cast<TDriveNumber>(driveArray[i]))))
                        {
                        MPX_DEBUG2("Closing database %i", driveArray[i]);
                        TRAP_IGNORE( iDbHandler->CloseDatabaseL( driveArray[i] ) );
                        }
                    }
                }
            else
                {
                TRAP_IGNORE( iDbHandler->CloseDatabaseL(aArg) ); //Closing can fail if physical media has been removed or forced disk dismount has occurred.
                }
 #else
            iDbHandler->CloseDatabaseL(aArg);
 #endif // RD_MULTIPLE_DRIVE
            break;
            }
        case EMcReOpenCollection:
            {
            MPX_DEBUG1("CMPXDbPlugin::CommandL - EMcReOpenCollection");
            // Open the specified database
#ifdef RD_MULTIPLE_DRIVE
            MPX_DEBUG1("Multiple drives opening databases");
            DriveInfo::TDriveArray driveArray;
            User::LeaveIfError( DriveInfo::GetUserVisibleDrives( iFs, driveArray ) );
            TInt count( driveArray.Count() );
            for( TInt i=0; i<count; ++i )
                {
                MPX_DEBUG2("At drive %i", driveArray[i]);
                if( (driveArray[i] != EDriveC)  && (!iDbHandler->IsRemoteDrive(static_cast<TDriveNumber>(driveArray[i]))))
                    {
                    TUint driveStatus(0);
                    User::LeaveIfError( DriveInfo::GetDriveStatus(
                        iFs, driveArray[i], driveStatus ) );
                    if( driveStatus & DriveInfo::EDrivePresent )
                        {
                        MPX_DEBUG2("Opening database %i", driveArray[i]);
                        TRAP_IGNORE( iDbHandler->OpenDatabaseL( driveArray[i] ) );
                        }
                    }
                }
#else
            iDbHandler->OpenDatabaseL(aArg);
#endif // RD_MULTIPLE_DRIVE
            break;
            }
        case EMcRefreshStarted:
            {
            MPX_DEBUG1("CMPXDbPlugin::CommandL - EMcRefreshStarted");
            iDbHandler->CheckDiskSpaceOnDrivesL();
            // ask the handler to start a transaction
            iDbHandler->RefreshStartL();
            iRefreshing=ETrue;
            break;
            }
        case EMcRefreshEnded:
            {
            MPX_DEBUG1("CMPXDbPlugin::CommandL - EMcRefreshEnded");
            // ask the handler to finalize the transaction
            iDbHandler->RefreshEndL();
            iRefreshing=EFalse;
            break;
            }
         case EMcCmdReCreateDB:
            {
            MPX_DEBUG1("CMPXDbPlugin::CommandL - EMcCmdReCreateDB");
            // Recreate all databases
            iDbHandler->ReCreateDatabasesL();
            break;
            }
         case EMcCmdDbCorrupted:
            {
            MPX_DEBUG1("CMPXDbPlugin::CommandL - EMcCmdDbCorrupted");
            iDbHandler->SetDBCorruptedL(ETrue);
            break;
            }
        case EMcCmdRefresh:
        case EMcCmdCollectionInit:
        case EMcCmdCollectionResyn:
            {
            // deprecated
            break;
            }
        case EMcCmdMtpStart:
            iDbHandler->CheckDiskSpaceOnDrivesL();
            iMtpInUse = ETrue;
            iDbHandler->MtpStartL();
            break;
        case EMcCmdMtpEnd:
            iMtpInUse = EFalse;
            iDbHandler->MtpEndL();
            break;
         default:
            {
            User::Leave(KErrNotSupported);
            }
        }
    }

// ----------------------------------------------------------------------------
// Executes the given command on the collection
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::CommandL(
    CMPXCommand& aCmd)
    {
    MPX_FUNC("CMPXDbPlugin::CommandL");

    if (!aCmd.IsSupported(KMPXCommandGeneralId))
        {
        User::Leave(KErrArgument);
        }

    TMPXCommandId commandId = aCmd.ValueTObjectL<TMPXCommandId>(KMPXCommandGeneralId);

    TBool syncOp(EFalse);
    if (aCmd.IsSupported(KMPXCommandGeneralDoSync))
        {
        syncOp = aCmd.ValueTObjectL<TBool>(KMPXCommandGeneralDoSync);
        }

    // Handle this operation synchronously or asynchronously
    //
    if (!syncOp)
        {
        iActiveTask->StartL(commandId, aCmd);
        }
    else  // Sync operation
        {
        switch (commandId)
            {
            case KMPXCommandIdCollectionRetrieveUriForDeletion:
                {
                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdCollectionRetrieveUriForDeletion");
                DoRetrieveUriForDeletionL(aCmd);
                break;
                }
            case KMPXCommandIdCollectionRemove:
                {
                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdCollectionRemove");
                if ( !iDbHandler->InTransaction() )
                    {
                    iDbHandler->BeginTransactionL();
                    }

                if (iFirstDeleteStep )
                    {
                    iFirstDeleteStep = EFalse;
                    }
                DoRemovePathL(aCmd);
                break;
                }
            case KMPXCommandIdCollectionRemoveMedia:
                {
                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdCollectionRemoveMedia");
                DoRemoveMediaL(aCmd);
                break;
                }
            case KMPXCommandIdCollectionCleanupDeletedMedias:
                {
                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdCollectionCleanupDeletedMedias");
                CleanupDeletedRecordsL(aCmd);
                break;
                }
            case KMPXCommandIdCollectionAdd:
                {
                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdCollectioAdd");
                CMPXMedia* media = aCmd.Value<CMPXMedia>(KMPXCommandColAddMedia);
                User::LeaveIfNull( media );
                TUint32 id(DoAddL(*media));
                aCmd.SetTObjectValueL<TMPXItemId>(KMPXCommandColAddRtnId, id);
                break;
                }
            case KMPXCommandIdCollectionSet:
                {
                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdCollectionSet");
                CMPXMedia* media = aCmd.Value<CMPXMedia>(KMPXCommandColSetMedia);
                User::LeaveIfNull( media );
                DoSetL(*media);
                break;
                }
            case KMPXCommandIdCollectionCompleteDelete:
                {
                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdCollectionCompleteDelete");
                DoHandleDeleteCompleteL(aCmd);
                break;
                }
            case KMPXCommandIdReorderPlaylist:
                {
                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdReorderPlaylist");
                DoReorderPlaylistL(aCmd);
                break;
                }
            case KMPXCommandIdUpdateRefreshTime:
                {
                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdUpdateRefreshTime");
                TTime curTime;
                curTime.HomeTime();
                iDbHandler->SetLastRefreshedTimeL(curTime);
                break;
                }
            case KMPXCommandCollectionGetCount:
                {
                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandCollectionGetCount");
                DoGetCollectionCountL(aCmd);
                break;
                }
            case KMPXCommandCollectionGetURIs:
                {
                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandCollectionGetURIs");
                DoGetCollectionUriL(aCmd);
                break;
                }
            default:
                {
                User::Leave(KErrNotSupported);
                }
            }
        }
    }

// ----------------------------------------------------------------------------
// Adds an item (song or playlist) to the collection
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::AddL(
    const CMPXMedia& aMedia)
    {
    MPX_FUNC("CMPXDbPlugin::AddL");
    DoAddL(aMedia);
    }

// ----------------------------------------------------------------------------
// Remove an item from the collection database using the given path
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::RemoveL(
    const CMPXCollectionPath& aPath)
    {
    MPX_FUNC("CMPXDbPlugin::RemoveL(by path)");
    MPX_DEBUG_PATH(aPath);

    CMPXMessageArray* msgAry = CMPXMessageArray::NewL();
    CleanupStack::PushL(msgAry);

    // Return file path for deleted item(s)
    CDesCArray* fp = DoRemoveL(aPath, *msgAry);

    iObs->HandleRemove(*fp, KErrNone);
    delete fp;

    // Send Change Messages
    iActiveTask->SetVisibleChange(CMPXDbActiveTask::EAllVisible);
    DoHandleChangeL(msgAry);
    CleanupStack::PopAndDestroy(msgAry);
    }

// ----------------------------------------------------------------------------
// Remove an item from the collection database using the given media properties
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::RemoveL(
    const CMPXMedia& aMedia)
    {
    MPX_FUNC("CMPXDbPlugin::RemoveL(by media)");
    DoRemoveL(aMedia, EFalse);
    }

// ----------------------------------------------------------------------------
// Sets/updates the media for an item in the collection
// DEPRECATED for week 18
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::SetL(
    const CMPXMedia& aMedia)
    {
    MPX_FUNC("CMPXDbPlugin::SetL");
    DoSetL(aMedia);
    }

// ----------------------------------------------------------------------------
// Find the items matching the media specifications
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::FindAllL(
    const CMPXMedia& aCriteria,
    const TArray<TMPXAttribute>& aAttrs)
    {
    MPX_FUNC("CMPXDbPlugin::FindAllL");

    CMPXMedia* entries = FindAllSyncL(aCriteria, aAttrs);

    // notify client. if FindAllL leaves, framework will notify client of the error
    iObs->HandleFindAll(entries, KErrNone);
    delete entries;
    }

// ----------------------------------------------------------------------------
// Find the items matching the media specifications
// ----------------------------------------------------------------------------
//
CMPXMedia* CMPXDbPlugin::FindAllSyncL(
    const CMPXMedia& aCriteria,
    const TArray<TMPXAttribute>& aAttrs)
    {
    MPX_FUNC("CMPXDbPlugin::FindAllSyncL");

    CMPXMedia* entries = iDbHandler->FindAllLC(aCriteria, aAttrs);

    if (entries)
        {
        CMPXMediaArray* ary = entries->Value<CMPXMediaArray>(KMPXMediaArrayContents);
        User::LeaveIfNull( ary );
        DoSetDrmForArrayL( *ary, aAttrs );
        }

    CleanupStack::Pop(entries);
    return entries;
    }

// ----------------------------------------------------------------------------
// Get the list of supported capabilities
// ----------------------------------------------------------------------------
//
TCollectionCapability CMPXDbPlugin::GetCapabilities()
    {
    // This one supports simple search
    return EMcSearch;
    }

// ----------------------------------------------------------------------------
// Get the list of supported capabilities
// ----------------------------------------------------------------------------
//
TBool CMPXDbPlugin::HandleStepL()
    {
    MPX_FUNC("CMPXDbPlugin::HandleStepL");

    TBool done(ETrue);

    switch (iActiveTask->GetTask())
        {
        case KMPXCommandIdCollectionSet:
            {
            done = DoSetAsyncL();
            break;
            }
        case KMPXCommandIdCollectionAdd:
            {
            done = DoAddAsyncL();
            break;
            }
        case KMPXCommandIdCollectionRemove:
            {
            DoRemovePathL(iActiveTask->GetCommand());
            done = ETrue;
            break;
            }
        case KMPXCommandIdCollectionRemoveMedia:
            {
            DoRemoveMediaL(iActiveTask->GetCommand());
            done = ETrue;
            break;
            }
        case KMPXCommandIdCollectionRetrieveUriForDeletion:
            {
            DoRetrieveUriForDeletionL(iActiveTask->GetCommand());
            done = ETrue;
            break;
            }
        case KMPXCommandIdCollectionCleanupDeletedMedias:
            {
            CleanupDeletedRecordsL(iActiveTask->GetCommand());
            done = ETrue;
            break;
            }
        case KMPXCommandIdCollectionCompleteDelete:
            {
            DoHandleDeleteCompleteL( iActiveTask->GetCommand() );
            break;
            }
        case KMPXCommandIdUpdateRefreshTime:
            {
            MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdUpdateRefreshTime");
            TTime curTime;
            curTime.HomeTime();
            iDbHandler->SetLastRefreshedTimeL(curTime);
            break;
            }
        case KMPXCommandIdIncrementalOpenL:
            {
            DoIncrementalOpenL( iActiveTask->GetCommand() );
            done = ETrue;
            break;
            }
        default:
            {
            // Should never happen!
            ASSERT(0);
            break;
            }
        }
    return done;
    }

// ----------------------------------------------------------------------------
// Handler for async operations completed
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::HandleOperationCompleted(
    TInt aErr)
    {
    MPX_FUNC("CMPXDbPlugin::HandleOperationCompleted");
    TRAP_IGNORE(DoHandleOperationCompletedL(aErr));
    }

// ----------------------------------------------------------------------------
// Process the OpenL command
// ----------------------------------------------------------------------------
//
TBool CMPXDbPlugin::DoOpenL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& aAttrs,
    CMPXMedia& aEntries,
    CMPXFilter* aFilter )
    {
    MPX_FUNC("CMPXDbPlugin::DoOpenL");

    TInt err( KErrNone );
    CMPXMediaArray* array = CMPXMediaArray::NewL();
    CleanupStack::PushL(array);

    TInt levels(aPath.Levels());
    TBool isASong(EFalse);


	if ( 1 == levels )
	    {

	    // Redirecting all open requests at level 1 to open albums 
	    // due to UI changes that removed the library menu collection level.
        TInt acount = array->Count();
        MPX_DEBUG2(" array count11 [%d]", acount);
        
 		CMPXCollectionPath* path = CMPXCollectionPath::NewL(aPath);
		CleanupStack::PushL( path );
		
		path->AppendL(3); // Albums
		TInt whatLevel = path->Levels();

		MPX_DEBUG_PATH(*path);
		
		aEntries.SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, path->Id(whatLevel - 1) );
		
      // Create a media which hold the pointer to the returned path
        if (aEntries.IsSupported(KMPXMediaGeneralValue))
            {
            MPX_DEBUG1(" pointer to the returned path ");
            CMPXMedia* pMedia = CMPXMedia::NewL();
            CleanupStack::PushL(pMedia);
            pMedia->SetTObjectValueL<TInt>(KMPXMediaGeneralValue,
                                          aEntries.ValueTObjectL<TInt>(KMPXMediaGeneralValue));
            array->AppendL(*pMedia);
            CleanupStack::PopAndDestroy(pMedia);
            }
		
	
        RArray<TMPXAttribute> openAttrs;
        CleanupClosePushL(openAttrs);

        RArray<TInt> supportedIds;
        CleanupClosePushL(supportedIds);

        SetAttributesL(*path, openAttrs, supportedIds);
        openAttrs.AppendL(KMPXMediaArrayContents);
        
        CleanupStack::PopAndDestroy(&supportedIds);
		
		if( iAllSongsValid )
		    {
		    isASong = DoOpenBrowseAlbumL( *path, openAttrs.Array(), aEntries, array );
		    }
		CleanupStack::PopAndDestroy(&openAttrs);
		CleanupStack::PopAndDestroy( path );

        //Remove the first media
        if ( array->Count() &&
            (*array)[0]->IsSupported(KMPXMediaGeneralValue))
            {
            array->Remove(0);
            }
	    }
    else if (levels >= 2)
        {
	    aEntries.SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, aPath.Id(levels - 1));
        // Create a media which hold the pointer to the returned path
        if (aEntries.IsSupported(KMPXMediaGeneralValue))
            {
            CMPXMedia* pMedia = CMPXMedia::NewL();
            CleanupStack::PushL(pMedia);
            pMedia->SetTObjectValueL<TInt>(KMPXMediaGeneralValue,
                                          aEntries.ValueTObjectL<TInt>(KMPXMediaGeneralValue));
            array->AppendL(*pMedia);
            CleanupStack::PopAndDestroy(pMedia);
            MPX_ASSERT(array->Count()==1);
            }

        // check the browse type
        switch (aPath.Id(1).iId2)
            {
            case EBrowseAll:
                {
                TBool doIncremental(ETrue);
                if( aFilter && aFilter->IsSupported( KMPXCollectionOpenLSupportsIncremental ) )
                    {
                    doIncremental =
                         aFilter->ValueTObjectL<TBool>(KMPXCollectionOpenLSupportsIncremental);
                    }

                if( doIncremental )
                    {
                    TRAP( err, isASong = DoOpenIncrementalL( aPath, aAttrs, aEntries, array ) );
                    }
                else
                    {
                    TRAP( err, isASong = DoOpenBrowseAllL(aPath, aAttrs, aEntries, array) );
                    }
                break;
                }

            case EBrowseArtist:
                {
                if( iAllSongsValid )
                    {
                    isASong = DoOpenBrowseArtistL( aPath, aAttrs, aEntries, array );
                    }
                break;
                }

            case EBrowseAlbum:
                {
                if( iAllSongsValid )
                    {
                    isASong = DoOpenBrowseAlbumL( aPath, aAttrs, aEntries, array );
                    }
                break;
                }

            case EBrowsePlaylist:
                {
                if( iAllSongsValid )
                    {
                    isASong = DoOpenBrowsePlaylistL(aPath, aAttrs, aEntries, array);
                    }

                break;
                }

            case EBrowseGenre:
                {
                if( iAllSongsValid )
                    {
                    isASong = DoOpenBrowseGenreL( aPath, aAttrs, aEntries, array );
                    }
                break;
                }

            case EBrowseComposer:
                {
                if( iAllSongsValid )
                    {
                    isASong = DoOpenBrowseComposerL( aPath, aAttrs, aEntries, array );
                    }
                break;
                }

            default:
                {
                User::Leave(KErrArgument);
                }
            }
        //Remove the first media
        if ( array->Count() &&
            (*array)[0]->IsSupported(KMPXMediaGeneralValue))
            {
            array->Remove(0);
            }
        }
    else
        {
        User::Leave(KErrNotSupported);
        }
    aEntries.SetCObjectValueL(KMPXMediaArrayContents, array);
    aEntries.SetTObjectValueL<TInt>(KMPXMediaArrayCount, array->Count());

    CleanupStack::PopAndDestroy(array);

    if( err == KSQLErrGeneral )
        {
        iAllSongsValid = EFalse;
        User::Leave( KErrDiskFull );
        }
    else if( err != KErrNone )
        {
        User::Leave( err );
        }
    return isASong;
    }


// ----------------------------------------------------------------------------
// CMPXDbPlugin::DoOpenIncrementalL
// ----------------------------------------------------------------------------
//
TBool CMPXDbPlugin::DoOpenIncrementalL( const CMPXCollectionPath& aPath,  const TArray<TMPXAttribute>& aAttrs,
                                       CMPXMedia& aEntries, CMPXMediaArray* aArray)
    {
    TBool isASong(EFalse);

    TInt levels(aPath.Levels());

    if( levels == 2 )
        {
        // Remove the pPath dummy from the array
        TInt pPath = aEntries.ValueTObjectL<TInt>(KMPXMediaGeneralValue);
        aArray->Remove(0);
        CMPXCollectionPath* p = (CMPXCollectionPath*) pPath;

        RArray<TMPXItemId> ids;
        CleanupClosePushL( ids );

        iDbHandler->GetAllSongsLimitedL( aAttrs, *aArray, KFirstFetchCount );

        TInt c( aArray->Count() );
        for( TInt i=0; i<c; ++i )
            {
            TMPXItemId id = aArray->AtL(i)->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );
            ids.Append( id );
            }

        // Rest are all blank items
        CMPXMedia* entry = CMPXMedia::NewL();
        CleanupStack::PushL(entry);
        entry->SetTObjectValueL<TMPXGeneralType>(KMPXMediaGeneralType, EMPXItem);
        entry->SetTObjectValueL<TMPXGeneralCategory>(KMPXMediaGeneralCategory, EMPXSong);
        entry->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, KMPXInvalidItemId );

        TInt count = iDbHandler->NumberOfItemsL(EMPXSong);
        count-=c;
        for( TInt i=0; i<count; ++i )
            {
            aArray->AppendL( *entry );
            ids.Append( KMPXInvalidItemId );
            }
        CleanupStack::PopAndDestroy( entry );

        // Set the "Supportes incremental Command" flag
        //
        aEntries.SetTObjectValueL( KMPXCollectionOpenLSupportsIncremental, ETrue );

        TMPXOpenDataBlock block;
        block.iOffset=KErrNotFound;
        block.iSize=count;
        aEntries.SetTObjectValueL<TMPXOpenDataBlock>( KMPXCollectionOpenLResultRange, block );

        SetMediaGeneralAttributesL(aEntries, EMPXGroup, EMPXSong,
                iMusicLibraryTitles->MdcaPoint(EBrowseAll));

        p->AppendL(ids.Array());
        CleanupStack::PopAndDestroy( &ids );
        }
    else if( levels == 3 )
        {
        iDbHandler->GetSongL(aPath.Id(levels - 1).iId2, aAttrs, *aArray);
        isASong = ETrue;
        }


    return isASong;
    }

// ----------------------------------------------------------------------------
// Handles OpenL called for EBrowseAll
// ----------------------------------------------------------------------------
//
TBool CMPXDbPlugin::DoOpenBrowseAllL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& aAttrs,
    CMPXMedia& aEntries,
    CMPXMediaArray* aArray)
    {
    MPX_FUNC("CMPXDbPlugin::DoOpenBrowseAllL");

    TInt levels(aPath.Levels());
    switch (levels)
       {
       // All songs
       case 2:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseAllL_All);

            iDbHandler->GetAllSongsL(aArray, aAttrs);
            SetMediaGeneralAttributesL(aEntries, EMPXGroup, EMPXSong,
                iMusicLibraryTitles->MdcaPoint(EBrowseAll));

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseAllL_All);
            break;
            }

         // A Song in all songs
         case 3:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseAllL_Song);

            iDbHandler->GetSongL(aPath.Id(levels - 1).iId2, aAttrs, *aArray);

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseAllL_Song);
            break;
            }

         default:
            {
            MPX_DEBUG2("CMPXDbPlugin_DoOpenBrowseAllL: Invalid levels[%d]", levels);
            User::Leave(KErrNotSupported);
            }
        } // end switch(levels)

    return (levels == 3);
    }

// ----------------------------------------------------------------------------
// Handles OpenL called for EBrowseArtist
// ----------------------------------------------------------------------------
//
TBool CMPXDbPlugin::DoOpenBrowseArtistL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& aAttrs,
    CMPXMedia& aEntries,
    CMPXMediaArray* aArray)
    {
    MPX_FUNC("CMPXDbPlugin::DoOpenBrowseArtistL");

    TBool isASong(EFalse);
    TInt levels(aPath.Levels());
    TInt idIndex(levels - 1);

    RArray<TMPXItemId> selections;
    CleanupClosePushL(selections);
    aPath.SelectionL(selections);

    switch (levels)
        {
        // All artists
        case 2:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseArtistL_All);

            iDbHandler->GetAllArtistsL(aAttrs, aArray);
            SetMediaGeneralAttributesL(aEntries, EMPXGroup, EMPXArtist,
                iMusicLibraryTitles->MdcaPoint(EBrowseArtist));

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseArtistL_All);
            break;
            }

        // All albums of an artist
        case 3:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseArtistL_AllAlbums);
            // get the albums
            TInt id(aPath.Id(idIndex).iId2);
            MPX_ASSERT(aArray->Count());
            MPX_ASSERT((*aArray)[0]->IsSupported(KMPXMediaGeneralValue));
            TInt pPath = (*aArray)[0]->ValueTObjectL<TInt>(KMPXMediaGeneralValue);
            MPX_ASSERT(pPath);
            iDbHandler->GetAlbumsMatchingArtistL(id, aAttrs, *aArray);
            SetMediaGeneralAttributesL(aEntries, EMPXItem, EMPXArtist, id);

            TInt count = aArray->Count();
            if ( count > 2 )
                {
                // Only show "all" item if there is more than 1 album
                // count for "all" item
                TInt total = 0;
                for ( TInt i = 1; i < count; i++ )
                {
                TInt temp = (*aArray)[i]->ValueTObjectL<TInt>(KMPXMediaGeneralCount);
                total += temp;
                }
            // Add "all" item under an artist
            MPXDbCommonUtil::PrependMediaL(*aArray, *iAllSongsForArtistTitle, EMPXItem, EMPXAlbum,
                aPath.Id(idIndex), 0, 0, 1);

                (*aArray)[1]->SetTObjectValueL<TInt>(KMPXMediaGeneralCount, total);

            TMPXItemId allId = ((*aArray)[1]->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));
            if (aArray->Count() > 2)
                { // path media, all id  and at least one media
                ((CMPXCollectionPath*)pPath)->InsertL(allId, 0);
                }
            else
                { // only has all item
                ((CMPXCollectionPath*)pPath)->AppendL(allId);
                    }
                }

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseArtistL_AllAlbums);
            break;
            }

        // All songs of an album for an artist or all songs for an artist
        case 4:
            {
            // all songs for an artist
            if (aPath.Id(3) == aPath.Id(2))
                {
                MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseArtistL_AllSongs);

                TInt id(aPath.Id(idIndex - 1).iId2);
                iDbHandler->GetSongsMatchingArtistL(id, aAttrs, aArray);
                SetMediaGeneralAttributesL(aEntries, EMPXItem, EMPXSong, id);

                MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseArtistL_AllSongs);
                }
            // all songs of an album for an artist
            else
                {
                MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseArtistL_AllSongsForAlbum);
                TUint32 artistId(aPath.Id(idIndex - 1).iId2);

                if (selections.Count())
                    {
                    // Multiple albums
                    const TInt count(aPath.Selection().Count());
                    for (TInt i = 0; i < count; ++i)
                        {
                        iDbHandler->GetSongsMatchingArtistAndAlbumL(artistId, selections[i].iId2,
                            aAttrs, aArray);
                        }
                    }
                else
                    {
                    // One album
                    iDbHandler->GetSongsMatchingArtistAndAlbumL(artistId, aPath.Id(idIndex).iId2,
                        aAttrs, aArray);
                    }

                SetMediaGeneralAttributesL(aEntries, EMPXItem, EMPXAlbum, aPath.Id(idIndex).iId2);
                MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseArtistL_AllSongsForAlbum);
                }

            MPX_DEBUG2("CMPXDbPlugin_DoOpenBrowseArtistL: retrieved %d items", aArray->Count());

            break;
            }

        // A Song in an album
        case 5:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseArtistL_Song);

            iDbHandler->GetSongL(aPath.Id(idIndex).iId2, aAttrs, *aArray);
            isASong = ETrue;

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseArtistL_Song);
            break;
            }

        default:
            {
            MPX_DEBUG2("CMPXDbPlugin_DoOpenBrowseArtistL: Invalid levels[%d]", levels);
            User::Leave(KErrNotSupported);
            }
        } // end switch(level)

    CleanupStack::PopAndDestroy(&selections);
    return isASong;
    }

// ----------------------------------------------------------------------------
// Handles OpenL called for EBrowseAlbum
// ----------------------------------------------------------------------------
//
TBool CMPXDbPlugin::DoOpenBrowseAlbumL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& aAttrs,
    CMPXMedia& aEntries,
    CMPXMediaArray* aArray)
    {
    MPX_FUNC("CMPXDbPlugin::DoOpenBrowseAlbumL");

    TBool isASong(EFalse);
    TInt levels(aPath.Levels());
    TInt idIndex(levels - 1);

    RArray<TMPXItemId> selections;
    CleanupClosePushL(selections);
    aPath.SelectionL(selections);

    switch (levels)
        {
        // All Albums
        case 2:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseAlbumL_All);

            TRAPD(err, iDbHandler->GetAllAlbumsL(aAttrs, aArray) );
            // in error case, return empty list and append empty id to path 
            // in order to increase one level 
            if ( err != KErrNone )
                {
                TInt pPath(0);
                if (aArray->Count())
                    {
                    CMPXMedia* pMedia = (*aArray)[0];
                    if (pMedia->IsSupported(KMPXMediaGeneralValue))
                        {
                        pPath = pMedia->ValueTObjectL<TInt>(KMPXMediaGeneralValue);
                        MPX_ASSERT(pPath);
                        }                   
                    }

                RArray<TMPXItemId> ids;
                CleanupClosePushL(ids);
            
                // Append ids to the returned path
                if (pPath)
                    {
                    ((CMPXCollectionPath*)pPath)->AppendL(ids.Array());
                    }
                CleanupStack::PopAndDestroy(&ids);
                }
            
            SetMediaGeneralAttributesL(aEntries, EMPXGroup, EMPXAlbum,
                iMusicLibraryTitles->MdcaPoint(EBrowseAlbum));

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseAlbumL_All);
            break;
            }

        // All songs in one or multiple albums
        case 3:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseAlbumL_AllSongs);
            if (selections.Count())
                {
                // Multiple albums
                const TInt count(aPath.Selection().Count());
                for (TInt i = 0; i < count; ++i)
                    {
                    iDbHandler->GetSongsMatchingAlbumL(selections[i].iId2, aAttrs, aArray);
                    }
                }
            else
                {
                // One album
                iDbHandler->GetSongsMatchingAlbumL(aPath.Id(idIndex).iId2, aAttrs, aArray);
                }

				// added for ganes
                SetMediaGeneralAttributesL(aEntries, EMPXItem, EMPXAlbum, iMusicLibraryTitles->MdcaPoint(EBrowseAlbumSong));

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseAlbumL_AllSongs);
            break;
            }

        // A song in an album
        case 4:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseAlbumL_Song);

            iDbHandler->GetSongL(aPath.Id(idIndex).iId2, aAttrs, *aArray);
            isASong = ETrue;

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseAlbumL_Song);
            break;
            }

        default:
            {
            MPX_DEBUG2("CMPXDbPlugin_DoOpenBrowseAlbumL: Invalid levels[%d]", levels);
            User::Leave(KErrNotSupported);
            }
        }

    CleanupStack::PopAndDestroy(&selections);
    return isASong;
    }

// ----------------------------------------------------------------------------
// Handles OpenL called for EBrowsePlaylist
// ----------------------------------------------------------------------------
//
TBool CMPXDbPlugin::DoOpenBrowsePlaylistL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& aAttrs,
    CMPXMedia& aEntries,
    CMPXMediaArray* aArray)
    {
    MPX_FUNC("CMPXDbPlugin::DoOpenBrowsePlaylistL");

    TBool isASong(EFalse);
    TInt levels(aPath.Levels());
    TInt idIndex(levels - 1);

    RArray<TMPXItemId> selections;
    CleanupClosePushL(selections);
    aPath.SelectionL(selections);

    switch (levels)
         {
         case 2:
            {
            // All playlists
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowsePlaylistL_All);

            iDbHandler->GetAllPlaylistsL(aArray, aAttrs);
            iDbHandler->GetAllSystemPlaylistNamesL(aArray);

            SetMediaGeneralAttributesL(aEntries, EMPXGroup, EMPXPlaylist,
                iMusicLibraryTitles->MdcaPoint(EBrowsePlaylist));

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowsePlaylistL_All);
            break;
            }

         // All songs in a playlist
         case 3:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowsePlaylistL_AllSongs);

            if (selections.Count())
                {
                const TInt count(aPath.Selection().Count());
                for (TInt i = 0; i < count; ++i)
                    {
                    iDbHandler->GetSongsMatchingPlaylistL(selections[i].iId2, aAttrs, aArray);
                    }
                }
            else
                {
                iDbHandler->GetSongsMatchingPlaylistL(aPath.Id (idIndex).iId2, aAttrs, aArray);
                }


            SetMediaGeneralAttributesL(aEntries, EMPXItem, EMPXPlaylist, aPath.Id(idIndex).iId2);

            // populate EMPXMediaGeneralNonPermissibleActions
            if (iDbHandler->IsAutoPlaylistL(aPath.Id(idIndex).iId2))
                {
                // set non-permissible actions to not writable and cacheable
                aEntries.SetTObjectValueL<TMPXGeneralNonPermissibleActions>(
                    KMPXMediaGeneralNonPermissibleActions, (TMPXGeneralNonPermissibleActions)(EMPXWrite | EMPXCache));
                }

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowsePlaylistL_AllSongs);
            break;
            }

         // Specific song in a playlist
         case 4:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowsePlaylistL_Song);

            iDbHandler->GetPlaylistSongL(aPath.Id(idIndex).iId2, aPath.Id(idIndex - 1).iId2,
                aAttrs, *aArray);
            isASong = ETrue;

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowsePlaylistL_Song);
            break;
            }

         default:
            {
            MPX_DEBUG2("CMPXDbPlugin_DoOpenBrowsePlaylistL: Invalid levels[%d]", levels);
            User::Leave(KErrNotSupported);
            }
       }

    CleanupStack::PopAndDestroy(&selections);
    return isASong;
    }

// ----------------------------------------------------------------------------
// Handles OpenL called for EBrowseGenre
// ----------------------------------------------------------------------------
//
TBool CMPXDbPlugin::DoOpenBrowseGenreL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& aAttrs,
    CMPXMedia& aEntries,
    CMPXMediaArray* aArray)
    {
    MPX_FUNC("CMPXDbPlugin::DoOpenBrowseGenreL");

    TBool isASong(EFalse);
    TInt levels(aPath.Levels());
    TInt idIndex(levels - 1);

    RArray<TMPXItemId> selections;
    CleanupClosePushL(selections);
    aPath.SelectionL(selections);

    switch (levels)
        {
        // All genres
         case 2:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseGenreL_All);

            iDbHandler->GetAllGenresL(aAttrs, aArray);
            SetMediaGeneralAttributesL(aEntries, EMPXGroup, EMPXGenre,
                iMusicLibraryTitles->MdcaPoint(EBrowseGenre));

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseGenreL_All);
            break;
            }

        // All songs of a genre
        case 3:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseGenreL_AllSongs);

            if (selections.Count())
                {
                const TInt count(aPath.Selection().Count());
                for (TInt i = 0; i < count; ++i)
                    {
                    iDbHandler->GetSongsMatchingGenreL(selections[i].iId2, aAttrs, aArray);
                    }
                }
            else
                {
                iDbHandler->GetSongsMatchingGenreL(aPath.Id(idIndex).iId2, aAttrs, aArray);
                }
            SetMediaGeneralAttributesL(aEntries, EMPXItem, EMPXGenre, aPath.Id(idIndex).iId2);

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseGenreL_AllSongs);
            break;
            }

        // Specific song in a genre
        case 4:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseGenreL_Song);

            iDbHandler->GetSongL(aPath.Id(idIndex).iId2, aAttrs, *aArray);
            isASong = ETrue;

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseGenreL_Song);
            break;
            }

        default:
            {
            MPX_DEBUG2("CMPXDbPlugin_DoOpenBrowseGenreL: Invalid levels[%d]", levels);
            User::Leave(KErrNotSupported);
            }
        }

    CleanupStack::PopAndDestroy(&selections);
    return isASong;
    }

// ----------------------------------------------------------------------------
// Handles OpenL called for EBrowseComposer
// ----------------------------------------------------------------------------
//
TBool CMPXDbPlugin::DoOpenBrowseComposerL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& aAttrs,
    CMPXMedia& aEntries,
    CMPXMediaArray* aArray)
    {
    MPX_FUNC("CMPXDbPlugin::DoOpenBrowseComposerL");

    TBool isASong(EFalse);
    TInt levels(aPath.Levels());
    TInt idIndex(levels - 1);

    RArray<TMPXItemId> selections;
    CleanupClosePushL(selections);
    aPath.SelectionL(selections);

    switch (levels)
        {
        // All composers
        case 2:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseComposerL_All);

            iDbHandler->GetAllComposersL(aAttrs, aArray);
            SetMediaGeneralAttributesL(aEntries, EMPXGroup, EMPXComposer,
                iMusicLibraryTitles->MdcaPoint(EBrowseComposer));

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseComposerL_All);
            break;
            }

        // All songs of a composer
        case 3:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseComposerL_AllSongs);
            if (selections.Count())
                {
                const TInt count(aPath.Selection().Count());
                for (TInt i = 0; i < count; ++i)
                    {
                    iDbHandler->GetSongsMatchingComposerL(selections[i].iId2, aAttrs, aArray);
                    }
                }
            else
                {
                iDbHandler->GetSongsMatchingComposerL(aPath.Id(idIndex).iId2, aAttrs, aArray);
                }
            SetMediaGeneralAttributesL(aEntries, EMPXItem, EMPXComposer, aPath.Id(idIndex).iId2);

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseComposerL_AllSongs);
            break;
            }

        // Specific song of a composer
        case 4:
            {
            MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseComposerL_Song);

            iDbHandler->GetSongL(aPath.Id(idIndex).iId2, aAttrs, *aArray);
            isASong = ETrue;

            MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseComposerL_Song);
            break;
            }

        default:
            {
            MPX_DEBUG2("CMPXDbPlugin_DoOpenBrowseComposerL: Invalid levels[%d]", levels);
            User::Leave(KErrNotSupported);
            }
        }

    CleanupStack::PopAndDestroy(&selections);
    return isASong;
    }

// ----------------------------------------------------------------------------
// Process the OpenL method with open mode EMPXOpenPlaylistOnly
// ----------------------------------------------------------------------------
//
CMPXCollectionPath* CMPXDbPlugin::DoOpenPlaylistL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& aAttrs )
    {
    MPX_FUNC("CMPXDbPlugin::DoOpenPlaylistL");

    RArray<TMPXItemId> ids;
    CleanupClosePushL(ids);

    CMPXMedia* entries = CMPXMedia::NewL();
    CleanupStack::PushL(entries);

    CMPXCollectionPath* path = CMPXCollectionPath::NewL(aPath);
    CleanupStack::PushL(path);

    // Go through the browse path
    TInt levels(aPath.Levels());
    if (levels == 2)
        {
        // Create a new collection path
        CleanupStack::PopAndDestroy( path );
        path = CMPXCollectionPath::NewL();
        CleanupStack::PushL( path );

        // Always return all songs here
        ids.Reset();
        ids.AppendL( KDBPluginUid );
        path->AppendL(ids.Array());
        path->SelectL((TMPXItemId) KDBPluginUid);

        ids.Reset();
        ids.AppendL(EBrowseAll);
        path->AppendL(ids.Array());
        path->SelectL((TMPXItemId) EBrowseAll);
        path->Set(EMPXOpenPlaylistOnly);

        // Get all item IDs
        CMPXMediaArray* array = CMPXMediaArray::NewL();
        CleanupStack::PushL(array);

        DoOpenBrowseAllL(*path, aAttrs, *entries, array);

        entries->SetCObjectValueL(KMPXMediaArrayContents, array);
        entries->SetTObjectValueL<TInt>(KMPXMediaArrayCount, array->Count());

        CleanupStack::PopAndDestroy(array);

        DoAppendLevelL(*path, *entries);
        }
    else if (levels > 2)
        {
        switch (aPath.Id(1).iId2)
            {
            case EBrowseAll:
                {
                path->Set(EMPXOpenPlaylistOnly);
                // Returns the same path that we copied
                break;
                }
            case EBrowseArtist:
                {
                if (levels == 3)
                    {
                    // return all songs of a particular artist (currently highlighted)
                    path->Set(EMPXOpenGroupOrPlaylist);
                    ids.Reset();
                    ids.Append(aPath.Id(2));
                    path->AppendL(ids.Array());
                    path->SelectL(aPath.Id(2));
                    path->Set(EMPXOpenPlaylistOnly);

                    // Opens all songs of an artist and create the corresponding
                    // Collection playlist by appending all songs of an artist to
                    // the collection path
                    //
                    DoOpenL(*path, aAttrs, *entries, NULL);
                    DoAppendLevelL(*path, *entries);
                    }
                else if (levels == 4)
                    {
                    // Open the album of an artist and create the corresponding
                    // Collection playlist by appending all songs of an artist to
                    // the collection path
                    //
                    path->Set(EMPXOpenPlaylistOnly);
                    DoOpenL(*path, aAttrs, *entries, NULL);
                    DoAppendLevelL(*path, *entries);
                    }
                else
                    {
                    // case is a song no need to open again!
                    }

                break;
                }
            // Playlist, album, genre and composer easier, only 2 levels deep
            // plugin | category | category contents | songs of category
            //
            case EBrowsePlaylist:
            case EBrowseAlbum:
            case EBrowseGenre:
            case EBrowseComposer:
                {
                if (!DoOpenL(aPath, aAttrs, *entries, NULL))
                    {
                    // If it is not at a song level
                    // Append all entries to create collection path
                    //
                    path->Set(EMPXOpenPlaylistOnly);
                    DoAppendLevelL( *path, *entries );
                    }
                break;
                }
            default:
                {
                User::Leave(KErrNotSupported);
                }
            }
        }
    else  // levels < 2
        {
        User::Leave(KErrNotSupported);
        }

    // Cleanup
    CleanupStack::Pop(path);
    CleanupStack::PopAndDestroy(entries);
    CleanupStack::PopAndDestroy(&ids);

    return path;
    }

// ----------------------------------------------------------------------------
// Process the MediaL command
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoMediaL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& aAttrs,
    CMPXMedia& aEntries)
    {
    MPX_FUNC("CMPXDbPlugin::DoMediaL");

    // Fetch Media for root level
    //
    if (aPath.Levels() == 1) //root
        {
        DoRootMediaL( aAttrs, aEntries );
        }
    // Ensure the database has been merged before attempting MediaL()
    //
    else
        {
        CMPXMediaArray* array = CMPXMediaArray::NewL();
        CleanupStack::PushL(array);

        switch (aPath.Id(1).iId2)
            {
            case EBrowseAll:
                {
                DoAllSongsMediaL(aPath, aAttrs, aEntries, *array);
                break;
                } // end case EBrowseAll

            case EBrowseArtist:
                {
                DoArtistMediaL(aPath, aAttrs, aEntries, *array);
                break;
                } // end case EBrowseArtist

            case EBrowseAlbum:
                {
                DoCategoryMediaL(aPath, aAttrs, EMPXAlbum, aEntries, *array);
                break;
                } // end case EBrowseAlbum

            case EBrowsePlaylist:
                {
                DoCategoryMediaL(aPath, aAttrs, EMPXPlaylist, aEntries, *array);
                break;
                } // end case EBrowsePlaylist

            case EBrowseGenre:
                {
                DoCategoryMediaL(aPath, aAttrs, EMPXGenre, aEntries, *array);
                break;
                } // end case EBrowseGenre

            case EBrowseComposer:
                {
                DoCategoryMediaL(aPath, aAttrs, EMPXComposer, aEntries, *array);
                break;
                } // end case EBrowseComposer
#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
            case EBrowsePodcasts:
                {
                break;
                }
#endif
            default:
                {
                User::Leave(KErrArgument);
                }
            } // end switch(aPath.id(1)

        if (array->Count() > 0)
            {
            aEntries.SetCObjectValueL(KMPXMediaArrayContents, array);
            aEntries.SetTObjectValueL<TInt>(KMPXMediaArrayCount, array->Count());
            }
        CleanupStack::PopAndDestroy(array);
        }
    // Else case cannot leave, because this will happen when we have no disk space to
    // perform the merging. It should NOT leave.
    //
    }

// ----------------------------------------------------------------------------
// Find the collection media for root level
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoRootMediaL(
    const TArray<TMPXAttribute>& aAttrs,
    CMPXMedia& aMedia )
    {
    MPX_FUNC("CMPXDbPlugin::DoRootMediaL");

    TInt count(aAttrs.Count());
#ifndef __ENABLE_PODCAST_IN_MUSIC_MENU
    aMedia.SetTObjectValueL<TMPXGeneralNonPermissibleActions> (
            KMPXMediaGeneralNonPermissibleActions, (TMPXGeneralNonPermissibleActions)(EMPXWrite | EMPXCache) );
#endif // __ENABLE_PODCAST_IN_MUSIC_MENU
    for (TInt i = 0; i < count; ++i)
        {
        if (aAttrs[i].ContentId() == KMPXMediaIdGeneral)
            {
            TUint att(aAttrs[i].AttributeId());
            if (att & EMPXMediaGeneralTitle)
                {
                HBufC* title(iResource->ReadHBufCL(R_MPX_QTN_MUS_MUSIC));
                CleanupStack::PushL(title);
                aMedia.SetTextValueL(KMPXMediaGeneralTitle, *title);
                CleanupStack::PopAndDestroy(title);
                }
            if (att & EMPXMediaGeneralSubTitle)
                {
                TInt numSongs(iDbHandler->NumberOfItemsL(EMPXSong));
                aMedia.SetTObjectValueL<TInt>(KMPXMediaGeneralCount, numSongs);

                HBufC* text(iResource->ReadHBufCL((1 == numSongs) ?
                    R_MPX_QTN_MUS_MUSIC_ONE_SONG : R_MPX_QTN_MUS_MUSIC_NUM_SONGS));

                CleanupStack::PushL(text);
                aMedia.SetTextValueL(KMPXMediaGeneralSubTitle, *text);
                CleanupStack::PopAndDestroy(text);
                }
            if (att & EMPXMediaGeneralIcon)
                {
                TIconInfo icon;
                icon.bmpfile = KMPlayerDbPluginMbmFile;
                icon.bitmapId = EMbmMpxdbhgpluginQgn_graf_mup_dlst_music;
                icon.maskId = EMbmMpxdbhgpluginQgn_graf_mup_dlst_music_mask;
                aMedia.SetTObjectValueL<TIconInfo>(KMPXMediaGeneralIcon, icon);
                }
            } // if
        } // for
    }

// ----------------------------------------------------------------------------
// Find the collection media for all songs category
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoAllSongsMediaL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& aAttrs,
    CMPXMedia& aEntries,
    CMPXMediaArray& aMediaArray)
    {
    MPX_FUNC("CMPXDbPlugin::DoAllSongsMediaL");

    TInt levels(aPath.Levels());

    switch (levels)
       {
       // All songs
       case 2:
            {
            MPX_PERF_START(CMPXDbPlugin_DoAllSongsMediaL_All);
            DoRootCategoryMediaL(aAttrs, EBrowseAll, EMPXSong, aEntries);
            MPX_PERF_END(CMPXDbPlugin_DoAllSongsMediaL_All);
            break;
            }

         // A Song in all songs
         case 3:
            {
            MPX_PERF_START(CMPXDbPlugin_DoAllSongsMediaL_Song);
            GetSongInfoL(aPath, aAttrs, aEntries, aMediaArray);
            MPX_PERF_END(CMPXDbPlugin_DoAllSongsMediaL_Song);
            break;
            }

         default:
            {
            MPX_DEBUG2("CMPXDbPlugin_DoAllSongsMediaL: Invalid levels[%d]", levels);
            User::Leave(KErrNotSupported);
            }
        } // end switch(levels)
    }

// ----------------------------------------------------------------------------
// Find the collection media for artists category
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoArtistMediaL (
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& aAttrs,
    CMPXMedia& aEntries,
    CMPXMediaArray& aMediaArray)
    {
    MPX_FUNC("CMPXDbPlugin::DoArtistMediaL");

    TInt levels(aPath.Levels());
    TInt count(aPath.Selection().Count());

     // All artists
    if (levels == 2)
        {
        MPX_PERF_START(CMPXDbPlugin_DoArtistMediaL_All);
        DoRootCategoryMediaL(aAttrs, EBrowseArtist, EMPXArtist, aEntries);
        MPX_PERF_END(CMPXDbPlugin_DoArtistMediaL_All);
        }
    else if ((levels == 3) && count) // multiple artists selected
        {
        RArray<TMPXItemId> selections;
        CleanupClosePushL(selections);
        aPath.SelectionL(selections);

        for (TInt i = 0; i < count; ++i)
            {
            CMPXMedia* artist = CMPXMedia::NewL();
            CleanupStack::PushL(artist);
            iDbHandler->GetCategoryL(selections[i].iId2, EMPXArtist, aAttrs, artist);
            aMediaArray.AppendL(*artist);
            CleanupStack::PopAndDestroy(artist);
            }

        CleanupStack::PopAndDestroy(&selections);
        }
    else if (levels == 3) // single artist selected
        {
        iDbHandler->GetCategoryL(aPath.Id(2).iId2, EMPXArtist, aAttrs, &aEntries);
        }
    else if (levels == 4 && (aPath.Id(3) == aPath.Id(2))) // all songs for an artist
        {
        MPX_PERF_START(CMPXDbPlugin_DoArtistMediaL_AllSongs);
        // Calculate duration directly with SQL
        if (MPXDbCommonUtil::AttributeExists(aAttrs, KMPXMediaGeneralDuration))
            {
            DoDurationL(aEntries, EMPXArtist, aPath.Id(2));
            }

        MPX_PERF_END(CMPXDbPlugin_DoArtistMediaL_AllSongs);
        }
    else if ((levels == 4) && count) // multiple albums of an artist
        {
        MPX_PERF_START(CMPXDbPlugin_DoArtistMediaL_AllAlbums);

        RArray<TMPXItemId> selections;
        CleanupClosePushL(selections);
        aPath.SelectionL(selections);

        for (TInt i = 0; i < count; ++i)
            {
            CMPXMedia* media = CMPXMedia::NewL();
            CleanupStack::PushL(media);
            iDbHandler->GetCategoryL(selections[i].iId2, EMPXAlbum, aAttrs, media);
            aMediaArray.AppendL(*media);
            CleanupStack::PopAndDestroy(media);
            }

        CleanupStack::PopAndDestroy(&selections);

        MPX_PERF_END(CMPXDbPlugin_DoArtistMediaL_AllAlbums);
        }
    else if (levels == 4) // one album of an artist
        {
        MPX_PERF_START(CMPXDbPlugin_DoArtistMediaL_OneAlbum);
        iDbHandler->GetCategoryL(aPath.Id(3).iId2, EMPXAlbum, aAttrs, &aEntries);

        // Calculate duration
        if (MPXDbCommonUtil::AttributeExists(aAttrs, KMPXMediaGeneralDuration))
            {
            DoDurationL(aEntries, EMPXArtist, aPath.Id(2), EMPXAlbum, aPath.Id(3));
            }

        MPX_PERF_END(CMPXDbPlugin_DoArtistMediaL_OneAlbum);
        }
     else if (levels == 5) // a song/songs in an album
        {
        MPX_PERF_START(CMPXDbPlugin_DoArtistMediaL_Song);
        GetSongInfoL(aPath, aAttrs, aEntries, aMediaArray);
        MPX_PERF_END(CMPXDbPlugin_DoArtistMediaL_Song);
        }
    else
        {
        MPX_DEBUG2("CMPXDbPlugin_DoArtistMediaL: Invalid levels[%d]", levels);
        User::Leave(KErrNotSupported);
        }
    }

// ----------------------------------------------------------------------------
// Find the collection media for all songs category
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoRootCategoryMediaL (
    const TArray<TMPXAttribute>& aAttrs,
    TMPXItemId aRootCategoryId,
    TMPXGeneralCategory aCategory,
    CMPXMedia& aEntries)
    {
    MPX_FUNC("CMPXDbPlugin::DoRootCategoryMediaL");

    TInt count(aAttrs.Count());
    for (TInt i = 0; i < count; ++i)
        {
        if (aAttrs[i].ContentId() == KMPXMediaIdGeneral)
            {
            TUint att(aAttrs[i].AttributeId());
            switch (att)
                {
                case EMPXMediaGeneralId:
                    {
                    aEntries.SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, aRootCategoryId);
                    break;
                    }
                case EMPXMediaGeneralTitle:
                    {
                    aEntries.SetTextValueL(KMPXMediaGeneralTitle,
                        iMusicLibraryMenuTitles->MdcaPoint(BrowseTypeForCategory(aCategory)));
                    break;
                    }
                case EMPXMediaGeneralCount:
                    {
                    // count number of category
                    aEntries.SetTObjectValueL<TInt>(KMPXMediaGeneralCount,
                        iDbHandler->NumberOfItemsL(aCategory));
                    break;
                    }
                case EMPXMediaGeneralDuration:
                    {
                    if (aCategory == EMPXSong)
                        {
                        DoDurationL(aEntries, EMPXSong);
                        }
                    break;
                    }
                default:
                    // not supported
                    break;
                } // end switch
            } // end if
        } // end for

    aEntries.SetTObjectValueL<TMPXGeneralType>(KMPXMediaGeneralType, EMPXGroup);
    aEntries.SetTObjectValueL<TMPXGeneralCategory>(KMPXMediaGeneralCategory, aCategory);
    }

// ----------------------------------------------------------------------------
// Find the collection media for albums/playlists/genres/composers category
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoCategoryMediaL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& aAttrs,
    TMPXGeneralCategory aCategory,
    CMPXMedia& aEntries,
    CMPXMediaArray& aMediaArray)
    {
    MPX_FUNC("CMPXDbPlugin::DoCategoryMediaL");

    TInt levels(aPath.Levels());
    TInt count(aPath.Selection().Count());

    if (levels == 2) // all albums/playlists/genres/composers
        {
        MPX_PERF_START (CMPXDbPlugin_DoCategoryMediaL_All);
        DoRootCategoryMediaL(aAttrs, aPath.Id(1).iId2, aCategory, aEntries);
        MPX_PERF_END (CMPXDbPlugin_DoCategoryMediaL_All);
        }
    else if (levels == 3 && count) // multiple albums/playlists/genres/composers selected
        {
        RArray<TMPXItemId> selections;
        CleanupClosePushL(selections);
        aPath.SelectionL(selections);

        for (TInt i = 0; i < count; ++i)
            {
            CMPXMedia* media = CMPXMedia::NewL();
            CleanupStack::PushL(media);
            iDbHandler->GetCategoryL(selections[i].iId2, aCategory, aAttrs, media);
            aMediaArray.AppendL(*media);
            CleanupStack::PopAndDestroy(media);
            }

        CleanupStack::PopAndDestroy(&selections);
        }
    else if (levels == 3) // all songs in an album/playlist/genre/composer
        {
        MPX_PERF_START(CMPXDbPlugin_DoCategoryMediaL_Category);
        TMPXItemId id = aPath.Id(2);
        iDbHandler->GetCategoryL(id.iId2, aCategory, aAttrs, &aEntries);

        // Calculate duration directly with SQL
        if (MPXDbCommonUtil::AttributeExists(aAttrs, KMPXMediaGeneralDuration))
            {
            DoDurationL(aEntries, aCategory, id);
            }

        TInt nonPermisAction( aEntries.ValueTObjectL<TInt>(KMPXMediaGeneralNonPermissibleActions));
        nonPermisAction |= EMPXCache;

        aEntries.SetTObjectValueL<TMPXGeneralNonPermissibleActions>(
                    KMPXMediaGeneralNonPermissibleActions, (TMPXGeneralNonPermissibleActions) nonPermisAction );

        MPX_PERF_END(CMPXDbPlugin_DoCategoryMediaL_Category);
        }
    else if (levels == 4) // a song/songs in an album/playlist/genre/composer
        {
        MPX_PERF_START(CMPXDbPlugin_DoCategoryMediaL_Song);
        GetSongInfoL(aPath, aAttrs, aEntries, aMediaArray);
        MPX_PERF_END(CMPXDbPlugin_DoCategoryMediaL_Song);
        }
    else
        {
        MPX_DEBUG2("CMPXDbPlugin__DoMediaL__EBrowseAlbum: Invalid levels[%d]", levels);
        User::Leave(KErrNotSupported);
        }
    }

// ----------------------------------------------------------------------------
// Set all the attributes in CMPXMedia corresponding to KMPXMediaIdDrm
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoSetMediaDrmL(
    CMPXMedia& aMedia,
    TUint aDrmAttributes,
    const TDesC& aLocation)
    {
    MPX_FUNC("CMPXDbPlugin::DoSetMediaDrmL");

    iDrmMediaUtility->InitL(aLocation);
    CleanupClosePushL(*iDrmMediaUtility);
    const CMPXMedia* drmMedia(iDrmMediaUtility->GetMediaL(aDrmAttributes));

    // Only get attributes if it's a DRM file
    if (drmMedia)
        {
        if ((aDrmAttributes & EMPXMediaDrmType) &&
            drmMedia->IsSupported(KMPXMediaDrmType))
            {
            aMedia.SetTObjectValueL(KMPXMediaDrmType,
                drmMedia->ValueTObjectL<TInt>(KMPXMediaDrmType));
            }
        if ((aDrmAttributes & EMPXMediaDrmRightsStatus) &&
            drmMedia->IsSupported(KMPXMediaDrmRightsStatus))
            {
            aMedia.SetTObjectValueL(KMPXMediaDrmRightsStatus,
                drmMedia->ValueTObjectL<TInt>(KMPXMediaDrmRightsStatus));
            }
        if ((aDrmAttributes & EMPXMediaDrmRightsType) &&
            drmMedia->IsSupported(KMPXMediaDrmRightsType))
            {
            aMedia.SetTObjectValueL(KMPXMediaDrmRightsType,
                drmMedia->ValueTObjectL<TInt>(KMPXMediaDrmRightsType));
            }
        if ((aDrmAttributes & EMPXMediaDrmCount) &&
            drmMedia->IsSupported(KMPXMediaDrmCount))
            {
            aMedia.SetTObjectValueL(KMPXMediaDrmCount,
                drmMedia->ValueTObjectL<TInt>(KMPXMediaDrmCount));
            }
        if ((aDrmAttributes & EMPXMediaDrmProtected) &&
            drmMedia->IsSupported(KMPXMediaDrmProtected))
            {
            aMedia.SetTObjectValueL(KMPXMediaDrmProtected,
                drmMedia->ValueTObjectL<TBool>(KMPXMediaDrmProtected));
            }
        if ((aDrmAttributes & EMPXMediaDrmSendingAllowed) &&
            drmMedia->IsSupported(KMPXMediaDrmSendingAllowed))
            {
            aMedia.SetTObjectValueL(KMPXMediaDrmSendingAllowed,
                drmMedia->ValueTObjectL<TBool>(KMPXMediaDrmSendingAllowed));
            }
        if ((aDrmAttributes & EMPXMediaDrmCanSetAutomated) &&
            drmMedia->IsSupported(KMPXMediaDrmCanSetAutomated))
            {
            aMedia.SetTObjectValueL(KMPXMediaDrmCanSetAutomated,
                drmMedia->ValueTObjectL<TBool>(KMPXMediaDrmCanSetAutomated));
            }
        if ((aDrmAttributes & EMPXMediaDrmHasInfoUrl) &&
            drmMedia->IsSupported(KMPXMediaDrmHasInfoUrl))
            {
            aMedia.SetTObjectValueL(KMPXMediaDrmHasInfoUrl,
                drmMedia->ValueTObjectL<TBool>(KMPXMediaDrmHasInfoUrl));
            }
        if ((aDrmAttributes & EMPXMediaDrmHasPreviewUrl) &&
            drmMedia->IsSupported(KMPXMediaDrmHasPreviewUrl))
            {
            aMedia.SetTObjectValueL(KMPXMediaDrmHasPreviewUrl,
                drmMedia->ValueTObjectL<TBool>(KMPXMediaDrmHasPreviewUrl));
            }
        if ((aDrmAttributes & EMPXMediaDrmAboutToExpire) &&
            drmMedia->IsSupported(KMPXMediaDrmAboutToExpire))
            {
            aMedia.SetTObjectValueL( KMPXMediaDrmAboutToExpire,
                drmMedia->ValueTObjectL<TBool>(KMPXMediaDrmAboutToExpire));
            }
        if ((aDrmAttributes & EMPXMediaDrmStartTime) &&
            drmMedia->IsSupported(KMPXMediaDrmStartTime))
            {
            aMedia.SetTObjectValueL(KMPXMediaDrmStartTime,
                drmMedia->ValueTObjectL<TInt64>(KMPXMediaDrmStartTime));
            }
        if ((aDrmAttributes & EMPXMediaDrmEndTime) &&
            drmMedia->IsSupported(KMPXMediaDrmEndTime))
            {
            aMedia.SetTObjectValueL( KMPXMediaDrmEndTime,
                drmMedia->ValueTObjectL<TInt64>(KMPXMediaDrmEndTime));
            }
        if ((aDrmAttributes & EMPXMediaDrmIntervalStartTime) &&
            drmMedia->IsSupported(KMPXMediaDrmIntervalStartTime))
            {
            aMedia.SetTObjectValueL( KMPXMediaDrmIntervalStartTime,
                drmMedia->ValueTObjectL<TInt64>(KMPXMediaDrmIntervalStartTime));
            }
        if ((aDrmAttributes & EMPXMediaDrmAccumulatedTime) &&
            drmMedia->IsSupported(KMPXMediaDrmAccumulatedTime))
            {
            aMedia.SetTObjectValueL(KMPXMediaDrmAccumulatedTime,
                drmMedia->ValueTObjectL<TInt64>(KMPXMediaDrmAccumulatedTime));
            }
        if ((aDrmAttributes & EMPXMediaDrmInterval) &&
            drmMedia->IsSupported(KMPXMediaDrmInterval))
            {
            aMedia.SetTObjectValueL( KMPXMediaDrmInterval,
                drmMedia->ValueTObjectL<TTimeIntervalSeconds>(KMPXMediaDrmInterval));
            }
        }

    CleanupStack::PopAndDestroy(iDrmMediaUtility);
    }

// ----------------------------------------------------------------------------
// Add media objects to the array with attributes from song details
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::GetSongInfoL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXAttribute>& aAttrs,
    CMPXMedia& aEntry,
    CMPXMediaArray& aMediaArray)
    {
    MPX_FUNC("CMPXDbPlugin::GetSongInfoL");

    RArray<TInt> supportedIds;
    CleanupClosePushL(supportedIds);
    MPXDbCommonUtil::FillInSupportedUIDsL(aAttrs, supportedIds);

    RArray<TMPXItemId> selections;
    CleanupClosePushL(selections);
    aPath.SelectionL(selections);

    //
    // If we are trying to locate a song from a playlist, we should read available song
    // info from Playlist table first in case the song is located on a removable
    // drive and the drive is not currently present. This is achieved by supplying
    // playlist Id to GetSongMatchingSongIdL. When playlistId is 0, we are reading song
    // info directly from Songs table. If playlistId is specified, GetSongMatchingSongIdL
    // will populate song media from Playlist table and if Songs table for the drive
    // exists, song media will be overwritten with info from Songs table.
    //
    TMPXItemId playlistId(0);
    if (aPath.Id(1) == EBrowsePlaylist)
        {
        if (aPath.Levels() < 2)
            {
            User::Leave(KErrArgument);
            }

        playlistId = aPath.Id(aPath.Levels() - 2);
        }

    TInt countSelection(aPath.Selection().Count());
    if (countSelection)
        {
        // We have a selection, iterate it
        for (TInt selectionIndex = 0; selectionIndex < countSelection; ++selectionIndex)
            {
            CMPXMedia* newEntry = CMPXMedia::NewL(supportedIds.Array());
            CleanupStack::PushL(newEntry);

            DoGetSongInfoL(aAttrs, selections[selectionIndex].iId2, playlistId.iId2, *newEntry);

            aMediaArray.AppendL(*newEntry);
            CleanupStack::PopAndDestroy(newEntry);
            }
        }
    else
        {
        // No selection, get the attributes for the one song
        DoGetSongInfoL(aAttrs, aPath.Id(aPath.Levels() - 1).iId2, playlistId.iId2, aEntry);
        }

    CleanupStack::PopAndDestroy(&selections);
    CleanupStack::PopAndDestroy(&supportedIds);
    }

// ----------------------------------------------------------------------------
// Retrieves the attributes for a media object.
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoGetSongInfoL(
    const TArray<TMPXAttribute>& aAttrs,
    TInt aEntryId,
    TInt aPlaylistId,
    CMPXMedia& aEntry)
    {
    MPX_FUNC("CMPXDbPlugin::DoGetSongInfoL");

    if (aPlaylistId)
        {
        iDbHandler->GetPlaylistSongL(aEntryId, aPlaylistId, aAttrs, aEntry);
        }
    else
        {
        iDbHandler->GetSongL(aEntryId, aAttrs, aEntry);
        }

    const TDesC& location(aEntry.ValueText(KMPXMediaGeneralUri));

    // Check DRM Only if we have a location
    if (location != KNullDesC)
        {
        TUint drmAttributes(0);

        // Compact the attribute set
        TInt count(aAttrs.Count());
        for (TInt i = 0; i < count; ++i)
            {
            if (aAttrs[i].ContentId() == KMPXMediaIdDrm)
                {
                drmAttributes |= aAttrs[i].AttributeId();
                }
            }

        // Set the correct attributes to media, only if requested
        if (drmAttributes)
            {
            DoSetMediaDrmL(aEntry, drmAttributes, location);
            }
        }

    // Disable caching for any MediaL() returning song info.
    TInt nonPermisAction( aEntry.ValueTObjectL<TInt>(KMPXMediaGeneralNonPermissibleActions));
    nonPermisAction |= EMPXCache;

    aEntry.SetTObjectValueL<TMPXGeneralNonPermissibleActions>(
                KMPXMediaGeneralNonPermissibleActions, (TMPXGeneralNonPermissibleActions) nonPermisAction );
    }

// ----------------------------------------------------------------------------
// Find the collection details
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoHandleOtherMediaAttributesL(
    const TArray<TMPXAttribute>& aAttrs,
    const CMPXCollectionPath& aPath,
    CMPXMedia& aMedia)
    {
    MPX_FUNC("CMPXDbPlugin::DoHandleOtherMediaAttributesL");

    TInt count(aAttrs.Count());
    for (TInt i = 0; i < count; ++i)
        {
        if (aAttrs[i].ContentId() == KMPXMediaIdCollectionDetails)
            {
            TUint att(aAttrs[i].AttributeId());

            if (att & EMPXMediaColDetailNumberOfItems)
                {
                aMedia.SetTObjectValueL(KMPXMediaColDetailNumberOfItems,
                    iDbHandler->NumberOfItemsL(EMPXSong));
                }
            if (att & EMPXMediaColDetailDuration)
                {
                aMedia.SetTObjectValueL(KMPXMediaColDetailDuration,
                    DoDurationL(aMedia, EMPXSong));
                }
            if (att & EMPXMediaColTotalSize)
                {
                // todo
                TInt totalSize(0);
                aMedia.SetTObjectValueL(KMPXMediaColDetailTotalSize, totalSize);
                }
            if (att & EMPXMediaLastRefreshed)
                {
                TTime lastRefreshed(iDbHandler->GetLastRefreshedTimeL());
                aMedia.SetTObjectValueL(KMPXMediaColDetailLastRefreshed,
                    lastRefreshed.Int64());
                }
            if (att & EMPXMediaColDetailDBCreated)
                {
                aMedia.SetTObjectValueL(KMPXMediaColDetailDBCreated,
                    iDbHandler->DatabaseCreated());
                }
            if (att & EMPXMediaColDetailDBCorrupted)
                {
                aMedia.SetTObjectValueL(KMPXMediaColDetailDBCorrupted,
                    iDbHandler->IsDBCorruptedL());
                }
            }
        else if (aAttrs[i] == KMPXMediaGeneralPath)
            {
            aMedia.SetCObjectValueL(KMPXMediaGeneralPath,
                const_cast<CMPXCollectionPath*>(&aPath));
            }
        }
    }

// ----------------------------------------------------------------------------
// Remove an item from the collection database using the given path
// ----------------------------------------------------------------------------
//
CDesCArray* CMPXDbPlugin::DoRemoveL(
    const CMPXCollectionPath& aPath,
    CMPXMessageArray& aChangeMsgArray)
    {
    MPX_FUNC("CMPXDbPlugin::DoRemoveL");

    if (aPath.Levels() <= 1)
        {
        User::Leave(KErrNotSupported);
        }

    // Return file path for deleted item(s)
    //
    CDesCArray* fp = new(ELeave) CDesCArrayFlat(1);
    CleanupStack::PushL(fp);

    // Ids of the selected items
    RArray<TMPXItemId> selections;
    CleanupClosePushL(selections);
    aPath.SelectionL(selections);

    switch (aPath.Id(1).iId2)
        {
        case EBrowseAll:
            {
            DoRemoveFromAllSongsL(aPath, selections.Array(), *fp, aChangeMsgArray);
            }
            break;

        case EBrowseArtist:
            {
            DoRemoveFromArtistsL(aPath, selections.Array(), *fp, aChangeMsgArray);
            }
            break;

        case EBrowseAlbum: // deliberate fall through
        case EBrowseGenre: // deliberate fall through
        case EBrowseComposer: // deliberate fall through
            {
            DoRemoveFromCategoriesL(aPath, selections.Array(),
                CategoryForBrowseType(static_cast<TMCBrowseType>(aPath.Id(1).iId2)), *fp, aChangeMsgArray);
            }
            break;

        case EBrowsePlaylist:
            {
            DoRemoveFromPlaylistsL(aPath, selections.Array(), *fp, aChangeMsgArray);
            }
            break;

        default:
            {
            User::Leave(KErrArgument);
            }
        } // end switch (aPath.Id(1))

    MPX_DEBUG2("CMPXDbPlugin::RemoveL itemId[%d]", aPath.Id(aPath.Levels() - 1).iId2);

    CleanupStack::PopAndDestroy( &selections );
    CleanupStack::Pop(fp);

    return fp;
    }

// ----------------------------------------------------------------------------
// Remove an item from the collection database using the given media properties
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoRemoveL(
    const CMPXMedia& aMedia,
    TBool aDeleteRecord)
    {
    MPX_FUNC("CMPXDbPlugin::DoRemoveL(by media)");

    // Return deleted file paths to caller
    CDesCArray* fp = new(ELeave) CDesCArrayFlat(1);
    CleanupStack::PushL(fp);

    // a list of change event messages a result of the item being removed
    CMPXMessageArray* itemChangedMessages = CMPXMediaArray::NewL();
    CleanupStack::PushL(itemChangedMessages);

    TUint32 mediaId(0);

    // Removing a container of items
    //
    if (aMedia.IsSupported(KMPXMediaArrayContents))
        {
        MPX_DEBUG1("CMPXDbPlugin::RemoveL -- Removing a container of items");
        const CMPXMediaArray* media = aMedia.Value<CMPXMediaArray>(KMPXMediaArrayContents);
        if( !media )
            {
            User::Leave(KErrNoMemory);
            }
        const TInt mediaCount(media->Count());
        for (TInt i = 0; i < mediaCount; ++i)
            {
            CMPXMedia* entry = media->AtL(i);
            if (entry->IsSupported(KMPXMediaGeneralId))
                {
                mediaId = entry->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
                }
            else if (entry->IsSupported(KMPXMediaGeneralUri))
                {
                const TDesC& uri = entry->ValueText(KMPXMediaGeneralUri);
                mediaId = iDbHandler->GetSongIdMatchingUriL(uri);
                }
            else
                {
                // Unable to process this item
                continue;
                }

            iDbHandler->RemoveSongL(mediaId, *fp, *itemChangedMessages, aDeleteRecord);
            }
        }
    // Removing an item with known item id
    //
    else if (aMedia.IsSupported(KMPXMediaGeneralId))
        {
        MPX_DEBUG1("CMPXDbPlugin::RemoveL -- Removing an item by item id");
        mediaId =  aMedia.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);

        if (MPX_ITEM_CATEGORY(mediaId) != EMPXPlaylist)
            {
            iDbHandler->RemoveSongL(mediaId, *fp, *itemChangedMessages, aDeleteRecord);
            }
        else
            {
            iDbHandler->RemovePlaylistL(mediaId, *fp, *itemChangedMessages);
            }
        }
    // Removing an item with known uri
    //
    else if (aMedia.IsSupported(KMPXMediaGeneralUri))
        {
        MPX_DEBUG1("CMPXDbPlugin::RemoveL -- Removing an item by uri");
        TPtrC uri = aMedia.ValueText( KMPXMediaGeneralUri );

        TMPXGeneralCategory category =
            aMedia.ValueTObjectL<TMPXGeneralCategory>(KMPXMediaGeneralCategory);

        if (category == EMPXSong)
            {
            mediaId = iDbHandler->GetSongIdMatchingUriL(uri);
            iDbHandler->RemoveSongL(mediaId, *fp, *itemChangedMessages, aDeleteRecord);
            }
        else if (category == EMPXPlaylist)
            {
            mediaId = iDbHandler->GetPlaylistIdMatchingUriL(uri);
            iDbHandler->RemovePlaylistL(mediaId, *fp, *itemChangedMessages);
            }
#ifdef ABSTRACTAUDIOALBUM_INCLUDED
        else if (category == EMPXAbstractAlbum )
            {
            mediaId = iDbHandler->GetAbstractAlbumIdMatchingUriL(uri);
            iDbHandler->RemoveAbstractAlbumL(mediaId, *itemChangedMessages, EFalse);
            }
#endif // ABSTRACTAUDIOALBUM_INCLUDED
        else
            {
            // otherwise unable to process this item
            }
        }
    else
        {
        MPX_DEBUG1("CMPXDbPlugin::RemoveL -- Unknown item for removal");
        User::Leave(KErrNotSupported);
        }

    iActiveTask->SetVisibleChange(CMPXDbActiveTask::EAllVisible);

    // Removing an item always invalidates all songs.
    //
    MPXDbCommonUtil::AddItemChangedMessageL(*itemChangedMessages, EBrowseAll,
                                            EMPXItemModified, EMPXCollection, KDBPluginUid);

    DoHandleChangeL(itemChangedMessages);

    CleanupStack::PopAndDestroy(itemChangedMessages);
    CleanupStack::PopAndDestroy(fp);
    }

// ----------------------------------------------------------------------------
// Remove media by path through a command
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoRemovePathL(
    CMPXCommand& aCmd)
    {
    MPX_FUNC("CMPXDbPlugin::DoRemovePathL(by command)");

    TInt removeError(KErrNone);
    TBool removeCompleted(ETrue);

    if (!aCmd.IsSupported(KMPXCommandCollectionRemovePath) ||
        !aCmd.IsSupported(KMPXCommandCollectionRemoveMediaCount))
        {
        removeError = KErrArgument;
        }
    else
        {
        CMPXCollectionPath* path =
            aCmd.ValueCObjectL<CMPXCollectionPath>(KMPXCommandCollectionRemovePath);
        CleanupStack::PushL(path);

        // in order to support cancel delete for a category, we need to adjust path. If
        // the path ends in a category, retrieve all songs under the selected category
        // and append a new level with all songs under the selected category
        DoAppendLevelL(*path);

        CMPXCollectionPath* iterationPath = CMPXCollectionPath::NewL(*path);
        CleanupStack::PushL(iterationPath);
        iterationPath->ClearSelection();

        // indices of the selected items
        TArray<TInt> selectionIndices = path->Selection();
        TInt count(selectionIndices.Count());

        // number of media items to remove in this iteration
        TInt removeCount = (aCmd.ValueTObjectL<TInt>(KMPXCommandCollectionRemoveMediaCount));

        // remove all in one shot if removeCount is 0 or negative
        if (removeCount <= 0)
            {
            removeCount = count;
            }

        // If the given path contains multiple selections, remove the first n selected media
        // and update the path so that client can use this path to call remove iteratively
        // until all selections are processed
        //
        if (count)
            {
            for (TInt i = 0; i < removeCount; ++i)
                {
                TInt index(selectionIndices[i]);

                MPX_DEBUG4(" path: selected item [index %d] [selectioncount %d] [remove count %d]", index, count, removeCount);

                iterationPath->SelectL(index);
                path->Remove(index);
                }

            aCmd.SetCObjectValueL(KMPXCommandCollectionRemovePath, path);

            // indicate to the client that subsequent remove command is required
            if ((count - removeCount) > 0)
                {
                removeCompleted = EFalse;
                }
            }

        // Remove the media specified by the path
        CDesCArray* fp(NULL);
        TBool supressMsgs(EFalse);
        CMPXMessageArray* msgAry(NULL);

        if (aCmd.IsSupported(KMPXCommandCollectionRemoveSuppressMsgs) &&
            aCmd.ValueTObjectL<TBool>(KMPXCommandCollectionRemoveSuppressMsgs))
            {
            // Msgs are stored in the command
            supressMsgs = ETrue;

            CMPXMessageArray* msgs( aCmd.Value<CMPXMessageArray>(KMPXCommandCollectionChangeMsgs) );
            User::LeaveIfNull( msgs );
            fp = DoRemoveL(*iterationPath, *msgs);
            }
        else
            {
            // Msgs will be sent after delete
            msgAry = CMPXMessageArray::NewL();
            CleanupStack::PushL(msgAry);
            fp = DoRemoveL(*iterationPath, *msgAry);
            }

        CleanupStack::PushL(fp);
        if (fp->MdcaCount() > removeCount)
            {
            removeError = KErrCorrupt;
            }
        CleanupStack::PopAndDestroy(fp);

        if (!supressMsgs)
            {
            // Send Change Messages
            iActiveTask->SetVisibleChange(CMPXDbActiveTask::EAllVisible);
            DoHandleChangeL(msgAry);
            CleanupStack::PopAndDestroy(msgAry);
            }

        // Cleanup
        CleanupStack::PopAndDestroy(iterationPath);
        CleanupStack::PopAndDestroy(path);
        }

    // mandatory return parameters
    aCmd.SetTObjectValueL<TInt>(KMPXCommandCollectionRemoveError, removeError);
    aCmd.SetTObjectValueL<TBool>(KMPXCommandCollectionRemoveCompleted, removeCompleted);
    }

// ----------------------------------------------------------------------------
// Remove media by CMPXMedia through a command
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoRemoveMediaL(
    CMPXCommand& aCmd)
    {
    MPX_FUNC("CMPXDbPlugin::DoRemoveMediaL(by command)");

    TInt error(KErrArgument);

    if (aCmd.IsSupported(KMPXCommandCollectionRemoveMedia))
        {
        CMPXMedia* media = aCmd.ValueCObjectL<CMPXMedia>(KMPXCommandCollectionRemoveMedia);
        CleanupStack::PushL(media);

        MPX_TRAP(error, DoRemoveL(*media,
            aCmd.ValueTObjectL<TBool>(KMPXCommandCollectionRemoveMediaDeleteRecord)));

        CleanupStack::PopAndDestroy(media);
        }

    aCmd.SetTObjectValueL<TInt>(KMPXCommandCollectionRemoveMediaError, error);
    }

// ----------------------------------------------------------------------------
// Remove a media/media items from All Songs view
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoRemoveFromAllSongsL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXItemId>& aSelections,
    CDesCArray& aUriArray,
    CMPXMessageArray& aItemChangedMessages)
    {
    MPX_FUNC("CMPXDbPlugin::DoRemoveFromAllSongsL");

    switch (aPath.Levels())
        {
        case 2:
            {
            // when the collection is removed, it's intended not to delete the files
            iDbHandler->RemoveEntireCollectionL();
            }
            break;

        case 3:
            {
            TInt count(aSelections.Count());
            if (count)
                {
                for (TInt i = 0; i < count; ++i)
                    {
                    iDbHandler->RemoveSongL(aSelections[i].iId2, aUriArray, aItemChangedMessages);
                    } // end for
                }
            else
                {
                iDbHandler->RemoveSongL(aPath.Id(aPath.Levels() - 1).iId2, aUriArray,
                     aItemChangedMessages);
                }
            }
            break;

        default:
            {
            MPX_DEBUG2("CMPXDbPlugin_DoRemoveFromAllSongsL: Invalid levels[%d]", aPath.Levels());
            User::Leave(KErrNotSupported);
            }
        }
    }

// ----------------------------------------------------------------------------
// Remove a media/media items from Artists view
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoRemoveFromArtistsL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXItemId>& aSelections,
    CDesCArray& aUriArray,
    CMPXMessageArray& aItemChangedMessages)
    {
    MPX_FUNC("CMPXDbPlugin::DoRemoveFromArtistsL");

    TInt levels(aPath.Levels());
    if (levels == 2)
        {
        // when the collection is removed, it's intended not to delete the files
        iDbHandler->RemoveEntireCollectionL();
        }
    else
        {
        TInt count(aSelections.Count());
        if (count)
            {
            for (TInt i = 0; i < count; ++i)
                {
                RemoveFromArtistsL(aPath, aSelections[i].iId2, aUriArray, aItemChangedMessages);
                }
            }
        else
            {
            RemoveFromArtistsL(aPath, aPath.Id(levels - 1).iId2, aUriArray, aItemChangedMessages);
            }
        }

    MPX_DEBUG2("CMPXDbPlugin__RemoveL__EBrowseArtist: levels[%d]", levels);
    }

// ----------------------------------------------------------------------------
// Remove a media item from Artists view
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::RemoveFromArtistsL(
    const CMPXCollectionPath& aPath,
    TUint32 aItemId,
    CDesCArray& aUriArray,
    CMPXMessageArray& aItemChangedMessages)
    {
    MPX_FUNC("CMPXDbPlugin::RemoveFromArtistsL");

    switch (aPath.Levels())
        {
        case 3:
            {
            iDbHandler->RemoveSongsMatchingCategoryL(EMPXArtist, aItemId, aUriArray, aItemChangedMessages);
            break;
            }
        case 4:
            {
            // remove the songs for the artist and album
            iDbHandler->RemoveSongsMatchingArtistAndAlbumL(aPath.Id(aPath.Levels() - 2), aItemId,
                aUriArray, aItemChangedMessages);
            break;
            }
        case 5:
            {
            iDbHandler->RemoveSongL(aItemId, aUriArray, aItemChangedMessages);
            break;
            }
        default:
            {
            User::Leave(KErrArgument);
            }
        }
    }

// ----------------------------------------------------------------------------
// Remove a media/media items from Albums/Genres/Composers view
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoRemoveFromCategoriesL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXItemId>& aSelections,
    TMPXGeneralCategory aCategory,
    CDesCArray& aUriArray,
    CMPXMessageArray& aItemChangedMessages)
    {
    MPX_FUNC("CMPXDbPlugin::DoRemoveFromCategoriesL");

    TInt levels(aPath.Levels());
    if (levels == 2)
        {
        // when the collection is removed, it's intended not to delete the files
        iDbHandler->RemoveEntireCollectionL();
        }
    else
        {
        TInt count(aSelections.Count());
        if (count)
            {
            for (TInt i = 0; i < count; ++i)
                {
                RemoveFromCategoriesL(aPath, aSelections[i].iId2, aCategory,
                    aUriArray, aItemChangedMessages);
                }
            }
        else
            {
            RemoveFromCategoriesL(aPath, aPath.Id(levels - 1).iId2, aCategory,
                aUriArray, aItemChangedMessages);
            }
        }

    MPX_DEBUG2("CMPXDbPlugin__RemoveL__EBrowseAlbum: levels[%d]", levels);
    }

// ----------------------------------------------------------------------------
// Remove a media item from Albums/Genres/Composers view
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::RemoveFromCategoriesL(
    const CMPXCollectionPath& aPath,
    TUint32 aItemId,
    TMPXGeneralCategory aCategory,
    CDesCArray& aUriArray,
    CMPXMessageArray& aItemChangedMessages)
    {
    MPX_FUNC("CMPXDbPlugin::RemoveFromCategoriesL");

    switch (aPath.Levels())
        {
        case 3:
            {
            iDbHandler->RemoveSongsMatchingCategoryL(aCategory, aItemId, aUriArray,
                aItemChangedMessages);
            break;
            }
        case 4:
            {
            iDbHandler->RemoveSongL(aItemId, aUriArray, aItemChangedMessages);
            break;
            }
        default:
            {
            User::Leave(KErrArgument);
            }
        }
    }

// ----------------------------------------------------------------------------
// Remove one or multiple media items from Playlists view
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoRemoveFromPlaylistsL(
    const CMPXCollectionPath& aPath,
    const TArray<TMPXItemId>& aSelections,
    CDesCArray& aUriArray,
    CMPXMessageArray& aItemChangedMessages)
    {
    MPX_FUNC("CMPXDbPlugin::DoRemoveFromPlaylistsL");

    TInt levels(aPath.Levels());

    // all playlists
    if (levels == 2)
        {
        // when the collection is removed, it's intended not to delete the files
        iDbHandler->RemoveAllPlaylistsL();
        }
    else
        {
        TArray<TInt> selectionIndices = aPath.Selection();
        TInt count(selectionIndices.Count());

        // multiple selections
        if (count)
            {
            for (TInt i = (count - 1); i >= 0; --i)
                {
                RemoveFromPlaylistsL(aPath, aSelections[i], selectionIndices[i],
                    aUriArray, aItemChangedMessages);
                }
            }
        // else no selection
        else
            {
            RemoveFromPlaylistsL(aPath, aPath.IdOfIndex(aPath.Index()), aPath.Index(),
                aUriArray, aItemChangedMessages);
            }
        }

    MPX_DEBUG2("CMPXDbPlugin__RemoveL__EBrowsePlaylist: levels[%d]", levels);
    }

// ----------------------------------------------------------------------------
// Remove a media item from Playlists view
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::RemoveFromPlaylistsL(
    const CMPXCollectionPath& aPath,
    const TMPXItemId& aItemId,
    TInt aIndex,
    CDesCArray& aUriArray,
    CMPXMessageArray& aItemChangedMessages)
    {
    MPX_FUNC("CMPXDbPlugin::RemoveFromPlaylistsL");

    switch (aPath.Levels())
        {
        case 3:
            {
            iDbHandler->RemovePlaylistL(aItemId.iId2, aUriArray, aItemChangedMessages);
            break;
            }
        case 4:
            {
            if ( !iDbHandler->InTransaction() )
                {
                iDbHandler->BeginTransactionL();
                }
            iDbHandler->RemoveSongFromPlaylistL(aPath.Id(aPath.Levels() - 2).iId2, aItemId,
                aIndex, aItemChangedMessages);
            break;
            }
        default:
            {
            User::Leave(KErrArgument);
            }
        }
    }

// ----------------------------------------------------------------------------
// Retrieve URIs associated with this file path for file deletion
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoRetrieveUriForDeletionL(
    CMPXCommand& aCmd)
    {
    MPX_FUNC("CMPXDbPlugin::DoRetrieveUriForDeletionL");

    // initialize mandatory return parameters
    aCmd.SetTObjectValueL<TInt>(KMPXCommandCollectionRetrieveUriError, KErrNone);

    if (!aCmd.IsSupported(KMPXCommandCollectionRetrievePath))
        {
        aCmd.SetTObjectValueL<TInt>(KMPXCommandCollectionRetrieveUriError, KErrArgument);
        }
    else
        {
        CMPXCollectionPath* path = aCmd.ValueCObjectL<CMPXCollectionPath>(KMPXCommandCollectionRetrievePath);
        CleanupStack::PushL(path);
        if (iFirstDeleteStep )
            {
            iSelections.Reset( );
        // in order to support cancel delete for a category, we need to adjust path. If
        // the path ends in a category, retrieve all songs under the selected category
        // and append a new level with all songs under the selected category
        DoAppendLevelL(*path);

        // Ids of the selected items
            path->SelectionL(iSelections );

        // single selection
            if (iSelections.Count()== 0 )
                {
                iSelections.AppendL(path->Id (path->Levels()- 1 ) );
                }
            }

        CDesCArray* fp = new(ELeave) CDesCArrayFlat(4);
        CleanupStack::PushL(fp);

        TInt count(iSelections.Count());
        TInt itemCount = count > KIncrementalDeleteCount ? KIncrementalDeleteCount : count;
        for (TInt i = 0; i < itemCount; ++i )
            {
            // do not report song URIs if collection path is for songs within a playlist, i.e.
            // EBrowsePlaylist and level 4, because client should not be deleting those song
            // files
            if (path->Id(1) != EBrowsePlaylist || path->Levels() !=4)
                {
                HBufC * uri = iDbHandler->GetUriMatchingIdL (iSelections[0].iId2 );
                CleanupStack::PushL(uri);
                fp->AppendL(*uri);
                CleanupStack::PopAndDestroy(uri);
                }
            iSelections.Remove(0);
            }

        aCmd.SetNoNewLCObjectL(KMPXCommandCollectionRetrieveMediaUriArray, fp);
        if (iFirstDeleteStep)
            {
        aCmd.SetCObjectValueL(KMPXCommandCollectionRetrievePath, path);
            }

        CleanupStack::PopAndDestroy(fp);
        CleanupStack::PopAndDestroy(path);
        }
    }

// ----------------------------------------------------------------------------
// Cleanup deleted records
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::CleanupDeletedRecordsL(
    CMPXCommand& aCmd)
    {
    MPX_FUNC("CMPXDbPlugin::CleanupDeletedRecordsL");

    MPX_TRAPD(error, iDbHandler->CleanupDeletedRecordsL());
    aCmd.SetTObjectValueL<TInt>(KMPXCommandCollectionCleanupError, error);
    }

// ----------------------------------------------------------------------------
// Find the duration
// ----------------------------------------------------------------------------
//
TInt CMPXDbPlugin::DoDurationL(
    CMPXMedia& aMedia,
    TMPXGeneralCategory aFirstCat,
    TMPXItemId aId,
    TMPXGeneralCategory aSecondCat,
    TMPXItemId aSubId)
    {
    MPX_FUNC("CMPXDbPlugin::DoDurationL");

    TInt duration(0);

    switch (aFirstCat)
        {
        case EMPXSong:
            {
            duration = iDbHandler->GetAllSongsDurationL();
            break;
            }
        case EMPXAlbum:
            {
            duration = iDbHandler->GetAlbumDurationL(aId.iId2);
            break;
            }
        case EMPXComposer:
            {
            duration = iDbHandler->GetComposerDurationL(aId.iId2);
            break;
            }
        case EMPXGenre:
            {
            duration = iDbHandler->GetGenreDurationL(aId.iId2);
            break;
            }
        case EMPXArtist:
            {
            if (aSecondCat == EMPXAlbum)
                {
                duration = iDbHandler->GetArtistAlbumDurationL(aId.iId2, aSubId.iId2);
                }
            else
                {
                duration = iDbHandler->GetArtistDurationL(aId.iId2);
                }
            break;
            }
        case EMPXPlaylist:
            {
            duration = iDbHandler->GetPlaylistDurationL(aId.iId2);
            break;
            }
        default:
            {
            User::Leave(KErrNotSupported);
            }
        }

    aMedia.SetTObjectValueL<TInt>(KMPXMediaGeneralDuration, duration);
    return duration;
    }

// ----------------------------------------------------------------------------
// Append a level to a collection path and set selection to the first item
// ----------------------------------------------------------------------------
//
TInt CMPXDbPlugin::DoAppendLevelL(
    CMPXCollectionPath& aPath,
    CMPXMedia& aMedia )
    {
    MPX_FUNC("CMPXDbPlugin::DoAppendLevelL");

    RArray<TMPXItemId> ids;
    CleanupClosePushL(ids);

    // Extract media array, and get all item ids
    //
    const CMPXMediaArray* mediaArray = aMedia.Value<CMPXMediaArray>(KMPXMediaArrayContents);
    if( !mediaArray )
        {
        User::Leave( KErrNoMemory );
        }

    TInt count(mediaArray->Count());
    if (count >= 0)
        {
        for (TInt i = 0; i < count; ++i)
            {
            TMPXItemId id = mediaArray->AtL(i)->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
            ids.AppendL(id);
            }

        // Put item id array into the path and select the first one
        aPath.AppendL(ids.Array());
        if (count > 0)
            {
            aPath.Set(0);
            }
        }

    CleanupStack::PopAndDestroy(&ids);
    return count;
    }

// ----------------------------------------------------------------------------
// Append a level to a collection path and set selection to all songs under the
// selected category/categories
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoAppendLevelL(
    CMPXCollectionPath& aPath)
    {
    MPX_FUNC("CMPXDbPlugin::DoAppendLevelL");

    TMPXItemId contextId(aPath.Id(1));
    TInt levels(aPath.Levels());

    if ((contextId == EBrowseAll) ||
        (contextId == EBrowsePlaylist))
        {
        return;
        }
    else if (levels == 3 || (levels == 4 && contextId == EBrowseArtist))
        {
        // retrieve songs in the selected category
        //
        CMPXMediaArray* songs = CMPXMediaArray::NewL();
        CleanupStack::PushL(songs);

        RArray<TMPXAttribute> attributes;
        CleanupClosePushL(attributes);
        attributes.AppendL(KMPXMediaGeneralId);

        // Ids of the selected items
        RArray<TMPXItemId> selections;
        CleanupClosePushL(selections);
        aPath.SelectionL(selections);

        // single selection
        if (selections.Count() == 0)
            {
            selections.AppendL(aPath.Id(aPath.Levels() - 1));
            }

        TInt count(selections.Count());

        // all songs for the selected artist
        if (contextId == EBrowseArtist && levels == 3)
            {
            for (TInt i = 0; i < count; ++i)
                {
                iDbHandler->GetSongsMatchingArtistL(selections[i].iId2, attributes.Array(), songs);
                }
            if (songs->Count())
                {
                aPath.AppendL(selections.Array());
                }
            }

        // all songs for the selected artist in the specified album
        else if ((contextId == EBrowseArtist) && (levels == 4))
            {
            for (TInt i = 0; i < count; ++i)
                {
                if (aPath.Id(2) == aPath.Id(3))
                    {
                    iDbHandler->GetSongsMatchingArtistL(aPath.Id(3).iId2,
                        attributes.Array(), songs);
                    }
                else
                    {
                    iDbHandler->GetSongsMatchingArtistAndAlbumL(aPath.Id(aPath.Levels() - 2),
                        selections[i].iId2, attributes.Array(), songs);
                    }
                }
            }

         // all songs for the selected album
        else if (contextId == EBrowseAlbum && levels == 3)
            {
            for (TInt i = 0; i < count; ++i)
                {
                iDbHandler->GetSongsMatchingAlbumL(selections[i], attributes.Array(), songs);
                }
            }

        // all songs for the selected genre
        else if (contextId == EBrowseGenre && levels == 3)
            {
            for (TInt i = 0; i < count; ++i)
                {
                iDbHandler->GetSongsMatchingGenreL(selections[i], attributes.Array(), songs);
                }
            }

        // all songs for the selected composer
        else if (contextId == EBrowseComposer && levels == 3)
            {
            for (TInt i = 0; i < count; ++i)
                {
                iDbHandler->GetSongsMatchingComposerL(selections[i], attributes.Array(), songs);
                }
            }
        else
            {
            // else do nothing
            }

        CleanupStack::PopAndDestroy(&selections);
        CleanupStack::PopAndDestroy(&attributes);

        // transform from CMPXMediaArray to RArray
        RArray<TMPXItemId> songIds;
        CleanupClosePushL(songIds);

        TInt songCount(songs->Count());
        for (TInt i = 0; i < songCount; ++i)
            {
            CMPXMedia* song = (*songs)[i];

            if (song->IsSupported(KMPXMediaGeneralId))
                {
                songIds.AppendL(song->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));
                }
            }

        // modify the collection path. append another level with all songs under the selected
        // category/categories selected
        songCount = songIds.Count();

        if (songCount)
            {
            aPath.ClearSelection();
            aPath.AppendL(songIds.Array());

            // select all
            for (TInt i = 0; i < songCount; ++i)
                {
                aPath.SelectL(songIds[i]);
                }
            }

        CleanupStack::PopAndDestroy(&songIds);
        CleanupStack::PopAndDestroy(songs);
        }
    else
        {
        // do nothing
        }
    }

// ----------------------------------------------------------------------------
// Execute an Add task step
// ----------------------------------------------------------------------------
//
TBool CMPXDbPlugin::DoAddAsyncL()
    {
    MPX_FUNC("CMPXDbPlugin::DoAddAsyncL");

    TBool done(EFalse);
    const CMPXMedia* task = (iActiveTask->GetCommand().Value<CMPXMedia>(KMPXCommandColAddMedia));
    if( !task )
        {
        User::Leave(KErrNoMemory);
        }

    CMPXMessageArray& msgArray = iActiveTask->GetChangeMessages();

    if (!task->IsSupported(KMPXMediaGeneralType))
        {
        User::Leave(KErrArgument);
        }

    // Group of items or a single item
    //
    if (task->ValueTObjectL<TMPXGeneralType>(KMPXMediaGeneralType) == EMPXGroup)
        {
        if (!task->IsSupported(KMPXMediaArrayContents))
            {
            User::Leave(KErrArgument);
            }

        CMPXMediaArray* ary = task->Value<CMPXMediaArray>(KMPXMediaArrayContents);
        User::LeaveIfNull(ary);
        TInt step( iActiveTask->GetStep() );
        DoAddItemL( *ary->AtL(step), msgArray );

        if (++step == ary->Count())
            {
            done = ETrue;
            }
        }
    else // type == EMPXItem
        {
        TUint32 item = DoAddItemL( *task, msgArray );
        iActiveTask->GetCommand().SetTObjectValueL<TMPXItemId>( KMPXCommandColAddRtnId, item);
        done = ETrue;
        }

    iActiveTask->SetVisibleChange(CMPXDbActiveTask::EAllVisible);
    return done;
    }

// ----------------------------------------------------------------------------
// Add an item to the collection
// ----------------------------------------------------------------------------
//
TUint32 CMPXDbPlugin::DoAddL(
    const CMPXMedia& aMedia)
    {
    MPX_FUNC("CMPXDbPlugin::DoAddL");

    if (!aMedia.IsSupported(KMPXMediaGeneralType))
        {
        User::Leave(KErrArgument);
        }

    TUint32 itemId(0);
    CMPXMessageArray* changeMsgAry = CMPXMessageArray::NewL();
    CleanupStack::PushL(changeMsgAry);

    // start a transaction here
    if (!iDbHandler->InTransaction())
        {
        iDbHandler->BeginTransactionL();
        }

    // Group of items
    if (aMedia.ValueTObjectL<TMPXGeneralType>(KMPXMediaGeneralType) == EMPXGroup)
        {
        CMPXMediaArray* array = aMedia.Value<CMPXMediaArray>(KMPXMediaArrayContents);
        User::LeaveIfNull( array );

        TInt count(array->Count());
        for (TInt i = 0; i < count; ++i)
            {
            // ETrue indicates we are batch committing the songs.
            // This parameter is only used for the use case of adding
            // thousands of songs at a time.
            DoAddItemL(*array->AtL(i), *changeMsgAry, ETrue);
            }
        }
    else // single item
        {
        itemId = DoAddItemL(aMedia, *changeMsgAry);
        }

    // end transaction here.
    iDbHandler->EndTransactionL(KErrNone);

    iActiveTask->SetVisibleChange(CMPXDbActiveTask::EAllVisible);
    DoHandleChangeL(changeMsgAry);
    CleanupStack::PopAndDestroy(changeMsgAry);

    return itemId;
    }

// ----------------------------------------------------------------------------------------------------------
// Add an item to the collection
// ----------------------------------------------------------------------------------------------------------
//
TUint32 CMPXDbPlugin::DoAddItemL(
    const CMPXMedia& aMedia,
    CMPXMessageArray& aMessageArray,
    TBool aBatchCommit)
    {
    MPX_FUNC("CMPXDbPlugin::DoAddItemL");

    TUint32 itemId(0);
    if (!aMedia.IsSupported(KMPXMediaGeneralCategory))
        {
        User::Leave(KErrArgument);
        }

    switch (aMedia.ValueTObjectL<TMPXGeneralCategory>(KMPXMediaGeneralCategory))
        {
        case EMPXPlaylist:
            {
            if (!aMedia.IsSupported(KMPXMediaArrayContents))
                {
                User::Leave(KErrArgument);
                }

            if (aMedia.IsSupported(KMPXMediaGeneralId))
                {
                itemId = iDbHandler->AddSongToPlaylistL(aMedia);
                MPXDbCommonUtil::AddItemChangedMessageL(aMessageArray, itemId, EMPXItemModified,
                    EMPXPlaylist, KDBPluginUid);
                }
            else if (aMedia.IsSupported(KMPXMediaGeneralUri))
                {
                itemId = iDbHandler->AddPlaylistL(aMedia);
                MPXDbCommonUtil::AddItemChangedMessageL(aMessageArray, EBrowsePlaylist, EMPXItemInserted,
                    EMPXPlaylist, KDBPluginUid);
                }
            else
                {
                User::Leave(KErrArgument);
                }
            }
            break;
#ifdef ABSTRACTAUDIOALBUM_INCLUDED
       case EMPXAbstractAlbum:
            {
            if (aMedia.IsSupported(KMPXMediaGeneralUri))
                {
                //add abstractalbum to AbstractAlbum table
                itemId = iDbHandler->AddAbstractAlbumL(aMedia, &aMessageArray);

                //in case aMedia as mediaArray which contains songs as arrayContents, need to update all songs associated
                if ( aMedia.IsSupported(KMPXMediaArrayContents))
                    {
                    iDbHandler->UpdateSongsAbstractAlbumInfoL(aMedia, aMessageArray);
                    }
                }
            else
                {
                User::Leave(KErrArgument);
                }
            }
            break;
#endif // ABSTRACTAUDIOALBUM_INCLUDED
        case EMPXSong:
            {
            // For the use case of adding thousands of songs at once,
            // we do not create a new database transaction for each song;
            // Instead DoAddL() will batch 100 songs under a single transaction.
            // This enhancement improves performance with MMC-based databases.
            if (aBatchCommit)
                {
                itemId = iDbHandler->AddSongWithNoTransactionL(aMedia, &aMessageArray);
                }
            else
                {
                itemId = iDbHandler->AddSongL(aMedia, &aMessageArray);
                }

            MPXDbCommonUtil::AddItemChangedMessageL(aMessageArray, itemId, EMPXItemInserted,
                EMPXSong, KDBPluginUid);
            }
            break;

        default:
            {
            User::Leave(KErrNotSupported);
            }
        }

    return itemId;
    }

// ----------------------------------------------------------------------------
// Update the collection from a media
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoSetL(
    const CMPXMedia& aMedia )
    {
    MPX_FUNC("CMPXDbPlugin::DoSetL");

    if (!aMedia.IsSupported(KMPXMediaGeneralType))
        {
        User::Leave(KErrArgument);
        }

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

    CMPXMessageArray* changeMsgArray = CMPXMessageArray::NewL();
    CleanupStack::PushL(changeMsgArray);

    if (aMedia.ValueTObjectL<TMPXGeneralType>(KMPXMediaGeneralType) == EMPXGroup)
        {
        if (!aMedia.IsSupported(KMPXMediaArrayContents))
            {
            User::Leave(KErrArgument);
            }

        CMPXMediaArray* array = aMedia.Value<CMPXMediaArray>(KMPXMediaArrayContents);
        User::LeaveIfNull( array );
        TInt count( array->Count() );
        for (TInt i = 0; i < count; ++i)
            {
            visibleChange = (CMPXDbActiveTask::TChangeVisibility)(visibleChange | DoSetItemL(*array->AtL(i), *changeMsgArray));
            }
        }
    else
        {
        visibleChange = DoSetItemL(aMedia, *changeMsgArray);
        }

    // Handle Change Events
    if (visibleChange)
        {
        iActiveTask->SetVisibleChange(visibleChange);
        DoHandleChangeL(changeMsgArray);
        }
    CleanupStack::PopAndDestroy(changeMsgArray);
    }

// ----------------------------------------------------------------------------
// Execute a task step for async set
// ----------------------------------------------------------------------------
//
TBool CMPXDbPlugin::DoSetAsyncL()
    {
    MPX_FUNC("CMPXDbPlugin::DoSetAsyncL");

    TBool done(EFalse);
    CMPXMedia* task = iActiveTask->GetCommand().Value<CMPXMedia>(KMPXCommandColSetMedia);
    User::LeaveIfNull( task );

    CMPXMessageArray& msgArray = iActiveTask->GetChangeMessages();
    CMPXDbActiveTask::TChangeVisibility visibleChange(iActiveTask->GetVisibleChange());

    // Multiple steps can be in a transaction for faster response
    if( !iDbHandler->InTransaction() )
        {
        iDbHandler->BeginTransactionL();
        }

    if (!task->IsSupported(KMPXMediaGeneralType))
        {
        User::Leave(KErrArgument);
        }

    if (task->ValueTObjectL<TMPXGeneralType>(KMPXMediaGeneralType) == EMPXGroup)
        {
        if (!task->IsSupported(KMPXMediaArrayContents))
            {
            User::Leave(KErrArgument);
            }

        // Multiple items
        CMPXMediaArray* array = task->Value<CMPXMediaArray>(KMPXMediaArrayContents);
        User::LeaveIfNull( array );
        TInt step = iActiveTask->GetStep();
        visibleChange = (CMPXDbActiveTask::TChangeVisibility)(visibleChange | DoSetItemL(*array->AtL(step), msgArray));

        if (++step == array->Count())
            {
            done = ETrue;
            }
        }
    else // Single item
        {
        visibleChange = DoSetItemL(*task, msgArray);
        done = ETrue;
        }
    iActiveTask->SetVisibleChange(visibleChange);
    return done;
    }

// ----------------------------------------------------------------------------
// Update the collection from a media
// ----------------------------------------------------------------------------
//
CMPXDbActiveTask::TChangeVisibility CMPXDbPlugin::DoSetItemL(
    const CMPXMedia& aMedia,
    CMPXMessageArray& aMessageArray )
    {
    MPX_FUNC("CMPXDbPlugin::DoSetItemL");

    TMPXGeneralCategory category = aMedia.ValueTObjectL<TMPXGeneralCategory>(KMPXMediaGeneralCategory);

    CMPXDbActiveTask::TChangeVisibility visibleChange(CMPXDbActiveTask::ENotVisibile);
    switch (category)
        {
        case EMPXPlaylist:
            {
            if (aMedia.IsSupported(KMPXMediaArrayContents))
                {
                CMPXMessage* message = CMPXMedia::NewL();
                CleanupStack::PushL(message);

                iDbHandler->UpdatePlaylistSongsL(aMedia, *message);

                aMessageArray.AppendL(message); // ownership xfer
                CleanupStack::Pop(message);
                }
            else
                {
                iDbHandler->UpdatePlaylistL(aMedia, aMessageArray);
                }

            visibleChange = CMPXDbActiveTask::ESingleVisible;
            }
            break;
#ifdef ABSTRACTAUDIOALBUM_INCLUDED
        case EMPXAbstractAlbum:
            {
            //update all songes which associate with ABSTRACTALBUM
            if (aMedia.IsSupported(KMPXMediaGeneralUri))
                {
                //in case aMedia as mediaArray which contains songs as arrayContents, need to update all songs associated
                if ( aMedia.IsSupported(KMPXMediaArrayContents))
                    {
                    iDbHandler->UpdateSongsAbstractAlbumInfoL(aMedia, aMessageArray);
                    }
                //only update field values in abstractalbum table, or renaming (change uri) for abstractalbum table
                else
                    {
                    visibleChange = iDbHandler->UpdateAbstractAlbumL(aMedia, aMessageArray);
                    }
                }
            }
            break;
#endif // ABSTRACTAUDIOALBUM_INCLUDED
        case EMPXSong:
            {
            // a list of changed messages as a result of the song being updated
            visibleChange = iDbHandler->UpdateSongL(aMedia, aMessageArray);
            }
            break;

        default:
            {
            User::Leave(KErrNotSupported);
            }
            break;
        }
    return visibleChange; // ownership xfer
    }

// ----------------------------------------------------------------------------
// Sets the drm properties for a list of medias
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoSetDrmForArrayL(
    const CMPXMediaArray& mediaArray,
    const TArray<TMPXAttribute>& aAttrs)
    {
    MPX_FUNC("CMPXDbPlugin::DoSetDrmForArrayL");

    TUint drmAttributes(0);

    // Compact the attribute set
    //
    TInt attrCount(aAttrs.Count());
    for (TInt i = 0; i < attrCount; ++i)
        {
        if (aAttrs[i].ContentId() == KMPXMediaIdDrm)
            {
            drmAttributes |= aAttrs[i].AttributeId();
            }
        }

    // Fetch drm attributes for every item
    //
    if (drmAttributes)
        {
        TInt count(mediaArray.Count());
        for (TInt i = 0; i < count; ++i)
            {
            if (mediaArray[i]->IsSupported(KMPXMediaGeneralUri))
                {
                DoSetMediaDrmL(*mediaArray[i], drmAttributes,
                    mediaArray[i]->ValueText(KMPXMediaGeneralUri));
                }
            }
        }
    }

// ----------------------------------------------------------------------------
// Handle change events
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::HandleChangeL(
    const CMPXMessage& aMessage)
    {
    MPX_FUNC("CMPXDbPlugin::HandleChange");

    // check if message is filled
    if (aMessage.IsSupported(KMPXMessageGeneralId))
        {
#if _DEBUG
        PrintMessagesL(aMessage);
#endif // _DEBUG
        if(iRefreshing)
            {
            if (aMessage.IsSupported(KMPXMessageArrayContents))
                {
                const CMPXMessageArray* messageArray = aMessage.Value<CMPXMessageArray>(KMPXMessageArrayContents);
                if(messageArray)
                    {
                    CMPXMessage& message = *((*messageArray)[0]);
                    TMPXChangeEventType changeType( message.ValueTObjectL<TMPXChangeEventType>( KMPXMessageChangeEventType ) );
                    TMPXGeneralCategory cat(message.ValueTObjectL<TMPXGeneralCategory>(KMPXMessageMediaGeneralCategory));
                    if(changeType == EMPXItemInserted && (cat == EMPXSong || cat == EMPXPlaylist || cat == EMPXPodcast))
                        {
                        iObs->HandleMessage(aMessage);
                        }
                    }
                }
            else
                {
                TMPXChangeEventType changeType( aMessage.ValueTObjectL<TMPXChangeEventType>( KMPXMessageChangeEventType ) );
                TMPXGeneralCategory cat(aMessage.ValueTObjectL<TMPXGeneralCategory>(KMPXMessageMediaGeneralCategory));
                if(changeType == EMPXItemInserted && (cat == EMPXSong || cat == EMPXPlaylist || cat == EMPXPodcast))
                    {
                    iObs->HandleMessage(aMessage);
                    }
                }
            }
        else
            {
            if(!iMtpInUse)
                {
                iObs->HandleMessage(aMessage);
                }
            }
        }
    }

// ----------------------------------------------------------------------------
// Construct a CMPXMedia and call HandleChange
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoHandleChangeL(
    CMPXMessageArray* aItemChangedMessages,
    TMPXCommandId aCommandId )
    {
    MPX_FUNC("CMPXDbPlugin::DoHandleChangeL");

    if( (iActiveTask->GetVisibleChange() & CMPXDbActiveTask::EAllVisible)
        && (aCommandId == KMPXCommandIdCollectionSet ||
            aCommandId == KMPXCommandIdCollectionAdd ||
            aCommandId == KMPXCommandIdCollectionRemove ||
            aCommandId == KMPXCommandIdCollectionCompleteDelete ))
        {
        MPXDbCommonUtil::AddItemChangedMessageL(*aItemChangedMessages, EBrowseAll,
                                                 EMPXItemModified, EMPXCollection, KDBPluginUid);
        }
    // group change messages and send to collection client context
    //
    CMPXMessage* message = CMPXMessage::NewL();
    CleanupStack::PushL(message);

    message->SetTObjectValueL<TMPXMessageId>(KMPXMessageGeneralId, KMPXMessageIdItemChanged);
    message->SetCObjectValueL(KMPXMessageArrayContents, aItemChangedMessages);
    message->SetTObjectValueL<TInt>(KMPXMessageArrayCount, aItemChangedMessages->Count());

    HandleChangeL(*message);

    CleanupStack::PopAndDestroy(message);
    }

// ----------------------------------------------------------------------------
// Handle completion of operation
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::DoHandleOperationCompletedL(
    TInt aErr)
    {
    MPX_FUNC("CMPXDbPlugin::DoHandleOperationCompletedL");

    // Broadcase change messages
    //
    if (iActiveTask->GetVisibleChange())
        {
        DoHandleChangeL(&iActiveTask->GetChangeMessages(), iActiveTask->GetTask() );
        }

    // Callback to engine to signal completion
    // NOTE: Collection server immediately completes the async message when
    // Cancel is called, no need to callback to observer
    if (aErr != KErrCancel)
        {
        if( iActiveTask->GetTask() == KMPXCommandIdCollectionAdd )
            {
            iObs->HandleCommandComplete( &iActiveTask->GetCommand(), aErr );
            }
        else
            {
            iObs->HandleCommandComplete(NULL, aErr);
            }
        }

    if( iDbHandler->InTransaction() )
        {
        // Commit if cancelled
        TInt err(aErr);
        if( err == KErrCancel )
            {
            err = KErrNone;
            }
        iDbHandler->EndTransactionL( err );
        }
    }

// ----------------------------------------------------------------------------------------------------------
// Complete a delete operation
// ----------------------------------------------------------------------------------------------------------
//
void CMPXDbPlugin::DoHandleDeleteCompleteL(
    CMPXCommand& aCmd)
    {
    MPX_FUNC("CMPXDbPlugin::DoHandleDeleteCompleteL");
    iFirstDeleteStep = ETrue;
    iSelections.Reset();
    if ( iDbHandler->InTransaction() )
        {
        // if it can reach this point in a transaction, there's no error
        iDbHandler->EndTransactionL( KErrNone );
        }

    // Change messages
    if (aCmd.IsSupported(KMPXCommandCollectionDeleteMsgArray))
        {
        CMPXMessageArray* msgs = aCmd.Value<CMPXMessageArray>(KMPXCommandCollectionDeleteMsgArray);
        User::LeaveIfNull( msgs );
        iActiveTask->SetVisibleChange(CMPXDbActiveTask::EAllVisible);
        DoHandleChangeL(msgs, KMPXCommandIdCollectionCompleteDelete);
        }
    }

// ----------------------------------------------------------------------------------------------------------
// Reorder a song in a playlist
// ----------------------------------------------------------------------------------------------------------
//
void CMPXDbPlugin::DoReorderPlaylistL(
    const CMPXCommand& aCmd)
    {
    MPX_FUNC("CMPXDbPlugin::DoReorderPlaylistL");

    if (!aCmd.IsSupported(KMPXCommandReorderPlaylistId) ||
        !aCmd.IsSupported(KMPXCommandReorderSongId) ||
        !aCmd.IsSupported(KMPXCommandReorderOriginalOrdinal) ||
        !aCmd.IsSupported(KMPXCommandReorderNewOrdinal))
        {
        User::Leave(KErrArgument);
        }

    CMPXMessage* message = CMPXMedia::NewL();
    CleanupStack::PushL(message);

    iDbHandler->ReorderPlaylistL(
        aCmd.ValueTObjectL<TMPXItemId>(KMPXCommandReorderPlaylistId),
        aCmd.ValueTObjectL<TMPXItemId>(KMPXCommandReorderSongId),
        aCmd.ValueTObjectL<TUint>(KMPXCommandReorderOriginalOrdinal),
        aCmd.ValueTObjectL<TUint>(KMPXCommandReorderNewOrdinal),
        *message);

    HandleChangeL(*message);

    CleanupStack::PopAndDestroy(message);
    }

// ----------------------------------------------------------------------------------------------------------
// Get total songs and playlists count for a database
// ----------------------------------------------------------------------------------------------------------
//
void CMPXDbPlugin::DoGetCollectionCountL( const CMPXCommand& aCmd )
    {
    MPX_FUNC("CMPXDbPlugin::DoGetCollectionCountL");
    if (!aCmd.IsSupported(KMPXCommandCollectionCountDrive) ||
        !aCmd.IsSupported(KMPXCommandCollectionCountTable) )
        {
        User::Leave(KErrArgument);
        }

    TInt count = 0;
    TInt drive = aCmd.ValueTObjectL<TInt>(KMPXCommandCollectionCountDrive);
    TInt table = aCmd.ValueTObjectL<TInt>(KMPXCommandCollectionCountTable);
    switch(table)
        {
        case EMPXCollectionCountTrack:
            count = (TInt)iDbHandler->GetMusicCountL(drive);
            break;
        case EMPXCollectionCountPlaylist:
            count = (TInt)iDbHandler->GetPlaylistCountL(drive);
            break;
        case EMPXCollectionCountTotal:
            count = (TInt)iDbHandler->GetTotalCountL(drive);
            break;
        default:
            User::Leave(KErrArgument);
        }
    ((CMPXMedia&)aCmd).SetTObjectValueL<TInt>(KMPXCommandCollectionCountValue, count);
    }

// ----------------------------------------------------------------------------------------------------------
// Get URIs for all songs and file playlists in a database
// ----------------------------------------------------------------------------------------------------------
//
void CMPXDbPlugin::DoGetCollectionUriL( const CMPXCommand& aCmd )
    {
    MPX_FUNC("CMPXDbPlugin::DoGetCollectionCountL");
    if (!aCmd.IsSupported(KMPXCommandCollectionURIDrive) ||
        !aCmd.IsSupported(KMPXCommandCollectionURITable) ||
        !aCmd.IsSupported(KMPXCommandCollectionURIFromID) ||
        !aCmd.IsSupported(KMPXCommandCollectionURIRecords) )
        {
        User::Leave(KErrArgument);
        }

    TInt drive = aCmd.ValueTObjectL<TInt>(KMPXCommandCollectionURIDrive);
    TInt table = aCmd.ValueTObjectL<TInt>(KMPXCommandCollectionURITable);
    TInt fromID = aCmd.ValueTObjectL<TInt>(KMPXCommandCollectionURIFromID);
    TInt recnum = aCmd.ValueTObjectL<TInt>(KMPXCommandCollectionURIRecords);

    CDesCArray* uris = new(ELeave) CDesCArrayFlat(4);
    CleanupStack::PushL(uris);
    TInt lastID = 0;

    switch(table)
        {
        case EMPXCollectionURITrack:
            iDbHandler->GetMusicUriArrayL(drive, fromID, recnum, *uris, lastID);
            break;
        case EMPXCollectionURIPlaylist:
            iDbHandler->GetPlaylistUriArrayL(drive, fromID, recnum, *uris, lastID);
            break;
        default:
            User::Leave(KErrArgument);
        }

    ((CMPXMedia&)aCmd).SetNoNewLCObjectL(KMPXCommandCollectionURIList, uris);
    ((CMPXMedia&)aCmd).SetTObjectValueL(KMPXCommandCollectionURILastID, lastID);
    CleanupStack::PopAndDestroy(uris);
    }


// ----------------------------------------------------------------------------------------------------------
// Perform one step of the incremental operation
// ----------------------------------------------------------------------------------------------------------
//
void CMPXDbPlugin::DoIncrementalOpenL( const CMPXCommand& aCmd )
    {
    MPX_DEBUG1("CMPXDbPlugin::DoIncrementalOpenL <--");

    TInt offset = aCmd.ValueTObjectL<TInt>( KMPXCollectionCommandIdIncOpenLOffset );
    TInt numItems = aCmd.ValueTObjectL<TInt>( KMPXCollectionCommandIdIncOpenLNumItems );

    TReadDirection direction(EReadUnknown);
/*  Ascending and Decending reads are currently not used. We optimized for offset reads.
    if( aCmd.IsSupported(KMPXCollectionCommandIdIncOpenLAscDsc) &&
        aCmd.IsSupported(KMPXCollectionCommandIdIncOpenLKeyItem) )
        {
        direction = aCmd.ValueTObjectL<TReadDirection>(KMPXCollectionCommandIdIncOpenLAscDsc);
        }
*/
    CMPXCollectionPath* path =  aCmd.ValueCObjectL<CMPXCollectionPath>(KMPXCollectionCommandIdIncOpenLPath);
    CleanupStack::PushL( path );
    MPX_DEBUG_PATH( *path );

    // Switch on level and item selected
    //
    TInt levels( path->Levels() );
    switch( levels )
        {
        case 3:  // levels of 3 top level is not stripped
            {
            switch( path->Id(1).iId2 )
                {
                case EBrowseAll:
                    {
                    CMPXMedia* results = CMPXMedia::NewL();
                    CleanupStack::PushL( results );

                    TMPXOpenDataBlock block;
                    block.iOffset = offset;
                    block.iSize = numItems;

                    // Todo: this should come from the UI
                    RArray<TMPXAttribute> attrs;
                    CleanupClosePushL( attrs );
                    attrs.AppendL(TMPXAttribute(KMPXMediaIdGeneral,
                                   EMPXMediaGeneralId | EMPXMediaGeneralType | EMPXMediaGeneralCategory |
                                   EMPXMediaGeneralTitle | EMPXMediaGeneralFlags));
                    attrs.AppendL( TMPXAttribute(KMPXMediaIdMusic,
                                        EMPXMediaMusicArtist | EMPXMediaMusicAlbumArtFileName ) );

                    // Array to read data from
                    CMPXMediaArray* array = CMPXMediaArray::NewL();
                    CleanupStack::PushL( array );

                    // Do we have to use offset or can we use asc/dsc
                    //
                    if( direction == EReadUnknown )
                        {
                        iDbHandler->GetSongsAtOffsetL( array, attrs.Array(), offset, numItems );
                        }
                    else
                        {
                        iDbHandler->GetSongsInBlockL( array, attrs.Array(),
                                                      aCmd.ValueText( KMPXCollectionCommandIdIncOpenLKeyItem ),
                                                      numItems,
                                                      direction );
                        }

                    TInt max( path->Count() );
                    TInt count(0);
                    TInt aryCount( array->Count() );
                    // Update the collection path
                    while( count<numItems && offset<max &&
                           count<aryCount )
                        {
                        TMPXItemId id = array->AtL(count)->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );
                        path->Update( offset, id );

                        // Next items
                        offset++;
                        count++;
                        }

                    // Setup the results
                    //
                    results->SetCObjectValueL(KMPXMediaArrayContents, array);
                    results->SetTObjectValueL<TInt>(KMPXMediaArrayCount, array->Count());
                    CleanupStack::PopAndDestroy( array );
                    CleanupStack::PopAndDestroy( &attrs );

                    // Callback with results
                    //
                    results->SetTObjectValueL<TMPXOpenDataBlock>( KMPXCollectionOpenLResultRange, block );
                    iObs->HandleOpen( results, path, KErrNone );
                    CleanupStack::PopAndDestroy( results );
                    break;
                    }
                default:
                    User::Leave(KErrNotSupported);
                    break;
                }
            break;
            }
        default:
            {
            User::Leave(KErrNotSupported);
            break;
            }

        }
    CleanupStack::PopAndDestroy( path );

    MPX_DEBUG1("CMPXDbPlugin::DoIncrementalOpenL -->");
    }

// ----------------------------------------------------------------------------
// Maps a given browse type to a category ID.
// ----------------------------------------------------------------------------
//
TMPXGeneralCategory CMPXDbPlugin::CategoryForBrowseType(
    TMCBrowseType aBrowseType)
    {
    MPX_FUNC("CMPXDbPlugin::CategoryForBrowseType");

    TMPXGeneralCategory cat(EMPXNoCategory);

    switch (aBrowseType)
        {
        case EBrowseAll:
            {
            cat = EMPXSong;
            break;
            }
        case EBrowseArtist:
            {
            cat = EMPXArtist;
            break;
            }
        case EBrowseAlbum:
            {
            cat = EMPXAlbum;
            break;
            }
        case EBrowsePlaylist:
            {
            cat = EMPXPlaylist;
            break;
            }
        case EBrowseGenre:
            {
            cat = EMPXGenre;
            break;
            }
        case EBrowseComposer:
            {
            cat = EMPXComposer;
            break;
            }
#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
        case EBrowsePodcasts:
            {
            cat = EMPXPodcast;
            break;
            }
#endif
        default:
            {
            // do nothing
            break;
            }
        }

    return cat;
    }

// ----------------------------------------------------------------------------
// Maps a given category ID to a browse type.
// ----------------------------------------------------------------------------
//
TMCBrowseType CMPXDbPlugin::BrowseTypeForCategory(
    TMPXGeneralCategory aCategory)
    {
    MPX_FUNC("CMPXDbPlugin::BrowseTypeForCategory");

    TMCBrowseType browseType(EBrowseComposer);

    switch (aCategory)
        {
        case EMPXSong:
            {
            browseType = EBrowseAll;
            break;
            }
        case EMPXArtist:
            {
            browseType = EBrowseArtist;
            break;
            }
        case EMPXAlbum:
            {
            browseType = EBrowseAlbum;
            break;
            }
        case EMPXPlaylist:
            {
            browseType = EBrowsePlaylist;
            break;
            }
        case EMPXGenre:
            {
            browseType = EBrowseGenre;
            break;
            }
        default:
            {
            // do nothing
            break;
            }
        }

    return browseType;
    }

// ----------------------------------------------------------------------------
// Sets the type, category and title attributes in the specified media instance
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::SetMediaGeneralAttributesL(
    CMPXMedia& aMedia,
    TMPXGeneralType aType,
    TMPXGeneralCategory aCategory,
    const TDesC& aTitle)
    {
    aMedia.SetTObjectValueL<TMPXGeneralType>(KMPXMediaGeneralType, aType);
    aMedia.SetTObjectValueL<TMPXGeneralCategory>(KMPXMediaGeneralCategory, aCategory);
    aMedia.SetTextValueL(KMPXMediaGeneralTitle, aTitle);
    }

// ----------------------------------------------------------------------------
// Sets the type, category and title attributes in the specified media instance
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::SetMediaGeneralAttributesL(
    CMPXMedia& aMedia,
    TMPXGeneralType aType,
    TMPXGeneralCategory aCategory,
    TInt aId)
    {
    MPX_FUNC("CMPXDbPlugin::SetMediaGeneralAttributesL");

    HBufC* title = iDbHandler->GetNameMatchingIdL(aId);
    CleanupStack::PushL(title);
    SetMediaGeneralAttributesL(aMedia, aType, aCategory, *title);
    CleanupStack::PopAndDestroy(title);
    }

// ----------------------------------------------------------------------------
// Set the attribute list according to current path
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::SetAttributesL(
    const CMPXCollectionPath& aPath,
    RArray<TMPXAttribute>& aAttrs,
    RArray<TInt>& aSupportedIds )
    {
    aAttrs.AppendL( TMPXAttribute(KMPXMediaIdGeneral,
        EMPXMediaGeneralId | EMPXMediaGeneralType | EMPXMediaGeneralCategory |
        EMPXMediaGeneralTitle | EMPXMediaGeneralFlags) );

    aSupportedIds.AppendL(KMPXMediaIdContainer);
    aSupportedIds.AppendL(KMPXMediaIdGeneral);

    TInt levels(aPath.Levels());
    if ( 2 == levels )
        {
        // check the browse type
        switch ( aPath.Id(1).iId2 )
            {
            case EBrowseAll:
                {
                aAttrs.AppendL( TMPXAttribute(KMPXMediaIdMusic,
                    EMPXMediaMusicArtist | EMPXMediaMusicAlbumArtFileName ) );
                aSupportedIds.AppendL( KMPXMediaIdMusic );
                break;
                }
            case EBrowseArtist:
                {
                aAttrs.AppendL( TMPXAttribute(KMPXMediaIdGeneral, EMPXMediaGeneralCount) );
                aAttrs.AppendL( TMPXAttribute(KMPXMediaIdMusic,
                                    EMPXMediaMusicAlbumArtFileName ) );
                break;
                }
            case EBrowseAlbum:
                {
                aAttrs.AppendL( TMPXAttribute(KMPXMediaIdMusic,
                    EMPXMediaMusicArtist | EMPXMediaMusicAlbum | EMPXMediaMusicAlbumArtFileName ) );
                aSupportedIds.AppendL( KMPXMediaIdMusic );
                break;
                }
            case EBrowsePlaylist:
                {
                aAttrs.AppendL( TMPXAttribute(KMPXMediaIdGeneral,
                    EMPXMediaGeneralCount | EMPXMediaGeneralDuration ) );
                break;
                }
            case EBrowseGenre:
                {
                aAttrs.AppendL( TMPXAttribute(KMPXMediaIdGeneral, EMPXMediaGeneralCount) );
                break;
                }
            case EBrowseComposer:
                {
                aAttrs.AppendL( TMPXAttribute(KMPXMediaIdGeneral, EMPXMediaGeneralCount) );
                break;
                }
            default:
                {
                User::Leave(KErrArgument);
                }
            }
        }
    else if ( 3 == levels )
        {
        // check the browse type
        switch ( aPath.Id(1).iId2 )
            {
            case EBrowseArtist:
                {
                aAttrs.AppendL( TMPXAttribute(KMPXMediaIdGeneral, EMPXMediaGeneralCount) );
                aAttrs.AppendL( TMPXAttribute(KMPXMediaIdMusic, EMPXMediaMusicAlbumArtFileName ) );
                aSupportedIds.AppendL( KMPXMediaIdMusic );
                break;
                }
            case EBrowseAlbum:
                {

                aAttrs.AppendL( TMPXAttribute(KMPXMediaIdMusic,
                    EMPXMediaMusicArtist | EMPXMediaMusicAlbum | EMPXMediaMusicAlbumArtFileName ) );
                aSupportedIds.AppendL( KMPXMediaIdMusic );
                break;
                }
            case EBrowsePlaylist:
            case EBrowseGenre:
            case EBrowseComposer:
                {
                aAttrs.AppendL( TMPXAttribute(KMPXMediaIdMusic,
//                    EMPXMediaMusicArtist | EMPXMediaMusicAlbumArtFileName ) );
                //added ganes
                    EMPXMediaMusicArtist | EMPXMediaMusicAlbumArtFileName | EMPXMediaMusicAlbum) );
                aSupportedIds.AppendL( KMPXMediaIdMusic );
                break;
                }
            }
        }
    else if ( (4 == levels) && (aPath.Id(1).iId2 == EBrowseArtist) )
        {
        aAttrs.AppendL( TMPXAttribute(KMPXMediaIdMusic,
            EMPXMediaMusicArtist | EMPXMediaMusicAlbum | EMPXMediaMusicAlbumArtFileName ) );
        aSupportedIds.AppendL( KMPXMediaIdMusic );
        }
    }

#ifdef _DEBUG
// ----------------------------------------------------------------------------
// Print change events
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::PrintMessagesL(
    const CMPXMessage& aMessage)
    {
    MPX_FUNC("CMPXDbPlugin::PrintMessages");

    if (aMessage.IsSupported(KMPXMessageArrayContents))
        {
        const CMPXMessageArray* messageArray =
            aMessage.Value<CMPXMessageArray>(KMPXMessageArrayContents);
        if( !messageArray )
            {
            User::Leave( KErrNoMemory );
            }

        TInt count(messageArray->Count());
        MPX_DEBUG2("%d messages:", count);

        for (TInt i = 0; i < count; ++i)
            {
            PrintMessage(*((*messageArray)[i]));
            }
        }
    else
        {
        PrintMessage(aMessage);
        }
    }

// ----------------------------------------------------------------------------
// Print one change event
// ----------------------------------------------------------------------------
//
void CMPXDbPlugin::PrintMessage(
    const CMPXMessage& aMessage)
    {
    MPX_FUNC("CMPXDbPlugin::PrintMessage");

    if (aMessage.IsSupported(KMPXMessageGeneralId))
        {
        TMPXItemId id = aMessage.ValueTObjectL<TMPXItemId>(KMPXMessageGeneralId);
        MPX_DEBUG3("    message id[0x%x, 0x%x]", id.iId1, id.iId2);
        }

    if (aMessage.IsSupported(KMPXMessageCollectionId))
        {
        TUid uid = aMessage.ValueTObjectL<TUid>(KMPXMessageCollectionId);
        MPX_DEBUG2("    uid [0x%x]", uid.iUid);
        }

    if (aMessage.IsSupported(KMPXMessageChangeEventType))
        {
        MPX_DEBUG2("    change event type [%d]",
            aMessage.ValueTObjectL<TMPXChangeEventType>(KMPXMessageChangeEventType));
        }

    if (aMessage.IsSupported(KMPXMessageMediaGeneralCategory))
        {
        MPX_DEBUG2("    category [%d]",
            aMessage.ValueTObjectL<TMPXGeneralCategory>(KMPXMessageMediaGeneralCategory));
        }

    if (aMessage.IsSupported(KMPXMessageMediaGeneralId))
        {
        TMPXItemId id = aMessage.ValueTObjectL<TMPXItemId>(KMPXMessageMediaGeneralId);
        MPX_DEBUG3("    media id[0x%x, 0x%x]", id.iId1, id.iId2);
        }

    if (aMessage.IsSupported(KMPXMessageMediaDeprecatedId))
        {
        TMPXItemId id = aMessage.ValueTObjectL<TMPXItemId>(KMPXMessageMediaDeprecatedId);
        MPX_DEBUG3("    deprecated id [0x%x, 0x%x]", id.iId1, id.iId2);
        }
    }

#endif// _DEBUG

// End of file
