/*
* 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