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 "test/testshareddata.h"

    37 #include "test/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 	//creation of a new windows server session

   102 	if(iWs.Connect() != KErrNone) {

   103 		return;

   104 	}

   105 	// This line is for debug purposes.

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

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

   108 #endif // ifndef LIGHT_MODE

   109 

   110 	iFs = aSession;

   111 	pMsg = aMsg;

   112 

   113 #ifndef LIGHT_MODE

   114 	if(IsWindowServerAvailable())

   115 		{

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

   117 		// window shell mode.

   118 		User::LeaveIfError(FbsStartup());

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

   120 

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

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

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

   124 	    iDevice -> Construct();

   125 

   126 		// create new bitmap

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

   128 

   129 		// set the display mode for the bitmap

   130 		TInt gray;	

   131 		TInt color;

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

   133 

   134 		TSize size = iDevice -> SizeInPixels();

   135 

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

   137 

   138 		if (ret != KErrNone)

   139 			{

   140 			User::Leave(ret);

   141 			}

   142 		}

   143 #endif // ifndef LIGHT_MODE

   144 

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

   146     

   147     //set system drive

   148    

   149 	TDriveNumber defaultSysDrive(EDriveC);

   150 	RLibrary pluginLibrary;

   151 	TInt pluginErr = pluginLibrary.Load(KFileSrvDll);

   152 	

   153 	if (pluginErr == KErrNone)

   154 		{

   155 		typedef TDriveNumber(*fun1)();

   156 		fun1 sysdrive;

   157 	

   158 	#ifdef __EABI__

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

   160 	#else

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

   162 	#endif

   163 		if(sysdrive!=NULL)

   164 			{

   165 			defaultSysDrive = sysdrive();			

   166 			}

   167 		}

   168 	pluginLibrary.Close();

   169 	

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

   171 	iSystemDrive.Append(KFileSeparator);

   172 

   173     

   174     

   175 

   176 	RefreshStatus( );

   177 }

   178 

   179 //-----------------------------------------------------------------------------------

   180 //destructor

   181 CStatApiCommandDecoder::~CStatApiCommandDecoder()

   182 {

   183 #ifndef LIGHT_MODE

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

   185      if(iDevice != NULL)

   186      {

   187          delete iDevice;

   188      }

   189  

   190     if(screenBitmap != NULL)

   191      {

   192          delete screenBitmap;

   193      }

   194 

   195      RFbsSession::Disconnect();

   196      iWs.Close();

   197 #endif // ifndef LIGHT_MODE

   198 }

   199 

   200 //------------------------------------------------------------------------------

   201 //

   202 // Do whatever the user requested

   203 //

   204 TInt CStatApiCommandDecoder::ExecuteCommand(TUint commandtype,

   205 	MDataConsumer *const aDataConsumer, MDataSupplier **aDataSupplier)

   206 {

   207 	TInt ret = KErrNone;

   208 	TInt exp = KErrNone;

   209 

   210 	TInt commandLength = 0;

   211 

   212 	if (aDataConsumer)

   213 		{

   214 		aDataConsumer->GetTotalSize(commandLength);

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

   216 		}

   217 	else

   218         {

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

   220         }

   221 

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

   223 	command.Zero();

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

   225 		aDataConsumer && commandLength)

   226 		{

   227 		command.Copy( *(aDataConsumer) );

   228 		}

   229 

   230 	// Screen saver activates regardless of activity.

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

   232 	// inactivity timer.

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

   234 	// event processing.

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

   236 		commandtype == 'M' || commandtype == 'H')

   237 	{

   238 		User::ResetInactivityTime();

   239 	}

   240 

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

   242 	// window session server or the application architecture

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

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

   245 	// then we do not support:

   246 	// SendText, SendSystemKey, SendCombinationKeys,

   247 	// SendKeyHold, StopApplicationL, OpenIcon,

   248 	// OpenFile, StartESHell, Screenshot and

   249 	// StartApplication.

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

   251 		commandtype == 'M' || commandtype == 'H' ||

   252 		commandtype == 'C' || commandtype == 'I' ||

   253 		commandtype == 'F' || commandtype == '!' ||

   254 		commandtype == 'A' || commandtype == 'S' )

   255 		{

   256 

   257 		if( ! IsWindowServerAvailable())

   258 			{

   259 			ret = KErrNotSupported;

   260 			}

   261 		}	

   262 

   263 	if(ret == KErrNone)

   264 		{

   265 		//check message header type

   266 		switch (commandtype)

   267 			{

   268 

   269 			case ('K'):

   270 				{

   271                 if (aDataConsumer && commandLength)

   272                     {

   273 					ret = SendText(aDataConsumer, commandLength);

   274                     }

   275 				}

   276 				break;

   277 			case ('L'):

   278 				ret = SendSystemKeys();

   279 				break;

   280 			case ('M'):

   281 				ret = SendCombinationKeys();

   282 				break;

   283 			case ('H'):

   284 				ret = SendKeyHold();

   285 				break;

   286 			case ('A'):

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

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

   289 				break;

   290 			case ('J'):

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

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

   293 				break;

   294 			case ('C'):

   295 				TRAP(ret, StopApplicationL());

   296 				break;

   297 			case ('F'):

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

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

   300 				break;

   301 			case ('I'):

   302 				ret = OpenIcon();

   303 				break;

   304 			case ('!'):

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

   306                     {

   307                     TRAP(ret, StartEShellL());

   308                     }

   309                 else

   310                     {

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

   312                         {

   313                         TRAP(ret, StopEShellL());

   314                         }

   315                     }

   316 				break;

   317 			case ('U'):

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

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

   320 				break;

   321 			case ('2'):

   322                 if(aDataConsumer) 

   323                     {

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

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

   326                     }

   327 				break;

   328 			case ('1'):

   329                 if(aDataConsumer)

   330                     {

   331                     ret = CheckLocation(aDataConsumer);

   332                     }

   333 				break;

   334 			case ('Y'):

   335 				ret = CreateFolder();

   336 				break;

   337 			case ('Z'):

   338 				ret = RemoveFolder();

   339 				break;

   340 			case ('T'):

   341                 if(aDataConsumer)

   342                     {

   343                     ret = TransferFile(aDataConsumer);

   344                     }

   345 				break;

   346 			case ('R'):

   347                 if(aDataConsumer)

   348                     {

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

   350                     }

   351 				break;

   352 			case ('X'):

   353 			case ('S'):

   354                 if(aDataConsumer)

   355                     {

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

   357                     }

   358 				//DeleteLastFile();

   359 				break;

   360 			case ('D'):

   361 				ret = DeviceInfo(aDataSupplier);

   362 				break;

   363 			case ('G'):

   364 				SaveLogFile(aDataSupplier);

   365 				break;

   366 			case ('W'):

   367 				ret = GetDiskDriveInformationL(aDataSupplier);

   368 				break;

   369 			case ('V'):

   370                 if(aDataConsumer)

   371                     {

   372                     ret = GetDirectoryInformationL(aDataConsumer, aDataSupplier);

   373                     }

   374 				break;

   375 			case ('B'):

   376 				RefreshStatus( );

   377 				break;

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

   379 				break;

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

   381 				break;

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

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

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

   385 				break;

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

   387                 if(aDataConsumer)

   388                     {

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

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

   391                     }

   392 				break;

   393 			case ('|'):

   394 				//emulator restart

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

   396 				break;

   397 			case ('3'):

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

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

   400 				break;

   401 			case ('~'):

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

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

   404 				break;

   405 				

   406 #ifndef LIGHT_MODE

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

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

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

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

   411 //					{

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

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

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

   415 //					}

   416 				updatePathWithSysDrive(command) ; 

   417 				ret = CAppInstall::Install(command);

   418 				break;	

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

   420 				ret = CAppInstall::Uninstall(command);

   421 				break;	

   422 #endif // ifndef LIGHT_MODE

   423 			

   424 			default:

   425 				ret = KErrNotSupported;     

   426 			}

   427 		}

   428 

   429 	// put the error code into the response

   430 	if(ret != KErrNone)

   431 		{

   432 		if(*aDataSupplier)

   433 			{

   434 			(*aDataSupplier)->Delete( );

   435 			*aDataSupplier = NULL;

   436 			}

   437 		AppendErrorCode(ret, aDataSupplier);

   438 		}

   439 

   440 	return ret;

   441 }

   442 

   443 //------------------------------------------------------------------------------

   444 //

   445 // Initialise our command handling status.

   446 //

   447 void CStatApiCommandDecoder::RefreshStatus(void)

   448 {

   449 	iName = 1;

   450 }

   451 

   452 

   453 //------------------------------------------------------------------------------

   454 //

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

   456 //

   457 TInt CStatApiCommandDecoder::DeleteLastFile()

   458 {

   459 	TInt exp = KErrNone;

   460 	command = filename;

   461 	TRAP( exp, DeleteFileL(FALSE) );

   462 	return exp;

   463 }

   464 

   465 

   466 //------------------------------------------------------------------------------

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

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

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

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

   471 //

   472 TInt CStatApiCommandDecoder::SendText(

   473 		MDataConsumer *const aDataConsumer, int commandLength)

   474 {

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

   476 	// DoKeyEvent.

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

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

   479 	// requires the window server to be available.

   480 	// A command filter in ExecuteCommand should have prevented

   481 	// this call from being made.

   482 	assert(IsWindowServerAvailable());

   483 

   484 	TInt err = KErrNone;

   485 	TInt i = 0;

   486 

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

   488 

   489 	if( ! keyData )

   490 		{

   491 		err = KErrNoMemory;

   492 		}

   493 

   494 	if( err == KErrNone )

   495 		{

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

   497 		}

   498 

   499 	if( err == KErrNone )

   500 		{

   501 		TBuf16<1> x;

   502 

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

   504 			{

   505 			x.Zero();

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

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

   508 

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

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

   511 			// the system to process the key event.

   512 			User::After(0);

   513 			}

   514 

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

   516 		User::After(0);

   517 		}

   518 

   519 	if( keyData )

   520 		{

   521 		delete keyData;

   522 		keyData = NULL;

   523 		}

   524 

   525 	return (err);

   526 }

   527 

   528 

   529 //------------------------------------------------------------------------------

   530 //

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

   532 //

   533 

   534 TInt CStatApiCommandDecoder::SendSystemKeys()

   535 {

   536 #ifndef LIGHT_MODE

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

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

   539 	// requires the window server to be available.

   540 	// A command filter in ExecuteCommand should have prevented

   541 	// this call from being made.

   542 	assert(IsWindowServerAvailable());

   543 

   544 	TInt ret = KErrArgument;

   545 	TInt i = 0;

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

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

   548 

   549 	// look for correct system command from scancodes first

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

   551 	{

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

   553 		{

   554 			//send using SimulateRawEvent...

   555 			TRawEvent rawEventa;

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

   557 			iWs.SimulateRawEvent(rawEventa);

   558 			iWs.Flush();

   559 			

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

   561 			iWs.SimulateRawEvent(rawEventa);

   562 			iWs.Flush();

   563 

   564 			ret = KErrNone;

   565 			break;

   566 		}

   567 			

   568 		i++;	

   569 		scancodevalue = ENUM_TEXTSCANCODEArray[i];

   570 	}

   571 

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

   573 	if(ret != KErrNone)

   574 	{

   575 		i = 0;	//reinitialise

   576 		

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

   578 		{

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

   580 			{

   581 				// set the event

   582 				DoKeyEvent(ENUM_VALKEYArray[i]);

   583 				ret = KErrNone;

   584 				break;

   585 			}

   586 				

   587 			i++;	

   588 			keycodevalue = ENUM_TEXTKEYArray[i];

   589 		}

   590 	}

   591 

   592 	return (ret);

   593 #else // ifndef LIGHT_MODE

   594 	return (KErrNotSupported);

   595 #endif // ifndef LIGHT_MODE

   596 }

   597 

   598 

   599 //------------------------------------------------------------------------------

   600 //

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

   602 //

   603 

   604 TInt CStatApiCommandDecoder::SendCombinationKeys()

   605 {

   606 #ifndef LIGHT_MODE

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

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

   609 	// requires the window server to be available.

   610 	// A command filter in ExecuteCommand should have prevented

   611 	// this call from being made.

   612 	assert(IsWindowServerAvailable());

   613 

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

   615 	TInt i = 0;

   616 	TInt counter = 0;

   617 	TInt index = 0;

   618 

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

   620 	

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

   622 	

   623 	TKeyEvent event;		//the key event structure

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

   625 	TKeyCode kp = EKeyNull;

   626 	

   627 	//*****Initialisation section*****

   628 	

   629 	int a = 0;

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

   631 	{

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

   633 		myModifierKey[a].SetLength(0);

   634 	}

   635 

   636 	int b = 0;

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

   638 	{

   639 		em[b] = (TEventModifier)0;

   640 	}

   641 	

   642 	//********************************

   643 	

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

   645 

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

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

   648 	{

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

   650 

   651 		if (plusposition != KErrNotFound)

   652 		{

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

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

   655 			counter++;

   656 		}

   657 		else	//no more '+' in string

   658 		{

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

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

   661 			counter = 5;										//make sure exits

   662 		}

   663 	}

   664 	

   665 	counter = 0;

   666 	event.iCode = 0;

   667 	event.iScanCode = 0;

   668 	event.iRepeats = 0;

   669 	event.iModifiers = 0;	//initialisation

   670 	

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

   672 	while (counter <= 4)

   673 	{

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

   675 

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

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

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

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

   680 		{

   681 			TBuf<100> value;

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

   683 

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

   685 			{

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

   687 				{

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

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

   690 					break;

   691 				}

   692 				

   693 				i++;

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

   695 			}	//end while

   696 		}

   697 		else	//no combination keys left

   698 		{

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

   700 			{

   701 				TBuf<100> valuekey;

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

   703 

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

   705 				{

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

   707 					{

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

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

   710 

   711 						if(kp < ENonCharacterKeyBase)

   712 						{

   713 							event.iCode = kp;

   714 							em[2] = EModifierPureKeycode;

   715 							index = 3;

   716 							counter = 5;

   717 						}

   718 						else

   719 						{

   720 							event.iCode = kp;

   721 							index = 3;

   722 							counter = 5;

   723 						}

   724 

   725 						break;

   726 

   727 					}	//end if

   728 				

   729 					i++;	

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

   731 				}

   732 			}

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

   734 			{

   735 				input.LowerCase();

   736 

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

   738 				{

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

   740 					{

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

   742 						counter = 4;

   743 						break;

   744 					}

   745 					else

   746 					{

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

   748 						index++;

   749 						counter = 4;

   750 					}

   751 				}

   752 			}

   753 

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

   755 		

   756 		}	//end else

   757 

   758 		counter++;

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

   760 	

   761 	}	//end while

   762 

   763 

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

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

   766 

   767 	return KErrNone;

   768 #else // ifndef LIGHT_MODE

   769 	return (KErrNotSupported);

   770 #endif // ifndef LIGHT_MODE

   771 }

   772 

   773 ////////////////////////////////////////////////////////////////////////////////////////////

   774 //

   775 //Function used to hold down keys

   776 //

   777 ////////////////////////////////////////////////////////////////////////////////////////////

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

   779 {

   780 	TInt i, j;

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

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

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

   784 

   785 	// clear the modifiers field

   786 	modifiers = 0;

   787 

   788 	// make sure the key is not completely empty

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

   790 		return -1;

   791 	}

   792 

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

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

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

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

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

   798 				scancode = ENUM_VALSCANCODEArray[i];

   799 				return 0;

   800 			}

   801 		}

   802 		return -1;

   803 	}

   804 

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

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

   807 

   808 	// handle lowercase alpha characters

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

   810 		keycode.UpperCase();

   811 		scancode = keycode;

   812 		return 0;

   813 	}

   814 

   815 	// handle uppercase alpha characters

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

   817 		scancode = keycode;

   818 		modifiers = ESMLShift;

   819 		return 0;

   820 	}

   821 

   822 	// handle numbers

   823 	if( keycode.IsDigit() ) {

   824 		scancode = keycode;

   825 		return 0;

   826 	}

   827 

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

   829 	if( keycode.IsPunctuation() ) {

   830 

   831 		j = base_punctuation.Locate( keycode );

   832 		if( j != KErrNotFound ) {

   833 			scancode = 120 + j;

   834 			return 0;

   835 		}

   836 

   837 		j = shift_punctuation.Locate( keycode );

   838 		if( j != KErrNotFound ) {

   839 			scancode = 120 + j;

   840 			modifiers = ESMLShift;

   841 			return 0;

   842 		}

   843 

   844 		j = numeric_punctuation.Locate( keycode );

   845 		if( j != KErrNotFound ) {

   846 			scancode = '0' + j;

   847 			modifiers = ESMLShift;

   848 			return 0;

   849 		}

   850 

   851 		scancode = keycode;

   852 		return 0;

   853 	}

   854 

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

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

   857 	bool found = false;

   858 	switch( keycode ) {

   859 

   860 	case 0x24:

   861 		scancode = 0x34;

   862 		modifiers = ESMLShift;

   863 		found = true;

   864 		break;

   865 

   866 	case 0xa3:

   867 		scancode = 0x33;

   868 		modifiers = ESMLShift;

   869 		found = true;

   870 		break;

   871 

   872 	case 0x80:

   873 		scancode = 0x34;

   874 //		modifiers = ESMRFunc | ESMLCtrl;

   875 		modifiers = ESMRAlt;

   876 		found = true;

   877 		break;

   878 

   879 	case 0xa6:

   880 		scancode = 0x78;

   881 		modifiers = ESMRFunc;

   882 		found = true;

   883 		break;

   884 	}

   885 

   886 	if (found)

   887 		return 0;

   888 	else

   889 	// key not found

   890 		return -1;

   891 }

   892 

   893 TInt CStatApiCommandDecoder::SendKeyHold()

   894 {

   895 #ifndef LIGHT_MODE

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

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

   898 	// requires the window server to be available.

   899 	// A command filter in ExecuteCommand should have prevented

   900 	// this call from being made.

   901 	assert(IsWindowServerAvailable());

   902 

   903 	TLex Lexcounter;

   904 	TInt key_action = 0;

   905 	TRawEvent rawEventa;

   906 	TInt scancodefound;

   907 	TInt scancode;

   908 	TInt modifiers;

   909 

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

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

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

   913 	if( commaposition == KErrNotFound ) {

   914 		return KErrArgument;

   915 	}

   916 

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

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

   919 	Lexcounter.Val( key_action );

   920 

   921 	// get the scancode for the key

   922 	command.SetLength( commaposition );

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

   924 	if( scancodefound == -1 ) {

   925 		return KErrArgument;

   926 	}

   927 

   928 	// set the appropriate modifier keys

   929 	if( modifiers & ESMLShift ) {

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

   931 		iWs.SimulateRawEvent(rawEventa);

   932 		iWs.Flush();

   933 	}

   934 	if( modifiers & ESMRFunc ) {

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

   936 		iWs.SimulateRawEvent(rawEventa);

   937 		iWs.Flush();

   938 	}

   939 	if( modifiers & ESMRAlt ) {

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

   941 		iWs.SimulateRawEvent(rawEventa);

   942 		iWs.Flush();

   943 	}

   944 	if( modifiers & ESMLCtrl ) {

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

   946 		iWs.SimulateRawEvent(rawEventa);

   947 		iWs.Flush();

   948 	}

   949 

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

   951 	switch( key_action ) {

   952 

   953 	case -1:

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

   955 		iWs.SimulateRawEvent(rawEventa);

   956 		iWs.Flush();

   957 		break;

   958 

   959 	case 0:

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

   961 		iWs.SimulateRawEvent(rawEventa);

   962 		iWs.Flush();

   963 		break;

   964 

   965 	default:

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

   967 		iWs.SimulateRawEvent(rawEventa);

   968 		iWs.Flush();

   969 

   970 		key_action *= 1000;

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

   972 		

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

   974 		iWs.SimulateRawEvent(rawEventa);

   975 		iWs.Flush();

   976 		break;

   977 	}

   978 

   979 	// release appropriate function keys

   980 	if( modifiers & ESMLShift ) {

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

   982 		iWs.SimulateRawEvent(rawEventa);

   983 		iWs.Flush();

   984 	}

   985 	if( modifiers & ESMRFunc ) {

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

   987 		iWs.SimulateRawEvent(rawEventa);

   988 		iWs.Flush();

   989 	}

   990 	if( modifiers & ESMRAlt ) {

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

   992 		iWs.SimulateRawEvent(rawEventa);

   993 		iWs.Flush();

   994 	}

   995 	if( modifiers & ESMLCtrl ) {

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

   997 		iWs.SimulateRawEvent(rawEventa);

   998 		iWs.Flush();

   999 	}

  1000 

  1001 	return KErrNone;

  1002 #else // ifndef LIGHT_MODE

  1003 	return (KErrNotSupported);

  1004 #endif // ifndef LIGHT_MODE

  1005 }

  1006 

  1007 

  1008 //------------------------------------------------------------------------------

  1009 //

  1010 //Function used to start application(s)

  1011 //

  1012 TInt CStatApiCommandDecoder::StartApplicationL()

  1013 {	

  1014 #ifndef LIGHT_MODE

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

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

  1017 	// requires the window server to be available.

  1018 	// A command filter in ExecuteCommand should have prevented

  1019 	// this call from being made.

  1020 	assert(IsWindowServerAvailable());

  1021 

  1022 	TInt ret = KErrNone;

  1023 

  1024 	TBuf<KMaxFileName> docName;

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

  1026 

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

  1028 	if (commaposition != KErrNotFound)

  1029 	{

  1030 		// set the application name

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

  1032 

  1033 		// use document name supplied in command string

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

  1035 	}

  1036 	else

  1037 	{

  1038 		TBuf<10> timestring;

  1039 		TTime DateAndTime;

  1040 		DateAndTime.HomeTime();

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

  1042 

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

  1044 		

  1045 		docName.Append(iSystemDrive);

  1046 		docName.Append(timestring);

  1047 

  1048 		// set the application name

  1049 		cmdLine -> SetExecutableNameL(command);

  1050 	}

  1051 

  1052 	cmdLine -> SetDocumentNameL(docName);

  1053 	cmdLine -> SetCommandL(EApaCommandCreate);

  1054 

  1055 	if( ret == KErrNone )

  1056 		{

  1057 		//initialise

  1058 		ret = iApaS.Connect();

  1059 		if(ret != KErrNone)

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

  1061 		}

  1062 

  1063 	if( ret == KErrNone )

  1064 		{

  1065 		// startup

  1066 		ret = iApaS.StartApp(*cmdLine);

  1067 		if(ret != KErrNone)

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

  1069 		}

  1070 

  1071 	//cleanup

  1072 	iApaS.Close();

  1073 	CleanupStack::PopAndDestroy();

  1074 

  1075 	if( ret == KErrNone )

  1076 		{

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

  1078 		User::After(3000000);

  1079 		}

  1080 

  1081 	return (ret);

  1082 #else // ifndef LIGHT_MODE

  1083 	return (KErrNotSupported);

  1084 #endif // ifndef LIGHT_MODE

  1085 }

  1086 

  1087 //------------------------------------------------------------------------------

  1088 //

  1089 //Function used to start executables(s)

  1090 //

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

  1092 {	

  1093 	TInt ret = KErrNone;

  1094 

  1095 	TBuf<KMaxFileName> programName;

  1096 	TBuf<KMaxFileName> parameters;

  1097 

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

  1099 	if (commaposition != KErrNotFound)

  1100 	{

  1101 		// set the program name

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

  1103 

  1104 		// set the parameters

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

  1106 	}

  1107 	else

  1108 	{

  1109 		programName = command;

  1110 	}

  1111 

  1112 	updatePathWithSysDrive(programName) ; 

  1113 	updatePathWithSysDrive(parameters) ; 

  1114 	RProcess newProcess;

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

  1116 	

  1117 	if(ret == KErrNone)

  1118 		{

  1119 		

  1120 		TProcessId handle = newProcess.Id();

  1121 		

  1122 		if(ret == KErrNone)

  1123 		{

  1124 			newProcess.Resume();

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

  1126 		}

  1127 		

  1128 		// Return the PID

  1129 		

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

  1131 		

  1132 		TBuf8<50> handleNumber;

  1133 		

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

  1135