/*

* Copyright (c) 2008-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:  Orientation class of Orientation SSY

*

*/

// Includes

#include <e32math.h>

#include <sensrvchannelfinder.h>

#include <sensrvgeneralproperties.h>

#include <sensrvaccelerometerproperties.h>

#include <sensordatacompensator.h>

#include <centralrepository.h>

#include "SsyOrientation.h"

#include "Ssyeventtimer.h"

#include "SsyConfiguration.h"               // configuration

#include "SsyTrace.h"

#include "OrientationConfiguration.h"

// Constants

/**

 *  Constants for degrees

 */

const TInt K45Degrees  = 45;

const TInt K90Degrees  = 90;

const TInt K135Degrees = 135;

const TInt K180Degrees = 180;

const TInt K225Degrees = 225;

const TInt K270Degrees = 270;

const TInt K315Degrees = 315;

const TInt K360Degrees = 360;

const TReal KRad2degrees = 57.3; // accurate enough for our purposes. 180° / pi

const TReal KVariationFactor = 0.85;

const TInt KOneSecond = 1;

#ifdef _DEBUG

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

// TraceOrientation()

// Helper function for tracing orientation data.

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

//

void TraceOrientation( const TSensrvOrientationData::TSensrvDeviceOrientation aOrientation,

                               const TInt aXRotation,

                               const TInt aYRotation,

                               const TInt aZRotation )

    {

    switch ( aOrientation )

        {

        case TSensrvOrientationData::EOrientationDisplayUp:

            SSY_TRACE( EExtended, "ORIENTATIONSSY:EOrientationDisplayUp" );

            break;

        case TSensrvOrientationData::EOrientationDisplayDown:

            SSY_TRACE( EExtended, "ORIENTATIONSSY:EOrientationDisplayDown" );

            break;

        case TSensrvOrientationData::EOrientationDisplayLeftUp:

            SSY_TRACE( EExtended, "ORIENTATIONSSY:EOrientationDisplayLeftUp" );

            break;

        case TSensrvOrientationData::EOrientationDisplayRightUp:

            SSY_TRACE( EExtended, "ORIENTATIONSSY:EOrientationDisplayRightUp" );

            break;

        case TSensrvOrientationData::EOrientationDisplayUpwards:

            SSY_TRACE( EExtended, "ORIENTATIONSSY:EOrientationDisplayUpwards" );

            break;

        case TSensrvOrientationData::EOrientationDisplayDownwards:

            SSY_TRACE( EExtended, "ORIENTATIONSSY:EOrientationDisplayDownwards" );

            break;

        default:

            SSY_TRACE( EExtended, "ORIENTATIONSSY:EOrientationUndefined" );

            break;

        }

    SSY_TRACE( EExtended, "ORIENTATIONSSY:aXRotation=%d", aXRotation );

    SSY_TRACE( EExtended, "ORIENTATIONSSY:aYRotation=%d", aYRotation );

    SSY_TRACE( EExtended, "ORIENTATIONSSY:aZRotation=%d", aZRotation );

    }

#endif

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

// CSSYOrientation::CSSYOrientation()

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

// 

CSSYOrientation::CSSYOrientation( const TSensrvChannelTypeId aChannelType ) :

    iChannelType( aChannelType ),

    iChannel( NULL ),

    iChannelFinder( NULL ),

    iSensorChannel( NULL ),

    iEventTimer( NULL ),

    iFirstDataReceived( EFalse )

    {

    SSY_TRACE_IN();

    iConfigForCurrentState.iOrientationState = TSensrvOrientationData::EOrientationUndefined;

    iTimerState = CSSYOrientation::EUninitialized;

    iOrientationEvent.iDeviceOrientation = 

        TSensrvOrientationData::EOrientationUndefined;

    iCurrentOrientationState.iDeviceOrientation = 

        TSensrvOrientationData::EOrientationUndefined;

    iRotationEvent.iDeviceRotationAboutZAxis = 

        TSensrvRotationData::KSensrvRotationUndefined;

    iRotationEvent.iDeviceRotationAboutXAxis = 

        TSensrvRotationData::KSensrvRotationUndefined;

    iRotationEvent.iDeviceRotationAboutYAxis = 

        TSensrvRotationData::TSensrvRotationData::KSensrvRotationUndefined;

    iOrientationArray.Reset();

    SSY_TRACE_OUT();

    }

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

// CSSYOrientation::~CSSYOrientation()

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

// 

CSSYOrientation::~CSSYOrientation()

    {

    SSY_TRACE_IN();

    if( iChannelFinder )

        {

        delete iChannelFinder;

        iChannelFinder = NULL;

        }

    if( iEventTimer )

        {

        delete iEventTimer;

        iEventTimer = NULL;

        }

    if( iSensorChannel )

        {

        delete iSensorChannel;

        iSensorChannel = NULL;

        }

#ifdef AUTO_ORIENTAION_TEST

    if( iCRListener )

        {

        delete iCRListener;

        iCRListener = NULL;

        }

#endif

    if( iRepository )

        {

        delete iRepository;

        iRepository = NULL;

        }

    delete iCompensator;

    iChannel = NULL;

    iChannelInfoList.Reset();

    iOrientationArray.Reset();

    iConfigArray.Reset();

    iChannelInfoList.Close();

    iOrientationArray.Close();

    iConfigArray.Close();

    SSY_TRACE_OUT();

    }

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

//

//

void CSSYOrientation::ConstructL()

    {

    iRepository = CRepository::NewL( KCRUidOrientationSsySettings );

    CreateConfigurations();

#ifdef AUTO_ORIENTAION_TEST

    iCRListener = CSsyOrientationCRListener::NewL( *this, iRepository );

#endif

    }

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

// CSSYOrientation::DataReceived()

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

//

#ifdef _DEBUG

void CSSYOrientation::DataReceived( CSensrvChannel& aChannel, 

                                    TInt aCount, 

                                    TInt aDataLost )

#else

// aCount and aDataLost are not used in UREL builds

void CSSYOrientation::DataReceived( CSensrvChannel& aChannel, 

                                    TInt /*aCount*/, 

                                    TInt /*aDataLost*/ )

#endif

    {

    SSY_TRACE_IN();

    SSY_TRACE( EExtended, "ORIENTATIONSSY:aChannel: %d", aChannel.GetChannelInfo().iChannelId );

    SSY_TRACE( EExtended, "ORIENTATIONSSY:aCount: %d", aCount );

    SSY_TRACE( EExtended, "ORIENTATIONSSY:aDataLost: %d", aDataLost );

    ASSERT_DEBUG_SSY( iSensorChannel == &aChannel );

    TBool rotationChanged( EFalse );

	if ( !iFirstDataReceived )

		{

        // No need to come here anymore

        iFirstDataReceived = ETrue;

        }

    TPckgBuf<TSensrvAccelerometerAxisData> dataBuf;

    TInt err = iSensorChannel->GetData( dataBuf );

    if ( KErrNone != err )

        {

        SSY_TRACE( EError, "ORIENTATIONSSY: GetData() failed: %d", err );

        return;

        }

    if ( !iCompensator )

        {        

        TSensrvChannelInfo channelInfo = iSensorChannel->GetChannelInfo();

        TSensrvChannelDataTypeId dataTypeId( channelInfo.iChannelDataTypeId );

        TRAP( err, iCompensator = CSensorDataCompensator::NewL( dataTypeId, 

                                        ESensorCompensateDeviceOrientation ) );

        if ( err != KErrNone )

            {

            SSY_TRACE( EError, "ORIENTATIONSSY: Unable to create compensator, data won't be compensated! err: %d", err );

            }

        }

    if ( iCompensator )

        {

        err = iCompensator->Compensate( dataBuf );

        if ( err != KErrNone )

            {

            SSY_TRACE( EError, "ORIENTATIONSSY: Data compensation failed! err: %d", err );

            }

        }

    TSensrvAccelerometerAxisData data = dataBuf();

    TInt zenith( 0 );

    TInt azimuth( 0 );

    err = CalculateSphericalPolarCoordinates(

         data.iAxisX,

         data.iAxisY,

         data.iAxisZ,

         zenith,

         azimuth );

    TSensrvOrientationData::TSensrvDeviceOrientation orientation = 

            CalculateDeviceOrientation( zenith, azimuth );

    // positive device rotation about the x-axis

    TInt xRotation = CalculateDeviceRotationInDegrees( 

        data.iAxisZ, data.iAxisY, ERotationAboutXaxis );

    // positive device rotation about the y-axis

    TInt yRotation = CalculateDeviceRotationInDegrees( 

        data.iAxisZ, data.iAxisX, ERotationAboutYaxis );

    // positive device rotation about the z-axis

    TInt zRotation = CalculateDeviceRotationInDegrees( 

        data.iAxisX, data.iAxisY, ERotationAboutZaxis );

    iOrientationEvent.iTimeStamp = data.iTimeStamp;

    iCurrentOrientationState.iTimeStamp = data.iTimeStamp;

    // In initial state do this

    if( ( iCurrentOrientationState.iDeviceOrientation == 

          TSensrvOrientationData::EOrientationUndefined )

     && ( iChannelType == KSensrvChannelTypeIdOrientationData ) 

     && ( iTimerState != CSSYOrientation::ERunning )

     && ( err == KErrNone ) )

        {

        GetConfigurationForState( orientation, iConfigForCurrentState );

        iOrientationEvent.iDeviceOrientation = orientation;

        iCurrentOrientationState.iDeviceOrientation = orientation;

        iOrientationEvent.iTimeStamp = data.iTimeStamp;

        iCurrentOrientationState.iTimeStamp = data.iTimeStamp;

        iRotationEvent.iTimeStamp = data.iTimeStamp;

        if ( iChannel && iChannel->AppendData( iOrientationEvent, iRotationEvent ) )

            {

            SSY_TRACE( EExtended, "ORIENTATIONSSY: First time data received, set first orientation=%d", orientation );

            iChannel->IssueRequest();

            iChannel = NULL;

            }

        }

    // Set rotation to rotation event

    if ( iChannelType == KSensrvChannelTypeIdRotationData )

        {

        if ( iRotationEvent.iDeviceRotationAboutXAxis != xRotation )

            {

            iRotationEvent.iDeviceRotationAboutXAxis = xRotation;

            rotationChanged = ETrue;

            }

        if ( iRotationEvent.iDeviceRotationAboutYAxis != yRotation )

            {

            iRotationEvent.iDeviceRotationAboutYAxis = yRotation;

            rotationChanged = ETrue;

            }

        if ( iRotationEvent.iDeviceRotationAboutZAxis != zRotation )

            {

            iRotationEvent.iDeviceRotationAboutZAxis = zRotation;

            rotationChanged = ETrue;

            }

        }

    if( ( iTimerState == CSSYOrientation::ERunning ) 

     && ( orientation != TSensrvOrientationData::EOrientationUndefined ) )

        {

        if( err == KErrNone )

            {

            TRAP_IGNORE( iOrientationArray.AppendL( (TInt)orientation ) );

            }

        }

    if( ( orientation != iCurrentOrientationState.iDeviceOrientation )

     && ( orientation != TSensrvOrientationData::EOrientationUndefined )

     && ( iTimerState != CSSYOrientation::ERunning )

     && ( err == KErrNone ) )

        {

        TInt timer = iConfigForCurrentState.GetTimerToOrientation( orientation );

        if( timer == 0 )

            {

            /**

            * Don't set timer to zero seconds, set it rather to one

            * milliseconds.

            */

            timer = KOneSecond;

            }

        SSY_TRACE( EExtended, "ORIENTATIONSSY:Set timer to %d ms", timer );

        TRAP_IGNORE( iOrientationArray.AppendL( (TInt)orientation ) );

        if( !iEventTimer )

            {

            TRAP_IGNORE( iEventTimer = CSsyOrientationEventTimer::NewL( timer, *this ) );

            }

        iTimerState = CSSYOrientation::ERunning;

        }

    // append only if somebody is listening

    if ( iChannel )

        {

#ifdef _DEBUG

        SSY_TRACE( EExtended, "ORIENTATIONSSY:data.iAxisX=%d", data.iAxisX );

        SSY_TRACE( EExtended, "ORIENTATIONSSY:data.iAxisY=%d", data.iAxisY );

        SSY_TRACE( EExtended, "ORIENTATIONSSY:data.iAxisZ=%d", data.iAxisZ );        

        TraceOrientation( iOrientationEvent.iDeviceOrientation, 

                          iRotationEvent.iDeviceRotationAboutXAxis, 

                          iRotationEvent.iDeviceRotationAboutYAxis, 

                          iRotationEvent.iDeviceRotationAboutZAxis );

#endif

        // If rotation channel is listened append data to rotation channel

        if ( ( iChannelType == KSensrvChannelTypeIdRotationData ) && rotationChanged )

            {

            iOrientationEvent.iTimeStamp = data.iTimeStamp;

            iRotationEvent.iTimeStamp = data.iTimeStamp;

            if ( iChannel->AppendData( iOrientationEvent, iRotationEvent ) )

                {

                iChannel->IssueRequest();

                iChannel = NULL;

                }

            }

        }

    SSY_TRACE_OUT();

    }

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

// CSSYOrientation::CalculateDeviceRotationInDegrees()

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

// 

TInt CSSYOrientation::CalculateDeviceRotationInDegrees( 

    const TInt aAxis1, 

    const TInt aAxis2,

    const TRotation aRotation )

    {

    SSY_TRACE_IN();

    TInt devicetilt( TSensrvRotationData::KSensrvRotationUndefined );

    if ( aAxis2 != 0 )

        {

        TReal alpha    = 0;

        TReal relation = (TReal)Abs(aAxis1) / (TReal)Abs(aAxis2);

        // calculate the angle

        Math::ATan( alpha, relation );

        // change radians to degrees

        alpha = alpha * KRad2degrees;

        switch ( aRotation )

            {

            case ERotationAboutXaxis:

                {

                if ( aAxis1 > 0 && aAxis2 > 0 )

                    {

                    // 0-90

                    }

                else if ( aAxis1 > 0 && aAxis2 < 0 )

                    {

                    // 90-180

                    alpha = K90Degrees + ( K90Degrees - alpha );

                    }

                else if ( aAxis1 < 0 && aAxis2 < 0 )

                    {

                    // 180-270

                    alpha += K180Degrees;

                    }

                else

                    {

                    // 270-360

                    alpha = K270Degrees + ( K90Degrees - alpha );

                    }

                break;

                }

// positive device rotation about the x-axis

            case ERotationAboutYaxis:

                {

                if ( aAxis1 > 0 && aAxis2 > 0 )

                    {

                    // 90-180

                    alpha += K90Degrees;

                    }

                else if ( aAxis1 > 0 && aAxis2 < 0 )

                    {

                    // 180-270

                    alpha = K270Degrees - alpha;

                    }

                else if ( aAxis1 < 0 && aAxis2 < 0 )

                    {

                    // 270-360

                    alpha += K270Degrees;

                    }

                else

                    {

                    // 0-90

                    alpha = K90Degrees - alpha;

                    }

                break;

                }

            case ERotationAboutZaxis:

                {

                if ( aAxis1 > 0 && aAxis2 > 0 )

                    {

                    // 270-360

                    alpha = K360Degrees - alpha;

                    }

                else if ( aAxis1 > 0 && aAxis2 < 0 )

                    {

                    // 180-270

                    alpha += K180Degrees;

                    }

                else if ( aAxis1 < 0 && aAxis2 < 0 )

                    {

                    // 90-180

                    alpha = K180Degrees - alpha;

                    }

                else

                    {

                    // 0-90

                    }

                break;

                }

            default:

                {

                SSY_TRACE( EError, "ORIENTATIONSSY:ERROR: Unknown rotation!" );

                }

            }

        // truncate to integer

        devicetilt = (TInt)alpha;

        // round the result according to KRotationResolutionInDegrees

        devicetilt += ( KRotationResolutionInDegrees >> 1 );

        devicetilt /= KRotationResolutionInDegrees;

        devicetilt *= KRotationResolutionInDegrees;

        devicetilt %= K360Degrees;

        }

    SSY_TRACE_OUT();

    return devicetilt;

    }

/**

* New implementation

*/

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

// CSSYOrientation::CalculateDeviceOrientation()

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

// 

TSensrvOrientationData::TSensrvDeviceOrientation CSSYOrientation::CalculateDeviceOrientation( 

    const TInt aZenithAngle,

    const TInt aAzimuthAngle )

    {

    SSY_TRACE_IN();

    TSensrvOrientationData::TSensrvDeviceOrientation orientation = 

                                TSensrvOrientationData::EOrientationUndefined;