/*

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

*

*/

#include <aknphysics.h>

#include <aknphysicsobserveriface.h>

#include <e32debug.h>

#include "aknphysicsconstants.h"

#include "aknphysicsengine.h"

#include "aknphysicsparameterprovider.h"

#include "aknphysicsrestrictor.h"

#include "aknphysicsconeobserver.h"

#include <touchfeedback.h>

const TInt KSamePositionStopCount( 3 );

_LIT( KNullThreadProcessName, "ekern.exe*" );

_LIT( KNullThreadName, "::Null" );

#undef AKNHIGHRESPERIODIC_PROFILE

/**

 * Opens a handle to the null thread.

 */

static TBool FindNullThread( RThread& aThread )

    {

    TFindProcess fp( KNullThreadProcessName );

    TFullName kernelName;

    if ( fp.Next( kernelName ) == KErrNone )

        {

        kernelName.Append( KNullThreadName );

        TFindThread ft( kernelName );

        TFullName threadName;

        if ( ft.Next( threadName ) == KErrNone )

            {

            if ( aThread.Open( threadName ) != KErrNone )

                {

                return EFalse;

                }

            }

        }        

    return ( aThread.Handle() != 0 );

    }

/**

 * Periodic timer using CTimer::HighRes.

 */

NONSHARABLE_CLASS( CAknHighResPeriodic ) : public CTimer

    {

public:

    /**

     * Creates new timer instance.

     * 

     * @param  aPriority    Priority of the timer.

     * @param  aNullThread  Open thread handle to the null thread,

     *                      ownership is not transferred.

     */

    static CAknHighResPeriodic* NewL( TInt aPriority,

                                      RThread* aNullThread );

    /**

     * Destructor.

     */

    ~CAknHighResPeriodic();

    /**

     * Starts periodic timer.

     * 

     * @param  aDelay      Initial delay.

     * @param  anInterval  Minimum interval between callback.

     * @param  aCallBack   Callback to invoke.

     */

    void Start( TTimeIntervalMicroSeconds32 aDelay,

                TTimeIntervalMicroSeconds32 anInterval,

                TCallBack aCallBack );

    /**

     * Sets minimum time between end of callback to beginning of next one.

     *

     * This is one approach to try to make sure that there is some time for

     * other processes. If this process can handle callback quickly,

     * this won't slow down frame rate.

     * 

     * @param  aDelay  Minimum time between callbacks.

     */

    void SetMinCallBackPeriod( TTimeIntervalMicroSeconds32 aDelay );

protected:

    /**

     * C++ constructor.

     * 

     * @param  aPriority    Priority of the timer.

     * @param  aNullThread  Open thread handle to the null thread,

     *                      ownership is not transferred.

     */

    CAknHighResPeriodic( TInt aPriority, RThread* aNullThread );

    /**

     * Called upon timer completion.

     */

    void RunL();

private:

    /**

     * Prints out the CPU time given to the null thread between this and

     * the previous call to this method.

     */

    void DumpNull();

private:

    /** Timer interval. */

    TTimeIntervalMicroSeconds32 iInterval;

    /** Callback of the timer. */

    TCallBack iCallBack;

    /** Is the end time valid, i.e. has the timer been completed at least once. */

    TBool iEndTimeValid;

    /** Time after the execution of the last timer callback. */

    TTime iEndTime;

    /** Minimum interval between callbacks. */

    TInt64 iMinCallBackPeriod;

    TBool iWaiting;

    /** Pointer to the null thread handle, not own. */

    RThread* iDebugNullThread;

    /** Null thread CPU time after the last callback. */ 

    TInt64 iDebugPreviousTime;

    };

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

// Creates new timer instance

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

//

CAknHighResPeriodic* CAknHighResPeriodic::NewL( TInt aPriority,

                                                RThread* aNullThread )

    {

    CAknHighResPeriodic* self =

        new (ELeave) CAknHighResPeriodic( aPriority, aNullThread );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CAknHighResPeriodic::~CAknHighResPeriodic()

    {

    }

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

// Starts the periodic timer.

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

//

void CAknHighResPeriodic::Start( TTimeIntervalMicroSeconds32 aDelay,

                                 TTimeIntervalMicroSeconds32 anInterval,

                                 TCallBack aCallBack)

    {

    iInterval = anInterval.Int();

    iCallBack = aCallBack;

    iEndTimeValid = EFalse;

    iWaiting = EFalse;

    HighRes( aDelay );

    }

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

// Sets minimum time between end of callback to beginning of next one.

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

//

void CAknHighResPeriodic::SetMinCallBackPeriod(

    TTimeIntervalMicroSeconds32 aDelay )

    {

    if ( aDelay.Int() >= 0 )

        {

        iMinCallBackPeriod = aDelay.Int();

        }

    else

        {

        iMinCallBackPeriod = 0;

        }

    }

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

// C++ constructor.

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

//

CAknHighResPeriodic::CAknHighResPeriodic( TInt aPriority,

                                          RThread* aNullThread )

    : CTimer( aPriority ), iDebugNullThread( aNullThread )

    {

    CActiveScheduler::Add( this );

    }

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

// Prints out the CPU time given to the null thread between this and previous

// call to this method.

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

//

void CAknHighResPeriodic::DumpNull()

    {

    TTimeIntervalMicroSeconds time;

    TInt err = iDebugNullThread->GetCpuTime( time );

    if ( !err )

        {

        if ( !iEndTimeValid )

            {

            iDebugPreviousTime = time.Int64();

            }

        else

            {

            TInt64 delta = time.Int64() - iDebugPreviousTime; 

            iDebugPreviousTime = time.Int64();

#ifdef AKNHIGHRESPERIODIC_PROFILE

            _LIT( KDMsg1, "[AKNPHYSICS] Null thread CPU time between frames: %d microseconds" );

            RDebug::Print( KDMsg1, TInt( delta ) );

#endif // AKNHIGHRESPERIODIC_PROFILE

            }

        }

    else

        {

#ifdef AKNHIGHRESPERIODIC_PROFILE

        _LIT( KDMsg2, "[AKNPHYSICS] Error %d in getting null thread CPU time" );

        RDebug::Print( KDMsg2, err );

#endif // AKNHIGHRESPERIODIC_PROFILE

        }

    }

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

// Handles timer completion.

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

//

void CAknHighResPeriodic::RunL()

    {

    if ( iEndTimeValid && !iWaiting ) 

        {

        TTime now;

        now.UniversalTime();

        TInt64 delta = now.MicroSecondsFrom( iEndTime ).Int64();

        if ( delta < 0 )

            {

            delta = 0;

            }

        TInt64 waitTime = iMinCallBackPeriod - delta; 

        if ( waitTime >= 0 )

            {

            // Restrict to some sensible min-max period.

            if ( waitTime < KAknHighResMinWait )

                {

                waitTime = KAknHighResMinWait;

                }

            if ( waitTime > KAknHighResMaxWait )

                {

                waitTime = KAknHighResMaxWait;

                }

            TInt timeToWait( waitTime );

#ifdef AKNHIGHRESPERIODIC_PROFILE

            _LIT( KDmsg, "[AKNPHYSICS] - CAknHighResPeriodic::RunL : waiting for %d microseconds" );

            RDebug::Print( KDmsg, timeToWait );

#endif            

            iWaiting = ETrue;

            HighRes( timeToWait );

            return;

            }

        }

    HighRes( iInterval );

    iCallBack.CallBack();

#ifdef AKNHIGHRESPERIODIC_PROFILE

    if ( iDebugNullThread && iDebugNullThread->Handle() )

        {

        DumpNull();

        }

#endif // AKNHIGHRESPERIODIC_PROFILE

    iWaiting = EFalse;

    iEndTime.UniversalTime();

    iEndTimeValid = ETrue;

    }

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

// CAknPhysics::NewL()

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

//

EXPORT_C CAknPhysics* CAknPhysics::NewL( MAknPhysicsObserver& aObserver,

                                         CCoeControl* aViewControl )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aViewControl );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknPhysics::~CAknPhysics()

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

//

CAknPhysics::~CAknPhysics()

    {

    delete iPhysics;

    delete iEngine;

    delete iParamProvider;

    delete iRestrictor;

    delete iConeObserver;

    iNullThread.Close();

    }

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

// CAknPhysics::InitPhysicsL()

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

//

EXPORT_C void CAknPhysics::InitPhysicsL( const TSize& aWorldSize, 

                                         const TSize& aViewSize, 

                                         TBool aLandscape )

    {

    if ( iRestrictor )

        {

        // Update always the restrictor parameters.

        iRestrictor->UpdatePhysicsEnvironment( aWorldSize,

                                               aViewSize,

                                               aLandscape );

        }

    // Do not initialize if all parameters match with old ones

    if ( aWorldSize == iWorldSize && aViewSize == iViewSize 

        && ( ( aLandscape && iLandscape ) || ( !aLandscape && !iLandscape ) ) )

        {

        return;    

        }

    StopPhysics();

    iEngine->DeletePhysics();

    iLandscape = aLandscape;

    iWorldSize = aWorldSize;

    iViewSize = aViewSize;

    if( (iLandscape && aWorldSize.iWidth < aViewSize.iWidth) 

            || (!iLandscape && aWorldSize.iHeight < aViewSize.iHeight) )

        {

        iWorldSize = aViewSize;

        }

    TInt64 ih, x, y, w, h, r;

    if(iLandscape)

        {

        ih = iWorldSize.iWidth;

        x = 1;

        y = 0;

        r = iViewSize.iHeight;

        }

    else

        {

        ih = iWorldSize.iHeight;

        x = 0;

        y = 1;

        r = iViewSize.iWidth;

        }

    w = iViewSize.iWidth;

    h = iViewSize.iHeight;

    if ( iEngine )

        {

        iEngine->CreateWorld( iParamProvider->Gravity() );

        iEngine->CreatePlanes( ih, x, y, r );

        iEngine->CreateViewBody( w, h, iParamProvider->ViewMass() );

        }

    }

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

// CAknPhysics::StartPhysics

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

//

EXPORT_C TBool CAknPhysics::StartPhysics( TPoint& aDrag, 

                                          const TTime& aStartTime )

    {

    // Check that world really exists

    if ( !iEngine || !iEngine->WorldExists() )

        {

        return EFalse;

        }

    iSuspended = EFalse;

    TTime now;

    now.HomeTime();

    TInt moveTime( now.MicroSecondsFrom( aStartTime ).Int64() );

    TBool startPhysics( EFalse );

    iFlickTimeExceeded = EFalse;

    // Check if drag direction has changed during drag event

    // and receive the changed parameters

    if ( iConeObserver )

        {

        iConeObserver->DragChanged( iLandscape, aDrag, moveTime );

        }

    // Start physics if drag threshold is exceeded

    startPhysics = 

        ( iLandscape && Abs( aDrag.iX ) > DragThreshold() )

        || ( !iLandscape && Abs( aDrag.iY ) > DragThreshold() );

    // Check if movetime threshold is exceeded

    if ( startPhysics && moveTime > KFlickMaxDuration )

        {

        iFlickTimeExceeded = ETrue;

        }

    // Start physics always if position reveals empty space

    if ( !startPhysics && iRestrictor )

        {

        TPoint viewPosition( iObserver.ViewPosition() );

        startPhysics = 

            iRestrictor->PositionRevealsEmptySpace( viewPosition );

        }

    // Stop FPS logging here so that panning gets logged correctly. Each

    // panning always ends with a flick attempt.

    if ( iParamProvider->FpsLoggingEnabled() )

        {

        iEngine->StopFpsLogging();

        }

    if ( startPhysics && iEngine )

        {

        iEngine->SetViewBodyPosition( iObserver.ViewPosition() );

        StartPhysics();

        ApplyDrag( aDrag, moveTime ); 

        if ( iParamProvider->FpsLoggingEnabled() )

            {

            iEngine->StartFpsLogging();

            }

        return ETrue;

        }

    return EFalse;

    }

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

// CAknPhysics::StopPhysics()

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

//

EXPORT_C void CAknPhysics::StopPhysics()

    {

    // Check that world really exists

    if ( !iEngine || !iEngine->WorldExists() )

        {

        return;

        }

    iSuspended = EFalse;

    iSamePositionCounter = 0;

    if ( iPhysics && iPhysics->IsActive() )

        {

        if ( iParamProvider->FpsLoggingEnabled() )

            {

            iEngine->StopFpsLogging();

            }

        CancelPhysicsTimer();

        if ( iEngine )

            {

            iEngine->ResetViewBodyForceAndVelocity();

            }

        iObserver.PhysicEmulationEnded();

        }

    else

        {

        UpdateActionState();

        }

    }