examples/SFExamples/RecipeEx/src/SensorListener.cpp

// Symbian Foundation Example Code
// 
// This software is in the public domain. No copyright is claimed, and you 
// may use it for any purpose without license from the Symbian Foundation.
// No warranty for any purpose is expressed or implied by the authors or
// the Symbian Foundation. 


#include <SensrvDataListener.h> 
#include <sensrvchannelfinder.h> 
#include <sensrvchannel.h> 
#include <sensrvaccelerometersensor.h>
#include <e32math.h>

#include "SensorListener.h"     
#include "LogContainer.h"       

// Constants
const TReal KIntervalBetweenShakes = 0.5;
const TReal KShakeThreshold = 100;

CSensorListener* CSensorListener::NewL(CLogContainer* aLogView)
        {
        CSensorListener* self = CSensorListener::NewLC(aLogView);
        CleanupStack::Pop(self);
        return self;
        }

CSensorListener* CSensorListener::NewLC(CLogContainer* aLogView)
        {
        CSensorListener* self = new (ELeave) CSensorListener(aLogView);
        CleanupStack::PushL(self);
        self->ConstructL();
        return self;
        }

CSensorListener::~CSensorListener()
        {
        if(iSensrvChannel)
        {
                iSensrvChannel->StopDataListening();
                iSensrvChannel->CloseChannel();
        }
        
        delete iSensrvChannel;
        iChannelInfoList.Reset();
        delete iSensrvChannelFinder;
        }

CSensorListener::CSensorListener(CLogContainer* aLogView) : iLogView(aLogView)
        {
        }

void CSensorListener::ConstructL()
        {
        _LIT(KSensorNotSupported, "Sensor not supported!");
        _LIT(KIntroduction, "Shake detector...");

        iLogView->LogEntryL(KIntroduction);
        
        iSensrvChannelFinder = CSensrvChannelFinder::NewL(); 
        
        TSensrvChannelInfo searchConditions; // match for AccelerometerXYZ
        searchConditions.iChannelType = KSensrvChannelTypeIdAccelerometerXYZAxisData;
        iSensrvChannelFinder->FindChannelsL(iChannelInfoList,searchConditions);
                                
        if (iChannelInfoList.Count()<1)
                {
                // The sensor is not supported on this device
                iLogView->LogEntryL(KSensorNotSupported);
                }
        else
                {
                // Create the sensor channel using the first returned in the search
                iSensrvChannel = CSensrvChannel::NewL(iChannelInfoList[0]);
                iSensrvChannel->OpenChannelL();
                
                // Start Listening for data. 
                iSensrvChannel->StartDataListeningL( 
                                this,   
                                1,              /* The desired and maximum number of measured data items */ 
                                                /* before a callback. A value of 1 means we will not miss a single item. */
                                1,
                                0);
                
                // Set the current univeral time
                iLastTime.UniversalTime();
                }
        
        }

void CSensorListener::DataReceived( CSensrvChannel& aChannel, 
                                                   TInt aCount, 
                                                   TInt /*aDataLost*/ )
        {
        _LIT(KShaken, "%S: Shake Detected");
        
        TTime currentTime;
        currentTime.UniversalTime();
        
        TTimeIntervalSeconds timeDiff;
        currentTime.SecondsFrom(iLastTime, timeDiff);
        
        if (timeDiff.Int()>KIntervalBetweenShakes)
                {
                // Only respond to data from the channel type we are interested in.
                if ( aChannel.GetChannelInfo().iChannelType ==  KSensrvChannelTypeIdAccelerometerXYZAxisData )
                        {       
                        TSensrvAccelerometerAxisData data;
                        for( TInt i = 0; i < aCount; i++ )
                                {
                                TPckgBuf<TSensrvAccelerometerAxisData> dataBuf;
                                aChannel.GetData( dataBuf );
                                data = dataBuf();

                                TInt x = data.iAxisX;
                                TInt y = data.iAxisY;
                                TInt z = data.iAxisZ;
                                
                                TReal source = TReal(x * x + y * y + z * z);
                                TReal result(0.0);
                                
                                // Calculate the violence of current acceleration 
                            Math::Sqrt(result, source);
                            
                            // Log a shake if the violence exceeds our threshold
                            if (result>KShakeThreshold)
                                {
                                        // Log the timestamp and XYZ data
                                        _LIT(KTimeFormat,"%H:%T:%S");
                                        TBuf <50> formattedTime;
                                        TRAP_IGNORE(data.iTimeStamp.FormatL(formattedTime, KTimeFormat));
                                        TRAP_IGNORE(iLogView->LogEntryL(KShaken, &formattedTime));
                                }
                                }
                        }
                iLastTime.UniversalTime();
                }
        }

void CSensorListener::DataError( CSensrvChannel& aChannel, 
                                                TSensrvErrorSeverity aError )
        {
        // Sensor error severity 
        _LIT(KSeverityNotDefined, "Not Defined");
        _LIT(KSeverityMinor, "Minor");
        _LIT(KSeverityFatal, "Fatal");
        _LIT(KSensorDataError, "Sensor error, severity: %S");
        
        // Only log errors for the channel we are interested in.
        if (aChannel.GetChannelInfo().iChannelType == KSensrvChannelTypeIdAccelerometerXYZAxisData)
                {
                switch (aError)
                        {
                        case ESensrvErrorSeverityMinor:
                                {
                                TRAP_IGNORE(iLogView->LogEntryL(KSensorDataError, &KSeverityMinor));
                                break;
                                }
                        case ESensrvErrorSeverityFatal:                 
                                {
                                TRAP_IGNORE(iLogView->LogEntryL(KSensorDataError, &KSeverityFatal));
                                break;
                                }
                        case ESensrvErrorSeverityNotDefined:
                        default:                
                                {
                                TRAP_IGNORE(iLogView->LogEntryL(KSensorDataError, &KSeverityNotDefined));
                                break;
                                }
                        }
                }
        }

void CSensorListener::GetDataListenerInterfaceL( TUid /*aInterfaceUid*/, TAny*& /*aInterface*/ )
        {
        // Not implemented
        }

// End of File

---