/*
* 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:  Tap touch gesture recognizer.
*
*/

#include "akntouchgesturefwdefs.h"
#include "akntouchgesturefwevent.h"
#include "akntouchgesturefwsettings.h"
#include "akntouchgesturefwtaprecognizer.h"

using namespace AknTouchGestureFw;

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

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CAknTouchGestureFwTapRecognizer* CAknTouchGestureFwTapRecognizer::NewL(
        CAknTouchGestureFwRecognitionEngine& aEngine )
    {
    CAknTouchGestureFwTapRecognizer* self =
        CAknTouchGestureFwTapRecognizer::NewLC( aEngine );
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CAknTouchGestureFwTapRecognizer* CAknTouchGestureFwTapRecognizer::NewLC(
        CAknTouchGestureFwRecognitionEngine& aEngine )
    {
    CAknTouchGestureFwTapRecognizer* self
        = new ( ELeave ) CAknTouchGestureFwTapRecognizer( aEngine );
    CleanupStack::PushL( self );
    return self;
    }


// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CAknTouchGestureFwTapRecognizer::~CAknTouchGestureFwTapRecognizer()
    {
    if ( iLongTapTimer )
        {
        iLongTapTimer->Cancel();
        }
    delete iLongTapTimer;
    }


// ---------------------------------------------------------------------------
// Returns the tap gesture group.
// ---------------------------------------------------------------------------
//
TAknTouchGestureFwGroup CAknTouchGestureFwTapRecognizer::GestureGroup() const
    {
    return EAknTouchGestureFwGroupTap;
    }


// ---------------------------------------------------------------------------
// Cancels the tap recognition.
// ---------------------------------------------------------------------------
//
void CAknTouchGestureFwTapRecognizer::CancelRecognizing()
    {
    DoCancelTapRecognition( ETrue );
    }


// ---------------------------------------------------------------------------
// Handles single-touch pointer events.
// ---------------------------------------------------------------------------
//
void CAknTouchGestureFwTapRecognizer::HandleSinglePointerEventL(
        const TPointerEventData& aPointerData )
    {
    switch ( aPointerData.iPointerEvent.iType )
        {
        case TPointerEvent::EButton1Down:
            {
            // Start recognition on down event
            StartTapRecognition( 
                    aPointerData.iPointerEvent.iPosition,
                    aPointerData.iTimeStamp );
            break;
            }
        case TPointerEvent::EDrag:
            {
            // Continue tap recognizing.
            TapRecognize( aPointerData.iPointerEvent.iPosition );
            break;
            }
        case TPointerEvent::EButton1Up:
            {
            // Pointer up - complete recognition
            CompleteTapRecognitionL( aPointerData.iTimeStamp );
            break;
            }
        default:
            {
            break;
            }
        }
    }


// ---------------------------------------------------------------------------
// Handles multi-touch pointer events.
// ---------------------------------------------------------------------------
//
void CAknTouchGestureFwTapRecognizer::HandleMultiPointerEventL(
    const TPointerEventData& aPointerData,
    const TPoint& /*aFirstPointerPosition*/,
    const TPoint& /*aSecondPointerPosition*/ )
    {
    if ( aPointerData.iPointerEvent.iType == TPointerEvent::EButton1Down )
        {
        // First pointer is already down, second pointer down cancels tap
        // recognizing because taps are allowed only for the first pointer.
        CancelRecognizing();
        }
    }


// ---------------------------------------------------------------------------
// C++ constructor.
// ---------------------------------------------------------------------------
//
CAknTouchGestureFwTapRecognizer::CAknTouchGestureFwTapRecognizer(
        CAknTouchGestureFwRecognitionEngine& aEngine )
    : CAknTouchGestureFwBaseRecognizer( aEngine ),
    iThresholdArea(),
    iLongTapTimer( NULL ),
    iFirstTapDetected( EFalse ),
    iFirstTapTime(),
    iFirstTapPos(),
    iLongTapIntensity( 0 ),
    iFeedBackStarted( EFalse ) 
    {
    }


// ---------------------------------------------------------------------------
// Starts the tap gesture recognition.
// ---------------------------------------------------------------------------
//
void CAknTouchGestureFwTapRecognizer::StartTapRecognition(
    const TPoint& aStartPoint, 
    const TTime& aTimeStamp )
    {
    iThresholdArea.Start( aStartPoint );

    // Start timer to recognize long tap
    if ( !iLongTapTimer )
        {
        iLongTapTimer = CPeriodic::New( CActive::EPriorityStandard );
        }

    if ( iLongTapTimer )
        {
        iLongTapTimer->Cancel();
        // Set timer for initial long tap delay.
        iLongTapTimer->Start( KDefaultLongTapInitialDelay, 
                              KDefaultLongTapInitialDelay,
                              TCallBack( LongTapCallback, this ) );
        }

    if ( iFirstTapDetected )
        {
        // First tap already detected, check if this tap is double tap

        // Check if position of this tap is too far from
        // position of first tap.
        TInt xDistance = Abs( aStartPoint.iX - iFirstTapPos.iX );
        TInt yDistance = Abs( aStartPoint.iY - iFirstTapPos.iY );

        if ( xDistance > DragThreshold() || yDistance > DragThreshold() )
            {
            // Too far, this tap can't be double tap.
            iFirstTapDetected = EFalse;
            return;
            }

        // Check if delay between already detected tap and this tap is too long.
        TInt delay( aTimeStamp.MicroSecondsFrom( iFirstTapTime ).Int64() );

        if ( delay > DoubleTapMaximumDuration() )
            {
            // Delay is too long, this tap can't be double tap.
            iFirstTapDetected = EFalse;
            }
        }
    }


// ---------------------------------------------------------------------------
// Continues the tap gesture recognition, called on drag pointer events.
// ---------------------------------------------------------------------------
//
void CAknTouchGestureFwTapRecognizer::TapRecognize( const TPoint& aPoint )
    {
    if ( iThresholdArea.Check( aPoint, TapThreshold() ) )
        {
        CancelRecognizing();
        }
    }


// ---------------------------------------------------------------------------
// Ends the tap gesture recognition.
// ---------------------------------------------------------------------------
//
void CAknTouchGestureFwTapRecognizer::CompleteTapRecognitionL( 
    const TTime& aTimeStamp )
    {
    if ( iThresholdArea.IsActive() )
        {
        // Single pointer has been down and goes up now
        // and tap recognition hasn't been cancelled
        const TPoint startPos( iThresholdArea.InitialPosition() );

        // Cancel tap recognition of this tap, but don't
        // remove the possible info that first tap has already been detected
        DoCancelTapRecognition( EFalse );

        if ( iFirstTapDetected )
            {
            iFirstTapDetected = EFalse;
            // First tap already detected: Send Double Tap gesture event
            SendTapEventL( EAknTouchGestureFwDoubleTap, iFirstTapPos );
            }
        else
            {
            iFirstTapTime = aTimeStamp;
            iFirstTapDetected = ETrue;
            iFirstTapPos = startPos;

            // First tap not detected: Send normal Tap gesture event
            SendTapEventL( EAknTouchGestureFwTap, startPos );
            }
        }
    }


// ---------------------------------------------------------------------------
// Sends a tap gesture event to the observer.
// ---------------------------------------------------------------------------
//
void CAknTouchGestureFwTapRecognizer::SendTapEventL(
    TAknTouchGestureFwType aGestureType,
    const TPoint& aPointerPos )
    {
    TTouchFeedbackType feedbackType( FeedbackType( aGestureType ) );
    if ( feedbackType )
        {
        switch ( aGestureType )
            {
            case EAknTouchGestureFwTap:
                {
                ImmediateFeedback( ETouchFeedbackSensitive, feedbackType );
                break;
                }
            case EAknTouchGestureFwDoubleTap:
                {
                ImmediateFeedback( ETouchFeedbackBasic, feedbackType );
                break;
                }
            case EAknTouchGestureFwLongTap:
                {
                ImmediateFeedback( ETouchFeedbackBasic, feedbackType );                                                       
                break;
                }
            default:
                {
                break;
                }
            }    
        }

    TAknTouchGestureFwTapEvent tap;
    tap.SetType( aGestureType );
    tap.SetPosition( aPointerPos );
    SendGestureEventL( tap );
    }


// ---------------------------------------------------------------------------
// Called when long tap has been detected.
// ---------------------------------------------------------------------------
//
TInt CAknTouchGestureFwTapRecognizer::LongTapCallback( TAny* aThis )
    {
    CAknTouchGestureFwTapRecognizer* recognizer =
        static_cast<CAknTouchGestureFwTapRecognizer*>( aThis );
    if ( recognizer )
        {
        TRAP_IGNORE( recognizer->HandleLongTapCallbackL() );
        }
    return 0;
    }


// ---------------------------------------------------------------------------
// Handles long tap callback related actions.
// ---------------------------------------------------------------------------
//
void CAknTouchGestureFwTapRecognizer::HandleLongTapCallbackL()
    {   
    if ( iLongTapIntensity == 0 && iLongTapTimer )
        {   
        iLongTapTimer->Cancel();

        TInt interval = ( LongTapThreshold() - KDefaultLongTapInitialDelay )
            / KDefaultMaxLongTapIntensitySteps;
        
        TInt timeOut = 
            interval * ( KDefaultMaxLongTapIntensitySteps + 1 );
        
        // Start timer again to increase long tap intensity on
        // regular interval until max intensity is reached.
        iLongTapTimer->Start( 0, interval,
            TCallBack( LongTapCallback, this ) );
        
        TTouchFeedbackType feedbackType(
            FeedbackType( EAknTouchGestureFwTap ) );       
           
        if ( feedbackType & ETouchFeedbackVibra )
            {      
            // Start feedback for long tap gesture.
            StartContinuousFeedback( ETouchContinuousSmooth, 0, timeOut ); 
            iFeedBackStarted = ETrue;
            }
        }
 
    // Calculate new long tap intensity value.
    iLongTapIntensity = iLongTapIntensity + 
        KDefaultMaxLongTapIntensity / KDefaultMaxLongTapIntensitySteps;
    
    if ( iFeedBackStarted )
        {
        // Modify existing continuous feedback. Intensity will grow 
        // from 0 to 100 and after that long tap is detected. 
        ModifyContinuousFeedback( iLongTapIntensity );
        }
    
    if ( iLongTapIntensity >= KDefaultMaxLongTapIntensity )
        {
        const TPoint startPos( iThresholdArea.InitialPosition() );
        CancelRecognizing();
        // Send Long Tap gesture event.
        SendTapEventL( EAknTouchGestureFwLongTap, startPos );
        }            
    }


// ---------------------------------------------------------------------------
// Cancels the tap gesture recognition.
// ---------------------------------------------------------------------------
//
void CAknTouchGestureFwTapRecognizer::DoCancelTapRecognition(
        TBool aResetFirstTapDetection )
    {
    iThresholdArea.Reset();

    if ( aResetFirstTapDetection )
        {
        iFirstTapDetected = EFalse;
        }

    if ( iLongTapTimer )
        {
        iLongTapTimer->Cancel();
        
        if ( iLongTapIntensity > 0 )
            {
            StopContinuousFeedback();
            iFeedBackStarted = EFalse;
            iLongTapIntensity = 0;
            }
        }
    }


// ---------------------------------------------------------------------------
// Returns the value for the long tap threshold setting.
// ---------------------------------------------------------------------------
//
TInt CAknTouchGestureFwTapRecognizer::LongTapThreshold() const
    {
    return Settings().LongTapThreshold() * KMicroSecondsInMilliSecond;
    }


// ---------------------------------------------------------------------------
// Returns the value for the single tap threshold setting.
// ---------------------------------------------------------------------------
//
TInt CAknTouchGestureFwTapRecognizer::TapThreshold() const
    {
    return Settings().TapThreshold();
    }


// ---------------------------------------------------------------------------
// Returns the value for the double tap maximum duration setting.
// ---------------------------------------------------------------------------
//
TInt CAknTouchGestureFwTapRecognizer::DoubleTapMaximumDuration() const
    {
    return Settings().DoubleTapMaximumDuration() * KMicroSecondsInMilliSecond;
    }

// End of File