/*

* Copyright (c) 2009-2010 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:  CMediaManager class implementation

*

*/

#include "mediamanager.h"

#include <mpxmedia.h>

#include <mpxmediageneraldefs.h>

#include <mpxcollectionhelper.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediaarray.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxcollectionhelper.h>

#include <utf.h>

#include <mpxplaylistenginedefs.h> // for EMPXPlaylistTypeM3U

#include <mpxcollectiontype.h>

#include <mpxmediamusicdefs.h>

#include <mpxcollectionplugin.hrh>

#include <PathInfo.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediamtpdefs.h>

#include <driveinfo.h>

#include "mediadsproviderdefs.h"

#include "playlistitem.h"

#include "logger.h"

const TUid KMpxLocalCollectionUid = { 0x101FFC3A };

_LIT( KPlaylistPath, "playlists\\" );

_LIT( KMPXVirtualPlaylistExt, ".vir" );

// Maximum amount of song items to be enumerated on one RunL.

const TInt iMaxSongItemsToEnumerate(100);

// Maximum amount of playlist items to be enumerated on one RunL.

const TInt iMaxPlaylistItemsToEnumerate(15);

CMediaManager::CMediaManager( RFs& aFs, MMediaManagerObserver* aObserver,

        TKeyArrayFix aKey, CMD5& aHasher  )

: CActive( EPriorityStandard ),

iObserver( aObserver ),

iKey( aKey ),

iHasher( aHasher ),

iFs( aFs )

    {

    TRACE_FUNC;

    CActiveScheduler::Add(this);

    }

void CMediaManager::ConstructL()

    {

    TRACE_FUNC_ENTRY;

    iHarvester = CMPXHarvesterFactory::NewL();

    LOGGER_WRITE("1");

    iCollection = MMPXCollectionUtility::NewL( iObserver );

    LOGGER_WRITE("2");

    iMediator = CMPXCollectionMediator::NewL( iCollection->Collection() );

    LOGGER_WRITE("3");

    iCollectionHelper = CMPXCollectionHelperFactory::NewCollectionCachedHelperL();   

    TRACE_FUNC_EXIT;

    }

CMediaManager* CMediaManager::NewL( RFs& aFs, MMediaManagerObserver* aObserver, TKeyArrayFix aKey, CMD5& aHasher )

    {

    CMediaManager* self = new( ELeave ) CMediaManager( aFs, aObserver, aKey, aHasher );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CMediaManager::~CMediaManager()

    {

    TRACE_FUNC_ENTRY;

    Cancel();

    delete iFoundedMedia;

    if ( iCollectionHelper )

        {

        iCollectionHelper->Close();

        iCollectionHelper = NULL;

        }

    delete iMediator;

    if ( iCollection )

        {

        iCollection->Close();

        iCollection = NULL;

        }

    if ( iHarvester )

        {

        // For some unknown reason this may sometimes leave with error code -38

        TRAP_IGNORE( iHarvester->Close() );

        iHarvester = NULL;

        }

    TRACE_FUNC_EXIT;

    }

void CMediaManager::ScanL()

    {

    TRACE_FUNC_ENTRY;

    iHarvester->ScanL();

    TRACE_FUNC_EXIT;

    }

void CMediaManager::CancelScanL()

    {

    TRACE_FUNC_ENTRY;

    iHarvester->CancelScanL();

    TRACE_FUNC_EXIT;

    }

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

// Starts registering all playlists. Calls RegisterAllPlayListsCompleted when ready

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

// 

TInt CMediaManager::RegisterAllPlayLists()

    {

    TRACE_FUNC_ENTRY;

    if ( iCurrentState != EIdle || !iSnapshotArray)

        {

        LOGGER_WRITE("Not Idle or iSnapshotArray is NULL");

        return KErrNotReady;

        }

    iCurrentState = EReadingPlaylistCount;

    SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    TRACE_FUNC_EXIT;

    return KErrNone;

    }

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

// Starts registering all song items. Calls RegisterAllSongsCompleted when ready

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

// 

TInt CMediaManager::RegisterAllSongs()

    {

    TRACE_FUNC_ENTRY;

    if ( iCurrentState != EIdle || !iSnapshotArray)

        {

        LOGGER_WRITE("Not Idle or iSnapshotArray is NULL");

        return KErrNotReady;

        }

    iCurrentState = EReadingSongCount;

    SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    TRACE_FUNC_EXIT;

    return KErrNone;

    }

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

// Registers playlist.

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

// 

void CMediaManager::RegisterPlaylistL( const CMPXMedia& aMedia )

    {

    TRACE_FUNC_ENTRY;

    if ( !iSnapshotArray )

        {

        User::Leave( KErrGeneral );

        }

    if ( !aMedia.IsSupported(KMPXMediaGeneralId) )

        {

        LOGGER_WRITE("KMPXMediaGeneralId not supported");

        User::Leave(KErrNotSupported);

        }

     // Extract the playlist id from the found object

     TUint32 playlistId = *aMedia.Value<TMPXItemId>(KMPXMediaGeneralId);

     LOGGER_WRITE_1("KMPXMediaGeneralId: %d", playlistId);

     if ( !aMedia.IsSupported( KMPXMediaGeneralTitle ) )

          {

          LOGGER_WRITE("KMPXMediaGeneralTitle not supported");

          User::Leave(KErrNotSupported);

          }

     CPlaylistItem* playlist = CPlaylistItem::NewLC();

     // find the media object that contains a list of songs in the playlist

     RArray<TInt> contentIDs;

     CleanupClosePushL( contentIDs );

     contentIDs.AppendL(KMPXMediaIdGeneral);

     CMPXMedia* searchMedia = CMPXMedia::NewL(contentIDs.Array());

     CleanupStack::PopAndDestroy( &contentIDs );

     CleanupStack::PushL(searchMedia);

     searchMedia->SetTObjectValueL(KMPXMediaGeneralType, EMPXGroup);    

     searchMedia->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXSong);

     searchMedia->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, playlistId);

     RArray<TMPXAttribute> songAttributes;

     CleanupClosePushL(songAttributes);

     songAttributes.AppendL(KMPXMediaGeneralId);

     songAttributes.AppendL(KMPXMediaGeneralUri);

     CMPXMedia* foundMedia = iCollectionHelper->FindAllL(*searchMedia, 

                                                         songAttributes.Array());

     CleanupStack::PopAndDestroy(&songAttributes);

     CleanupStack::PopAndDestroy(searchMedia);

     CleanupStack::PushL(foundMedia);

     if ( !foundMedia->IsSupported(KMPXMediaArrayCount) )

         {

         User::Leave(KErrNotSupported);

         }

     // Number of references

     TInt numOfRefs = *foundMedia->Value<TInt>(KMPXMediaArrayCount);

     if ( numOfRefs )

         {

         if (!foundMedia->IsSupported(KMPXMediaArrayContents))

             {

             User::Leave(KErrNotSupported);

             }

         const CMPXMediaArray* refArray =

             foundMedia->Value<CMPXMediaArray>(KMPXMediaArrayContents);

         // Import the references

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

             {

             const CMPXMedia* refMedia = (*refArray)[i];

             if ( refMedia->IsSupported(KMPXMediaGeneralUri) )

                 {

                 const TDesC& uri = refMedia->ValueText(KMPXMediaGeneralUri);

                 playlist->AddItemL( uri );

                 }

             }

         }

    TSnapshotItem playlistItem(playlistId);

    const TDesC& title = aMedia.ValueText( KMPXMediaGeneralTitle );

    playlist->SetTitleL( title );

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

    playlist->SetUrlL( uri );

    playlistItem.SetItemHash( *playlist, iHasher );

    playlistItem.SetParentId( KPlaylistsFolderId );

    TKeyArrayFix key( iKey );

    iSnapshotArray->InsertIsqL( playlistItem, key );

    CleanupStack::PopAndDestroy( foundMedia );

    CleanupStack::PopAndDestroy( playlist );

    TRACE_FUNC_EXIT;

    }

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

// Populates CPlaylistItem

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

// 

void CMediaManager::GetPlayListL( TInt aPlaylistId, CPlaylistItem& aList )

    {

    TRACE_FUNC_ENTRY;

    LOGGER_WRITE_1("aPlaylistId: %d", aPlaylistId);

    CMPXMedia* playlistItem = FindPlaylistL( aPlaylistId );

    CleanupStack::PushL( playlistItem );

    if ( !playlistItem->IsSupported(KMPXMediaGeneralId) )

        {

        LOGGER_WRITE("KMPXMediaGeneralId not supported");

        User::Leave(KErrNotSupported);

        }

    // Extract the playlist id from the found object

    TUint32 playlistId = *playlistItem->Value<TMPXItemId>(KMPXMediaGeneralId);

    LOGGER_WRITE_1("KMPXMediaGeneralId: %d", playlistId);

    aList.SetId( playlistId );

    if ( !playlistItem->IsSupported(KMPXMediaGeneralTitle) )

        {

        LOGGER_WRITE("KMPXMediaGeneralTitle not supported");

        User::Leave( KErrNotSupported );

        }

    else

        {

        const TDesC& title = playlistItem->ValueText(KMPXMediaGeneralTitle);

        LOGGER_WRITE_1("KMPXMediaGeneralTitle: %S", &title);

        aList.SetTitleL( title );

        }

    if ( playlistItem->IsSupported( KMPXMediaGeneralUri ) )

        {

        const TDesC& uri = playlistItem->ValueText( KMPXMediaGeneralUri );

        aList.SetUrlL( uri );

        }

    CleanupStack::PopAndDestroy( playlistItem );

    CMPXMedia* playlist = FetchPlaylistContentL( aPlaylistId );

    CleanupStack::PushL( playlist );

    if ( !playlist->IsSupported(KMPXMediaArrayCount) )

         {

         User::Leave(KErrNotSupported);

         }

    // Number of references

    TInt numOfRefs = *playlist->Value<TInt>(KMPXMediaArrayCount);

    LOGGER_WRITE_1("numOfRefs: %d", numOfRefs);

    if ( numOfRefs )

        {

        if (!playlist->IsSupported(KMPXMediaArrayContents))

            {

            User::Leave(KErrNotSupported);

            }

        const CMPXMediaArray* refArray =

        playlist->Value<CMPXMediaArray>(KMPXMediaArrayContents);

        // Import the references

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

            {

            const CMPXMedia* refMedia = (*refArray)[i];

            if ( refMedia->IsSupported(KMPXMediaGeneralUri) )

                {

                aList.AddItemL( refMedia->ValueText(KMPXMediaGeneralUri) );

                }

            }

        }

    CleanupStack::PopAndDestroy( playlist );

    TRACE_FUNC_EXIT;

    }

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

// Fetch a playlist content

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

// 

CMPXMedia* CMediaManager::FetchPlaylistContentL( TInt aId )

    {

    TRACE_FUNC_ENTRY;

    TMPXItemId id(aId);

    CMPXMedia* criteria = CMPXMedia::NewL();

    CleanupStack::PushL( criteria );

    criteria->SetTObjectValueL<TUid>(

            KMPXMediaGeneralCollectionId, KMpxLocalCollectionUid );

    criteria->SetTObjectValueL<TMPXGeneralType>(

            KMPXMediaGeneralType, EMPXGroup );

    // set search keys

    criteria->SetTObjectValueL<TMPXGeneralCategory>(

            KMPXMediaGeneralCategory, EMPXSong );    

    criteria->SetTObjectValueL<TMPXItemId>(

            KMPXMediaGeneralId, id );

    // define attributes fetched

    RArray<TMPXAttribute> songAttributes;

    CleanupClosePushL(songAttributes);

    songAttributes.AppendL(KMPXMediaGeneralId);

    songAttributes.AppendL(KMPXMediaGeneralUri);

    // now find

    CMPXMedia* result = iCollectionHelper->FindAllL( *criteria , songAttributes.Array() );

    CleanupStack::PopAndDestroy( &songAttributes );

    CleanupStack::PopAndDestroy( criteria );

    TRACE_FUNC_EXIT;

    return result;

    }

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

 // Find a playlist

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

 //

 CMPXMedia* CMediaManager::FindPlaylistL( TInt aUid )

     {

     TRACE_FUNC_ENTRY;

     CMPXMedia* criteria = CMPXMedia::NewL();

     CleanupStack::PushL( criteria );

     criteria->SetTObjectValueL<TMPXGeneralType>(

                 KMPXMediaGeneralType, EMPXItem );

     criteria->SetTObjectValueL<TMPXGeneralCategory>(

                 KMPXMediaGeneralCategory, EMPXPlaylist );

     criteria->SetTObjectValueL<TMPXItemId>(

                 KMPXMediaGeneralId, aUid );

     // define attributes fetched

     RArray<TMPXAttribute> playlistAttributes;

     CleanupClosePushL(playlistAttributes);

     playlistAttributes.AppendL(KMPXMediaGeneralId);

     playlistAttributes.AppendL(KMPXMediaGeneralCollectionId); //test

     playlistAttributes.AppendL(KMPXMediaGeneralTitle);

     playlistAttributes.AppendL(KMPXMediaGeneralUri);

     // now find

     CMPXMedia* foundList = 0;

     foundList = iCollectionHelper->FindAllL( *criteria , playlistAttributes.Array() );

     CleanupStack::PopAndDestroy( &playlistAttributes );

     CleanupStack::PopAndDestroy( criteria );

     CleanupStack::PushL( foundList );

     if ( !foundList->IsSupported(KMPXMediaArrayCount) )

         {

         LOGGER_WRITE("KMPXMediaArrayCount not supported");

         User::Leave( KErrNotSupported );

         }

     TInt foundItemCount = *foundList->Value<TInt>(KMPXMediaArrayCount);

     CMPXMedia* playlist(NULL);

     if ( foundItemCount )

         {

         if ( !foundList->IsSupported(KMPXMediaArrayContents) )

             {

             LOGGER_WRITE("KMPXMediaArrayContents not supported");

             User::Leave(KErrNotSupported);

             }

         const CMPXMediaArray* foundArray = foundList->Value<CMPXMediaArray>(KMPXMediaArrayContents);

         // get the first founded item

         playlist = CMPXMedia::NewL(*(*foundArray)[0]);

         }

     else

         {

         User::Leave( KErrGeneral );

         }

     CleanupStack::PopAndDestroy( foundList );

     TRACE_FUNC_EXIT;

     return playlist;

     }

void CMediaManager::GetSongL( TInt aSongId, CSongItem& aSongItem )

    {

    TRACE_FUNC_ENTRY;

    TMPXItemId id(aSongId);

    RArray<TInt> contentIDs;

    CleanupClosePushL( contentIDs );

    contentIDs.AppendL( KMPXMediaIdMusic );

    contentIDs.AppendL( KMPXMediaIdGeneral );

    CMPXMedia* criteria = CMPXMedia::NewL(contentIDs.Array());

    CleanupStack::PopAndDestroy( &contentIDs );

    CleanupStack::PushL(criteria);

    // set search keys

    criteria->SetTObjectValueL<TMPXGeneralType>(

            KMPXMediaGeneralType, EMPXItem );

    criteria->SetTObjectValueL<TMPXGeneralCategory>(

            KMPXMediaGeneralCategory, EMPXSong );   

    criteria->SetTObjectValueL<TMPXItemId>(

            KMPXMediaGeneralId, id );

    // define attributes fetched

    RArray<TMPXAttribute> songAttributes;

    CleanupClosePushL(songAttributes);

    songAttributes.AppendL( KMPXMediaGeneralType );

    songAttributes.AppendL( KMPXMediaGeneralCategory );

    songAttributes.AppendL( KMPXMediaGeneralUri );

    songAttributes.AppendL( KMPXMediaGeneralId );

    songAttributes.AppendL( KMPXMediaGeneralTitle );

    songAttributes.AppendL( KMPXMediaGeneralMimeType );

    songAttributes.AppendL( KMPXMediaGeneralDuration );

    songAttributes.AppendL( KMPXMediaGeneralComment );

    songAttributes.AppendL( KMPXMediaMusicArtist );

    songAttributes.AppendL( KMPXMediaMusicAlbum );

    songAttributes.AppendL( KMPXMediaMusicYear );

    songAttributes.AppendL( KMPXMediaMusicAlbumTrack );

    songAttributes.AppendL( KMPXMediaMusicGenre );

    songAttributes.AppendL( KMPXMediaMusicComposer );

    // now find

    CMPXMedia* result = 0;

    TRAPD(err, result = iCollectionHelper->FindAllL( *criteria , songAttributes.Array() ));

    CleanupStack::PopAndDestroy( &songAttributes );

    CleanupStack::PopAndDestroy( criteria );

    if ( err )

        {

        LOGGER_WRITE_1("FindAllL err: %d", err);

        User::Leave( err );

        }

    CleanupStack::PushL( result );

    if ( !result->IsSupported(KMPXMediaArrayCount) )

         {