/*

* Copyright (c) 2008 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:      Plugin for playing files in a remote upnp renderer

*

*/

// INCLUDES

#include "upnpavcontrollerfactory.h"

#include "upnpavcontroller.h"

#include "upnpfileutility.h"

#include "upnpavrenderingsession.h"

#include "upnpavdevice.h"

#include <mpxplaybackpluginobserver.h>

#include "upnpmusicplayer.h"

#include "upnpsingleton.h"

#include "upnptrack.h"

#include "upnpplaybackstatemachine.h"

#include "upnpvaluestatemachine.h"

#include "upnppluginserrortranslation.h"

// CONSTANTS

// ** a message to music player to complete an immediate exit

const TInt KMusicPluginMessageExit = 3001;

const TUid KMusicPlayerUid = { 0x200075D8 };

_LIT( KStateUninitialized, "Uninitialised" );

_LIT( KStateUninitialising, "Uninitialising" );

_LIT( KStateInitializing, "Initializing" );

_LIT( KStateActive, "Active" );

_LIT( KStatePreInitializing, "PreInitializing" );

_LIT( KStatePreInitialized, "PreInitialized" );

_LIT( KStateWaiting, "Waiting" );

_LIT( KStateActiveForceInit, "ActiveForceInit" );

_LIT( KStateError, "Error" );

_LIT( KStateUnknown, "Unknown" );

_LIT( KComponentLogfile, "musicplugins.txt");

#include "upnplog.h"

// LOCAL FUNCTIONS

    /*

     * a template helper function to safely delete a pointer

     * (make sure pointer becomes NULL before delete is called)

     * 1. first copy the given pointer to a local temp variable

     * 2. then allocate a local member, then nullify the given pointer

     * 3. last, delete the temporary pointer

     */

    template <class T>

    inline void SafeDelete( T*& aPointer )

        {

        // first, store the given object into a local temp variable

        T* tempPointer = aPointer;

        // nullify the given pointer

        aPointer = 0;

        // last, delete the given object

        delete tempPointer;

        }

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

// Static members of CUPnPMusicPlayer

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

//

// Pointer to the plugin that is active at the time

CUPnPMusicPlayer* CUPnPMusicPlayer::iActivePlugIn;

// Pointer to the plugini that is waiting to activate (pre-initialized)

CUPnPMusicPlayer* CUPnPMusicPlayer::iNextPlugIn;

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

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

// CUPnPMusicPlayer::NewL

// 1st phase constructor.

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

//

CUPnPMusicPlayer* CUPnPMusicPlayer::NewL( MMPXPlaybackPluginObserver& aObs )

    {

    CUPnPMusicPlayer* p = new(ELeave) CUPnPMusicPlayer( aObs );

    CleanupStack::PushL( p );

    __LOG1( "CUPnPMusicPlayer::NewL [%d]", p );

    p->ConstructL();

    CleanupStack::Pop( p );

    return p;

    }

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

// CUPnPMusicPlayer::CUPnPMusicPlayer

// Default constructor.

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

// 

CUPnPMusicPlayer::CUPnPMusicPlayer( MMPXPlaybackPluginObserver& aObs ) :

    iSelectedRendererIndex( KErrNotFound ),

    iPlayerState( EStateUninitialised ),

    iIsReady( EFalse )

    {   

    iObs = &aObs;

    iTrack = NULL;

    }

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

// CUPnPMusicPlayer::ConstructL

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

//

void CUPnPMusicPlayer::ConstructL()

    {

    __LOG( "CUPnPMusicPlayer::ConstructL" );

    // get a handle to the shared singleton

    iSingleton = CUPnPSingleton::GetInstanceL();

    // audio policy

    iAudioPolicy = CUPnPAudioPolicy::NewL( *this );

    }

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

// CUPnPMusicPlayer::~CUPnPMusicPlayer

// Destructor.

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

//

CUPnPMusicPlayer::~CUPnPMusicPlayer()

    {

    __LOG( "CUPnPMusicPlayer::~CUPnPMusicPlayer()" );

    UninitialiseTrack( EStateNone );

    if( iSingleton != NULL )

        {

        CUPnPSingleton::LoseInstance( iSingleton );

        iSingleton = NULL;

        }

    delete iAudioPolicy;

    iAudioPolicy = 0;

    delete iSelectedRenderer;

    } 

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

// CUPnPMusicPlayer::MatchRenderer

// Compares renderers names

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

//

TBool CUPnPMusicPlayer::MatchRenderer(

    const CUpnpAVDevice* aRenderer ) const

    {

    if( aRenderer == NULL  )

        {

        // no renderer - using default renderer, which is always

        // the same as previously selected renderer -> ALWAYS MATCH.

        return ETrue;

        }

    if( iSelectedRenderer == NULL  )

        {

        // Current renderer does not exist - this should never happen.

        __PANICD( __FILE__, __LINE__ );

        return ETrue;

        }

    // compare renderer pointer

    if ( iSelectedRenderer == aRenderer )

        {

        return ETrue;

        }

    // Compare renderer UUID

    if ( iSelectedRenderer->Uuid().Compare( aRenderer->Uuid() ) == 0 )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CUPnPMusicPlayer::UsedRendererDevice

// Returns currently used renderer device

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

//

CUpnpAVDevice& CUPnPMusicPlayer::UsedRendererDevice() const

    {

    return *iSelectedRenderer;

    }

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

// CUPnPMusicPlayer::SetActive

// Set Plugin state to active.

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

//

void CUPnPMusicPlayer::SetActive( TBool aForceInitialise )

    {

    __LOG( "CUPnPMusicPlayer::SetActive" );

    if ( iActivePlugIn != 0 &&

        iActivePlugIn->MatchRenderer( iSelectedRenderer ) )

        {

        // Continuing playback on the same renderer.

        // copy some cached values

        // 

        iValueStateMachine->CopyValues(

            iActivePlugIn->ValueStateMachine() );

        }

    if( iPlayerState == EStatePreInitialized ) 

        {

        // Preinitialize is ready. Clear pointer from iNextPlugin and 

        // sets it to iActivePlugIn.

        iActivePlugIn = this;

        iNextPlugIn = NULL;

        if( aForceInitialise )

            {

            ChangeState( EStateActiveForceInitialise );

            TRAP_IGNORE( iAudioPolicy->PlayL() );

            }

        else

            {

            ChangeState( EStateActive );

            TRAP_IGNORE( iAudioPolicy->PlayL() );

            }

        }

    else if( iPlayerState == EStateWaiting )

        {

        // Used renderer does not support SetNextURI feature. Initialise

        // track by SetURI after play command.

        iActivePlugIn = this;

        iNextPlugIn = NULL;

        ChangeState( EStateActiveForceInitialise );

        }

    else if( iPlayerState == EStateActive )

        {

        // do nothing

        iActivePlugIn = this;

        iNextPlugIn = NULL;

        ChangeState( EStateActive );

        TRAP_IGNORE( iAudioPolicy->PlayL() );

        }

    else if( iPlayerState == EStatePreInitializing )

        {

        // Do nothing.

        }

    else

        {

        __LOG1( "CUPnPMusicPlayer::SetActive in wrong state %S",

            State( iPlayerState ) );

        __PANICD( __FILE__, __LINE__ );

        }   

    }

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

// CUPnPMusicPlayer::Observer

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

//

MMPXPlaybackPluginObserver& CUPnPMusicPlayer::Observer() const

    {

    __ASSERTD( iObs != 0, __FILE__, __LINE__ );

    return *iObs;

    }

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

// CUPnPMusicPlayer::PlaybackStateMachine

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

//

const CUPnPPlaybackStateMachine&

    CUPnPMusicPlayer::PlaybackStateMachine() const

    {

    __ASSERTD( iPlaybackStateMachine != 0, __FILE__, __LINE__ );

    return *iPlaybackStateMachine;

    }

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

// CUPnPMusicPlayer::ValueStateMachine

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

//

const CUPnPValueStateMachine&

    CUPnPMusicPlayer::ValueStateMachine() const

    {

    __ASSERTD( iValueStateMachine != 0, __FILE__, __LINE__ );

    return *iValueStateMachine;

    }

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

// CUPnPMusicPlayer::Track

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

//

CUPnPTrack& CUPnPMusicPlayer::Track() const

    {

    __ASSERTD( iTrack != 0, __FILE__, __LINE__ );

    return *iTrack;

    }

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

// CUPnPMusicPlayer::HandlePlayStarted

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

//

void CUPnPMusicPlayer::HandlePlayStarted()

    {

    __LOG( "CUPnPMusicPlayer::HandlePlayStarted" );

    // Remote device is ready for give playback information 

    // (duration, position..)

    iIsReady = ETrue;

    // Inform user that playback is started

    iObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPPlaying, 0,

        KErrNone );

    if( iValueStateMachine && iTrack )

        {

        // always query volume. Duration if not already exist or in 

        // case of remote track.

        TRAP_IGNORE(

            iValueStateMachine->VolumeQueryL();

            if( iTrack->TrackDuration() == 0 || iTrack->IsRemote() )

                {

                iValueStateMachine->DurationQueryL();

                }

            )

        }

    }

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

// CUPnPMusicPlayer::HandlePlayComplete

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

//

void CUPnPMusicPlayer::HandlePlayComplete()

    {

    __LOG( "CUPnPMusicPlayer::HandlePlayComplete" );

    iAudioPolicy->Stop();

    // If there is a next initialized plugin then active it

    if( iActivePlugIn == this && iNextPlugIn != 0 )

        {

        // Set iActivePlugIn to null.

        iNextPlugIn->SetActive( EFalse );   

        }

    }

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

// Methods from CMPXPlaybackPlugin

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

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

// CUPnPMusicPlayer::InitialiseL( const TDesC& aSong )

// Initializes a song for playback.

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

//

void CUPnPMusicPlayer::InitialiseL( const TDesC& aSong )

    {    

    // Initialise song for play back.

    InitialiseTrackL( aSong );

    }

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

// CUPnPMusicPlayer::InitialiseL(  RFile& aSong )

// Initializes a song for playback.

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

//   

void CUPnPMusicPlayer::InitialiseL( RFile& aSong )

    {

    // At first get the song path from given resource file

    HBufC* tempBuf = HBufC::NewL( KMaxFileName );

    CleanupStack::PushL( tempBuf );

    TPtr ptr = tempBuf->Des();

    TInt err = aSong.FullName( ptr );

    // Leave if any error

    if( err != KErrNone )

        {

        User::Leave( KErrArgument );

        }

    // Initialise song for play back.

    InitialiseTrackL( *tempBuf );

    CleanupStack::PopAndDestroy( tempBuf );

    }

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

// CUPnPMusicPlayer::InitialiseTrackL

// Initializes a remote or local song for playback

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

//

void CUPnPMusicPlayer::InitialiseTrackL( const TDesC& aSong )

    {

    __LOG1( "CUPnPMusicPlayer::InitialiseTrackL [%d]", this );

    __ASSERTD( iPlayerState == EStateUninitialised, __FILE__, __LINE__ );

    // some state checks

    if ( iPlayerState != EStateUninitialised )

        {

        __LOG( "CUPnPMusicPlayer::InitialiseTrackL: In wrong state! " );

        User::Leave( KErrNotReady );

        }

    if( ( iActivePlugIn != NULL ) && ( iNextPlugIn != NULL ) )

        {

        __LOG( "CUPnPMusicPlayer::InitialiseTrackL - \

        More than two plugin initialisezed at the same time! " );

        User::Leave( KErrNotReady );

        }

    if( iSelectedRenderer == 0 )

        {

        __LOG( "CUPnPMusicPlayer::InitialiseTrackL - \

        Subplayer not selected " );

        User::Leave( KErrNotReady );

        }

    if( aSong.Length() == 0 )

        {

        User::Leave( KErrNotSupported );

        }

    __LOG( "CUPnPMusicPlayer::InitialiseTrackL: Start rendering session" );

    MUPnPAVRenderingSession* tempSession =

        &iSingleton->AVC().StartRenderingSessionL( *iSelectedRenderer );

    __LOG( "CUPnPMusicPlayer::InitialiseTrackL - \

        Set Rendering session observer" );

    // Set media observer

    tempSession->SetObserver( *this );

    // stop existing rendering session if exists

    if( iRendererSession )

        {

        __LOG( "CUPnPMusicPlayer::InitialiseTrackL: Stop old session" );

        // releasing local MS services is left to AVController

        iSingleton->AVC().StopRenderingSession( *iRendererSession );

        iRendererSession = 0;

        }

    iRendererSession = tempSession;

    // Set plugin to active and call SetURI if there is no track

    // playing currently or the track playing currently is in 

    // different renderer

    if( iActivePlugIn == NULL ) 

        {

        // There is no track playing currently

        iActivePlugIn = this; // Set Plugin to the active.

        ChangeState( EStateInitializing );

        }

    else // Track is currently playing.

        {

        // Check if track is playing in different renderer

        if( iActivePlugIn->MatchRenderer( iSelectedRenderer ) )

            {

            iNextPlugIn = this; // Set plugin to the next

            ChangeState( EStatePreInitializing );

            }

        else

            {

            // Track is playing but different renderer

            ChangeState( EStateInitializing );

            }

        } 

    // Create state machines

    iPlaybackStateMachine = CUPnPPlaybackStateMachine::NewL(

        *this, *iRendererSession );

    iValueStateMachine = CUPnPValueStateMachine::NewL(

        *this, *iRendererSession );

    // Create track object to resolving URI

    iTrack = CUPnPTrack::NewL( iSingleton->AVC() );

    iTrack->ResolveURIL( aSong, *this, CUPnPTrack::EDirectionRemote );

    }

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

// CUPnPMusicPlayer::UninitialiseTrack

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

// 

void CUPnPMusicPlayer::UninitialiseTrack( TPlayerState aToState )

    {

    __LOG1( "CUPnPMusicPlayer::UninitialiseTrack(%S)",

        State( aToState ) );

    ChangeState( EStateUninitialising );

    if ( iAudioPolicy )

        {

        iAudioPolicy->Stop();

        }

    if ( iActivePlugIn == this )

        {

        iActivePlugIn = 0;

        }

    if ( iNextPlugIn == this )

        {

        iNextPlugIn = 0;

        }

    if( iPlaybackStateMachine )

        {

        delete iPlaybackStateMachine;

        iPlaybackStateMachine = 0;

        }

    if( iValueStateMachine )

        {

        delete iValueStateMachine;

        iValueStateMachine = 0;

        }

    // Rendering session is not cleared until destructor.

    if( iRendererSession && aToState == EStateNone )

        {