diff -r 06b8e2af4411 -r 6fbed849b4f4 qtmobility/plugins/sensors/symbian/sensorbackendsym.cpp --- a/qtmobility/plugins/sensors/symbian/sensorbackendsym.cpp Fri Jun 11 14:26:25 2010 +0300 +++ b/qtmobility/plugins/sensors/symbian/sensorbackendsym.cpp Wed Jun 23 19:08:38 2010 +0300 @@ -42,12 +42,12 @@ #include "sensorbackendsym.h" #include +#include // Constants const TInt KDesiredReadingCount = 1; const TInt KMaximumReadingCount = 1; const TInt KDefaultBufferingPeriod = 0; -const TInt KInvalidDataRate = 123456; const TInt KAccuracyInvalid = -1; ///// Internal Functions @@ -63,6 +63,7 @@ CSensrvChannelFinder* finder = CSensrvChannelFinder::NewLC(); RSensrvChannelInfoList channelList; TSensrvChannelInfo channelInfo; + channelInfo.iChannelType = iBackendData.iSensorType; // Retrieve the list of channels available finder->FindChannelsL( channelList, channelInfo ); CleanupStack::PopAndDestroy(finder); @@ -153,6 +154,19 @@ return iBackendData.iSensorChannel->SetProperty(prop); } +TSensrvPropertyType CSensorBackendSym::propertyType(TSensrvPropertyId aPropertyId, TInt &errId) + { + TSensrvProperty propertyType; + //Getting the property to check the type + TRAPD(err, iBackendData.iSensorChannel->GetPropertyL(aPropertyId, ESensrvSingleProperty, propertyType)); + if(err != KErrNone) + { + errId = err; + } + //Find the type of property + return propertyType.PropertyType(); + } + TInt CSensorBackendSym::SetMeasurementRange() { //Setting measurement range @@ -161,15 +175,13 @@ { return KErrNone; } - TSensrvProperty propertyType; - //Getting the property to check the type - TRAPD(err, iBackendData.iSensorChannel->GetPropertyL(KSensrvPropIdMeasureRange, ESensrvSingleProperty, propertyType)); + + TInt err = KErrNone; + TSensrvPropertyType type = propertyType(KSensrvPropIdMeasureRange, err); if(err != KErrNone) { return err; } - //Find the type of property - TSensrvPropertyType type = propertyType.PropertyType(); //If type is integer if(type == ESensrvRealProperty) { @@ -180,6 +192,7 @@ { return SetProperty(KSensrvPropIdMeasureRange, ESensrvIntProperty, ESensrvArrayPropertyInfo, sensor()->outputRange()); } + return KErrNone; } TInt CSensorBackendSym::SetDataRate() @@ -196,13 +209,41 @@ { return KErrNone; } - return SetProperty(KSensrvPropIdDataRate, ESensrvIntProperty,ESensrvArrayPropertyInfo, - availableDataRates.indexOf(qrange(sensor()->dataRate(),sensor()->dataRate()))); + TInt err = KErrNone; + TSensrvPropertyType type = propertyType(KSensrvPropIdDataRate, err); + if(err != KErrNone) + { + return err; + } + if(type == ESensrvIntProperty) + { + return SetProperty(KSensrvPropIdDataRate, ESensrvIntProperty, ESensrvArrayPropertyInfo, + availableDataRates.indexOf(qrange(sensor()->dataRate(),sensor()->dataRate()))); + } + else if(type == ESensrvRealProperty) + { + return SetProperty(KSensrvPropIdDataRate, ESensrvRealProperty, ESensrvArrayPropertyInfo, + availableDataRates.indexOf(qrange(sensor()->dataRate(),sensor()->dataRate()))); + } } else { - // Uses range value - return SetProperty(KSensrvPropIdDataRate, ESensrvIntProperty, ESensrvSingleProperty, sensor()->dataRate()); + TInt err = KErrNone; + TSensrvPropertyType type = propertyType(KSensrvPropIdDataRate, err); + if(err != KErrNone) + { + return err; + } + if(type == ESensrvIntProperty) + { + // Uses range value + return SetProperty(KSensrvPropIdDataRate, ESensrvIntProperty, ESensrvSingleProperty, sensor()->dataRate()); + } + else if(type == ESensrvRealProperty) + { + // Uses range value + return SetProperty(KSensrvPropIdDataRate, ESensrvIntProperty, ESensrvSingleProperty, sensor()->dataRate()); + } } } // No data rates available @@ -211,7 +252,7 @@ void CSensorBackendSym::SetProperties() { - if(sensor()) + if(sensor()->outputRange() != -1) { //Set measurement range TInt err = SetMeasurementRange(); @@ -219,8 +260,11 @@ { sensorError(err); } + } + if(sensor()->dataRate() != 0) + { //Set data rate - err = SetDataRate(); + TInt err = SetDataRate(); if(err != KErrNone) { sensorError(err); @@ -310,39 +354,58 @@ void CSensorBackendSym::GetDataRate() { - RSensrvPropertyList list; - TRAPD(err, iBackendData.iSensorChannel->GetAllPropertiesL(KSensrvPropIdDataRate, list)); + TSensrvProperty datarate_prop; + TInt err; + TRAP(err, iBackendData.iSensorChannel->GetPropertyL(KSensrvPropIdDataRate, KSensrvItemIndexNone, datarate_prop)); if(err == KErrNone) { - //if list has only one item then it is range of values and not descrete values, agreed with DS team - if(list.Count() == 1) - { - TInt min, max, value; - list[0].GetMinValue(min); - list[0].GetMaxValue(max); + if(datarate_prop.GetArrayIndex() == ESensrvSingleProperty) + { + TReal min, max, value; + if(datarate_prop.PropertyType() == ESensrvIntProperty) + { + TInt intMin, intMax, intValue; + datarate_prop.GetMinValue(intMin); + datarate_prop.GetMaxValue(intMax); + datarate_prop.GetValue(intValue); + min = intMin; + max = intMax; + value = intValue; + } + else if(datarate_prop.PropertyType() == ESensrvRealProperty) + { + datarate_prop.GetMinValue(min); + datarate_prop.GetMaxValue(max); + datarate_prop.GetValue(value); + } //Set datarate as range addDataRate(min, max); - list[0].GetValue(value); - //Set current datarate as default - sensor()->setDataRate(value); - } + } //if list has more than one item, data rate will be having descrete values, agreed with DS team - else + else if(datarate_prop.GetArrayIndex() == ESensrvArrayPropertyInfo) { - TInt datarate, index; - for(int i=0; iGetPropertyL(KSensrvPropIdDataRate, KSensrvItemIndexNone, i, datarate_prop)); + if(err == KErrNone) { - //If array index is ESensrvArrayPropertyInfo, getting the value to get current datarate - list[i].GetValue(index); - list[index].GetValue(datarate); - //Setting current datarate as default - sensor()->setDataRate(datarate); - continue; - } - list[i].GetValue(datarate); - addDataRate(datarate, datarate); + if(datarate_prop.PropertyType() == ESensrvIntProperty) + { + TInt intDatarate; + datarate_prop.GetValue(intDatarate); + datarate = intDatarate; + } + else if(datarate_prop.PropertyType() == ESensrvRealProperty) + { + datarate_prop.GetValue(datarate); + } + addDataRate(datarate, datarate); + } } } } @@ -362,73 +425,134 @@ */ TReal accuracy = 0; RSensrvPropertyList accuracyList; - RSensrvPropertyList list; TInt err; TRAP(err, iBackendData.iSensorChannel->GetAllPropertiesL(KSensrvPropIdChannelAccuracy, accuracyList)); if(err == KErrNone) { + // If only one accuracy value present set value to accuracy if(accuracyList.Count() == 1) { - accuracyList[0].GetValue(accuracy); + if(accuracyList[0].PropertyType() == ESensrvIntProperty) + { + TInt intAccuracy; + accuracyList[0].GetValue(intAccuracy); + accuracy = intAccuracy; + } + else if(accuracyList[0].PropertyType() == ESensrvRealProperty) + { + accuracyList[0].GetValue(accuracy); + } } + // If more than one accuracy values present set accuracy to invalid else { accuracy = KAccuracyInvalid; } } - - //measurement minimum & maximum - list.Reset(); - TRAP(err, iBackendData.iSensorChannel->GetAllPropertiesL(KSensrvPropIdMeasureRange, list)); + + //Scale + TSensrvProperty scale_prop; + TReal scale=1; + TRAP(err, iBackendData.iSensorChannel->GetPropertyL(KSensrvPropIdChannelScale, KSensrvItemIndexNone, scale_prop)); if(err == KErrNone) - { - for(int i=0; iGetPropertyL(KSensrvPropIdMeasureRange, KSensrvItemIndexNone, measurerange_prop)); + if(err == KErrNone) + { + if(measurerange_prop.GetArrayIndex() == ESensrvSingleProperty) + { + TReal measureMin, measureMax, value; + if(measurerange_prop.PropertyType() == ESensrvIntProperty) { - continue; + TInt intMin, intMax; + measurerange_prop.GetMinValue(intMin); + measurerange_prop.GetMaxValue(intMax); + measureMin = intMin; + measureMax = intMax; } - if(list[i].PropertyType() == ESensrvIntProperty ) + else if(measurerange_prop.PropertyType() == ESensrvRealProperty) { - TInt min, max; - list[i].GetMinValue(min); - list[i].GetMaxValue(max); - if(accuracy != KAccuracyInvalid) + measurerange_prop.GetMinValue(measureMin); + measurerange_prop.GetMaxValue(measureMax); + } + //Set output as range + addOutputRange(measureMin*scale, measureMax*scale, accuracy); + } + //if list has more than one item, data rate will be having descrete values, agreed with DS team + else if(measurerange_prop.GetArrayIndex() == ESensrvArrayPropertyInfo) + { + TReal measureMin, measureMax; + TInt min, max, index; + if(measurerange_prop.PropertyType() == ESensrvIntProperty) + { + measurerange_prop.GetMinValue(min); + measurerange_prop.GetMaxValue(max); + measurerange_prop.GetValue(index); + } + else if(measurerange_prop.PropertyType() == ESensrvRealProperty) + { + TReal realMin, realMax, realValue; + measurerange_prop.GetMinValue(realMin); + measurerange_prop.GetMaxValue(realMax); + measurerange_prop.GetValue(realValue); + min = realMin; + max = realMax; + index = realValue; + } + for(int i=min; i<=max; i++) + { + TRAP(err, iBackendData.iSensorChannel->GetPropertyL(KSensrvPropIdMeasureRange, KSensrvItemIndexNone, i, measurerange_prop)); + if(err == KErrNone) { - addOutputRange(min, max, accuracy); - } - else - { - if(accuracyList.Count() > i) + if(measurerange_prop.PropertyType() == ESensrvIntProperty) + { + TInt intMeasureMin, intMeasureMax; + measurerange_prop.GetMinValue(intMeasureMin); + measurerange_prop.GetMaxValue(intMeasureMax); + measureMin = intMeasureMin; + measureMax = intMeasureMax; + } + else if(measurerange_prop.PropertyType() == ESensrvRealProperty) { - accuracyList[i].GetValue(accuracy); - addOutputRange(min, max, accuracy); + measurerange_prop.GetMinValue(measureMin); + measurerange_prop.GetMaxValue(measureMax); } + // If only one accuracy value is present set same accuracy for all + if(accuracy != KAccuracyInvalid) + { + addOutputRange(measureMin*scale, measureMax*scale, accuracy); + } + // If more than one accuracy values are there then map them linearly else { - addOutputRange(min, max, KAccuracyInvalid); - } - } - } - else if(list[i].PropertyType() == ESensrvRealProperty ) - { - TReal min, max; - list[i].GetMinValue(min); - list[i].GetMaxValue(max); - if(accuracy != KAccuracyInvalid) - { - addOutputRange(min, max, accuracy); - } - else - { - if(accuracyList.Count() > i) - { - accuracyList[i].GetValue(accuracy); - addOutputRange(min, max, accuracy); - } - else - { - addOutputRange(min, max, KAccuracyInvalid); + if(accuracyList.Count() > (i - min)) + { + accuracyList[i].GetValue(accuracy); + addOutputRange(measureMin*scale, measureMax*scale, accuracy); + } + else + { + // If less accuracy values are present than measurement ranges then + // set invalid accuracy for rest of measument ranges + addOutputRange(measureMin*scale, measureMax*scale, KAccuracyInvalid); + } } } }