/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include "xqdeviceorientation_p.h"

#include <e32math.h>

const TInt KDefaultResolution = 15;

XQDeviceOrientationPrivate::XQDeviceOrientationPrivate(

        XQDeviceOrientation& qq) : q(qq), iResolution(KDefaultResolution)

{

    iXRotation = 0;

    iYRotation = 0;

    iZRotation = 0;

}

XQDeviceOrientationPrivate::~XQDeviceOrientationPrivate()

{

    close();

}

void XQDeviceOrientationPrivate::open()

{

    iAccelerationSensor.addFilter(*this);

    iAccelerationSensor.addFilter(iAccelerationPostFilter);

    iAccelerationSensor.open();

    iAccelerationSensor.startReceiving();

}

void XQDeviceOrientationPrivate::close()

{

    iAccelerationSensor.stopReceiving();

    iAccelerationSensor.close();

    iAccelerationSensor.filters().removeOne(this);

}

void XQDeviceOrientationPrivate::setResolution(TInt resolution)

{

    iResolution = resolution;

}

TInt XQDeviceOrientationPrivate::resolution() const

{

    return iResolution;

}

int XQDeviceOrientationPrivate::xRotation() const

{

    return iXRotation;

}

int XQDeviceOrientationPrivate::yRotation() const

{

    return iYRotation;

}

int XQDeviceOrientationPrivate::zRotation() const

{

    return iZRotation;

}

XQDeviceOrientation::DisplayOrientation

        XQDeviceOrientationPrivate::orientation() const

{

    return iOrientation;

}

bool XQDeviceOrientationPrivate::filter(int& xAcceleration, 

    int& yAcceleration, int& zAcceleration)

{

    TReal xAcc = xAcceleration;

    TReal yAcc = yAcceleration;

    TReal zAcc = zAcceleration;

    TReal angle = 0;

    //axis X rotation

    if (yAcc != 0) {

        Math::ATan(angle, Abs(zAcc / yAcc));

        angle *= 180 / KPi;  //rad to degrees

        if (zAcc > 0 && yAcc > 0) {

            //do nothing

        } else if (zAcc > 0 && yAcc < 0) {

            angle = 90 + (90 - angle);

        } else if (zAcc < 0 && yAcc < 0) {

            angle += 180;

        } else {

            angle = 270 + (90 - angle);

        }

    } else {

        if (zAcceleration > 0) {

            angle = 90;

        } else {

            angle = 270;

        }

    }

    TInt xRotation = RoundAngle(angle);

    //axis Y rotation

    if (xAcc != 0) {

        Math::ATan(angle, Abs(zAcc / xAcc));

        angle *= 180 / KPi;  //rad to degrees

        if (zAcc > 0 && xAcc > 0) {

            angle += 90;

        } else if (zAcc > 0 && xAcc < 0) {

            angle = 270 - angle;

        } else if (zAcc < 0 && xAcc < 0) {

            angle += 270;

        } else {

            angle = 90 - angle;

        }

    } else {

        if (zAcceleration > 0) {

            angle = 180;

        } else {

            angle = 0;

        }

    }

    TInt yRotation = RoundAngle(angle);

    //axis Z rotation

    if (yAcc != 0) {

        Math::ATan(angle, Abs(xAcc / yAcc));

        angle *= 180 / KPi;  //rad to degrees

        if (xAcc > 0 && yAcc > 0) {

            angle = 360 - angle;

        } else if (xAcc > 0 && yAcc < 0) {

            angle += 180;

        } else if (xAcc <= 0 && yAcc <= 0) {

            angle = 180 - angle;

        } else {

            //Do nothing

        }

    } else {

        if (xAcceleration > 0) {

            angle = 270;

        } else {

            angle = 90;

        }

    }

    TInt zRotation = RoundAngle(angle);

    iXRotation = xRotation;

    iYRotation = yRotation;

    iZRotation = zRotation;

    XQDeviceOrientation::DisplayOrientation orientation =

            XQDeviceOrientation::OrientationUndefined;

    if (((315 < xRotation && xRotation < 360) ||

            (0 <= xRotation && xRotation <= 45)) &&

         ((315 < zRotation && zRotation < 360) ||

            (0 <= zRotation && zRotation <= 45))) {

        orientation = XQDeviceOrientation::OrientationDisplayUp;

    } else if (135 < xRotation && xRotation <= 225 && 135 < zRotation &&

            zRotation <= 225) {

        orientation = XQDeviceOrientation::OrientationDisplayDown;

    } else if (225 < yRotation && yRotation <= 315 && 45 < zRotation &&

            zRotation <= 135) {

        orientation = XQDeviceOrientation::OrientationDisplayLeftUp;

    } else if (45 < yRotation && yRotation <= 135 && 225 < zRotation &&

            zRotation <= 315) {

        orientation = XQDeviceOrientation::OrientationDisplayRightUp;

    } else if (45 < xRotation && xRotation <= 135 && 135 < yRotation &&

            yRotation <= 225) {

        orientation = XQDeviceOrientation::OrientationDisplayUpwards;

    } else if (225 < xRotation && xRotation <= 315 &&

        ((315 < yRotation && yRotation < 360) || (0 <= yRotation &&

            yRotation <= 45))) {

        orientation = XQDeviceOrientation::OrientationDisplayDownwards;

    }

    emit q.rotationChanged(xRotation, yRotation, zRotation);

    if (orientation != iOrientation) {

        if (orientation != XQDeviceOrientation::OrientationUndefined) {

            emit q.orientationChanged(orientation);

        }

        iOrientation = orientation;

    }

    return false;

}

TInt XQDeviceOrientationPrivate::RoundAngle(TReal aAngle) const

{

    return ((TInt(aAngle) + iResolution / 2) / iResolution * iResolution) % 360;

}

// End of file