/*

* 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:  handles music playing within UPnP framework

*

*/

// INCLUDE FILES

// MPX framework api

#include <mpxcommonframeworkdefs.h>

#include <mpxcollectionplaylist.h>

#include <mpxplaybackframeworkdefs.h>

#include <mpxmediaarray.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxplaybackutility.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionplaylist.h>

#include <mpxplaybackmessage.h>

#include <mpxviewutility.h>

#include <mpxcollectionpath.h>

#include <mpxcollectionmessage.h>

#include <mpxmessagegeneraldefs.h>

// upnpframework / avcontroller api

#include "upnpavcontroller.h"

#include "upnpavbrowsingsession.h"

#include "upnpavdevice.h"

// musicadapter internal

#include "upnpmpxhelper.h"

#include "upnpplaylistfiller.h"

#include "upnpmusicadapter.h"

// debug

_LIT16( KComponentLogfile, "musicadapter.txt" );

#include "upnplog.h"

// constants

_LIT16( KTempPlaylistTitle, "TempPlaylist" );

const TUid KRemotePlayerUid = { 0x200075D8 }; // Remote player UID

const TUid KLocalPlayerUid = { 0x200075D9 };  // Local player UID

const TUid KHomeConnectUid = { 0x10208A0A };  // Home Connect app UID

const TUid KPlaybackDialogUid = { 0x101FFCBD }; // UPnPPlayback dialog UID

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

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

// CUPnPMusicAdapter::NewL

// 1st phase constructor.

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

//

EXPORT_C CUPnPMusicAdapter* CUPnPMusicAdapter::NewL( 

MUPnPAVController& aAVController )

    {

    __LOG( "CUPnPMusicAdapter::NewL" );

    CUPnPMusicAdapter* self = new(ELeave) CUPnPMusicAdapter( aAVController );

    __LOG1( "CUPnPMusicAdapter: self = %x", self );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUPnPMusicAdapter::CUPnPMusicAdapter

// Default constructor.

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

//

CUPnPMusicAdapter::CUPnPMusicAdapter( MUPnPAVController& aAVController )

    : iAVController( aAVController )

    {

    iTrackArray = 0;

    iPlaylist = 0;

    iState = EStateIdle;

    }

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

// CUPnPMusicAdapter::ConstructL

// 1st phase constructor.

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

// 

void CUPnPMusicAdapter::ConstructL()

    {

    __LOG( "CUPnPMusicAdapter::ConstructL" );

    // Create playbackutility for playback comands

    iPlaybackUtility = MMPXPlaybackUtility::NewL( KHomeConnectUid, this );

    __LOG1( "iPlaybackUtility = %x", iPlaybackUtility );

    // Create collectionutility 

    iCollectionUtility = MMPXCollectionUtility::NewL( this, 

    KHomeConnectUid );

    __LOG1( "iCollectionUtility = %x", iCollectionUtility );

    // Get an instance of view utility

    iViewUtility = MMPXViewUtility::UtilityL();

    __LOG1( "iViewUtility = %x", iViewUtility );

    // internal MPX helper for some advanced operations

    iMpxHelper = CUPnPMpxHelper::NewL( KHomeConnectUid );

    __LOG( "CUPnPMusicAdapter::ConstructL - end" );

    }

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

// CUPnPMusicAdapter::~CUPnPMusicAdapter

// Destructor.

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

//

EXPORT_C CUPnPMusicAdapter::~CUPnPMusicAdapter()

    {

    __LOG( "CUPnPMusicAdapter::~CUPnPMusicAdapter()" );

    if ( iCurrentFillerState == EFillerStateFilling )

        {

        iCurrentFiller->CancelFill();

        }

    delete iMedia;

    delete iCurrentFiller;    

    delete iTrackArray;    

    delete iPlaylist;

    delete iWait;

    delete iMpxHelper;

    if( iPlaybackUtility )

        {

        iPlaybackUtility->Close();

        iPlaybackUtility = 0;

        }

    if( iCollectionUtility )

        {

        iCollectionUtility->Close();

        iCollectionUtility = 0;

        }

    if( iViewUtility )

        {

        iViewUtility->Close();

        iViewUtility = 0;

        }

    __LOG( "CUPnPMusicAdapter::~CUPnPMusicAdapter - End" );

    }

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

// CUPnPMusicAdapter::ExecuteMusicLiteInRemoteL

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

//

EXPORT_C TInt CUPnPMusicAdapter::ExecuteMusicLiteInRemoteL(

    CEikAppUi* aAppUi,

    MUPnPPlaylistFiller* aFiller,

    const CUpnpAVDevice& aRenderer )

    {

    __LOG( "CUPnPMusicAdapter::ExecuteMusicLiteInRemoteL" );

    InitState();

    iAppUi = aAppUi;     

    iRemotePlayer = ETrue;

    TakeOwnershipOfTheFiller( aFiller );

    iTargetDevice = &aRenderer;

    // Create and fill playlist

    CreatePlayListL();

    // show the UI

    UiShowLoopL();

     __LOG1( "CUPnPMusicAdapter::ExecuteMusicInRemoteL returns %d",

        iReturnCode );

    return iReturnCode;

    }

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

// CUPnPMusicAdapter::ExecuteMusicLiteInLocalL

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

//

EXPORT_C TInt CUPnPMusicAdapter::ExecuteMusicLiteInLocalL(

    CEikAppUi* aAppUi,

    MUPnPPlaylistFiller* aFiller )

    {

    __LOG( "CUPnPMusicAdapter::ExecuteMusicLiteInLocalL" );

    InitState();

    iAppUi = aAppUi;

    iRemotePlayer = EFalse;

    TakeOwnershipOfTheFiller( aFiller );

    iTargetDevice = 0;

    // Create and fill playlist

    CreatePlayListL();

    // show the UI

    UiShowLoopL();

    __LOG1( "CUPnPMusicAdapter::ExecuteMusicInLocalL returns %d",

        iReturnCode );

    return iReturnCode;

    }

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

// CUPnPMusicAdapter::ExecuteMusicInRemoteL

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

//

EXPORT_C TInt CUPnPMusicAdapter::ExecuteMusicInRemoteL(

    CEikAppUi* aAppUi,

    CUPnPPlayListFiller* aFiller,

    const CUpnpAVDevice& aRenderer )

    {

    __LOG( "CUPnPMusicAdapter::ExecuteMusicInRemoteL" );

    InitState();

    iAppUi = aAppUi;     

    iRemotePlayer = ETrue;

    TakeOwnershipOfTheFiller( aFiller );

    iTargetDevice = &aRenderer;

    // Create and fill playlist

    CreatePlayListL();

    // show the UI

    UiShowLoopL();

     __LOG1( "CUPnPMusicAdapter::ExecuteMusicInRemoteL returns %d",

        iReturnCode );

    return iReturnCode;

    }

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

// CUPnPMusicAdapter::ExecuteMusicInLocalL

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

//

EXPORT_C TInt CUPnPMusicAdapter::ExecuteMusicInLocalL(

    CEikAppUi* aAppUi,

    CUPnPPlayListFiller* aFiller )

    {

    __LOG( "CUPnPMusicAdapter::ExecuteMusicInLocalL" );

    InitState();

    iAppUi = aAppUi;

    iRemotePlayer = EFalse;

    TakeOwnershipOfTheFiller( aFiller );

    iTargetDevice = 0;

    // Create and fill playlist

    CreatePlayListL();

    // show the UI

    UiShowLoopL();

    __LOG1( "CUPnPMusicAdapter::ExecuteMusicInLocalL returns %d",

        iReturnCode );

    return iReturnCode;

    }

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

// CUPnPMusicAdapter::Dismiss

// Dismiss the music player UI

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

//

EXPORT_C void CUPnPMusicAdapter::Dismiss( TInt aReturnCode )

    {

    Exit( aReturnCode );

    }

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

// CUPnPMusicAdapter::UiShowLoop

// Wait to show the UI

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

//

void CUPnPMusicAdapter::UiShowLoopL()

    {

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

    // PART 1 - wait part

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

    if ( iState == EStatePreparing )

        {

        // Not yet ready to go. Wait until signalled to proceed

        iWait = new (ELeave) CActiveSchedulerWait();

        __LOG( "UiShowLoopL: wait..." );

        iState = EStatePreparingWait;

        iWait->Start();

        delete iWait;

        iWait = 0;

        }

    else 

        {

        __LOG( "UiShowLoopL: no need to wait" );

        }

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

    // PART 2 - action part

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

    if ( iState == EStateInitialising )

        {

        __LOG( "Activate playback view" );  

        iViewUtility->ActivateViewL( KPlaybackDialogUid );

        iState = EStateClosing;

        }

    else if ( iState == EStateClosing )

        {

        // Exit signalled before UI was shown

        }

    else

        {

        // illegal state

        __PANICD( __FILE__, __LINE__ );

        }

    iState = EStateIdle;

    }

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

// CUPnPMusicAdapter::DisplayUI

// Commands the UI to show

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

//

void CUPnPMusicAdapter::DisplayUI()

    {

    __LOG1( "CUPnPMusicAdapter::DisplayUI() in state %d",

        iState );

    if ( iState == EStatePreparing )

        {

        // UiShowLoop can show UI directly - no wait

        iState = EStateInitialising;

        }

    else if ( iState == EStatePreparingWait )

        {

        // release wait loop in UiShowLoop

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

        iState = EStateInitialising;

        iWait->AsyncStop();

        }

    else

        {

        // should never be here

        __PANICD( __FILE__, __LINE__ );

        }

    }

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

// CUPnPMusicAdapter::Exit

// Performs cleanup and releases the execute thread

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

//

void CUPnPMusicAdapter::Exit( TInt aReturnCode )

    {

    __LOG2( "CUPnPMusicAdapter::Exit(%d) in state %d",

        aReturnCode, iState );

    if ( iState == EStatePreparing )

        {

        // change state - UiShowLoop will exit immediately

        iReturnCode = aReturnCode;

        iState = EStateClosing;

        }

    if ( iState == EStatePreparingWait )

        {

        // release wait loop in UiShowLoop

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

        iReturnCode = aReturnCode;

        iState = EStateClosing;

        iWait->AsyncStop();

        }

    else if ( iState == EStateInitialising ||

        iState == EStateRunning )

        {

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

        iReturnCode = aReturnCode;

        iState = EStateClosing;

        // Send a close command to plugin with this error code.

        // Plugin will notify that it is not available,

        // and then the player UI will exit

        TRAP_IGNORE( iPlaybackUtility->CommandL( 

            EPbCmdClose, KMusicPluginMessageExit ) );

        }

    else if ( iState == EStateClosing )

        {

        // do nothing - already in exit process

        }

    else

        {

        // should never be here

        __PANICD( __FILE__, __LINE__ );

        }

    }

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

// CUPnPMusicAdapter::CreatePlayList

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

//    

void CUPnPMusicAdapter::CreatePlayListL()

    {

    __LOG( "CUPnPMusicAdapter::CreatePlayList" );

    __ASSERTD( iState == EStateIdle, __FILE__, __LINE__ );

    iState = EStatePreparing;

    // Get collection Uid

    iPlaylistCollectionId = KInMemoryCollection;

    iPlaylistCollectionId = iCollectionUtility->Collection()

        .CollectionIDL( iPlaylistCollectionId );

    // Create and fill the playlist

    iTrackArray = CMPXMediaArray::NewL();

    __LOG( "Filling object list" );

    iCurrentFiller->FillL( *this, *iTrackArray );

    if ( iCurrentFillerState == EFillerStateIdle )

        {

        iCurrentFillerState = EFillerStateFilling;

        }

    iMedia = CMPXMedia::NewL();

    // set collection id

    iMedia->SetTObjectValueL<TUid>(

        KMPXMediaGeneralCollectionId, iPlaylistCollectionId );

    // Set type

    iMedia->SetTObjectValueL<TMPXGeneralType>( 

        KMPXMediaGeneralType, EMPXItem );

    // Set category

    iMedia->SetTObjectValueL<TMPXGeneralCategory>( 

        KMPXMediaGeneralCategory, EMPXPlaylist );

    // Set title

    iMedia->SetTextValueL( 

        KMPXMediaGeneralTitle, KTempPlaylistTitle );

    // set contents

    iMedia->SetCObjectValueL( 

        KMPXMediaArrayContents, iTrackArray );  

    // set size

    __LOG1( "Set Array count=%d", iCurrentFiller->PlaylistSize() );

    iMedia->SetTObjectValueL( 

        KMPXMediaArrayCount,  iCurrentFiller->PlaylistSize() );

    __LOG( "Create collection playlist" );

    // Create collection playlist

    iMpxHelper->AddAndOpenL( KHomeConnectUid, *iMedia );

    __LOG( "CUPnPMusicAdapter::CreatePlayList - end" );

    }

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

// CUPnPMusicAdapter::HandleCollectionMessage

// From MMPXCollectionObserver.

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

//

void CUPnPMusicAdapter::HandleCollectionMessage(CMPXMessage* aMsg, 

    TInt aErr )

    {

    __LOG1( "CUPnPMusicAdapter::HandleCollectionMessage: error %d", aErr );

    if( aMsg && aErr == KErrNone )

        {        

        TInt event = KErrNotSupported;

        TInt type = KErrNotSupported;

        TInt data = KErrNotSupported;

        if( aMsg->IsSupported( KMPXMessageGeneralEvent ) )

            {

            event = *aMsg->Value<TInt>( KMPXMessageGeneralEvent );

            }

        if( aMsg->IsSupported( KMPXMessageGeneralType ) )

            {

            type = *aMsg->Value<TInt>( KMPXMessageGeneralType );

            }

        if( aMsg->IsSupported( KMPXMessageGeneralData ) )

            {

            data = *aMsg->Value<TInt>( KMPXMessageGeneralData );

            }

        TRAPD( error, DoHandleCollectionMessageL( event, type, data ) );

        if ( error != KErrNone )

            {

            __LOG1( "DoHandleCollectionMessageL: leave with %d", error );

            Exit( error );

            }

        }

    else

        {

        Exit( aErr );

        }

    }

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

// CUPnPMusicAdapter::DoHandleCollectionMessageL

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

//

void CUPnPMusicAdapter::DoHandleCollectionMessageL(

    TInt aEvent, TInt /*aType*/, TInt /*aData*/ )

    {

    __LOG( "CUPnPMusicAdapter::DoHandleCollectionMessageL" );

    switch ( aEvent )

        {

        case TMPXCollectionMessage::EPathChanged:

            {

            __LOG( "HandleCollectionMessageL: EPathChanged" );

            if ( iState == EStatePreparing || iState == EStatePreparingWait )

                {

                __LOG( "Pick up playlist from collection" );

                CMPXCollectionPath* path = 

                iCollectionUtility->Collection().PathL();

                CleanupStack::PushL( path );

                // select track with given index

                __LOG1( "Set selected index = %d",

                    iCurrentFiller->SelectedIndex() );

                path->Set( iCurrentFiller->SelectedIndex() );

                __LOG( "Ccreating new playlist" );

                delete iPlaylist;

                iPlaylist = NULL;

                iPlaylist = CMPXCollectionPlaylist::NewL( *path );

                __LOG1( "iPlaylist = %x", iPlaylist );

                iPlaylist->SetEmbeddedPlaylist( ETrue );