/*

* Copyright (c) 2002-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:  core ROAP engine

*

*/

// INCLUDE FILES

// #include <GenericParam.h> // from S60

#include "RoapEngBase.h"

#include "RoapHttpHandler.h"

#include "RoapTrigger.h"

#include "RoapDef.h"

#include "RoapMessage.h"

#include "RoapLog.h"

#include "RoapObserver.h"

#include "RoapStorageClient.h"

using namespace Roap;

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

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

// CRoapEngBase::~CRoapEngBase()

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

//

EXPORT_C CRoapEngBase::~CRoapEngBase()

    {

    Cancel();

    delete iTrigger;

    delete iRequest;

    delete iResponse;

    delete iRoapResp;

    delete iHttpHandler;

    delete iStoredRiContext;

    iReturnedROs.ResetAndDestroy();

    delete iDomainRightsResp;

    delete iRiAlias;

    }

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

// CRoapEngBase::CRoapEngBase()

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

//

CRoapEngBase::CRoapEngBase( ): CActive( CActive::EPriorityStandard ),

    iPreferredIap(0)

    {

    CActiveScheduler::Add( this );

    }

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

// CRoapEngBase::ConstructL()

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

//

void CRoapEngBase::ConstructL()

    {

    LOGLIT( "CRoapEngBase::ConstructL" )

    iCompleted = EFalse;

    iState = EInit;

    iTransTrackConf = EFalse;

    iAllowedToContactRi = EFalse;

    iUseRiContextUrl = EFalse;

    iImplicitJoinDomain = EFalse;

    iReRegistered = EFalse;

    iRiAlias = NULL;

    }

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

// CRoapEngBase::SetTriggerL()

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

//

EXPORT_C void CRoapEngBase::SetTriggerL( const TDesC8& aXmlTrigger,

    const CAiwGenericParamList* /*aParamList*/,

    TTriggerType& aType,

    TRiContextStatus& aContextStatus,

    TDomainOperation& aDomainOperation,

    RPointerArray<HBufC8>& aContentIdList )

    {

    LOGLIT( "CRoapEngBase::SetTriggerL" )

#ifndef __DRM_OMA2

    User::Leave(KErrNotSupported);

#endif

    __ASSERT_ALWAYS( iState == EInit || iState == EReady, \

        User::Invariant() );

    TBool registered = EFalse;

    TBool isValidDomainGeneration = ETrue;

    TInt error = KErrNone;

    HBufC8* temp = NULL;

    aDomainOperation = ENotDomainOperation;

    iProgressInBytes = KRoapProgressDelta;

    delete iTrigger;

    iTrigger = NULL;

    iTrigger = ParseTriggerL( aXmlTrigger );

    if ( !iTrigger || !iTrigger->ValidTrigger() )

        {

        LOGLIT( "Trigger parsing failed!" )

        User::Leave( KErrRoapGeneral );

        }

    aType = iTrigger->iTriggerType;

    if ( iTrigger->iTriggerType == ERegistrationTrigger )

        {

        iReqMessage = EDeviceHello;

        if ( iAllowedToContactRi )

            {

            aContextStatus = EInvalidContextNoConf;

            }

        else

            {

            aContextStatus = EInvalidContext;

            }

        iState = EReady;

        return;

        }

    else if ( iTrigger->iTriggerType == ERoAcquisitionTrigger )

        {

        iReqMessage = EROAcquisition;

        }

    else if ( iTrigger->iTriggerType == EJoinDomainTrigger )

        {

        iReqMessage = EJoinDomain;

        }

    else if ( iTrigger->iTriggerType == ELeaveDomainTrigger )

        {

        iReqMessage = ELeaveDomain;

        }

#ifdef RD_DRM_METERING

    else if ( iTrigger->iTriggerType == EMeteringReportTrigger )

        {

        iReqMessage = EMeteringRequest;

        }

#endif

    else

        {

        LOG2(_L ("Unsupported Trigger type: %d"), iTrigger->iTriggerType)

        User::Leave( KErrRoapUnsupported );

        }

    GetRIContextL( registered, iTrigger->iRiId );

    if ( !registered )

        {

        LOGLIT( "No valid RI Context -> Device Hello" )

        iReqMessage = EDeviceHello;

        aContextStatus = EInvalidContext;

        }

    else

        {

        aContextStatus = EValidContext;

        }

    if ( iTrigger->iTriggerType == EJoinDomainTrigger )

        {

        GetDomainContextL( registered, isValidDomainGeneration, *iTrigger->iDomainId );

        registered ? aDomainOperation = EKeyUpgradeOperation : aDomainOperation = EJoinDomainOperation;

        }

    for ( TInt i = 0; i < iTrigger->iContentIdList.Count(); i++ )

        {

        temp = iTrigger->iContentIdList[i]->Alloc();

        if ( temp )

            {

            error = aContentIdList.Append( temp );

            if ( error )

                {

                aContentIdList.ResetAndDestroy();

                delete temp;

                User::Leave( error );

                }

            }

        else

            {

            aContentIdList.ResetAndDestroy();

            User::Leave( KErrNoMemory );

            }

        }

    if ( iTrigger->iDomainId &&  iTrigger->iTriggerType == ERoAcquisitionTrigger )

        {

        GetDomainContextL( registered, isValidDomainGeneration, *iTrigger->iDomainId );

        if ( !registered || !isValidDomainGeneration )

            {

            // We don't have a valid Domain key for the RO -> JoinDomain

            LOGLIT( "Perform implicit Join Domain" )

            iImplicitJoinDomain = ETrue;

            if ( aContextStatus == EValidContext )

                {

                iReqMessage = EJoinDomain;

                }

            }

        }

    iState = EReady;

    if ( aContextStatus == EInvalidContext && iAllowedToContactRi )

        {

        aContextStatus = EInvalidContextNoConf;

        }

    else if ( aContextStatus == EInvalidContext )

        {

        RRoapStorageClient client;

        User::LeaveIfError( client.Connect() );

        CleanupClosePushL( client );

        // check that SilentRightsUrl is on the white list

        // URL is searched from pre-configured white list

        TBool fromPreConfiguredWhiteList( ETrue );

        if ( client.WhiteListURLExistsL( *iTrigger->iRoapUrl, fromPreConfiguredWhiteList ) )

            {

            aContextStatus = EInvalidContextNoConf;

            }

        CleanupStack::PopAndDestroy( &client );

        }

    if ( iTrigger->iRiAlias )

        {

        iRiAlias = iTrigger->iRiAlias->AllocL();

        }

    }

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

// CRoapEngBase::AcceptL()

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

//

EXPORT_C void CRoapEngBase::AcceptL( MRoapObserver* aObserver, TRequestStatus* aStatus )

    {

    LOGLIT( "CRoapEngBase::Accept" )

    PERFORMANCE_LOGLIT( "ROAP started" )

    if ( iState != EReady )

        {

        User::Leave( KErrNotReady );

        }

    iObserver = aObserver;

    iParentStatus = aStatus;

    *iParentStatus = KRequestPending;

    iResult = KErrNone;

    if ( iObserver )

        {

        iObserver->RoapProgressInfoL( iProgressInBytes );

        }

    iProgressInBytes = Min( iProgressInBytes + KRoapProgressDelta, KRoapProgressMax );

    Continue( ECreateConn );

    }

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

// CRoapEngBase::Reject()

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

//

EXPORT_C void CRoapEngBase::Reject()

    {

    LOGLIT( "CRoapEngBase::Reject" )

    Cancel();

    // Cleanup first, so that

    DoCleanup();

    delete iTrigger;

    iTrigger = NULL;

    delete iRequest;

    iRequest = NULL;

    delete iResponse;

    iResponse = NULL;

    delete iRoapResp;

    iRoapResp = NULL;

    delete iHttpHandler;

    iHttpHandler = NULL;

    delete iStoredRiContext;

    iStoredRiContext = NULL;

    delete iDomainRightsResp;

    iDomainRightsResp = NULL;

    iImplicitJoinDomain = EFalse;

    iState = EInit;

    }

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

// CRoapEngBase::DoCleanup()

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

//

EXPORT_C TInt CRoapEngBase::DoCleanup()

    {

    LOGLIT( "CRoapEngBase::DoCleanup" )

    RDRMRightsClient rightsClient;

    HBufC8* contentUri = NULL;

    TInt error = KErrNone;

    if ( iTrigger && iTrigger->iTriggerType == ERoAcquisitionTrigger )

        {

        if ( iCompleted )

            {

            error = rightsClient.Connect();

            if ( !error)

                {

                for ( TInt i = 0; i < iReturnedROs.Count(); i++ )

                    {

                    error = iReturnedROs[i]->GetContentURI( contentUri );

                    if ( !error )

                        {

                        // rightsClient.DeleteDbEntry( *contentUri, iReturnedROs[i]->GetLocalID() )

                        }

                    }

                rightsClient.Close();

                }

            iReturnedROs.ResetAndDestroy();

            }

        }

    if ( iRoapResp )

        {

        if ( iRoapResp->DcfFileName().Length() )

            {

            RFs fs;

            error = fs.Connect();

            if ( error != KErrNone )

                {

                fs.Delete( iRoapResp->DcfFileName() );

                }

            fs.Close();

            }

        }

    return error;

    }

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

// CRoapEngBase::HandleRoReponseL()

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

//

EXPORT_C void CRoapEngBase::HandleRoReponseL( const TDesC8& aResponse, RPointerArray<CDRMRights>& aParsedRights )

    {

    LOGLIT( "CRoapEngBase::HandleRoReponseL" )

    __ASSERT_ALWAYS( iState == EInit, User::Invariant() );

    aParsedRights.ResetAndDestroy();

    TRAPD( error, HandleRightsResponsePduL( aResponse, ETrue ) );

    if ( error == KErrRoapNotRegistered )

        {

        // Needs to register

        }

    else if ( iReturnedROs.Count() )

        {

        for ( TInt i = 0; i < iReturnedROs.Count(); i++ )

            {

            CDRMRights* temp = CDRMRights::NewL();

            CleanupStack::PushL( temp );

            *temp = *iReturnedROs[i];

            aParsedRights.AppendL( temp );

            CleanupStack::Pop( temp );

            }

        }

    }

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

// CRoapEngBase::GetTrigger()

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

//

EXPORT_C const CRoapTrigger& CRoapEngBase::Trigger() const

    {

    return *iTrigger;

    }

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

// CRoapEngBase::DoCancel()

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

//

void CRoapEngBase::DoCancel()

    {

    LOGLIT( "CRoapEngBase::DoCancel" )

    if (iHttpHandler)

        {

        iHttpHandler->Cancel();

        }

    iResult = KErrCancel;

    CompleteRequest();

    }

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

// CRoapEngBase::RunL()

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

//

void CRoapEngBase::RunL()

    {

    LOGLIT( "CRoapEngBase::RunL" )

    switch ( iState )

        {

        case ECreateConn:

                {

                CreateConnectionL();

                break;

                }

        case EStartTrans:

                {

                StartTransactionL();

                break;

                }

        case ERespReceived:

                {

                HandleResponseL();

                break;

                }

        case EComplete:

                {

                CompleteL();

                break;

                }

        default:

                {

                break;

                }

        }

    }

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

// CRoapEngBase::RunError()

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

//

TInt CRoapEngBase::RunError( TInt aError )

    {

    LOG2( _L ( "CRoapEngBase::RunError: %d" ), aError )

    PERFORMANCE_LOG2( _L ( "Error occured: %d" ), aError  )

    iResult = aError;

    if ( aError == KErrTimedOut || aError == KErrDisconnected )

        {

        // Retry in time out and disconnected cases

        iResult = KErrRoapServer;

        }

    if ( iReqMessage == ERegistration )

        {

        // in case of retry send DeviceHello (not RegRequest)

        iReqMessage = EDeviceHello;

        }

    if ( iRoapResp )

        {

        if ( iRoapResp->DcfFileName().Length() )

            {

            RFs fs;

            if ( fs.Connect() )

                {

                fs.Delete( iRoapResp->DcfFileName() );

                fs.Close();

                }

            }

        }

    iCompleted = ETrue;

    Continue( EComplete );

    return KErrNone;

    }

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

// CRoapEngBase::CreateConnectionL()

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

//

void CRoapEngBase::CreateConnectionL()

    {

    LOGLIT( "CRoapEngBase::CreateConnectionL" )

    __ASSERT_ALWAYS( iState == ECreateConn, User::Invariant() );

    if ( iObserver )

        {

        iObserver->RoapProgressInfoL( iProgressInBytes );

        }

    iProgressInBytes = Min( iProgressInBytes + KRoapProgressDelta, KRoapProgressMax );

    iHttpHandler = CRoapHttpHandler::NewL();

    iHttpHandler->SetObserver( iObserver );

    iHttpHandler->SetPreferredIap( iPreferredIap );

    iHttpHandler->CreateConnectionL( &iStatus );

    iState = EStartTrans;

    SetActive();

    }

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

// CRoapEngBase::StartTransactionL()

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

//

void CRoapEngBase::StartTransactionL()

    {

    LOGLIT( "CRoapEngBase::StartTransactionL" )

    User::LeaveIfError( iStatus.Int() );

    __ASSERT_ALWAYS( iState == EStartTrans, User::Invariant() );

    __ASSERT_ALWAYS( iHttpHandler, User::Invariant() );

    __ASSERT_ALWAYS( iTrigger, User::Invariant() );

    __ASSERT_ALWAYS( !iRequest, User::Invariant() );