/*

* Copyright (c) 2008 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:  HTTP plugin framework implementation

*

*/

#include <wmdrmdlatypes.h>

#include <wmdrmdlahttpplugin.h>

#include <wmdrmdlauinotifier.h>

#include "wmdrmdlahttpmeteringpluginfw.h"

#include "wmdrmdlahttpfwpluginresolver.h"

#include "wmdrmdlaui.h"

#define _LOGGING_FILE L"wmdrmdla.txt"

#include "logfn.h"

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

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

// CWmDrmDlaHttpMeteringPluginFw::ConstructL

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

//

void CWmDrmDlaHttpMeteringPluginFw::ConstructL()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::ConstructL" );

    iIdle =  CIdle::NewL( CActive::EPriorityIdle );

    }

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

// CWmDrmDlaHttpMeteringPluginFw::CWmDrmDlaHttpMeteringPluginFw

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

//

CWmDrmDlaHttpMeteringPluginFw::CWmDrmDlaHttpMeteringPluginFw() 

    : CActive( EPriorityStandard ), 

      iState( CWmDrmDlaHttpMeteringPluginFw::EIdle )

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::CWmDrmDlaHttpMeteringPluginFw" );

    CActiveScheduler::Add( this );

    }

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

// CWmDrmDlaHttpMeteringPluginFw::NewL

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

//

CWmDrmDlaHttpMeteringPluginFw* CWmDrmDlaHttpMeteringPluginFw::NewL()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::NewL" );

    CWmDrmDlaHttpMeteringPluginFw* self = 

        CWmDrmDlaHttpMeteringPluginFw::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWmDrmDlaHttpMeteringPluginFw::NewLC

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

//

CWmDrmDlaHttpMeteringPluginFw* CWmDrmDlaHttpMeteringPluginFw::NewLC()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::NewLC" );

    CWmDrmDlaHttpMeteringPluginFw* self = 

        new( ELeave ) CWmDrmDlaHttpMeteringPluginFw;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CWmDrmDlaHttpMeteringPluginFw::~CWmDrmDlaHttpMeteringPluginFw

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

//

CWmDrmDlaHttpMeteringPluginFw::~CWmDrmDlaHttpMeteringPluginFw()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::~CWmDrmDlaHttpMeteringPluginFw" );

    CancelMetering();

    delete iHttpPlugin;

    delete iUiNotifier;

    delete iIdle;

    delete iMeteringChallenge;

    delete iMeteringUrl;

    delete iMeteringResponse;

    }

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

// CWmDrmDlaHttpMeteringPluginFw::ProcessMeteringCertificate

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

//

void CWmDrmDlaHttpMeteringPluginFw::ProcessMeteringCertificate( 

    const TDesC8& aCertificate, 

    TRequestStatus& aStatus )

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::ProcessMeteringCertificate" );

    TRequestStatus *status = &aStatus;

    aStatus = KRequestPending;

    if ( iState != CWmDrmDlaHttpMeteringPluginFw::EIdle )

        {

        User::RequestComplete( status, KErrInUse );

        return;

        }

    iClientStatus = &aStatus;

    iCertificate = &aCertificate;

    iState = CWmDrmDlaHttpMeteringPluginFw::EResolvingHttpPlugin;

    CompleteSelf();

    }

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

// CWmDrmDlaHttpMeteringPluginFw::CancelMetering

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

//

void CWmDrmDlaHttpMeteringPluginFw::CancelMetering()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::CancelMetering" );

    if ( iHttpPlugin )

        {

        iHttpPlugin->CancelMetering();

        }

    Cancel();

    if ( iUiNotifier )

        {

        TRAP_IGNORE( iUiNotifier->HandleErrorL( KErrCancel ) );

        }

    CompleteClientRequest( KErrCancel );

    Reset();

    }

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

// CWmDrmDlaHttpMeteringPluginFw::SetIapId

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

//

void CWmDrmDlaHttpMeteringPluginFw::SetIapId( TInt aIapId )

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::SetIapId" );

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

    iIapId = aIapId;

    if ( iHttpPlugin )

        {

        iHttpPlugin->SetIapId( iIapId );

        }

    }

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

// CWmDrmDlaHttpMeteringPluginFw::DoCancel

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

//

void CWmDrmDlaHttpMeteringPluginFw::DoCancel()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::DoCancel" );

    }

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

// CWmDrmDlaHttpMeteringPluginFw::RunL

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

//

void CWmDrmDlaHttpMeteringPluginFw::RunL()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::RunL" );

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

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

    if ( iStatus.Int() != KErrNone )

        {

        HandleErrorL( iStatus.Int() );

        }

    switch ( iState )

	    {

        case CWmDrmDlaHttpMeteringPluginFw::EResolvingHttpPlugin:

            ResolvingHttpPluginHandlerL();

            break;

        case CWmDrmDlaHttpMeteringPluginFw::ERetrievingMeteringChallenge:

    	    RetrievingMeteringChallenge();

    	    break;

    	case CWmDrmDlaHttpMeteringPluginFw::EProcessingMeteringChallenge:

    	    ProcessingMeteringChallenge();

    	    break;

    	case CWmDrmDlaHttpMeteringPluginFw::ERetrievingMeteringResponse:

    	    RetrievingMeteringResponse();

    	    break;

    	case CWmDrmDlaHttpMeteringPluginFw::EProcessingMeteringResponse:

    	    ProcessingMeteringResponse();

    	    break;

    	case CWmDrmDlaHttpMeteringPluginFw::EMeteringFinished:

    	    MeteringFinished();

    	    break;

    	default:

            ASSERT( EFalse );

    	    break;

    	}

    }    

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

// CWmDrmDlaHttpMeteringPluginFw::RunError

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

//

TInt CWmDrmDlaHttpMeteringPluginFw::RunError( TInt aError )

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::RunError" );

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

    CompleteClientRequest( aError );

    Reset();

    return KErrNone;

    }

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

// CWmDrmDlaHttpMeteringPluginFw::UserCancellation

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

//

void CWmDrmDlaHttpMeteringPluginFw::UserCancellation()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::UserCancellation");

    TCallBack callBack( CWmDrmDlaHttpMeteringPluginFw::AsyncCancel, 

                        this );

    iIdle->Start( callBack );

    }

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

// CWmDrmDlaHttpMeteringPluginFw::CompleteSelf

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

//

void CWmDrmDlaHttpMeteringPluginFw::CompleteSelf()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::CompleteSelf" );

    if ( !IsActive() )

        {

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        SetActive();

        }

    }

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

// CWmDrmDlaHandlerImpl::CompleteClientRequest

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

//

void CWmDrmDlaHttpMeteringPluginFw::CompleteClientRequest( TInt aError )

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::CompleteClientRequest" );

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

    if ( iClientStatus )

        {

        User::RequestComplete( iClientStatus, aError );

        iClientStatus = NULL;

        }

    }

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

// CWmDrmDlaHttpMeteringPluginFw::::Reset

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

//

void CWmDrmDlaHttpMeteringPluginFw::Reset()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::Reset" );

    delete iHttpPlugin;

    iHttpPlugin = NULL;

    delete iUiNotifier;

    iUiNotifier = NULL;

    delete iMeteringChallenge;

    iMeteringChallenge = NULL;

    delete iMeteringUrl;

    iMeteringUrl = NULL;

    delete iMeteringResponse;

    iMeteringResponse = NULL;

    iCertificate = NULL;

    iState = CWmDrmDlaHttpMeteringPluginFw::EIdle;

    }

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

// CWmDrmDlaHttpMeteringPluginFw::ResolvingHttpPluginHandlerL

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

//

void CWmDrmDlaHttpMeteringPluginFw::ResolvingHttpPluginHandlerL()

    {

    TInt err( KErrNone );

    LOGFNR( "CWmDrmDlaHttpMeteringPluginFw::ResolvingHttpPluginHandlerL", err );

    TRAP( err, ResolveHttpPluginWithCertificateL( *iCertificate ) );

    if ( err )

        {

        HandleErrorL( err );

        }

    iState = CWmDrmDlaHttpMeteringPluginFw::ERetrievingMeteringChallenge;

    CompleteSelf();

    }

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

// CWmDrmDlaHttpMeteringPluginFw::RetrievingMeteringChallengeL

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

//

void CWmDrmDlaHttpMeteringPluginFw::RetrievingMeteringChallenge()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::RetrievingMeteringChallenge" );

    delete iMeteringChallenge;

    iMeteringChallenge = NULL;

    delete iMeteringUrl;

    iMeteringUrl = NULL;

    SetActive();

    iState = CWmDrmDlaHttpMeteringPluginFw::EProcessingMeteringChallenge;

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNotSupported );

    }

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

// CWmDrmDlaHttpMeteringPluginFw::ProcessingMeteringChallengeL

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

//

void CWmDrmDlaHttpMeteringPluginFw::ProcessingMeteringChallenge()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::ProcessingMeteringChallenge" );

    iHttpPlugin->ProcessMeteringChallenge( *iMeteringChallenge, 

                                           *iMeteringUrl, 

                                           iStatus );

    SetActive();

    iState = CWmDrmDlaHttpMeteringPluginFw::ERetrievingMeteringResponse;

    }

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

// CWmDrmDlaHttpMeteringPluginFw::RetrievingMeteringResponseL

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

//

void CWmDrmDlaHttpMeteringPluginFw::RetrievingMeteringResponse()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::RetrievingMeteringResponse" );

    delete iMeteringResponse;

    iMeteringResponse = NULL;

    iHttpPlugin->GetMeteringResponse( iMeteringResponse, iStatus );

    SetActive();

    iState = CWmDrmDlaHttpMeteringPluginFw::EProcessingMeteringResponse;

    }

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

// CWmDrmDlaHttpMeteringPluginFw::ProcessingMeteringResponseL

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

//

void CWmDrmDlaHttpMeteringPluginFw::ProcessingMeteringResponse()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::ProcessingMeteringResponse" );

    SetActive();

    iState = CWmDrmDlaHttpMeteringPluginFw::EMeteringFinished;

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNotSupported );

    }

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

// CWmDrmDlaHttpMeteringPluginFw::MeteringFinishedL

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

//

void CWmDrmDlaHttpMeteringPluginFw::MeteringFinished()

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::MeteringFinished" );

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

    if ( iPartialMetering )

        {

        iState = CWmDrmDlaHttpMeteringPluginFw::ERetrievingMeteringChallenge;

        CompleteSelf();

        }

    else

        {

        iHttpPlugin->MeteringFinished();

        CompleteClientRequest( KErrNone );

        Reset();

        }

    }

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

// CWmDrmDlaHttpMeteringPluginFw::::ResolveHttpPluginWithCertificateL

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

//

void CWmDrmDlaHttpMeteringPluginFw::ResolveHttpPluginWithCertificateL( 

    const TDesC8& aCertificate )

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::ResolveHttpPluginL" );

    delete iHttpPlugin;

    iHttpPlugin = NULL;

    delete iUiNotifier;

    iUiNotifier = NULL;

    WmDrmDlaHttpFwPluginResolver::ResolveHttpPluginWithCertificateL( 

            aCertificate, iHttpPlugin, iUiNotifier );

    //Set cancel observer for ui plugin

    if ( iUiNotifier )

        {

        iUiNotifier->SetCancelObserver( this );

        }

    //Set iap for http plugin

    if ( iIapId )

        {

        iHttpPlugin->SetIapId( iIapId );

        }

    }

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

// CWmDrmDlaHttpMeteringPluginFw::HandleErrorL

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

//

void CWmDrmDlaHttpMeteringPluginFw::HandleErrorL( TInt aError )

    {

    TInt err( KErrNone );

    LOGFNR( "CWmDrmDlaHttpMeteringPluginFw::HandleErrorL", err );

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

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

    if ( iUiNotifier )

        {

        TRAP( err, iUiNotifier->HandleErrorL( aError ) );

        }

    switch ( iState )

        {

        case CWmDrmDlaHttpMeteringPluginFw::ERetrievingMeteringChallenge:

            break;

        case CWmDrmDlaHttpMeteringPluginFw::EProcessingMeteringChallenge:

            break;

        case CWmDrmDlaHttpMeteringPluginFw::ERetrievingMeteringResponse:

            break;

        case CWmDrmDlaHttpMeteringPluginFw::EProcessingMeteringResponse:

            break;

        case CWmDrmDlaHttpMeteringPluginFw::EMeteringFinished:

            break;

        default:

            break;

        }

    User::Leave( aError );

    }

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

// CWmDrmDlaHttpMeteringPluginFw::AsyncCancel

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

//

TInt CWmDrmDlaHttpMeteringPluginFw::AsyncCancel( TAny* aPtr )

    {

    LOGFN( "CWmDrmDlaHttpMeteringPluginFw::AsyncCancel");

    CWmDrmDlaHttpMeteringPluginFw* meteringFw = 

        static_cast<CWmDrmDlaHttpMeteringPluginFw*>( aPtr );

    meteringFw->CancelMetering();

    return EFalse;

    }