/*

* 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:  Initialize a file before playback

*

*/

#include <mpxcollectionpath.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxmedia.h>

#include <mpxcollectionplaylist.h>

#include <mpxplaybackplugin.h>

#include <mpxlog.h>

#include <mpxmediageneralextdefs.h>

#include <mpxplaybackpluginversion2.h>

#include "mpxplaybackinitializer.h"

#include "mpxplaybackpluginhandler.h"

#include "mpxplaybackengine.h"

#include "mpxplaybackmediahelper.h"

const TInt KMPXInitTimer = 3000000; // 3 seconds

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

// CMPXPlaybackInitializer* NewL

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

//

CMPXPlaybackInitializer* CMPXPlaybackInitializer::NewL(

    CMPXPlaybackEngine& aEngine,

    CMPXPlaybackMediaHelper& aMediaHelper )

    {

    CMPXPlaybackInitializer* self = new (ELeave)

        CMPXPlaybackInitializer( aEngine, aMediaHelper );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Constructor

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

//

CMPXPlaybackInitializer::CMPXPlaybackInitializer(

    CMPXPlaybackEngine& aEngine,

    CMPXPlaybackMediaHelper& aMediaHelper )

    : iState( EPbStateNotInitialised ),

      iEngine( aEngine ),

      iMediaHelper( aMediaHelper )

    {

    }

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

// CMPXPlaybackInitializer::ConstructL

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

//

void CMPXPlaybackInitializer::ConstructL()

    {

    iMedia = CMPXMedia::NewL();

    iTimer = CPeriodic::NewL( CActive::EPriorityIdle );

    }

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

// Destructor

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

//

CMPXPlaybackInitializer::~CMPXPlaybackInitializer()

    {

    delete iMedia;

    delete iMediaMessage;

    Close();

    CancelPreInitTimer();

    delete iTimer;

    }

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

// CMPXPlaybackInitializer::Init

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

//

void CMPXPlaybackInitializer::Init( CMPXCollectionPlaylist& aPlaylist )

    {

    MPX_FUNC_EX("CMPXPlaybackInitializer::Init aPlaylist");

    // Check if we already initialized the song in this playlist,

    // if so then do nothing

    if ( !IsInitializing( aPlaylist ))

        {

        Reset(); // clean up all resources (start again)

        delete iHandler;

        iHandler = NULL;

        // Save the path index and count.  This is just in case the

        // engine calls InitL() again before we make a call to

        // Request media, because these are used to check if we're

        // initializing the same song in the IsInitializing() method.

        iPathIndex = aPlaylist.Path().Index();

        iInitPlaylistCount = iEngine.iPlaylist->Count();

        }

    }

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

// CMPXPlaybackInitializer::Next

// Advance the playlist and start initializing (return ETrue) or if there's

// no next song, does nothing (return EFalse)

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

//

TBool CMPXPlaybackInitializer::Next()

    {

    MPX_FUNC("CMPXPlaybackInitializer::Next");

    ASSERT( iEngine.iPlaylist );

    TInt nextPlIndex( KErrNotFound );

    TBool playNext( iEngine.iPlaylist->NextIndex( EFalse, nextPlIndex ));

    Reset(); // Reset state

    // Only pre-init if there is a next song

    if ( playNext )

        {

        MPX_DEBUG1("CMPXPlaybackInitializer::Next(): Starting timer");

        iPathIndex = iEngine.iPlaylist->PathIndex( nextPlIndex );

        iInitPlaylistCount = iEngine.iPlaylist->Count();

        CancelPreInitTimer();

        // Start timer

        iTimer->Start(

            KMPXInitTimer,

            KMPXInitTimer,

            TCallBack(PreInitTimerCallback, this ));

        }

    return playNext;

    }

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

// CMPXPlaybackInitializer::SetActiveL. Swaps the item being handled in the

// initializer to the engine, which takes over in whatever state it currently

// is in

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

//

void CMPXPlaybackInitializer::SetActiveL()

    {

    ASSERT(iEngine.iPlaylist);

    MPX_DEBUG3("-->CMPXPlaybackInitializer::SetActiveL state %d, error %d",

                iState, iError);

    CancelPreInitTimer();

    switch(iState)

        {

        case EPbStateNotInitialised:

        //

        // From NewL()/InitL()/NextL()/PreviousL()

        // up until the requested media URI is returned.

        // Need to swap the playlist only (no plugin has

        // yet been resolved

        //

            {

            if (iEngine.iPlaylist)

                {

                //

                // Get the URI from the collection - the callback triggers

                // the initialization

                //

                RequestMediaL();

                UpdateMediaForwarding();

                }

            break;

            }

        case EPbStateInitialising:

        //

        // From NewL()/InitL()/NextL()/PreviousL() up

        // until the URI has been returned, plug-in is

        // being intialized OR an error has been returned

        // from playlist

        //

            {

            UpdateMediaForwarding();

            SwapUriL();

            SwapFlag();

            if (iError==KErrNone)

                //

                // Plug-in must be initialising

                //

                {

                SwapPluginL();

                }

            else

                {

                //

                // Hasn't got as far as initialising a plug-in

                //

                iEngine.HandleCollectionMediaL(*iMedia,iError);

                }

            break;

            }

        case EPbStateStopped:

        //

        // From NewL()/InitL()/NextL()/PreviousL() up

        // until the plug-in has been initialised, either

        // successfully or with an error

        //

            {

            UpdateMediaForwarding();

            SwapPluginL();

            SwapUriL();

            SwapFlag();

            if (iError==KErrNone)

                {

                iEngine.HandlePluginEvent(EPInitialised,iDuration,KErrNone);

                }

            else

                {

                iEngine.HandlePluginEvent(EPInitialised,0,iError);

                }

            break;

            }

        default:

            ASSERT(0) ;

        }

    MPX_DEBUG1("<--CMPXPlaybackInitializer::SetActiveL");

    }

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

// CMPXPlaybackInitializer::Close. Resets and destroys all resources owned by

// initializer

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

//

void CMPXPlaybackInitializer::Close()

    {

    MPX_FUNC("CMPXPlaybackInitializer::Close");

    CancelPreInitTimer();

    Reset(); // must come after handler deletion

    delete iHandler;

    iHandler=NULL;

    }

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

// Gets the current item id in use by the initializer

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

//

TMPXItemId CMPXPlaybackInitializer::CurrentInitItemId()

    {

    TMPXItemId id( KMPXInvalidItemId );

    if( iState != EPbStateNotInitialised && iEngine.iPlaylist )

        {

        id = iEngine.iPlaylist->Path().Id();

        }

    return id;

    }

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

// Implementation uid of the plugin for pre-initialzer

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

//

TUid CMPXPlaybackInitializer::PluginUid()

    {

    TUid uid(KNullUid);

    if (iHandler)

        {

        if (iHandler->Plugin())

            {

            uid = iHandler->Plugin()->Uid();

            }

        }

    return uid;

    }

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

// CMPXPlaybackInitializer::Reset. Resets such that next media can be initialised

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

//

void CMPXPlaybackInitializer::Reset()

    {

    MPX_FUNC("CMPXPlaybackInitializer::Reset");

    //

    // Cancel any activity with current plug-in

    //

    if (iHandler)

        {

        if (iHandler->Plugin())

            {

            TRAP_IGNORE(iHandler->Plugin()->CommandL(EPbCmdStop));

            TRAP_IGNORE(iHandler->Plugin()->CommandL(EPbCmdClose));

            }

        }

    //

    // Reset data associated with previous initialization

    //

    iState = EPbStateNotInitialised;

    iError = KErrNone;

    iDuration = 0;

    iPathIndex = KErrNotFound;

    iInitPlaylistCount = 0;

    }

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

// CMPXPlaybackInitializer::RequestMediaL

// Get the Media from the collection - the callback triggers

// the initialization

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

//

void CMPXPlaybackInitializer::RequestMediaL( )

    {

    ASSERT(iEngine.iPlaylist);

    MPX_DEBUG3("-->CMPXPlaybackInitializer::RequestMediaL 0x%08x item index %d",

               this, iEngine.iPlaylist->Index());

    // Reset media message

    delete iMediaMessage;

    iMediaMessage = NULL;

    iErrorOfMediaMessage = KErrNone;

    // Setup attribute array

    RArray<TMPXAttribute> attrs;

    CleanupClosePushL(attrs);

    attrs.Append(KMPXMediaGeneralId);

    attrs.Append(KMPXMediaGeneralUri);

    attrs.Append(KMPXMediaGeneralMimeType);

    attrs.Append(KMPXMediaGeneralLastPlaybackPosition);

    attrs.Append(KMPXMediaGeneralFlags);

    attrs.Append(KMPXMediaGeneralDuration);

    attrs.Append(KMPXMediaGeneralTitle);

    attrs.Append( KMPXMediaMusicArtist );

    // Create object to hold attributes and specs

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL<TInt>(KMPXCommandGeneralId, KMPXCommandContentIdMedia);

    CBufBase* buf = CBufFlat::NewL( KMPXBufGranularity );

    CleanupStack::PushL( buf );

    RBufWriteStream writeStream( *buf );

    CleanupClosePushL( writeStream );

    // externalize attributes array

    ::ExternalizeL(attrs.Array(), writeStream);

    // Close and compress buffer

    writeStream.CommitL();

    buf->Compress();

    CleanupStack::PopAndDestroy( &writeStream );

    TPtrC ptr( MPXUser::Ptr( buf->Ptr( 0 )));

    cmd->SetTextValueL( KMPXCommandMediaAttribute, ptr );

    CMPXAttributeSpecs* attrSpecs( CMPXAttributeSpecs::NewL() );

    CleanupStack::PushL( attrSpecs );

    cmd->SetCObjectValueL<CMPXAttributeSpecs>(

        KMPXCommandMediaAttributeSpecs, attrSpecs );

    CleanupStack::PopAndDestroy( attrSpecs );

    // Instead of copying the whole path object, which may be large due

    // to number of songs in the list, just get the container path and

    // append the item ID to that.  This saves memory and time.

    const CMPXCollectionPath& path( iEngine.iPlaylist->Path() );

    CMPXCollectionPath* initPath( path.ContainerPathL() );

    CleanupStack::PushL( initPath );

    initPath->AppendL( path.IdOfIndex( iPathIndex ) );

    iMediaHelper.MediaL( *initPath,

                         cmd,   // ownership passed

                         this );

    CleanupStack::PopAndDestroy( initPath );

    CleanupStack::PopAndDestroy( buf );

    CleanupStack::Pop( cmd );

    CleanupStack::PopAndDestroy( &attrs );

    iMediaRequested = ETrue;

    MPX_DEBUG2("<--CMPXPlaybackInitializer::RequestMediaL 0x%08x", this);

    }    

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

// CMPXPlaybackInitializer::UpdateMediaForwarding. Updates the forwarding variable

// to send the media to the engine if a media has been requested.

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

//

void CMPXPlaybackInitializer::UpdateMediaForwarding()

    {

    MPX_FUNC("CMPXPlaybackInitializer::UpdateMediaForwarding");

    // Forward the media to the engine if it has been requested.

    // The difference between the iMediaToEngine and iMediaRequested flags,

    // is that if the engine calls this method first (through SetActive()),

    // but the media has not been requested yet, then we want to make sure

    // in that case to not forward the subsequent media requests

    iMediaToEngine = iMediaRequested ? ETrue : EFalse;

    }

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

// CMPXPlaybackInitializer::SwapPluginL. Swaps the plugin being handled in the

// initializer to the engine, which takes over in whatever state it currently

// is in

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

//

void CMPXPlaybackInitializer::SwapPluginL()

    {

    MPX_DEBUG1("==>CMPXPlaybackInitializer::SwapPluginL");

    // unfinished business with old playback plug-in

    if (iEngine.iPluginHandler->Plugin())

        {

        iEngine.iPluginHandler->Plugin()->CancelRequest();

        }

    TInt index( iEngine.iPlaylist->Index() );

    TMPXPlaybackMessage msg( TMPXPlaybackMessage::EStateChanged,

                             EPbStateInitialising,

                             index );

    iEngine.SetStateL( msg );

    TRAPD(err, iEngine.DoStopL());

    if (err)

        { // play is not available. e.g. power off

        MPX_DEBUG2("CMPXPlaybackInitializer::SwapPluginL stop leave %d", err);

        iError = err; // save error

        }

    else

        {

        if ( iMedia )

            {

            iEngine.RestorePlaybackPositionAndStateL( *iMedia );

            }

        //

        // Set plug-in handler

        //

        if ( iHandler )

            {

            CMPXPlaybackPluginHandler*& h=iEngine.iPluginHandler;

            delete h; // delete engine's handler

            // plug-in handler now reports to engine

            iHandler->SetObserver(iEngine); 

            if (iHandler->Plugin())

                {

                iHandler->Plugin()->SetObserver(iEngine);

                }

            h=iHandler; // replace engine's handler

            iHandler=NULL; // reset handler in initializer

            }

        if (iMediaMessage)

            {

            iEngine.HandlePlaybackMessage(iMediaMessage, iErrorOfMediaMessage);

            }

        }

    MPX_DEBUG1("<==CMPXPlaybackInitializer::SwapPluginL");

    }

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

// CMPXPlaybackInitializer::SwapUriL. Swaps the item uri in the engine

// Only in the EPbStateInitialising and EPbStateStopped states

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

//

void CMPXPlaybackInitializer::SwapUriL()

    {

    // Update the engine's uri to the item that was in the initializer

    //

    delete iEngine.iUri ;

    iEngine.iUri = NULL;

    if ( iMedia->IsSupported( KMPXMediaGeneralUri ))

        {

        iEngine.iUri = iMedia->ValueText(KMPXMediaGeneralUri).AllocL();

        }

    }

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

// CMPXPlaybackInitializer::SwapFlag. Swaps the item db flag in the engine

// Only in the EPbStateInitialising and EPbStateStopped states

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

//

void CMPXPlaybackInitializer::SwapFlag()

    {

    // Update the engine's flag to the item that was in the initializer

    //

    if ( iMedia->IsSupported( KMPXMediaGeneralFlags ) )

        {

        iEngine.iDbFlag = iMedia->ValueTObjectL<TUint>( KMPXMediaGeneralFlags );

        }

    else // not supported, reset to 0

        {

        iEngine.iDbFlag = 0;

        }

    // Also swap item id

    if ( iMedia->IsSupported( KMPXMediaGeneralId ))

        {

        iEngine.iItemId = iMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );

        }

    else

        {

        iEngine.iItemId = KMPXInvalidItemId;

        }

    // Also swap duration value

    if ( iMedia->IsSupported( KMPXMediaGeneralDuration ))

        {

        iEngine.iMediaDuration = iMedia->ValueTObjectL<TInt>( KMPXMediaGeneralDuration );

        }

    else

        {

        iEngine.iMediaDuration = 0;

        }

    iEngine.iAccessPointSet = EFalse;

    if ( iMedia->IsSupported(KMPXMediaGeneralExtAccessPoint) )

        {

        TInt accessPoint = iMedia->ValueTObjectL<TInt>( KMPXMediaGeneralExtAccessPoint );

        iEngine.iAccessPoint = accessPoint;

        if ( accessPoint )

            {

            iEngine.iAccessPointSet = ETrue;

            }

        }

    else

        {

        iEngine.iAccessPoint = 0;

        }

    }

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

// CMPXPlaybackInitializer::IsInitializing