/*

* Copyright (c) 2010 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:  Displays untrusted certificate dialog.

*

*/

#include "CTUntrustedCertQuery.h"           // CCTUntrustedCertQuery

#include <hb/hbcore/hbsymbianvariant.h>     // CHbSymbianVariantMap

// Note that the dialog type string, the parameters name strings, and the return code

// name string and values must match to those defined in Qt-side untrusted certificate

// dialog (in untrustedcertificatedefinitions.h file).

// Device dialog type for untrusted certificate dialog

_LIT( KUntrustedCertificateDialog, "com.nokia.untrustedcert/1.0" );

// Variant map parameter names for untrusted certificate dialog

_LIT( KUntrustedCertEncodedCertificate, "cert" );   // bytearray, mandatory

_LIT( KUntrustedCertServerName, "host" );           // string, mandatory

_LIT( KUntrustedCertValidationError, "err" );       // int (TValidationError), mandatory

_LIT( KUntrustedCertTrustedSiteStoreFail, "tss" );  // any, prevents permanent acceptance

// Dialog return code name and values

_LIT( KUntrustedCertDialogResult, "result" );       // int

const TInt KUntrustedCertDialogRejected = 0;

const TInt KUntrustedCertDialogAccepted = 1;

const TInt KUntrustedCertDialogAcceptedPermanently = 2;

// TODO: replace with OST tracing

#ifdef _DEBUG

#include <e32debug.h>

#define TRACE(x)        RDebug::Printf(x)

#define TRACE1(x,y)     RDebug::Printf(x,y)

#else

#define TRACE(x)

#define TRACE1(x,y)

#endif

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

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

// CCTUntrustedCertQuery::NewLC()

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

//

CCTUntrustedCertQuery* CCTUntrustedCertQuery::NewLC(

        TValidationError aValidationError, const TDesC8& aCertificate,

        const TDesC& aServerName, TBool aCanHandlePermanentAccept )

    {

    TRACE( "CCTUntrustedCertQuery::NewLC" );

    CCTUntrustedCertQuery* self = new ( ELeave ) CCTUntrustedCertQuery(

            aValidationError, aCertificate, aServerName,

            aCanHandlePermanentAccept );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCTUntrustedCertQuery::~CCTUntrustedCertQuery()

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

//

CCTUntrustedCertQuery::~CCTUntrustedCertQuery()

    {

    TRACE( "CCTUntrustedCertQuery::~CCTUntrustedCertQuery" );

    Cancel();

    delete iWait;

    delete iDeviceDialog;

    delete iVariantMap;

    }

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

// CCTUntrustedCertQuery::ShowQueryAndWaitForResponseL()

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

//

void CCTUntrustedCertQuery::ShowQueryAndWaitForResponseL( TResponse& aResponse )

    {

    TRACE( "CCTUntrustedCertQuery::ShowQueryAndWaitForResponseL" );

    if( !iDeviceDialog )

        {

        iDeviceDialog = CHbDeviceDialogSymbian::NewL();

        }

    if( !iVariantMap )

        {

        iVariantMap = CHbSymbianVariantMap::NewL();

        }

    CHbSymbianVariant *variant = NULL;

    variant = CHbSymbianVariant::NewL( &iCertificate, CHbSymbianVariant::EBinary );

    User::LeaveIfError( iVariantMap->Add( KUntrustedCertEncodedCertificate, variant ) );

    variant = CHbSymbianVariant::NewL( &iValidationError, CHbSymbianVariant::EInt );

    User::LeaveIfError( iVariantMap->Add( KUntrustedCertValidationError, variant ) );

    variant = CHbSymbianVariant::NewL( &iServerName, CHbSymbianVariant::EDes );

    User::LeaveIfError( iVariantMap->Add( KUntrustedCertServerName, variant ) );

    if( !iCanHandlePermanentAccept )

        {

        variant = CHbSymbianVariant::NewL( &iCanHandlePermanentAccept, CHbSymbianVariant::EBool );

        User::LeaveIfError( iVariantMap->Add( KUntrustedCertTrustedSiteStoreFail, variant ) );

        }

    User::LeaveIfError( iDeviceDialog->Show( KUntrustedCertificateDialog, *iVariantMap, this ) );

    iStatus = KRequestPending;

    SetActive();

    TRACE( "CCTUntrustedCertQuery::ShowQueryAndWaitForResponseL, wait start" );

    iWait->Start();

    TRACE( "CCTUntrustedCertQuery::ShowQueryAndWaitForResponseL, wait end" );

    TRACE1( "CCTUntrustedCertQuery::ShowQueryAndWaitForResponseL, iWaitCompletionCode=%d", iWaitCompletionCode );

    User::LeaveIfError( iWaitCompletionCode );

    TRACE1( "CCTUntrustedCertQuery::ShowQueryAndWaitForResponseL, iResponse=%d", iResponse );

    aResponse = iResponse;

    }

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

// CCTUntrustedCertQuery::DoCancel()

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

//

void CCTUntrustedCertQuery::DoCancel()

    {

    TRACE( "CCTUntrustedCertQuery::DoCancel begin" );

    if( iDeviceDialog )

        {

        TRACE( "CCTUntrustedCertQuery::DoCancel, iDeviceDialog->Cancel()" );

        iDeviceDialog->Cancel();

        }

    if( iWait && iWait->IsStarted() && iWait->CanStopNow() )

        {

        TRACE( "CCTUntrustedCertQuery::DoCancel, iWait->AsyncStop()" );

        iWaitCompletionCode = KErrCancel;

        iWait->AsyncStop();

        }

    TRACE( "CCTUntrustedCertQuery::DoCancel end" );

    }

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

// CCTUntrustedCertQuery::RunL()

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

//

void CCTUntrustedCertQuery::RunL()

    {

    TRACE1( "CCTUntrustedCertQuery::RunL, iStatus.Int()=%d", iStatus.Int() );

    iWaitCompletionCode = iStatus.Int();

    if( iWait )

        {

        iWait->AsyncStop();

        }

    }

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

// CCTUntrustedCertQuery::DataReceived()

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

//

void CCTUntrustedCertQuery::DataReceived( CHbSymbianVariantMap& aData )

    {

    TRACE( "CCTUntrustedCertQuery::DataReceived" );

    const CHbSymbianVariant* variant = aData.Get( KUntrustedCertDialogResult );

    if( variant )

        {

        TInt* value = variant->Value<TInt>();

        if( value )

            {

            switch( *value )

                {

                case KUntrustedCertDialogRejected:

                    TRACE( "CCTUntrustedCertQuery::DataReceived, rejected" );

                    iResponse = EQueryRejected;

                    break;

                case KUntrustedCertDialogAccepted:

                    TRACE( "CCTUntrustedCertQuery::DataReceived, accepted" );

                    iResponse = EQueryAccepted;

                    break;

                case KUntrustedCertDialogAcceptedPermanently:

                    TRACE( "CCTUntrustedCertQuery::DataReceived, accepted permanently" );

                    iResponse = EQueryAcceptedPermanently;

                    break;

                default:

                    __ASSERT_DEBUG( EFalse, User::Invariant() );

                    break;

                }

            }

        else

            {

            __ASSERT_DEBUG( EFalse, User::Invariant() );

            }

        }

    else

        {

        __ASSERT_DEBUG( EFalse, User::Invariant() );

        }

    }

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

// CCTUntrustedCertQuery::DeviceDialogClosed()

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

//

void CCTUntrustedCertQuery::DeviceDialogClosed( TInt aCompletionCode )

    {

    TRACE1( "CCTUntrustedCertQuery::DeviceDialogClosed aCompletionCode=%d", aCompletionCode );

    TRequestStatus* status( &iStatus );

    User::RequestComplete( status, aCompletionCode );

    }

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

// CCTUntrustedCertQuery::CCTUntrustedCertQuery()

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

//

CCTUntrustedCertQuery::CCTUntrustedCertQuery(

        TValidationError aValidationError, const TDesC8& aCertificate,

        const TDesC& aServerName, TBool aCanHandlePermanentAccept ) :

        CActive( CActive::EPriorityStandard ), iValidationError( aValidationError ),

        iCertificate( aCertificate ), iServerName( aServerName ),

        iCanHandlePermanentAccept( aCanHandlePermanentAccept ),

        iResponse( EQueryRejected )

    {

    CActiveScheduler::Add( this );

    }

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

// CCTUntrustedCertQuery::ConstructL()

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

//

void CCTUntrustedCertQuery::ConstructL()

    {

    TRACE( "CCTUntrustedCertQuery::ConstructL" );

    iWait = new( ELeave ) CActiveSchedulerWait;

    }