/*------------------------------------------------------------------

 -

 * Software Name : UserEmulator

 * Version       : v4.2.1309

 * 

 * Copyright (c) 2009 France Telecom. All rights reserved.

 * This software is distributed under the License 

 * "Eclipse Public License - v 1.0" the text of which is available

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

 *

 * Initial Contributors:

 * France Telecom 

 *

 * Contributors:

 *------------------------------------------------------------------

 -

 * File Name: GlobalCapturer.cpp

 * 

 * Created: 13/08/2009

 * Author(s): Marcell Kiss, Reshma Sandeep Das

 *   

 * Description:

 * Key capturing class

 *------------------------------------------------------------------

 -

 *

 */

// System Includes

#include <e32base.h>

#include <e32std.h>

#include <e32cons.h>

#include <aknnotewrappers.h>

#include <apgwgnam.h>

#include <eikenv.h>

#include <apgtask.h>

#include <APGCLI.H>

#include <W32STD.H>

#include <bautils.h>

// User Includes

#include <UserEmulator_0x2001C3AF.rsg>

#include "GlobalCapturer.h"

#include "UserEmulatorApplication.h"

// Constants

const TUid KUidStandBy = { 0x102750f0 };

const TUint KKeyCodePowerKey  	= EKeyDevice2;

const TUint KCameraKey 			= 0xF887;

const TUint KEndKeyScanCode 	= 197;

const TInt KCaptureMaxPriority = 11;

const TInt KAppInfoLength = 10;

const TInt KZeroAscii = 48;

const TInt KZedAscii = 122;

const TInt KDotAscii = 46;

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

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

// CGlobalCapturer::CGlobalCapturer

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

//

CGlobalCapturer::CGlobalCapturer(MKeyObserver& aObserver, CSettings& aSettings, TBool& aScriptRun, 

		TBool& aRandomTestStarted, RClientCommander& aClientCommander, CEikonEnv* aEikonEnv, RApaLsSession& aSession) :

		CActive( EPriorityNormal ),iObserver(aObserver),iSettings(aSettings), iScriptRun(aScriptRun),

		iRandomTestStarted(aRandomTestStarted),iClientCommander(aClientCommander), iEEnv(aEikonEnv), iSession(aSession)

{

}

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

// CGlobalCapturer::NewL

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

//

CGlobalCapturer* CGlobalCapturer::NewL(MKeyObserver& aObserver, CSettings& aSettings, TBool& aScriptRun, 

		TBool& aRandomTestStarted, RClientCommander& aClientCommander, CEikonEnv* aEikonEnv,RApaLsSession& aSession)

	{

	CGlobalCapturer* me = new (ELeave) CGlobalCapturer(aObserver,aSettings,aScriptRun, 

			aRandomTestStarted,aClientCommander,aEikonEnv,aSession);

	CleanupStack::PushL(me);

	me->ConstructL();

	CleanupStack::Pop(me);

	return me;

	}

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

// Symbian 2nd phase constructor

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

//

void CGlobalCapturer::ConstructL(void)

	{

	iRecord = EFalse;

	iKeyCaptureStart = EFalse;

	iCameraAppTimer = CCameraAppTimer::NewL(*this);

	}

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

// Destructor

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

//

CGlobalCapturer::~CGlobalCapturer()

{

	Cancel();			

	delete iWindowGroup;

	iWsSession.Close();

	iFs.Close();

	if(iCameraAppTimer)

		{

	    delete iCameraAppTimer;

	    iCameraAppTimer = NULL;

	    }

}

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

// CActive cancel function

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

//

void CGlobalCapturer::DoCancel()

{	

	if ( IsActive() )

	{

		iWsSession.EventReadyCancel();

	}

}

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

// Initialise key capturing

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

//

void CGlobalCapturer::StartCapturingL() 

{

	// Connect to the window server

	User::LeaveIfError( iWsSession.Connect() );

	// Create an invisible window group. Well, we'll make it invisible later

	iWindowGroup = new (ELeave) RWindowGroup ( iWsSession );

	iWindowGroup->Construct( (TUint32)iWindowGroup, EFalse );

	CApaWindowGroupName* wn;

	wn=CApaWindowGroupName::NewLC(iWsSession);

	wn->SetHidden(ETrue);

	wn->SetWindowGroupName(*iWindowGroup);	

	CleanupStack::PopAndDestroy(wn);

	CActiveScheduler::Add( this );

}

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

// Starts capturing Power button key presses

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

//

void CGlobalCapturer::StartL()

{ 

    User::LeaveIfError( iCaptureHandle1 = iWindowGroup->CaptureKey( EKeyDevice2, 0, 0, KCaptureMaxPriority ) );	

	// Tell window server we are ready to receive events

	if ( !IsActive() )

	{

		iWsSession.EventReady( &iStatus );

		SetActive();

	}		

}

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

// Stops capturing Power button key presses

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

//

void CGlobalCapturer::Stop()

{

		Cancel();

		iWindowGroup->CancelCaptureKey( iCaptureHandle1 );

}

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

// CActive RunL function. Called when a key press happened

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

//

void CGlobalCapturer::RunL()

{

	if( iStatus == KErrNone ) 	

	{

		TWsEvent we;

		iWsSession.GetEvent( we );

		iKeyEvent=we.Key();

		CApaWindowGroupName* gn = CApaWindowGroupName::NewLC(iEEnv->WsSession(), iEEnv->WsSession().GetFocusWindowGroup());

		TUid foreTaskUid = gn->AppUid();

		CleanupStack::PopAndDestroy(gn);

		// Stops key recording

		if(iKeyEvent->iCode == EKeyDevice2 && iRecord)

			{

			StopRecordKeysL();

			return;

			}

		// Stops random tests

		else if(iKeyEvent->iCode == EKeyDevice2 && iRandomTestStarted)

			{

			iObserver.RandomTestEndsL();

			return;

			}

		// Stops running scripts

		else if(iKeyEvent->iCode == EKeyDevice2)

			{

			Stop();

			iObserver.TerminationKeyReceived();

			return;

			}

		// Send event to the application which is in foreground			

		TInt appId = iEEnv->WsSession().GetFocusWindowGroup();

		iEEnv->WsSession().SendEventToWindowGroup(appId, we);											

		if ( !IsActive() )

		{

			iWsSession.EventReady( &iStatus );

			SetActive();

		}		

	}

}

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

// Checks if camera app is in memory or not

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

//

void CGlobalCapturer::CheckCameraAppL()

{

    _LIT8(KDecimal,"%d");

    _LIT8(KAsterisk,"*");

	// Get foreground app's name

	CApaWindowGroupName* gn = CApaWindowGroupName::NewLC(iEEnv->WsSession(),iEEnv->WsSession().GetFocusWindowGroup());

	TApaAppInfo appInfo;

	RApaLsSession ApaLs;

	User::LeaveIfError(ApaLs.Connect());

	ApaLs.GetAppInfo(appInfo, gn->AppUid());

	// Store length!

	iAppName.Format(KDecimal,appInfo.iCaption.Length());

	if(appInfo.iCaption.Length()<KAppInfoLength)

		iAppName.Append(KAsterisk);

	iAppName.Append(appInfo.iCaption);

	CleanupStack::PopAndDestroy(gn);

	ApaLs.Close();

	iAppName.ZeroTerminate();

	TPtrC8 ptr;

	ptr.Set(iAppName);

	// Poll. (And send foreground app's name) 

	if( iClientCommander.AnimCommand( RClientCommander::EPoll, &ptr) == 1 )

	{

		TUid CamId;

		CamId = KUidCamera;

		TApaTaskList taskList(iEEnv->WsSession());

		TApaTask task = taskList.FindApp(CamId);

		if (task.Exists())

			task.EndTask();

		else

		  iClientCommander.AnimCommand( RClientCommander::ETaskExisted, NULL);

	}

	// Restart camera app timer

	iCameraAppTimer->After(KWait08); // 0.8 sec

}

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

// Filters not appropriate characters

// Allows only chars. from 0 to z and '.'

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

//

TBool CGlobalCapturer::StrictFileNameCheck(const TDesC& aFileName)

{

	TBool res=ETrue;

	for(TInt t=0;t<aFileName.Length();t++)

	{

		const TUint16* a=aFileName.Mid(t,1).Ptr();

		if((*a<KZeroAscii || *a>KZedAscii) && *a!=KDotAscii) // 46 -> '.'

			res=EFalse;

	}

	return res;

}

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

// Starts key record with Windows server dll

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

//

TInt CGlobalCapturer::StartRecordKeysL()

	{

	// Checks if there's another process started

	if(!iRecord && !iScriptRun && !iKeyCaptureStart)

		{

		_LIT16(Ktitle,"Output file name?");

		TBuf16<KBuffer256> aBuffer;

		TBool exit = EFalse;

		while(!exit)

        {

          // Asks for output file name

		  CAknTextQueryDialog* Dialog = CAknTextQueryDialog::NewL(aBuffer,CAknQueryDialog::ENoTone); 

		  Dialog->PrepareLC(R_FILE_DIALOG); 

		  Dialog->SetPromptL(Ktitle); 

		  if(Dialog->RunLD())

			{

				iBuf8.Copy(iSettings.iScriptsPath);

				TInt a = iBuf8.LocateReverse('\\');

				if(a!=KErrNotFound)

				{

				iBuf8 = iBuf8.Left(a+1);

				}

				iBuf8.Append(aBuffer);

				if(iBuf8.LocateReverse('.')==KErrNotFound)

				{

			    _LIT(Kxml,".xml");

			    iBuf8.Append(Kxml);

			    }

				TBuf<KBuffer512> TempPath;

				TempPath.Copy(iBuf8);

				// Validate file name

				if(iEEnv->FsSession().IsValidName(TempPath) && StrictFileNameCheck(aBuffer))

				{

					exit = ETrue;

				}

				else

				{

				    _LIT(KInvalid,"Invalid file name! Please try again.");

					CAknErrorNote* errorNote = new (ELeave) CAknErrorNote(ETrue);

					errorNote->ExecuteLD(KInvalid);

					continue;

				}

				User::LeaveIfError(iFs.Connect());

				// If file exists then overwrite it or not?

				TBool overwrite=ETrue;

				TBuf16<KBuffer512> TempiBuf8;

				TBuf16<KBuffer8> empty;

				TempiBuf8.Copy(iBuf8);

				if(BaflUtils::FileExists(iFs, TempiBuf8))

				{

					_LIT8(Kk,"Overwrite existing file?");

					_LIT8(Kk1,"");

					TempiBuf8.Copy(Kk);

					empty.Copy(Kk1);

					if(iEEnv->QueryWinL(TempiBuf8,empty))

						overwrite = ETrue;

					else

						overwrite = EFalse;

				}

				iFs.Close();

				if(overwrite)

				{

					TPtrC8 ptr;

					ptr.Set(iBuf8);

					// Starts all event capture with the Window server object!

					TInt res=iClientCommander.AnimCommand( RClientCommander::EStart, &ptr);

					if(res==1)

					{

					    _LIT(KWritingError,"Script file writing error. Drive might be locked");

						CAknErrorNote* errorNote = new (ELeave) CAknErrorNote(ETrue);

						errorNote->ExecuteLD(KWritingError);

						return 1;

					}

					else

					{

                       TBuf<KBuffer64> buff;

                       _LIT(KWait,"Wait. Script recording will start from the Idle screen..");

                       CAknConfirmationNote* note = new (ELeave) CAknConfirmationNote(ETrue);

                       buff.Copy(KWait);

                       note->ExecuteLD(buff);

                       User::After(KWait02);

					   // Closes apps (there are exceptions) as a reset

					   KillUnwantedAppsResetL();

					   // Starts wait timer

                       iClientCommander.AnimCommand( RClientCommander::EStartTiming, NULL);

					   // Resets menu screen

					   if(ScreenReset()!=KErrNone)

						  return 1;

					   iKeyCaptureStart = ETrue;				

					   iRecord = ETrue;

	                   // Starts Power button capturing

					   StartL();

					   // Starts camera app timer

					   iCameraAppTimer->After(KWait05); // 0.5 sec

					}	

				}

			}

			else

				return 1;

		  }// while end

		}

	else

		{

		_LIT(KRunning,"A script or recording is already running!");

		CAknErrorNote* errorNote = new (ELeave) CAknErrorNote(ETrue);

		errorNote->ExecuteLD(KRunning);

		return 1;

		}

	return 0;

	}

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

// Closes Menu screen and resets idle screen by two No key presses

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

//

TInt CGlobalCapturer::ScreenReset()

	{

	// Reset Menu app.

	TApaTaskList taskList(iEEnv->WsSession());

	TApaTask task = taskList.FindApp(KUidMenu);

	task.EndTask();

	//Brings 'Menu' to foreground and resets screen selecting 'Exit'

	TApaTaskList taskList2(iEEnv->WsSession());

    TApaTask task2 = taskList2.FindApp(KUidHomeScreen); //? old phones

    task2.BringToForeground();

    User::After(KWait1);

    TRawEvent lEventDown;

    TRawEvent lEventUp;

    // No key press (Idle screen reset!) //? old phones (No key opens a menu on old phones)

    lEventDown.Set(TRawEvent::EKeyDown, KEndKeyScanCode); // No key

    UserSvr::AddEvent(lEventDown);

    User::After(KWait01);               

    lEventUp.Set(TRawEvent::EKeyUp, KEndKeyScanCode);                       

    UserSvr::AddEvent(lEventUp);

    User::After(KWait1);

	return KErrNone;

	}

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

// Kills applications in the background except apps which has to run

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

//

void CGlobalCapturer::KillUnwantedAppsResetL()

	{	

    TInt numWindowGroups = iEEnv->WsSession().NumWindowGroups();

    CArrayFixFlat<TInt>* windowGroupList = new(ELeave) CArrayFixFlat<TInt>(numWindowGroups);

    CleanupStack::PushL(windowGroupList);

    // Populate array with current group list ids

    User::LeaveIfError(iEEnv->WsSession().WindowGroupList(windowGroupList));

    CApaWindowGroupName* windowGroupName = CApaWindowGroupName::NewLC(iEEnv->WsSession());

    for (TInt i = 0; i < numWindowGroups; ++i)

    	{

        TInt wgId = windowGroupList->At(i);

        windowGroupName->ConstructFromWgIdL(wgId);

        TUid Uid = windowGroupName->AppUid();

        TInt32 appUid = Uid.iUid;

        // Exceptions

        if(appUid != KUidMenu.iUid && appUid != KUidPanicCapturer.iUid && appUid != KUidUserEmulatorApp.iUid &&

        		appUid != KUidHomeScreen.iUid && appUid != KUidAknCapServer.iUid &&

                   		appUid != KUidAknnfySrv.iUid && appUid != KUidTelephony.iUid && 

appUid != KUidPenInputSrv.iUid )

        	{

			// Only list 'visible' applications

			if (!windowGroupName->Hidden() && !windowGroupName->IsBusy() && !windowGroupName->IsSystem())

				{

				TApaTaskList taskList(iEEnv->WsSession());

				TApaTask task = taskList.FindApp(Uid);

				if (task.Exists())

					{

					task.EndTask();

					User::After(KWait005);

					}

				}

        	}

    	}

    CleanupStack::PopAndDestroy(2);

	}

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

// Notifies Window server object to stop capturing

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

//

void CGlobalCapturer::StopRecordKeysL()

{

	iKeyCaptureStart = EFalse;

	// Call client commander which calls server side object

	iClientCommander.AnimCommand( RClientCommander::EStop, NULL);

	// Cancels camera app timer

	iCameraAppTimer->Cancel();

	// Stop Power button capturing

	Stop();

	if(iRecord)

		iRecord = EFalse;

	// Bring this app to foreground

	iObserver.BringUserEmulatorToFront();

	// Display acknowledgement

	CAknInformationNote* note = new (ELeave) CAknInformationNote(ETrue);

	TBuf<KBuffer64> buff;

	_LIT(KCapturingEnded, "Capturing ended");

	buff.Format(KCapturingEnded);

	note->ExecuteLD(buff);

}

// End of file