/*

* 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:  Extended collection helper with an internal caching array

*  Version     : %version: da1mmcf#27.1.12 % 

*

*/

#include <e32base.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxmediamtpdefs.h>

#include <mpxcollectionutility.h>

#include <mpxharvesterutility.h>

#include <mpxlog.h>

#include "mpxcollectioncachedhelper.h"

#include "mpxcollectionhelpercommon.h"

#include <mpxmetadataextractor.h>

// CONSTANTS

const TInt KCacheCount = 10;

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

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

// Constructor

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

//

CMPXCollectionCachedHelper::CMPXCollectionCachedHelper() :

#ifdef RD_MPX_COLLECTION_CACHE

    CMPXCollectionHelperImp(EFalse),iNotInCache(ETrue), iHitFoundMedia(0),

    iNotHitInCache(0), iLookingInCache(0),iLookingInUnknowCache(0),

#endif //RD_MPX_COLLECTION_CACHE

    iMetadataExtractor(NULL)

    {

    }

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

// 2nd Phase Constructor

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

//

void CMPXCollectionCachedHelper::ConstructL()

    {

    MPX_DEBUG1("CMPXCollectionCachedHelper::ConstructL <--");

    iCache = CMPXMediaArray::NewL();

    CMPXCollectionHelperImp::ConstructL();

#ifdef RD_MPX_COLLECTION_CACHE

    MPX_DEBUG1("CMPXCollectionCachedHelper::ConstructL Todd advancedcache");

    // cache for unknown artist

    TMPXItemId artistId = NULL;

    TRAPD(err, artistId = GetArtistIdL( KNullDesC(), iMusicCollectionId ));

    if ( err || artistId == (TMPXItemId)0 )

        {

        MPX_DEBUG2("CMPXCollectionCachedHelper::ConstructL no known artist id %d", err);

        }

    else

        {

        // Get songs that belong to the unknown artist

        GetSongsL( artistId, iMusicCollectionId, ETrue );

        }

#endif //RD_MPX_COLLECTION_CACHE

    User::LeaveIfError( iFs.Connect() );

    User::LeaveIfError( iAppArc.Connect() );

    iMetadataExtractor = CMPXMetadataExtractor::NewL( iFs, iAppArc, iSupportedTypes);

    MPX_DEBUG1("CMPXCollectionCachedHelper::ConstructL -->");

    }

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

// Two-Phased Constructor

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

//

CMPXCollectionCachedHelper* CMPXCollectionCachedHelper::NewL()

    {

    CMPXCollectionCachedHelper* self = CMPXCollectionCachedHelper::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-Phased Constructor

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

//

CMPXCollectionCachedHelper* CMPXCollectionCachedHelper::NewLC()

    {

    CMPXCollectionCachedHelper* self = new( ELeave ) CMPXCollectionCachedHelper();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CMPXCollectionCachedHelper::~CMPXCollectionCachedHelper()

    {

    Commit();

    delete iFoundMedia;

#ifdef RD_MPX_COLLECTION_CACHE

    if ( iCachedArtistArray )

        {

        delete iCachedArtistArray;

        }

    if ( iCachedUnknownArtistArray )

        {

        delete iCachedUnknownArtistArray;

        }

#endif //RD_MPX_COLLECTION_CACHE

    delete iCache;

    iOp.Close();

    if (iMetadataExtractor)

        {

        delete iMetadataExtractor;

        }

    iFs.Close();

    iAppArc.Close();

    iSupportedTypes.ResetAndDestroy();

    }

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

// Add a media object

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

//

void CMPXCollectionCachedHelper::AddL( CMPXMedia* aMedia )

    {

    MPX_FUNC("CMPXCollectionCachedHelper::::AddL");    

    // Commit when we have cached more than a set amount

    //

    if( iCache->Count() >= KCacheCount)

        {

        Commit();

        }

    // Extract album art from the file

    iMetadataExtractor->ExtractAlbumArtL( aMedia );

    CMPXMedia* copy = CMPXMedia::NewL( *aMedia );

    CleanupStack::PushL( copy );

    iCache->AppendL( copy );  // ownership x-fer

    CleanupStack::Pop( copy );

    iOp.AppendL( EAdd );

    }

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

// Remove a media object

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

//

void CMPXCollectionCachedHelper::RemoveL( const TDesC& aFile, 

                                          TMPXGeneralCategory aItemCat )

    {

    MPX_FUNC("CMPXCollectionCachedHelper::RemoveL");

    MPX_DEBUG3("aFile %S, category %d", &aFile, aItemCat);

    Commit();

    ::InitializeCollectionPluginsL( *iCollectionUtil );

    //

    // ask harvester to remove the file if any of the following is true:

    // 1) removing a song

    // 2) removing a playlist scanned through file system.

    //

    //    There are 3 types of playlists. The ones created from the device

    //    are virtual playlists which have file extension .vir. There are

    //    no physical playlist files associated with them; hence not

    //    registered with harvester. For virtual playlists, IsPlaylistL

    //    will return EFalse because there is not a playlist plugin that

    //    deals with .vir playlist files.

    //

    //    The ones synced from PC through MTP have file extension .pla.

    //    There are 0-byte .pla files associated with them but they

    //    are not registered with harvester either. IsPlaylistL will also

    //    return EFalse because there is not a playlist plugin that deals

    //    with .pla.

    //

    //    The 3rd type of playlists is .m3u on the file system. They are

    //    added to the collection through file scan and registered with

    //    harvester. IsPlaylistL will return ETrue.

    //

    //    For now virtual playlists and synced playlists are assumed to

    //    be in the music collection for now until there is a generic way

    //    resolving collections aside from using file extension or UID.

    //

    TInt collection(iMusicCollectionId.iUid);

    if (aItemCat == EMPXSong || iHvsUtility->IsPlaylistL(aFile))

        {

        // Remove from the harvester

        collection = iHvsUtility->RemoveFileL( aFile );

        }

    // Remove from the collection

    // Construct a CMPXMedia object with URI and collection

    //

    RArray<TInt> contID;

    CleanupClosePushL( contID );

    contID.AppendL( KMPXMediaIdGeneral );

    CMPXMedia* media = CMPXMedia::NewL( contID.Array() );

    CleanupStack::PopAndDestroy(&contID);

    CleanupStack::PushL( media );

    media->SetTextValueL( KMPXMediaGeneralUri, aFile );

    media->SetTObjectValueL<TUid>( KMPXMediaGeneralCollectionId, TUid::Uid( collection ) );

    media->SetTObjectValueL( KMPXMediaGeneralType, EMPXItem );

    media->SetTObjectValueL( KMPXMediaGeneralCategory, aItemCat );

    // set up remove media command

    CMPXCommand* command = CMPXMedia::NewL();

    CleanupStack::PushL(command);

    command->SetTObjectValueL<TMPXCommandId>(

        KMPXCommandGeneralId, KMPXCommandIdCollectionRemoveMedia);

    command->SetTObjectValueL<TBool>(

        KMPXCommandGeneralDoSync, ETrue);

    command->SetTObjectValueL<TInt>(

        KMPXCommandGeneralCollectionId, collection);

    command->SetCObjectValueL(

        TMPXAttribute(KMPXCommandIdCollectionRemoveMedia, EMPXCommandCollectionRemoveMedia), 

        media);   

    command->SetTObjectValueL<TBool>(

        TMPXAttribute(KMPXCommandIdCollectionRemoveMedia, EMPXCommandCollectionRemoveMediaDeleteRecord), ETrue);         

    // send sync remove media command    

    iCollectionUtil->Collection().CommandL(*command);

    //

    // return command should contain error attribute

    //

    if (!command->IsSupported(TMPXAttribute(KMPXCommandIdCollectionRemoveMedia, EMPXCommandCollectionRemoveMediaError)))

        {

        User::Leave(KErrAbort);

        }

    //

    // abandon operation if an error occured cleaning up deleted medias from the collection

    //

    TInt error =

         command->ValueTObjectL<TInt>(

            TMPXAttribute(KMPXCommandIdCollectionRemoveMedia, EMPXCommandCollectionRemoveMediaError));

    User::LeaveIfError(error);

    //

    // reset found media if it's been deleted

    //

    if (iFoundMedia &&

        iFoundMedia->ValueText(KMPXMediaGeneralUri).CompareF(aFile) == 0)

        {

        delete iFoundMedia;

        iFoundMedia = NULL;

        }    

    CleanupStack::PopAndDestroy(2, media ); // command and media

    }

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

// Remove a media object

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

//

void CMPXCollectionCachedHelper::CleanupDeletedMediasL()

    {

    MPX_FUNC("CMPXCollectionCachedHelper::CleanupDeletedMediasL");

    Commit();

    ::InitializeCollectionPluginsL( *iCollectionUtil );

    //

    // set up the command to send to the collection

    //

    CMPXCommand* command = CMPXMedia::NewL();

    CleanupStack::PushL(command);

    command->SetTObjectValueL<TMPXCommandId>(

        KMPXCommandGeneralId, KMPXCommandIdCollectionCleanupDeletedMedias);

    command->SetTObjectValueL<TBool>(

        KMPXCommandGeneralDoSync, ETrue);

    command->SetTObjectValueL<TInt>(

        KMPXCommandGeneralCollectionId, iMusicCollectionId.iUid);

    // send sync cleanup command    

    iCollectionUtil->Collection().CommandL(*command);

    //

    // return command should contain error attribute

    //

    if (!command->IsSupported(TMPXAttribute(KMPXCommandIdCollectionCleanupDeletedMedias, EMPXCommandCollectionCleanupError)))

        {

        User::Leave(KErrAbort);

        }

    //

    // abandon operation if an error occured cleaning up deleted medias from the collection

    //

    TInt error =

        command->ValueTObjectL<TInt>(

            TMPXAttribute(KMPXCommandIdCollectionCleanupDeletedMedias, EMPXCommandCollectionCleanupError));

    User::LeaveIfError(error); 

    CleanupStack::PopAndDestroy(command);

    }

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

// Update a media object

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

//    

void CMPXCollectionCachedHelper::SetL( CMPXMedia*& aMedia )

    {

    MPX_DEBUG1("CMPXCollectionCachedHelper::::SetL <--");     

    const TDesC& newUri = aMedia->ValueText( KMPXMediaGeneralUri );

    TInt count( iCache->Count() );

    // Take advantage that MTP always try to access the most recent item

    //

    CMPXMedia* media( NULL );

    for( TInt i=count-1; i>=0; --i )

        {

        const TDesC& uri = iCache->AtL(i)->ValueText( KMPXMediaGeneralUri );

        if( newUri.CompareF( uri ) == 0 )

            {

            MPX_DEBUG2("Found existing media, index %i", i);

            media = iCache->AtL(i);

            break;

            }

        }

    // Not found in the array

    if( !media )

        {

        CMPXMedia* copy = CMPXMedia::NewL( *aMedia );

        CleanupStack::PushL( copy );

        iCache->AppendL( copy );  // ownership x-fer

        CleanupStack::Pop( copy );

        iOp.AppendL( ESet );

        }

    else

        {

        // Update existing media object already in the array

        //

        DoAppendGeneralL( *aMedia, *media );

        DoAppendMusicL( *aMedia, *media );

        DoAppendAudioL( *aMedia, *media );

        DoAppendDRML( *aMedia, *media ); 

        DoAppendContainerL( *aMedia, *media );

        DoAppendMTPL( *aMedia, *media ); 

        }

    MPX_DEBUG1("CMPXCollectionCachedHelper::::SetL -->");     

    }

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

// Renames a file

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

//    

void CMPXCollectionCachedHelper::RenameL( const TDesC& aOldUri,

                                          const TDesC& aNewUri,

                                          TMPXGeneralCategory aItemCat )

    {

    TInt count = iCache->Count();

    // Take advantage that MTP always try to access the most recent item

    //

    CMPXMedia* media( NULL );

    for( TInt i=count-1; i>=0; --i )

        {

        const TDesC& uri = iCache->AtL(i)->ValueText( KMPXMediaGeneralUri );

        if( aOldUri.CompareF( uri ) == 0 )

            {

            MPX_DEBUG2("Found existing media, index %i", i);

            media = iCache->AtL(i);

            break;

            }

        }

    // Not found in the array

    if( !media )

        {

        Commit();

        CMPXCollectionHelperImp::RenameL(aOldUri, aNewUri, aItemCat);

        }

    else

        {

        // Update existing media object already in the array

        //

        media->SetTextValueL(KMPXMediaGeneralUri, aNewUri);

        }

    if (iFoundMedia &&

        iFoundMedia->ValueText(KMPXMediaGeneralUri).CompareF(aOldUri) == 0)

        {

        iFoundMedia->SetTextValueL(KMPXMediaGeneralUri, aNewUri);

        }        

    }

#ifdef RD_MPX_COLLECTION_CACHE

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

// Gets the media object of the supplied attributes

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

//    

void CMPXCollectionCachedHelper::GetSongL( const TDesC& aFile, 

    TMPXGeneralCategory aItemCat, TUid aCollectionUId )

    {

    MPX_DEBUG1("CMPXCollectionCachedHelper::GetSongL <--");

    RArray<TMPXAttribute> attributes;

    CleanupClosePushL(attributes);

    attributes.AppendL(

        TMPXAttribute(KMPXMediaIdGeneral,

                      EMPXMediaGeneralTitle | EMPXMediaGeneralDate |

                      EMPXMediaGeneralDuration | EMPXMediaGeneralComment |

                      EMPXMediaGeneralUri ));

    attributes.AppendL(

        TMPXAttribute(KMPXMediaIdMusic,

                      EMPXMediaMusicArtist | EMPXMediaMusicAlbum |

                      EMPXMediaMusicAlbumTrack | EMPXMediaMusicComposer |

                      EMPXMediaMusicYear | EMPXMediaMusicGenre));

    attributes.AppendL(KMPXMediaAudioAudioAll);

    attributes.AppendL(KMPXMediaMTPAll);

    delete iFoundMedia;

    iFoundMedia = NULL;

    iFoundMedia = CMPXCollectionHelperImp::GetL( aFile, attributes.Array(), aItemCat );

    if ( !iFoundMedia )

        {

        User::Leave(KErrNotFound);

        }

    iFoundMedia->SetTObjectValueL<TUid>(

        KMPXMediaGeneralCollectionId, aCollectionUId );

    CleanupStack::PopAndDestroy(&attributes);

    //MPX_DEBUG1("Artist name =");

    //RDebug::RawPrint(iFoundMedia->ValueText( KMPXMediaMusicArtist));

    MPX_DEBUG1("CMPXCollectionCachedHelper::GetSongL -->");

    }

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

// Gets the artist id for the media object

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

//    

TMPXItemId CMPXCollectionCachedHelper::GetArtistIdL( const TDesC& aArtist, 

    TUid aCollectionUId )

    {

    MPX_DEBUG1("CMPXCollectionCachedHelper::GetArtistIdL <--");

    CMPXMedia* search = CMPXMedia::NewL();

    CleanupStack::PushL(search);

    search->SetTObjectValueL(KMPXMediaGeneralType, EMPXItem);        

    search->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXArtist);

    search->SetTObjectValueL<TUid>( KMPXMediaGeneralCollectionId, aCollectionUId );

    search->SetTextValueL( KMPXMediaGeneralTitle, aArtist );

    RArray<TMPXAttribute> attributes;

    CleanupClosePushL(attributes);

    attributes.AppendL(KMPXMediaGeneralId);

    CMPXMedia* result =

        CMPXCollectionHelperImp::FindAllL(*search, attributes.Array());

    CleanupStack::PopAndDestroy(&attributes);

    CleanupStack::PopAndDestroy(search);

    CleanupStack::PushL(result);

    const CMPXMediaArray* results =

        result->Value<CMPXMediaArray>(KMPXMediaArrayContents);

    if( !results )

        {

        User::Leave( KErrNoMemory );

        }

    TMPXItemId artistId = 0;

    if ( !results->Count() || aArtist == KNullDesC )

    	{

	    CleanupStack::PopAndDestroy(result);

    	return TMPXItemId(0);

    	}

    artistId = results->AtL(0)->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);

    CleanupStack::PopAndDestroy(result);

    MPX_DEBUG1("CMPXCollectionCachedHelper::GetArtistIdL -->");

    return artistId;

    }

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

// Gets the artist id for the media object

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

//    

void CMPXCollectionCachedHelper::GetSongsL( TMPXItemId aArtistId, 

    TUid aCollectionUId, TBool aUnknownArtist )

    {

    MPX_DEBUG1("CMPXCollectionCachedHelper::GetSongsLL <--");

    RArray<TMPXAttribute> attributes;

    CleanupClosePushL(attributes);

    if ((aArtistId == (TMPXItemId)0) || aUnknownArtist )

	    {

	    CleanupStack::PopAndDestroy(&attributes);