|
1 /* |
|
2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Accelerometer sensor implementation |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INTERNAL INCLUDES |
|
20 #include "cacceleratorsensor.h" |
|
21 #include "csensorproperties.h" |
|
22 #include "sensorlistener.h" |
|
23 #include "sensornativeconstants.h" |
|
24 #include "logger.h" |
|
25 |
|
26 #include <e32debug.h> |
|
27 |
|
28 #include <sensrvtypes.h> |
|
29 |
|
30 |
|
31 _LIT(KSeparator, "#"); |
|
32 _LIT(KDescription, "description="); |
|
33 _LIT(KModel, "#model=Nokia#"); |
|
34 _LIT(KConnectionTypeNotSpecified, "connectiontype=0"); |
|
35 _LIT(KContextTypeUser, "user#"); |
|
36 _LIT(KDataTypeDouble, "1#"); |
|
37 _LIT(KValueScale, "0#"); |
|
38 |
|
39 _LIT(KMeasureRangeCount, "1#"); |
|
40 _LIT(KChannelTerminator, "#@ch_end#"); |
|
41 |
|
42 const TInt KChannels = 3; |
|
43 |
|
44 const TInt KDataListening = 1; |
|
45 const TInt KConditionListening = 2; |
|
46 const TInt KGetDataListening = 4; |
|
47 const TReal KStandardGravityValue = 9.812865328; // in m/s^2 |
|
48 |
|
49 CAcceleratorSensor::CAcceleratorSensor(const TSensrvChannelInfo& aChannelInfo) : |
|
50 iChannelInfo(aChannelInfo), iStartTime(KErrNotFound) |
|
51 { |
|
52 JELOG2(ESensor); |
|
53 // No implementation needed |
|
54 } |
|
55 |
|
56 CAcceleratorSensor::~CAcceleratorSensor() |
|
57 { |
|
58 JELOG2(ESensor); |
|
59 if (iChannel) |
|
60 { |
|
61 iChannel->StopDataListening(); |
|
62 iChannel->CloseChannel(); |
|
63 } |
|
64 delete iChannel; |
|
65 } |
|
66 |
|
67 CAcceleratorSensor* CAcceleratorSensor::NewLC(const TSensrvChannelInfo& aChannelInfo) |
|
68 { |
|
69 JELOG2(ESensor); |
|
70 CAcceleratorSensor* self = new(ELeave) CAcceleratorSensor(aChannelInfo); |
|
71 CleanupStack::PushL(self); |
|
72 self->ConstructL(); |
|
73 return self; |
|
74 } |
|
75 |
|
76 CAcceleratorSensor* CAcceleratorSensor::NewL(const TSensrvChannelInfo& aChannelInfo) |
|
77 { |
|
78 JELOG2(ESensor); |
|
79 CAcceleratorSensor* self = CAcceleratorSensor::NewLC(aChannelInfo); |
|
80 CleanupStack::Pop(); // self; |
|
81 return self; |
|
82 } |
|
83 |
|
84 void CAcceleratorSensor::ConstructL() |
|
85 { |
|
86 JELOG2(ESensor); |
|
87 CSensorBase::ConstructL(); |
|
88 iChannel = CSensrvChannel::NewL(iChannelInfo); |
|
89 } |
|
90 |
|
91 void CAcceleratorSensor::GetProperty(const RSensrvPropertyList aList, |
|
92 const TSensrvPropertyId aPropertyId, |
|
93 const TInt aItemIndex, |
|
94 TSensrvProperty& aProperty) |
|
95 { |
|
96 JELOG2(ESensor); |
|
97 TInt propCount = aList.Count(); |
|
98 for (int i = 0; i < propCount; i++) |
|
99 { |
|
100 aProperty = aList[i]; |
|
101 if (aProperty.GetPropertyId() == aPropertyId && |
|
102 aProperty.PropertyItemIndex() == aItemIndex) |
|
103 { |
|
104 return; |
|
105 } |
|
106 } |
|
107 TSensrvProperty prop; |
|
108 aProperty = prop; |
|
109 } |
|
110 // newcode for querying for the property using arrayindex also |
|
111 void CAcceleratorSensor::GetProperty(const RSensrvPropertyList aList, |
|
112 const TSensrvPropertyId aPropertyId, |
|
113 const TInt aItemIndex, |
|
114 const TInt aArrayIndex, |
|
115 TSensrvProperty& aProperty) |
|
116 { |
|
117 JELOG2(ESensor); |
|
118 TInt propCount = aList.Count(); |
|
119 for (int i = 0; i < propCount; i++) |
|
120 { |
|
121 aProperty = aList[i]; |
|
122 if (aProperty.GetPropertyId() == aPropertyId && |
|
123 aProperty.PropertyItemIndex() == aItemIndex&& |
|
124 aProperty.GetArrayIndex()==aArrayIndex) |
|
125 |
|
126 { |
|
127 return; |
|
128 } |
|
129 } |
|
130 TSensrvProperty prop; |
|
131 aProperty = prop; |
|
132 } |
|
133 |
|
134 HBufC* CAcceleratorSensor::CreateDescriptionLC() |
|
135 { |
|
136 JELOG2(ESensor); |
|
137 HBufC* description = HBufC::NewLC(KMaxSensorDescriptionLength); |
|
138 TPtr desPtr = description->Des(); |
|
139 |
|
140 CSensrvChannel* channel = CSensrvChannel::NewL(iChannelInfo); |
|
141 CleanupStack::PushL(channel); |
|
142 channel->OpenChannelL(); |
|
143 |
|
144 RSensrvPropertyList propList; |
|
145 CleanupClosePushL(propList); |
|
146 channel->GetAllPropertiesL(propList); |
|
147 channel->CloseChannel(); |
|
148 |
|
149 // Quantity |
|
150 desPtr.Append(SensorProperties::GetPropertyString( |
|
151 KQuantity, iChannelInfo.iQuantity)); |
|
152 desPtr.Append(KSeparator); |
|
153 |
|
154 // ContextType |
|
155 desPtr.Append(KContextTypeUser); |
|
156 |
|
157 // Location |
|
158 TBuf<KSensrvLocationLength> location; |
|
159 location.Copy(iChannelInfo.iLocation); |
|
160 desPtr.Append(location); |
|
161 desPtr.Append(KSeparator); |
|
162 |
|
163 // Vendor |
|
164 TBuf<KSensrvVendorIdLength> vendor; |
|
165 vendor.Copy(iChannelInfo.iVendorId); |
|
166 desPtr.Append(vendor); |
|
167 desPtr.Append(KSeparator); |
|
168 |
|
169 // Description and Model |
|
170 desPtr.Append(KDescription); |
|
171 |
|
172 desPtr.Append(SensorProperties::GetPropertyString(KSensorDescription, |
|
173 SensorDescriptionId())); |
|
174 |
|
175 Model(&desPtr); |
|
176 |
|
177 TSensrvProperty property; |
|
178 TInt intValue(0); |
|
179 |
|
180 // Connection type |
|
181 GetProperty(propList, KSensrvSensorConnectionType, KSensrvItemIndexNone, |
|
182 property); |
|
183 if (property.PropertyType() == ESensrvIntProperty) |
|
184 { |
|
185 property.GetValue(intValue); |
|
186 desPtr.Append(SensorProperties::GetPropertyString( |
|
187 KConnectionType, intValue)); |
|
188 } |
|
189 else |
|
190 { |
|
191 desPtr.Append(KConnectionTypeNotSpecified); |
|
192 } |
|
193 desPtr.Append(KSeparator); |
|
194 |
|
195 // Availability |
|
196 GetProperty(propList, KSensrvPropIdAvailability, KSensrvItemIndexNone, |
|
197 property); |
|
198 if (property.PropertyType() == ESensrvIntProperty) |
|
199 { |
|
200 property.GetValue(intValue); |
|
201 desPtr.AppendNum(intValue); |
|
202 } |
|
203 else |
|
204 { |
|
205 desPtr.AppendNum(0); |
|
206 } |
|
207 desPtr.Append(KSeparator); |
|
208 |
|
209 //number of channels |
|
210 desPtr.AppendNum(KChannels); |
|
211 desPtr.Append(KSeparator); |
|
212 DescriptorAppendChannel(&desPtr, propList, |
|
213 TSensrvAccelerometerAxisData::EAxisX); |
|
214 DescriptorAppendChannel(&desPtr, propList, |
|
215 TSensrvAccelerometerAxisData::EAxisY); |
|
216 DescriptorAppendChannel(&desPtr, propList, |
|
217 TSensrvAccelerometerAxisData::EAxisZ); |
|
218 |
|
219 CleanupStack::PopAndDestroy(); |
|
220 CleanupStack::PopAndDestroy(channel); |
|
221 return description; |
|
222 } |
|
223 |
|
224 void CAcceleratorSensor::DescriptorAppendChannel(TPtr* aPtr, |
|
225 const RSensrvPropertyList aList, |
|
226 TInt aItemIndex) |
|
227 { |
|
228 JELOG2(ESensor); |
|
229 TRealFormat realFormat; |
|
230 realFormat.iTriLen = 0; |
|
231 realFormat.iPoint = '.'; |
|
232 TSensrvProperty property; |
|
233 TReal realValue(0); |
|
234 |
|
235 // name |
|
236 aPtr->Append(SensorProperties::GetPropertyString( |
|
237 KAcceleratorChannelName, aItemIndex)); |
|
238 aPtr->Append(KSeparator); |
|
239 |
|
240 // accuracy |
|
241 GetProperty(aList, KSensrvPropIdChannelAccuracy, |
|
242 KSensrvItemIndexNone, property); |
|
243 if (property.PropertyType() == ESensrvRealProperty) |
|
244 { |
|
245 property.GetValue(realValue); |
|
246 aPtr->AppendNum(realValue / 100, realFormat); |
|
247 } |
|
248 // the checking for int property was introduced for 9.2 |
|
249 else if (property.PropertyType() == ESensrvIntProperty) |
|
250 { |
|
251 TInt intValue(0); |
|
252 property.GetValue(intValue); |
|
253 aPtr->AppendNum(intValue, realFormat); |
|
254 } |
|
255 else |
|
256 { |
|
257 aPtr->AppendNum(-1); |
|
258 } |
|
259 |
|
260 aPtr->Append(KSeparator); |
|
261 |
|
262 // data type |
|
263 DataType(aPtr); |
|
264 |
|
265 // scale |
|
266 aPtr->Append(KValueScale); |
|
267 |
|
268 // data unit |
|
269 DataUnit(aList, aPtr); |
|
270 aPtr->Append(KSeparator); |
|
271 |
|
272 // range count and range |
|
273 DataRange(aList, aPtr); |
|
274 aPtr->Append(KChannelTerminator); |
|
275 } |
|
276 |
|
277 |
|
278 CSensorBase* CAcceleratorSensor::DuplicateL() |
|
279 { |
|
280 JELOG2(ESensor); |
|
281 return NewL(iChannelInfo); |
|
282 } |
|
283 |
|
284 TReal CAcceleratorSensor::InterpretValue(TReal aValue) |
|
285 { |
|
286 JELOG2(ESensor); |
|
287 return iScaleFactor * aValue; |
|
288 } |
|
289 |
|
290 int CAcceleratorSensor::OpenChannel(SensorListener *aListener) |
|
291 { |
|
292 JELOG2(ESensor); |
|
293 iSensorListener = aListener; |
|
294 TRAPD(err, OpenChannelL();); |
|
295 return err==KErrNotFound? KErrNone : err; |
|
296 } |
|
297 |
|
298 void CAcceleratorSensor::OpenChannelL() |
|
299 { |
|
300 JELOG2(ESensor); |
|
301 LOG(ESensor,EInfo,"Creating Open Channel"); |
|
302 iChannel->OpenChannelL(); |
|
303 LOG(ESensor,EInfo,"Channel Created"); |
|
304 // Check if the sensor data is scaled and set the scale factor |
|
305 iScaleFactor = 1; |
|
306 TInt format(ESensrvChannelDataFormatAbsolute); |
|
307 TSensrvProperty property; |
|
308 TRAPD(err1,iChannel->GetPropertyL(KSensrvPropIdChannelDataFormat, KSensrvItemIndexNone, |
|
309 property);); |
|
310 LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::GetPropertyL() One = %d",err1); |
|
311 if (property.PropertyType() == ESensrvIntProperty) |
|
312 { |
|
313 property.GetValue(format); |
|
314 LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::GetValue()::KSensrvPropIdChannelDataFormat format = %d",format); |
|
315 } |
|
316 else |
|
317 { |
|
318 LOG(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::KSensrvPropIdChannelDataFormat::Propety Type must be Integer"); |
|
319 //KSensrvPropIdChannelDataFormat::Propety Type must be Integer |
|
320 __ASSERT_DEBUG(EFalse,User::Invariant()); |
|
321 } |
|
322 |
|
323 if (format == ESensrvChannelDataFormatScaled) |
|
324 { |
|
325 LOG(ESensor,EInfo," format is equal to ESensrvChannelDataFormatScaled"); |
|
326 // Scaled value maximum |
|
327 TSensrvProperty property_scaled; |
|
328 TInt maxScaled(0); |
|
329 TRAPD(err2,iChannel->GetPropertyL(KSensrvPropIdScaledRange, KSensrvItemIndexNone, |
|
330 property_scaled);); |
|
331 LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::GetPropertyL() Two = %d",err2); |
|
332 |
|
333 if (property_scaled.GetArrayIndex() == ESensrvArrayPropertyInfo) |
|
334 { |
|
335 LOG(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::If"); |
|
336 //for 2G Accelerometer Sensor index value is 0. |
|
337 TInt rangeIndex(0); |
|
338 TRAPD(err3,iChannel->GetPropertyL(KSensrvPropIdScaledRange, KSensrvItemIndexNone, |
|
339 rangeIndex, property_scaled);); |
|
340 LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::GetPropertyL() Three = %d",err3); |
|
341 |
|
342 property_scaled.GetMaxValue(maxScaled); |
|
343 |
|
344 LOG1(ESensor,EInfo,"property_scaled::maxValue = %d",maxScaled); |
|
345 } |
|
346 else |
|
347 { |
|
348 LOG(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::else"); |
|
349 property_scaled.GetMaxValue(maxScaled); |
|
350 LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::maxScaled = %d",maxScaled); |
|
351 } |
|
352 // MeasureRange can be an array property |
|
353 TReal maxMeasure; |
|
354 TSensrvProperty property_Measured; |
|
355 TRAPD(err4,iChannel->GetPropertyL(KSensrvPropIdMeasureRange, KSensrvItemIndexNone, |
|
356 property_Measured);); |
|
357 LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::GetPropertyL() Four = %d",err4); |
|
358 |
|
359 if (err4 == KErrNone) |
|
360 { |
|
361 TInt arrayIndex = property_Measured.GetArrayIndex(); |
|
362 LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::KSensrvPropIdMeasureRange::arrayIndex = %d",arrayIndex); |
|
363 |
|
364 if (property_Measured.GetArrayIndex() == ESensrvArrayPropertyInfo) |
|
365 { |
|
366 LOG(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::If"); |
|
367 |
|
368 TInt index2g = 0; |
|
369 LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::Getting RangeIndex = %f",index2g); |
|
370 //We need to TypeCast variable rangeIndex to TInt for |
|
371 TRAPD(err5,iChannel->GetPropertyL(KSensrvPropIdMeasureRange, KSensrvItemIndexNone, |
|
372 index2g, property_Measured);); |
|
373 LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::GetPropertyL() Five = %d",err5); |
|
374 property_Measured.GetMaxValue(maxMeasure); |
|
375 } |
|
376 else |
|
377 { |
|
378 LOG(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::else"); |
|
379 property_Measured.GetMaxValue(maxMeasure); |
|
380 } |
|
381 |
|
382 } |
|
383 iScaleFactor = maxMeasure / maxScaled ; |
|
384 LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::iScaleFactor = %f",iScaleFactor); |
|
385 } |
|
386 // this checking was introduced for 9.2 |
|
387 else if (format == ESensrvChannelDataFormatAbsolute) |
|
388 { |
|
389 iScaleFactor = 2 * KStandardGravityValue / 127; |
|
390 // no need to calculate the scale factor |
|
391 } |
|
392 } |
|
393 void CAcceleratorSensor::CloseChannelL() |
|
394 { |
|
395 JELOG2(ESensor); |
|
396 TInt err = iChannel->CloseChannel(); |
|
397 } |
|
398 |
|
399 void CAcceleratorSensor::StartDataListeningL() |
|
400 { |
|
401 JELOG2(ESensor); |
|
402 if (iStartTime == KErrNotFound) |
|
403 { |
|
404 iStartTime.UniversalTime(); |
|
405 } |
|
406 iChannelXData = iData[ 0 ]; |
|
407 iChannelYData = iData[ 1 ]; |
|
408 iChannelZData = iData[ 2 ]; |
|
409 if (!iListeningType) |
|
410 { |
|
411 iChannel->StartDataListeningL(this, iBufferSize, iBufferSize, |
|
412 iBufferingPeriod/1000); |
|
413 } |
|
414 if (iIsOneShot) |
|
415 { |
|
416 iListeningType = iListeningType | KGetDataListening; |
|
417 } |
|
418 else |
|
419 { |
|
420 iListeningType = iListeningType | KDataListening; |
|
421 } |
|
422 } |
|
423 |
|
424 |
|
425 void CAcceleratorSensor::CancelDataListeningL() |
|
426 { |
|
427 JELOG2(ESensor); |
|
428 if (iListeningType & KDataListening) |
|
429 { |
|
430 iListeningType = iListeningType ^ KDataListening; |
|
431 } |
|
432 if (!iListeningType) |
|
433 { |
|
434 User::LeaveIfError(iChannel->StopDataListening()); |
|
435 } |
|
436 } |
|
437 |
|
438 |
|
439 void CAcceleratorSensor::StopConditionListeningL() |
|
440 { |
|
441 JELOG2(ESensor); |
|
442 if (iListeningType & KConditionListening) |
|
443 { |
|
444 iListeningType = iListeningType ^ KConditionListening; |
|
445 User::LeaveIfError(iChannel->StopDataListening()); |
|
446 if (iListeningType) |
|
447 { |
|
448 iChannel->StartDataListeningL(this, iBufferSize, iBufferSize, |
|
449 iBufferingPeriod/1000); |
|
450 } |
|
451 } |
|
452 } |
|
453 |
|
454 |
|
455 void CAcceleratorSensor::StartConditionListeningL() |
|
456 { |
|
457 JELOG2(ESensor); |
|
458 if (iListeningType & (KDataListening | KGetDataListening)) |
|
459 { |
|
460 iChannel->StopDataListening(); |
|
461 } |
|
462 if (!(iListeningType & KConditionListening)) |
|
463 { |
|
464 |
|
465 // changing -1 to 0 for buffering period since -1 throws KErrArgument in 9.2 |
|
466 iChannel->StartDataListeningL(this, 1, 1 /* listen every value*/, 0); |
|
467 } |
|
468 iListeningType = iListeningType | KConditionListening; |
|
469 } |
|
470 |
|
471 void CAcceleratorSensor::DataReceived(CSensrvChannel& aChannel, |
|
472 TInt aCount, |
|
473 TInt aDataLost) |
|
474 { |
|
475 JELOG2(ESensor); |
|
476 TSensrvAccelerometerAxisData data; |
|
477 TPckgBuf<TSensrvAccelerometerAxisData> dataBuf; |
|
478 TBool dataFetched = EFalse; |
|
479 TTime currentTime; |
|
480 currentTime.UniversalTime(); |
|
481 // no need for data preparation if only listening conditions |
|
482 if (iListeningType & (KDataListening | KGetDataListening)) |
|
483 { |
|
484 // Do not go over buffer count |
|
485 if (iChannelXData->iNumOfValues + aCount > iBufferSize) |
|
486 { |
|
487 aCount = iBufferSize - iChannelXData->iNumOfValues; |
|
488 } |
|
489 |
|
490 // Prepare own data |
|
491 for (TInt i = iChannelXData->iNumOfValues; i < aCount + iChannelXData->iNumOfValues; i++) |
|
492 { |
|
493 aChannel.GetData(dataBuf); |
|
494 data = dataBuf(); |
|
495 dataFetched = ETrue; |
|
496 CopyData(data, i); |
|
497 // add timestamps, if needed |
|
498 if (iChannelXData->iTimeStampsIncluded) |
|
499 { |
|
500 // Sensrv api returns timestams in localtime java requires UTC |
|
501 iChannelXData->iTimeStamps[ i ] = TimeStamp(currentTime); |
|
502 iChannelYData->iTimeStamps[ i ] = TimeStamp(currentTime); |
|
503 iChannelZData->iTimeStamps[ i ] = TimeStamp(currentTime); |
|
504 } |
|
505 } |
|
506 iChannelXData->iNumOfValues += aCount; |
|
507 iChannelYData->iNumOfValues += aCount; |
|
508 iChannelZData->iNumOfValues += aCount; |
|
509 |
|
510 if (iChannelXData->iNumOfValues == iBufferSize || iBufferingPeriod > 0 |
|
511 || (iListeningType & KConditionListening |
|
512 && currentTime.MicroSecondsFrom(iStartTime) |
|
513 >= iBufferingPeriod)) |
|
514 { |
|
515 if (iListeningType & KGetDataListening) |
|
516 { |
|
517 iListeningType = iListeningType ^ KGetDataListening; |
|
518 if (!(iListeningType & KConditionListening)) |
|
519 { |
|
520 iChannel->StopDataListening(); |
|
521 } |
|
522 } |
|
523 // callback |
|
524 iSensorListener->DataReceived(iData, aDataLost > 0); |
|
525 iChannelXData->iNumOfValues = 0; |
|
526 iChannelYData->iNumOfValues = 0; |
|
527 iChannelZData->iNumOfValues = 0; |
|
528 iStartTime = KErrNotFound; |
|
529 } |
|
530 } |
|
531 // evaluate conditions if condition listening is on |
|
532 if (iListeningType & KConditionListening) |
|
533 { |
|
534 // get data if not done already by datalistening routine |
|
535 if (!dataFetched) |
|
536 { |
|
537 aChannel.GetData(dataBuf); |
|
538 data = dataBuf(); |
|
539 } |
|
540 EvaluateConditions(data.iAxisX, 0); |
|
541 EvaluateConditions(data.iAxisY, 1); |
|
542 EvaluateConditions(data.iAxisZ, 2); |
|
543 if (!iJavaConditionEval && iConditions.Count() == 0) |
|
544 { |
|
545 TRAP_IGNORE(StopConditionListeningL()); |
|
546 } |
|
547 } |
|
548 } |
|
549 |
|
550 void CAcceleratorSensor::DataError(CSensrvChannel& /*aChannel*/, |
|
551 TSensrvErrorSeverity /*aError*/) |
|
552 { |
|
553 JELOG2(ESensor); |
|
554 // Currently we don't care wether error is minor or fatal |
|
555 if (!(iListeningType ^ KGetDataListening)) |
|
556 { |
|
557 iChannel->StopDataListening(); |
|
558 } |
|
559 TSensrvAccelerometerAxisData data; |
|
560 for (TInt i = iChannelXData->iNumOfValues; i < iBufferSize; i++) |
|
561 { |
|
562 data.iAxisX = 0; |
|
563 data.iAxisY = 0; |
|
564 data.iAxisZ = 0; |
|
565 CopyData(data, i); |
|
566 if (iValiditiesIncluded) |
|
567 { |
|
568 iChannelXData->iValidities[i] = EFalse; |
|
569 iChannelYData->iValidities[i] = EFalse; |
|
570 iChannelZData->iValidities[i] = EFalse; |
|
571 } |
|
572 } |
|
573 iSensorListener->DataReceived(iData, ETrue); |
|
574 iChannelXData->iNumOfValues = 0; |
|
575 iChannelYData->iNumOfValues = 0; |
|
576 iChannelZData->iNumOfValues = 0; |
|
577 iStartTime = KErrNotFound; |
|
578 } |
|
579 |
|
580 void CAcceleratorSensor::GetDataListenerInterfaceL(TUid /*aInterfaceUid*/, |
|
581 TAny*& aInterface) |
|
582 { |
|
583 JELOG2(ESensor); |
|
584 aInterface = NULL; |
|
585 // For future extension, implement when needed |
|
586 } |
|
587 |
|
588 void CAcceleratorSensor::Model(TPtr* aPtr) |
|
589 { |
|
590 JELOG2(ESensor); |
|
591 aPtr->Append(KModel); |
|
592 } |
|
593 |
|
594 void CAcceleratorSensor::DataType(TPtr* aPtr) |
|
595 { |
|
596 JELOG2(ESensor); |
|
597 aPtr->Append(KDataTypeDouble); |
|
598 } |
|
599 |
|
600 void CAcceleratorSensor::DataUnit(const RSensrvPropertyList aList, TPtr* aPtr) |
|
601 { |
|
602 JELOG2(ESensor); |
|
603 TSensrvProperty property; |
|
604 TInt intValue(0); |
|
605 GetProperty(aList, KSensrvPropIdChannelUnit, KSensrvItemIndexNone, property); |
|
606 if (property.PropertyType() == ESensrvIntProperty) |
|
607 { |
|
608 property.GetValue(intValue); |
|
609 aPtr->Append(SensorProperties::GetPropertyString(KChannelUnit, intValue)); |
|
610 } |
|
611 else |
|
612 { |
|
613 aPtr->Append(SensorProperties::GetPropertyString(KChannelUnit, |
|
614 ESensrvChannelUnitNotDefined)); |
|
615 } |
|
616 } |
|
617 |
|
618 void CAcceleratorSensor::DataRange(const RSensrvPropertyList aList, |
|
619 TPtr* aPtr) |
|
620 { |
|
621 JELOG2(ESensor); |
|
622 TRealFormat realFormat; |
|
623 realFormat.iTriLen = 0; |
|
624 realFormat.iPoint = '.'; |
|
625 realFormat.iPlaces = 2; |
|
626 TSensrvProperty property; |
|
627 TReal realValue(0); |
|
628 GetProperty(aList, KSensrvPropIdMeasureRange,KSensrvItemIndexNone, property); |
|
629 |
|
630 // the extra checking for arraypropertyindex was introduced for 9.2 driver changes |
|
631 // for 5.0 and 9.2 both the platforms first and second IF blocks should be executed |
|
632 if ((property.GetArrayIndex() == ESensrvArrayPropertyInfo)&& |
|
633 (property.PropertyType() == ESensrvRealProperty)) |
|
634 { |
|
635 LOG(ESensor,EInfo,"CAcceleratorSensor::DataRange()::KSensrvPropIdMeasureRange is ESensrvArrayPropertyInfo and ESensrvRealProperty::first IF"); |
|
636 // Read index |
|
637 TInt index2g = 0; |
|
638 // Read actual property data from array |
|
639 GetProperty(aList, KSensrvPropIdMeasureRange, |
|
640 KSensrvItemIndexNone, index2g, property); |
|
641 LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::DataRange() index = %f",index); |
|
642 } |
|
643 |
|
644 if (property.PropertyType() == ESensrvRealProperty) |
|
645 { |
|
646 LOG(ESensor,EInfo,"CAcceleratorSensor::DataRange()::KSensrvPropIdMeasureRange ESensrvRealProperty::second IF"); |
|
647 aPtr->Append(KMeasureRangeCount); |
|
648 property.GetMinValue(realValue); // min |
|
649 LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::DataRange() min = %f",realValue); |
|
650 aPtr->AppendNum(realValue, realFormat); |
|
651 aPtr->Append(KSeparator); |
|
652 property.GetMaxValue(realValue); // max |
|
653 LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::DataRange() max = %f",realValue); |
|
654 aPtr->AppendNum(realValue, realFormat); |
|
655 aPtr->Append(KSeparator); |
|
656 property.GetValue(realValue); // resolution |
|
657 //resolution is minimum difference between the data values |
|
658 TReal resolution = realValue /127 ; |
|
659 LOG1(ESensor,EInfo,"CAcceleratorSensor::OpenChannelL()::DataRange() val = %f",resolution); |
|
660 aPtr->AppendNum(resolution, realFormat); |
|
661 } |
|
662 // the extra checking for ESensrvIntProperty was introduced for 9.2 driver changes |
|
663 else if (property.PropertyType() == ESensrvIntProperty) |
|
664 { |
|
665 //This condition is an extra check and not supposed to be entered. |
|
666 LOG(ESensor,EInfo,"CAcceleratorSensor::DataRange()::KSensrvPropIdMeasureRange ESensrvIntProperty::ELSE IF"); |
|
667 TReal min,max,resolution; |
|
668 // Read TInt values |
|
669 TInt minInt,maxInt,resolutionInt; |
|
670 property.GetMinValue(minInt); |
|
671 property.GetMaxValue(maxInt); |
|
672 property.GetValue(resolutionInt); |
|
673 |
|
674 // Convert integers to TReal |
|
675 min=-((resolutionInt * KStandardGravityValue)/1000); |
|
676 max=((resolutionInt * KStandardGravityValue)/1000); |
|
677 // Resolution is minimum value difference which can be caught. |
|
678 // for ex. in case of raw data(-128 -to- 127) the resolution is 1 |
|
679 resolution=(resolutionInt* KStandardGravityValue)/(1000 * 127); |
|
680 aPtr->Append(KMeasureRangeCount); |
|
681 aPtr->AppendNum(min, realFormat); |
|
682 aPtr->Append(KSeparator); |
|
683 aPtr->AppendNum(max, realFormat); |
|
684 aPtr->Append(KSeparator); |
|
685 aPtr->AppendNum(resolution, realFormat); |
|
686 |
|
687 } |
|
688 else |
|
689 { |
|
690 aPtr->AppendNum(0); |
|
691 } |
|
692 } |
|
693 void CAcceleratorSensor::CopyData(const TSensrvAccelerometerAxisData aData, TInt aIndex) |
|
694 { |
|
695 JELOG2(ESensor); |
|
696 iChannelXData->iDoubleValues[ aIndex ] = aData.iAxisX * iScaleFactor; |
|
697 iChannelYData->iDoubleValues[ aIndex ] = aData.iAxisY * iScaleFactor; |
|
698 iChannelZData->iDoubleValues[ aIndex ] = aData.iAxisZ * iScaleFactor; |
|
699 } |
|
700 |
|
701 TInt CAcceleratorSensor::SensorDescriptionId() |
|
702 { |
|
703 JELOG2(ESensor); |
|
704 return EAccelerometerSensor; |
|
705 } |