/*

* Copyright (c) 2006 - 2007 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:  Playback Utility implementation

*

*/

#include <bamdesca.h>

#include <s32mem.h>

#include <e32math.h>

#include <mpxcmn.h>

#include <mpxplaybackobserver.h>

#include <mpxcollectionplaylist.h>

#include <mpxmedia.h>

#include <mpxmessagemonitor.h>

#include <mpxtaskqueue.h>

#include <mpxuser.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectionpath.h>

#include <mpxplaybackcommanddefs.h>

#include <mpxsubscription.h>

#include <mpxlog.h>

#include "mpxplaybackserverdefs.h"

#include "mpxplaybackutilityimpl.h"

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

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

// Retrieves playback utility from TLS. Creates if it's not there.

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

//

MMPXPlaybackUtility* CMPXPlaybackUtility::UtilityL(

    const TUid& aModeId,

    const TMPXCategory aCategory)

    {

    MPX_FUNC("CMPXPlaybackUtility::UtilityL");

    MMPXPlaybackUtility* utility( NULL );

    // Currently only make the default mode a singleton since it's used the most

    // If needed we could make other modes a singleton as well.  This is why

    // a struct was used to store in the TLS so that more utilities can be

    // added easily.

    if ( KPbModeDefault == aModeId )

        {

        TMPXPlaybackUtilityStruct* s( reinterpret_cast<TMPXPlaybackUtilityStruct*>( Dll::Tls() ));

        if ( !s )

            {

            MPX_DEBUG1("CMPXPlaybackUtility::UtilityL(): Creating default mode");

            utility = CMPXPlaybackUtility::NewL( aModeId, NULL, aCategory );

            CleanupClosePushL( *utility );

            MPX_DEBUG2("CMPXPlaybackUtility::UtilityL(): utility = 0x%08x", utility);

            s = new (ELeave) TMPXPlaybackUtilityStruct;

            s->iDefaultPlaybackUtility = utility;

            Dll::SetTls( s );

            CleanupStack::Pop( utility );

            }

        else

            {

            utility = s->iDefaultPlaybackUtility;

            MPX_DEBUG2("CMPXPlaybackUtility::UtilityL(): Retrieving default mode 0x%08x", utility);

            static_cast<CMPXPlaybackUtility*>( utility )->iRefCount++;

            }

        }

    else

        {

        MPX_DEBUG1("CMPXPlaybackUtility::UtilityL(): Not default mode");

        utility = CMPXPlaybackUtility::NewL( aModeId, NULL, aCategory );

        }

    return utility;

    }

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

// Two phases constructor

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

//

CMPXPlaybackUtility* CMPXPlaybackUtility::NewL(const TUid& aModeId,

                                               MMPXPlaybackObserver* aObs,

                                               const TMPXCategory aCategory)

    {

    CMPXPlaybackUtility* p=new(ELeave)CMPXPlaybackUtility();

    CleanupStack::PushL(p);

    p->ConstructL(aModeId,aObs,aCategory);

    CleanupStack::Pop(p);

    return p;

    }

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

// Destructor

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

//

CMPXPlaybackUtility::~CMPXPlaybackUtility()

    {

    MPX_FUNC_EX("CMPXPlaybackUtility::~CMPXPlaybackUtility");

    Cancel();

#ifdef _ENABLE_GUARD_TIMER

    delete iGuardTimer;

#endif

    if (iTaskQueue)

        {

        delete iTaskQueue;

        }

    if (iMsgMonitor)

        {

        delete iMsgMonitor;

        }

    iObservers.Close();

    iPbs.Close();

    iFile.Close();

    if (iBuffer)

        {

        delete iBuffer;

        }

    delete iMediaOnError;

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    iFile64.Close();

#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    }

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

// C++ constructor

// Create a unique name out of thread ID and this pointer: no other instance of

// this object will have the same name; used to identify this object for

// recieving messages

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

//

CMPXPlaybackUtility::CMPXPlaybackUtility()

    : CActive(EPriorityStandard),

    iCallbackOngoing(EFalse)

    {

    CActiveScheduler::Add(this);

    }

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

// 2nd construtor

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

//

void CMPXPlaybackUtility::ConstructL(const TUid& aModeId,

                                     MMPXPlaybackObserver* aObs, 

                                     const TMPXCategory aCategory)

    {

    MPX_FUNC_EX("CMPXPlaybackUtility::ConstructL()");

    MPX_DEBUG4("CMPXPlaybackUtility::ConstructL this 0x%08x mode 0x%08x observer 0x%08x",

               this, aModeId.iUid, aObs);

    if (aObs)

        {

        AddObserverL(*aObs);

        }

    iTaskQueue = CMPXTaskQueue::NewL();

    User::LeaveIfError(iPbs.Connect(KMPXPlaybackServerName,

                                    KMPXPlaybackServerImg,

                                    TVersion(KMPXPlaybackServerMajorVersionNumber,

                                             KMPXPlaybackServerMinorVersionNumber,

                                             KMPXPlaybackServerBuildVersionNumber)));

    iPbs.SendReceiveL(EPbsSetMode,TIpcArgs(aModeId.iUid, aCategory));

    iMsgMonitor = CMPXMessageMonitor::NewL(iPbs, *this);

#ifdef _ENABLE_GUARD_TIMER

    iGuardTimer=CPeriodic::NewL(CActive::EPriorityStandard);

#endif

    iMediaOnError = CMPXMedia::NewL();

    iRefCount++;

    }

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

// Add a observer

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

//

void CMPXPlaybackUtility::AddObserverL(MMPXPlaybackObserver& aObs)

    {

    MPX_FUNC_EX("CMPXPlaybackUtility::AddObserverL()");

    iObservers.AppendL(&aObs);

    }

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

// Remove a observer

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

//

void CMPXPlaybackUtility::RemoveObserverL(MMPXPlaybackObserver& aObs)

    {

    MPX_FUNC_EX("CMPXPlaybackUtility::RemoveObserverL()");

    TInt i=iObservers.FindL(&aObs);

    iObservers.Remove(i);

    }

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

// Returns PIds of clients that are using the engine in the mode

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

//

void CMPXPlaybackUtility::GetClientsL(RArray<TProcessId>& aClients)

    {

    MPX_FUNC_EX("CMPXPlaybackUtility::GetClientsL()");

    TInt size = iPbs.SendReceiveL(EPbsGetClients);

    ::ArrayFromServerL<TProcessId>(iPbs, EPbsGetSyncBuffer,size,aClients);

    }

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

// Initializes a track given by aIndex in path aCollectionPath

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

//

void CMPXPlaybackUtility::InitL(

    const CMPXCollectionPlaylist& aPlaylist,

    TBool aPlay /*=ETrue*/ )

    {

    MPX_FUNC("CMPXPlaybackUtility::InitL()");

    MPX_DEBUG_THREAD("CMPXPlaybackUtility::InitL()");

    CBufBase* buffer(NULL);

    ::CreateBufferL<CMPXCollectionPlaylist>(aPlaylist, buffer);

    CleanupStack::PushL( buffer );

    TPtr8 p=buffer->Ptr(0);

    iPbs.SendReceiveL(EPbsInitFromCollection,TIpcArgs(&p,aPlay));

    CleanupStack::PopAndDestroy( buffer );

    }

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

// Inititialises with a single song, may not be part of any collection

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

//

void CMPXPlaybackUtility::InitL(const TDesC& aUri,const TDesC8* aType)

    {

    MPX_FUNC("CMPXPlaybackUtility::InitL(const TDesC& aUri,const TDesC8* aType)");

    MPX_DEBUG_THREAD("CMPXPlaybackUtility::InitL()");

    const TDesC8& type=aType?*aType:KNullDesC8;

    TPtrC8 uri = MPXUser::Ptr(aUri);

    iPbs.SendReceiveL(EPbsInitFromUri,TIpcArgs(&uri,&type));

    }

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

// Inititialises with a single song, may not be part of any collection

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

//

void CMPXPlaybackUtility::InitL(RFile& aShareableFile)

    {

    MPX_FUNC("CMPXPlaybackUtility::InitL(RFile& aShareableFile)");

    MPX_DEBUG_THREAD("CMPXPlaybackUtility::InitL()");

    if (!aShareableFile.SubSessionHandle())

        {

        User::Leave(KErrArgument);

        }

    TIpcArgs args;

    aShareableFile.TransferToServer(args,0,1);

    iPbs.SendReceiveL(EPbsInitFromFile,args);

    }

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

// Inititialises with a URI

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

//

void CMPXPlaybackUtility::InitStreamingL(const TDesC& aUri, const TDesC8* aType, const TInt aAccessPoint)

{

    MPX_FUNC("CMPXPlaybackUtility::InitStreamingL(const TDesC& aUri, const TInt aAccessPoint)");

    MPX_DEBUG_THREAD("CMPXPlaybackUtility::InitStreamingL()");

    const TDesC8& type=aType?*aType:KNullDesC8;

    TPtrC8 uri = MPXUser::Ptr(aUri);

    iPbs.SendReceiveL(EPbsInitStreamingFromUri,TIpcArgs(&uri, &type, aAccessPoint));

}

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

// Inititialises with a file, may not be part of any collection

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

//

void CMPXPlaybackUtility::InitStreamingL(RFile& aShareableFile, const TInt aAccessPoint)

{

    MPX_FUNC("CMPXPlaybackUtility::InitStreamingL(RFile& aShareableFile, const TInt aAccessPoint)");

    MPX_DEBUG_THREAD("CMPXPlaybackUtility::InitStreamingL()");

    if (!aShareableFile.SubSessionHandle())

        {

        User::Leave(KErrArgument);

        }

    TIpcArgs args;

    aShareableFile.TransferToServer(args,0,1); 

    args.Set(2, aAccessPoint);  //use index "2" for setting the AccessPoint   

    iPbs.SendReceiveL(EPbsInitStreamingFromFile, args);

}

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

// Frees up client side resources only; a player is freed when there are no

// clients using it, and all resources are freed when the last client closed

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

//

void CMPXPlaybackUtility::Close()

    {

    MPX_DEBUG2("CMPXPlaybackUtility::Close 0x%08x", this);

    ASSERT( iRefCount > 0 );

    if ( --iRefCount == 0 )

        {

        // last client released

        iMsgMonitor->Cancel();

        TMPXPlaybackUtilityStruct* s( reinterpret_cast<TMPXPlaybackUtilityStruct*>( Dll::Tls() ));

        if ( s )

            {

            if ( s->iDefaultPlaybackUtility == this )

                {

                delete s;

                Dll::SetTls( NULL );

                }

            }

        delete this;

        }

    }

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

// Stops any async operations that are currently under way

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

//

void CMPXPlaybackUtility::CancelRequest()

    {

    MPX_FUNC_EX("CMPXPlaybackUtility::CancelRequest()");

    Cancel();

    iTaskQueue->Reset();

    }

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

// Issue player commands, with optional data.

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

//

void CMPXPlaybackUtility::CommandL(TMPXPlaybackCommand aCmd,TInt aData)

    {

    MPX_DEBUG2("-->CMPXPlaybackUtility::CommandL(%d)", aCmd);

    MPX_DEBUG_THREAD("CMPXPlaybackUtility::CommandL()");

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL(cmd);

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

    // All of current commands are sync

    cmd->SetTObjectValueL<TBool>(KMPXCommandGeneralDoSync, ETrue);

    cmd->SetTObjectValueL<TInt>(KMPXCommandPlaybackGeneralType, aCmd);

    cmd->SetTObjectValueL<TInt>(KMPXCommandPlaybackGeneralData, aData);

    CommandL(*cmd, NULL);

    CleanupStack::PopAndDestroy(cmd);

    MPX_DEBUG2("<--CMPXPlaybackUtility::CommandL(%d)", aCmd);

    }

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

// Issue player commands

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

//

void CMPXPlaybackUtility::CommandL(

    CMPXCommand& aCmd,

    MMPXPlaybackCallback* aCallback/*=NULL*/)

    {

    MPX_FUNC_EX("CMPXPlaybackUtility::CommandL(CMPXCommand& aCmd)");

    MPX_DEBUG_THREAD("CMPXPlaybackUtility::CommandL(CMPXCommand& aCmd)");

    ASSERT(aCmd.IsSupported(KMPXCommandGeneralId));

    TInt id = aCmd.ValueTObjectL<TInt>(KMPXCommandGeneralId);

    MPX_DEBUG2("CMPXPlaybackUtility::CommandL(): id = 0x%08x", id);

    if (KMPXCommandIdPlaybackGeneral==id)

        {

        ASSERT(aCmd.IsSupported(KMPXCommandPlaybackGeneralType));

        TMPXPlaybackCommand cmdType = static_cast<TMPXPlaybackCommand>(

                      aCmd.ValueTObjectL<TInt>(KMPXCommandPlaybackGeneralType));

        MPX_DEBUG2("CMPXPlaybackUtility::CommandL(): cmdType = %d", cmdType);

        if ( EPbCmdPlay == cmdType ||

             EPbCmdPlayPause == cmdType ||

             EPbCmdStop == cmdType)

            {

            }

        }

    TBool asyncVar(ETrue); // by default command is asynchronous

    if (aCmd.IsSupported(KMPXCommandGeneralDoSync))

        { // check if command is sync

        asyncVar=!(aCmd.ValueTObjectL<TBool>(KMPXCommandGeneralDoSync));

        }

    CBufBase* buf(NULL);

    ::CreateBufferL<CMPXCommand>( aCmd, buf );

    CleanupStack::PushL( buf );

    TPtr8 ptr = buf->Ptr(0);

    if (asyncVar)

        { // async request

        ASSERT(aCallback); // callback must be provided for asynchronous command

        // Increase reference count on command ownership transferred

        CMPXCommand* ref = CMPXCommand::NewL(aCmd);

        // Async version, Add request to the task queue

        CleanupStack::PushL(ref);

        AddRequestL(EPbsCommand, aCallback, asyncVar, buf, NULL, ref );

        CleanupStack::Pop(ref);

        CleanupStack::Pop( buf );  // ownership transferred to the queue

        }

    else

        { // send request if sync

        iPbs.SendReceiveL(EPbsCommand, TIpcArgs(asyncVar, &ptr));

        CleanupStack::PopAndDestroy( buf );

        }

    }

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

// Current state of player

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

//

TMPXPlaybackState CMPXPlaybackUtility::StateL() const

    {

    MPX_DEBUG2("CMPXPlaybackUtility::StateL 0x%08x", this);

    return static_cast<TMPXPlaybackState>(iPbs.SendReceiveL(EPbsGetState));

    }

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

// Determine whether there is a song by the state of the engine: if there is,

// its OK to return MMPXMedia, else NULL is returned

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

//

MMPXSource* CMPXPlaybackUtility::Source()

    {

    MPX_FUNC_EX("CMPXPlaybackUtility::Source()");

    TMPXPlaybackState s=EPbStateNotInitialised;

    TRAP_IGNORE(s=StateL());

    return (s==EPbStateNotInitialised ||

            s==EPbStateShuttingDown) ? NULL:this;

    }

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

// Get player manager

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

//

MMPXPlayerManager& CMPXPlaybackUtility::PlayerManager()

    {

    return *this;

    }

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

// Set playback property, EPropertyChanged event when complete

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

//

void CMPXPlaybackUtility::SetL(TMPXPlaybackProperty aProperty,TInt aValue)

    {

    MPX_FUNC_EX("CMPXPlaybackUtility::SetL()");

    iPbs.SendReceiveL(EPbsSetProperty,TIpcArgs(aProperty,aValue));

    }

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

// Send property request

// Result will be called back in HandleProperty

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

//

void CMPXPlaybackUtility::ValueL(MMPXPlaybackCallback& aCallback,

                                 TMPXPlaybackProperty aProperty)

    {

    MPX_FUNC_EX("CMPXPlaybackUtility::ValueL()");

    PropertyL(aCallback, aProperty);

    }

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

// Send property request

// Result will be called back in HandleProperty

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

//

void CMPXPlaybackUtility::PropertyL(

    MMPXPlaybackCallback& aCallback,

    TMPXPlaybackProperty aProperty)

    {

    MPX_DEBUG2("-->CMPXPlaybackUtility::PropertyL(%d)", aProperty);

    MPX_DEBUG_THREAD("CMPXPlaybackUtility::PropertyL()");

    AddRequestL(EPbsGetProperty, &aCallback, aProperty);

    MPX_DEBUG2("<--CMPXPlaybackUtility::PropertyL(%d)", aProperty);

    }

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

// Return a list of mime types supported by playback framework

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

//

CDesCArray* CMPXPlaybackUtility::SupportedMimeTypes()

    {

    MPX_FUNC_EX("CMPXPlaybackUtility::SupportedMimeTypes()");

    TInt size = 0;

    TRAPD( err, size = iPbs.SendReceiveL( EPbsGetSupportedMimeTypes ) );

    CDesCArray* desArray = NULL;

    if ( size && ( err == KErrNone ) )

        {

        TRAP_IGNORE(

        ::TransferBufferFromServerL(iPbs, EPbsGetSyncBuffer, size, iBuffer);

        MPXUser::CreateFromBufferL(*iBuffer, desArray));

        }

    return desArray;

    }

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

// Return a list of mime types supported by playback framework

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

//

CDesCArray* CMPXPlaybackUtility::SupportedExtensions()

    {

    MPX_FUNC_EX("CMPXPlaybackUtility::SupportedExtensions()");

    TInt size = 0;

    TRAPD( err, size = iPbs.SendReceiveL( EPbsGetSupportedExtensions ) );

    CDesCArray* desArray = NULL;

    if ( size && ( err == KErrNone ) )

        {

        TRAP_IGNORE(

        ::TransferBufferFromServerL(iPbs, EPbsGetSyncBuffer, size, iBuffer);

        MPXUser::CreateFromBufferL(*iBuffer, desArray));

        }

    return desArray;

    }

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

// Return a list of mime types supported by playback framework

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

//

CDesCArray* CMPXPlaybackUtility::SupportedSchemas()

    {

    MPX_FUNC_EX("CMPXPlaybackUtility::SupportedSchemas()");

    TInt size = 0;

    TRAPD( err, size = iPbs.SendReceiveL( EPbsGetSupportedSchemas ) );

    CDesCArray* desArray = NULL;

    if ( size && ( err == KErrNone ) )

        {

        TRAP_IGNORE(

        ::TransferBufferFromServerL(iPbs, EPbsGetSyncBuffer, size, iBuffer);

        MPXUser::CreateFromBufferL(*iBuffer, desArray));

        }