/*

* Copyright (c) 2005-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:   DRM Play Session

*

*/

#include "DRMPlaySession.h"

#include <e32test.h>

#include <e32std.h>

#include <e32svr.h>

#include <mmf/common/mmfcontrollerframework.h>

#ifdef RD_TSP_CLIENT_MAPPER

#include <tspclientmapper.h>

#endif // #ifdef RD_TSP_CLIENT_MAPPER

#ifdef _DEBUG

#define DEP_PRN0(str)   RDebug::Print(str)

#define DEP_PRN1(str, v1)   RDebug::Print(str, v1)

#define DEP_PRN2(str, v1, v2)   RDebug::Print(str, v1, v2)

#else

#define DEP_PRN0(str)

#define DEP_PRN1(str, v1)

#define DEP_PRN2(str, v1, v2)

#endif // _DEBUG

// This is the UID defined by custom interface builder

const TUid KUidCustomInterfaceBuilderImpl = {0x10207A8E};

// panic the client

void CDRMPlayServerSession::PanicClient(const RMessage2 &aMessage, TInt aPanic) const

    {

    _LIT(KTxtServer,"DRM Play server");

    aMessage.Panic(KTxtServer,aPanic);

    }

CDRMPlayServerSession::CDRMPlayServerSession(CDRMPlayServer* aServer)

:iMessage2(NULL)

    {

    iServer=aServer;

    }

CDRMPlayServerSession* CDRMPlayServerSession::NewL(CDRMPlayServer* aServer, const RMessage2& aMessage )

    {

    DEP_PRN0(_L("CDRMPlayServerSession::NewL"));

    CDRMPlayServerSession* self = new(ELeave) CDRMPlayServerSession(aServer);

    CleanupStack::PushL(self);

    self->ConstructL( aMessage );

    CleanupStack::Pop(self);

    return self;

    }

#ifdef RD_TSP_CLIENT_MAPPER

void CDRMPlayServerSession::ConstructL( const RMessage2& aMessage )

#else

void CDRMPlayServerSession::ConstructL( const RMessage2& /*aMessage*/ )

#endif //RD_TSP_CLIENT_MAPPER

    {

#ifdef RD_TSP_CLIENT_MAPPER

    iTSPClientMapper = CTspClientMapper::NewL();

    // Get client process ID

    RThread clientThread;

    RProcess clientProcess;

    // Open client thread and process handles

    User::LeaveIfError( aMessage.Client(clientThread) );

    User::LeaveIfError(  clientThread.Process(clientProcess) );

    // Get process id

    iClientProcessId = clientProcess.Id();

    // Close client thread and client process handles

    clientThread.Close();

    clientProcess.Close();

    iTSPClientMapper->SetTspTargetClient(

                            CTspClientMapper::ERegisteredClients,

                            iClientProcessId );

#endif // #ifdef RD_TSP_CLIENT_MAPPER

    // Increment number of sessions in server

    iServer->iClients++;

    DEP_PRN1(_L("CDRMPlayServerSession::iClients = %d"), iServer->iClients);

    }

CDRMPlayServerSession::~CDRMPlayServerSession()

    {

    if(iMetaDataBuffer)

    {

     delete iMetaDataBuffer;

     iMetaDataBuffer = NULL;

    }

    // Delete any pending message objects

    // This will never happen, only happens when

    // Client closes the session in the middle of playback

    // but we cannot complete the message as RSession Handle is invalid

/*    if (iMessage2)

        {

        iMessage2->Complete(KErrCancel);

        }

*/

    if(iMessage2)

    {	

     delete iMessage2;

     iMessage2 = NULL;

    }

    // Delete play utility

    if (iPlayUtil)

     {	

     	delete iPlayUtil;

     	iPlayUtil = NULL;

     }

    //delete iAsyncCallback;

    //iAsyncCallback = NULL;

#ifdef RD_TSP_CLIENT_MAPPER

    if (iTSPClientMapper)

    	{

    TInt status = iTSPClientMapper->RemoveTspTargetClient(

                                        CTspClientMapper::ERegisteredClients,

                                        iClientProcessId );

    DEP_PRN2(_L("CDRMPlayServerSession::~CDRMPlayServerSession:Unreg PID[%x]Status[%d]"), iClientProcessId.Id(), status );

    delete iTSPClientMapper;

    	}

#endif // #ifdef RD_TSP_CLIENT_MAPPER

    // Cancel any pending async messages.

    TInt index(0);

    CDRMCustomCommandAsyncAO* tempAO(NULL);

    for (;index < iActiveAsyncCustomCommands.Count(); index++)

        {

        tempAO = iActiveAsyncCustomCommands[0];

        if ( iCDRMCustomCommandAsyncAO2Phase == tempAO )

            {

            iCDRMCustomCommandAsyncAO2Phase = NULL;

            }

        delete tempAO;

        iActiveAsyncCustomCommands.Remove(0);

        }

    iActiveAsyncCustomCommands.Reset();

    iActiveAsyncCustomCommands.Close();

    delete iCDRMCustomCommandAsyncAO2Phase;

    iServer->iClients--;

    if(!iServer->iClients)

        {

        CActiveScheduler::Stop();

        }

    }

void CDRMPlayServerSession::ServiceL(const RMessage2& aMessage)

    {

    TInt ret = KErrNone;

    TRAPD(err,ret = DispatchMessageL(aMessage));

    if (KErrNone != err)

        {

        ret = err;

        }

    if(iAsyncComplete == EFalse)

        {

        DEP_PRN1(_L("CDRMPlayServerSession::ServiceL - ret = %d"),ret);

        aMessage.Complete(ret);

        }

    }

// service a client request; test the opcode and then do appropriate servicing

TInt CDRMPlayServerSession::DispatchMessageL(const RMessage2 &aMessage)

    {

    TInt ret=KErrNone;

    iAsyncComplete= EFalse;

    DEP_PRN1(_L("CDRMPlayServerSession::DispatchMessageL:FnId[%d]"),aMessage.Function());

    switch (aMessage.Function())

        {

        case EDRMPlayServCreate:

             break;

        case EDRMPlayServNewFilePlayerL:

            iMessage = aMessage;

            NewFilePlayerL(aMessage);

            iAsyncComplete = ETrue;

            break;

        case EDRMPlayServNewDesPlayerL:

            iMessage = aMessage;

            NewDesPlayerL(aMessage);

            iAsyncComplete = ETrue;

            break;

        case EDRMPlayServNewDesPlayerReadOnlyL:

            iMessage = aMessage;

            NewDesPlayerReadOnlyL(aMessage);

            iAsyncComplete = ETrue;

            break;

        case EDRMPlayServNewPlayerL:

            NewPlayerL(aMessage);

            break;

        case EDRMPlayServOpenFile:

            iMessage = aMessage;

            OpenFileL(aMessage);

            iAsyncComplete = ETrue;

            break;

        case EDRMPlayServOpenFileByHandle:

            iMessage = aMessage;

            OpenFileByHandleL(aMessage);

            iAsyncComplete = ETrue;

            break;

        case EDRMPlayServOpenFileBySource:

            iMessage = aMessage;

            OpenFileBySourceL(aMessage);

            iAsyncComplete = ETrue;

            break;

        case EDRMPlayServOpenDes:

            iMessage = aMessage;

            OpenDesL(aMessage);

            iAsyncComplete = ETrue;

            break;

        case EDRMPlayServOpenUrl:

            iMessage = aMessage;

            OpenUrlL(aMessage);

            iAsyncComplete = ETrue;

            break;

        case EDRMPlayServPlay:

            iMessage = aMessage;

            if(iMessage2)

                {

                iMessage2->Complete(KErrCancel);

                delete iMessage2;

                iMessage2 = NULL;

                }

            iMessage2 = new (ELeave) RMessage2(aMessage);

            Play();

            iAsyncComplete = ETrue;

            break;

        case EDRMPlayServStop:

            if(iState == EStopped)

                break;

            if(iMessage2)

                {

                iMessage2->Complete(KErrCancel);

                delete iMessage2;

                iMessage2 = NULL;

                }

            Stop();

            break;

        case EDRMPlayServSetVolume:

            SetVolume(aMessage);

            break;

        case EDRMPlayServSetRepeats:

            SetRepeats(aMessage);

            break;

        case EDRMPlayServSetVolumeRamp:

            SetVolumeRamp(aMessage);

            break;

        case EDRMPlayServDuration:

            Duration(aMessage);

            break;

        case EDRMPlayServMaxVolume:

            ret = MaxVolume();

            break;

        case EDRMPlayServPause:

            ret = Pause();

            if(iMessage2)

                {

                iMessage2->Complete(KErrCancel);

                delete iMessage2;

                iMessage2 = NULL;

                }

            iAsyncComplete = EFalse;

            break;

        case EDRMPlayServClose:

            Close();

            break;

        case EDRMPlayServGetPosition:

            ret = GetPosition(aMessage);

            break;

        case EDRMPlayServSetPosition:

            SetPosition(aMessage);

            break;

        case EDRMPlayServSetPriority:

            ret = SetPriority(aMessage);

            break;

        case EDRMPlayServGetVolume:

            ret = GetVolume(aMessage);

            break;

        case EDRMPlayServGetNumberOfMetaDataEntries:

            ret = GetNumberOfMetaDataEntries(aMessage);

            break;

        case EDRMPlayServGetMetaDataEntry:

            GetMetaDataEntryL(aMessage);

            break;

        case EDRMPlayServClearPlayWindow:

            ret = ClearPlayWindow();

            break;

        case EDRMPlayServSetBalance:

            ret = SetBalance(aMessage);

            break;

        case EDRMPlayServGetBalance:

            ret = GetBalance(aMessage);

            break;

        case EDRMPlayServGetBitRate:

            ret = GetBitRate(aMessage);

            break;

        case EDRMPlayServRegisterForAudioLoadingNotification:

            iMessage = aMessage;

            RegisterForAudioLoadingNotification(aMessage);

            iAsyncComplete = ETrue;

            break;

        case EDRMPlayServGetAudioLoadingProgress:

            GetAudioLoadingProgressL(aMessage);

            break;

        case EDRMPlayServSetPlayWindow:

            SetPlayWindow(aMessage);

            break;

        case EDRMPlayServControllerImplementationInformation:

            ControllerImplementationInformationL(aMessage);

            break;

        case EDRMPlayServCustomCommandSyncWithReturn:

        case EDRMPlayServCustomCommandSyncWithoutReturn:

                CustomCommandSyncL(aMessage);

                break;

        case EDRMPlayServCustomCommandAsyncWithReturnStep1:

        case EDRMPlayServCustomCommandAsyncWithoutReturnStep1:

            CustomCommandAsyncStep1L(aMessage);

            // Setting this flag does not complete message in ServiceL,

            iAsyncComplete = ETrue;

            break;

        case EDRMPlayServCustomCommandAsyncWithReturnStep2:

        case EDRMPlayServCustomCommandAsyncWithoutReturnStep2:

            CustomCommandAsyncStep2L(aMessage);

            // Setting this flag does not complete message in ServiceL,

            iAsyncComplete = ETrue;

            break;

        case EDRMPlayServSetPriorityPreference:

            SetPriorityPreference(aMessage);

            break;

       default:

         PanicClient(aMessage, EBadRequest);

         break;

        }

    return ret;

    }

void CDRMPlayServerSession::NewFilePlayerL(const RMessage2 aMessage)

    {

    TDataStructPckgBuf params;

    aMessage.Read(0,iCallbackState);

    aMessage.Read(1,params);

    aMessage.Read(2,iErrDurPckg);

    HBufC16* inputBuf = HBufC16::NewL(aMessage.GetDesLengthL(3));

    TPtr16 ptr = inputBuf->Des();

    aMessage.Read(3,ptr);

    const TDataStruct &theStruct = params();

    delete iPlayUtil;

    iPlayUtil = NULL;

    iPlayUtil = CMdaAudioPlayerUtility::NewFilePlayerL( inputBuf->Des(),

                                                       *this,

                                                       iPriority,

                                                       iPref);

    delete inputBuf;

    }

void CDRMPlayServerSession::NewDesPlayerL(const RMessage2 aMessage)

    {

    TDataStructPckgBuf thePckg;

    aMessage.Read(0,iCallbackState);

    aMessage.Read(1,thePckg);

    aMessage.Read(2,iErrDurPckg);

    delete iPlayUtil;

    iPlayUtil = NULL;

    iPlayUtil = CMdaAudioPlayerUtility::NewDesPlayerL(thePckg().iData,

                                                      *this,

                                                      iPriority,

                                                      iPref);

    }

void CDRMPlayServerSession::NewDesPlayerReadOnlyL(const RMessage2 aMessage)

    {

    TDataStructPckgBuf thePckg;

    aMessage.Read(0,iCallbackState);

    aMessage.Read(1,thePckg);

    aMessage.Read(2,iErrDurPckg);

    delete iPlayUtil;

    iPlayUtil = NULL;

    iPlayUtil = CMdaAudioPlayerUtility::NewDesPlayerReadOnlyL(thePckg().iData,

                                                              *this,

                                                              iPriority,

                                                              iPref);

    }

void CDRMPlayServerSession::NewPlayerL(const RMessage2 aMessage)

    {

    TDataStructPckgBuf thePckg;

    aMessage.Read(0,iCallbackState);

    aMessage.Read(1,thePckg);

    aMessage.Read(2,iErrDurPckg);

    delete iPlayUtil;

    iPlayUtil = NULL;

    iPlayUtil = CMdaAudioPlayerUtility::NewL(*this,

                                             iPriority,

                                             iPref);

    }

void CDRMPlayServerSession::OpenFileL(const RMessage2 &aMessage)

    {

    //call mmfclientaudioplayer open file

    iFileHandleUsed = EFalse;

    aMessage.Read(0,iCallbackState);

    // Get the file length

    TInt len = aMessage.GetDesLengthL(1);

    HBufC* fileName = HBufC::NewLC(len);

    TPtr fileNamePtr = fileName->Des();

    aMessage.Read(1,fileNamePtr);

    aMessage.Read(2,iErrDurPckg);

    if(iPlayUtil)

        {

        iPlayUtil->OpenFileL(fileNamePtr);

        }

    CleanupStack::PopAndDestroy(fileName);

    }

void CDRMPlayServerSession::OpenFileByHandleL(const RMessage2 &aMessage)

    {

    iFileHandleUsed = ETrue;

    TInt err = iFileHandle.AdoptFromClient(aMessage,1,3);

    aMessage.Read(0,iCallbackState);

    aMessage.Read(2,iErrDurPckg);

    if (err == KErrNone)

        {

        if(iPlayUtil)

            {

            iPlayUtil->OpenFileL(iFileHandle);

            }

        }

    else

        {

        User::Leave(err);

        }

    }

void CDRMPlayServerSession::OpenFileBySourceL(const RMessage2 &/*aMessage*/)

    {

    }

void CDRMPlayServerSession::OpenDesL(const RMessage2 &aMessage)

    {

    //call mmfclientaudioplayer OpenDesL

    TBuf8<50> aDes;

    aMessage.Read(0,iCallbackState);

    aMessage.Read(1,aDes);

    aMessage.Read(2,iErrDurPckg);

    if(iPlayUtil)

        {

        iPlayUtil->OpenDesL(aDes);

        }

    }

void CDRMPlayServerSession::OpenUrlL(const RMessage2 &aMessage)

    {

    //call mmfclientaudioplayer OpenUrlL

    TUrlStructPckgBuf thePckg;

    aMessage.Read(0,iCallbackState);

    aMessage.Read(1,thePckg);

    aMessage.Read(2,iErrDurPckg);

    if(iPlayUtil)

        {

        iPlayUtil->OpenUrlL(thePckg().iUrl,

                            thePckg().iIapId,

                            thePckg().iMimeType);

        }

    }

void CDRMPlayServerSession::Play()

    {

    //call mmfclientaudioplayer Play

    iState = EPlaying;

    if(iPlayUtil)

        {

        iPlayUtil->Play();

#ifdef RD_TSP_CLIENT_MAPPER

        TInt status = iTSPClientMapper->SetTspTargetClientToOtherType(

                                            CTspClientMapper::EPlayingClients,

                                            iClientProcessId );

        DEP_PRN2(_L("CDRMPlayServerSession::Play:Change PID[%x]Status[%d]"), iClientProcessId.Id(), status );

#endif // #ifdef RD_TSP_CLIENT_MAPPER

        }

    }

void CDRMPlayServerSession::Stop()

    {

    //call mmfclientaudioplayer Stop

    if(iPlayUtil)

        {

        iPlayUtil->Stop();

#ifdef RD_TSP_CLIENT_MAPPER

        TInt status = iTSPClientMapper->SetTspTargetClientToOtherType(

                                            CTspClientMapper::EStoppedClients,

                                            iClientProcessId );

        DEP_PRN2(_L("CDRMPlayServerSession::Stop:Change PID[%x]Status[%d]"), iClientProcessId.Id(), status );

#endif // #ifdef RD_TSP_CLIENT_MAPPER

        }

    iState = EStopped;

    }

void CDRMPlayServerSession::SetVolume(const RMessage2 & aMessage)

    {

    //call mmfclientaudioplayer SetVolume

    TInt theVolume = aMessage.Int0();

    if(iPlayUtil)

        {

        iPlayUtil->SetVolume(theVolume);

        }

    }

void CDRMPlayServerSession::SetRepeats(const RMessage2 &aMessage)

    {

    //call mmfclientaudioplayer SetRepeats

    TInt theRepeatNumberOfTimes = aMessage.Int0();

    TTimeIntervalMicroSeconds theTrailingSilence;

    TPckgTTimeIntervalMicroSeconds theTrailingSilencePckg(theTrailingSilence);

    aMessage.Read(1,theTrailingSilencePckg);

    iPlayUtil->SetRepeats(theRepeatNumberOfTimes,theTrailingSilence);

    }

void CDRMPlayServerSession::SetVolumeRamp(const RMessage2 &aMessage)

    {

    //call mmfclientaudioplayer SetVolumeRamp

    TTimeIntervalMicroSeconds theRampDuration;

    TPckgTTimeIntervalMicroSeconds theRampDurationPckg(theRampDuration);

    aMessage.Read(0,theRampDurationPckg);

    iPlayUtil->SetVolumeRamp(theRampDuration);

    }

void CDRMPlayServerSession::Duration(const RMessage2& aMessage)

    {

    TTimeIntervalMicroSeconds theDuration;

    theDuration = iPlayUtil->Duration();

    TPckgBufTTimeIntervalMicroSeconds theDurationPckg(theDuration);

    aMessage.Write(0,theDurationPckg);

    }

TInt CDRMPlayServerSession::MaxVolume()

    {

    TInt theMaxVolume;

    theMaxVolume = iPlayUtil->MaxVolume();

    return theMaxVolume;

    }

// API Additions since version 7.0

TInt CDRMPlayServerSession::Pause()

    {

    TInt ret = KErrNone;

    if(iPlayUtil)

        {

        ret = iPlayUtil->Pause();

        }

    // This message should not be completed here. It should be completed in ServiceL()

/*    if(iState == EPlaying)

        {

        iMessage.Complete(KErrNone);

        }*/

    iState = EStopped;

    return ret;

    }

void CDRMPlayServerSession::Close()

    {

    if(iFileHandleUsed)

     iFileHandle.Close();

    iPlayUtil->Close();

    }

TInt CDRMPlayServerSession::GetPosition(const RMessage2 &aMessage)

    {

    TInt ret;

    TTimeIntervalMicroSeconds thePosition;

    ret = iPlayUtil->GetPosition(thePosition);

    TPckgTTimeIntervalMicroSeconds thePositionPckg(thePosition);

    aMessage.Write(0,thePositionPckg);

    return ret;

    }

void CDRMPlayServerSession::SetPosition(const RMessage2 &aMessage)

    {

    TTimeIntervalMicroSeconds thePosition;

    TPckgTTimeIntervalMicroSeconds thePositionPckg(thePosition);

    aMessage.Read(0,thePositionPckg);

    iPlayUtil->SetPosition(thePosition);

    }

TInt CDRMPlayServerSession::SetPriority(const RMessage2 &aMessage)

    {

    TInt thePriority = aMessage.Int0();

    TMdaPriorityPreference thePref = (TMdaPriorityPreference)aMessage.Int1();

    TInt ret = iPlayUtil->SetPriority(thePriority,thePref);

    return ret;

    }

TInt CDRMPlayServerSession::GetVolume(const RMessage2 &aMessage)

    {

    TInt theVolume;

    TInt ret = iPlayUtil->GetVolume(theVolume);

    TPckgBufTInt pckg(theVolume);

    aMessage.Write(0,pckg);

    return ret;

    }

TInt CDRMPlayServerSession::GetNumberOfMetaDataEntries(const RMessage2 &aMessage)

    {

    TInt ret;

    TInt theNumOfMetaDataEntries;

    ret = iPlayUtil->GetNumberOfMetaDataEntries(theNumOfMetaDataEntries);

    TPckgBufTInt pckg(theNumOfMetaDataEntries);

    aMessage.Write(0,pckg);

    return ret;

    }

void CDRMPlayServerSession::GetMetaDataEntryL(const RMessage2 &aMessage)

    {

    //Get the index of the required entry

    TInt theIndex = aMessage.Int0();

    CMMFMetaDataEntry* entry = iPlayUtil->GetMetaDataEntryL(theIndex);

    CleanupStack::PushL(entry);

    // Delete any existing buffer

    if (iMetaDataBuffer)

    	{

    	delete iMetaDataBuffer;

    	iMetaDataBuffer = NULL;

    	}

    // Create a buffer to hold the externalised entry

    iMetaDataBuffer = CBufFlat::NewL(32);

    RBufWriteStream s;

    s.Open(*iMetaDataBuffer);

    CleanupClosePushL(s);

    entry->ExternalizeL(s);

    CleanupStack::PopAndDestroy(2);//s, entry

    //Write the externalised data back to the client

    aMessage.Write(1,iMetaDataBuffer->Ptr(0));

    }

TInt CDRMPlayServerSession::SetPlayWindow(const RMessage2 &aMessage)

    {

    TPlayWindowStructBuf buf;

    aMessage.Read(0,buf);

    TTimeIntervalMicroSeconds playStart = buf().iPlayStart;

    TTimeIntervalMicroSeconds playEnd = buf().iPlayEnd;

    TInt ret = iPlayUtil->SetPlayWindow(playStart,playEnd);

    return ret;

    }

TInt CDRMPlayServerSession::ClearPlayWindow()

    {

    return iPlayUtil->ClearPlayWindow();

    }

TInt CDRMPlayServerSession::SetBalance(const RMessage2 &aMessage)

    {

    TInt theBalance = aMessage.Int0();

    return iPlayUtil->SetBalance(theBalance);

    }

TInt CDRMPlayServerSession::GetBalance(const RMessage2 &aMessage)

    {

    TInt theBalance;

    TInt ret;

    ret = iPlayUtil->GetBalance(theBalance);

    TPckgBufTInt pckg(theBalance);

    aMessage.Write(0,pckg);

    return ret;

    }

TInt CDRMPlayServerSession::GetBitRate(const RMessage2 &aMessage)

    {

    TUint theBitRate;

    TInt ret;

    ret = iPlayUtil->GetBitRate(theBitRate);

    TPckgBufTUint pckg(theBitRate);

    aMessage.Write(0,pckg);

    return ret;

    }

void CDRMPlayServerSession::RegisterForAudioLoadingNotification(const RMessage2 &aMessage)

    {

    aMessage.Read(0,iCallbackState);

    if(iCallbackState()==ELoadingStarted)

        {

        iPlayUtil->RegisterForAudioLoadingNotification(*this);

        }

    }

void CDRMPlayServerSession::GetAudioLoadingProgressL(const RMessage2 &aMessage)

    {

    TInt thePercentProgress;

    iPlayUtil->GetAudioLoadingProgressL(thePercentProgress);

    TPckgBufTInt pckg(thePercentProgress);

    aMessage.Write(0,pckg);

    }

void CDRMPlayServerSession::ControllerImplementationInformationL(const RMessage2 &aMessage)

    {

    const CMMFControllerImplementationInformation& x= iPlayUtil->ControllerImplementationInformationL();

    //for now just write Uid by to client

    typedef TPckg<TUid> TPckgTUid;

    TPckgTUid thePckg(x.Uid());

    aMessage.Write(0,thePckg);

    }

void CDRMPlayServerSession::CustomCommandSyncL(const RMessage2 &aMessage)

    {

    DEP_PRN0(_L("CDRMPlayServerSession::CustomCommandSyncL:Enter"));

    TPckgCustomCommand thePckgCustomCommand;

    User::LeaveIfError(aMessage.Read(0,thePckgCustomCommand));

    HBufC8* dataTo1Buf(NULL);

    HBufC8* dataTo2Buf(NULL);

    HBufC8* dataFromBuf(NULL);

    TPtr8 ptr1(NULL, NULL);

    TPtr8 ptr2(NULL, NULL);

    TPtr8 ptr3(NULL, NULL);

    // Read data1

    dataTo1Buf = HBufC8::NewL(aMessage.GetDesLengthL(1));

    CleanupStack::PushL(dataTo1Buf);

    ptr1.Set(dataTo1Buf->Des());

    User::LeaveIfError(aMessage.Read(1,ptr1));

   // Check and filter the messages

   // Dont Allow Select Custom Commands

   if( !IsValidCustomCommandDestination(thePckgCustomCommand().iDestination().InterfaceId(), ptr1) )

            User::Leave(KErrAccessDenied);

    // Read data2

    dataTo2Buf = HBufC8::NewL(aMessage.GetDesLengthL(2));

    CleanupStack::PushL(dataTo2Buf);

    ptr2.Set(dataTo2Buf->Des());

    User::LeaveIfError(aMessage.Read(2,ptr2));

    if ( aMessage.Function() == EDRMPlayServCustomCommandSyncWithReturn )

        {

        // Read data3

        dataFromBuf = HBufC8::NewL(aMessage.GetDesLengthL(3));

        CleanupStack::PushL(dataFromBuf);

        ptr3.Set(dataFromBuf->Des());

        User::LeaveIfError(aMessage.Read(3,ptr3));

/*

        RDebug::Print(_L("CDRMPlayServerSession::CustomCommandSync:IFId[%x]DestHndl[%x]Fn[%d]RetDesLen[%d]"),

                                    thePckgCustomCommand().iDestination().InterfaceId(),

                                    thePckgCustomCommand().iDestination().DestinationHandle(),

                                    thePckgCustomCommand().iFunction,

                                    ptr3.MaxLength());

*/

        // Call CustomCommandSync on play util

        User::LeaveIfError(iPlayUtil->CustomCommandSync(

                                            thePckgCustomCommand().iDestination,

                                            thePckgCustomCommand().iFunction,

                                            ptr1,

                                            ptr2,

                                            ptr3));

        User::LeaveIfError(aMessage.Write(3,ptr3));

        // Free heap allocated for data3

        CleanupStack::PopAndDestroy(dataFromBuf);

        }

    else

        {

/*

        RDebug::Print(_L("CDRMPlayServerSession::CustomCommandSync:IFId[%x]DestHndl[%x]Fn[%d]"),

                                    thePckgCustomCommand().iDestination().InterfaceId(),

                                    thePckgCustomCommand().iDestination().DestinationHandle(),

                                    thePckgCustomCommand().iFunction );

*/

        // Call CustomCommandSync on play util

        User::LeaveIfError(iPlayUtil->CustomCommandSync(

                                            thePckgCustomCommand().iDestination,

                                            thePckgCustomCommand().iFunction,

                                            ptr1,

                                            ptr2));

        }

    // Free heap allocated for data2

    CleanupStack::PopAndDestroy(dataTo2Buf);

    // Free heap allocated for data1

    CleanupStack::PopAndDestroy(dataTo1Buf);

    DEP_PRN0(_L("CDRMPlayServerSession::CustomCommandSyncL:Exit"));

    }

void CDRMPlayServerSession::CustomCommandAsyncStep1L( const RMessage2& aMessage )

    {

    DEP_PRN0(_L("CDRMPlayServerSession::CustomCommandAsyncStep1L:Enter"));

    // If there is a pending phase1, then there is something wrong.

    if ( iCDRMCustomCommandAsyncAO2Phase )

        {

        User::Leave(KErrAlreadyExists);

        }

    if ( aMessage.Function() == EDRMPlayServCustomCommandAsyncWithReturnStep1 )

        {

        iCDRMCustomCommandAsyncAO2Phase = CDRMCustomCommandAsyncAO::NewL(

                                                    aMessage,

                                                    CDRMCustomCommandAsyncAO::ECustomCommandWithResult,

                                                    *this );

        }

    else /*if ( aMessage.Function() == EDRMPlayServCustomCommandAsyncWithoutReturnStep1 )*/

        {

        iCDRMCustomCommandAsyncAO2Phase = CDRMCustomCommandAsyncAO::NewL(

                                                    aMessage,

                                                    CDRMCustomCommandAsyncAO::ECustomCommandWithoutResult,

                                                    *this );

        }

    // Get reference to data1 descriptor

    TPtr8 data1Ptr(iCDRMCustomCommandAsyncAO2Phase->GetData1FromClient()->Des());

    // Check and filter the messages

    // Dont Allow Select Custom Commands

    if( !IsValidCustomCommandDestination((iCDRMCustomCommandAsyncAO2Phase->GetMMFMessageDestinationPckg())().InterfaceId(), data1Ptr) )

        {

        User::Leave( KErrAccessDenied );

        }

    aMessage.Complete( KErrNone );

    DEP_PRN0(_L("CDRMPlayServerSession::CustomCommandAsyncStep1L:Exit"));

    }

void CDRMPlayServerSession::CustomCommandAsyncStep2L( const RMessage2& aMessage )

    {

    DEP_PRN0(_L("CDRMPlayServerSession::CustomCommandAsyncStep2L:Enter"));

    // Read info from client session

    TPtr8 data1Ptr(NULL,NULL);

    TPtr8 data2Ptr(NULL,NULL);

    TPtr8 dataToClientPtr(NULL,NULL);

    // If there is no pending phase1, then there is something wrong.

    if ( !iCDRMCustomCommandAsyncAO2Phase )

        {

        User::Leave(KErrNotReady);

        }

    // Add custCmdAsyncAO object to array of async custom command objects

    iActiveAsyncCustomCommands.AppendL( iCDRMCustomCommandAsyncAO2Phase );

    // aMessage ownership is transferred to custCmdAsyncAO.

    // After succesful transfer, aMessage should not be completed

    // anywhere outside of this object.

    iCDRMCustomCommandAsyncAO2Phase->TransferOwnershipL(aMessage);

    CDRMCustomCommandAsyncAO* drmCCAsyncAO = iCDRMCustomCommandAsyncAO2Phase;

    iCDRMCustomCommandAsyncAO2Phase = NULL;

    // Get reference to descriptors

    data1Ptr.Set(drmCCAsyncAO->GetData1FromClient()->Des());

    data2Ptr.Set(drmCCAsyncAO->GetData2FromClient()->Des());

    // Make call on controller

    drmCCAsyncAO->SetActive();

    if ( aMessage.Function() == EDRMPlayServCustomCommandAsyncWithReturnStep2 )

        {

        // If date needs to be returned, get reference to the descriptor

        dataToClientPtr.Set(drmCCAsyncAO->GetDataToClient()->Des());

/*

        RDebug::Print(_L("CDRMPlayServerSession::CustomCommandAsyncStep2L:IFId[%x]DestHndl[%x]Fn[%d]Data1[Len:%d:MaxLen:%d]Data2Len[Len:%d:MaxLen:%d]RetDesLen[Len:%d:MaxLen:%d]"),

                                    (drmCCAsyncAO->GetMMFMessageDestinationPckg())().InterfaceId(),

                                    (drmCCAsyncAO->GetMMFMessageDestinationPckg())().DestinationHandle(),

                                    drmCCAsyncAO->GetMMFMessageFunction(),

                                    data1Ptr.Length(),

                                    data1Ptr.MaxLength(),

                                    data2Ptr.Length(),

                                    data2Ptr.MaxLength(),

                                    dataToClientPtr.Length(),

                                    dataToClientPtr.MaxLength() );

*/

        // Call CustomCommandAsync on play util

        iPlayUtil->CustomCommandAsync(

                        drmCCAsyncAO->GetMMFMessageDestinationPckg(),

                        drmCCAsyncAO->GetMMFMessageFunction(),

                        data1Ptr,

                        data2Ptr,

                        dataToClientPtr,

                        drmCCAsyncAO->iStatus );

        }

    else /*if ( aMessage.Function() == EDRMPlayServCustomCommandAsyncWithoutReturnStep2 )*/

        {

/*

        RDebug::Print(_L("CDRMPlayServerSession::CustomCommandAsyncStep2L:IFId[%x]DestHndl[%x]Fn[%d]Data1[Len:%d:MaxLen:%d]Data2Len[Len:%d:MaxLen:%d]"),

                                    (drmCCAsyncAO->GetMMFMessageDestinationPckg())().InterfaceId(),

                                    (drmCCAsyncAO->GetMMFMessageDestinationPckg())().DestinationHandle(),

                                    drmCCAsyncAO->GetMMFMessageFunction(),

                                    data1Ptr.Length(),

                                    data1Ptr.MaxLength(),

                                    data2Ptr.Length(),

                                    data2Ptr.MaxLength() );

*/

        // Call CustomCommandAsync on play util

        iPlayUtil->CustomCommandAsync(

                        drmCCAsyncAO->GetMMFMessageDestinationPckg(),

                        drmCCAsyncAO->GetMMFMessageFunction(),

                        data1Ptr,

                        data2Ptr,

                        drmCCAsyncAO->iStatus );

        }

    DEP_PRN0(_L("CDRMPlayServerSession::CustomCommandAsyncStep2L:Exit"));

    }

void CDRMPlayServerSession::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration)

    {

    DEP_PRN2(_L("CDRMPlayServerSession::MapcInitComplete :-> Status[%d] Duration[%d]"), aError, I64INT(aDuration.Int64()));

     //iMessage.Write aError & aDuration to client

    iCallbackState() = EInitComplete;

    iMessage.Write(0,iCallbackState);

    iErrDurPckg().iError = aError;

    iErrDurPckg().iDuration = aDuration;

    iMessage.Write(2,iErrDurPckg);

    iMessage.Complete(aError);

    iAsyncComplete= EFalse;

    }

void CDRMPlayServerSession::MapcPlayComplete(TInt aError)

    {

    DEP_PRN1(_L("CDRMPlayServerSession::MapcPlayComplete :-> Error[%d]"), aError);

#ifdef RD_TSP_CLIENT_MAPPER