/*

* Copyright (c) 2005-2009 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 <hal.h>

#ifndef LIGHT_MODE

	#include <eikenv.h>

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

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

#endif

#include "assert.h"

#include "stat.h"

#include "statapi_commanddecoder.h"

#include "keycodes.h"

#include "modifiers.h"

#include "statapi_DeviceInformation.h"

#include "datasupplier_memory.h"

#include "datasupplier_file.h"

#include "dataconsumer_memory.h"

#include "testshareddata.h"

#include "tefshareddata.h"

#ifndef LIGHT_MODE

#include <s32mem.h>

#include "AppInstall.h"

#endif // ifndef LIGHT_MODE

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

#define	  CTRLA CTRL

#define   ESTATNoMoreKeys (EStdKeyDecBrightness+1)

#define	  ESMLShift		1

#define	  ESMRShift		2

#define	  ESMLAlt		4

#define   ESMRAlt		8

#define   ESMLCtrl	    16

#define   ESMRCtrl	    32

#define   ESMLFunc		64

#define	  ESMRFunc		128

const TInt KMaxSharedDataName	= 128;

const TInt KMaxSharedDataString	= 1048;

#ifndef LIGHT_MODE

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

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

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

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

#endif // ifndef LIGHT_MODE

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

//constructor

CStatApiCommandDecoder::CStatApiCommandDecoder()

: iFs( NULL ), pMsg(NULL)

{

}

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

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

{	

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

	CleanupStack::PushL(self);

	self -> ConstructL(aSession, aMsg);

	CleanupStack::Pop();

	return self;

}

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

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

{

#ifndef LIGHT_MODE

	// Try to connect to the window session server.

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

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

	// available.

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

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

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

	// This line is for debug purposes.

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

	// TInt wsHandle = iWs.WsHandle();

#endif // ifndef LIGHT_MODE

	iFs = aSession;

	pMsg = aMsg;

#ifndef LIGHT_MODE

	if(IsWindowServerAvailable())

		{

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

		// window shell mode.

		User::LeaveIfError(FbsStartup());

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

		// Create the data we use for screen capture.

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

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

	    iDevice -> Construct();

		// create new bitmap

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

		// set the display mode for the bitmap

		TInt gray;	

		TInt color;

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

		TSize size = iDevice -> SizeInPixels();

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

		if (ret != KErrNone)

			{

			User::Leave(ret);

			}

		}

#endif // ifndef LIGHT_MODE

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

    //set system drive

	TDriveNumber defaultSysDrive(EDriveC);

	RLibrary pluginLibrary;

	TInt pluginErr = pluginLibrary.Load(KFileSrvDll);

	if (pluginErr == KErrNone)

		{

		typedef TDriveNumber(*fun1)();

		fun1 sysdrive;

	#ifdef __EABI__

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

	#else

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

	#endif

		if(sysdrive!=NULL)

			{

			defaultSysDrive = sysdrive();			

			}

		}

	pluginLibrary.Close();

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

	iSystemDrive.Append(KFileSeparator);

	RefreshStatus( );

}

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

//destructor

CStatApiCommandDecoder::~CStatApiCommandDecoder()

{

#ifndef LIGHT_MODE

	// Clean-up objects created for screen capture.

     if(iDevice != NULL)

     {

         delete iDevice;

     }

    if(screenBitmap != NULL)

     {

         delete screenBitmap;

     }

     RFbsSession::Disconnect();

     iWs.Close();

#endif // ifndef LIGHT_MODE

}

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

//

// Do whatever the user requested

//

TInt CStatApiCommandDecoder::ExecuteCommand(TUint commandtype,

	MDataConsumer *const aDataConsumer, MDataSupplier **aDataSupplier)

{

	TInt ret = KErrNone;

	TInt exp = KErrNone;

	TInt commandLength = 0;

	if (aDataConsumer)

		{

		aDataConsumer->GetTotalSize(commandLength);

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

		}

	else

        {

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

        }

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

	command.Zero();

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

		aDataConsumer && commandLength)

		{

		command.Copy( *(aDataConsumer) );

		}

	// Screen saver activates regardless of activity.

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

	// inactivity timer.

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

	// event processing.

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

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

	{

		User::ResetInactivityTime();

	}

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

	// window session server or the application architecture

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

	// If there is no window server or application architecture

	// then we do not support:

	// SendText, SendSystemKey, SendCombinationKeys,

	// SendKeyHold, StopApplicationL, OpenIcon,

	// OpenFile, StartESHell, Screenshot and

	// StartApplication.

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

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

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

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

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

		{

		if( ! IsWindowServerAvailable())

			{

			ret = KErrNotSupported;

			}

		}	

	if(ret == KErrNone)

		{

		//check message header type

		switch (commandtype)

			{

			case ('K'):

				{

                if (aDataConsumer && commandLength)

                    {

					ret = SendText(aDataConsumer, commandLength);

                    }

				}

				break;

			case ('L'):

				ret = SendSystemKeys();

				break;

			case ('M'):

				ret = SendCombinationKeys();

				break;

			case ('H'):

				ret = SendKeyHold();

				break;

			case ('A'):

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

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

				break;

			case ('J'):

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

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

				break;

			case ('C'):

				TRAP(ret, StopApplicationL());

				break;

			case ('F'):

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

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

				break;

			case ('I'):

				ret = OpenIcon();

				break;

			case ('!'):

                if(command.Length() == 0)

                    {

                    TRAP(ret, StartEShellL());

                    }

                else

                    {

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

                        {

                        TRAP(ret, StopEShellL());

                        }

                    }

				break;

			case ('U'):

				TRAP( exp, ret = DeleteFileL() );

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

				break;

			case ('2'):

                if(aDataConsumer) 

                    {

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

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

                    }

				break;

			case ('1'):

                if(aDataConsumer)

                    {

                    ret = CheckLocation(aDataConsumer);

                    }

				break;

			case ('Y'):

				ret = CreateFolder();

				break;

			case ('Z'):

				ret = RemoveFolder();

				break;

			case ('T'):

                if(aDataConsumer)

                    {

                    ret = TransferFile(aDataConsumer);

                    }

				break;

			case ('R'):

                if(aDataConsumer)

                    {

                    ret = ReceiveFile(commandtype, aDataConsumer, aDataSupplier);

                    }

				break;

			case ('X'):

			case ('S'):

                if(aDataConsumer)

                    {

                    ret = ReceiveFile(commandtype, aDataConsumer, aDataSupplier);

                    }

				//DeleteLastFile();

				break;

			case ('D'):

				ret = DeviceInfo(aDataSupplier);

				break;

			case ('G'):

				SaveLogFile(aDataSupplier);

				break;

			case ('W'):

				ret = GetDiskDriveInformationL(aDataSupplier);

				break;

			case ('V'):

                if(aDataConsumer)

                    {

                    ret = GetDirectoryInformationL(aDataConsumer, aDataSupplier);

                    }

				break;

			case ('B'):

				RefreshStatus( );

				break;

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

				break;

			case ('?'):	// resync command

				break;

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

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

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

				break;

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

                if(aDataConsumer)

                    {

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

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

                    }

				break;

			case ('|'):

				//emulator restart

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

				break;

			case ('3'):

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

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

				break;

			case ('~'):

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

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

				break;

#ifndef LIGHT_MODE

			case ('+'):	// install command

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

				//if the filname starts with a back slash.

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

//					{

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

//					command.Delete(0,1);

//					command.Insert(0, iSystemDrive);

//					}

				updatePathWithSysDrive(command) ; 

				ret = CAppInstall::Install(command);

				break;	

			case ('-'):	// uninstall command

				ret = CAppInstall::Uninstall(command);

				break;	

#endif // ifndef LIGHT_MODE

			default:

				ret = KErrNotSupported;     

			}

		}

	// put the error code into the response

	if(ret != KErrNone)

		{

		if(*aDataSupplier)

			{

			(*aDataSupplier)->Delete( );

			*aDataSupplier = NULL;

			}

		AppendErrorCode(ret, aDataSupplier);

		}

	return ret;

}

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

//

// Initialise our command handling status.

//

void CStatApiCommandDecoder::RefreshStatus(void)

{

	iName = 1;

}

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

//

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

//

TInt CStatApiCommandDecoder::DeleteLastFile()

{

	TInt exp = KErrNone;

	command = filename;

	TRAP( exp, DeleteFileL(FALSE) );

	return exp;

}

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

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

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

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

// easily into the 1024 length limit...

//

TInt CStatApiCommandDecoder::SendText(

		MDataConsumer *const aDataConsumer, int commandLength)

{

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

	// DoKeyEvent.

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

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

	// requires the window server to be available.

	// A command filter in ExecuteCommand should have prevented

	// this call from being made.

	assert(IsWindowServerAvailable());

	TInt err = KErrNone;

	TInt i = 0;

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

	if( ! keyData )

		{

		err = KErrNoMemory;

		}

	if( err == KErrNone )

		{

		err = aDataConsumer->GetData( *keyData );

		}

	if( err == KErrNone )

		{

		TBuf16<1> x;

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

			{

			x.Zero();

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

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

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

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

			// the system to process the key event.

			User::After(0);

			}

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

		User::After(0);

		}

	if( keyData )

		{

		delete keyData;

		keyData = NULL;

		}

	return (err);

}

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

//

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

//