/*

* 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 "../../SecUi/inc/SecQueryUi.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;

    vl->setMargin(0);

    vl->setSpacing(0);

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

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

    	RDEBUG( "KSettingsAutoLockTime", KSettingsAutoLockTime );

    	RDEBUG( "cRresult", cRresult );

    	RDEBUG( "lockTime", lockTime );

    if(lockTime>0 && lockTime<1000)

    	{

			serviceDevicelock->setInactivityPeriod(lockTime);

			}

		else

			{

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

			}

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

    	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, 30000)", 30000 );

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

    repositorySet->Set(KSettingsAutoLockTime, 10);

    delete repositorySet;

}

void AutolockSrv::test2Action()

{

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

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

    repositorySet->Set(KSettingsAutoLockTime, 0);

    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;

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

		    	RDEBUG( "WaitForRequestL ret", ret );

		    #ifdef __WINS__

		    if(ret==KErrTimedOut)

		    	ret = KErrNone;

		    #endif

	    	if(ret==KErrNone)

	    		validCode = 1;

	    	else

	    		validCode = 0;

				}

			else

				validCode = 0x20;

			}

		else

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

	*/

	}

// TODO this doesn't wait on WINS , so how do I get the Acceptation?

	RDEBUG( "validCode (true/false)", validCode );

if(validCode)

	return KErrNone;

return KErrCancel;

}

void AutolockSrv::lockAction()

{

			RDEBUG( "0", 0 );

    XQSERVICE_DEBUG_PRINT("AutolockSrv::lockAction");

		TryChangeStatus(ELockAppOfferDevicelock);

}

void AutolockSrv::handleAnswerDelivered()

{

			RDEBUG( "This should never be called", 0 );

    // quit();

}

void AutolockSrv::endCall()

{

			RDEBUG( "This should never be called", 0 );

    //QVBoxLayout *vl = qobject_cast<QVBoxLayout *>(layout()) ;

    //vl->removeWidget(mEndCallButton);

    //XQServiceUtil::toBackground(true);

}

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

{

			RDEBUG( "0", 0 );

    mLabel->setText("mLabel=" + label);

    mNumberEdit->setText("mNumberEdit=" + number);

}

void AutolockSrv::DebugRequest(int aReason)

{

    switch(aReason)

    {

    	case ELockAppEnableKeyguard:

					RDEBUG( "ELockAppEnableKeyguard", aReason );