/*

* 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 advanced pointer multitouch service

*

*/

// INCLUDE FILES

#include "HtiKeyEventServicePlugin.h"

#include "MultiTouchPointerEventHandler.h"

#include "MultiTouchPointerEvent.h"

#include <HtiDispatcherInterface.h>

#include <HtiLogging.h>

// CONSTANTS

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

// CMultiTouchPointerEventHandler::NewL()

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

CMultiTouchPointerEventHandler* CMultiTouchPointerEventHandler::NewL(MHtiMultiTouchObserver& aObserver)

    {

    HTI_LOG_FUNC_IN( "CMultiTouchPointerEventHandler::NewL" );

    CMultiTouchPointerEventHandler* self = new (ELeave) CMultiTouchPointerEventHandler(aObserver);

    CleanupStack::PushL ( self );

    self->ConstructL();

    CleanupStack::Pop();

    HTI_LOG_FUNC_OUT( "CMultiTouchPointerEventHandler::NewL" );

    return self;

    }

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

// CMultiTouchPointerEventHandler::CMultiTouchPointerEventHandler()

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

CMultiTouchPointerEventHandler::CMultiTouchPointerEventHandler(MHtiMultiTouchObserver& aObserver)

	:iFinishedCount(0),	iObserver(aObserver)

    {

    HTI_LOG_TEXT( "CMultiTouchPointerEventHandler constructor" );

    }

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

// CMultiTouchPointerEventHandler::~CMultiTouchPointerEventHandler()

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

CMultiTouchPointerEventHandler::~CMultiTouchPointerEventHandler()

    {

    HTI_LOG_TEXT( "CMultiTouchPointerEventHandler destructor" );    

    Clear();

    iWsSession.Close();

    }

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

// CMultiTouchPointerEventHandler::ConstructL()

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

void CMultiTouchPointerEventHandler::ConstructL()

    {

    HTI_LOG_TEXT( "CMultiTouchPointerEventHandler::ConstructL" ); 

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

    }

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

// CMultiTouchPointerEventHandler::Clear()

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

void CMultiTouchPointerEventHandler::Clear()

	{

	HTI_LOG_TEXT( "CMultiTouchPointerEventHandler::Clear" ); 

	iTouchPointerArray.ResetAndDestroy();

	iFinishedCount=0;

	}

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

// CMultiTouchPointerEventHandler::NotifyTouchComplete()

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

void CMultiTouchPointerEventHandler::NotifyTouchComplete(TUint8 aTouchNumber)

    {

    HTI_LOG_FUNC_IN("CMultiTouchPointerEventHandler::NotifyTouchComplete");

    iFinishedCount++;

    HTI_LOG_FORMAT( "touch number %d finished", aTouchNumber);

    HTI_LOG_FORMAT( "%d touch finished", iFinishedCount);

    if(iTouchPointerArray.Count() == iFinishedCount)

    	{

		// notify observer

		iObserver.NotifyMultiTouchComplete();

    	}

    HTI_LOG_FUNC_OUT("CMultiTouchPointerEventHandler::NotifyTouchComplete");

    }

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

// CMultiTouchPointerEventHandler::ParsePoint()

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

TBool CMultiTouchPointerEventHandler::ParsePoint( const TDesC8& aData, TInt& aoffset,

		TInt& aX, TInt& aY, TInt& aZ, 

		TTimeIntervalMicroSeconds32& aWait, TTimeIntervalMicroSeconds32& aHold )

    {

    HTI_LOG_FUNC_IN( "CMultiTouchPointerEventHandler::ParsePoint" );

    TInt dataLength = aData.Length();

    if ( dataLength-aoffset < 14 ) 

        return EFalse ;

    aX = aData[aoffset] + ( aData[aoffset+1] << 8 );

    aoffset += 2;

    aY = aData[aoffset] + ( aData[aoffset+1] << 8 );

    aoffset += 2;

    aZ = aData[aoffset] + ( aData[aoffset+1] << 8 );

    aoffset += 2;

    aWait = (aData[aoffset] + ( aData[aoffset+1] << 8 )

                + ( aData[aoffset+2] << 16 ) + (aData[aoffset+3] << 24) ) * 1000;

    aoffset += 4;      

    aHold = ( aData[aoffset] + ( aData[aoffset+1] << 8 )

                + ( aData[aoffset+2] << 16 ) + (aData[aoffset+3] << 24) ) * 1000;

    aoffset += 4;

    HTI_LOG_FUNC_OUT( "CMultiTouchPointerEventHandler::ParsePoint" );

    return ETrue;

    }

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

// CMultiTouchPointerEventHandler::ParseMove()

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

TBool CMultiTouchPointerEventHandler::ParseMove( const TDesC8& aData, TInt& aoffset,

		TTimeIntervalMicroSeconds32& aDragTime, TInt& aStepCount )

    {

    HTI_LOG_FUNC_IN( "CMultiTouchPointerEventHandler::ParseMove" );

    TInt dataLength = aData.Length();

    if ( dataLength-aoffset < 6 ) 

        return EFalse ;

    aDragTime = ( aData[aoffset] + ( aData[aoffset+1] << 8 )

				+ ( aData[aoffset+2] << 16 ) + (aData[aoffset+3] << 24) ) * 1000;

    aoffset += 4;

	aStepCount = aData[aoffset] + ( aData[aoffset+1] << 8 );

	aoffset += 2;

    HTI_LOG_FUNC_OUT( "CMultiTouchPointerEventHandler::ParseMove" );

    return ETrue;

    }

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

// CMultiTouchPointerEventHandler::HandleMultiTouchL()

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

TBool CMultiTouchPointerEventHandler::HandleMultiTouchL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CMultiTouchPointerEventHandler::HandleMultiTouchL" );

    TBool validparameter=EFalse;

    TInt dataLength = aData.Length();

    if ( dataLength < 1 )

        return validparameter;

    // Parse the parameters - correct length is already verified

	TInt offset = 0;

    TInt touchCount = aData[offset];

    offset += 1;

    HTI_LOG_FORMAT( "Number of touches: %d", touchCount );

    if (touchCount<=0)

    	return validparameter;

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

        {

        //check valid data length

        if(dataLength-offset < 3)

            return validparameter;

        TInt pointerNumber = aData[offset];

        offset += 1;

        HTI_LOG_FORMAT( "Pointer Number %d", pointerNumber );

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

        offset += 2;

        HTI_LOG_FORMAT( "Number of points: %d", pointerCount );

        if (pointerCount == 0 )

            return validparameter;

        CMultiTouchPointerEvent* touch = CMultiTouchPointerEvent::NewL(pointerNumber,this);        

        CleanupStack::PushL(touch);

        iTouchPointerArray.AppendL(touch);

        CleanupStack::Pop();

        TInt lastX, lastY, lastZ, stepCount; 

        TTimeIntervalMicroSeconds32 dragTime;

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

        	{

			// read point

			TInt X1, Y1, Z1; 

			TTimeIntervalMicroSeconds32 waitTime, holdTime;

			if (!ParsePoint( aData, offset,X1, Y1, Z1, waitTime, holdTime))

				return validparameter;

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

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

			HTI_LOG_FORMAT( "Z coord down = %d", Z1 );

			HTI_LOG_FORMAT( "Event wait time = %d", waitTime.Int() );   

			HTI_LOG_FORMAT( "Point holding time = %d", holdTime.Int() );

			if ( waitTime.Int() < 0 || holdTime.Int() < 0 )

				return validparameter;

			// add move event from last point to this point 

			if (j!=0)

				{

				HTI_LOG_FORMAT( "Point dragging time = %d", dragTime.Int() );

				HTI_LOG_FORMAT( "Step count between two points = %d", stepCount );

				touch->InterpolatePointL(lastX, lastY, lastZ,X1,Y1,Z1,dragTime,stepCount);

				}				

			// set last point

			lastX=X1;

			lastY=Y1;

			lastZ=Z1;

			// wait event

			touch->AddPointL(waitTime,X1,Y1,Z1,TRawEvent::EButton1Down);

			// hold event

			touch->AddPointL(holdTime, X1,Y1,Z1,TRawEvent::EPointerMove);

			if (j!=pointerCount-1)

				{

				// not last point

				if (!ParseMove(aData, offset, dragTime, stepCount))

					return validparameter;				

				if (dragTime.Int() < 0 || stepCount <= 0)

					return validparameter;        				

				}

			else

				{

				// last point

				touch->AddPointL(0,X1,Y1,Z1,TRawEvent::EButton1Up);

				}

        	}  

            touch->PrintInfo();

        } 

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

        iTouchPointerArray[i]->StartTouch();

    validparameter=ETrue;

    HTI_LOG_FUNC_OUT( "CMultiTouchPointerEventHandler::HandleMultiTouchL" );

    return validparameter;

    }	

void CMultiTouchPointerEventHandler::SimulateEvent(TUint8 aTouchNumber, 

		TInt aX, TInt aY, TInt aZ, TRawEvent::TType aEventType)

    {

    HTI_LOG_FUNC_IN( "CMultiTouchPointerEventHandler::SimulateEvent" );

	TRawEvent rawEvent;

	rawEvent.SetPointerNumber( aTouchNumber ); 

	rawEvent.Set( aEventType, aX,  aY,  aZ);   

	HTI_LOG_FORMAT( "SimulatePointer touch number=%d ", aTouchNumber );

	HTI_LOG_FORMAT( "SimulatePointer event=%d ", aEventType );

	HTI_LOG_FORMAT( "SimulatePointer X=%d ", aX );

	HTI_LOG_FORMAT( "SimulatePointer Y=%d ", aY );

	HTI_LOG_FORMAT( "SimulatePointer Z=%d", aZ );

	iWsSession.SimulateRawEvent( rawEvent );

	iWsSession.Flush();

    HTI_LOG_FUNC_OUT( "CMultiTouchPointerEventHandler::SimulateEvent" );

    }

// End of file