/*

* Copyright (c) 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:  Functional implementation of pointer event service

*

*/

// INCLUDE FILES

#include "HtiKeyEventServicePlugin.h"

#include "PointerEventHandler.h"

#include <HtiDispatcherInterface.h>

#include <HtiLogging.h>

// CONSTANTS

_LIT8( KErrorMissingCommand, "Command was not given - message was empty" );

_LIT8( KErrorServiceNotReady, "Service is busy - possibly executing long running pointer events" );

_LIT8( KErrorInvalidParameters, "Command parameters not valid" );

_LIT8( KErrorUnrecognizedCommand, "Unrecognized command" );

_LIT8( KErrorInternalFailure, "Internal pointer command failure" );

_LIT8( KErrorGetHALData, "Can not get the HAL data" );

const TInt KTapCmdLength = 10;

const TInt KDragMultiCmdMinLength = 14;

const TInt KSinglePointerCmdLength = 4;

const TInt KAdvancedTapScreenCmdMinLength = 16;

const TInt KPinchZoomCmdMinLength = 30;

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

// CPointerEventHandler::NewL()

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

CPointerEventHandler* CPointerEventHandler::NewL()

    {

    HTI_LOG_FUNC_IN( "CPointerEventHandler::NewL" );

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

    CleanupStack::PushL ( self );

    self->ConstructL();

    CleanupStack::Pop();

    HTI_LOG_FUNC_OUT( "CPointerEventHandler::Done" );

    return self;

    }

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

// CPointerEventHandler::CPointerEventHandler()

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

CPointerEventHandler::CPointerEventHandler()

    : CActive( CActive::EPriorityStandard ), iReady( ETrue ), iCommand( 0 ),

      iState( EPointerUp )

    {

    }

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

// CPointerEventHandler::~CPointerEventHandler()

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

CPointerEventHandler::~CPointerEventHandler()

    {

    HTI_LOG_TEXT( "CPointerEventHandler destroy" );

    Cancel();

    iTimer.Close();

    iWsSession.Close();

    if ( iCoords )

        {

        iCoords->Close();

        }

    delete iCoords;

	iAdvancedPointers.ResetAndDestroy();

	iDelayArray.ResetAndDestroy();  

	iAdvPointerMoveArray.ResetAndDestroy(); 

    }

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

// CPointerEventHandler::ConstructL()

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

void CPointerEventHandler::ConstructL()

    {

    HTI_LOG_TEXT( "CPointerEventHandler::ConstructL" );

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

    User::LeaveIfError( iTimer.CreateLocal() );

    CActiveScheduler::Add( this );

    }

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

// void CPointerEventHandler::SetDispatcher()

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

void CPointerEventHandler::SetDispatcher( MHtiDispatcher* aDispatcher )

    {

    iDispatcher = aDispatcher;

    }

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

// CPointerEventHandler::RunL()

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

void CPointerEventHandler::RunL()

    {

    HTI_LOG_FUNC_IN( "CPointerEventHandler::RunL" );

    if ( iCommand == ETapScreen || iCommand == EAdvancedTapScreen )

        {

        ChangePointerStateL();

        }

    else if ( iCommand == ETapAndDrag  && iState == EPointerDown )

        {

        PointerMove();

        PointerUp();

        SendOkMsgL();

        iReady = ETrue;

        }

    else if ( iCommand == ETapAndDragMultipoint )

        {

        if ( iState == EPointerUp )  // Starting a new line

            {

            PointerDown();

            iTapCount--;

            iTimer.After( iStatus, iEventDelay );

            SetActive();

            }

        else

            {

            MoveToNextPointL(); // Continuing current line

            }

        }

    else if ( iCommand == EPinchZoom )

        {

        PointerMove();

        if ( !AdvancedStartDelay())

            {

            PointerUp();

            SendOkMsgL();

            iReady = ETrue;

            }

        }		

    HTI_LOG_FUNC_OUT( "CPointerEventHandler::RunL" );

    }

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

// CPointerEventHandler::RunError()

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

TInt CPointerEventHandler::RunError( TInt aError )

    {

    HTI_LOG_FORMAT( "CPointerEventHandler::RunError %d", aError );

    TInt dispatchResult = KErrNone;

    TRAP( dispatchResult, SendErrorMessageL( aError, KErrorInternalFailure ) );

    if ( dispatchResult != KErrNone )

        {

        HTI_LOG_FORMAT( "CPointerEventHandler::RunError: Failed to send error report to framework: %d.", dispatchResult );

        }

    iReady = ETrue;

    return KErrNone;

    }

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

// CPointerEventHandler::DoCancel()

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

void CPointerEventHandler::DoCancel()

    {

    iTimer.Cancel();

    }

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

// CPointerEventHandler::ProcessMessageL()

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

void CPointerEventHandler::ProcessMessageL( const TDesC8& aMessage,

    THtiMessagePriority /*aPriority*/ )

    {

    HTI_LOG_FUNC_IN("CPointerEventHandler::ProcessMessageL");

    HTI_LOG_FORMAT("Msg len: %d.", aMessage.Length());

    if ( !iReady )

        {

        SendErrorMessageL( ENotReadyCommand, KErrorServiceNotReady );

        return;

        }

    if ( aMessage.Length() == 0 )

        {

        SendErrorMessageL( EMissingCommand, KErrorMissingCommand );

        return;

        }

    User::ResetInactivityTime();

    iCommand = aMessage.Ptr()[0];

    switch ( iCommand )

        {

        case ETapScreen:

            HandleTapScreenL( aMessage.Right( aMessage.Length() - 1 ) );

            break;

        case ETapAndDrag:

            HandleTapAndDragL( aMessage.Right( aMessage.Length() - 1 ) );

            break;

        case ETapAndDragMultipoint:

            HandleTapAndDragMultipointL(

                aMessage.Right( aMessage.Length() - 1 ) );

            break;

        case EPressPointerDown:

        case ELiftPointerUp:

            HandlePointerDownOrUpL( aMessage.Right( aMessage.Length() - 1 ) );

            break;

		case EAdvancedTapScreen:

		    HandleAdvancedTapScreenL( aMessage.Right( aMessage.Length() - 1 ) );

            break;		

		case EPinchZoom: 

		    HandlePinchZoomL( aMessage.Right( aMessage.Length() - 1 ) );

            break;

        default:

            SendErrorMessageL( EUnrecognizedCommand,

                KErrorUnrecognizedCommand );

            break;

        }

    HTI_LOG_FUNC_OUT( "CPointerEventHandler::ProcessMessageL: Done" );

    }

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

// CPointerEventHandler::HandleTapScreenL()

// Handles single or multiple taps to one point.

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

void CPointerEventHandler::HandleTapScreenL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CPointerEventHandler::HandleTapScreenL" );

    if ( aData.Length() != KTapCmdLength )

        {

        SendErrorMessageL( EInvalidParameters, KErrorInvalidParameters );

        return;

        }

    // Parse the parameters - correct length is already verified

    TInt offset = 0;

    iX = aData[offset] + ( aData[offset+1] << 8 );

    offset += 2;

    HTI_LOG_FORMAT( "X coord = %d", iX );

    iY = aData[offset] + ( aData[offset+1] << 8 );

    offset += 2;

    HTI_LOG_FORMAT( "Y coord = %d", iY );

    iEventDelay = ( aData[offset] + ( aData[offset+1] << 8 ) ) * 1000;

    offset += 2;

    HTI_LOG_FORMAT( "Time to hold down = %d", iEventDelay.Int() );

    iTapCount = aData[offset] + ( aData[offset+1] << 8 );

    offset += 2;

    HTI_LOG_FORMAT( "Tap count = %d", iTapCount );

    iActionDelay = ( aData[offset] + ( aData[offset+1] << 8 ) ) * 1000;

    HTI_LOG_FORMAT( "Pause between taps = %d", iActionDelay.Int() );

    // Start tapping

    iReady = EFalse;

    ChangePointerStateL();

    HTI_LOG_FUNC_OUT( "CPointerEventHandler::HandleTapScreenL" );

    }

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

// CPointerEventHandler::HandleTapAndDragL()

// Handles a single drag and drop with straight line.

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

void CPointerEventHandler::HandleTapAndDragL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CPointerEventHandler::HandleTapAndDragL" );

    if ( aData.Length() != KTapCmdLength )

        {

        SendErrorMessageL( EInvalidParameters, KErrorInvalidParameters );

        return;

        }

    TInt offset = 0;

    iX = aData[offset] + ( aData[offset+1] << 8 );

    offset += 2;

    HTI_LOG_FORMAT( "X coord down = %d", iX );

    iY = aData[offset] + ( aData[offset+1] << 8 );

    offset += 2;

    HTI_LOG_FORMAT( "Y coord down = %d", iY );

    TInt xUp = aData[offset] + ( aData[offset+1] << 8 );

    offset += 2;

    HTI_LOG_FORMAT( "X coord up = %d", xUp );

    TInt yUp = aData[offset] + ( aData[offset+1] << 8 );

    offset += 2;

    HTI_LOG_FORMAT( "Y coord up = %d", yUp );

    iEventDelay = ( aData[offset] + ( aData[offset+1] << 8 ) ) * 1000;

    HTI_LOG_FORMAT( "Drag time = %d", iEventDelay.Int() );

    iReady = EFalse;

    PointerDown();

    iX = xUp;

    iY = yUp;

    iTimer.After( iStatus, iEventDelay );

    SetActive();

    HTI_LOG_FUNC_OUT( "CPointerEventHandler::HandleTapAndDragL" );

    }

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

// CPointerEventHandler::HandleTapAndDragMultipointL()

// Handles drawing one or more curvy lines.

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

void CPointerEventHandler::HandleTapAndDragMultipointL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CPointerEventHandler::HandleTapAndDragMultipointL" );

    TInt dataLength = aData.Length();

    if ( dataLength < KDragMultiCmdMinLength || dataLength % 2 != 0 )

        {

        SendErrorMessageL( EInvalidParameters, KErrorInvalidParameters );

        return;

        }

    TInt offset = 0;

    iEventDelay = ( aData[offset] + ( aData[offset+1] << 8 ) ) * 1000;

    offset += 2;

    HTI_LOG_FORMAT( "Time between events = %d", iEventDelay.Int() );

    iActionDelay = ( aData[offset] + ( aData[offset+1] << 8 ) ) * 1000;

    offset += 2;

    HTI_LOG_FORMAT( "Pause between lines = %d", iActionDelay.Int() );

    if ( iCoords == NULL )

        {

        iCoords = new ( ELeave ) RArray<TInt>();

        }

    iCoords->Reset();

    // Read integers from aData to the array, all integers are 2 bytes

    while ( offset < dataLength )

        {

        iCoords->AppendL( aData[offset] + ( aData[offset + 1] << 8 ) );

        offset += 2;

        }

    iReady = EFalse;

    iTapCount = ( *iCoords )[0];

    iCoords->Remove( 0 );

    iX = ( *iCoords )[0];

    iCoords->Remove( 0 );

    iY = ( *iCoords )[0];

    iCoords->Remove( 0 );

    HTI_LOG_FORMAT( "Point count for first line = %d", iTapCount );

    PointerDown();

    iTapCount--;

    iTimer.After( iStatus, iEventDelay );

    SetActive();

    HTI_LOG_FUNC_OUT( "CPointerEventHandler::HandleTapAndDragMultipointL" );

    }

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

// CPointerEventHandler::HandlePointerDownOrUpL()

// Handles pushing pointer down in one point or lifting it up.

// This is synchronous operation and sends OK message right after the event

// is simulated.

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

void CPointerEventHandler::HandlePointerDownOrUpL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CPointerEventHandler::HandlePointerDownOrUpL" );

    if ( aData.Length() != KSinglePointerCmdLength )

        {

        SendErrorMessageL( EInvalidParameters, KErrorInvalidParameters );

        return;

        }

    // Parse the parameters - correct length is already verified

    TInt offset = 0;

    iX = aData[offset] + ( aData[offset+1] << 8 );

    offset += 2;

    HTI_LOG_FORMAT( "X coord = %d", iX );

    iY = aData[offset] + ( aData[offset+1] << 8 );

    offset += 2;

    HTI_LOG_FORMAT( "Y coord = %d", iY );

    if ( iCommand == EPressPointerDown )

        {

        PointerDown();

        }

    else

        {

        PointerUp();

        }

    SendOkMsgL();

    HTI_LOG_FUNC_OUT( "CPointerEventHandler::HandlePointerDownOrUpL" );

    }

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

// CPointerEventHandler::ChangePointerStateL()

// Decides whether to do  "pointer down" or "pointer up" event next or if

// operation is complete.

// This function is used by ETapScreen command.

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

void CPointerEventHandler::ChangePointerStateL()

    {

    HTI_LOG_FUNC_IN( "CPointerEventHandler::ChangePointerStateL" );

    HTI_LOG_FORMAT( "Taps remaining = %d", iTapCount );

    if ( iTapCount < 1 )

        {

        SendOkMsgL();

        iReady = ETrue;

        return;

        }

    if ( iState == EPointerUp )

        {

        PointerDown();

        iTimer.After( iStatus, iEventDelay );

        SetActive();

        }

    else if ( iState == EPointerDown )

        {

        PointerUp();

        iTapCount--; // one tap done

        if ( iTapCount > 0 ) // do we continue tapping?

            {

            iTimer.After( iStatus, iActionDelay );

            SetActive();

            }

        else

            {

            SendOkMsgL();  // tapping done

            iReady = ETrue;

            }

        }

    HTI_LOG_FUNC_OUT( "CPointerEventHandler::ChangePointerStateL" );

    }

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

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

// CPointerEventHandler::HandleAdvancedTapScreenL()

// ****cherry.

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

void CPointerEventHandler::HandleAdvancedTapScreenL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CPointerEventHandler::HandleAdvancedTapScreenL" );

    if ( aData.Length() < KAdvancedTapScreenCmdMinLength ) //KAdvancedTapScreenCmdMinLength needs to be defined

        {

        SendErrorMessageL( EInvalidParameters, KErrorInvalidParameters );

        return;

        }

	TInt dataLength = aData.Length();

    // Parse the parameters - correct length is already verified

	TInt offset = 0;

	iEventDelay = ( aData[offset] + ( aData[offset+1] << 8 ) ) * 1000;

    offset += 2;

    HTI_LOG_FORMAT( "Time to hold down = %d", iEventDelay.Int() );

    iTapCount = aData[offset] + ( aData[offset+1] << 8 );

    offset += 2;

    HTI_LOG_FORMAT( "Tap count = %d", iTapCount );

    iActionDelay = ( aData[offset] + ( aData[offset+1] << 8 ) ) * 1000;

	offset += 2;

    HTI_LOG_FORMAT( "Pause between taps = %d", iActionDelay.Int() );		

	TInt pointerCount = aData[offset] + ( aData[offset+1] << 8 );

	offset += 2;

	HTI_LOG_FORMAT( "Pointer Count = %d", pointerCount );

    iAdvancedPointers.ResetAndDestroy();

    // Read integers from aData to the array, all integers are 2 bytes

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

        {

		TAdvancedPointer* advancedPointer = new (ELeave) TAdvancedPointer;

		advancedPointer->PointerNum = aData[offset];

		offset += 1;

		HTI_LOG_FORMAT( "%d Pointer", advancedPointer->PointerNum );

		advancedPointer->X = aData[offset] + ( aData[offset+1] << 8 );

		offset += 2;

		HTI_LOG_FORMAT( "X coord down = %d", advancedPointer->X );

		advancedPointer->Y = aData[offset] + ( aData[offset+1] << 8 );

		offset += 2;

		HTI_LOG_FORMAT( "Y coord down = %d", advancedPointer->Y );

		advancedPointer->Z = aData[offset] + ( aData[offset+1] << 8 );

		offset += 2;

		HTI_LOG_FORMAT( "Z coord down = %d", advancedPointer->Z );

        iAdvancedPointers.AppendL( advancedPointer );

        }

    // Start tapping

    iReady = EFalse;

    ChangePointerStateL();

    HTI_LOG_FUNC_OUT( "CPointerEventHandler::HandleAdvancedTapScreenL" );

    }

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

// CPointerEventHandler::HandlePinchZoomL()

// ****cherry

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

void CPointerEventHandler::HandlePinchZoomL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CPointerEventHandler::HandlePinchZoomL" );

    if ( aData.Length() < KPinchZoomCmdMinLength ) //KPinchZoomCmdMinLength needs to be defined

        {

        SendErrorMessageL( EInvalidParameters, KErrorInvalidParameters );

        return;