/*

* 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:  Playback server session

*

*/

#include <e32std.h>

#include <e32svr.h>

#include <CustomCommandUtility.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxplaybackcommanddefs.h>

#include <mpxmedia.h>

#include <mpxclientlist.h>

#include <mpxcmn.h>

#include <mpxcollectionplaylist.h>

#include <mpxlog.h>

#include <mpxmessagequeue.h>

#include "mpxplaybackserver.h"

#include "mpxplaybackengine.h"

#include "mpxplaybackserversession.h"

// ============================ LOCAL FUNCTIONS ==============================

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

// Panic client

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

//

LOCAL_C void PanicClient(const RMessage2 &aMessage,TInt aPanic)

    {

    _LIT(KTxtServer,"Playback server Session");

    aMessage.Panic(KTxtServer,aPanic);

    }

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

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

// Two-phased constructor.

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

//

CMPXPlaybackSession* CMPXPlaybackSession::NewL()

    {

    CMPXPlaybackSession* s = new(ELeave)CMPXPlaybackSession();

    CleanupStack::PushL(s);

    s->ConstructL();

    CleanupStack::Pop(s);

    return s;

    }

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

// C++ constructor can NOT contain any code that might leave.

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

//

CMPXPlaybackSession::CMPXPlaybackSession()

    {

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXPlaybackSession::ConstructL()

    {

    MPX_DEBUG2("CMPXPlaybackSession::ConstructL(), this 0x%08x", this);

    }

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

// Destructor

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

//

CMPXPlaybackSession::~CMPXPlaybackSession()

    {

    CancelRequests();

    CMPXPlaybackServer* server = static_cast<CMPXPlaybackServer*>(

            const_cast<CServer2*>(Server()));

    if ( iMessageQueue )

        {

        server->RemoveClient( *iMessageQueue );

        }

    delete iSyncBuffer;

    delete iAsyncBuffer;

    delete iMedia;

    delete iMessageQueue;

    }

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

// Service request

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

//

void CMPXPlaybackSession::ServiceL(const RMessage2& aMessage)

    {

    // by default - change for async in helper methods if required

    iCompleteRequest=ETrue;

    TInt r=KErrNone;

    TRAPD( err, DispatchMessageL( aMessage, r ) );

    TBool isErr=(err!=KErrNone);

    // If it's not async, complete now (or an async helper method leaves)

    if(iCompleteRequest)

        {

        if (!aMessage.IsNull())

            {

            aMessage.Complete(isErr ? err : r);

            } // otherwise message already completed DispatchMessageL

        }

    else  if (isErr) // Async and error,  remove message from message queue

        {

        CompleteAsync(err);

        }

    }

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

// Message dispatcher

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

//

void CMPXPlaybackSession::DispatchMessageL( const RMessage2& aMessage, TInt& aMsgHandleResult )

    {

    aMsgHandleResult = KErrNone;

    //

    // All methods apart from the player creation methods, require a player

    //

    TInt op=aMessage.Function();

    if (op != EPbsSetMode)

        {

        CheckPlayerL();

        }

    MPX_DEBUG3("-->CMPXPlaybackSession::DispatchMessageL %d, this 0x%08x",

            op, this);

    switch(op)

        {

        case EPbsSetMode:

            {

            SetModeL(aMessage);

            break;

            }

        case EPbsGetClients:

            {

            RArray<TProcessId> procArray;

            ::CopyArrayL<TProcessId>(

                iPlayer->ClientList()->ClientProcessList(),

                procArray );

            TProcessId lastPid = static_cast<CMPXPlaybackServer*>(

                         const_cast<CServer2*>(Server()))->LastActiveProcessId();

            TInt index( procArray.Find( lastPid ));

            if ( KErrNotFound != index && index )

                {

                procArray.Remove( index );

                procArray.Insert( lastPid, 0 );

                }

            ::CreateBufferL<TProcessId>(

                            procArray.Array(),

                            iSyncBuffer);

            aMsgHandleResult = iSyncBuffer->Size();

            procArray.Close();

            break;

            }

        case EPbsGetSyncBuffer:

            {

            aMessage.WriteL(0,iSyncBuffer->Ptr(0));

            delete iSyncBuffer;

            iSyncBuffer = NULL;

            break;

            }

        case EPbsGetAsyncBuffer:

            {

            aMessage.WriteL(0,iAsyncBuffer->Ptr(0));

            delete iAsyncBuffer;

            iAsyncBuffer = NULL;

            break;

            }

        case EPbsInitFromCollection:

            {

            MPXUser::CreateBufferL(aMessage, 0, iSyncBuffer);

            CMPXCollectionPlaylist* p = NULL;

            ::NewFromBufferL(*iSyncBuffer, p);

            delete iSyncBuffer;

            iSyncBuffer = NULL;

            CleanupStack::PushL(p);

            iPlayer->InitL(*p,aMessage.Int1());

            CleanupStack::PopAndDestroy(p);

            }

            break;

        case EPbsInitFromUri:

            {

            CBufBase* buf0(NULL);

            MPXUser::CreateBufferL(aMessage,0,buf0);

            CleanupStack::PushL(buf0);

            // Type parameter is optional

            if ( aMessage.GetDesLength( 1 ) > 0 )

                {

                CBufBase* buf1(NULL);

                MPXUser::CreateBufferL(aMessage,1,buf1);

                CleanupStack::PushL(buf1);

                iPlayer->InitL(MPXUser::Ptr(buf0->Ptr(0)), buf1->Ptr(0));

                CleanupStack::PopAndDestroy(buf1);

                }

            else

                {

                MPX_DEBUG2("CMPXPlaybackSession::DispatchMessageL %d: Type is empty", op);

                iPlayer->InitL( MPXUser::Ptr( buf0->Ptr(0) ), KNullDesC8 );

                }

            CleanupStack::PopAndDestroy(buf0);

            }

            break;

        case EPbsInitFromFile:

            {

            InitFromFileL(aMessage);

            break;

            }

        case EPbsInitStreamingFromUri:

            {            

            CBufBase* buf0(NULL);

            MPXUser::CreateBufferL(aMessage,0,buf0);

            CleanupStack::PushL(buf0);

            // Type parameter is optional

            if ( aMessage.GetDesLength( 1 ) > 0 )

                {

                CBufBase* buf1(NULL);

                MPXUser::CreateBufferL(aMessage,1,buf1);

                CleanupStack::PushL(buf1);

                iPlayer->InitStreamingL(MPXUser::Ptr(buf0->Ptr(0)), buf1->Ptr(0), aMessage.Int2());

                CleanupStack::PopAndDestroy(buf1);

                }

            else

                {

                MPX_DEBUG2("CMPXPlaybackSession::DispatchMessageL %d: Type is empty", op);

                iPlayer->InitStreamingL( MPXUser::Ptr( buf0->Ptr(0) ), KNullDesC8, aMessage.Int2() );

                }

            CleanupStack::PopAndDestroy(buf0);

            break;                          

            }

         case EPbsInitStreamingFromFile:

            {

            RFile file;

            User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));

            iPlayer->InitStreamingL(file, aMessage.Int2());

            file.Close();

            break;

            }            

        case EPbsCancelRequest:

            {

            CancelRequests();

            break;

            }

        case EPbsGetState:

            {

            aMsgHandleResult = iPlayer->State();

            break;

            }

        case EPbsSetProperty:

            {

            iPlayer->SetL(static_cast<TMPXPlaybackProperty>(aMessage.Int0()),

                          aMessage.Int1());

            break;

            }

        case EPbsGetProperty:

            {

            SetAsync(aMessage);

            iPlayer->PropertyL(

                    static_cast<TMPXPlaybackProperty>(aMessage.Int0()),*this);

            break;

            }

        case EPbsGetPlayerTypes:

            {

            RArray<TMPXPlaybackPlayerType> pluginTypes;

            CleanupClosePushL(pluginTypes);

            RArray<TInt> types;

            CleanupClosePushL(types);

            iPlayer->PluginHandler()->GetPluginTypes(types);

            for (TInt i=0; i< types.Count(); ++i)

                {

                pluginTypes.AppendL(

                        static_cast<TMPXPlaybackPlayerType>(types[i]));

                }

            CleanupStack::PopAndDestroy(&types);

            ::CreateBufferL<TMPXPlaybackPlayerType>(

                                    pluginTypes.Array(),

                                    iSyncBuffer);

            aMsgHandleResult = iSyncBuffer->Size();

            CleanupStack::PopAndDestroy(&pluginTypes);

            break;

            }

        case EPbsGetPlayerTypeDisplayName:

            {

            const TDesC& playerName = iPlayer->PluginHandler()->PlayerName(

                        static_cast<TMPXPlaybackPlayerType>(aMessage.Int0()));

            aMsgHandleResult = 0;

            if (playerName.Length()>0)

                {

                MPXUser::CreateBufferL(playerName, iSyncBuffer);

                aMsgHandleResult = iSyncBuffer->Size();

                }

            break;

            }

        case EPbsGetAllPlayersUids:

            {

            RArray<TUid> uids;

            CleanupClosePushL(uids);

            iPlayer->PluginHandler()->GetPluginUids(uids);

            ::CreateBufferL<TUid>(

                    uids.Array(),

                    iSyncBuffer);

            aMsgHandleResult = iSyncBuffer->Size();

            CleanupStack::PopAndDestroy(&uids);

            break;

            }

        case EPbsGetPlayersUidsForType:

            {

            aMsgHandleResult = CreatePlayerUidsBufferL(aMessage);

            break;

            }

        case EPbsGetSubPlayerNamesByUid:

            {

            SetAsync(aMessage);

            iPlayer->SubPlayerNamesL(TUid::Uid(aMessage.Int0()),*this);

            break;

            }

        case EPbsSelectPlayerByType:

            {

            iPlayer->PluginHandler()->SelectPlayersL(

                         static_cast<TMPXPlaybackPlayerType>(aMessage.Int0()));

            break;

            }

        case EPbsSelectPlayerByUid:

            {

            iPlayer->PluginHandler()->SelectPlayerL(TUid::Uid(aMessage.Int0()));

            break;

            }

        case EPbsSelectSubPlayer:

            {

            iPlayer->PluginHandler()->SelectSubPlayerL(

                                  TUid::Uid(aMessage.Int0()),aMessage.Int1());

            break;

            }

        case EPbsClearPlayerSelection:

            {

            iPlayer->PluginHandler()->ClearSelectPlayersL();

            break;

            }

        case EPbsGetSelection:

            {

            GetSelectionL(aMessage);

            break;

            }

        case EPbsPlayerFound:

            {

            aMsgHandleResult = iPlayer->PluginHandler()->PlayerFound();

            break;

            }

        case EPbsGetPlayerType:

            {

            aMsgHandleResult = iPlayer->PluginHandler()->PluginType();

            break;

            }

        case EPbsGetTypeName:

            {

            MPXUser::CreateBufferL(iPlayer->PluginHandler()->PlayerName(),

                                   iSyncBuffer);

            aMsgHandleResult = iSyncBuffer->Size();

            break;

            }

        case EPbsGetSubPlayerIndex:

            {

            aMsgHandleResult = iPlayer->PluginHandler()->SubPlayer();

            break;

            }

        case EPbsGetPlayerUid:

            {

            TPckgC<TInt> uidPkg((iPlayer->PluginHandler()->PluginUid()).iUid);

            aMessage.Write(0,uidPkg);

            break;

            }

        case EPbsGetCollectionPlaylist:

            {

            aMsgHandleResult = 0;

            if (iPlayer->Playlist())

                {

                ::CreateBufferL<CMPXCollectionPlaylist>(*(iPlayer->Playlist()),

                                                        iSyncBuffer);

                aMsgHandleResult = iSyncBuffer->Size();

                }

            break;

            }

        case EPbsGetFile:

            {

            const RFile& file = iPlayer->File();

            if (file.SubSessionHandle())

                {

                aMsgHandleResult = file.TransferToClient(aMessage,0); //message completed

                }

            else

                {

                TPckgC<TInt> handle(KErrNotFound);

                aMessage.Write(0, handle);

                }

            break;

            }

        case EPbsGetUri:

            {

            aMsgHandleResult=0;

            if (iPlayer->Uri().Length()>0)

                {

                MPXUser::CreateBufferL(iPlayer->Uri(),iSyncBuffer);

                aMsgHandleResult = iSyncBuffer->Size();

                }

            break;

            }

        case EPbsGetMedia:

            {

            SetAsync( aMessage );

            CMPXCommand* cmd( CMPXCommand::NewL( aMessage.Int1() ) );

            CleanupStack::PushL( cmd );

            iPlayer->MediaL( *this, *cmd );

            CleanupStack::PopAndDestroy( cmd );

            break;

            }

        case EPbsGetSupportedMimeTypes:

            {

            CDesCArray* mimeTypes =

               iPlayer->PluginHandler()->SupportedMimeTypesL();

            CleanupStack::PushL(mimeTypes);

            MPXUser::CreateBufferL((const MDesCArray*)mimeTypes, iSyncBuffer);

            aMsgHandleResult = iSyncBuffer->Size();

            CleanupStack::PopAndDestroy(mimeTypes);

            }

            break;

        case EPbsGetSupportedExtensions:

            {

            CDesCArray* exts =

              iPlayer->PluginHandler()->SupportedExtensionsL();

            CleanupStack::PushL(exts);

            MPXUser::CreateBufferL((const MDesCArray*)exts, iSyncBuffer);

            aMsgHandleResult = iSyncBuffer->Size();

            CleanupStack::PopAndDestroy(exts);

            }

            break;

        case EPbsGetSupportedSchemas:

            {

            CDesCArray* schemas =

                 iPlayer->PluginHandler()->SupportedSchemasL();

            CleanupStack::PushL(schemas);

            MPXUser::CreateBufferL((const MDesCArray*)schemas, iSyncBuffer);

            aMsgHandleResult = iSyncBuffer->Size();

            CleanupStack::PopAndDestroy(schemas);

            }

            break;

        case EPbsGetNextMessage:

            {

            ASSERT(iMessageQueue);

            iMessageQueue->SendNext(aMessage);

            iCompleteRequest=EFalse;

            break;

            }

        case EPbsCancelGetMessage:

            {

            ASSERT(iMessageQueue);

            iMessageQueue->Reset();

            break;

            }

        case EPbsCommand:

            {

            CMPXCommand* cmd( NULL );

            ::NewFromMessageL<CMPXMedia>(aMessage, 1, cmd);

            CleanupStack::PushL(cmd);

            if (aMessage.Int0())

                { // aSync command

                SetAsync(aMessage);

                } // else sync command

            iPlayer->CommandL(*cmd, *iMessageQueue);

            CleanupStack::PopAndDestroy(cmd);

            break;

            }

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

        case EPbsInitFromFile64:

            {

            RFile64 file;

            User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));

            iPlayer->Init64L(file);

            file.Close();

            break;

            }

        case EPbsInitStreamingFromFile64:

            {

            RFile64 file;

            User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));

            iPlayer->InitStreaming64L(file, aMessage.Int2());           

            file.Close();

            break;

            }

        case EPbsGetFile64:

            {

            const RFile64& file = iPlayer->File64();

            if (file.SubSessionHandle())

                {

                aMsgHandleResult = file.TransferToClient(aMessage,0); //message completed

                }

            else

                {

                TPckgC<TInt> handle(KErrNotFound);

                aMessage.Write(0, handle);

                }

            break;

            }

#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

        case EPbsSetPrimaryClient:

            {

            break;

            }

        default:

            {

            PanicClient(aMessage,KErrNotSupported);

            break;

            }