/*

* 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 playlist

*

*/

#include <e32math.h>

#include <mpxcollectionpath.h>

#include <mpxcmn.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionmessage.h>

#include <mpxmediageneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxmediacontainerdefs.h>

#include <mpxlog.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxmessagecontainerdefs.h>

#include <mpxcollectionopenutility.h>

#include "mpxcollectionplaylistobserver.h"

#include "mpxcollectionplaylist.h"

// CONSTANTS

const TInt KIncrementalFetchSize = 400;

const TInt KIncrementalDelay = 2000000;

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

// Two-phased constructor.

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

//

EXPORT_C CMPXCollectionPlaylist* CMPXCollectionPlaylist::NewL()

    {

    MPX_DEBUG1("-->CMPXCollectionPlaylist::NewL()"); 

    CMPXCollectionPlaylist* p = new(ELeave) CMPXCollectionPlaylist(NULL);

    CleanupStack::PushL(p);

    p->ConstructL();

    CleanupStack::Pop(p);

    MPX_DEBUG2("<--CMPXCollectionPlaylist::NewL() playlist 0x%08x", p);

    return p;

    }

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

// Two-phased constructor.

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

//

EXPORT_C CMPXCollectionPlaylist* CMPXCollectionPlaylist::NewL(

    const CMPXCollectionPlaylist& aPlaylist,

    MMPXCollectionPlaylistObserver* aPlObs /*= NULL*/)

    {

    MPX_DEBUG2("-->CMPXCollectionPlaylist::NewL(pl, plobs) with plobs 0x%08x", aPlObs); 

    CMPXCollectionPlaylist* p = new(ELeave) CMPXCollectionPlaylist(aPlObs);

    CleanupStack::PushL(p);

    p->ConstructL(aPlaylist);

    CleanupStack::Pop(p);

    MPX_DEBUG3("<--CMPXCollectionPlaylist::NewL(pl, plobs) playlist 0x%08x, , plobs 0x%08x",

               p, aPlObs);  

    return p;

    }

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

// Two-phased constructor.

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

//

EXPORT_C CMPXCollectionPlaylist* CMPXCollectionPlaylist::NewL(

    const CMPXCollectionPath& aPath,

    MMPXCollectionPlaylistObserver* aPlObs /*= NULL*/)

    {

    MPX_DEBUG2("-->CMPXCollectionPlaylist::NewL(path, plobs) with plobs 0x%08x", aPlObs); 

    CMPXCollectionPlaylist* p = new(ELeave) CMPXCollectionPlaylist(aPlObs);

    CleanupStack::PushL(p);

    p->ConstructL(aPath);

    CleanupStack::Pop(p);

    MPX_DEBUG3("<--CMPXCollectionPlaylist::NewL(pl, plobs) playlist 0x%08x, , plobs 0x%08x",

               p, aPlObs);  

    return p;

    }

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

// Two-phased constructor.

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

//

EXPORT_C CMPXCollectionPlaylist* CMPXCollectionPlaylist::NewL(

    RReadStream& aStream,

    MMPXCollectionPlaylistObserver* aPlObs /*= NULL*/)

    {

    MPX_DEBUG2("-->CMPXCollectionPlaylist::NewL(strm, plobs) with plobs 0x%08x", aPlObs); 

    CMPXCollectionPlaylist* p = new(ELeave) CMPXCollectionPlaylist(aPlObs);

    CleanupStack::PushL(p);

    p->ConstructL(aStream);

    CleanupStack::Pop(p);

    MPX_DEBUG3("<--CMPXCollectionPlaylist::NewL(pl, plobs) playlist 0x%08x, , plobs 0x%08x",

               p, aPlObs);  

    return p;

    }

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

// Default constructor

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

//

CMPXCollectionPlaylist::CMPXCollectionPlaylist(

    MMPXCollectionPlaylistObserver* aPlObs)

:   iRepeatMode(ERepeatOff), iShuffle(EFalse), iRemote(EFalse), 

    iItemIndex(KErrNotFound),iEmbedded(EFalse), iPlObs(aPlObs),

    iRepeatEnabled(ETrue),

    iShuffleEnabled(ETrue), iAutoPlaylist(EFalse),

    iAutoPlay(ETrue), iSingleItemPlaylist(EFalse),

    iPreInitPlugin(ETrue)

    {

    }

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

// 2nd phase constructor. 

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

//

void CMPXCollectionPlaylist::ConstructL(const CMPXCollectionPath& aPath)

    {

    MPX_FUNC_EX("CMPXCollectionPlaylist::ConstructL(aPath)");

    iPath=CMPXCollectionPath::NewL(aPath); 

    iIncOpenUtil = CMPXCollectionOpenUtility::NewL( this, KMcModePlaylist );

    SetShuffleL(EFalse, EFalse);

    if (!iAutoPlaylist)

        {

        DoIncrementalOpenL();

        }

    }

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

// 2nd phase constructor. 

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

//

void CMPXCollectionPlaylist::ConstructL(

    const CMPXCollectionPlaylist& aPlaylist)

    {

    MPX_FUNC_EX("CMPXCollectionPlaylist::ConstructL(aPlaylist)");

    iIncOpenUtil = CMPXCollectionOpenUtility::NewL( this, KMcModePlaylist );

    CopyContentL(aPlaylist);

    }

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

// 2nd phase constructor. 

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

//

void CMPXCollectionPlaylist::ConstructL(RReadStream& aStream)

    {

    MPX_FUNC_EX("CMPXCollectionPlaylist::ConstructL(aStream)");

    InternalizeL(aStream);

    iIncOpenUtil = CMPXCollectionOpenUtility::NewL( this, KMcModePlaylist );

    if (!iAutoPlaylist)

        {

        DoIncrementalOpenL();

        }

    }

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

// 2nd phase constructor. 

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

//

void CMPXCollectionPlaylist::ConstructL()

    {

    MPX_FUNC_EX("CMPXCollectionPlaylist::ConstructL()");

    iPath = CMPXCollectionPath::NewL();

    iIncOpenUtil = CMPXCollectionOpenUtility::NewL( this, KMcModePlaylist );

    }

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

// Destructor

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

//

EXPORT_C CMPXCollectionPlaylist::~CMPXCollectionPlaylist()

    {

    MPX_FUNC_EX("CMPXCollectionPlaylist::~CMPXCollectionPlaylist");

    delete iPath;

    iItemIndexes.Close();

    if (iColUtil)

        {

        iColUtil->Close();

        }

    delete iIncOpenUtil;

    }

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

// Copy playlist content from other playlist except observers and session to 

// collection server

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

//

EXPORT_C void CMPXCollectionPlaylist::CopyContentL(

    const CMPXCollectionPlaylist& aPlaylist)

    {

    MPX_FUNC_EX("CMPXCollectionPlaylist::CopyContentL(aPlaylist)");

    iRepeatMode=aPlaylist.iRepeatMode;

    iRepeatEnabled=aPlaylist.iRepeatEnabled;

    iShuffle=aPlaylist.iShuffle;

    iShuffleEnabled=aPlaylist.iShuffleEnabled;

    iRemote=aPlaylist.iRemote;

    delete iPath;

    iPath = NULL;

    iPath=CMPXCollectionPath::NewL(aPlaylist.Path());

    ::CopyArrayL(aPlaylist.iItemIndexes.Array(), iItemIndexes);

    iItemIndex=aPlaylist.iItemIndex;

    iEmbedded=aPlaylist.iEmbedded;

    iAutoPlaylist=aPlaylist.iAutoPlaylist;

    iAutoPlay=aPlaylist.iAutoPlay;

    iSingleItemPlaylist=aPlaylist.iSingleItemPlaylist;

    iPreInitPlugin=aPlaylist.iPreInitPlugin;

    if( !iColUtil )

        {

        iColUtil=MMPXCollectionUtility::NewL(this ,KMcModePlaylist);  

        }

    if (!iAutoPlaylist)

        {

        DoIncrementalOpenL();

        }

    }

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

// Advances path to next item

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

//

EXPORT_C TBool CMPXCollectionPlaylist::Next( 

    TBool aIgnoreRepeat /*=EFalse*/ )

    {

    MPX_FUNC_EX("CMPXCollectionPlaylist::Next()");

    TInt nextPlIndex( KErrNotFound );

    TBool ret( NextIndex( aIgnoreRepeat, nextPlIndex ));

    if ( KErrNotFound != nextPlIndex )

        {

        iPath->Set( iItemIndexes[nextPlIndex] );

        if ( iShuffle && iItemIndex == Count()-1 )

            {

            MPX_TRAPD( err, SetShuffleL( iShuffle, ETrue ));

            if ( KErrNone != err )

                {

                ret = EFalse;

                iItemIndex = 0;

                iPath->Set( iItemIndexes[0] );

                }

            }

        else

            {

            iItemIndex = nextPlIndex;

            }

        }

    return ret;

    }

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

// Gets the next index to play

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

//

EXPORT_C TBool CMPXCollectionPlaylist::NextIndex( 

    TBool aIgnoreRepeatOneMode,

    TInt& aPlaylistIndex ) const

    {

    MPX_FUNC("CMPXCollectionPlaylist::NextIndex()");

    TInt count( Count() );

    TBool ret( ETrue );

    if ( count <= 0 )

        {

        ret = EFalse;

        aPlaylistIndex = KErrNotFound;

        }

    else 

        {

        MPX_ASSERT( iItemIndex != -1 );

        aPlaylistIndex = iItemIndex;

        // If not in repeat one mode, then go to the next item,

        // otherwise leave index unchanged

        if (( ERepeatOne != iRepeatMode ) ||

            ( aIgnoreRepeatOneMode ))

            {

            // If not the last one in the list, find the next valid item

            if ( count-1 != aPlaylistIndex )

                {

                do

                    {

                    ++aPlaylistIndex;

                    }

                while( aPlaylistIndex != count && 

                        iPath->IdOfIndex( iItemIndexes[aPlaylistIndex] )

                        == KMPXInvalidItemId );

                }

            // If Last one in list, set to first

            if ( count-1 == iItemIndex || count == aPlaylistIndex )

                {

                if ( ERepeatOff == iRepeatMode )

                    {

                    ret = EFalse;

                    }

                // If shuffle mode is on, choose a song to be the first song in the new

                // randomized list.  This chooses the middle song, not exactly random,

                // but this ensures that if this method is called multiple times

                // it would return a consistent result.  The reason is because this

                // method maybe called multiple times in a row by different clients, 

                // so we want to make sure that each client returns the same result.

                // If shuffle is off then choose the first item in list.

                if ( iShuffle )

                    {

                    aPlaylistIndex = count / 2;

                    }

                else

                    {

                    aPlaylistIndex = 0;

                    }

                }

            }

        }

    MPX_DEBUG3("CMPXCollectionPlaylist::NextIndex %d %d", ret, aPlaylistIndex);

    return ret;

    }

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

// Gets the path index of the item given it's position in the playlist.

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

//

EXPORT_C TInt CMPXCollectionPlaylist::PathIndex( TInt aPlaylistIndex ) const

    {

    MPX_FUNC("CMPXCollectionPlaylist::PathIndex");

    MPX_ASSERT(aPlaylistIndex < Count());

    return iItemIndexes[aPlaylistIndex];

    }

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

// Advances path to previous item

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

//

EXPORT_C TBool CMPXCollectionPlaylist::Previous( 

    TBool aIgnoreRepeat /*=EFalse*/ )

    {

    MPX_FUNC_EX("CMPXCollectionPlaylist::Previous");

    TBool ret=ETrue;

    TInt count( Count() );

    if ( count <= 0 )

        {

        ret = EFalse;

        }

    else if ( ERepeatOne != iRepeatMode ||

              aIgnoreRepeat )

        {

        // If first one in list, set to last

        if ( 0 == iItemIndex )

            {

            if (iShuffle)

                { // re-shuffle

                TRAP_IGNORE(SetShuffleL(iShuffle, EFalse));

                }

            SetToLast();

            }

        else

            {

            // Find the next valid item

            //

            do

                {

                --iItemIndex;

                if (iItemIndex>=0 && iItemIndex < iItemIndexes.Count())

                    {

                    iPath->Set(iItemIndexes[iItemIndex]);

                    }    

                }

            while( iPath->Id() == KMPXInvalidItemId && 

                   iItemIndex != KErrNotFound );

            if( iItemIndex < 0 )

                {

                iItemIndex=0;

                ret=Previous();

                }

            }

        }

    MPX_DEBUG2("CMPXCollectionPlaylist::PreviousL %i", iPath->Index());

    return ret;

    }

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

// Sets path to first item

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

//

EXPORT_C void CMPXCollectionPlaylist::SetToFirst()

    {

    if (Count())

        {    

        iItemIndex=0;

        iPath->Set(iItemIndexes[iItemIndex]);

        }

    }

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

// Sets path to last item

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

//   

EXPORT_C void CMPXCollectionPlaylist::SetToLast()

    {

    if (Count())

        {    

        iItemIndex=Count()-1;

        iPath->Set(iItemIndexes[iItemIndex]);

        }

    }

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

// Sets path to a particular index

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

//   

EXPORT_C void CMPXCollectionPlaylist::SetToIndex( TInt aIndex )

    {

    MPX_ASSERT( aIndex >= -1 && aIndex < Count() );

    iItemIndex = aIndex;

    // Special case, the collection path does not support -1 no selection

    if( iItemIndex != -1 )

        {

        iPath->Set(iItemIndexes[iItemIndex]);

        }

    }

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

// Returns the number of items in the same container

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

//

EXPORT_C TInt CMPXCollectionPlaylist::Count() const

    {

    return iItemIndexes.Count();

    }

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

// Returns the depth into the collection (0 = root level, 1 = first level etc.)

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

//    

EXPORT_C TInt CMPXCollectionPlaylist::Levels() const

    {

    return iPath ? iPath->Levels() : 0; 

    }

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

// Returns play ordinal of current item in the playlist

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

//    

EXPORT_C TInt CMPXCollectionPlaylist::Index() const

    {

    TInt index(KErrNotFound);

    if (Count() && iItemIndex < Count())

        {

        index = iItemIndex;

        }

    return index;

    }

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

// Is the collection stored on a remote device

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

//

EXPORT_C TBool CMPXCollectionPlaylist::Remote() const

    {

    MPX_DEBUG2("-->CMPXCollectionPlaylist::Remote iColUtil 0x%08x", iColUtil);

    CMPXCollectionPlaylist *s = const_cast<CMPXCollectionPlaylist*>(this);

    if (!s->iColUtil && iPath)

        {

        TRAP_IGNORE(s->iColUtil=MMPXCollectionUtility::NewL(s, KMcModePlaylist));

        if (s->iColUtil)

            {

            s->iRemote=s->iColUtil->Collection().IsRemote(*iPath);

            }

        }

    MPX_DEBUG2("<--CMPXCollectionPlaylist::Remote iColUtil 0x%08x", iColUtil);

    return iRemote;

    }

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

// Repeat mode

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

//

EXPORT_C CMPXCollectionPlaylist::TRepeatMode 

    CMPXCollectionPlaylist::RepeatMode() const

    {

    return iRepeatMode;

    }

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

// Shuffle

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

//    

EXPORT_C TBool CMPXCollectionPlaylist::Shuffle() const

    {

    return iShuffle;

    }

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

// Collection path

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

//    

EXPORT_C const CMPXCollectionPath& CMPXCollectionPlaylist::Path() const

    {

    return *iPath;

    }

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

// Get media properties for current item

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

//    

EXPORT_C void CMPXCollectionPlaylist::MediaL(

    const TArray<TMPXAttribute>& aAttrs,

    MMPXCollectionMediaObserver& aMediaObs)

    {