/*

* 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:  Synchronous wrapper for ROAP protocol suite

*

*/

#include <RoapEng.h>

#include "RoapSyncWrapper.h"

#include <RoapDef.h>

using namespace Roap;

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

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

// UpdateUrlL

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

//

LOCAL_C void UpdateUrlL( HBufC8*& aTargetUrl, const TDesC8& aSourceUrl )

    {

    if ( aTargetUrl )

        {

        delete aTargetUrl;

        aTargetUrl = NULL;

        }

    if ( aSourceUrl.Length() )

        {

        aTargetUrl = aSourceUrl.AllocL();

        }

    }

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

// DoResetAndDestroy

// Does RPointerArray< >->ResetAndDestroy() for the given array aPtr.

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

//

LOCAL_C void DoResetAndDestroy( TAny* aPtr )

    {

    ( reinterpret_cast< RPointerArray< HBufC8 >* >( aPtr ) )->

        ResetAndDestroy();

    }

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

CRoapSyncWrapper::CRoapSyncWrapper() : CActive( EPriorityStandard )

    {

    CActiveScheduler::Add( this );

    }

void CRoapSyncWrapper::ConstructL()

    {

    }

EXPORT_C CRoapSyncWrapper* CRoapSyncWrapper::NewL()

    {

    CRoapSyncWrapper* self = new ( ELeave ) CRoapSyncWrapper;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

EXPORT_C CRoapSyncWrapper::~CRoapSyncWrapper()

    {

    Cancel();

    delete iErrorUrl;

    delete iPostResponseUrl;

    }

EXPORT_C void CRoapSyncWrapper::HandleTriggerL( const TDesC8& aTrigger )

    {

    TTriggerType triggerType;

    TRiContextStatus contextStatus;

    TDomainOperation domainOperation;

    RPointerArray<HBufC8> contentIds;

    CRoapEng* roapEng = CRoapEng::NewL();

    CleanupStack::PushL( roapEng );

    roapEng->SetTriggerL( aTrigger, NULL, triggerType, contextStatus,

        domainOperation, contentIds );

    contentIds.ResetAndDestroy();

    roapEng->AcceptL( this, &iStatus );

    SetActive();

    iWait.Start();

    CleanupStack::PopAndDestroy( roapEng );

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

    }

EXPORT_C TBool CRoapSyncWrapper::HandleTriggerSilentlyL( const TDesC8& aTrigger )

    {

    TTriggerType triggerType;

    TRiContextStatus contextStatus;

    TDomainOperation domainOperation;

    RPointerArray<HBufC8> contentIds;

    CRoapEng* roapEng = CRoapEng::NewL();

    TBool r = EFalse;

    TCleanupItem item( DoResetAndDestroy, &contentIds );

    CleanupStack::PushL( item );

    CleanupStack::PushL( roapEng );

    roapEng->SetTriggerL( aTrigger, NULL, triggerType, contextStatus,

        domainOperation, contentIds );

    // if we have a valid RI context, or if there is no user confirmation needed, do the ROAP

    if ( contextStatus != EInvalidContext )

        {

        roapEng->AcceptL( this, &iStatus );

        SetActive();

        iWait.Start();

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

        r = ETrue;

        }

    CleanupStack::PopAndDestroy( roapEng );

    CleanupStack::PopAndDestroy( &contentIds );

    return r;

    }

EXPORT_C HBufC8* CRoapSyncWrapper::GetErrorUrlL( const TInt aError, TInt& aErrorType )

    {

    // ROAP ERROR CODES

    switch ( aError )

        {

        case KErrRoapUnsupported:

        case KErrRoapServerFatal:

        case KErrRoapDevice:

        case KErrRoapInvalidDomain:

            {

            aErrorType = KErrRoapPermanent;

            break;

            }

        case KErrRoapGeneral:

        case KErrRoapServer:

        case KErrRoapDomainFull:

        case KErrRoapNotRegistered:

            {

            aErrorType = KErrRoapTemporary;

            break;

            }

        }

    if( iErrorUrl )

        {

        return iErrorUrl->AllocL();

        }

    return NULL;

    }

void CRoapSyncWrapper::ErrorUrlL( const TDesC8& aErrorUrl )

    {

    UpdateUrlL( iErrorUrl, aErrorUrl );

    }

void CRoapSyncWrapper::DoCancel()

    {

    if (iWait.IsStarted())

        {

        iWait.AsyncStop();

        }

    }

void CRoapSyncWrapper::RunL()

    {

    iWait.AsyncStop();

    }

TBool CRoapSyncWrapper::ConnectionConfL()

    {

    return ETrue;

    }

TBool CRoapSyncWrapper::ContactRiConfL()

    {

    return ETrue;

    }

TBool CRoapSyncWrapper::TransIdConfL()

    {

    return EFalse;

    }

void CRoapSyncWrapper::RightsObjectDetailsL(

    const RPointerArray<CDRMRights>& /*aRightsList*/ )

    {

    // do nothing

    }

void CRoapSyncWrapper::ContentDownloadInfoL( TPath& /*aTempFolder*/,

    TFileName& /*aContentName*/,

    TInt& aMaxSize )

    {

    aMaxSize = -1;

    }

void CRoapSyncWrapper::ContentDetailsL( const TDesC& /*aPath*/,

    const TDesC8& /*aType*/,

    const TUid& /*aAppUid*/ )

    {

    }

void CRoapSyncWrapper::RoapProgressInfoL( const TInt /*aProgressInfo*/ )

    {

    // do nothing

    }

void CRoapSyncWrapper::PostResponseUrlL( const TDesC8& aPostResponseUrl )

    {

    UpdateUrlL( iPostResponseUrl, aPostResponseUrl );

    }

EXPORT_C HBufC8* CRoapSyncWrapper::GetPostResponseUrlL()

    {

    if ( iPostResponseUrl )

        {

        return iPostResponseUrl->AllocL();

        }

    return NULL;

    }

//  End of File