/*

* 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 <QCoreApplication>

#include <QKeyEvent>

#include <QEvent>

#include <QLabel>

#include <QVBoxLayout>

#include <QStackedWidget>

#include <QImageReader>

#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 "Autolock.h"

#include <xqserviceutil.h>

#include "autolockuseractivityservice.h"

#include <settingsinternalcrkeys.h>		// CenRep keys

#include <w32std.h>

#include <eikenv.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 "../PubSub/securityuisprivatepskeys.h"

#include <avkondomainpskeys.h>

#include <hwrmdomainpskeys.h>

#include <hbdevicedialog.h>

const TInt KPhoneIndex(0);

const TInt KTriesToConnectServer(2);

const TInt KTimeBeforeRetryingServerConnection(50000);

#define ESecUiTypeLock					0x00100000

_LIT( KMmTsyModuleName, "PhoneTsy");

// Constant definitions to control screensaver view types

static const char *KSnsrViewTypeKey = "view_type";

static const int KSnsrViewTypeValueActive = 1;

static const int KSnsrViewTypeValueStandby = 2;

static const char *KSnsrCmdUnlock = "unlock";

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

    QWidget(parent, f), mService(NULL)

    {

    RDEBUG("start autolock", 0);

		// The very first thing is to define the properties, so that others can use them.

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

    // This is important: we set the status through a property

    TInt autolockState;

    RDEBUG("Get KCoreAppUIsAutolockStatus", ret);

    RDEBUG("autolockState", autolockState);

    if(autolockState==EAutolockStatusUninitialized)

    	{

    	autolockState = EAutolockOff;	// not-initialized means taht the unlock-query hasn't been displayed. Therefore the device should not stay locked.

    	}

    ret = RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus,	

                   autolockState);	// this might re-set it. That's not bad. It will re-notify all listeners.

    RDEBUG("Set 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);

    ret = RProperty::Define(KPSUidSecurityUIs, KSecurityUIsDismissDialog,

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

            TSecurityPolicy(TSecurityPolicy::EAlwaysPass));

    RDEBUG("defined KSecurityUIsDismissDialog", ret);

    mService = new AutolockService(this);

    /* Adjust the palette */

#if defined(Q_WS_S60)

		// this is defined.

    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

    RDEBUG("connect", 1);

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

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

#elif defined(Q_WS_S60)

    // this doesn't work well

    // showMaximized();

    showFullScreen();

#endif

    serviceKeyguard = new AutolockUserActivityService();

    serviceDevicelock = new AutolockUserActivityService();

    TInt lockValue = 0;

    TInt lightsTimeout = 0;

    CRepository* repository = NULL;

    TInt cRresult = 0;

    iLockStatusPrev = ELockNotActive;

    iLockStatus = ELockNotActive;

    QT_TRAP_THROWING( 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);

    QT_TRAP_THROWING( repository = CRepository::NewL(KCRUidProfileEngine) );

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

    // this value is not used for now

    delete repository;

    QT_TRAP_THROWING( repository = CRepository::NewL(KCRUidLightSettings) );

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

    // this value is not used for now

    delete repository;

    // subscribe to settings changes

    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()));

    subscriberKSecurityUIsDismissDialog = new QValueSpaceSubscriber(

            "/KPSUidSecurityUIs/KSecurityUIsDismissDialog", this);

    connect(subscriberKSecurityUIsDismissDialog, SIGNAL(contentsChanged()), this,

            SLOT(subscriberKSecurityUIsDismissDialogChanged()));

    // subscribe to environment changes

    subscriberKHWRMGripStatus = new QValueSpaceSubscriber(

            "/KPSUidHWRM/KHWRMGripStatus");

    connect(subscriberKHWRMGripStatus, SIGNAL(contentsChanged()), this,

            SLOT(subscriberKHWRMGripStatusChanged()));

    subscriberKAknKeyguardStatus = new QValueSpaceSubscriber(

            "/KPSUidAvkonDomain/KAknKeyguardStatus");

    connect(subscriberKAknKeyguardStatus, SIGNAL(contentsChanged()), this,

            SLOT(subscriberKAknKeyguardStatusChanged()));

    subscriberKCoreAppUIsAutolockStatus = new QValueSpaceSubscriber(

            "/KPSUidCoreApplicationUIs/KCoreAppUIsAutolockStatus");

    connect(subscriberKCoreAppUIsAutolockStatus, SIGNAL(contentsChanged()), this,

            SLOT(subscriberKCoreAppUIsAutolockStatusChanged()));

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

    groupWin.CaptureKey(EKeyDeviceF, 0, 0);

    groupWin.CaptureKey(EKeyBell, 0, 0);

    RDEBUG("got mKeyCaptureHandle", 1);

    iSecQueryUiCreated = -1;

    // TryChangeStatus(iLockStatus);

    TryChangeStatus( ELockNotActive);

    lower();

    hide();

    // screensaver standby mode timer

    mScreensaverModeTimer = new QTimer( this );

    mScreensaverModeTimer->setInterval( 5*1000 ); // milliseconds, TODO: read from cenrep

    connect( mScreensaverModeTimer, SIGNAL(timeout()), SLOT(switchScreensaverToPowerSaveMode()) );

    }

Autolock::~Autolock()

    {

    RDEBUG("0", 0);

    delete mService;

    delete mScreensaverModeTimer;

    RDEBUG("1", 1);

    }

void Autolock::adjustInactivityTimers(int aReason)

    {

    RDEBUG("aReason", aReason);

    TInt keyguardTime = 0;

    TInt lockTime = 0;

    CRepository* repository = NULL;

    TInt cRresult = 0;

    QT_TRAP_THROWING( repository = CRepository::NewL(KCRUidSecuritySettings) );

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

        }

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

    lockTime *= 60;

    RDEBUG("KSettingsAutoLockTime", KSettingsAutoLockTime);

    RDEBUG("cRresult", cRresult);

    RDEBUG("lockTime", lockTime);

    if(lockTime == 65535*60)	// Special setting "lock at same time as keyguard" at CpDeviceLockPluginView::GetAutoLockIndex which uses this magic number

    	lockTime = keyguardTime-2;	// lock 2 seconds before before, to avoid keyguard->devicelock sequence

    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

        }

    delete repository;

    }

void Autolock::quit()

    {

    RDEBUG("0", 0);

    qApp->quit();

    }

int Autolock::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;

		RDEBUG("KSecurityUIsLights err", err);

    RMmCustomAPI iCustomPhone;

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

            <= KTriesToConnectServer)

        {

        User::After( KTimeBeforeRetryingServerConnection);

        }

    err = iTelServer.LoadPhoneModule(KMmTsyModuleName);

    RTelServer::TPhoneInfo PhoneInfo;

    RDEBUG("LoadPhoneModule err", err);

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

    RDEBUG("SetExtendedErrorGranularity err", err);

    err = iTelServer.GetPhoneInfo(KPhoneIndex, PhoneInfo);

    RDEBUG("GetPhoneInfo err", err);

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

    RDEBUG("Open err", err);

    err = iCustomPhone.Open(iPhone);

    RDEBUG("Open2 err", err);

    RDEBUG("CSecurityHandler", 0);

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

    if (aReason == ELockAppDisableDevicelock)

        {

        RDEBUG("calling AskSecCodeInAutoLockL", 0);

        QT_TRAP_THROWING( 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;

                QT_TRAP_THROWING( iWait = CWait::NewL() );

                iWait->SetRequestType(EMobilePhoneSetLockSetting);

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

                RDEBUG("WaitForRequestL", 0);

                QT_TRAP_THROWING( 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

                RDEBUG("WaitForRequestL ret", ret);

#ifdef __WINS__

                if(ret==KErrTimedOut)

                ret = KErrNone;

#endif

                if (ret == KErrNone)

                    validCode = 1;

                else

                    validCode = 0;

                }

            else

            		{

            		RDEBUG("RMobilePhone::ELockSetEnabled", RMobilePhone::ELockSetEnabled);

            		RDEBUG("lockInfo.iSetting = RMobilePhone::ELockSetEnabled", RMobilePhone::ELockSetEnabled);

                validCode = 0x20;

              	}

            }

        else

            {

            RDEBUG("Error: ret", ret);

            validCode = 0x21;

          	}

        /* Alternative way to ask for password

         RMobilePhone::TMobilePhoneSecurityEvent iEvent;

         TInt result = KErrNone;

         iEvent = RMobilePhone::EPhonePasswordRequired;

         RDEBUG( "calling HandleEventL", 0 );

         handler->HandleEventL(iEvent, result);	// this is supposed to wait

         validCode = false;

         if(result)

         validCode = true;

         RDEBUG( "result", result );

         */

        }

    RDEBUG("validCode", validCode);

    if (validCode>0)

        return KErrNone;

		// no valid code -> switch off the lights

    err = RProperty::Set(KPSUidSecurityUIs,

            KSecurityUIsLights, ESecurityUIsLightsLockOffRequest);

		RDEBUG("KSecurityUIsLights err", err);

    return KErrCancel;

    }

void Autolock::handleAnswerDelivered()

    {

    RDEBUG("0", 0);

    // quit();

    }

void Autolock::setLabelNumber(QString label, QString number)

    {

    RDEBUG("0", 0);

    }

void Autolock::DebugRequest(int aReason)