/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include <apgtask.h>

#include <etelmm.h>

#include <AknEcs.h>

#include <aknnotedialog.h>

#include <aknkeylock.h>

#include <AknLayoutDef.h>

#include <AknLayout.lag>

#include <bldvariant.hrh>

#include <aknappui.h> 

#include <centralrepository.h>

#include <settingsinternalcrkeys.h>

#include <secuisecurityhandler.h>

#include <secui.h>

#include <featmgr.h>

#include <Autolock.rsg>

#include <mmtsy_names.h>

#include <e32property.h>

#include <PSVariables.h>   // Property values

#include <coreapplicationuisdomainpskeys.h>

#include <startupdomainpskeys.h>

#include <ctsydomainpskeys.h>

#include <securityuisprivatepskeys.h>

#include <AknSgcc.h>

#include "AutolockAppUiPS.h"

#include "AutoLockValueObserverPS.h"

#include "AutoLockModelPS.h"

#include "AutolockApp.h"

#include "autolock.hrh"

#include "AutolockView.h"

#include <SCPClient.h>

#include <AknSoftNotifier.h>

// sysap uid and message enums defined in eikon.hrh

// for sending messages to sysap

#include <eikon.hrh>

#include <apgwgnam.h>

#include <aknlayoutscalable_avkon.cdl.h>

//  LOCAL CONSTANTS AND MACROS  

#define KSysApUid TUid::Uid(0x100058F3)

const TInt KTriesToConnectServer( 2 );

const TInt KTimeBeforeRetryingServerConnection( 50000 );

const TInt PhoneIndex( 0 );

// ================= MEMBER FUNCTIONS =======================

//

// ----------------------------------------------------------

// CAutolockAppUi::ConstructL()

// ?implementation_description

// ----------------------------------------------------------

//

void CAutolockAppUi::ConstructL()

    {

	#if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL"));

    #endif

    BaseConstructL( EAknEnableSkin | EAknEnableMSK );

	}

// ----------------------------------------------------

// CAutolockAppUi::~CAutolockAppUi()

// Destructor

// Frees reserved resources

// ----------------------------------------------------

//

CAutolockAppUi::~CAutolockAppUi()

    {

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::~CAutolockAppUi() BEGIN"));

    #endif

    if(iWait)

        {

        // Cancel active requests

        if(iWait->IsActive())

            {

            #if defined(_DEBUG)

	        RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::~CAutolockAppUi() CANCEL REQ"));

	        #endif

            iPhone.CancelAsyncRequest(iWait->GetRequestType());

            }

        }

    //close ETel connections

    if (iCustomPhone.SubSessionHandle())

        iCustomPhone.Close();

    if (iPhone.SubSessionHandle())

    	iPhone.Close();

    if (iServer.Handle())

        {           

        iServer.UnloadPhoneModule(KMmTsyModuleName);

        iServer.Close();

        }

	delete iModel;

	delete iPhoneObserver;

	delete iIncallBubble;

	delete iKeyguardObserver;

#endif

    delete iEcsDetector;

    delete iEcsNote; // Ecs change

    FeatureManager::UnInitializeLib();

    delete iGripStatusObserver;

    delete iFpsStatusObserver;

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::~CAutolockAppUi() END"));

    #endif

// ----------------------------------------------------

// CAutolockAppUi::HandleForegroundEventL()

// Handles foreground event.

// ----------------------------------------------------

//

void CAutolockAppUi::HandleForegroundEventL(TBool aForeground)

	{

	#if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleForegroundEventL()"));

    #endif

	if (aForeground )

		{

		if (iLocked)

			{

			// lock voice key 

			LockSideKeyL();			

			}

		else

			{

			// app back to background

			TApaTask self(iCoeEnv->WsSession());

			self.SetWgId(iCoeEnv->RootWin().Identifier());

			self.SendToBackground();

			}

		}

	if (!aForeground && iLocked)

		{

        TInt callState=0;

        TInt simStatus=0;

        RProperty::Get(KPSUidCtsyCallInformation, KCTsyCallState, callState );

        RProperty::Get(KPSUidStartup, KPSSimStatus, simStatus);

        if (callState == EPSCTsyCallStateNone && simStatus != ESimNotPresent)

			{	

			// try put autolock back to foreground

			TApaTask self(iCoeEnv->WsSession());

			self.SetWgId(iCoeEnv->RootWin().Identifier());

			self.BringToForeground();		

			}

		else

			{

			// unlock voice key while there is active call

			UnLockSideKey();

			}

		}

	CAknAppUi::HandleForegroundEventL(aForeground);

	}

// ----------------------------------------------------

// CAutolockAppUi::HandleMessageL

//

// Handles the TARM command to unlock the phone.

// ----------------------------------------------------

//	

MCoeMessageObserver::TMessageResponse CAutolockAppUi::HandleMessageL( 

                                TUint32 aClientHandleOfTargetWindowGroup, 

                                TUid aMessageUid, 

                                const TDesC8& aMessageParameters 

                               )

    {

    	if(!FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ))  

    	{

    		User::Leave(KErrNotSupported);

    	}

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleMessageL()"));

    #endif

    MCoeMessageObserver::TMessageResponse messageResponse( EMessageHandled );

    if ( aMessageUid.iUid == SCP_CMDUID_UNLOCK )

        {        

        // For security reasons we must check from the SCP server did this 

        // command originate from it.                                

        RSCPClient scpClient;

        if ( scpClient.Connect() == KErrNone )

            {

            CleanupClosePushL( scpClient );

            if ( scpClient.QueryAdminCmd( ESCPCommandUnlockPhone ) )

                {

                // Switch autolock to BG

                #if defined(_DEBUG)

                RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleMessageL():\

                    Admin command received, unlocking"));

                #endif            

                if ( !iLocked )

                    {

                    #if defined(_DEBUG)

                    RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleMessageL():\

                        Ignoring Unlock message - not locked."));

                    #endif            

                    }   

                else

                    {

                    iLocked = EFalse;

                  DisableWGListChangeEventListening();  

	                UnLockKeys();

	                iModel->SetLockedL(EFalse);

			// Disable keyguard after remote unlock

	                RAknKeyLock iKeyLock;

	                TInt tempResult = iKeyLock.Connect();

	                iKeyLock.DisableKeyLock();

	                // end Disable keyguard after remote unlock

	                SwitchToPreviousAppL();

                    }   

                }           

            else

                {

                #if defined(_DEBUG)

                RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleMessageL():\

                    Unauthorized attempt to unlock"));

                #endif

                }

            CleanupStack::PopAndDestroy(); // scpClient                               

            }

        else

            {          

            #if defined(_DEBUG)

            RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleMessageL():\

                Failed to connect to SCP, ignoring unlock-message."));

            #endif            

            }

        }               

    else // aMessageUid.iUid != SCP_CMDUID_UNLOCK 

        {

        messageResponse = CAknAppUi::HandleMessageL( aClientHandleOfTargetWindowGroup, 

                                                     aMessageUid,

                                                     aMessageParameters

                                                   );

        }

    return messageResponse;

    }

// ------------------------------------------------------------------------------

// CAutolockAppUi::::DynInitMenuPaneL(TInt aResourceId,CEikMenuPane* aMenuPane)

//  This function is called by the UIKON framework just before it displays

//  a menu pane. Its default implementation is empty, and by overriding it,

//  the application can set the state of menu items dynamically according

//  to the state of application data.

// ------------------------------------------------------------------------------

//

void CAutolockAppUi::DynInitMenuPaneL(

    TInt /*aResourceId*/,CEikMenuPane* /*aMenuPane*/)

    {

    }

void CAutolockAppUi::HandlePointerEventL(const TPointerEvent& aPointerEvent)

    {

    RDebug::Printf( "%s %s (%u) value=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, 0 );

		}

// ----------------------------------------------------

// CAutolockAppUi::HandleKeyEventL(

//     const TKeyEvent& aKeyEvent,TEventCode /*aType*/)

// ----------------------------------------------------

//

TKeyResponse CAutolockAppUi::HandleKeyEventL(

    const TKeyEvent& aKeyEvent,TEventCode aType)

    {

	if ( aKeyEvent.iCode == EKeyBell)

 		{

 		HandleCommandL(ESecUiCmdUnlock);

 		return EKeyWasConsumed; 

 		}

    TBool featureNoPowerkey = FeatureManager::FeatureSupported( KFeatureIdNoPowerkey );

    // If power key pressed, tell SysAp about if

    if( (aKeyEvent.iScanCode == EStdKeyDevice2 && aType == EEventKeyDown )

        || (aType == EEventKey && featureNoPowerkey && aKeyEvent.iCode == EKeyNo))

        {

        SendMessageToSysAp(EEikKeyLockPowerKeyPressed);

        if ( featureNoPowerkey )

            {

            SendMessageToSysAp(EEikKeyLockLightsOnRequest);              

            }

        }

    return EKeyWasNotConsumed;

    }

void CAutolockAppUi::SendMessageToSysAp(TInt aMessage)

    {

    RWsSession& ws = iEikonEnv->WsSession();

    TInt wgId=0;

    CApaWindowGroupName::FindByAppUid(KSysApUid, ws, wgId);

    if (wgId)

        {

        TWsEvent event;

        event.SetType(aMessage);

        event.SetTimeNow();

        ws.SendEventToWindowGroup(wgId, event);

        }

    }

// ----------------------------------------------------

// HideSoftNotification()

// dismiss all the pending notes just before asking the unlocking code

// ----------------------------------------------------

//

void HideSoftNotification()

    {

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)HideSoftNotification"));

    #endif

    CAknSoftNotifier *softNotifier = NULL;

    TRAPD (err, {

            softNotifier = CAknSoftNotifier::NewL();

            softNotifier->AddNotificationL(ESetIdleState, 0);

    };)

    delete softNotifier;

    }

// CAutolockAppUi::HandleCommandL(TInt aCommand)

// ----------------------------------------------------

//

void CAutolockAppUi::HandleCommandL(TInt aCommand)

    {

	#if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleCommandL()"));

    #endif

	switch ( aCommand )

        {

        case EEikCmdExit:

			{

			#if defined(_DEBUG)

			RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleCommandL() EEikCmdExit"));

			#endif

            Exit();

            break;

			}

        case ESecUiCmdUnlock:

			{

			break;

			}

        default:

            break;      

        } 

    }

// ----------------------------------------------------

// CAutolockAppUi::SwitchToPreviousAppL()

// Activates previous app 

//----------------------------------------------------

//

void CAutolockAppUi::SwitchToPreviousAppL()

	{

	#if defined(_DEBUG)

	RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::SwitchToPreviousAppL()"));

	#endif

	iEcsDetector->Reset(); // Ecs queue is cleared; keys up til here are forgotten

	// stop observing phone events

	iPhoneObserver->Stop();

	CAknView* view = View(KAutoLockViewId);

	if(view)

	  {

	  STATIC_CAST(CAutolockView*, view)->MakeVisible(EFalse);

	  }

	else

	  {

	  #if defined(_DEBUG)

	  RDebug::Printf( "%s %s (%u) no view ????=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, view );

	  #endif

	  }

	// app to background

	TApaTask self(iCoeEnv->WsSession());

	self.SetWgId(iCoeEnv->RootWin().Identifier());

	self.SendToBackground();

	// flush

	iCoeEnv->WsSession().Flush();

	}

// ----------------------------------------------------

// CAutolockAppUi::BringAppToForegroundL()

// Activates autolock app

//----------------------------------------------------

//

void CAutolockAppUi::BringAppToForegroundL()

	{

	#if defined(_DEBUG)

	RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::BringAppToForegroundL()"));

	#endif

	TBool tarmAdminFlag(EFalse);

	TBool remotelockState(EFalse);

if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ))

{

    tarmAdminFlag = TarmState();

}

#ifdef RD_REMOTELOCK

        TInt autolockState;

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

        remotelockState = (autolockState == ERemoteLocked);           

#endif//RD_REMOTELOCK

	// If TARM admin flag is set, bring Autolock to foreground regardless of call state.

	if(!tarmAdminFlag)

	{   //If phone has been remote locked bring Autolock to foreground regardless of call state.

	    if(!remotelockState)

	    {   // check if there is active call

    	    TInt callState;

    	    RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallState, callState );

            if (callState != EPSCTsyCallStateNone )

                {

    		    iModel->SetLockedL(EFalse);

    		    iModel->ResetInactivityTimeout();

    		    UnLockKeys();

    		    return;

    		    }   

	    }

	}

	#ifndef __WINS__

	#ifndef __NO_DOS__

		/*****************************************************

		*	Series 60 Customer / ETEL

		*	Series 60 ETEL API

		*****************************************************/

	// check that device locked in DOS side too

	RMobilePhone::TMobilePhoneLock lockType = RMobilePhone::ELockPhoneDevice;

	RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;

	RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPkg(lockInfo);

	#if defined(_DEBUG)

	RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::BringAppToForegroundL() GetLockInfo"));

	#endif

	iWait->SetRequestType(EMobilePhoneGetLockInfo);

	iPhone.GetLockInfo(iWait->iStatus, lockType, lockInfoPkg);

	TInt res = iWait->WaitForRequestL();

	User::LeaveIfError(res);

	if (iWait->iStatus == KErrNone)

		{

		// if not don't lock ui either

		#if defined(_DEBUG)

		RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::BringAppToForegroundL() KErrNone"));

		#endif

		if (lockInfo.iSetting == RMobilePhone::ELockSetDisabled)

			{

			iModel->SetLockedL(EFalse);

			UnLockKeys();

			return;

			}

		}

	#endif

	#endif

	// in case Telephone-app is topmost, then the user is confused because he sees but can't use it.

	// therefore it's required to hide it, by sending to background. ETMA-7M8A2Y 20090105

	if ( AknLayoutUtils::PenEnabled() )

     	{ 		

   			TApaTaskList apaTaskList(CCoeEnv::Static()->WsSession());

   			#define KPhoneAppUid TUid::Uid(0x100058B3)

   			TApaTask apaTask = apaTaskList.FindApp(KPhoneAppUid);

   			if (apaTask.Exists())

       	{

			 		#if defined(_DEBUG)

			 			RDebug::Print(_L("(AUTOLOCK)CAknKeyLockControl::EnableKeylock() Bring phone to background"));

			 		#endif

       		// Bring phone to background

       		apaTask.SendToBackground();

       	}

			}	

	iPhoneObserver->Start();

	iLocked = ETrue;

	// app to foreground	

	TApaTask self(iCoeEnv->WsSession());

	self.SetWgId(iCoeEnv->RootWin().Identifier());

	self.BringToForeground();

	ActivateLocalViewL(KAutoLockViewId);