/*

* 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:  Device dialog plugin that shows untrusted certificate

*               dialog for TLS server authentication failure errors.

*

*/

#include "untrustedcertificatedialog.h"

#include "untrustedcertificatedefinitions.h"

#include "untrustedcertificatewidget.h"

#include <hblabel.h>

#include <hbaction.h>

const int KNoError = 0;             // KErrNone

const int KParameterError = -6;     // KErrArgument

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

// UntrustedCertificateDialog::UntrustedCertificateDialog()

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

//

UntrustedCertificateDialog::UntrustedCertificateDialog(const QVariantMap &parameters) : HbDialog(),

    mLastError(KNoError), mShowEventReceived(false), mContent(0)

{

    constructDialog(parameters);

}

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

// UntrustedCertificateDialog::~UntrustedCertificateDialog()

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

//

UntrustedCertificateDialog::~UntrustedCertificateDialog()

{

}

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

// UntrustedCertificateDialog::setDeviceDialogParameters()

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

//

bool UntrustedCertificateDialog::setDeviceDialogParameters(const QVariantMap &parameters)

{

   return updateFromParameters(parameters);

}

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

// UntrustedCertificateDialog::deviceDialogError()

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

//

int UntrustedCertificateDialog::deviceDialogError() const

{

    return mLastError;

}

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

// UntrustedCertificateDialog::closeDeviceDialog()

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

//

void UntrustedCertificateDialog::closeDeviceDialog(bool byClient)

{

    Q_UNUSED(byClient);

    close();

    // If show event has been received, close is signalled from hide event.

    // If not, hide event does not come and close is signalled from here.

    if (!mShowEventReceived) {

        emit deviceDialogClosed();

    }

}

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

// UntrustedCertificateDialog::deviceDialogWidget()

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

//

HbDialog *UntrustedCertificateDialog::deviceDialogWidget() const

{

    return const_cast<UntrustedCertificateDialog*>(this);

}

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

// UntrustedCertificateDialog::hideEvent()

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

//

void UntrustedCertificateDialog::hideEvent(QHideEvent *event)

{

    HbDialog::hideEvent(event);

    emit deviceDialogClosed();

}

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

// UntrustedCertificateDialog::showEvent()

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

//

void UntrustedCertificateDialog::showEvent(QShowEvent *event)

{

    HbDialog::showEvent(event);

    mShowEventReceived = true;

}

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

// UntrustedCertificateDialog::isParametersValid()

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

//

bool UntrustedCertificateDialog::isParametersValid(const QVariantMap &parameters)

{

    if (parameters.contains(KUntrustedCertEncodedCertificate) &&

        parameters.contains(KUntrustedCertServerName) &&

        parameters.contains(KUntrustedCertValidationError)) {

        return true;

        }

    mLastError = KParameterError;

    return false;

}

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

// UntrustedCertificateDialog::constructDialog()

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

//

bool UntrustedCertificateDialog::constructDialog(const QVariantMap &parameters)

{

    if (!isParametersValid(parameters)) {

        return false;

    }

    setTimeout(HbPopup::NoTimeout);

    setDismissPolicy(HbPopup::NoDismiss);

    setModal(true);

    //: Title text in untrusted certificate dialog. User is opening secure

    //: connection to site or service, which authenticity cannot be proved,

    //: or there are other problems in the site certificate. User needs to

    //: decide if she/he accepts the risk and opens the secure connection

    //: anyway, or if the connection is rejected.

    //TODO: localised UI string

    //QString titleText = hbTrId("");

    QString titleText = tr("Untrusted certificate");

    setHeadingWidget(new HbLabel(titleText, this));

    Q_ASSERT(mContent == 0);

    mContent = new UntrustedCertificateWidget(this);

    mContent->constructFromParameters(parameters);

    setContentWidget(mContent);

    if (mContent->isCertificateValid()) {

        HbAction *okAction = new HbAction(qtTrId("txt_common_button_ok"), this);

        connect(okAction, SIGNAL(triggered()), this, SLOT(handleAccepted()));

        addAction(okAction);

        HbAction *cancelAction = new HbAction(qtTrId("txt_common_button_cancel"), this);

        connect(cancelAction, SIGNAL(triggered()), this, SLOT(handleRejected()));

        addAction(cancelAction);

    } else {

        HbAction *closeAction = new HbAction(qtTrId("txt_common_button_close"), this);

        connect(closeAction, SIGNAL(triggered()), this, SLOT(handleRejected()));

        addAction(closeAction);

    }

    return true;

}

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

// UntrustedCertificateDialog::updateFromParameters()

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

//

bool UntrustedCertificateDialog::updateFromParameters(const QVariantMap &parameters)

{

    if (!isParametersValid(parameters)) {

        return false;

    }

    Q_ASSERT(mContent != 0);

    mContent->updateFromParameters(parameters);

    return true;

}

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

// UntrustedCertificateDialog::sendResult()

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

//

void UntrustedCertificateDialog::sendResult(int result)

{

    QVariant resultValue(result);

    mResultMap.insert(KUntrustedCertificateDialogResult, resultValue);

    emit deviceDialogData(mResultMap);

}

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

// UntrustedCertificateDialog::handleAccepted()

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

//

void UntrustedCertificateDialog::handleAccepted()

{

    if (mContent->isPermanentAcceptChecked()) {

        sendResult(KDialogAcceptedPermanently);

    } else {

        sendResult(KDialogAccepted);

    }

}

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

// UntrustedCertificateDialog::handleRejected()

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

//

void UntrustedCertificateDialog::handleRejected()

{

    sendResult(KDialogRejected);

}