/*

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

#include <QKeyEvent>

#include <QEvent>

#include <QTimer>

#include <QMessageBox>

#include <QSymbianEvent>

#include <QMainWindow>

#include <qvaluespacesubscriber.h>

#include <qvaluespacepublisher.h>

QTM_USE_NAMESPACE

#include <HbIndicator>

#include <hbdevicemessagebox.h>

#include <lockappclientserver.h>

#include "Autolock.h"

#include <xqserviceutil.h>

#include "autolockuseractivityservice.h"

#include <settingsinternalcrkeys.h>     // CenRep keys

#include <w32std.h>

#include <eikenv.h>

#include <aknsoundsystem.h>

#include <secuisecuritysettings.h>

#include <secui.h>

#include <secuisecurityhandler.h>

#include <etelmm.h>

#include <rmmcustomapi.h>

#include <keylockpolicyapi.h>

#include <qvaluespacesubscriber.h>

#include <SCPClient.h>

#include <hwrmlightdomaincrkeys.h>

#include <ProfileEngineSDKCRKeys.h>

#include <e32property.h>

#include <coreapplicationuisdomainpskeys.h>

#include "../PubSub/securityuisprivatepskeys.h"

#include <avkondomainpskeys.h>

#include <hwrmdomainpskeys.h>

#include <ctsydomainpskeys.h>

#include <startupdomainpskeys.h>

#include <hbdevicedialog.h>

// handled now directly but screensaver

// #include <power_save_display_mode.h>

const TInt KPhoneIndex(0);

const TInt KTriesToConnectServer(2);

const TInt KTimeBeforeRetryingServerConnection(50000);

#define ESecUiTypeDeviceLock        0x00100000

#define ESecUiTypeKeyguard          0x00200000

_LIT( KMmTsyModuleName, "PhoneTsy");

// Constant definitions to control screensaver view types

static const char *KSnsrViewTypeKey = "view_type";

enum TSnsrViewType

    {

    ESnsrViewTypeInitial = 0, // default initial state, depends on the configuration

    ESnsrViewTypeActive,

    ESnsrViewTypeStandby,

    ESnsrViewTypeDisabled,

    };

static const char *KSnsrCmdUnlock = "unlock";

static const char *KSnsrCmdSwitchLights = "switch_lights";

static const char *KSnsrCmdSwitchLowPower = "switch_low_power";

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

    QWidget(parent, f),

    mService(NULL),

    mPowerKeyCaptureHandle(0),

    mApplicationKeyCaptureHandle(0),

    mApplicationLongKeyCaptureHandle(0),

    mEKeyDeviceFCaptureHandle(0),

    mEKeyBellCaptureHandle(0),

    mEKeyYesCaptureHandle(0),

    mEKeyNoCaptureHandle(0),

    iLockCodeQueryInDisplay(false),

    mScreensaverModeTimer(0)

    {

    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;

    ret = RProperty::Get(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, autolockState);

    RDEBUG("Get KCoreAppUIsAutolockStatus", ret);

    RDEBUG("autolockState", autolockState);

    if (autolockState == EAutolockStatusUninitialized)

        {

        }

    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, TSecurityPolicy(TSecurityPolicy::EAlwaysPass), 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 */

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

    RDEBUG("connect", 1);

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

		RDEBUG( "Q_WS_X11", 1 );

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

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

    iLockCodeQueryInDisplay = EFalse;

    Q_UNUSED(cRresult);

    TInt err = 0;

		iProcessingEvent = -1;

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

    err = connect(subscriberKSettingsAutolockStatus, SIGNAL(contentsChanged()), this, SLOT(subscriberKSettingsAutolockStatusChanged()));

    RDEBUG("err", err);

    subscriberKSettingsAutoLockTime = new QValueSpaceSubscriber("/KCRUidSecuritySettings/KSettingsAutoLockTime", this);

    err = connect(subscriberKSettingsAutoLockTime, SIGNAL(contentsChanged()), this, SLOT(subscriberKSettingsAutoLockTimeChanged()));

    RDEBUG("err", err);

    subscriberKSettingsAutomaticKeyguardTime = new QValueSpaceSubscriber("/KCRUidSecuritySettings/KSettingsAutomaticKeyguardTime", this);

    err = connect(subscriberKSettingsAutomaticKeyguardTime, SIGNAL(contentsChanged()), this, SLOT(subscriberKSettingsAutomaticKeyguardTimeChanged()));

    RDEBUG("err", err);

    subscriberKDisplayLightsTimeout = new QValueSpaceSubscriber("/KCRUidLightSettings/KDisplayLightsTimeout", this);

    err = connect(subscriberKDisplayLightsTimeout, SIGNAL(contentsChanged()), this, SLOT(subscriberKDisplayLightsTimeoutChanged()));

    RDEBUG("err", err);

    subscriberKProEngActiveProfile = new QValueSpaceSubscriber("/KCRUidProfileEngine/KProEngActiveProfile", this);

    err = connect(subscriberKProEngActiveProfile, SIGNAL(contentsChanged()), this, SLOT(subscriberKProEngActiveProfileChanged()));

    RDEBUG("err", err);

    subscriberKSecurityUIsDismissDialog = new QValueSpaceSubscriber("/KPSUidSecurityUIs/KSecurityUIsDismissDialog", this);

    err = connect(subscriberKSecurityUIsDismissDialog, SIGNAL(contentsChanged()), this, SLOT(subscriberKSecurityUIsDismissDialogChanged()));

    RDEBUG("err", err);

    // subscribe to environment changes

    subscriberKHWRMGripStatus = new QValueSpaceSubscriber("/KPSUidHWRM/KHWRMGripStatus", this);

    err = connect(subscriberKHWRMGripStatus, SIGNAL(contentsChanged()), this, SLOT(subscriberKHWRMGripStatusChanged()));

    RDEBUG("err", err);

    subscriberKAknKeyguardStatus = new QValueSpaceSubscriber("/KPSUidAvkonDomain/KAknKeyguardStatus", this);

    err = connect(subscriberKAknKeyguardStatus, SIGNAL(contentsChanged()), this, SLOT(subscriberKAknKeyguardStatusChanged()));

    RDEBUG("err", err);

    subscriberKCoreAppUIsAutolockStatus = new QValueSpaceSubscriber("/KPSUidCoreApplicationUIs/KCoreAppUIsAutolockStatus", this);

    err = connect(subscriberKCoreAppUIsAutolockStatus, SIGNAL(contentsChanged()), this, SLOT(subscriberKCoreAppUIsAutolockStatusChanged()));

    RDEBUG("err", err);

    subscriberKCTsyCallState = new QValueSpaceSubscriber("/KPSUidCtsyCallInformation/KCTsyCallState", this);

    err = connect(subscriberKCTsyCallState, SIGNAL(contentsChanged()), this, SLOT(subscriberKCTsyCallStateChanged()));

    RDEBUG("err", err);

    subscriberKSecurityUIsTestCode = new QValueSpaceSubscriber("/KPSUidSecurityUIs/KSecurityUIsTestCode", this);

    err = connect(subscriberKSecurityUIsTestCode, SIGNAL(contentsChanged()), this, SLOT(subscriberKSecurityUIsTestCodeChanged()));

    RDEBUG("err", err);

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

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

    mEKeyDeviceFCaptureHandle = groupWin.CaptureKey(EKeyDeviceF, 0, 0);

    RDEBUG("mEKeyDeviceFCaptureHandle", mEKeyDeviceFCaptureHandle);

    mEKeyBellCaptureHandle = groupWin.CaptureKey(EKeyBell, 0, 0);

    RDEBUG("mEKeyBellCaptureHandle", mEKeyBellCaptureHandle);

    RDEBUG("got mKeyCaptureHandle", 1);

		iTempDisableOnlyKeyguardBecauseIncomingCall=0;

    iSecQueryUiCreated = -1;

    setDeviceDialogStatus( EDeviceDialogUninitialized );

    iDeviceDialog = NULL;

    // for now, always starts unlocked. This is correct because if locked, the unlock-query (from starter) is on top

    // TryChangeStatus(iLockStatus);

    TryChangeStatus( ELockNotActive);

    lower();

    hide();

    iDeviceDialog = new HbDeviceDialog(HbDeviceDialog::NoFlags, this);

    connect(iDeviceDialog, SIGNAL(dataReceived(QVariantMap)), SLOT(handleMessageFromScreensaver(QVariantMap)), Qt::QueuedConnection);	// Qt::QueuedConnection needed to avoid deadlock at waitForClosed

    connect(iDeviceDialog, SIGNAL(deviceDialogClosed()), SLOT(handleScreensaverClosed()));

    // screensaver standby mode timer

    mScreensaverModeTimer = new QTimer(this);

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

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

    // screensaver AMOLED low power mode support

    // handled now directly but screensaver

    // mScreensaverPowerSave = CPowerSaveDisplayMode::NewL();

    // mScreensaverPowerSavePixelBuffer = HBufC16::NewL(360 * 640);

    // mScreensaverPowerSavePixelBuffer->Des().Fill(0);

    RDEBUG("99", 0x99);

    }

// destructor

Autolock::~Autolock()

    {

    RDEBUG("0", 0);

    delete mService;

    // handled now directly but screensaver

    // delete mScreensaverPowerSave;

    // delete mScreensaverPowerSavePixelBuffer;

    RDEBUG("99", 0x99);

    }

// when detected some settings change, syncronize all of them

void Autolock::adjustInactivityTimers(int aReason)

    {

    RDEBUG("aReason", aReason);

    TInt keyguardTime = 0;

    TInt lockTime = 0;

    CRepository* repository = NULL;

    TInt cRresult = 0;

    Q_UNUSED(cRresult);

    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 > 2 && keyguardTime < 24 * 60 * 60)	// limit it to 1 day

        {

        serviceKeyguard->setInactivityPeriod(keyguardTime);

        }

    else

        {

        serviceKeyguard->setInactivityPeriod(12 * 31 * 24 * 60 * 60);	// if not set, fake it to 1 year

        }

    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 keyguard, to avoid keyguard->devicelock sequence

        if(lockTime<=2)

        	lockTime=2;

        RDEBUG("new lockTime", lockTime);

      	}

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

        {

        RDEBUG("setInactivityPeriod lockTime", lockTime);

        serviceDevicelock->setInactivityPeriod(lockTime);

        }

    else

        {

        RDEBUG("setInactivityPeriod infinite", lockTime);

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

        }

    delete repository;

    RDEBUG("99", 0x99);

    }

// Some external says to quit. It should not happen, but it helps to validate memory leaks

void Autolock::quit()

    {

    RDEBUG("0", 0);

    qApp->quit();

    }

// Inform P&S listeners thatthe screensaver is created/hidden/dismissed . In particular, HbDeviceDialogs needs this to display other pending notes.

int Autolock::setDeviceDialogStatus(int aStatus)

    {

    RDEBUG("aStatus", aStatus);

    RDEBUG("prev iDeviceDialogStatus", iDeviceDialogStatus);

		TInt lPSStatus;

    TInt err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsScreenSaverStatus, lPSStatus);

    RDEBUG("err", err);

    RDEBUG("lPSStatus", lPSStatus);

    if(aStatus>=EDeviceDialogLastValue)

    	{

    	RDEBUG("EDeviceDialogLastValue exceeded by aStatus", aStatus);

    	}

    else

    	{

	    err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsScreenSaverStatus, aStatus);

	    iDeviceDialogStatus = aStatus;

  	  RDEBUG("err", err);

  		}

    return aStatus;

		}

// Adjust the lights. It uses P&S, honoured by SysAp

int Autolock::TurnLights(int aMode, int aReason, int aCaller)

    {

    RDEBUG("aMode", aMode);

    RDEBUG("aReason", aReason);

    RDEBUG("aCaller", aCaller);

    TInt err = 0;

    if(aMode!=ESecurityUIsLightsLockOffRequest && aMode!=ELockAppDisableKeyguard)

    	{

    	RDEBUG("KLightsSSForcedLightsOn", KLightsSSForcedLightsOn);

    	err = RProperty::Set(KPSUidCoreApplicationUIs, KLightsSSForcedLightsOn, 30);

    	}

    else

     {

     RDEBUG("skip KLightsSSForcedLightsOn because aMode", aMode);

   	 }

    RDEBUG("err", err);

    err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsLights, aMode);

    RDEBUG("KSecurityUIsLights err", err);

    return err;

  }

// When locked, ask for the code. Returns KErrNone or KErrCancel. In other words: this keeps asking until correct code.

int Autolock::AskValidSecCode(int aReason)

    {

    RDEBUG("aReason", aReason);

    RMobilePhone iPhone; // NULL in emulator

#ifdef __WINS__1

    return KErrNone;

#endif

    TInt err(KErrGeneral);

    Q_UNUSED(err);

    TBool validCode(EFalse);

    TInt thisTry(0);

    RTelServer iTelServer;

    TurnLights(ESecurityUIsLightsQueryOnRequest, aReason, 0x10);

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

        iLockCodeQueryInDisplay = ETrue;

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

        iLockCodeQueryInDisplay = EFalse;

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