/*

* 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 playback engine media helper

*

*/

#include <mpxtaskqueue.h>

#include <mpxcollectionutility.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxlog.h>

#include "mpxplaybackengine.h"

#include "mpxplaybackmediahelper.h"

// CONSTANTS

const TInt KTaskMediaWithAttributeSpec = 0;

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

// Two-phased constructor

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

//

CMPXPlaybackMediaHelper* CMPXPlaybackMediaHelper::NewL(

    CMPXPlaybackEngine& aEngine )

    {

    CMPXPlaybackMediaHelper* p= new (ELeave) CMPXPlaybackMediaHelper( aEngine );

    CleanupStack::PushL(p);

    p->ConstructL();

    CleanupStack::Pop(p);

    return p;

    }

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

// Constructor.

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

//

CMPXPlaybackMediaHelper::CMPXPlaybackMediaHelper(

    CMPXPlaybackEngine& aEngine )

    : iEngine( aEngine )

    {

    }

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

// 2nd phase constructor.

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

//

void CMPXPlaybackMediaHelper::ConstructL()

    {

    iCollectionUtility = MMPXCollectionUtility::NewL( this );

#ifdef __USE_MESSAGE_SUBSCRIPTION

    // This class does not care about collection messages

    iCollectionUtility->Collection().ClearSubscriptionsL();

#endif

    iTaskQueue = CMPXActiveTaskQueue::NewL();

    }

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

// Destructor

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

//

CMPXPlaybackMediaHelper::~CMPXPlaybackMediaHelper()

    {

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        }

    if ( iTaskQueue )

        {

        iTaskQueue->CancelRequests();

        delete iTaskQueue;

        }

    }

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

// Retrieves the media given the current path, and upon return,

// either calls back the observer, or broadcasts the message to

// the given client list

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

void CMPXPlaybackMediaHelper::MediaL(

    const CMPXCollectionPath& aPath,

    CMPXCommand* aCmd,

    MMPXPlaybackEngineObserver* aObserver,

    TBool aBroadcast /*= EFalse */,

    CMPXClientList* aClientList /*= NULL */ )

    {

    MPX_DEBUG1("CMPXPlaybackMediaHelper::MediaL(): Entering");

    CMPXCollectionPath* path( CMPXCollectionPath::NewL( aPath ) );

    CleanupStack::PushL( path );

    CleanupStack::PushL( aCmd );

    if ( aBroadcast )

        {

        iTaskQueue->AddTaskL( KTaskMediaWithAttributeSpec,

                              aClientList,

                              this,

                              ETrue,

                              NULL,

                              NULL,

                              path,

                              aCmd );

        }

    else

        {

        iTaskQueue->AddTaskL( KTaskMediaWithAttributeSpec,

                              aObserver,

                              this,

                              EFalse,

                              NULL,

                              NULL,

                              path,

                              aCmd );

        }

    // Ownership of aAttrs and path passed to the task queue

    CleanupStack::Pop( aCmd );

    CleanupStack::Pop( path );

    MPX_DEBUG1("CMPXPlaybackMediaHelper::MediaL(): Exiting");

    }

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

// Cancels all outstanding requests

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

void CMPXPlaybackMediaHelper::CancelRequests()

    {

    MPX_FUNC_EX("CMPXPlaybackMediaHelper::CancelRequests()");

    if ( iCollectionUtility )

        {

        iCollectionUtility->Collection().CancelRequest();

        }

    if ( iTaskQueue )

        {

        iTaskQueue->CancelRequests();

        }

    }

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

// From MMPXTaskQueueObserver

// Executes task

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

void CMPXPlaybackMediaHelper::ExecuteTask(

    TInt aTask,

    TInt aParamData,

    TAny* aPtrData,

    const CBufBase& aBuf,

    TAny* aCallback,

    CBase* aCObject1,

    CBase* aCObject2)

    {

    MPX_DEBUG1("CMPXPlaybackMediaHelper::ExecuteTask(): Entering");

    TRAPD( err, DoExecuteTaskL( aTask, aParamData, aPtrData,

                                aBuf, aCallback, aCObject1, aCObject2 ));

    if ( KErrNone != err )

        {

        TRAP_IGNORE(

            CMPXMedia* dummy( CMPXMedia::NewL() );

            CleanupStack::PushL( dummy );

            HandleCollectionMediaL( *dummy, err );

            CleanupStack::PopAndDestroy( dummy );

            )

        }

    MPX_DEBUG1("CMPXPlaybackMediaHelper::ExecuteTask(): Exiting");

    }

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

// CMPXPlaybackMediaHelper::HandleTaskError

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

void CMPXPlaybackMediaHelper::HandleTaskError(

    TInt /* aTask */,

    TAny* /*aPtrData*/,

    TAny* /*aCallback*/,

    TInt /* aError */)

    {

    // do nothing, queued tasks are not canceled

    }

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

// From MMPXCollectionObserver

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

void CMPXPlaybackMediaHelper::HandleCollectionMessage(

    CMPXMessage* /*aMsg*/,

    TInt /*aErr*/)

    {

    MPX_DEBUG1("CMPXPlaybackMediaHelper::HandleCollectionMessageL(CMPXMessage): Entering");

    MPX_DEBUG1("CMPXPlaybackMediaHelper::HandleCollectionMessageL(CMPXMessage): Exiting");

    }

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

// From MMPXCollectionObserver

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

void CMPXPlaybackMediaHelper::HandleOpenL(

    const CMPXMedia& /*aEntries*/,

    TInt /*aIndex*/,

    TBool /*aComplete*/,

    TInt /*aError*/ )

    {

    MPX_DEBUG1("CMPXPlaybackMediaHelper::HandleOpenL(): Entering");

    MPX_DEBUG1("CMPXPlaybackMediaHelper::HandleOpenL(): Exiting");

    }

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

// From MMPXCollectionObserver

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

void CMPXPlaybackMediaHelper::HandleOpenL(

    const CMPXCollectionPlaylist& /*aPlaylist*/,

    TInt /*aError*/ )

    {

    MPX_DEBUG1("CMPXPlaybackMediaHelper::HandleOpenL(): Entering");

    MPX_DEBUG1("CMPXPlaybackMediaHelper::HandleOpenL(): Exiting");

    }

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

// From MMPXCollectionObserver

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

void CMPXPlaybackMediaHelper::HandleCommandComplete(

    CMPXCommand* /*aCommandResult*/,

    TInt /*aError*/ )

    {

    MPX_DEBUG1("CMPXPlaybackMediaHelper::HandleCommandComplete(): Entering");

    MPX_DEBUG1("CMPXPlaybackMediaHelper::HandleCommandComplete(): Exiting");

    }

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

// From MMPXCollectionmediaObserver

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

//

void CMPXPlaybackMediaHelper::HandleCollectionMediaL(

    const CMPXMedia& aMedia,

    TInt aError )

    {

    MPX_FUNC_EX("CMPXPlaybackMediaHelper::HandleCollectionMediaL");

    MPX_DEBUG2("CMPXPlaybackMediaHelper::HandleCollectionMediaL(): error %d", aError);

    // First check if media attributes supported, if not, need to retrieve

    // from playback plugin

    TBool mediaOk( ETrue );

    // Note: The following block is for uPnP remote playlist which does not contain

    // metadata in the remote playlist. However, uPnP update to gurantee that titles

    // are available in the collection plugin. If KMPXMediaColDetailMediaNotAvailable

    // returned, UI can at least update title anyway anyway.

    //

    // We could not call MediaFromPluginL before the plugin initiliazed. uPnP made

    // changes so that it will call back media after the new track is initialized.

    // So we don't need call plugin API MediaL.

    /*if ( KErrNone == aError )

        { // media object is ok

        if ( aMedia.IsSupported( KMPXMediaColDetailMediaNotAvailable ))

            {

            TBool mediaNotSupported(

                    aMedia.ValueTObjectL<TBool>( KMPXMediaColDetailMediaNotAvailable ));

            MPX_DEBUG2("HandleCollectionMediaL media not inCollection %d",

                        mediaNotSupported);

            if ( mediaNotSupported)

                { // It must be uPnP remote playlist, media request can only be

                  // sent to plugin at initialising, playing & pause state

                mediaOk = EFalse;

                // need to create a copy of buf since that will be delete when

                // this task is completed

                const TDesC8& data( iTaskQueue->BufData() );

                CBufBase* buf( MPXUser::CreateBufferLC( data.Size() ));

                buf->Write( 0, data );

                iEngine.MediaFromPluginL(

                         static_cast<MMPXPlaybackEngineObserver*>(

                                                    iTaskQueue->Callback() ),

                         buf );

                CleanupStack::Pop( buf );

                } //otherwise, just send uri to clients.

            }

        }*/

    if ( mediaOk || aError )

        {

        MPX_DEBUG2("CMPXPlaybackMediaHelper::HandleCollectionMediaL task %d",

                   iTaskQueue->Task());

        if ( iTaskQueue->Param() )

            {

            // Broadcast

            CMPXMessage* msg( CMPXMessage::NewL() );

            CleanupStack::PushL( msg );

            msg->SetTObjectValueL<TMPXMessageId>( KMPXMessageGeneralId,

                                                  KMPXMessagePbMediaChanged );

            msg->SetCObjectValueL<CMPXMedia>( KMPXMessagePbMedia,

                                              const_cast<CMPXMedia*>( &aMedia ));

            CMPXClientList* clientList(

                static_cast<CMPXClientList*>( iTaskQueue->Callback() ));

            clientList->SendMsg(msg, KErrNone);

            CleanupStack::PopAndDestroy( msg );

            }

        else

            {

            // Callback

            MPX_DEBUG2("CMPXPlaybackMediaHelper::HandleCollectionMediaL task cb 0x%08x",

                       iTaskQueue->Callback());

            MMPXPlaybackEngineObserver* callback(

                static_cast<MMPXPlaybackEngineObserver*>( iTaskQueue->Callback() ));

            callback->HandleMedia( aMedia, aError );

            }

        }

    MPX_DEBUG1("CMPXPlaybackMediaHelper::HandleCollectionMediaL complete task");

    iTaskQueue->CompleteTask();

    }

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

// Executes task, leaving method

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

//

void CMPXPlaybackMediaHelper::DoExecuteTaskL(

    TInt aTask,

    TInt /*aParamData*/,

    TAny* /*aPtrData*/,

    const CBufBase& /*aBuf*/,

    TAny* /*aCallback*/,

    CBase* aCObject1,

    CBase* aCObject2)

    {

    MPX_DEBUG1("CMPXPlaybackMediaHelper::DoExcuteTaskL(): Entering");

    if ( KTaskMediaWithAttributeSpec == aTask )

        {

        CMPXCollectionPath* path( static_cast<CMPXCollectionPath*>(aCObject1));

        CMPXMedia* media( static_cast<CMPXMedia*>(aCObject2));

        CMPXAttributeSpecs* specs =

                media->Value<CMPXAttributeSpecs>( KMPXCommandMediaAttributeSpecs );

        const TDesC& attr = media->ValueText( KMPXCommandMediaAttribute );

        TPtrC8 ptr = MPXUser::Ptr( attr );

        RDesReadStream readStream( ptr );

        CleanupClosePushL( readStream );

        // Internalize attributes

        RArray<TMPXAttribute> attrs;

        CleanupClosePushL( attrs );

        ::InternalizeL( attrs, readStream );

        iCollectionUtility->Collection().MediaL(*path,

                                                attrs.Array(),

                                                specs );

        CleanupStack::PopAndDestroy( &attrs );

        CleanupStack::PopAndDestroy( &readStream );

        }

    else

        {

        iTaskQueue->CompleteTask();

        }

    MPX_DEBUG1("CMPXPlaybackMediaHelper::DoExcuteTaskL(): Exiting");

    }

//End of file