1 /*

     2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 

    20 #include <hal.h>

    21 

    22 #ifndef LIGHT_MODE

    23 	#include <eikenv.h>

    24 	#include <apgtask.h>	//for TApaTask usage

    25 	#include <apgwgnam.h>	//for CApaWindowGroupName usage

    26 #endif

    27 #include "assert.h"

    28 #include "stat.h"

    29 #include "statapi_commanddecoder.h"

    30 #include "keycodes.h"

    31 #include "modifiers.h"

    32 #include "statapi_DeviceInformation.h"

    33 #include "datasupplier_memory.h"

    34 #include "datasupplier_file.h"

    35 #include "dataconsumer_memory.h"

    36 #include "testshareddata.h"

    37 #include "tefshareddata.h"

    38 

    39 #ifndef LIGHT_MODE

    40 #include <s32mem.h>

    41 #include "AppInstall.h"

    42 #endif // ifndef LIGHT_MODE

    43 // This redefinition is because CTRL ends in an L and so is picked up (incorrectly) by leavescan

    44 #define	  CTRLA CTRL

    45 

    46 #define   ESTATNoMoreKeys (EStdKeyDecBrightness+1)

    47 

    48 #define	  ESMLShift		1

    49 #define	  ESMRShift		2

    50 #define	  ESMLAlt		4

    51 #define   ESMRAlt		8

    52 #define   ESMLCtrl	    16

    53 #define   ESMRCtrl	    32

    54 #define   ESMLFunc		64

    55 #define	  ESMRFunc		128

    56 

    57 const TInt KMaxSharedDataName	= 128;

    58 const TInt KMaxSharedDataString	= 1048;

    59 

    60 #ifndef LIGHT_MODE

    61 _LIT8( newLine, "\r\n" );

    62 _LIT8( driveFormat, "%c,%S,%Ld%S" );

    63 _LIT8( entryFormat, "%S,%d,%S,%d%S" );

    64 _LIT8( dateFormat, "%02d/%02d/%04d %02d:%02d" );

    65 

    66 #endif // ifndef LIGHT_MODE

    67 

    68 //-----------------------------------------------------------------------------------

    69 //constructor

    70 CStatApiCommandDecoder::CStatApiCommandDecoder()

    71 : iFs( NULL ), pMsg(NULL)

    72 {

    73 }

    74 

    75 //-----------------------------------------------------------------------------------

    76 

    77 CStatApiCommandDecoder* CStatApiCommandDecoder::NewL(RFs *const aSession, MNotifyLogMessage *const aMsg)

    78 {	

    79 	CStatApiCommandDecoder* self = new(ELeave) CStatApiCommandDecoder();

    80 

    81 	CleanupStack::PushL(self);

    82 	

    83 	self -> ConstructL(aSession, aMsg);

    84 	

    85 	CleanupStack::Pop();

    86 	

    87 	return self;

    88 }

    89 

    90 //-----------------------------------------------------------------------------------

    91 

    92 void CStatApiCommandDecoder::ConstructL(RFs *const aSession, MNotifyLogMessage *const aMsg)

    93 {

    94 #ifndef LIGHT_MODE

    95 	// Try to connect to the window session server.

    96 	// Do not leave if there is an error as we may be in a

    97 	// text only mode (text shell) and the window server is not

    98 	// available.

    99 	// We carry on for now but certain features of the command

   100 	// decoder will become 'unsupported' and will fail.

   101 	iWs.Connect();	//creation of a new windows server session

   102 	// This line is for debug purposes.

   103 	// It is replicated in the function 'IsWindowServerAvailable'.

   104 	// TInt wsHandle = iWs.WsHandle();

   105 #endif // ifndef LIGHT_MODE

   106 

   107 	iFs = aSession;

   108 	pMsg = aMsg;

   109 

   110 #ifndef LIGHT_MODE

   111 	if(IsWindowServerAvailable())

   112 		{

   113 		// Only start the font and bitmap server if we are in

   114 		// window shell mode.

   115 		User::LeaveIfError(FbsStartup());

   116 		User::LeaveIfError(RFbsSession::Connect());	//font and bitmap server

   117 

   118 		// Create the data we use for screen capture.

   119 		// Do this just once and re-use for each screen image.

   120 	    iDevice = new(ELeave) CWsScreenDevice(iWs);	//Create new bitmap

   121 	    iDevice -> Construct();

   122 

   123 		// create new bitmap

   124 		screenBitmap = new(ELeave) CWsBitmap(iWs);	//Create new bitmap

   125 

   126 		// set the display mode for the bitmap

   127 		TInt gray;	

   128 		TInt color;

   129 		TDisplayMode mode = iWs.GetDefModeMaxNumColors(color, gray);

   130 

   131 		TSize size = iDevice -> SizeInPixels();

   132 

   133 		TInt ret = screenBitmap->Create(size, mode);

   134 

   135 		if (ret != KErrNone)

   136 			{

   137 			User::Leave(ret);

   138 			}

   139 		}

   140 #endif // ifndef LIGHT_MODE

   141 

   142     HAL::Get(HALData::EMachineUid, iUIDValue);;

   143     

   144     //set system drive

   145    

   146 	TDriveNumber defaultSysDrive(EDriveC);

   147 	RLibrary pluginLibrary;

   148 	TInt pluginErr = pluginLibrary.Load(KFileSrvDll);

   149 	

   150 	if (pluginErr == KErrNone)

   151 		{

   152 		typedef TDriveNumber(*fun1)();

   153 		fun1 sysdrive;

   154 	

   155 	#ifdef __EABI__

   156 		sysdrive = (fun1)pluginLibrary.Lookup(336);

   157 	#else

   158 		sysdrive = (fun1)pluginLibrary.Lookup(304);

   159 	#endif

   160 		if(sysdrive!=NULL)

   161 			{

   162 			defaultSysDrive = sysdrive();			

   163 			}

   164 		}

   165 	pluginLibrary.Close();

   166 	

   167 	iSystemDrive.Append(TDriveUnit(defaultSysDrive).Name());

   168 	iSystemDrive.Append(KFileSeparator);

   169 

   170     

   171     

   172 

   173 	RefreshStatus( );

   174 }

   175 

   176 //-----------------------------------------------------------------------------------

   177 //destructor

   178 CStatApiCommandDecoder::~CStatApiCommandDecoder()

   179 {

   180 #ifndef LIGHT_MODE

   181 	// Clean-up objects created for screen capture.

   182      if(iDevice != NULL)

   183      {

   184          delete iDevice;

   185      }

   186  

   187     if(screenBitmap != NULL)

   188      {

   189          delete screenBitmap;

   190      }

   191 

   192      RFbsSession::Disconnect();

   193      iWs.Close();

   194 #endif // ifndef LIGHT_MODE

   195 }

   196 

   197 //------------------------------------------------------------------------------

   198 //

   199 // Do whatever the user requested

   200 //

   201 TInt CStatApiCommandDecoder::ExecuteCommand(TUint commandtype,

   202 	MDataConsumer *const aDataConsumer, MDataSupplier **aDataSupplier)

   203 {

   204 	TInt ret = KErrNone;

   205 	TInt exp = KErrNone;

   206 

   207 	TInt commandLength = 0;

   208 

   209 	if (aDataConsumer)

   210 		{

   211 		aDataConsumer->GetTotalSize(commandLength);

   212 		pMsg->Msg (_L("DECODER: Decoding [%c] with [%d] bytes of data"), commandtype, commandLength);

   213 		}

   214 	else

   215         {

   216 		pMsg->Msg (_L("DECODER: Decoding [%c]"), commandtype);

   217         }

   218 

   219 	// make local copy but not for raw data (Transfer file command), Keypress or WriteTEFSharedData

   220 	command.Zero();

   221 	if (commandtype != 'T' && commandtype != 'K' && commandtype != 'O' &&

   222 		aDataConsumer && commandLength)

   223 		{

   224 		command.Copy( *(aDataConsumer) );

   225 		}

   226 

   227 	// Screen saver activates regardless of activity.

   228 	// Will check for navigation and keypresses here and reset the 

   229 	// inactivity timer.

   230 	// Ultimately, this should be handled by lower layer key 

   231 	// event processing.

   232 	if (commandtype == 'K' || commandtype == 'L' || 

   233 		commandtype == 'M' || commandtype == 'H')

   234 	{

   235 		User::ResetInactivityTime();

   236 	}

   237 

   238 	// Check if we are doing a command that depends upon the

   239 	// window session server or the application architecture

   240 	// (which may not be available if we are in text shell mode).

   241 	// If there is no window server or application architecture

   242 	// then we do not support:

   243 	// SendText, SendSystemKey, SendCombinationKeys,

   244 	// SendKeyHold, StopApplicationL, OpenIcon,

   245 	// OpenFile, StartESHell, Screenshot and

   246 	// StartApplication.

   247 	if (commandtype == 'K' || commandtype == 'L' || 

   248 		commandtype == 'M' || commandtype == 'H' ||

   249 		commandtype == 'C' || commandtype == 'I' ||

   250 		commandtype == 'F' || commandtype == '!' ||

   251 		commandtype == 'A' || commandtype == 'S' )

   252 		{

   253 

   254 		if( ! IsWindowServerAvailable())

   255 			{

   256 			ret = KErrNotSupported;

   257 			}

   258 		}	

   259 

   260 	if(ret == KErrNone)

   261 		{

   262 		//check message header type

   263 		switch (commandtype)

   264 			{

   265 

   266 			case ('K'):

   267 				{

   268                 if (aDataConsumer && commandLength)

   269                     {

   270 					ret = SendText(aDataConsumer, commandLength);

   271                     }

   272 				}

   273 				break;

   274 			case ('L'):

   275 				ret = SendSystemKeys();

   276 				break;

   277 			case ('M'):

   278 				ret = SendCombinationKeys();

   279 				break;

   280 			case ('H'):

   281 				ret = SendKeyHold();

   282 				break;

   283 			case ('A'):

   284 				TRAP( exp, (ret = StartApplicationL()) );

   285 				ret = ((exp != KErrNone) ? exp : ret);

   286 				break;

   287 			case ('J'):

   288 				TRAP( exp, (ret = StartProgramL(aDataSupplier)) );

   289 				ret = ((exp != KErrNone) ? exp : ret);

   290 				break;

   291 			case ('C'):

   292 				TRAP(ret, StopApplicationL());

   293 				break;

   294 			case ('F'):

   295 				TRAP( exp, (ret = OpenFileL()) );

   296 				ret = ((exp != KErrNone) ? exp : ret);

   297 				break;

   298 			case ('I'):

   299 				ret = OpenIcon();

   300 				break;

   301 			case ('!'):

   302                 if(command.Length() == 0)

   303                     {

   304                     TRAP(ret, StartEShellL());

   305                     }

   306                 else

   307                     {

   308                     if(command == _L("!"))

   309                         {

   310                         TRAP(ret, StopEShellL());

   311                         }

   312                     }

   313 				break;

   314 			case ('U'):

   315 				TRAP( exp, ret = DeleteFileL() );

   316 				ret = ((exp != KErrNone) ? exp : ret);

   317 				break;

   318 			case ('2'):

   319                 if(aDataConsumer) 

   320                     {

   321                     TRAP( exp, ret = RenameFileL(aDataConsumer) );

   322                     ret = ((exp != KErrNone) ? exp : ret);

   323                     }

   324 				break;

   325 			case ('1'):

   326                 if(aDataConsumer)

   327                     {

   328                     ret = CheckLocation(aDataConsumer);

   329                     }

   330 				break;

   331 			case ('Y'):

   332 				ret = CreateFolder();

   333 				break;

   334 			case ('Z'):

   335 				ret = RemoveFolder();

   336 				break;

   337 			case ('T'):

   338                 if(aDataConsumer)

   339                     {

   340                     ret = TransferFile(aDataConsumer);

   341                     }

   342 				break;

   343 			case ('R'):

   344                 if(aDataConsumer)

   345                     {

   346                     ret = ReceiveFile(commandtype, aDataConsumer, aDataSupplier);

   347                     }

   348 				break;

   349 			case ('X'):

   350 			case ('S'):

   351                 if(aDataConsumer)

   352                     {

   353                     ret = ReceiveFile(commandtype, aDataConsumer, aDataSupplier);

   354                     }

   355 				//DeleteLastFile();

   356 				break;

   357 			case ('D'):

   358 				ret = DeviceInfo(aDataSupplier);

   359 				break;

   360 			case ('G'):

   361 				SaveLogFile(aDataSupplier);

   362 				break;

   363 			case ('W'):

   364 				ret = GetDiskDriveInformationL(aDataSupplier);

   365 				break;

   366 			case ('V'):

   367                 if(aDataConsumer)

   368                     {

   369                     ret = GetDirectoryInformationL(aDataConsumer, aDataSupplier);

   370                     }

   371 				break;

   372 			case ('B'):

   373 				RefreshStatus( );

   374 				break;

   375 			case ('E'):	// end of script

   376 				break;

   377 			case ('?'):	// resync command

   378 				break;

   379 			case ('N'): // Retrieve TEF shared data

   380 				TRAP( exp, ret = ReadTEFSharedDataL( aDataSupplier ) );

   381 				ret = ((exp != KErrNone) ? exp : ret);

   382 				break;

   383 			case ('O'): // Update TEF shared data

   384                 if(aDataConsumer)

   385                     {

   386                     TRAP( exp, ret = WriteTEFSharedDataL(aDataConsumer, commandLength) );

   387                     ret = ((exp != KErrNone) ? exp : ret);

   388                     }

   389 				break;

   390 			case ('|'):

   391 				//emulator restart

   392 				HAL::Set(HAL::ECustomRestart,1);

   393 				break;

   394 			case ('3'):

   395 				TRAP( exp, (ret = ProgramStatusL(command, aDataSupplier)));

   396 				ret = ((exp != KErrNone) ? exp : ret);

   397 				break;

   398 			case ('~'):

   399 				TRAP( exp, (ret = StopProgramL(command)) );

   400 				ret = ((exp != KErrNone) ? exp : ret);

   401 				break;

   402 				

   403 #ifndef LIGHT_MODE

   404 			case ('+'):	// install command

   405 				//modify the name in case doesn't contain drive

   406 				//if the filname starts with a back slash.

   407 //				if(	command.Find(KFileSeparator)== 0 )

   408 //					{

   409 //					//replace the filename with one refering to system drive

   410 //					command.Delete(0,1);

   411 //					command.Insert(0, iSystemDrive);

   412 //					}

   413 				updatePathWithSysDrive(command) ; 

   414 				ret = CAppInstall::Install(command);

   415 				break;	

   416 			case ('-'):	// uninstall command

   417 				ret = CAppInstall::Uninstall(command);

   418 				break;	

   419 #endif // ifndef LIGHT_MODE

   420 			

   421 			default:

   422 				ret = KErrNotSupported;     

   423 			}

   424 		}

   425 

   426 	// put the error code into the response

   427 	if(ret != KErrNone)

   428 		{

   429 		if(*aDataSupplier)

   430 			{

   431 			(*aDataSupplier)->Delete( );

   432 			*aDataSupplier = NULL;

   433 			}

   434 		AppendErrorCode(ret, aDataSupplier);

   435 		}

   436 

   437 	return ret;

   438 }

   439 

   440 //------------------------------------------------------------------------------

   441 //

   442 // Initialise our command handling status.

   443 //

   444 void CStatApiCommandDecoder::RefreshStatus(void)

   445 {

   446 	iName = 1;

   447 }

   448 

   449 

   450 //------------------------------------------------------------------------------

   451 //

   452 // Delete a file once we've finished with it

   453 //

   454 TInt CStatApiCommandDecoder::DeleteLastFile()

   455 {

   456 	TInt exp = KErrNone;

   457 	command = filename;

   458 	TRAP( exp, DeleteFileL(FALSE) );

   459 	return exp;

   460 }

   461 

   462 

   463 //------------------------------------------------------------------------------

   464 // Function used to decode data received and send text to an app

   465 // We need to avoid using 'command' buffer because we don't know

   466 // how big the actual data will be whereas the other commands all fit

   467 // easily into the 1024 length limit...

   468 //

   469 TInt CStatApiCommandDecoder::SendText(

   470 		MDataConsumer *const aDataConsumer, int commandLength)

   471 {

   472 	// Check we have a window server because it is needed by

   473 	// DoKeyEvent.

   474 	// If this assert triggers it is because we are running in

   475 	// text shell mode without a window server and the call

   476 	// requires the window server to be available.

   477 	// A command filter in ExecuteCommand should have prevented

   478 	// this call from being made.

   479 	assert(IsWindowServerAvailable());

   480 

   481 	TInt err = KErrNone;

   482 	TInt i = 0;

   483 

   484 	HBufC8	*keyData = HBufC8::New( commandLength );

   485 

   486 	if( ! keyData )

   487 		{

   488 		err = KErrNoMemory;

   489 		}

   490 

   491 	if( err == KErrNone )

   492 		{

   493 		err = aDataConsumer->GetData( *keyData );

   494 		}

   495 

   496 	if( err == KErrNone )

   497 		{

   498 		TBuf16<1> x;

   499 

   500 		for(i=0;i<commandLength;i++)

   501 			{

   502 			x.Zero();

   503 			x.Append((*keyData)[i]);

   504 			DoKeyEvent(static_cast<TInt>(x[0]));

   505 

   506 			// Do not delay this thread for any time but simply

   507 			// give up the rest of our time-slice to allow

   508 			// the system to process the key event.

   509 			User::After(0);

   510 			}

   511 

   512 		// Yield here to give the OS time to actually complete this command.

   513 		User::After(0);

   514 		}

   515 

   516 	if( keyData )

   517 		{

   518 		delete keyData;

   519 		keyData = NULL;

   520 		}

   521 

   522 	return (err);

   523 }

   524 

   525 

   526 //------------------------------------------------------------------------------

   527 //

   528 //Function used to decode data received and send system keys to an app (ie - Menu, LeftArrow etc)

   529 //

   530 

   531 TInt CStatApiCommandDecoder::SendSystemKeys()

   532 {

   533 #ifndef LIGHT_MODE

   534 	// If this assert triggers it is because we are running in

   535 	// text shell mode without a window server and the call

   536 	// requires the window server to be available.

   537 	// A command filter in ExecuteCommand should have prevented

   538 	// this call from being made.

   539 	assert(IsWindowServerAvailable());

   540 

   541 	TInt ret = KErrArgument;

   542 	TInt i = 0;

   543 	TBuf<140> scancodevalue = ENUM_TEXTSCANCODEArray[i];	//scancode strings stored here

   544 	TBuf<100> keycodevalue = ENUM_TEXTKEYArray[i];			//keycode strings entered here

   545 

   546 	// look for correct system command from scancodes first

   547 	while (scancodevalue.Compare(TPtrC(NO_MORE_SCANCODEKEYS)) != 0)

   548 	{

   549 		if (command.Compare(scancodevalue) == 0)

   550 		{

   551 			//send using SimulateRawEvent...

   552 			TRawEvent rawEventa;

   553 			rawEventa.Set(TRawEvent::EKeyDown, ENUM_VALSCANCODEArray[i]);

   554 			iWs.SimulateRawEvent(rawEventa);

   555 			iWs.Flush();

   556 			

   557 			rawEventa.Set(TRawEvent::EKeyUp, ENUM_VALSCANCODEArray[i]);

   558 			iWs.SimulateRawEvent(rawEventa);

   559 			iWs.Flush();

   560 

   561 			ret = KErrNone;

   562 			break;

   563 		}

   564 			

   565 		i++;	

   566 		scancodevalue = ENUM_TEXTSCANCODEArray[i];

   567 	}

   568 

   569 	//if there is no scancode then now try the remaining key codes...

   570 	if(ret != KErrNone)

   571 	{

   572 		i = 0;	//reinitialise

   573 		

   574 		while (keycodevalue.Compare(TPtrC(NO_MORE_KEYS)) != 0)

   575 		{

   576 			if (command.Compare(keycodevalue) == 0)

   577 			{

   578 				// set the event

   579 				DoKeyEvent(ENUM_VALKEYArray[i]);

   580 				ret = KErrNone;

   581 				break;

   582 			}

   583 				

   584 			i++;	

   585 			keycodevalue = ENUM_TEXTKEYArray[i];

   586 		}

   587 	}

   588 

   589 	return (ret);

   590 #else // ifndef LIGHT_MODE

   591 	return (KErrNotSupported);

   592 #endif // ifndef LIGHT_MODE

   593 }

   594 

   595 

   596 //------------------------------------------------------------------------------

   597 //

   598 //Function used to decode data received and send combination keys to the device (ie - Ctrl+S)

   599 //

   600 

   601 TInt CStatApiCommandDecoder::SendCombinationKeys()

   602 {

   603 #ifndef LIGHT_MODE

   604 	// If this assert triggers it is because we are running in

   605 	// text shell mode without a window server and the call

   606 	// requires the window server to be available.

   607 	// A command filter in ExecuteCommand should have prevented

   608 	// this call from being made.

   609 	assert(IsWindowServerAvailable());

   610 

   611 	TInt plusposition = 0;					//used for combination key data

   612 	TInt i = 0;

   613 	TInt counter = 0;

   614 	TInt index = 0;

   615 

   616 	TBuf<100> input = _L("");

   617 	

   618 	TBuf<20> myModifierKey[4];		//there are 4 maximum combination keys that can be used for one command - they will be stored here

   619 	

   620 	TKeyEvent event;		//the key event structure

   621 	TEventModifier em[5];	//modifier keys required for each of the modifiers available (shift, ctrl, func)

   622 	TKeyCode kp = EKeyNull;

   623 	

   624 	//*****Initialisation section*****

   625 	

   626 	int a = 0;

   627 	for (a=0;a<4;a++)

   628 	{

   629 		myModifierKey[a] = _L("");

   630 		myModifierKey[a].SetLength(0);

   631 	}

   632 

   633 	int b = 0;

   634 	for (b=0;b<5;b++)

   635 	{

   636 		em[b] = (TEventModifier)0;

   637 	}

   638 	

   639 	//********************************

   640 	

   641 	TInt DataLength = command.Length();	//copy passed data length into local variable

   642 

   643 	//The following section splits the data up and puts them into the array

   644 	while ((DataLength >= 1) && (counter <= 4))		//while length > 1

   645 	{

   646 		plusposition = command.Locate('+');	//search for this char

   647 

   648 		if (plusposition != KErrNotFound)

   649 		{

   650 			myModifierKey[counter] = command.Left(plusposition);	//chars left of plus are stored

   651 			command.Delete(0, (plusposition + 1));					//delete all chars from pos 0 up to and including '+' with null terminator

   652 			counter++;

   653 		}

   654 		else	//no more '+' in string

   655 		{

   656 			myModifierKey[counter] = command.Left(command.Length());//store remaining string into array

   657 			command.Delete(0, plusposition + 1);					//delete remaining string

   658 			counter = 5;										//make sure exits

   659 		}

   660 	}

   661 	

   662 	counter = 0;

   663 	event.iCode = 0;

   664 	event.iScanCode = 0;

   665 	event.iRepeats = 0;

   666 	event.iModifiers = 0;	//initialisation

   667 	

   668 	//now check the new data in each of the elements in the array

   669 	while (counter <= 4)

   670 	{

   671 		input = myModifierKey[counter];	//assign value from string

   672 

   673 		if (input == _L("Ctrl")  || input == _L("LeftCtrl")  || input == _L("RightCtrl") 

   674 			|| input == _L("Shift") || input == _L("LeftShift") || input == _L("RightShift") 

   675 			|| input == _L("Func") || input == _L("LeftFunc") ||  input == _L("RightFunc") 

   676 			|| input == _L("Alt") ||  input == _L("LeftAlt") || input == _L("RightAlt"))

   677 		{

   678 			TBuf<100> value;

   679 			value = ENUM_TEXTMODIFIERSArray[i];	//assign initial data in array to value (element 0)

   680 

   681 			while (value.Compare(TPtrC(NO_MORE_MODIFIERKEYS)) != 0)	//make sure not end of array

   682 			{

   683 				if (input.Compare(value) == 0)	//if the string has been found in the text array

   684 				{

   685 					em[counter] = ENUM_VALMODIFIERSArray[i];	//assign em element with the same value from the val array by comparing counter num (location)

   686 					i = 0;	//reinitialise so that the search can restart at the beginning of the enumerated type list

   687 					break;

   688 				}

   689 				

   690 				i++;

   691 				value = ENUM_TEXTMODIFIERSArray[i];	//update contents of value for the next pass

   692 			}	//end while

   693 		}

   694 		else	//no combination keys left

   695 		{

   696 			if (input.Length() > 1)	//if the remaining data is longer than 1 char (ie - could be 'LeftArrow')

   697 			{

   698 				TBuf<100> valuekey;

   699 				valuekey = ENUM_TEXTKEYArray[i];	//assign initial data in array to value (element 0)

   700 

   701 				while (valuekey.Compare(TPtrC(NO_MORE_KEYS)) != 0)	//make sure not end of array

   702 				{

   703 					if (input.Compare(valuekey) == 0)	//if the string has been found in the text array

   704 					{

   705 						//kp.iScanCode = ENUM_VALKEYArray[i]; 

   706 						kp = ENUM_VALKEYArray[i]; //assign kp with the same value from the val array

   707 

   708 						if(kp < ENonCharacterKeyBase)

   709 						{

   710 							event.iCode = kp;

   711 							em[2] = EModifierPureKeycode;

   712 							index = 3;

   713 							counter = 5;

   714 						}

   715 						else

   716 						{

   717 							event.iCode = kp;

   718 							index = 3;

   719 							counter = 5;

   720 						}

   721 

   722 						break;

   723 

   724 					}	//end if

   725 				

   726 					i++;	

   727 					valuekey = ENUM_TEXTKEYArray[i];	//update contents of value for the next pass

   728 				}

   729 			}

   730 			else	//must be single char combination, so pass into iCode and set counter to four to exit!

   731 			{

   732 				input.LowerCase();

   733 

   734 				while (index < 3)	//need to check array and see if need to send CTRL or not

   735 				{

   736 					if ((em[index] == EModifierLeftCtrl) || (em[index] == EModifierRightCtrl) || (em[index] == EModifierCtrl))

   737 					{

   738 						event.iCode = CTRLA(input.Ptr()[0]);

   739 						counter = 4;

   740 						break;

   741 					}

   742 					else

   743 					{

   744 						event.iCode = input.Ptr()[0];

   745 						index++;

   746 						counter = 4;

   747 					}

   748 				}

   749 			}

   750 

   751 			event.iModifiers = em[0] | em[1] | em[2];	//used to set up Ctrl+Shift+...etc

   752 		

   753 		}	//end else

   754 

   755 		counter++;

   756 		input = _L("");	//reinitialise for next pass

   757 	

   758 	}	//end while

   759 

   760 

   761 	iWs.SimulateKeyEvent(event);		// send keystroke

   762 	iWs.Flush();						// flush client-side window server buffer

   763 

   764 	return KErrNone;

   765 #else // ifndef LIGHT_MODE

   766 	return (KErrNotSupported);

   767 #endif // ifndef LIGHT_MODE

   768 }

   769 

   770 ////////////////////////////////////////////////////////////////////////////////////////////

   771 //

   772 //Function used to hold down keys

   773 //

   774 ////////////////////////////////////////////////////////////////////////////////////////////

   775 TInt CStatApiCommandDecoder::ConvertKeycodeToScancode( TDesC& key, TInt& scancode, TInt& modifiers )

   776 {

   777 	TInt i, j;

   778 	TBuf<20> base_punctuation( _L("`,./\\;'#[]-=/*-") );

   779 	TBuf<20> shift_punctuation( _L("?>?|:@~{}_+XX_") );

   780 	TBuf<20> numeric_punctuation( _L(")!\"?%^&*(") );

   781 

   782 	// clear the modifiers field

   783 	modifiers = 0;

   784 

   785 	// make sure the key is not completely empty

   786 	if( key.Length() == 0 ) {

   787 		return -1;

   788 	}

   789 

   790 	// If the key is longer than one char then it must be a special key that we need to

   791 	// lookup in the table. If it's not in the table then return error

   792 	if( key.Length() > 1 ) {

   793 		for( i = 0; ENUM_TEXTSCANCODEArray[i] != NO_MORE_SCANCODEKEYS; i++ ) {

   794 			if( key.Compare(TPtrC(ENUM_TEXTSCANCODEArray[i])) == 0 ) {

   795 				scancode = ENUM_VALSCANCODEArray[i];

   796 				return 0;

   797 			}

   798 		}

   799 		return -1;

   800 	}

   801 

   802 	// get the first key (saves getting it heaps of times)

   803 	TChar keycode( key.Ptr()[0] );

   804 

   805 	// handle lowercase alpha characters

   806 	if( keycode.IsAlpha() && keycode.IsLower() ) {

   807 		keycode.UpperCase();

   808 		scancode = keycode;

   809 		return 0;

   810 	}

   811 

   812 	// handle uppercase alpha characters

   813 	if( keycode.IsAlpha() && keycode.IsUpper() ) {

   814 		scancode = keycode;

   815 		modifiers = ESMLShift;

   816 		return 0;

   817 	}

   818 

   819 	// handle numbers

   820 	if( keycode.IsDigit() ) {

   821 		scancode = keycode;

   822 		return 0;

   823 	}

   824 

   825 	// handle punctuation -- just offset by 36 for some unknown reason

   826 	if( keycode.IsPunctuation() ) {

   827 

   828 		j = base_punctuation.Locate( keycode );

   829 		if( j != KErrNotFound ) {

   830 			scancode = 120 + j;

   831 			return 0;

   832 		}

   833 

   834 		j = shift_punctuation.Locate( keycode );

   835 		if( j != KErrNotFound ) {

   836 			scancode = 120 + j;

   837 			modifiers = ESMLShift;

   838 			return 0;

   839 		}

   840 

   841 		j = numeric_punctuation.Locate( keycode );

   842 		if( j != KErrNotFound ) {

   843 			scancode = '0' + j;

   844 			modifiers = ESMLShift;

   845 			return 0;

   846 		}

   847 

   848 		scancode = keycode;

   849 		return 0;

   850 	}

   851 

   852 	// For some reason certain characters are not recognized as punctuation though they

   853 	// should be. These are handled specifically here.

   854 	bool found = false;

   855 	switch( keycode ) {

   856 

   857 	case 0x24:

   858 		scancode = 0x34;

   859 		modifiers = ESMLShift;

   860 		found = true;

   861 		break;

   862 

   863 	case 0xa3:

   864 		scancode = 0x33;

   865 		modifiers = ESMLShift;

   866 		found = true;

   867 		break;

   868 

   869 	case 0x80:

   870 		scancode = 0x34;

   871 //		modifiers = ESMRFunc | ESMLCtrl;

   872 		modifiers = ESMRAlt;

   873 		found = true;

   874 		break;

   875 

   876 	case 0xa6:

   877 		scancode = 0x78;

   878 		modifiers = ESMRFunc;

   879 		found = true;

   880 		break;

   881 	}

   882 

   883 	if (found)

   884 		return 0;

   885 	else

   886 	// key not found

   887 		return -1;

   888 }

   889 

   890 TInt CStatApiCommandDecoder::SendKeyHold()

   891 {

   892 #ifndef LIGHT_MODE

   893 	// If this assert triggers it is because we are running in

   894 	// text shell mode without a window server and the call

   895 	// requires the window server to be available.

   896 	// A command filter in ExecuteCommand should have prevented

   897 	// this call from being made.

   898 	assert(IsWindowServerAvailable());

   899 

   900 	TLex Lexcounter;

   901 	TInt key_action = 0;

   902 	TRawEvent rawEventa;

   903 	TInt scancodefound;

   904 	TInt scancode;

   905 	TInt modifiers;

   906 

   907 	// H commands must have the format <HC,N> where 'C' is the command to be executed and

   908 	// N is either -1 (key up) or 0 (key down)

   909 	TInt commaposition = command.Locate(',');

   910 	if( commaposition == KErrNotFound ) {

   911 		return KErrArgument;

   912 	}

   913 

   914 	// convert the key action from a string to an integer	

   915 	Lexcounter = command.Mid( commaposition + 1 );

   916 	Lexcounter.Val( key_action );

   917 

   918 	// get the scancode for the key

   919 	command.SetLength( commaposition );

   920 	scancodefound = ConvertKeycodeToScancode( command, scancode, modifiers );

   921 	if( scancodefound == -1 ) {

   922 		return KErrArgument;

   923 	}

   924 

   925 	// set the appropriate modifier keys

   926 	if( modifiers & ESMLShift ) {

   927 		rawEventa.Set(TRawEvent::EKeyDown, EStdKeyLeftShift);

   928 		iWs.SimulateRawEvent(rawEventa);

   929 		iWs.Flush();

   930 	}

   931 	if( modifiers & ESMRFunc ) {

   932 		rawEventa.Set(TRawEvent::EKeyDown, EStdKeyRightFunc);

   933 		iWs.SimulateRawEvent(rawEventa);

   934 		iWs.Flush();

   935 	}

   936 	if( modifiers & ESMRAlt ) {

   937 		rawEventa.Set(TRawEvent::EKeyDown, EStdKeyRightAlt);

   938 		iWs.SimulateRawEvent(rawEventa);

   939 		iWs.Flush();

   940 	}

   941 	if( modifiers & ESMLCtrl ) {

   942 		rawEventa.Set(TRawEvent::EKeyDown, EStdKeyLeftCtrl);

   943 		iWs.SimulateRawEvent(rawEventa);

   944 		iWs.Flush();

   945 	}

   946 

   947 	// now handle the key_action -1 == key_up, 0 == key_down, > 0 == milliseconds to hold the key down

   948 	switch( key_action ) {

   949 

   950 	case -1:

   951 		rawEventa.Set(TRawEvent::EKeyUp, scancode);

   952 		iWs.SimulateRawEvent(rawEventa);

   953 		iWs.Flush();

   954 		break;

   955 

   956 	case 0:

   957 		rawEventa.Set(TRawEvent::EKeyDown, scancode);

   958 		iWs.SimulateRawEvent(rawEventa);

   959 		iWs.Flush();

   960 		break;

   961 

   962 	default:

   963 		rawEventa.Set(TRawEvent::EKeyDown, scancode);

   964 		iWs.SimulateRawEvent(rawEventa);

   965 		iWs.Flush();

   966 

   967 		key_action *= 1000;

   968 		User::After(TTimeIntervalMicroSeconds32(key_action));

   969 		

   970 		rawEventa.Set(TRawEvent::EKeyUp, scancode);

   971 		iWs.SimulateRawEvent(rawEventa);

   972 		iWs.Flush();

   973 		break;

   974 	}

   975 

   976 	// release appropriate function keys

   977 	if( modifiers & ESMLShift ) {

   978 		rawEventa.Set(TRawEvent::EKeyUp, EStdKeyLeftShift);

   979 		iWs.SimulateRawEvent(rawEventa);

   980 		iWs.Flush();

   981 	}

   982 	if( modifiers & ESMRFunc ) {

   983 		rawEventa.Set(TRawEvent::EKeyUp, EStdKeyRightFunc);

   984 		iWs.SimulateRawEvent(rawEventa);

   985 		iWs.Flush();

   986 	}

   987 	if( modifiers & ESMRAlt ) {

   988 		rawEventa.Set(TRawEvent::EKeyUp, EStdKeyRightAlt);

   989 		iWs.SimulateRawEvent(rawEventa);

   990 		iWs.Flush();

   991 	}

   992 	if( modifiers & ESMLCtrl ) {

   993 		rawEventa.Set(TRawEvent::EKeyUp, EStdKeyLeftCtrl);

   994 		iWs.SimulateRawEvent(rawEventa);

   995 		iWs.Flush();

   996 	}

   997 

   998 	return KErrNone;

   999 #else // ifndef LIGHT_MODE

  1000 	return (KErrNotSupported);

  1001 #endif // ifndef LIGHT_MODE

  1002 }

  1003 

  1004 

  1005 //------------------------------------------------------------------------------

  1006 //

  1007 //Function used to start application(s)

  1008 //

  1009 TInt CStatApiCommandDecoder::StartApplicationL()

  1010 {	

  1011 #ifndef LIGHT_MODE

  1012 	// If this assert triggers it is because we are running in

  1013 	// text shell mode without a window server and the call

  1014 	// requires the window server to be available.

  1015 	// A command filter in ExecuteCommand should have prevented

  1016 	// this call from being made.

  1017 	assert(IsWindowServerAvailable());

  1018 

  1019 	TInt ret = KErrNone;

  1020 

  1021 	TBuf<KMaxFileName> docName;

  1022 	CApaCommandLine* cmdLine = CApaCommandLine::NewLC();

  1023 

  1024 	TInt commaposition = command.Locate(',');

  1025 	if (commaposition != KErrNotFound)

  1026 	{

  1027 		// set the application name

  1028 		cmdLine -> SetExecutableNameL(command.Mid(0, commaposition));

  1029 

  1030 		// use document name supplied in command string

  1031 		docName = command.Mid(commaposition + 1);

  1032 	}

  1033 	else

  1034 	{

  1035 		TBuf<10> timestring;

  1036 		TTime DateAndTime;

  1037 		DateAndTime.HomeTime();

  1038 		DateAndTime.FormatL(timestring, (_L("%J%T%S%*B")));

  1039 

  1040 		// create a default document name based on the system date and time

  1041 		

  1042 		docName.Append(iSystemDrive);

  1043 		docName.Append(timestring);

  1044 

  1045 		// set the application name

  1046 		cmdLine -> SetExecutableNameL(command);

  1047 	}

  1048 

  1049 	cmdLine -> SetDocumentNameL(docName);

  1050 	cmdLine -> SetCommandL(EApaCommandCreate);

  1051 

  1052 	if( ret == KErrNone )

  1053 		{

  1054 		//initialise

  1055 		ret = iApaS.Connect();

  1056 		if(ret != KErrNone)

  1057 			pMsg->Msg (_L("DECODER: Application Architecture server error [%c]"), ret);

  1058 		}

  1059 

  1060 	if( ret == KErrNone )

  1061 		{

  1062 		// startup

  1063 		ret = iApaS.StartApp(*cmdLine);

  1064 		if(ret != KErrNone)

  1065 			pMsg->Msg (_L("DECODER: Unable to start application [%c]"), ret);

  1066 		}

  1067 

  1068 	//cleanup

  1069 	iApaS.Close();

  1070 	CleanupStack::PopAndDestroy();

  1071 

  1072 	if( ret == KErrNone )

  1073 		{

  1074 		// need to sleep a bit here to give the OS time to actually start the application

  1075 		User::After(3000000);

  1076 		}

  1077 

  1078 	return (ret);

  1079 #else // ifndef LIGHT_MODE

  1080 	return (KErrNotSupported);

  1081 #endif // ifndef LIGHT_MODE

  1082 }

  1083 

  1084 //------------------------------------------------------------------------------

  1085 //

  1086 //Function used to start executables(s)

  1087 //

  1088 TInt CStatApiCommandDecoder::StartProgramL(MDataSupplier **aDataSupplier)

  1089 {	

  1090 	TInt ret = KErrNone;

  1091 

  1092 	TBuf<KMaxFileName> programName;

  1093 	TBuf<KMaxFileName> parameters;

  1094 

  1095 	TInt commaposition = command.Locate(',');

  1096 	if (commaposition != KErrNotFound)

  1097 	{

  1098 		// set the program name

  1099 		programName = command.Mid(0, commaposition);

  1100 

  1101 		// set the parameters

  1102 		parameters = command.Mid(commaposition + 1);

  1103 	}

  1104 	else

  1105 	{

  1106 		programName = command;

  1107 	}

  1108 

  1109 	updatePathWithSysDrive(programName) ; 

  1110 	updatePathWithSysDrive(parameters) ; 

  1111 	RProcess newProcess;

  1112 	ret = newProcess.Create(programName,parameters);

  1113 	

  1114 	if(ret == KErrNone)

  1115 		{

  1116 		

  1117 		TProcessId handle = newProcess.Id();

  1118 		

  1119 		if(ret == KErrNone)

  1120 		{

  1121 			newProcess.Resume();

  1122 			newProcess.Close(); // get rid of our handle

  1123 		}

  1124 		

  1125 		// Return the PID

  1126 		

  1127 		CDataSupplierMemory	*pDataSupplier = CDataSupplierMemory::NewL( );

  1128 		

  1129 		TBuf8<50> handleNumber;

  1130 		

  1131 		handleNumber.Num(handle.Id());

  1132 		

  1133 		TInt err;

  1134 

  1135 		if (pDataSupplier)