/*

 * 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 :

 *

 */

// INCLUDES

#include <hwrmlightdomaincrkeys.h>

#include <coreapplicationuisdomainpskeys.h>

#include <hal.h>

#include <atcmdpluginresource.rsg>

#include <barsread.h>

#include <barsc.h>

#include <bautils.h>

#include <e32math.h>

#include <e32base.h>

#include <eikenv.h>

#include <apgtask.h>

#include "debug.h"

#include "atcmdplugin.h"

// CONSTANTS

_LIT8( KAtCkpd, "+CKPD" );

_LIT8( KAtCbklt, "+CBKLT" );

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

_LIT8( KAtCtsa, "+CTSA");

const TInt KCustomKeyCodeIdentifier = -1;

const TInt KGranularity = 10;

const TInt KTimeMultiplier = 100000;

const TInt KMicroSeconds = 1000000;

#define REPLY_BUFFER_SIZE 200

// These values are based on testing results.

// Values less than 2000 causes some times missing key events

// even all keys are simulated with long commands.

const TInt KDefaultStrokeDelay = 50000;

const TInt KDefaultStrokeTime = 10000;

const TInt KLightTarget = CHWRMLight::EPrimaryDisplayAndKeyboard;

_LIT8( KParameterSeparator, "," );

_LIT8( Kok, "\r\nOK\r\n");

_LIT8( KCmeErrorNotSupported, "\r\n+CME ERROR: 4\r\n");

_LIT8( KTestCommand, "=?" );

_LIT8( KReadCommand, "?" );

_LIT8( KCbkltTestCommandResp, ":(0,1,2)" );

_LIT8( KCkpdTestCommandResp,  ":(GSM)" );

_LIT8( KCtsaTestCommandResp, ":(0,1,2),(width),(height)" );

_LIT( KFileName, "\\resource\\apps\\atcmdpluginresource.rsc" );

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

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

// CATCmdPluginEcom::NewL

// 2-phased constructor

// (may leave)

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

//

CATCmdPluginEcom* CATCmdPluginEcom::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CATCmdPluginEcom::CATCmdPluginEcom

// Constructor

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

//

CATCmdPluginEcom::CATCmdPluginEcom() 

    : CATExtPluginBase()

    {

    TRACE_FUNC

    }

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

// CATCmdPluginEcom::ConstructL

// Constructor

// (may leave)

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

//

void CATCmdPluginEcom::ConstructL()

    {

    TRACE_FUNC

    LEAVE_IF_ERROR( iWsSession.Connect() );

    iCkpdCmdArray = new (ELeave) CArrayFixFlat<TATCkpdCmd>( KGranularity );

    iKpdTimer = new ( ELeave ) CATCmdTimer( *this, ECmdCkpd );

	iKpdTimer->ConstructL();

    iBkltTimer = new ( ELeave ) CATCmdTimer( *this, ECmdCbklt );

    iBkltTimer->ConstructL();

    iKeepAliveTimer = new ( ELeave ) CATCmdTimer( *this, EKeepAlive );

    iKeepAliveTimer->ConstructL();

    LoadResourcesL();

   	}

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

// CATCmdPluginEcom::::LoadResourcesL

// Load resources

// (may leave)

// Status : Approved

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

//

void CATCmdPluginEcom::LoadResourcesL()

    {

    TRACE_FUNC_ENTRY

    RFs fs;

    CleanupClosePushL( fs );

    TFileName fileName;

    fileName.Copy( KFileName );

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

    BaflUtils::NearestLanguageFile( fs, fileName );

    RResourceFile resourceFile;

    CleanupClosePushL( resourceFile );

    resourceFile.OpenL( fs, fileName );

    resourceFile.ConfirmSignatureL();

    HBufC8* buf8 = resourceFile.AllocReadLC( R_ATCMDPLUGIN_TRANSLATIONTABLE );

    TResourceReader reader;

    reader.SetBuffer( buf8 );

    TInt count = reader.ReadInt16(); // array count

    iTranslations = new ( ELeave ) CArrayPtrFlat<CATCmdTranslation>( count );

    while ( count-- )

        {

        const TInt code = reader.ReadInt32(); 

        HBufC8* param = reader.ReadHBufC8L(); 

        CleanupStack::PushL( param );

        CATCmdTranslation* t = new (ELeave) CATCmdTranslation( *param, code );

        CleanupStack::Pop( param ); // transfer ownership

        CleanupStack::PushL( t );

        iTranslations->AppendL( t );

        CleanupStack::Pop( t ); // transfer ownership

        }

    CleanupStack::PopAndDestroy( 3 ); // resourceFile, fs, buf8

    TRACE_FUNC_EXIT

    }

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

// CATCmdPluginEcom::~CATCmdPluginEcom

// C++ Destructor

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

//

CATCmdPluginEcom::~CATCmdPluginEcom()

	{

	TRACE_FUNC

    if(iKpdTimer)

        {

        iKpdTimer->Cancel();

        delete iKpdTimer;

        }	    

    if(iBkltTimer)

        {

        iBkltTimer->Cancel();

        delete iBkltTimer;

        }

    if(iKeepAliveTimer)

        {

        iKeepAliveTimer->Cancel();

        delete iKeepAliveTimer;

        }

    if ( iTranslations)

        {

        iTranslations->ResetAndDestroy();

        delete iTranslations;

        }    

    if ( iCkpdCmdArray)

        {

        iCkpdCmdArray->Reset();

        delete iCkpdCmdArray;

        }

    iWsSession.Close();

	}

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

// CATCmdPluginEcom::HandleCommand

// Handle given command

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

//

void CATCmdPluginEcom::HandleCommand( const TDesC8& aCmd, RBuf8& aReply, TBool /* aReplyNeeded  */)

	{

	TRACE_FUNC_ENTRY

	aReply.Zero();

	iReplyBuf = &aReply;

	if ( IsCommandSupported( aCmd ) )

	    {

		TRAPD( err, HandleCommandL( aCmd ) );

		if ( err )

			{

			iReplyBuf->Append( KCmeErrorNotSupported ); 

			}

		else

			{

			if(iReplyBuf->Length() == 0)

				{

				iReplyBuf->Append( Kok );

				} 

			}

		HandleCommandCompleted( KErrNone,EReplyTypeOk );      

		}

    TRACE_FUNC_EXIT

    }

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

// CATCmdPluginEcom::HandleCommandL

// Handle given command

// (may leave)

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

//

void CATCmdPluginEcom::HandleCommandL( const TDesC8& aCmd )

	{

    // Verify command

    TInt offset;

    HBufC8* cmd = aCmd.AllocLC();

//    CleanupStack:: PushL(cmd);

    TPtr8 ptr = cmd->Des();

    ptr.Trim();

    TPtrC8 cptr;

    if ( ( offset = ptr.FindF(KAtCkpd) ) >= 0 )

        {

        cptr.Set( ptr.Mid( offset + KAtCkpd().Length() ) );         

        HandleCkpdCommandL( cptr );

        }

    else if ( ( offset = ptr.FindF(KAtCbklt) ) >= 0 ) 

        {

        cptr.Set( ptr.Mid( offset + KAtCbklt().Length() ) );

        HandleCbkltCommandL( cptr );

        }

    else if ( ( offset = ptr.FindF(KAtCtsa) ) >= 0 )

    	{

    	cptr.Set( ptr.Mid( offset + KAtCtsa().Length() ) );

    	HandleCtsaCommandL( cptr );

    	} 

    CleanupStack::PopAndDestroy( cmd );

    }    

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

//  HandleCtsaCommandL

//

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

void CATCmdPluginEcom::HandleCtsaCommandL( const TDesC8& aCmd )

    {

    if ( aCmd.Compare( KTestCommand ) == 0 )

        {

        // Test command just returns "OK"        

        iReplyBuf->Append( KCRLF );

        iReplyBuf->Append( KAtCtsa );

        iReplyBuf->Append( KCtsaTestCommandResp );

        iReplyBuf->Append( KCRLF );

        TRACE_FUNC_EXIT

        return;

        }  

    // Check boundary condition

	if ( ( aCmd.Length() < 6 ) || ( aCmd[2] !=  ',' ))

	    {

	    // Command Syntax Error

	    User::Leave( KErrNotSupported );           

	    } 	

 	TInt   pos=0;

 	TInt8  actionValue = aCmd[1] - '0';

 	TInt16 xCoordinateValue = 0;

 	TInt16 yCoordinateValue = 0;

 	TInt16 commandLen = aCmd.Length();  

 	if( actionValue < 0 || actionValue > 4 )

 	    {

 	    // Command Syntax Error          

 	    User::Leave( KErrNotSupported );                  

 	    }

 	pos=3;  // X Cordinate starts from 3d character

 	CWsScreenDevice *scrnDevPointer = new(ELeave) CWsScreenDevice(iWsSession);

 	TSize coordinateSize;

	scrnDevPointer->Construct();

 	coordinateSize = scrnDevPointer->SizeInPixels();  

 	delete scrnDevPointer;

	while(pos < commandLen)

 	    {

 	    if((aCmd[pos] >=  '0') && (aCmd[pos] <=  '9'))

 	        {

 	        xCoordinateValue *= 10;

 	        xCoordinateValue += aCmd[pos] - '0';

 	        pos++;

 	        if(xCoordinateValue > coordinateSize.iWidth )

 	            {

 	            // Command Syntax Error            

 	            User::Leave( KErrNotSupported );           

 	            }

 	        }

 	    else if((aCmd[pos] ==  ',') && pos > 3 )

            {

            pos++;

            break;

            }

 	    else

 	        {

 	        // Command Syntax Error            

 	        User::Leave( KErrNotSupported );             

 	        } 	    

 	    }

	if(pos == commandLen)	

		{

		// Command of type =0,100        /* Command Syntax Error */

 	    User::Leave( KErrNotSupported );  

		}

 	while(pos < commandLen)

 	    {

 	    if((aCmd[pos] >=  '0') && (aCmd[pos] <=  '9'))

 	        {

 	        yCoordinateValue *= 10;

 	        yCoordinateValue += aCmd[pos] - '0';

 	        pos++;

			if(yCoordinateValue > coordinateSize.iHeight)

 	            {

 	            // Command Syntax Error            

 	            User::Leave( KErrNotSupported );           

 	            }

 	        }

 	    else

 	        {

 	        // Command Syntax Error            

 	        User::Leave( KErrNotSupported );             

 	        }       

 	    }

 	TRawEvent rawEvent;

	switch(actionValue)

		{

		case 0:  // Release pointer event

		    {

			rawEvent.Set( TRawEvent::EButton1Up, xCoordinateValue, yCoordinateValue);

			iWsSession.SimulateRawEvent(rawEvent);

			iWsSession.Flush();

			break;

			}

		case 1:   // Depress pointer event

			{

			rawEvent.Set( TRawEvent::EButton1Down, xCoordinateValue, yCoordinateValue);

			iWsSession.SimulateRawEvent(rawEvent);

			iWsSession.Flush();

			break;

			}

		case 2:   // Single tap pointer event

			{

			rawEvent.Set( TRawEvent::EButton1Down, xCoordinateValue, yCoordinateValue);

			iWsSession.SimulateRawEvent(rawEvent);

			rawEvent.Set( TRawEvent::EButton1Up, xCoordinateValue+1, yCoordinateValue+1);

			iWsSession.SimulateRawEvent(rawEvent);

			iWsSession.Flush();

			break;

			}

		case 3:   // Double tap pointer event

			{

			rawEvent.Set( TRawEvent::EButton1Down, xCoordinateValue, yCoordinateValue);

			iWsSession.SimulateRawEvent(rawEvent);

			rawEvent.Set( TRawEvent::EButton1Up, xCoordinateValue+1, yCoordinateValue+1);

			iWsSession.SimulateRawEvent(rawEvent);

			rawEvent.Set( TRawEvent::EButton1Down, xCoordinateValue, yCoordinateValue);

			iWsSession.SimulateRawEvent(rawEvent);

			rawEvent.Set( TRawEvent::EButton1Up, xCoordinateValue+1, yCoordinateValue+1);

			iWsSession.SimulateRawEvent(rawEvent);

			iWsSession.Flush();

			break;

			}

		}

	}     

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

// CATCmdPluginEcom::HandleCkpdCommandL

// Handle CKPD command

// (may leave)

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

//

void CATCmdPluginEcom::HandleCkpdCommandL( const TDesC8& aCmd )

    {

    TRACE_FUNC_ENTRY

    TBool commandVerified(EFalse);

    TInt strokeTime = 0;

    TInt strokeDelay = 0;

    if ( aCmd.Compare( KTestCommand ) == 0 )

        {

        iReplyBuf->Append( KCRLF );

        iReplyBuf->Append( KAtCkpd );

        iReplyBuf->Append( KCkpdTestCommandResp );

        iReplyBuf->Append( KCRLF );

        TRACE_FUNC_EXIT

        return;

        }

    CArrayFix<TATCkpdCmd>* ckpdCmds = 

        new (ELeave) CArrayFixFlat<TATCkpdCmd>( KGranularity );

    CleanupStack::PushL( ckpdCmds );

    // Check that keys are defined

    if (  aCmd.Length() <= 1  )

        {

        // Command Syntax Error          

        User::Leave( KErrNotSupported );           

        }

    // Go through keys

    TBuf8<2> key;

    for (TInt i = 1 ; i < aCmd.Length(); i++ )

        {

        key.Copy(&aCmd[i],1);

        // Go through translation table for every character

        for ( TInt j = 0; j < iTranslations->Count(); j++ )

            {

            CATCmdTranslation& translation = *iTranslations->At( j );

            if ( key.CompareF( translation.Param() ) == 0 )

                {

                // Check if key is escape character for manufacturer specific keys

                if ( translation.Code() == KCustomKeyCodeIdentifier )

                    {

                    // Read next key to form key combination

                    i++;

                    // Check that there are key after escape character

                    if ( i >= aCmd.Length() )

                        {

                        TRACE_INFO(( _L( "INFO: invalid manufacturer specific key" ) ))            

                        // Not handled

                        User::Leave( KErrNotSupported );           

                        }

                    if ( key.Length() < key.MaxLength() )

                        {

                        key.Append(aCmd[i]);

                        }

                    // Start looping again for looking keycombination

                    // from translation table

                    j = 0;

                    }

                else

                    {

                    // Command verified

                    commandVerified = ETrue;

                    if ( translation.Code() != EKeyNull )

                        {

                        TATCkpdCmd cmd;

                        cmd.iCode = translation.Code();

                        ckpdCmds->AppendL( cmd );

                        }

                    break;

                    }

                }

            }

        if (!commandVerified)

            {

            // Check if character is parameter separator

            if ( key.Compare( KParameterSeparator ) == 0 )

                {

                i++;

                if ( i > aCmd.Length() )

                    {

                    TRACE_ERROR(( _L( "ERROR: invalid stroke time parameter" ) ))

                    // Not handled

                    User::Leave( KErrNotSupported );

                    }

                ParseParametersL(

                        aCmd.Right(aCmd.Length()-i),

                        strokeTime,

                        strokeDelay);

                strokeTime *= KTimeMultiplier;