/*
* 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:  AknPhysics flick tracker
*
*/

#include <e32debug.h>

#include "aknphysicsconstants.h"
#include "aknphysicsflicktracker.h"
#include "aknphysicsparameterprovider.h"

const TInt KDistanceFactor( 1000000 );
const TInt KSpeedUpIncrease( 500 );
const TInt KIgnoreSpeedUpEvents( 3 );

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

// ---------------------------------------------------------------------------
// CAknPhysicsFlickTracker::NewL
// ---------------------------------------------------------------------------
//
CAknPhysicsFlickTracker* CAknPhysicsFlickTracker::NewL(
        CAknPhysicsParameterProvider* aProvider )
    {
    CAknPhysicsFlickTracker* self = 
        CAknPhysicsFlickTracker::NewLC( aProvider );
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CAknPhysicsFlickTracker::NewLC
// ---------------------------------------------------------------------------
//
CAknPhysicsFlickTracker* CAknPhysicsFlickTracker::NewLC(
        CAknPhysicsParameterProvider* aProvider )
    {
    CAknPhysicsFlickTracker* self 
        = new ( ELeave ) CAknPhysicsFlickTracker( aProvider );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


// ---------------------------------------------------------------------------
// CAknPhysicsFlickTracker::~CAknPhysicsDragObserver
// ---------------------------------------------------------------------------
//
CAknPhysicsFlickTracker::~CAknPhysicsFlickTracker()
    {
    }


// ---------------------------------------------------------------------------
// CAknPhysicsFlickTracker::InitTracker
// ---------------------------------------------------------------------------
//
void CAknPhysicsFlickTracker::InitTracker( const TInt& aCoordinate )
    {
    iDirection = EDirectionNone;
    iCoordinate = aCoordinate;
    InitFlickData( iDirectionData, aCoordinate );
    InitFlickData( iNormalStartData, aCoordinate );
    InitFlickData( iSpeedUpData, aCoordinate );
    InitFlickData( iSpeedUpStartData, aCoordinate );
    iLastDragTime.HomeTime();
    iChangeRegistered = EFalse;
    iSpeedUpRegistered = EFalse;
    iLastDragSpeed = 0;
    iIgnoredEvents = 0;
    }


// ---------------------------------------------------------------------------
// CAknPhysicsFlickTracker::DragChanged
// ---------------------------------------------------------------------------
//
void CAknPhysicsFlickTracker::DragChanged( const TInt& aCoordinate )
    {
    TBool changed( EFalse );
    TBool registered( EFalse );

    // First check if drag direction has changed
    TDirection direction( EDirectionNone );
    if ( aCoordinate > iCoordinate 
        && iDirection != EDirectionForward )
        {
        direction = EDirectionForward;
        }
    else if ( aCoordinate < iCoordinate 
        && iDirection != EDirectionBackward )
        {
        direction = EDirectionBackward;
        }

    if ( direction != EDirectionNone )
        {
        // Direction change only after first direction is saved
        if ( iDirection != EDirectionNone )
            {
            iDirectionData.iCoordinate = aCoordinate;
            iDirectionData.iTime.HomeTime();
            iChangeRegistered = EFalse;
            changed = ETrue;
            }
        iDirection = direction;
        }

    if ( !iChangeRegistered && iDirectionData.iCoordinate != iNormalStartData.iCoordinate )
        {
        TInt distance( iDirectionData.iCoordinate - aCoordinate );
        // Distance from direction change position has exceeded threshold
        // - save the direction changed position as new start position
        if ( Threshold() && Abs( distance ) > Threshold() )
            {
            iNormalStartData = iDirectionData;
            iChangeRegistered = ETrue;
            registered = ETrue;
            }
        }

    // No speed changes are registered when direction has changed
    if ( !changed && !registered )
        {
        SpeedChanged( aCoordinate );    	
        }
    // If direction was changed - reset speed change data
    else if ( registered )
        {
        iSpeedUpData = iNormalStartData;
        iSpeedUpStartData = iNormalStartData;
        iSpeedUpRegistered = EFalse;
        iIgnoredEvents = 0;
        iLastDragSpeed = 0;
        }
    
    iCoordinate = aCoordinate;
    iLastDragTime.HomeTime();
    }


// ---------------------------------------------------------------------------
// CAknPhysicsFlickTracker::FlickStartCoordinate
// ---------------------------------------------------------------------------
//
TInt CAknPhysicsFlickTracker::FlickStartCoordinate() const
    {
    // If move time from flick start point has exceeded flick maximum duration,
    // check if speed has increased and use speed-up position parameters
    if ( NormalFlickMoveTime() > KFlickMaxDuration )
        {
        return iSpeedUpStartData.iCoordinate;
        }
    return iNormalStartData.iCoordinate;
    }


// ---------------------------------------------------------------------------
// CAknPhysicsFlickTracker::FlickMoveTime
// ---------------------------------------------------------------------------
//
TInt CAknPhysicsFlickTracker::FlickMoveTime() const
    {
    // If move time from flick start point has exceeded flick maximum duration,
    // check if speed has increased and use speed-up position parameters
    if ( NormalFlickMoveTime() > KFlickMaxDuration )
        {
        TTime now;
        now.HomeTime();
        return now.MicroSecondsFrom( iSpeedUpStartData.iTime ).Int64();
        }
    return NormalFlickMoveTime();
    }


// ---------------------------------------------------------------------------
// CAknPhysicsFlickTracker::CAknPhysicsFlickTracker
// ---------------------------------------------------------------------------
//
CAknPhysicsFlickTracker::CAknPhysicsFlickTracker( 
        CAknPhysicsParameterProvider* aProvider )
    :
    iDirection( EDirectionNone ),
    iProvider( aProvider )
    {
    }


// ---------------------------------------------------------------------------
// CAknPhysicsFlickTracker::ConstructL
// ---------------------------------------------------------------------------
//
void CAknPhysicsFlickTracker::ConstructL()
    {
    }


// ---------------------------------------------------------------------------
// CAknPhysicsFlickTracker::SpeedChanged
// ---------------------------------------------------------------------------
//
void CAknPhysicsFlickTracker::SpeedChanged( const TInt& aCoordinate )
    {
    TInt newSpeed( DragSpeed( aCoordinate ) );

    // iIgnoreEvents keeps track of such events which speedup positions should
    // be ignored. This is done to calculate speed-up parameters from the first
    // successive speed-up positions
    if ( iIgnoredEvents > 0 )
        {
        iIgnoredEvents--;
        }

    // New speed exceeds the speed threshold - save speed up data
    if ( iIgnoredEvents == 0 
        && iLastDragSpeed && ( newSpeed - iLastDragSpeed > KSpeedUpIncrease )
        && ( ( iDirection == EDirectionForward && aCoordinate > iCoordinate )
        ||  ( iDirection == EDirectionBackward && aCoordinate < iCoordinate ) ) )
        {
        iSpeedUpData.iCoordinate = iCoordinate;
        iSpeedUpData.iTime = iLastDragTime;
        iSpeedUpRegistered = EFalse;
        iIgnoredEvents = KIgnoreSpeedUpEvents;
        iSpeedUpStartData = iNormalStartData;
        }

    // Speed-up hasn't yet been registered - save speed up start data if the
    // drag distance exceeds threshold
    if  ( !iSpeedUpRegistered  && iSpeedUpData.iCoordinate != iSpeedUpStartData.iCoordinate )
        {
        TInt distance( iSpeedUpData.iCoordinate - aCoordinate );
        // Distance from direction change position has exceeded threshold
        // - save the direction changed position as new start position
        if ( Threshold() && Abs( distance ) > Threshold() )
            {
            iSpeedUpStartData = iSpeedUpData;
            iSpeedUpRegistered = ETrue;
            }
        }
    iLastDragSpeed = newSpeed;
    }

// ---------------------------------------------------------------------------
// CAknPhysicsFlickTracker::Threshold
// ---------------------------------------------------------------------------
//
TInt CAknPhysicsFlickTracker::Threshold()
    {
    if ( iProvider )
        {
        return iProvider->DragThreshold();
        }
    return 0;
    }


// ---------------------------------------------------------------------------
// CAknPhysicsFlickTracker::DragSpeed
// ---------------------------------------------------------------------------
//
TInt CAknPhysicsFlickTracker::DragSpeed( const TInt& aNewCoordinate )
    {
    TTime now;
    now.HomeTime();
    TInt moveTime( now.MicroSecondsFrom( iLastDragTime ).Int64() );
    TInt distance( Abs( iCoordinate - aNewCoordinate ) * KDistanceFactor );
    if ( moveTime )
        {
        return ( distance / moveTime ); 
        }
    return 0;
    }


// ---------------------------------------------------------------------------
// CAknPhysicsFlickTracker::InitFlickData
// ---------------------------------------------------------------------------
//
void CAknPhysicsFlickTracker::InitFlickData( TAknPhysicsTrackerData& aData, 
        const TInt& aCoordinate )
    {
    aData.iCoordinate = aCoordinate;
    aData.iTime.HomeTime();
    }


// ---------------------------------------------------------------------------
// CAknPhysicsFlickTracker::NormalFlickMoveTime
// ---------------------------------------------------------------------------
//
TInt CAknPhysicsFlickTracker::NormalFlickMoveTime() const
    {
    TTime now;
    now.HomeTime();
    return now.MicroSecondsFrom( iNormalStartData.iTime ).Int64();
    }