/*

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