/*

* Copyright (c) 2008-2009 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:  Implementation class for WMDRM DLA Handler

*

*/

#include <ecom/ecom.h>

#include "wmdrmdlahandlerimpl.h"

#include "wmdrmdlahttplicacqpluginfw.h"

#include "wmdrmdlahttpmeteringpluginfw.h"

#include "wmdrmdlarequest.h"

#define _LOGGING_FILE L"wmdrmdla.txt"

#include "logfn.h"

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

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

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

// CWmDrmDlaHandlerImpl::ConstructL

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

//

void CWmDrmDlaHandlerImpl::ConstructL()

    {

    LOGFN( "CWmDrmDlaHandlerImpl::ConstructL" );

    iLicenseAcquisitionFw = CWmDrmDlaHttpLicAcqPluginFw::NewL();

    iMeteringFw = CWmDrmDlaHttpMeteringPluginFw::NewL();

    iWait = new (ELeave) CActiveSchedulerWait;

    }

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

// CWmDrmDlaHandlerImpl::CWmDrmDlaHandlerImpl

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

//

CWmDrmDlaHandlerImpl::CWmDrmDlaHandlerImpl() 

    : CActive( EPriorityStandard ), iState( CWmDrmDlaHandlerImpl::EIdle )

    {

    LOGFN( "CWmDrmDlaHandlerImpl::CWmDrmDlaHandlerImpl" );

    CActiveScheduler::Add( this );

    }

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

// CWmDrmDlaHandlerImpl::NewL

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

//

CWmDrmDlaHandlerImpl* CWmDrmDlaHandlerImpl::NewL()

    {

    LOGFN( "CWmDrmDlaHandlerImpl::NewL" );

    CWmDrmDlaHandlerImpl* self = CWmDrmDlaHandlerImpl::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWmDrmDlaHandlerImpl::NewLC

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

//

CWmDrmDlaHandlerImpl* CWmDrmDlaHandlerImpl::NewLC()

    {

    LOGFN( "CWmDrmDlaHandlerImpl::NewLC" );

    CWmDrmDlaHandlerImpl* self = new( ELeave ) CWmDrmDlaHandlerImpl;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CWmDrmDlaHandlerImpl::~CWmDrmDlaHandlerImpl

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

//

CWmDrmDlaHandlerImpl::~CWmDrmDlaHandlerImpl()

    {

    LOGFN( "CWmDrmDlaHandlerImpl::~CWmDrmDlaHandlerImpl" );

    CancelLicenseAcquisition();

    CancelMetering();

    iRequests.ResetAndDestroy();

    iRequests.Close();

    delete iCurrentRequest;

    delete iSyncRequest;

    delete iLicenseAcquisitionFw;

    delete iMeteringFw;

    delete iWait;

    REComSession::FinalClose();

    }

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

// CWmDrmDlaHandlerImpl::SilentL

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

//

TBool CWmDrmDlaHandlerImpl::SilentL( 

    const RFile& aFile )

    {

    LOGFN( "CWmDrmDlaHandlerImpl::SilentL" );

    TBool silent( iLicenseAcquisitionFw->SilentL( aFile ) );

    LOG2( "silent: %d", silent );

    return silent;

    }

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

// CWmDrmDlaHandlerImpl::AcquireLicenseL

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

///

void CWmDrmDlaHandlerImpl::AcquireLicenseL( 

    const RFile& aFile, 

    HBufC*& aContentUrl, 

    HBufC*& aHtmlData )

    {

    LOGFN( "CWmDrmDlaHandlerImpl::AcquireLicenseL" );

    if ( iWait->IsStarted() )

        {

        User::Leave( KErrInUse );

        }

    CWmDrmDlaRequest* request( CWmDrmDlaRequest::NewL( aFile, 

                                                       aContentUrl, 

                                                       aHtmlData, 

                                                       ETrue, 

                                                       iStatus ) );

    if ( iState == CWmDrmDlaHandlerImpl::EIdle  )

        {

        iCurrentRequest = request;

        iState = CWmDrmDlaHandlerImpl::EAcquiringLicense;

        CompleteSelf();

        }

    else

        {

        iSyncRequest = request;

        }

    iWait->Start();

    LOG2( "iSyncReturnValue: %d", iSyncReturnValue );

    User::LeaveIfError( iSyncReturnValue );

    }

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

// CWmDrmDlaHandlerImpl::AcquireLicense

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

//

void CWmDrmDlaHandlerImpl::AcquireLicense( 

    const RFile& aFile, 

    HBufC*& aContentUrl, 

    HBufC*& aHtmlData, 

    TRequestStatus& aStatus )

    {

    TInt err( KErrNone );

    LOGFNR( "CWmDrmDlaHandlerImpl::AcquireLicense", err );

    CWmDrmDlaRequest* request( NULL );

    TRequestStatus *status = &aStatus;

    aStatus = KRequestPending;

    TRAP( err, request = CWmDrmDlaRequest::NewL( aFile, 

                                                 aContentUrl, 

                                                 aHtmlData, 

                                                 EFalse, 

                                                 aStatus ) );

    if ( err )

        {

        User::RequestComplete( status, err );

        }

    else if ( iState == CWmDrmDlaHandlerImpl::EIdle  )

        {

        iCurrentRequest = request;

        iState = CWmDrmDlaHandlerImpl::EAcquiringLicense;

        CompleteSelf();

        }

    else

        {

        err = iRequests.Append( request );

        if ( err )

            {

            delete request;

            User::RequestComplete( status, err );

            }

        }

    }

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

// CWmDrmDlaHandlerImpl::AcquireLicenseFromDrmHeaderL

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

//

void CWmDrmDlaHandlerImpl::AcquireLicenseFromDrmHeaderL( 

    const TDesC8& aDrmHeader,

    HBufC* aErrorUrl,

    HBufC*& aContentUrl, 

    HBufC*& aHtmlData )

    {

    LOGFN( "CWmDrmDlaHandlerImpl::AcquireLicenseFromDrmHeaderL" );

    if ( iWait->IsStarted() )

        {

        User::Leave( KErrInUse );

        }

    CWmDrmDlaRequest* request( CWmDrmDlaRequest::NewL( aDrmHeader,

                                                       aErrorUrl,

                                                       aContentUrl, 

                                                       aHtmlData, 

                                                       ETrue, 

                                                       iStatus ) );

    if ( iState == CWmDrmDlaHandlerImpl::EIdle  )

        {

        iCurrentRequest = request;

        iState = CWmDrmDlaHandlerImpl::EAcquiringLicenseFromDrmHeader;

        CompleteSelf();

        }

    else

        {

        iSyncRequest = request;

        }

    iWait->Start();

    LOG2( "iSyncReturnValue: %d", iSyncReturnValue );

    User::LeaveIfError( iSyncReturnValue );

    }

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

// CWmDrmDlaHandlerImpl::AcquireLicenseFromDrmHeader

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

//

void CWmDrmDlaHandlerImpl::AcquireLicenseFromDrmHeader( 

    const TDesC8& aDrmHeader, 

    HBufC* aErrorUrl,

    HBufC*& aContentUrl, 

    HBufC*& aHtmlData, 

    TRequestStatus& aStatus )

    {

    TInt err( KErrNone );

    LOGFNR( "CWmDrmDlaHandlerImpl::AcquireLicenseFromDrmHeader", err );

    CWmDrmDlaRequest* request( NULL );

    TRequestStatus *status = &aStatus;

    aStatus = KRequestPending;

    TRAP( err, request = CWmDrmDlaRequest::NewL( aDrmHeader,

                                                 aErrorUrl,

                                                 aContentUrl, 

                                                 aHtmlData, 

                                                 EFalse, 

                                                 aStatus ) );

    if ( err )

        {

        User::RequestComplete( status, err );

        }

    else if ( iState == CWmDrmDlaHandlerImpl::EIdle  )

        {

        iCurrentRequest = request;

        iState = CWmDrmDlaHandlerImpl::EAcquiringLicenseFromDrmHeader;

        CompleteSelf();

        }

    else

        {

        err = iRequests.Append( request );

        if ( err )

            {

            delete request;

            User::RequestComplete( status, err );

            }

        }

    }

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

// CWmDrmDlaHandlerImpl::CancelLicenseAcquisition

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

//

void CWmDrmDlaHandlerImpl::CancelLicenseAcquisition()

    {

    LOGFN( "CWmDrmDlaHandlerImpl::CancelLicenseAcquisition" );

    //First check, if we are currently handling license acquisition request.

    //If we are, then cancel handling and cancel request 

    if ( iState == CWmDrmDlaHandlerImpl::ECompleted && 

         iCurrentRequest->iType 

             != CWmDrmDlaRequest::EProcessMeteringCertificate )

        {

        iLicenseAcquisitionFw->CancelLicenseAcquisition();

        Cancel();

        CompleteClientRequest( KErrCancel );

        CompleteSyncRequest( KErrCancel );

        }

    else if ( iState == CWmDrmDlaHandlerImpl::EAcquiringLicense || 

              iState == CWmDrmDlaHandlerImpl::EAcquiringLicenseFromDrmHeader )

        {

        Cancel();

        CompleteClientRequest( KErrCancel );

        CompleteSyncRequest( KErrCancel );

        }

    // Next go through the request queue,

    // remove all license acquisition requests and cancel them.

    TInt removed( 0 );

    for ( TInt i( 0 ); i - removed < iRequests.Count(); ++i )

        {

        if ( iRequests[ i - removed ]->iType 

                != CWmDrmDlaRequest::EProcessMeteringCertificate )

            {

            iCurrentRequest = iRequests[ i - removed ];

            iRequests.Remove( i - removed );

            ++removed;

            CompleteClientRequest( KErrCancel );

            }

        }

    if ( !iCurrentRequest )

        {

        NextRequest();

        }

    }

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

// CWmDrmDlaHandlerImpl::ProcessMeteringCertificateL

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

//

void CWmDrmDlaHandlerImpl::ProcessMeteringCertificateL( 

    const TDesC8& aCertificate )

    {

    LOGFN( "CWmDrmDlaHandlerImpl::ProcessMeteringCertificateL" );

    if ( iWait->IsStarted() )

        {

        User::Leave( KErrInUse );

        }

    CWmDrmDlaRequest* request( CWmDrmDlaRequest::NewL( aCertificate, 

                                                       ETrue, 

                                                       iStatus ) );

    if ( iState == CWmDrmDlaHandlerImpl::EIdle  )

        {

        iCurrentRequest = request;

        iState = CWmDrmDlaHandlerImpl::EProcessingMeteringCertificate;

        CompleteSelf();

        }

    else

        {

        iSyncRequest = request;

        }

    iWait->Start();

    LOG2( "iSyncReturnValue: %d", iSyncReturnValue );

    User::LeaveIfError( iSyncReturnValue );

    }

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

// CWmDrmDlaHandlerImpl::ProcessMeteringCertificate

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

//

void CWmDrmDlaHandlerImpl::ProcessMeteringCertificate( 

    const TDesC8& aCertificate,

    TRequestStatus& aStatus )

    {

    TInt err( KErrNone );

    LOGFNR( "CWmDrmDlaHandlerImpl::ProcessMeteringCertificate", err );

    CWmDrmDlaRequest* request( NULL );

    TRequestStatus *status = &aStatus;

    aStatus = KRequestPending;

    TRAP( err, request = CWmDrmDlaRequest::NewL( aCertificate, 

                                                 EFalse, 

                                                 aStatus ) );

    if ( err )

        {

        User::RequestComplete( status, err );

        }

    else if ( iState == CWmDrmDlaHandlerImpl::EIdle  )

        {

        iCurrentRequest = request;

        iState = CWmDrmDlaHandlerImpl::EProcessingMeteringCertificate;

        CompleteSelf();

        }

    else

        {

        err = iRequests.Append( request );

        if ( err )

            {

            delete request;

            User::RequestComplete( status, err );

            }

        }

    }

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

// CWmDrmDlaHandlerImpl::CancelMetering

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

//

void CWmDrmDlaHandlerImpl::CancelMetering()

    {

    LOGFN( "CWmDrmDlaHandlerImpl::CancelMetering" );

    //First check, if we are currently handling process metering request.

    //If we are, then cancel handling and cancel request 

    if ( iState == CWmDrmDlaHandlerImpl::ECompleted &&

         iCurrentRequest->iType 

             == CWmDrmDlaRequest::EProcessMeteringCertificate )

        {

        iMeteringFw->CancelMetering();

        Cancel();

        CompleteClientRequest( KErrCancel );

        CompleteSyncRequest( KErrCancel );

        }

    else if ( iState == CWmDrmDlaHandlerImpl::EProcessingMeteringCertificate )

        {

        Cancel();

        CompleteClientRequest( KErrCancel );

        CompleteSyncRequest( KErrCancel );

        }

    // Next go through the request queue,

    // remove all process metering requests and cancel them.

    TInt removed( 0 );

    for ( TInt i( 0 ); i - removed < iRequests.Count(); ++i )

        {

        if ( iRequests[ i - removed ]->iType 

                == CWmDrmDlaRequest::EProcessMeteringCertificate )

            {

            iCurrentRequest = iRequests[ i - removed ];

            iRequests.Remove( i - removed );

            ++removed;

            CompleteClientRequest( KErrCancel );

            }

        }

    if ( !iCurrentRequest )

        {

        NextRequest();

        }

    }

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

// CWmDrmDlaHandlerImpl::SetIapId

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

//

void CWmDrmDlaHandlerImpl::SetIapId( TInt aIapId )

    {

    LOGFN( "CWmDrmDlaHandlerImpl::SetIapId" );

    LOG2( "aIapId: %d", aIapId );

    iLicenseAcquisitionFw->SetIapId( aIapId );

    iMeteringFw->SetIapId( aIapId );

    }

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

// CWmDrmDlaHandlerImpl::DoCancel

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

//

void CWmDrmDlaHandlerImpl::DoCancel()

    {

    LOGFN( "CWmDrmDlaHandlerImpl::DoCancel" );

    //Don't need to do anything, canceling is implemented in

    //CancelLicenseAcquisiton() and in CancelMetering() -functions

    }

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

// CWmDrmDlaHandlerImpl::RunL

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

//

void CWmDrmDlaHandlerImpl::RunL()

    {

    LOGFN( "CWmDrmDlaHandlerImpl::RunL" );

    LOG2( "iState: %d", iState );

    LOG2( "iStatus.Int(): %d", iStatus.Int() );

    //If some error happened, then set state to completed, in which

    //the failed client request will be completed with the error code

    if ( iStatus.Int() )

        {

        iState = ECompleted;

        }

    switch ( iState )

	    {

	    case CWmDrmDlaHandlerImpl::ECompleted:

	        Completed( iStatus.Int() );

	        break;

    	case CWmDrmDlaHandlerImpl::EAcquiringLicenseFromDrmHeader:

    	    AcquiringLicenseFromDrmHeader();

    	    break;

    	case CWmDrmDlaHandlerImpl::EAcquiringLicense:

    	    AcquiringLicense();

    	    break;

    	case CWmDrmDlaHandlerImpl::EProcessingMeteringCertificate:

    	    ProcessingMeteringCertificate();

    	    break;

    	default:

            ASSERT( EFalse );

    	    break;

    	}

    }

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

// CWmDrmDlaHandlerImpl::RunError

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

//

TInt CWmDrmDlaHandlerImpl::RunError( TInt aError )

    {

    LOGFN( "CWmDrmDlaHandlerImpl::RunError" );

    //Shouldn't ever happen, but better to be sure

    Completed( aError );

    return KErrNone;

    }

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

// CWmDrmDlaHandlerImpl::CompleteSelf

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

//

void CWmDrmDlaHandlerImpl::CompleteSelf()

    {

    LOGFN( "CWmDrmDlaHandlerImpl::CompleteSelf" );

    if ( !IsActive() )

        {

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        SetActive();

        }

    }

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

// CWmDrmDlaHandlerImpl::CompleteClientRequest