/*

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

*

*/

#ifndef AUTOLOCK_H

#define AUTOLOCK_H

#ifdef _DEBUG

		#define RDEBUG( x, y ) RDebug::Printf( "%s %s (%u) %s=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, x, y );

#else

    #define RDEBUG( x, y )

#endif

#include <QWidget>

#include <QEvent>

#include <QModelIndex>

#include <QMap>

#include <QStringList>

#include <xqserviceprovider.h>

#include <QToolButton>

#include <qmobilityglobal.h>

#include "autolockuseractivityservice.h"

#include "../../SecUi/Inc/SecQueryUi.h"

QTM_BEGIN_NAMESPACE

    class QValueSpacePublisher;

    class QValueSpaceSubscriber;

QTM_END_NAMESPACE

QTM_USE_NAMESPACE

#include <hbwidget.h>

#include <qapplication.h>

#include <hbdevicedialog.h>

enum TLockStatus

	{

	ELockNotActive = 0,

	EKeyguardActive,

	EDevicelockActive

	};

enum TDevicelockReason

	{

	EDevicelockManual = 1,

	EDevicelockRemote,

	EDevicelockTimer

	};

class QTimer;

class AutolockService;

// handled now directly but screensaver

// class CPowerSaveDisplayMode;

class Autolock : public QWidget

{

    Q_OBJECT

public:

    Autolock( QWidget *parent = 0, Qt::WFlags f = 0 );

    ~Autolock();

    void setLabelNumber(QString label,QString number);

    void setLabelIcon(int value);

    int CheckIfLegal(int value);

    void DebugRequest(int value);

    void DebugError(int value);

    void DebugStatus(int value);

    void adjustInactivityTimers(int aReason);

    int updateIndicator(int aReason);

    int TurnLights(int aMode, int aReason, int aCaller);

    int AskValidSecCode(int aReason);

    int publishStatus(int aReason);

    int TryChangeStatus(int aReason);

    int setLockDialog(int aReason, int status);

    int showNoteIfRequested(int aReason);

    int setDeviceDialogStatus(int aStatus);

    bool event(QEvent *event);    

    bool eventFilter(QObject *, QEvent *);

		int callerHasECapabilityWriteDeviceData;

		int iShowKeyguardNote;

    int mParam1;

    int mParam2;

public slots:    

    void quit();

    void handleAnswerDelivered();

    void subscriberKSettingsAutolockStatusChanged();

    void subscriberKSettingsAutoLockTimeChanged();

    void subscriberKSettingsAutomaticKeyguardTimeChanged();

    void subscriberKDisplayLightsTimeoutChanged();

    void subscriberKProEngActiveProfileChanged();

    void subscriberKAknKeyguardStatusChanged();

    void subscriberKCoreAppUIsAutolockStatusChanged();

    void subscriberKHWRMGripStatusChanged();

    void subscriberKCTsyCallStateChanged();

    void subscriberKSecurityUIsDismissDialogChanged();

    void subscriberKSecurityUIsTestCodeChanged();

private slots:

    void activeKeyguard();

    void notActiveKeyguard();

    void activeDevicelock();

    void notActiveDevicelock();

    void switchScreensaverMode( int mode );

    void switchScreensaverToPowerSaveMode();

    void handleMessageFromScreensaver( const QVariantMap &data );

    void handleScreensaverClosed();

private:

    int handleLockSwitch();

private:

    AutolockService* mService;

    // int mKeyCode;

    // int mKeyCaptureHandle;

    QValueSpaceSubscriber *subscriberKSettingsAutolockStatus;

    QValueSpaceSubscriber *subscriberKSettingsAutoLockTime;

    QValueSpaceSubscriber *subscriberKSettingsAutomaticKeyguardTime;

    QValueSpaceSubscriber *subscriberKDisplayLightsTimeout;

    QValueSpaceSubscriber *subscriberKProEngActiveProfile;

    QValueSpaceSubscriber *subscriberKAknKeyguardStatus;

    QValueSpaceSubscriber *subscriberKCoreAppUIsAutolockStatus;

    QValueSpaceSubscriber *subscriberKHWRMGripStatus;

    QValueSpaceSubscriber *subscriberKCTsyCallState;

    QValueSpaceSubscriber *subscriberKSecurityUIsDismissDialog;

    QValueSpaceSubscriber *subscriberKSecurityUIsTestCode;

		AutolockUserActivityService* serviceKeyguard;

		AutolockUserActivityService* serviceDevicelock;

		int iLockStatus;

		int iLockStatusPrev;

		CSecQueryUi *iSecQueryUi;

		int iSecQueryUiCreated;	// not used

		HbDeviceDialog *iDeviceDialog;

		int iDeviceDialogStatus;

    TInt32 mPowerKeyCaptureHandle;

    TInt32 mApplicationKeyCaptureHandle;

    TInt32 mApplicationLongKeyCaptureHandle;

    TInt32 mEKeyDeviceFCaptureHandle;

    TInt32 mEKeyBellCaptureHandle;

    TInt32 mEKeyYesCaptureHandle;

    TInt32 mEKeyNoCaptureHandle;

    TBool iLockCodeQueryInDisplay;

    QTimer *mScreensaverModeTimer;

    // these two are handled now directly by screensaver

    // CPowerSaveDisplayMode *mScreensaverPowerSave;

    // HBufC16 *mScreensaverPowerSavePixelBuffer;

    TInt32 iProcessingEvent;

		int iTempDisableOnlyKeyguardBecauseIncomingCall;

};

class AutolockService : public XQServiceProvider

{

    Q_OBJECT

public:

    AutolockService( Autolock *parent = 0 );

    ~AutolockService();

    void complete(QString number);

    bool asyncAnswer() {return mAsyncAnswer;}

public slots:

    int service(const QString& number, const QString& aParam1, const QString& aParam2 );

private slots:

   void handleClientDisconnect();

private:

    Autolock* mAutolock;

    QString mNumber;

    bool mAsyncAnswer;

    int mAsyncReqId;

};

class  CWait : public CActive

    {

     public:

       /**

        * Creates instance of the CWait class.

        *

		* @return Returns the instance just created.

        */

		static CWait* NewL();

		/**

        * Destructor.

        */

        ~CWait();

    public:

        /**

		* Starts waiting for aReqStatus. 

		*/

		TInt WaitForRequestL();

    public:

        /**

        * Sets active request type. 

        */

        void SetRequestType(TInt aRequestType);

        /**

        * Gets active request type. 

        */

        TInt GetRequestType();

	private:

		/**

		* C++ default constructor.

		*/

		CWait();

		/**

		* Symbian OS constructor.

		*/

		void ConstructL();

	private: // from CActive

        /** @see CActive::RunL() */

		void RunL();

		/** @see CActive::DoCancel() */

        void DoCancel();

		RTimer iTimer;

		CActiveSchedulerWait iWait;

		// Used if there is a need to cancel an active request;

        // namely in situations where destructor is called when Wait

        // is active.

        TInt iRequestType;

	};

#endif // AUTOLOCK_H