/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

* 

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, 

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:

*

*/

// #include "xqservicelog.h"

#include <QApplication>

#include <QKeyEvent>

#include <QEvent>

#include <QLabel>

#include <QVBoxLayout>

#include <QStackedWidget>

#include <QImageReader>

#include <QDebug>

#include <QTimer>

#include <QPushButton>

#include <QLineEdit>

#include <QListView>

#include <QMessageBox>

#include <QToolButton>

#include <QSymbianEvent>

#include <QMainWindow>

#include <qvaluespacesubscriber.h>

#include <qvaluespacepublisher.h>

QTM_USE_NAMESPACE

#include <HbIndicator>

#include <hbdevicemessagebox.h>

#include <lockappclientserver.h>

#include <xqsharablefile.h>

#include <QGraphicsLinearLayout>

#include <hblabel.h>

#include "AutolockSrv.h"

#include <xqserviceutil.h>

#include "autolockuseractivityservice.h"

#include <settingsinternalcrkeys.h>		// CenRep keys

#include <W32STD.H>

#include <eikenv.h>

#include <qapplication.h>

#include <secuisecuritysettings.h>

#include <secui.h>

#include <secuisecurityhandler.h>

#include <etelmm.h>

#include <rmmcustomapi.h>

#include <qvaluespacesubscriber.h>

#include <hwrmlightdomaincrkeys.h>

#include <ProfileEngineSDKCRKeys.h>

#include <e32property.h>

#include <coreapplicationuisdomainpskeys.h>

#include "../../../inc/securityuisprivatepskeys.h"

#include <avkondomainpskeys.h>

#include <hbdevicedialog.h>

const TInt KPhoneIndex(0);

const TInt KTriesToConnectServer(2);

const TInt KTimeBeforeRetryingServerConnection(50000);

#define ESecUiTypeLock					0x00100000

_LIT( KMmTsyModuleName, "PhoneTsy");

#define XQSERVICE_DEBUG_PRINT(a) qDebug() << (a)

AutolockSrv::AutolockSrv(QWidget *parent, Qt::WFlags f) :

    QWidget(parent, f), mService(NULL)

    {

    XQSERVICE_DEBUG_PRINT("AutolockSrv::AutolockSrv");

    RDEBUG("start", 0);

    mService = new AutolockSrvService(this);

    /* Adjust the palette */

#if defined(Q_WS_S60)

    RDEBUG( "Q_WS_S60", 1 );

    QPalette p = qApp->palette();

    QColor color(192,192,192);

    QColor bg(201,250,250);

    p.setColor(QPalette::Highlight, color.lighter(200));

    p.setColor(QPalette::Text, Qt::black);

    p.setColor(QPalette::Base, bg);

    p.setColor(QPalette::WindowText, Qt::black);

    p.setColor(QPalette::Window, bg);

    p.setColor(QPalette::ButtonText, Qt::black);

    p.setColor(QPalette::Button, color.lighter(150));

    p.setColor(QPalette::Link, QColor(240,40,40));

    qApp->setPalette(p);

#endif

    QPushButton *unlockButton = new QPushButton(tr("Unlock"));

    QPushButton *unguardButton = new QPushButton(tr("Unguard"));

    QPushButton *lockButton = new QPushButton(tr("Lock"));

    QPushButton *quitButton = new QPushButton(tr("Quit"));

    QPushButton *test1Button = new QPushButton(tr("Autolock 10 seconds"));

    QPushButton *test2Button = new QPushButton(tr("Autolock never"));

    connect(quitButton, SIGNAL(clicked()), this, SLOT(quit()));

    connect(lockButton, SIGNAL(clicked()), this, SLOT(lockAction()));

    connect(unlockButton, SIGNAL(clicked()), this, SLOT(unlockAction()));

    connect(unguardButton, SIGNAL(clicked()), this, SLOT(unguardAction()));

    connect(test1Button, SIGNAL(clicked()), this, SLOT(test1Action()));

    connect(test2Button, SIGNAL(clicked()), this, SLOT(test2Action()));

    RDEBUG("connect", 1);

    /* there's no use for this */

    /*

     bool isService = XQServiceUtil::isService();

     QString t = "SERVICEAPP:\n";

     t = t + (isService ?  "    LAUNCHED AS SERVICE\n" : "    LAUNCHED NORMALLY\n");

     t = t + (XQServiceUtil::isEmbedded() ? "    EMBEDDED\n" : "    NOT EMBEDDED\n");

     QStringList args = QApplication::arguments();

     foreach (QString arg, args)

     {

     t += "cmdline arg=" + arg + "\n";

     }

     QLabel *title = new QLabel(t);

     */

    mLabel = new QLabel("");

    mNumberEdit = new QLineEdit("");

    QVBoxLayout *vl = new QVBoxLayout;

    RDEBUG("QVBoxLayout", 1);

    vl->setMargin(0);

    vl->setSpacing(0);

    RDEBUG("setSpacing", 1);

    vl->addWidget(lockButton);

    vl->addWidget(unlockButton);

    vl->addWidget(unguardButton);

    vl->addWidget(quitButton);

    vl->addWidget(test1Button);

    vl->addWidget(test2Button);

    RDEBUG("added test2Button", 1);

    mLabelIcon = new QToolButton;

    mLabelIcon->setIcon(QIcon(

            ":/AutolockSrv_hbicon/qtg_large_device_lock.svg"));

    mLabelIcon->setIconSize(QSize(300, 300));

    vl->addWidget(mLabelIcon);

    RDEBUG("added mLabelIcon", 1);

    /*    vl->addItem(title);

     vl->addWidget(mLabel);

     vl->addWidget(mNumberEdit);

     */

    setLayout(vl);

#if defined(Q_WS_X11) || defined(Q_WS_WIN)

    setFixedSize(QSize(360,640)); // nHD

#elif defined(Q_WS_S60)

    // showMaximized();

    showFullScreen();

#endif

    mLabelIcon_visible = 1;

    serviceKeyguard = new AutolockUserActivityService();

    serviceDevicelock = new AutolockUserActivityService();

    TInt lockValue = 0;

    TInt lightsTimeout = 0;

    CRepository* repository;

    TInt cRresult = 0;

    iLockStatusPrev = ELockNotActive;

    iLockStatus = ELockNotActive;

    repository = CRepository::NewL(KCRUidSecuritySettings);

    cRresult = repository->Get(KSettingsAutolockStatus, lockValue);

    RDEBUG("KSettingsAutolockStatus", KSettingsAutolockStatus);

    RDEBUG("cRresult", cRresult);

    RDEBUG("lockValue", lockValue);

    iLockStatus = lockValue;

    // the settings says to lock

    delete repository;

    adjustInactivityTimers(0);

    repository = CRepository::NewL(KCRUidProfileEngine);

    cRresult = repository->Get(KProEngActiveProfile, lightsTimeout);

    delete repository;

    repository = CRepository::NewL(KCRUidLightSettings);

    cRresult = repository->Get(KDisplayLightsTimeout, lightsTimeout);

    delete repository;

    // TODO flip

    subscriberKSettingsAutolockStatus = new QValueSpaceSubscriber(

            "/KCRUidSecuritySettings/KSettingsAutolockStatus", this);

    connect(subscriberKSettingsAutolockStatus, SIGNAL(contentsChanged()),

            this, SLOT(subscriberKSettingsAutolockStatusChanged()));

    subscriberKSettingsAutoLockTime = new QValueSpaceSubscriber(

            "/KCRUidSecuritySettings/KSettingsAutoLockTime", this);

    connect(subscriberKSettingsAutoLockTime, SIGNAL(contentsChanged()), this,

            SLOT(subscriberKSettingsAutoLockTimeChanged()));

    subscriberKSettingsAutomaticKeyguardTime = new QValueSpaceSubscriber(

            "/KCRUidSecuritySettings/KSettingsAutomaticKeyguardTime", this);

    connect(subscriberKSettingsAutomaticKeyguardTime, SIGNAL(

            contentsChanged()), this, SLOT(

            subscriberKSettingsAutomaticKeyguardTimeChanged()));

    subscriberKDisplayLightsTimeout = new QValueSpaceSubscriber(

            "/KCRUidLightSettings/KDisplayLightsTimeout", this);

    connect(subscriberKDisplayLightsTimeout, SIGNAL(contentsChanged()), this,

            SLOT(subscriberKDisplayLightsTimeoutChanged()));

    subscriberKProEngActiveProfile = new QValueSpaceSubscriber(

            "/KCRUidProfileEngine/KProEngActiveProfile", this);

    connect(subscriberKProEngActiveProfile, SIGNAL(contentsChanged()), this,

            SLOT(subscriberKProEngActiveProfileChanged()));

    TSecurityPolicy readPolicy(ECapabilityReadDeviceData);

    TSecurityPolicy writePolicy(ECapabilityWriteDeviceData);

    TInt ret = RProperty::Define(KPSUidSecurityUIs,

            KSecurityUIsSecUIOriginatedQuery, RProperty::EInt, readPolicy,

            writePolicy);

    RDEBUG("defined KSecurityUIsSecUIOriginatedQuery", ret);

    ret = RProperty::Define(KPSUidSecurityUIs,

            KSecurityUIsQueryRequestCancel, RProperty::EInt, readPolicy,

            writePolicy);

    RDEBUG("defined KSecurityUIsQueryRequestCancel", ret);

    _LIT_SECURITY_POLICY_PASS( KReadPolicy);

    _LIT_SECURITY_POLICY_C1(KWritePolicy, ECapabilityWriteDeviceData);

    ret = RProperty::Define(KPSUidCoreApplicationUIs,

            KCoreAppUIsAutolockStatus, RProperty::EInt, KReadPolicy,

            KWritePolicy);

    RDEBUG("defined KCoreAppUIsAutolockStatus", ret);

    ret = RProperty::Define(KPSUidAvkonDomain, KAknKeyguardStatus,

            RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass),

            KWritePolicy);

    RDEBUG("defined KAknKeyguardStatus", ret);

    ret = RProperty::Define(KPSUidSecurityUIs,

            KSecurityUIsLockInitiatorUID, RProperty::EInt, readPolicy,

            writePolicy);

    RDEBUG("defined KSecurityUIsLockInitiatorUID", ret);

    ret = RProperty::Define(KPSUidSecurityUIs,

            KSecurityUIsLockInitiatorTimeHigh, RProperty::EInt, readPolicy,

            writePolicy);

    RDEBUG("defined KSecurityUIsLockInitiatorTimeHigh", ret);

    ret = RProperty::Define(KPSUidSecurityUIs,

            KSecurityUIsLockInitiatorTimeLow, RProperty::EInt, readPolicy,

            writePolicy);

    RDEBUG("defined KSecurityUIsLockInitiatorTimeLow", ret);

    ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsLights,

            RProperty::EInt, TSecurityPolicy(TSecurityPolicy::EAlwaysPass),

            TSecurityPolicy(TSecurityPolicy::EAlwaysPass));

    RDEBUG("defined KAknKeyguardStatus", ret);

    // inactivity

    connect(serviceKeyguard, SIGNAL(active()), this, SLOT(activeKeyguard()));

    connect(serviceKeyguard, SIGNAL(notActive()), this, SLOT(

            notActiveKeyguard()));

    connect(serviceDevicelock, SIGNAL(active()), this, SLOT(

            activeDevicelock()));

    connect(serviceDevicelock, SIGNAL(notActive()), this, SLOT(

            notActiveDevicelock()));

    RWindowGroup& groupWin = CEikonEnv::Static()->RootWin();

    RDEBUG("got groupWin", 1);

    // TODO if I want to release, I should do:   mKeyCaptureHandle = env->RootWin().CaptureKey(EKeyBackspace, 0, 0);

    groupWin.CaptureKey(EKeyBackspace, 0, 0);

    groupWin.CaptureKey(EKeyDeviceF, 0, 0);

    groupWin.CaptureKey(EKeyBell, 0, 0);

    groupWin.CaptureKey(EKeyTab, 0, 0);

    groupWin.CaptureKey(EKeyInsert, 0, 0);

    RDEBUG("got mKeyCaptureHandle", 1);

    iSecQueryUiCreated = -1;

    iDeviceDialogCreated = -1;

    // TODO for now, always starts unlocked

    // TryChangeStatus(iLockStatus);

    TryChangeStatus( ELockNotActive);

    lower();

    hide();

    // not needed:   new AutolockSrvService(this);

    }

AutolockSrv::~AutolockSrv()

    {

    RDEBUG("0", 0);

    delete mService;

    }

void AutolockSrv::adjustInactivityTimers(int aReason)

    {

    RDEBUG("aReason", aReason);

    TInt keyguardTime = 0;

    TInt lockTime = 0;

    CRepository* repository;

    TInt cRresult = 0;

    repository = CRepository::NewL(KCRUidSecuritySettings);

    cRresult = repository->Get(KSettingsAutoLockTime, lockTime);	// in minutes, handled internally as seconds

    lockTime *= 60;

    RDEBUG("KSettingsAutoLockTime", KSettingsAutoLockTime);

    RDEBUG("cRresult", cRresult);

    RDEBUG("lockTime", lockTime);

    if (lockTime > 60 && lockTime < 24*60*60)	// lock timer can't be bigger than 1 day

        {

        serviceDevicelock->setInactivityPeriod(lockTime);

        }

    else

        {

        serviceDevicelock->setInactivityPeriod(12 * 31 * 24 * 60 * 60);	// 0x1ea6e00

        }

    cRresult = repository->Get(KSettingsAutomaticKeyguardTime, keyguardTime);	// in seconds

    RDEBUG("KSettingsAutomaticKeyguardTime", KSettingsAutomaticKeyguardTime);

    RDEBUG("cRresult", cRresult);

    RDEBUG("keyguardTime", keyguardTime);

    if (keyguardTime > 0 && keyguardTime < 1000)

        {

        serviceKeyguard->setInactivityPeriod(keyguardTime);

        }

    else

        {

        serviceKeyguard->setInactivityPeriod(12 * 31 * 24 * 60 * 60);

        }

    delete repository;

    }

void AutolockSrv::quit()

    {

    RDEBUG("0", 0);

    qApp->quit();

    }

// from the button

void AutolockSrv::unlockAction()

    {

    RDEBUG("0", 0);

    TryChangeStatus( ELockAppDisableDevicelock);

    }

void AutolockSrv::unguardAction()

    {

    RDEBUG("0", 0);

    TryChangeStatus( ELockAppDisableKeyguard);

    }

void AutolockSrv::test1Action()

    {

    RDEBUG("Set(KSettingsAutoLockTime, 2)", 2);

    CRepository* repositorySet = CRepository::NewL(KCRUidSecuritySettings);

    repositorySet->Set(KSettingsAutoLockTime, 2);	// in minutes

    delete repositorySet;

    }

void AutolockSrv::test2Action()

    {

    RDEBUG("Set(KSettingsAutoLockTime, 0)", 0);

    CRepository* repositorySet = CRepository::NewL(KCRUidSecuritySettings);

    repositorySet->Set(KSettingsAutoLockTime, 0);	// minutes

    delete repositorySet;

    }

int AutolockSrv::AskValidSecCode(int aReason)

    {

    RDEBUG("aReason", aReason);

    RMobilePhone iPhone; // NULL in emulator

#ifdef __WINS__1

    return KErrNone;

#endif

    TInt err(KErrGeneral);

    TBool validCode(EFalse);

    TInt thisTry(0);

    RTelServer iTelServer;

    err = RProperty::Set(KPSUidSecurityUIs,

            KSecurityUIsLights, ESecurityUIsLightsQueryOnRequest);

		RDEBUG("KSecurityUIsLights err", err);

    RMmCustomAPI iCustomPhone;

    while ((err = iTelServer.Connect()) != KErrNone && (thisTry++)

            <= KTriesToConnectServer)

        {

        User::After( KTimeBeforeRetryingServerConnection);

        }

    err = iTelServer.LoadPhoneModule(KMmTsyModuleName);

    RTelServer::TPhoneInfo PhoneInfo;

    RDEBUG("err", err);

    err = iTelServer.SetExtendedErrorGranularity(RTelServer::EErrorExtended);

    RDEBUG("err", err);

    err = iTelServer.GetPhoneInfo(KPhoneIndex, PhoneInfo);

    RDEBUG("err", err);

    err = iPhone.Open(iTelServer, PhoneInfo.iName);

    RDEBUG("err", err);

    err = iCustomPhone.Open(iPhone);

    RDEBUG("err", err);

    RDEBUG("CSecurityHandler", 0);

    CSecurityHandler* handler = new (ELeave) CSecurityHandler(iPhone);

    if (aReason == ELockAppDisableDevicelock)

        {

        RDEBUG("calling AskSecCodeInAutoLockL", 0);

        validCode = handler->AskSecCodeInAutoLockL(); // this returns true/false

        // TODO should this also do iPhone.SetLockSetting(status, lockType, lockChange); ???

        }

    else if (aReason == ELockAppEnableDevicelock)

        {

        // check whether code is really needed

        RMobilePhone::TMobilePhoneLock lockType =

                RMobilePhone::ELockPhoneDevice;

        RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;

        RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPkg(lockInfo);

        RMobilePhone::TMobilePhoneLockSetting lockChange(

                RMobilePhone::ELockSetDisabled);

        TRequestStatus status = KRequestPending;

        TInt ret = KErrNone;

        RDEBUG("GetLockInfo", 0);

        iPhone.GetLockInfo(status, lockType, lockInfoPkg);

        RDEBUG("WaitForRequest", 0);

        User::WaitForRequest(status);

        ret = status.Int();

        RDEBUG("WaitForRequest ret", ret);

#ifdef __WINS__

        if(ret==KErrTimedOut)

            {

            ret = KErrNone;

            lockInfo.iSetting = RMobilePhone::ELockSetDisabled; // ask password only if there's no timeout.

            }

#endif

        if (ret == KErrNone)

            {

            RDEBUG("lockInfo.iSetting", lockInfo.iSetting);

            RDEBUG("RMobilePhone::ELockSetDisabled",

                    RMobilePhone::ELockSetDisabled);

            if (lockInfo.iSetting == RMobilePhone::ELockSetDisabled) // ask password only if there's no timeout

                {

                lockChange = RMobilePhone::ELockSetEnabled;

                RDEBUG("SetLockSetting lockChange", lockChange);

#define OLD_METHODx

#ifdef OLD_METHOD

                status = KRequestPending;

                RDEBUG( "SetLockSetting", 0 );

                iPhone.SetLockSetting(status, lockType, lockChange); // ask for PassPhraseRequiredL

                RDEBUG( "WaitForRequestL", 0 );

                User::WaitForRequest( status ); // TODO this waits 33 seconds in WINS and returns ffffffdf = KErrTimedOut

                ret = status.Int();

                RDEBUG( "WaitForRequestL ret", ret );

#else

                RDEBUG("! OLD_METHOD", 0);

                CWait *iWait = NULL;

                iWait = CWait::NewL();

                iWait->SetRequestType(EMobilePhoneSetLockSetting);

                iPhone.SetLockSetting(iWait->iStatus, lockType, lockChange); // ask for PassPhraseRequiredL

                RDEBUG("WaitForRequestL", 0);

                ret = iWait->WaitForRequestL();

                RDEBUG("WaitForRequestL ret", ret);

                if (iWait)

                    {

                    RDEBUG("IsActive", 0);

                    if (iWait->IsActive())

                        {

                        RDEBUG("CancelAsyncRequest", 0);

                        iPhone.CancelAsyncRequest(iWait->GetRequestType());

                        RDEBUG("cancelled", 0);

                        }

                    }

                delete iWait;

#endif