examples/Qt/sensorgesture/CoverGesture/coverrecognizer.cpp

/****************************************************************************
**
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation
**
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
**   * Redistributions of source code must retain the above copyright
**     notice, this list of conditions and the following disclaimer.
**   * Redistributions in binary form must reproduce the above copyright
**     notice, this list of conditions and the following disclaimer in
**     the documentation and/or other materials provided with the
**     distribution.
**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
**     the names of its contributors may be used to endorse or promote
**     products derived from this software without specific prior written
**     permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
** $QT_END_LICENSE$
**
****************************************************************************/
// User includes
#include "coverrecognizer.h"

// Constants
// We would prefer accelerometer running at 2g range. 
const qreal idealRange = 19.62;
// Default z value for moving average filter
const qreal movingAverageDefaultZ = 10.0/movingAverageSamples;
// Minimum time the phone should be covered and lying flat, face up and still before the
// recognized signal is emmited. Time in ms.
const uint minimumCoverTimeMS = 500;


// Namespace needed to use Qt Mobility APIs
// (defined in qmobilityglobal.h but implicitly included from any Qt Mobility header)
QTM_USE_NAMESPACE

CoverRecognizer::CoverRecognizer()
{
    mAccSensor = new QAccelerometer();
    // Call the filter_accelerometer() function when new accelerometet data is ready.
    connect(mAccSensor, SIGNAL(readingChanged()), this, SLOT(filter_accelerometer()));
    
    mProxSensor = new QProximitySensor();
    // Call the filter_proximity() function when new proximity data is ready.
    connect(mProxSensor, SIGNAL(readingChanged()), this, SLOT(filter_proximity()));
    
    mElapsedTimer = new QElapsedTimer();
    
    // Initialize moving average filter data index to 0.
    mMovingAverageIndex = 0;    
}

CoverRecognizer::~CoverRecognizer()
{
    delete mAccSensor;
    delete mProxSensor;
    delete mElapsedTimer;
}

bool CoverRecognizer::start()
{
    // Test if accelerometer is functional, by starting it.
    bool result = mAccSensor->start();
    // If accelerometer is functional we can continue start up of gesture detection.
    if (result) {
        // Stop accelerometer again, since it is not needed yet.
        mAccSensor->stop();
        // Find the closest available accelerometer range to 2g.
        qoutputrangelist outputRangeList = mAccSensor->outputRanges();
        int numOfItems = outputRangeList.count();
        if (0 < numOfItems) {
            qreal rangeDiff = qAbs(outputRangeList.first().maximum - idealRange);
            int selectedIndex(0);
            for (int i(1); i < numOfItems; ++i) {
                if (qAbs(outputRangeList.at(i).maximum - idealRange) < rangeDiff) {
                    // This is closer to 2g range than the previously checked one.
                    selectedIndex = i;
                    rangeDiff = qAbs(outputRangeList.at(i).maximum - idealRange);
                }
            }
            // Now we have the index to the range closest to 2g.
            mAccSensor->setOutputRange(selectedIndex);
        }
        
        // Start proximity sensor in order to start detecting gesture. result will now 
        // only be true if both accelerometer and proximity sensors are able to start.
        result &= mProxSensor->start();
    }
   
    return result;
}

void CoverRecognizer::stop()
{   
    mAccSensor->stop();
    mProxSensor->stop();
}

void CoverRecognizer::filter_accelerometer()
{
    QAccelerometerReading *accReading = mAccSensor->reading();
    if(mElapsedTimer->isValid())
    {
        // Moving average filter is used to smooth out outliers that can occur for
        // example when a hand hits the phone in order to cover it.
        mXValues[mMovingAverageIndex] = accReading->x()/movingAverageSamples;
        mYValues[mMovingAverageIndex] = accReading->y()/movingAverageSamples;
        mZValues[mMovingAverageIndex] = accReading->z()/movingAverageSamples;
        if(++mMovingAverageIndex >= movingAverageSamples)
        {
            mMovingAverageIndex = 0;
        }
        qreal xAvg = 0.0;
        qreal yAvg = 0.0;
        qreal zAvg = 0.0;
        for (int i = 0; i < movingAverageSamples; i++)
        {
            xAvg += mXValues[i];
            yAvg += mYValues[i];
            zAvg += mZValues[i];
        }
        
        // Test for accepted accelerometer values. Values are tested within a margin
        // to compensate for the phone being placed on surfaces that are not accurately 
        // perpendicular to the earths center of gravity (and accelerometer
        // inaccuracies).
        if(qAbs(xAvg) < 2 && qAbs(yAvg) < 2 && zAvg < 12 && zAvg > 7)
        {
            // Accelerometer values are within accepted range. Check if they have been
            // so for at least the minimum required amount of time.
            
            if(mElapsedTimer->elapsed() >= minimumCoverTimeMS)
            {
                // The phone has been covered and lying flat, face up and still for the
                // required minimum amount of time. Emit signal to user that cover
                // gesture has occured.
                emitSignal();
                // Stop accelerometer sensor and timer. Note that proximity sensor is
                // still running, so if user uncovers and covers phone again it will be
                // detected.
                mAccSensor->stop();
                mElapsedTimer->invalidate();
            }
        }
        else
        {
            // Accelerometer values outside accepted range. The phone is not lying flat,
            // face up and still. Restart timer.
            mElapsedTimer->restart();
        }
    } else {
        // Do nothing.
        // Accelerometer is started and stopped during start() call. In case we get any
        // accelerometer data during that time we end up here.
    }
}

void CoverRecognizer::filter_proximity()
{
    if (mProxSensor->reading()->close()) {
        // Phone is covered.
        // Reset moving average filter sample values to prevent old data from influencing
        // gesture detection.
        for (int i = 0; i < movingAverageSamples; i++)
        {
            mXValues[i] = 0.0;
            mYValues[i] = 0.0;
            mZValues[i] = movingAverageDefaultZ;
        }
        // Start accelerometer and timer to check if the phone is lying flat, face up and
        // still for the minimum required amount of time.
        mAccSensor->start();
        mElapsedTimer->start();
    } else {
        // Phone is no longer covered.
        // Stop accelerometer and timer since they are no longer needed.               
        mAccSensor->stop();
        mElapsedTimer->invalidate();
    }
       
}

void CoverRecognizer::emitSignal()
{
    emit recognized(coverGestureType, QVariantHash()); 
}

---