/*

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

_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) :

    {

    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)

        {

        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, 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 */

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

    iLockCodeQueryInDisplay = EFalse;

    Q_UNUSED(cRresult);

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

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

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

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

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

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

    // subscribe to environment changes

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

    iDeviceDialogCreated = EDeviceDialogUninitialized;

    RDEBUG("new iDeviceDialogCreated", iDeviceDialogCreated);

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

    }

Autolock::~Autolock()

    {

    RDEBUG("0", 0);

    delete mService;

    // handled now directly but screensaver

    // delete mScreensaverPowerSave;

    // delete mScreensaverPowerSavePixelBuffer;

    }

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)

        {

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

        }

    delete repository;

    }

void Autolock::quit()

    {

    RDEBUG("0", 0);

    qApp->quit();

    }

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

    {

    RDEBUG("aMode", aMode);

    RDEBUG("aReason", aReason);

    RDEBUG("aCaller", aCaller);

    RDEBUG("KSecurityUIsLights err", err);

    return err;

  	}

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

                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;

                }

            }