// Copyright (c) 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:

//

/**

 @file

 @internalComponent

*/

#include <mpxmediamusicdefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmessagegeneraldefs.h>

#include <pathinfo.h>

#include <mpxcollectionhelper.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxcollectionuihelper.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionplaylist.h>

#include <mpxcollectionmessage.h>

#include <mpxcollectionpath.h>

#include "cmtpplaybackcontrolimpl.h"

#include "cmtpplaybackplaylisthelper.h"

#include "mtpplaybackcontrolpanic.h"

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

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

// CMTPPlaybackPlaylistHelper::NewL

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

//

CMTPPlaybackPlaylistHelper* CMTPPlaybackPlaylistHelper::NewL( CMTPPlaybackControlImpl& aControlImpl )

    {

    CMTPPlaybackPlaylistHelper* self = new ( ELeave ) 

                CMTPPlaybackPlaylistHelper( aControlImpl );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMTPPlaybackPlaylistHelper::~CMTPPlaybackPlaylistHelper

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

//

CMTPPlaybackPlaylistHelper::~CMTPPlaybackPlaylistHelper()

    {

    if( iCollectionUiHelper )

        {

        iCollectionUiHelper->Close();

        }

    if ( iCollectionHelper )

        {

        iCollectionHelper->Close();

        }

    if( iCollectionUtil ) 

        {

        iCollectionUtil->Close();

        }

    delete iPlayObject;

    }

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

// CMTPPlaybackPlaylistHelper::GetPlayListFromCollectionL

//// Get Playlist via aMedia

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

//

void CMTPPlaybackPlaylistHelper::GetPlayListFromCollectionL( const TMTPPbDataSuid& aPlayObject )

    {

    //Reset

    ResetPlaySource();

    iPlayCategory = aPlayObject.Category();

    iPlayObject = aPlayObject.Suid().AllocL();

    switch ( iPlayCategory )

        {

        case EMTPPbCatPlayList:

            {

            OpenMusicPlayListPathL();

            }

            break;

        case EMTPPbCatAlbum:

            {

            OpenMusicAblumPathL();

            }

            break;

        default:

            {

            Panic( EMTPPBCollectionErrCall );

            }

            break;

        }

    }

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

// CMTPPlaybackPlaylistHelper::GetPlayListFromCollectionL

// Get Playlist via index

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

//

void CMTPPlaybackPlaylistHelper::GetPlayListFromCollectionL( TInt aIndex )

    {

    iSongIndex = aIndex;

    UpdatePathAndOpenL();

    }

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

// CMTPPlaybackPlaylistHelper::GetMTPPBSuidFromCollectionL

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

//

TMTPPbDataSuid CMTPPlaybackPlaylistHelper::GetMTPPBSuidFromCollectionL( 

        const CMPXCollectionPlaylist& aPlaylist )

    {

    CMPXCollectionPath* path = iCollectionUiHelper->MusicPlaylistPathL();

    if ( path->Id() == aPlaylist.Path().Id( KMTPPlaybackPlaylistAblumLevel -1 ))

        {

        iPlayCategory = EMTPPbCatPlayList;

        }

    else

        {

        iPlayCategory = EMTPPbCatAlbum;

        }

    TFileName uri = ItemIdToUriL( aPlaylist.Path().Id( KMTPPlaybackPlaylistAblumLevel ));

    TMTPPbDataSuid dataSuid( iPlayCategory, uri );

    return dataSuid;

    }

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

// CMTPPlaybackPlaylistHelper::MTPPbCategory

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

//

TMTPPbCategory CMTPPlaybackPlaylistHelper::MTPPbCategory() const

    {

    return iPlayCategory;

    }

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

// CMTPPlaybackPlaylistHelper::MTPPbSuid

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

//

TFileName CMTPPlaybackPlaylistHelper::MTPPbSuid() const

    {

    return TFileName( *iPlayObject );

    }

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

// From MMPXCollectionObserver

// Handle completion of a asynchronous command

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

//

void CMTPPlaybackPlaylistHelper::HandleCollectionMessage( CMPXMessage* aMsg, TInt aErr )

    {

    if (( KErrNone == aErr ) && aMsg )

        {

        TRAP( aErr, DoHandleCollectionMessageL( *aMsg ));

        }

    if ( KErrNone != aErr )

        {

        TInt error = MTPPlaybackControlImpl().MapError( aErr );

        MTPPlaybackControlImpl().DoHandleError( error );

        }

    }

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

// From MMPXCollectionObserver

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

//

void CMTPPlaybackPlaylistHelper::HandleOpenL( const CMPXMedia& aEntries, 

        TInt /*aIndex*/, TBool /*aComplete*/, TInt aError )

    {

    if ( KErrNone == aError )

        {

        TRAP( aError, DoHandleOpenL( aEntries ));

        }

    if ( KErrNone != aError )

        {

        TInt error = MTPPlaybackControlImpl().MapError( aError );

        MTPPlaybackControlImpl().DoHandleError( error );

        }

    }

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

// From MMPXCollectionObserver

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

//

void CMTPPlaybackPlaylistHelper::HandleOpenL( const CMPXCollectionPlaylist& aPlaylist,

        TInt aError )

    {

    if ( KErrNone == aError )

        {

        TRAP( aError, MTPPlaybackControlImpl().GetPlaylistFromCollectionCompleteL( aPlaylist ));

        }

    if ( KErrNone != aError )

        {

        TInt error = MTPPlaybackControlImpl().MapError( aError );

        MTPPlaybackControlImpl().DoHandleError( error );

        }

    }

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

// From MMPXCollectionMediaObserver

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

void CMTPPlaybackPlaylistHelper::HandleCollectionMediaL( const CMPXMedia& /*aMedia*/, TInt /*aError*/ )

    {

    }

//

// CMTPPlaybackPlaylistHelper::CMTPPlaybackPlaylistHelper

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

//

CMTPPlaybackPlaylistHelper::CMTPPlaybackPlaylistHelper( CMTPPlaybackControlImpl& aControlImpl )

        : iCollectionUiHelper( NULL ),

          iCollectionHelper( NULL ),

          iCollectionUtil( NULL ),

          iPlayObject( NULL ),

          iMTPPlaybackControl( aControlImpl )

    {

    }

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

// CMTPPlaybackPlaylistHelper::ConstructL

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

//

void CMTPPlaybackPlaylistHelper::ConstructL()

    {

    iCollectionUiHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL();

    iCollectionUtil = MMPXCollectionUtility::NewL( this, KMcModeDefault );

    }

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

// CMTPPlaybackPlaylistHelper::DoHandleCollectionMessage

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

//

void CMTPPlaybackPlaylistHelper::DoHandleCollectionMessageL( const CMPXMessage& aMsg )

    {

    TMPXMessageId id( aMsg.ValueTObjectL<TMPXMessageId>( KMPXMessageGeneralId ) );

    if ( KMPXMessageGeneral == id )

        {

        TInt event( aMsg.ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) );

        TInt type( aMsg.ValueTObjectL<TInt>( KMPXMessageGeneralType ) );

        TInt data( aMsg.ValueTObjectL<TInt>( KMPXMessageGeneralData ) );

        if ( event == TMPXCollectionMessage::EPathChanged &&

             type == EMcPathChangedByOpen && 

             data == EMcContainerOpened )

            {

            iCollectionUtil->Collection().OpenL();

            }

        else if ( event == TMPXCollectionMessage::EPathChanged &&

                  type == EMcPathChangedByOpen &&

                  data == EMcItemOpened )

            {

            iCollectionUtil->Collection().OpenL();

            }

        else if ( event == TMPXCollectionMessage::ECollectionChanged )

            {

            }

        }

    }

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

// CMTPPlaybackPlaylistHelper::DoHandleOpenL

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

//

void CMTPPlaybackPlaylistHelper::DoHandleOpenL( const CMPXMedia& aEntries )

    {

    if ( EMTPPbCatAlbum == iPlayCategory )

        {

        UpdateAlbumPathAndOpenL();

        }

    else

        {

        //playlist

        if ( -1 == iPathIndex )

            {

            //first, the top path

            UpdatePlaylistPathIndexL( aEntries );

            if ( -1 == iPathIndex )

                {

                MTPPlaybackControlImpl().DoHandleError( KPlaybackErrParamInvalid );

                }

            else

                {

                iCollectionUtil->Collection().OpenL( iPathIndex );

                }

                }

        else

            {

            //open the first song when initObject

            iCollectionUtil->Collection().OpenL( iSongIndex );

            }

        }

    }

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

// CMTPPlaybackPlaylistHelper::OpenMusicPlayListPathL

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

//

void CMTPPlaybackPlaylistHelper::OpenMusicPlayListPathL()

    {

    CMPXCollectionPath* path = iCollectionUiHelper->MusicPlaylistPathL();

    CleanupStack::PushL( path );

    iCollectionUtil->Collection().OpenL( *path );

    CleanupStack::PopAndDestroy( path );

    }

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

// CMTPPlaybackPlaylistHelper::OpenMusicAblumPathL

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

//

void CMTPPlaybackPlaylistHelper::OpenMusicAblumPathL()

    {

    CMPXCollectionPath* path = iCollectionUiHelper->MusicMenuPathL();

    CleanupStack::PushL( path );

    path->AppendL(KMPXCollectionArtistAlbum);

    iCollectionUtil->Collection().OpenL( *path );

    CleanupStack::PopAndDestroy( path );

    }

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

// CMTPPlaybackPlaylistHelper::ResetPlaySource

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

//

void CMTPPlaybackPlaylistHelper::ResetPlaySource()

    {

    iPathIndex = -1;

    iSongIndex = 0;

    delete iPlayObject;

    iPlayObject = NULL;

    }

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

// CMTPPlaybackPlaylistHelper::UpdatePlaylistPathIndexL

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

//

void CMTPPlaybackPlaylistHelper::UpdatePlaylistPathIndexL( const CMPXMedia& aEntries )

    {

    __ASSERT_DEBUG( iPlayCategory == EMTPPbCatPlayList, Panic( EMTPPBCollectionErrCall ));

    const CMPXMediaArray* refArray = aEntries.Value<CMPXMediaArray> ( KMPXMediaArrayContents );

    TInt count = refArray->Count();

    const TMPXItemId playlistId = UriToItemIdL();

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

        {

        CMPXMedia* container = refArray->AtL(i);

        /**

         * Try to find out the next path according to the 

         * playlist's ItemId

         */

        if ( container->IsSupported( KMPXMediaGeneralId ))

            {

            const TMPXItemId tempId = container->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);

            if ( tempId == playlistId )

                {

                iPathIndex = i;

                break;

                }

            }

       }

    }

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

// return instance of CollectionHelper.

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

//

MMPXCollectionHelper* CMTPPlaybackPlaylistHelper::CollectionHelperL()

    {

    if ( iCollectionHelper == NULL )

        {

        iCollectionHelper = CMPXCollectionHelperFactory::NewCollectionCachedHelperL();

        // Do a search for a song ID that does not exist

        RArray<TInt> contentIDs;

        CleanupClosePushL( contentIDs ); // + contentIDs

        contentIDs.AppendL( KMPXMediaIdGeneral );

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

        CleanupStack::PopAndDestroy( &contentIDs ); // - contentIDs

        CleanupStack::PushL( searchMedia ); // + searchMedia

        searchMedia->SetTObjectValueL( KMPXMediaGeneralType, EMPXItem );

        searchMedia->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXSong );

        searchMedia->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId,

                KMTPPlaybackInvalidSongID );

        /*

        * store root

        */

        TChar driveChar = 'c';

        TInt driveNumber;

        // get root path

        TBuf<KStorageRootMaxLength> storeRoot;

        searchMedia->SetTextValueL( KMPXMediaGeneralDrive, storeRoot );

        RArray<TMPXAttribute> songAttributes;

        CleanupClosePushL( songAttributes ); // + songAttributes

        songAttributes.AppendL( KMPXMediaGeneralId );

        CMPXMedia* foundMedia = NULL;

        TRAPD( err, foundMedia = iCollectionHelper->FindAllL(

                *searchMedia,

                songAttributes.Array() ) );

        CleanupStack::PopAndDestroy( &songAttributes ); // - songAttributes

        CleanupStack::PopAndDestroy( searchMedia ); // - searchMedia

        CleanupStack::PushL( foundMedia ); // + foundMedia