diff -r 000000000000 -r 4e1aa6a622a0 sensorservices/orientationssy/src/SsyOrientation.cpp --- /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 +#include +#include +#include +#include +#include +#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 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