/*

 * 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:   DRM Play Session

 *

 */

 #include "DRMCustomCommandAsyncAO.h"

 #include "DRMPlaySession.h"

 #ifdef _DEBUG

 #include <e32debug.h>

 #define TRACEPRNFNIN RDebug::Printf( "%s @ %d, %s>ENTER", __FILE__, __LINE__,  __PRETTY_FUNCTION__ );

 #define TRACEPRNFNOUT RDebug::Printf( "%s @ %d, %s>EXIT", __FILE__, __LINE__,  __PRETTY_FUNCTION__ );

 #define DEBPRN2(s, v1) RDebug::Print(s, v1);

 #define DEBPRN3(s, v1, v2) RDebug::Print(s, v1, v2);

 #else

 #define TRACEPRNFNIN

 #define TRACEPRNFNOUT

 #define DEBPRN2(s, v1)

 #define DEBPRN3(s, v1, v2)

 #endif

 CDRMCustomCommandAsyncAO::CDRMCustomCommandAsyncAO( TCustomCommandType aType, CDRMPlayServerSession& aParent )

 : CActive(CActive::EPriorityStandard),

  iCustomCommandType(aType),

  iAmCompleted(EFalse),

  iParent(aParent),

  iData1FromClient(NULL),

  iData2FromClient(NULL),

  iDataToClient(NULL)

     {

     TRACEPRNFNIN;

     CActiveScheduler::Add(this);

     TRACEPRNFNOUT;

     }

 CDRMCustomCommandAsyncAO::~CDRMCustomCommandAsyncAO()

     {

     TRACEPRNFNIN;

     Cancel();

     if ( !iAmCompleted && iMessage)

         {

         iMessage->Complete( KErrCancel );

         }

     // Delete the descriptors created on heap

     delete iData1FromClient;

     delete iData2FromClient;

     delete iDataToClient;

     delete iMessage;

     TRACEPRNFNOUT;

     }

 CDRMCustomCommandAsyncAO* CDRMCustomCommandAsyncAO::NewL( const RMessage2& aMessage,

                                                           TCustomCommandType aType,

                                                           CDRMPlayServerSession& aParent )

     {

     TRACEPRNFNIN;

     CDRMCustomCommandAsyncAO* self = new ( ELeave )CDRMCustomCommandAsyncAO( aType, aParent );

     CleanupStack::PushL( self );

     self->ConstructL(aMessage);

     CleanupStack::Pop( self );

     TRACEPRNFNOUT;

     return self;

     }

 void CDRMCustomCommandAsyncAO::ConstructL( const RMessage2& aMessage )

     {

     TRACEPRNFNIN;

     //Read mmf message destination information

     TPckgCustomCommand thePckg;

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

     iMMFMessageDestinationPckg = thePckg().iDestination;

     iMMFMessageFunction = thePckg().iFunction;

 /*

     RDebug::Print(_L("CDRMCustomCommandAsyncAO::ConstructL:InterfaceId[%x]DestinationHandle[%d]"), \

                                 iMMFMessageDestinationPckg().InterfaceId(),

                                 iMMFMessageDestinationPckg().DestinationHandle() );

 */

     // Create descriptors to hold data1, data2

     // Get Data 1 from client

     TInt dataLen = aMessage.GetDesLengthL( 1 );

     iData1FromClient = HBufC8::NewL( dataLen );

     TPtr8 data1Ptr = iData1FromClient->Des();

     aMessage.ReadL( 1, data1Ptr );

     // Get Data 2 from client

     dataLen = aMessage.GetDesLengthL( 2 );

     iData2FromClient = HBufC8::NewL( dataLen );

     TPtr8 data2Ptr = iData2FromClient->Des();

     aMessage.ReadL( 2, data2Ptr );

     TRACEPRNFNOUT;

     }

 TMMFMessageDestinationPckg& CDRMCustomCommandAsyncAO::GetMMFMessageDestinationPckg()

     {

     return iMMFMessageDestinationPckg;

     }

 TInt CDRMCustomCommandAsyncAO::GetMMFMessageFunction()

     {

     return iMMFMessageFunction;

     }

 HBufC8* CDRMCustomCommandAsyncAO::GetData1FromClient()

     {

     return iData1FromClient;

     }

 HBufC8* CDRMCustomCommandAsyncAO::GetData2FromClient()

     {

     return iData2FromClient;

     }

 HBufC8* CDRMCustomCommandAsyncAO::GetDataToClient()

     {

     return iDataToClient;

     }

 TInt CDRMCustomCommandAsyncAO::SetActive()

     {

     TRACEPRNFNIN;

     TInt status(KErrNotReady);

     if ( !IsActive() && iMessage )

         {

         CActive::SetActive();

         status = KErrNone;

         }

     TRACEPRNFNOUT;

     return status;

     }

 void CDRMCustomCommandAsyncAO::TransferOwnershipL( const RMessage2& aMessage )

     {

     // If this is a async custom command with result back to client

     // Descriptor place holder is passed in the async message 'aMessage'.

     if ( iCustomCommandType == ECustomCommandWithResult )

         {

         // Create buffer to hold the result back

         TInt dataLen = aMessage.GetDesMaxLengthL( 0 );

         iDataToClient = HBufC8::NewL( dataLen );

         }

     iMessage = new (ELeave) RMessage2(aMessage);

     }

 void CDRMCustomCommandAsyncAO::RunL()

     {

     TRACEPRNFNIN;

     TInt status(KErrNone);

     // Write the result back if client is expecting one

     TPtr8 dataPtr = iDataToClient->Des();

     if ( ( iCustomCommandType == ECustomCommandWithResult ) &&

          (dataPtr.Length() > 0 ) )

         {

         status = iMessage->Write( 0, dataPtr );

 #ifdef _DEBUG

         if ( status != KErrNone )

             {

             RDebug::Print(_L("CDRMCustomCommandAsyncAO::RunL:iMessage.Write()->Len[%d]MaxLen[%d]Status[%d]"),

                             dataPtr.Length(),

                             dataPtr.MaxLength(),

                             status);

             }

 #endif // _DEBUG

         }

     // Complete the message

     status = iStatus.Int();

     DEBPRN2(_L("CDRMCustomCommandAsyncAO::RunL[%d]"), status );

     iMessage->Complete( status );

     iAmCompleted = ETrue;

     // Signal the parent

     iParent.AsyncCustomCommandCompleted( this );

     TRACEPRNFNOUT;

     }

 void CDRMCustomCommandAsyncAO::DoCancel()

     {

     TRACEPRNFNIN;

     iMessage->Complete( KErrCancel );

     iAmCompleted = ETrue;

     TRACEPRNFNOUT;

     }

 TInt CDRMCustomCommandAsyncAO::RunError( TInt /*aError*/ )

     {

     TRACEPRNFNIN;

     // There was some error completing message....

     TRACEPRNFNOUT;

     return KErrNone;

     }

 // End of File