/*

* 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);

        {

        }

    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