--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sensorservices/orientationssy/src/SsyOrientation.cpp Tue Feb 02 00:53:00 2010 +0200
@@ -0,0 +1,1475 @@
+/*
+* 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;
+
+ /**
+ * The corrections are to different states are gotten from configurations
+ */
+ TInt correctionDisplayUp( iConfigForCurrentState.iOrientationDisplayUp.iAngle );
+ TInt correctionDisplayDown( iConfigForCurrentState.iOrientationDisplayDown.iAngle );
+ TInt correctionDisplayDownwards( iConfigForCurrentState.iOrientationDisplayDownwards.iAngle );
+ TInt correctionDisplayRightUp( iConfigForCurrentState.iOrientationDisplayRightUp.iAngle );
+ TInt correctionDisplayUpwards( iConfigForCurrentState.iOrientationDisplayUpwards.iAngle );
+ TInt correctionDisplayLeftUp( iConfigForCurrentState.iOrientationDisplayLeftUp.iAngle );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation iConfigForCurrentState.iOrientationDisplayUp.iConfigForCurrentState.iOrientationDisplayUp.iAngle=%d", iConfigForCurrentState.iOrientationDisplayUp.iAngle );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation iConfigForCurrentState.iOrientationDisplayUp.iConfigForCurrentState.iOrientationDisplayDown.iAngle=%d", iConfigForCurrentState.iOrientationDisplayDown.iAngle );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation iConfigForCurrentState.iOrientationDisplayUp.iConfigForCurrentState.iOrientationDisplayDownwards.iAngle=%d", iConfigForCurrentState.iOrientationDisplayDownwards.iAngle );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation iConfigForCurrentState.iOrientationDisplayUp.iConfigForCurrentState.iOrientationDisplayRightUp.iAngle=%d", iConfigForCurrentState.iOrientationDisplayRightUp.iAngle );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation iConfigForCurrentState.iOrientationDisplayUp.iConfigForCurrentState.iOrientationDisplayUpwards.iAngle=%d", iConfigForCurrentState.iOrientationDisplayUpwards.iAngle );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation iConfigForCurrentState.iOrientationDisplayUp.iConfigForCurrentState.iOrientationDisplayLeftUp.iAngle=%d", iConfigForCurrentState.iOrientationDisplayLeftUp.iAngle );
+
+ /**
+ * The current state needs to be compenstated in some cases.
+ * This is done whenever the current state is diminished from 45 degrees.
+ * This compenstation is saved to the correctionFromSelectedState.
+ */
+
+
+ /**
+ * Total correction contains the compensation from the configurations
+ */
+ TInt totalCorrection( K45Degrees - correctionDisplayUpwards );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation EOrientationDisplayUpwards totalCorrection=%d", totalCorrection );
+ TInt totalCorrection1( 0 );
+ TInt totalCorrection2( 0 );
+ TInt totalCorrection3( 0 );
+
+ /**
+ * If the acceleration vector points upwards the zenith is smaller than
+ * 45 + correction
+ */
+ if( aZenithAngle < totalCorrection )
+ {
+ orientation = TSensrvOrientationData::EOrientationDisplayUpwards;
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation EOrientationDisplayUpwards=%d", orientation );
+ }
+
+ totalCorrection = K135Degrees + correctionDisplayDownwards;
+
+
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation aZenithAngle=%d", aZenithAngle );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation EOrientationDisplayDownwards totalCorrection=%d", totalCorrection );
+
+ /**
+ * If the acceleration vector points downwards the zenith angle is bigger
+ * 135 + correction.
+ */
+ if( aZenithAngle > totalCorrection )
+ {
+ orientation = TSensrvOrientationData::EOrientationDisplayDownwards;
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation EOrientationDisplayDownwards=%d", orientation );
+ }
+
+ if(iCurrentOrientationState.iDeviceOrientation
+ == TSensrvOrientationData::EOrientationDisplayUpwards ||
+ iCurrentOrientationState.iDeviceOrientation
+ == TSensrvOrientationData::EOrientationDisplayDownwards)
+ {
+ totalCorrection = K45Degrees - correctionDisplayRightUp;
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation EOrientationDisplayRightUp totalCorrection=%d", totalCorrection );
+ totalCorrection1 = K135Degrees + correctionDisplayRightUp;
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation EOrientationDisplayRightUp totalCorrection1=%d", totalCorrection1 );
+ }
+ else
+ {
+ totalCorrection = K45Degrees - correctionDisplayUpwards;
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation EOrientationDisplayRightUp totalCorrection=%d", totalCorrection );
+ totalCorrection1 = K135Degrees + correctionDisplayDownwards;
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation EOrientationDisplayRightUp totalCorrection1=%d", totalCorrection1 );
+ }
+ totalCorrection2 = K45Degrees - correctionDisplayRightUp;
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation EOrientationDisplayRightUp totalCorrection2=%d", totalCorrection2 );
+ totalCorrection3 = K315Degrees + correctionDisplayRightUp;
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation EOrientationDisplayRightUp totalCorrection3=%d", totalCorrection3 );
+
+ /**
+ * If the acceleration vector points to the midlle the zenith is between
+ * 45 and 135 degrees + correction and azimuth angle is between 45 and
+ * 315 degrees + correction.
+ */
+ if( ( aZenithAngle >= totalCorrection )
+ && ( aZenithAngle <= totalCorrection1 )
+ && ( ( aAzimuthAngle <= totalCorrection2 ) || ( aAzimuthAngle >= totalCorrection3 ) ) )
+ {
+ // Azimuth 315 - 45
+ orientation = TSensrvOrientationData::EOrientationDisplayRightUp;
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation EOrientationDisplayRightUp=%d", orientation );
+ }
+
+ if(iCurrentOrientationState.iDeviceOrientation
+ == TSensrvOrientationData::EOrientationDisplayUpwards ||
+ iCurrentOrientationState.iDeviceOrientation
+ == TSensrvOrientationData::EOrientationDisplayDownwards)
+ {
+ totalCorrection = K45Degrees - correctionDisplayUp;
+ totalCorrection1 = K135Degrees + correctionDisplayUp;
+ }
+ else
+ {
+ totalCorrection = K45Degrees - correctionDisplayUpwards;
+ totalCorrection1 = K135Degrees + correctionDisplayDownwards;
+ }
+ totalCorrection2 = K45Degrees - correctionDisplayUp;
+ totalCorrection3 = K135Degrees + correctionDisplayUp;
+ /**
+ * If the acceleration vector points to the midlle the zenith is between
+ * 45 and 135 degrees + correction and azimuth angle is between 45 and
+ * 135 degrees + correction.
+ */
+ if( IsOrientation( aZenithAngle, aAzimuthAngle, totalCorrection,
+ totalCorrection1, totalCorrection2, totalCorrection3 ) )
+ {
+ // Azimuth 45 - 135
+ orientation = TSensrvOrientationData::EOrientationDisplayUp;
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation EOrientationDisplayUp=%d", orientation );
+ }
+
+ if(iCurrentOrientationState.iDeviceOrientation
+ == TSensrvOrientationData::EOrientationDisplayUpwards ||
+ iCurrentOrientationState.iDeviceOrientation
+ == TSensrvOrientationData::EOrientationDisplayDownwards)
+ {
+ totalCorrection = K45Degrees + correctionDisplayLeftUp;
+ totalCorrection1 = K135Degrees - correctionDisplayLeftUp;
+ }
+ else
+ {
+ totalCorrection = K45Degrees - correctionDisplayUpwards;
+ totalCorrection1 = K135Degrees + correctionDisplayDownwards;
+ }
+ totalCorrection2 = K135Degrees + correctionDisplayLeftUp;
+ totalCorrection3 = K225Degrees - correctionDisplayLeftUp;
+ /**
+ * If the acceleration vector points to the midlle the zenith is between
+ * 135 and 225 degrees + correction and azimuth angle is between 45 and
+ * 135 degrees + correction.
+ */
+ if( IsOrientation( aZenithAngle, aAzimuthAngle, totalCorrection,
+ totalCorrection1, totalCorrection2, totalCorrection3 ) )
+ {
+ // Azimuth 135 - 225
+ orientation = TSensrvOrientationData::EOrientationDisplayLeftUp;
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation EOrientationDisplayLeftUp=%d", orientation );
+ }
+
+ totalCorrection = K45Degrees - correctionDisplayUpwards;
+ totalCorrection1 = K135Degrees + correctionDisplayDownwards;
+ totalCorrection2 = K225Degrees + correctionDisplayDown;
+ totalCorrection3 = K315Degrees - correctionDisplayDown;
+ /**
+ * If the acceleration vector points to the midlle the zenith is between
+ * 225 and 315 degrees + correction and azimuth angle is between 45 and
+ * 135 degrees + correction.
+ */
+ if( IsOrientation( aZenithAngle, aAzimuthAngle, totalCorrection,
+ totalCorrection1, totalCorrection2, totalCorrection3 ) )
+ {
+ // Azimuth 225 - 315
+ orientation = TSensrvOrientationData::EOrientationDisplayDown;
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation EOrientationDisplayDown=%d", orientation );
+ }
+
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation orientation=%d", orientation );
+
+ SSY_TRACE_OUT();
+
+ return orientation;
+ }
+
+TBool CSSYOrientation::IsOrientation(
+ const TInt aZenithAngle,
+ const TInt aAzimuthAngle,
+ TInt aCorrectionToState,
+ TInt aCorrectionToState1,
+ TInt aCorrectionToState2,
+ TInt aCorrectionToState3 )
+ {
+ TBool retVal( EFalse );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation aZenithAngle=%d", aZenithAngle );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation aZenithAngle=%d", aAzimuthAngle );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation aZenithAngle=%d", aCorrectionToState );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation aZenithAngle=%d", aCorrectionToState1 );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation aZenithAngle=%d", aCorrectionToState2 );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateDeviceOrientation aZenithAngle=%d", aCorrectionToState3 );
+ if( ( aZenithAngle > aCorrectionToState )
+ && ( aZenithAngle < aCorrectionToState1 )
+ && ( aAzimuthAngle > aCorrectionToState2 )
+ && ( aAzimuthAngle < aCorrectionToState3 ) )
+ {
+ retVal = ETrue;
+ }
+ return retVal;
+ }
+
+// ----------------------------------------------------------------------------------
+// CSSYOrientation::CalculateDeviceRotationInDegrees()
+// ----------------------------------------------------------------------------------
+//
+TInt CSSYOrientation::CalculateSphericalPolarCoordinates(
+ const TInt aAxisX,
+ const TInt aAxisY,
+ const TInt aAxisZ,
+ TInt& aZenithAngle,
+ TInt& aAzimuthAngle )
+ {
+ SSY_TRACE_IN();
+ TInt retVal( KErrNone );
+
+ // Calculate the spherial coordinates from carthesian vector coordinates
+ // First take the length of the vector formed by x and y.
+ TReal srcSqrtZenith = (TReal)( ( aAxisX * aAxisX ) + ( aAxisY * aAxisY ) );
+ TReal srcZenith( 0 );
+ Math::Sqrt( srcZenith, srcSqrtZenith );
+ TReal axisZ( aAxisZ );
+ // The zenith angle is arctan( ( x and y length ) / z )
+ TReal trgZenith( 0 );
+ if(aAxisZ != 0)
+ {
+ srcZenith = ( srcZenith / axisZ );
+ Math::ATan( trgZenith, srcZenith );
+ }
+
+ TReal trgAzimuth( 0 );
+ TReal srcAzimuth( 0 );
+ TReal realAxisX( aAxisX );
+ TReal realAxisY( aAxisY );
+ if(aAxisX != 0 && aAxisY !=0)
+ {
+ srcAzimuth = ( realAxisY / realAxisX );
+ // The azimuth angle is arctan( y / x )
+ Math::ATan( trgAzimuth, srcAzimuth );
+ }
+ if(aAxisY ==0 && aAxisX != 0)
+ trgAzimuth = 0;
+
+ TReal zenithAngle = ( trgZenith * KRad2degrees );
+
+ if( zenithAngle < 0 )
+ {
+ // Correct the zenith angle if the result is negative
+ zenithAngle = K180Degrees + zenithAngle;
+ }
+
+ TReal azimuthAngle = ( trgAzimuth * KRad2degrees );
+
+ if( ( aAxisX > 0 ) && ( aAxisY < 0 ) )
+ {
+ // Azimuth is negative, so basically this is minus
+ azimuthAngle = azimuthAngle + K360Degrees;
+ }
+ if( ( aAxisX < 0 ) && ( aAxisY > 0 ) )
+ {
+ // Azimuth is negative, so basically this is minus
+ azimuthAngle = K180Degrees + azimuthAngle;
+ }
+ if( ( aAxisX < 0 ) && ( aAxisY < 0 ) )
+ {
+ // This is plus
+ azimuthAngle = azimuthAngle + K180Degrees;
+ }
+
+ TReal roundedAz( 0 );
+ Math::Round( roundedAz, azimuthAngle, 0 );
+ TReal roundedZen( 0 );
+ Math::Round( roundedZen, zenithAngle, 0 );
+
+ TInt32 valiAz( 0 );
+ TInt32 valiZen( 0 );
+ Math::Int( valiZen, roundedZen );
+ Math::Int( valiAz, roundedAz );
+ aZenithAngle = (TInt)valiZen;
+ aAzimuthAngle = (TInt)valiAz;
+
+ if(aAxisZ == 0)
+ aZenithAngle = 90;
+ if(aAxisX == 0 && aAxisY == 0)
+ aAzimuthAngle = 90;
+ if(aAxisX == 0 && aAxisY > 0)
+ aAzimuthAngle = 90;
+ if(aAxisX ==0 && aAxisY < 0)
+ aAzimuthAngle = 270;
+
+ // Check that calculated values are in range
+ if( ( aZenithAngle > K180Degrees )
+ || ( aAzimuthAngle > K360Degrees )
+ || ( aZenithAngle < 0 )
+ || ( aAzimuthAngle < 0 ) )
+ {
+ retVal = KErrArgument;
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateSphericalPolarCoordinates Could not calculate because some item was null err=%d", retVal );
+ }
+
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateSphericalPolarCoordinates aAzimuthAngle=%d", aAzimuthAngle );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateSphericalPolarCoordinates aZenithAngle=%d", aZenithAngle );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateSphericalPolarCoordinates aAxisX=%d", aAxisX );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateSphericalPolarCoordinates aAxisY=%d", aAxisY );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CalculateSphericalPolarCoordinates aAxisZ=%d", aAxisZ );
+
+ SSY_TRACE_OUT();
+
+ return retVal;
+ }
+
+// ----------------------------------------------------------------------------------
+// CSSYOrientation::DataError()
+// ----------------------------------------------------------------------------------
+//
+#ifdef _DEBUG
+void CSSYOrientation::DataError( CSensrvChannel& aChannel,
+ TSensrvErrorSeverity aError )
+#else
+// aError is not used in UREL builds
+void CSSYOrientation::DataError( CSensrvChannel& aChannel,
+ TSensrvErrorSeverity /*aError*/ )
+#endif
+ {
+ SSY_TRACE_IN();
+
+ ASSERT_DEBUG_SSY( iSensorChannel == &aChannel );
+
+ SSY_TRACE( EError, "ORIENTATIONSSY:ERROR: DataError %d for channelId %d",
+ aError,
+ aChannel.GetChannelInfo().iChannelId );
+
+ if ( iSensorChannel != &aChannel )
+ {
+ SSY_TRACE( EError, "ORIENTATIONSSY:ERROR: Wrong channel!" );
+ }
+
+ SSY_TRACE_OUT();
+ }
+
+// ----------------------------------------------------------------------------------
+// CSSYOrientation::OpenChannelL()
+// ----------------------------------------------------------------------------------
+//
+void CSSYOrientation::OpenChannelL()
+ {
+ SSY_TRACE_IN();
+
+ // if we are opening the channel for the first time
+ if ( !iSensorChannel )
+ {
+ TSensrvChannelInfo channelInfo;
+ channelInfo.iChannelType = KSensrvChannelTypeIdAccelerometerXYZAxisData;
+
+ // create channelfinder if it does not exist already
+ if ( !iChannelFinder )
+ {
+ iChannelFinder = CSensrvChannelFinder::NewL();
+ }
+
+ iChannelInfoList.Reset();
+
+ // find the accelerometer axis data channel
+ iChannelFinder->FindChannelsL( iChannelInfoList, channelInfo );
+
+ // we must find atleast one accelerometer axis channel
+ if ( !iChannelInfoList.Count() )
+ {
+ SSY_TRACE( EError, "ORIENTATIONSSY:ERROR: No KSensrvChannelTypeIdAccelerometerXYZAxisData found!" );
+ User::Leave( KErrNotFound );
+ }
+
+ // create the actual channel
+ iSensorChannel = CSensrvChannel::NewL( iChannelInfoList[0] );
+ }
+
+ // Reset orientation values
+
+ iTimerState = CSSYOrientation::EUninitialized;
+
+ // open the actual channel via sensor server
+ iSensorChannel->OpenChannelL();
+
+ SSY_TRACE_OUT();
+ }
+
+// ----------------------------------------------------------------------------------
+// CSSYOrientation::CloseChannelL()
+// ----------------------------------------------------------------------------------
+//
+void CSSYOrientation::CloseChannelL()
+ {
+ SSY_TRACE_IN();
+
+ if( !iSensorChannel )
+ {
+ User::Leave( KErrNotFound );
+ }
+
+ iSensorChannel->CloseChannel();
+ iChannel = NULL;
+
+ SSY_TRACE_OUT();
+ }
+
+// ----------------------------------------------------------------------------------
+// CSSYOrientation::StartListeningL()
+// ----------------------------------------------------------------------------------
+//
+void CSSYOrientation::StartListeningL()
+ {
+ SSY_TRACE_IN();
+
+ if ( !iSensorChannel )
+ {
+ User::Leave( KErrNotFound );
+ }
+
+ TInt desiredCount( 1 );
+ TInt maximumCount( 1 );
+ TInt bufferingPeriod( 0 );
+
+ iSensorChannel->StartDataListeningL( this, desiredCount, maximumCount, bufferingPeriod );
+
+ SSY_TRACE_OUT();
+ }
+
+// ----------------------------------------------------------------------------------
+// CSSYOrientation::StopListeningL()
+// ----------------------------------------------------------------------------------
+//
+void CSSYOrientation::StopListeningL()
+ {
+ SSY_TRACE_IN();
+
+ if ( !iSensorChannel )
+ {
+ User::Leave( KErrNotFound );
+ }
+
+ iSensorChannel->StopDataListening();
+ iChannel = NULL;
+
+ SSY_TRACE_OUT();
+ }
+
+// ----------------------------------------------------------------------------------
+// CSSYOrientation::GetDataFromHardware()
+// ----------------------------------------------------------------------------------
+//
+void CSSYOrientation::GetDataFromHardware( CSSYChannel* aChannel )
+ {
+ SSY_TRACE_IN();
+ iChannel = aChannel;
+ SSY_TRACE_OUT();
+ }
+
+// ----------------------------------------------------------------------------------
+// CSSYOrientation::GetMaxDataRateL()
+// ----------------------------------------------------------------------------------
+//
+void CSSYOrientation::GetMaxDataRateL( TSensrvProperty& aProperty )
+ {
+ SSY_TRACE_IN();
+ // Get data rate property
+ TSensrvProperty property;
+ iSensorChannel->GetPropertyL( KSensrvPropIdDataRate, KSensrvItemIndexNone, property );
+
+ // Check is it array type of property
+ if( ESensrvArrayPropertyInfo == property.GetArrayIndex() )
+ {
+ // Array type of property, get max property
+ TInt maxValueIndex( 0 );
+ property.GetMaxValue( maxValueIndex );
+ iSensorChannel->GetPropertyL( KSensrvPropIdDataRate,
+ KSensrvItemIndexNone, maxValueIndex, property );
+ }
+ else
+ {
+ // Single property, use max value as value
+ TInt maxValue( 0 );
+ property.GetMaxValue( maxValue );
+ property.SetValue( maxValue );
+ }
+
+ // Copy max data rate to reference parameter
+ aProperty = property;
+
+ SSY_TRACE_OUT();
+ }
+
+// ----------------------------------------------------------------------------------
+// CSSYOrientation::SendDataAfterTimer()
+// ----------------------------------------------------------------------------------
+//
+void CSSYOrientation::SendDataAfterTimer()
+ {
+ SSY_TRACE_IN()
+
+ // Timer has fired no send the data to channel if it is a valid state
+ iTimerState = CSSYOrientation::EStopped;
+ // Stop and delete timer
+ if( iEventTimer )
+ {
+ delete iEventTimer;
+ iEventTimer = NULL;
+ }
+ TInt amountOfOrientations = iOrientationArray.Count() - 1;
+
+ // If there are no orientation events don't try counting anything
+ if( amountOfOrientations >= 0 )
+ {
+ TInt lastOrientationOfArray = iOrientationArray[ amountOfOrientations ];
+ TInt sumOfCorrectOrientations( 0 );
+
+ // Check if the state should be changed to the state of the last orientation
+ for( TInt i = 0; iOrientationArray.Count() != i; i++ )
+ {
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:SendDataAfterTimer::iOrientationArray[ i ]=%d", iOrientationArray[ i ] );
+ if( iOrientationArray[ i ] == lastOrientationOfArray )
+ {
+ sumOfCorrectOrientations++;
+ }
+ }
+ TReal realCountOfArray = (TReal)( iOrientationArray.Count() );
+ TReal result = (TReal)(sumOfCorrectOrientations) / realCountOfArray;
+
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:SendDataAfterTimer::result=%f", result );
+
+ // If variance of the last orientation is in range and current orientation is a new orientation, change the state
+ if( ( result > KVariationFactor ) &&
+ ( iCurrentOrientationState.iDeviceOrientation !=
+ (TSensrvOrientationData::TSensrvDeviceOrientation)lastOrientationOfArray ) )
+ {
+ iOrientationEvent.iDeviceOrientation =
+ (TSensrvOrientationData::TSensrvDeviceOrientation)lastOrientationOfArray;
+
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:SendDataAfterTimer::Orientation changed to=%d", lastOrientationOfArray );
+ iCurrentOrientationState.iDeviceOrientation =
+ (TSensrvOrientationData::TSensrvDeviceOrientation)lastOrientationOfArray;
+
+ // Get configurations for the new state
+ GetConfigurationForState(
+ iCurrentOrientationState.iDeviceOrientation,
+ iConfigForCurrentState );
+
+ if( iChannel )
+ {
+ if( ( iChannelType == KSensrvChannelTypeIdOrientationData ) &&
+ ( iChannel->AppendData( iOrientationEvent, iRotationEvent ) ) )
+ {
+ iChannel->IssueRequest();
+ iChannel = NULL;
+ }
+ }
+ }
+
+ iOrientationArray.Reset();
+ }
+
+ SSY_TRACE_OUT();
+ }
+
+// ----------------------------------------------------------------------------------
+// CSSYOrientation::SetConfigurationForState()
+// ----------------------------------------------------------------------------------
+//
+void CSSYOrientation::SetConfigurationForState(
+ const TOrientationConfiguration& aConfigurationForState )
+ {
+ SSY_TRACE_IN();
+ TBool wasFound( EFalse );
+ // Check if is in array
+ for( TInt i = 0; i != iConfigArray.Count(); i++ )
+ {
+ TOrientationConfiguration ori = iConfigArray[ i ];
+ if( aConfigurationForState.iOrientationState == iConfigArray[ i ].iOrientationState )
+ {
+ iConfigArray.Remove( i );
+ iConfigArray.Insert( aConfigurationForState, i );
+ wasFound = ETrue;
+ }
+ }
+ if( !wasFound )
+ {
+ iConfigArray.Append( aConfigurationForState );
+ }
+ SSY_TRACE_OUT();
+ }
+
+// ----------------------------------------------------------------------------------
+// CSSYOrientation::GetConfigurationForState()
+// ----------------------------------------------------------------------------------
+//
+void CSSYOrientation::GetConfigurationForState(
+ const TSensrvOrientationData::TSensrvDeviceOrientation aOrientation,
+ TOrientationConfiguration& aConfigurationForState )
+ {
+ SSY_TRACE_IN();
+ SSY_TRACE( EExtended, "ORIENTATIONSSY: First time data received, set first orientation=%d", (TInt)aOrientation );
+ // Check if is in array
+ for( TInt i = 0; i != iConfigArray.Count(); i++ )
+ {
+ TOrientationConfiguration ori = iConfigArray[ i ];
+ if( aOrientation == iConfigArray[ i ].iOrientationState )
+ {
+ aConfigurationForState = iConfigArray[ i ];
+ }
+ }
+ SSY_TRACE_OUT();
+ }
+
+// ----------------------------------------------------------------------------------
+// CSSYOrientation::CreteConfigurations()
+// ----------------------------------------------------------------------------------
+//
+void CSSYOrientation::CreateConfigurations()
+ {
+ SSY_TRACE_IN();
+
+ TInt repValue( 0 );
+
+ // This is used in initialisation
+ if( iConfigForCurrentState.iOrientationState == TSensrvOrientationData::EOrientationUndefined )
+ {
+ iConfigForCurrentState.iOrientationDisplayUp.iAngle = 0;
+ iConfigForCurrentState.iOrientationDisplayUp.iTimerValueInMilSeconds = 0;
+ iConfigForCurrentState.iOrientationDisplayDown.iAngle = 0;
+ iConfigForCurrentState.iOrientationDisplayDown.iTimerValueInMilSeconds = 0;
+ iConfigForCurrentState.iOrientationDisplayLeftUp.iAngle = 0;
+ iConfigForCurrentState.iOrientationDisplayLeftUp.iTimerValueInMilSeconds = 0;
+ iConfigForCurrentState.iOrientationDisplayRightUp.iAngle = 0;
+ iConfigForCurrentState.iOrientationDisplayRightUp.iTimerValueInMilSeconds = 0;
+ iConfigForCurrentState.iOrientationDisplayUpwards.iAngle = 0;
+ iConfigForCurrentState.iOrientationDisplayUpwards.iTimerValueInMilSeconds = 0;
+ iConfigForCurrentState.iOrientationDisplayDownwards.iAngle = 0;
+ iConfigForCurrentState.iOrientationDisplayDownwards.iTimerValueInMilSeconds = 0;
+ }
+
+ // Configuration for display up
+ TOrientationConfiguration configForDisplayUp;
+ configForDisplayUp.iOrientationState = TSensrvOrientationData::EOrientationDisplayUp;
+ configForDisplayUp.iOrientationDisplayUp.iAngle = 0;
+ configForDisplayUp.iOrientationDisplayUp.iTimerValueInMilSeconds = 0;
+
+ iRepository->Get( KOriStateDisplayUpToDisplayDownKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUp.iOrientationDisplayDown=%d", repValue );
+ configForDisplayUp.iOrientationDisplayDown.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayUpToDisplayDownTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUp.iOrientationDisplayDowniTimerValueInMilSeconds=%d", repValue );
+ configForDisplayUp.iOrientationDisplayDown.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayUpToDisplayLeftUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUp.iOrientationDisplayLeftUp=%d", repValue );
+ configForDisplayUp.iOrientationDisplayLeftUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayUpToDisplayLeftUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUp.iOrientationDisplayLeftUpiTimerValueInMilSeconds=%d", repValue );
+ configForDisplayUp.iOrientationDisplayLeftUp.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayUpToDisplayRightUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUp.iOrientationDisplayRightUp=%d", repValue );
+ configForDisplayUp.iOrientationDisplayRightUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayUpToDisplayRightUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUp.iOrientationDisplayRightUpiTimerValueInMilSeconds=%d", repValue );
+ configForDisplayUp.iOrientationDisplayRightUp.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayUpToDisplayUpwardsKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUp.iOrientationDisplayUpwards=%d", repValue );
+ configForDisplayUp.iOrientationDisplayUpwards.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayUpToDisplayUpwardsTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUp.iOrientationDisplayUpwards.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayUp.iOrientationDisplayUpwards.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayUpToDisplayDownwardsKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUp.iOrientationDisplayDownwards=%d", repValue );
+ configForDisplayUp.iOrientationDisplayDownwards.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayUpToDisplayDownwardsTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUp.iOrientationDisplayDownwards.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayUp.iOrientationDisplayDownwards.iTimerValueInMilSeconds = repValue;
+
+ SetConfigurationForState( configForDisplayUp );
+
+ // Configuration for display down
+ TOrientationConfiguration configForDisplayDown;
+ configForDisplayDown.iOrientationState = TSensrvOrientationData::EOrientationDisplayDown;
+
+ iRepository->Get( KOriStateDisplayDownToDisplayUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDown.iOrientationDisplayUp=%d", repValue );
+ configForDisplayDown.iOrientationDisplayUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayDownToDisplayUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDown.iOrientationDisplayUp.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayDown.iOrientationDisplayUp.iTimerValueInMilSeconds = repValue;
+
+ configForDisplayDown.iOrientationDisplayDown.iAngle = 0;
+ configForDisplayDown.iOrientationDisplayDown.iTimerValueInMilSeconds = 0;
+
+ iRepository->Get( KOriStateDisplayDownToDisplayLeftUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDown.iOrientationDisplayLeftUp=%d", repValue );
+ configForDisplayDown.iOrientationDisplayLeftUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayDownToDisplayLeftUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDown.iOrientationDisplayLeftUp.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayDown.iOrientationDisplayLeftUp.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayDownToDisplayRightUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDown.iOrientationDisplayRightUp=%d", repValue );
+ configForDisplayDown.iOrientationDisplayRightUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayDownToDisplayRightUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDown.iOrientationDisplayRightUp.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayDown.iOrientationDisplayRightUp.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayDownToDisplayUpwardsKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDown.iOrientationDisplayUpwards=%d", repValue );
+ configForDisplayDown.iOrientationDisplayUpwards.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayDownToDisplayUpwardsTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDown.iOrientationDisplayUpwards.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayDown.iOrientationDisplayUpwards.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayDownToDisplayDownwardsKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDown.iOrientationDisplayDownwards=%d", repValue );
+ configForDisplayDown.iOrientationDisplayDownwards.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayDownToDisplayDownwardsTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDown.iOrientationDisplayDownwards.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayDown.iOrientationDisplayDownwards.iTimerValueInMilSeconds = repValue;
+ SetConfigurationForState( configForDisplayDown );
+
+ // Configuration for left up
+ TOrientationConfiguration configForDisplayLeftUp;
+ configForDisplayLeftUp.iOrientationState = TSensrvOrientationData::EOrientationDisplayLeftUp;
+
+ iRepository->Get( KOriStateDisplayLeftUpToDisplayUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayLeftUp.iOrientationDisplayUp=%d", repValue );
+ configForDisplayLeftUp.iOrientationDisplayUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayLeftUpToDisplayUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayLeftUp.iOrientationDisplayUp.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayLeftUp.iOrientationDisplayUp.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayLeftUpToDisplayDownKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayLeftUp.iOrientationDisplayDown=%d", repValue );
+ configForDisplayLeftUp.iOrientationDisplayDown.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayLeftUpToDisplayDownTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayLeftUp.iOrientationDisplayDown.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayLeftUp.iOrientationDisplayDown.iTimerValueInMilSeconds = repValue;
+
+ configForDisplayLeftUp.iOrientationDisplayLeftUp.iAngle = 0;
+ configForDisplayLeftUp.iOrientationDisplayLeftUp.iTimerValueInMilSeconds = 0;
+
+ iRepository->Get( KOriStateDisplayLeftUpToDisplayRightUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayLeftUp.iOrientationDisplayRightUp=%d", repValue );
+ configForDisplayLeftUp.iOrientationDisplayRightUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayLeftUpToDisplayRightUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayLeftUp.iOrientationDisplayRightUp.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayLeftUp.iOrientationDisplayRightUp.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayLeftUpToDisplayUpwardsKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayLeftUp.iOrientationDisplayUpwards=%d", repValue );
+ configForDisplayLeftUp.iOrientationDisplayUpwards.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayLeftUpToDisplayUpwardsTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayLeftUp.iOrientationDisplayUpwards.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayLeftUp.iOrientationDisplayUpwards.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayLeftUpToDisplayDownwardsKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayLeftUp.iOrientationDisplayDownwards=%d", repValue );
+ configForDisplayLeftUp.iOrientationDisplayDownwards.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayLeftUpToDisplayDownwardsTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayLeftUp.iOrientationDisplayDownwards.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayLeftUp.iOrientationDisplayDownwards.iTimerValueInMilSeconds = repValue;
+ SetConfigurationForState( configForDisplayLeftUp );
+
+ // Configuration for right up
+ TOrientationConfiguration configForDisplayRightUp;
+ configForDisplayRightUp.iOrientationState = TSensrvOrientationData::EOrientationDisplayRightUp;
+
+ iRepository->Get( KOriStateDisplayRightUpToDisplayUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayRightUp.iOrientationDisplayUp=%d", repValue );
+ configForDisplayRightUp.iOrientationDisplayUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayRightUpToDisplayUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayRightUp.iOrientationDisplayUp.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayRightUp.iOrientationDisplayUp.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayRightUpToDisplayDownKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayRightUp.iOrientationDisplayDown=%d", repValue );
+ configForDisplayRightUp.iOrientationDisplayDown.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayRightUpToDisplayDownTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayRightUp.iOrientationDisplayDown.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayRightUp.iOrientationDisplayDown.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayRightUpToDisplayLeftUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayRightUp.iOrientationDisplayLeftUp=%d", repValue );
+ configForDisplayRightUp.iOrientationDisplayLeftUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayRightUpToDisplayLeftUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayRightUp.iOrientationDisplayLeftUp.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayRightUp.iOrientationDisplayLeftUp.iTimerValueInMilSeconds = repValue;
+
+ configForDisplayRightUp.iOrientationDisplayRightUp.iAngle = 0;
+ configForDisplayRightUp.iOrientationDisplayRightUp.iTimerValueInMilSeconds = 0;
+
+ iRepository->Get( KOriStateDisplayRightUpToDisplayUpwardsKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayRightUp.iOrientationDisplayUpwards=%d", repValue );
+ configForDisplayRightUp.iOrientationDisplayUpwards.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayRightUpToDisplayUpwardsTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayRightUp.iOrientationDisplayUpwards.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayRightUp.iOrientationDisplayUpwards.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayRightUpToDisplayDownwardsKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayRightUp.iOrientationDisplayDownwards=%d", repValue );
+ configForDisplayRightUp.iOrientationDisplayDownwards.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayRightUpToDisplayDownwardsTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayRightUp.iOrientationDisplayDownwards.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayRightUp.iOrientationDisplayDownwards.iTimerValueInMilSeconds = repValue;
+ SetConfigurationForState( configForDisplayRightUp );
+
+ // Configuration for upwards
+ TOrientationConfiguration configForDisplayUpwards;
+ configForDisplayUpwards.iOrientationState = TSensrvOrientationData::EOrientationDisplayUpwards;
+
+ iRepository->Get( KOriStateDisplayUpwardsToDisplayUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUpwards.iOrientationDisplayUp=%d", repValue );
+ configForDisplayUpwards.iOrientationDisplayUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayUpwardsToDisplayUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUpwards.iOrientationDisplayUp.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayUpwards.iOrientationDisplayUp.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayUpwardsToDisplayDownKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUpwards.iOrientationDisplayDown=%d", repValue );
+ configForDisplayUpwards.iOrientationDisplayDown.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayUpwardsToDisplayDownTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUpwards.iOrientationDisplayDown.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayUpwards.iOrientationDisplayDown.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayUpwardsToDisplayLeftUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUpwards.iOrientationDisplayLeftUp=%d", repValue );
+ configForDisplayUpwards.iOrientationDisplayLeftUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayUpwardsToDisplayLeftUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUpwards.iOrientationDisplayLeftUp.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayUpwards.iOrientationDisplayLeftUp.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayUpwardsToDisplayRightUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUpwards.iOrientationDisplayRightUp=%d", repValue );
+ configForDisplayUpwards.iOrientationDisplayRightUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayUpwardsToDisplayRightUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUpwards.iOrientationDisplayRightUp.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayUpwards.iOrientationDisplayRightUp.iTimerValueInMilSeconds = repValue;
+
+ configForDisplayUpwards.iOrientationDisplayUpwards.iAngle = 0;
+ configForDisplayUpwards.iOrientationDisplayUpwards.iTimerValueInMilSeconds = 0;
+
+ iRepository->Get( KOriStateDisplayUpwardsToDisplayDownwardsKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUpwards.iOrientationDisplayDownwards=%d", repValue );
+ configForDisplayUpwards.iOrientationDisplayDownwards.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayUpwardsToDisplayDownwardsTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayUpwards.iOrientationDisplayDownwards.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayUpwards.iOrientationDisplayDownwards.iTimerValueInMilSeconds = repValue;
+ SetConfigurationForState( configForDisplayUpwards );
+
+ // Configuration for downwards
+ TOrientationConfiguration configForDisplayDownwards;
+ configForDisplayDownwards.iOrientationState =
+ TSensrvOrientationData::EOrientationDisplayDownwards;
+
+ iRepository->Get( KOriStateDisplayDownwardsToDisplayUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDownwards.iOrientationDisplayUp=%d", repValue );
+ configForDisplayDownwards.iOrientationDisplayUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayDownwardsToDisplayUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDownwards.iOrientationDisplayUp.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayDownwards.iOrientationDisplayUp.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayDownwardsToDisplayDownKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDownwards.iOrientationDisplayDown=%d", repValue );
+ configForDisplayDownwards.iOrientationDisplayDown.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayDownwardsToDisplayDownTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDownwards.iOrientationDisplayDown.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayDownwards.iOrientationDisplayDown.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayDownwardsToDisplayLeftUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDownwards.iOrientationDisplayLeftUp=%d", repValue );
+ configForDisplayDownwards.iOrientationDisplayLeftUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayDownwardsToDisplayLeftUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDownwards.iOrientationDisplayLeftUp.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayDownwards.iOrientationDisplayLeftUp.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayDownwardsToDisplayRightUpKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDownwards.iOrientationDisplayRightUp=%d", repValue );
+ configForDisplayDownwards.iOrientationDisplayRightUp.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayDownwardsToDisplayRightUpTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDownwards.iOrientationDisplayRightUp.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayDownwards.iOrientationDisplayRightUp.iTimerValueInMilSeconds = repValue;
+
+ iRepository->Get( KOriStateDisplayDownwardsToDisplayUpwardsKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDownwards.iOrientationDisplayUpwards=%d", repValue );
+ configForDisplayDownwards.iOrientationDisplayUpwards.iAngle = repValue;
+
+ iRepository->Get( KOriStateDisplayDownwardsToDisplayUpwardsTimerKey, repValue );
+ SSY_TRACE( EExtended, "ORIENTATIONSSY:CreteConfigurations::EOrientationDisplayDownwards.iOrientationDisplayUpwards.iTimerValueInMilSeconds=%d", repValue );
+ configForDisplayDownwards.iOrientationDisplayUpwards.iTimerValueInMilSeconds = repValue;
+
+ configForDisplayDownwards.iOrientationDisplayDownwards.iAngle = 0;
+ configForDisplayDownwards.iOrientationDisplayDownwards.iTimerValueInMilSeconds = 0;
+
+ SetConfigurationForState( configForDisplayDownwards );
+
+ if( iConfigForCurrentState.iOrientationState != TSensrvOrientationData::EOrientationUndefined )
+ {
+ GetConfigurationForState(
+ iCurrentOrientationState.iDeviceOrientation, iConfigForCurrentState );
+ }
+
+ SSY_TRACE_OUT();
+ }
+
+// ----------------------------------------------------------------------------------
+// CSSYOrientation::GetDataListenerInterfaceL()
+// ----------------------------------------------------------------------------------
+//
+void CSSYOrientation::GetDataListenerInterfaceL(
+ TUid /*aInterfaceUid*/,
+ TAny*& aInterface )
+ {
+ aInterface = NULL;
+ }
+
+// End of File