/*
* 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 "untrustedcertquery.h"             // CUntrustedCertQuery
#include <hb/hbcore/hbsymbianvariant.h>     // CHbSymbianVariantMap
#include "secuidialogstrace.h"           // TRACE macro

// 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;


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

// ---------------------------------------------------------------------------
// CUntrustedCertQuery::NewL()
// ---------------------------------------------------------------------------
//
CUntrustedCertQuery* CUntrustedCertQuery::NewL(
        TValidationError aValidationError, const TDesC8& aCertificate,
        const TDesC& aServerName, TBool aCanHandlePermanentAccept )
    {
    TRACE( "CUntrustedCertQuery::NewL" );
    CUntrustedCertQuery* self = new ( ELeave ) CUntrustedCertQuery(
            aValidationError, aCertificate, aServerName,
            aCanHandlePermanentAccept );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CUntrustedCertQuery::~CUntrustedCertQuery()
// ---------------------------------------------------------------------------
//
CUntrustedCertQuery::~CUntrustedCertQuery()
    {
    TRACE( "CUntrustedCertQuery::~CUntrustedCertQuery, begin" );
    Cancel();
    delete iWait;
    iWait = NULL;
    delete iDeviceDialog;
    iDeviceDialog = NULL;
    delete iVariantMap;
    iVariantMap = NULL;
    TRACE( "CUntrustedCertQuery::~CUntrustedCertQuery, end" );
    }

// ---------------------------------------------------------------------------
// CUntrustedCertQuery::ShowQueryAndWaitForResponseL()
// ---------------------------------------------------------------------------
//
void CUntrustedCertQuery::ShowQueryAndWaitForResponseL( TResponse& aResponse )
    {
    TRACE( "CUntrustedCertQuery::ShowQueryAndWaitForResponseL, begin" );
    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( "CUntrustedCertQuery::ShowQueryAndWaitForResponseL, iWait start" );
    iWait->Start();
    TRACE( "CUntrustedCertQuery::ShowQueryAndWaitForResponseL, iWaitCompletionCode=%d",
            iWaitCompletionCode );
    User::LeaveIfError( iWaitCompletionCode );
    TRACE( "CUntrustedCertQuery::ShowQueryAndWaitForResponseL, iResponse=%d", iResponse );
    aResponse = iResponse;
    }

// ---------------------------------------------------------------------------
// CUntrustedCertQuery::DoCancel()
// ---------------------------------------------------------------------------
//
void CUntrustedCertQuery::DoCancel()
    {
    TRACE( "CUntrustedCertQuery::DoCancel, begin" );
    if( iDeviceDialog )
        {
        TRACE( "CUntrustedCertQuery::DoCancel, cancelling device dialog" );
        iDeviceDialog->Cancel();
        }

    // Have to complete the request here, because cancelled device dialog does not
    // call DeviceDialogClosed() that normally completes it. The request needs to
    // be completed since CActive::Cancel() waits until the request is completed.
    TRACE( "CUntrustedCertQuery::DoCancel, completing self with KErrCancel" );
    TRequestStatus* status( &iStatus );
    User::RequestComplete( status, KErrCancel );

    // Normally the above request complete would trigger running RunL(). Now RunL()
    // is not run since the active object is already cancelled. Hence, have to stop
    // the waiting here so that iWait->Start() returns.
    iWaitCompletionCode = KErrCancel;
    if( iWait && iWait->IsStarted() )
        {
        TRACE( "CUntrustedCertQuery::DoCancel, stopping iWait" );
        iWait->AsyncStop();
        }
    TRACE( "CUntrustedCertQuery::DoCancel, end" );
    }

// ---------------------------------------------------------------------------
// CUntrustedCertQuery::RunL()
// ---------------------------------------------------------------------------
//
void CUntrustedCertQuery::RunL()
    {
    TRACE( "CUntrustedCertQuery::RunL, iStatus.Int()=%d", iStatus.Int() );
    iWaitCompletionCode = iStatus.Int();
    if( iWait && iWait->IsStarted() )
        {
        TRACE( "CUntrustedCertQuery::RunL, stopping iWait" );
        iWait->AsyncStop();
        }
    }

// ---------------------------------------------------------------------------
// CUntrustedCertQuery::DataReceived()
// ---------------------------------------------------------------------------
//
void CUntrustedCertQuery::DataReceived( CHbSymbianVariantMap& aData )
    {
    TRACE( "CUntrustedCertQuery::DataReceived" );
    const CHbSymbianVariant* variant = aData.Get( KUntrustedCertDialogResult );
    if( variant )
        {
        TInt* value = variant->Value<TInt>();
        if( value )
            {
            switch( *value )
                {
                case KUntrustedCertDialogRejected:
                    TRACE( "CUntrustedCertQuery::DataReceived, rejected" );
                    iResponse = EQueryRejected;
                    break;
                case KUntrustedCertDialogAccepted:
                    TRACE( "CUntrustedCertQuery::DataReceived, accepted" );
                    iResponse = EQueryAccepted;
                    break;
                case KUntrustedCertDialogAcceptedPermanently:
                    TRACE( "CUntrustedCertQuery::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() );
        }
    }

// ---------------------------------------------------------------------------
// CUntrustedCertQuery::DeviceDialogClosed()
// ---------------------------------------------------------------------------
//
void CUntrustedCertQuery::DeviceDialogClosed( TInt aCompletionCode )
    {
    TRACE( "CUntrustedCertQuery::DeviceDialogClosed, aCompletionCode=%d", aCompletionCode );
    if( IsActive() )
        {
        TRACE( "CUntrustedCertQuery::DeviceDialogClosed, request complete" );
        TRequestStatus* status( &iStatus );
        User::RequestComplete( status, aCompletionCode );
        }
    }

// ---------------------------------------------------------------------------
// CUntrustedCertQuery::CUntrustedCertQuery()
// ---------------------------------------------------------------------------
//
CUntrustedCertQuery::CUntrustedCertQuery(
        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 );
    }

// ---------------------------------------------------------------------------
// CUntrustedCertQuery::ConstructL()
// ---------------------------------------------------------------------------
//
void CUntrustedCertQuery::ConstructL()
    {
    TRACE( "CUntrustedCertQuery::ConstructL" );
    iWait = new( ELeave ) CActiveSchedulerWait;
    }