748
|
1 |
// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
|
|
2 |
// All rights reserved.
|
|
3 |
// This component and the accompanying materials are made available
|
|
4 |
// under the terms of the License "Symbian Foundation License v1.0"
|
|
5 |
// which accompanies this distribution, and is available
|
|
6 |
// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
|
|
7 |
//
|
|
8 |
// Initial Contributors:
|
|
9 |
// Nokia Corporation - initial contribution.
|
|
10 |
//
|
|
11 |
// Contributors:
|
|
12 |
//
|
|
13 |
// Description:
|
|
14 |
//
|
|
15 |
|
|
16 |
|
|
17 |
|
|
18 |
// INCLUDES
|
|
19 |
#include "ctlbsclientpostp169.h"
|
|
20 |
#include <badesca.h>
|
|
21 |
#include <EPos_CPosModules.h>
|
|
22 |
#include <EPos_CPosModuleUpdate.h>
|
|
23 |
#include <EPos_CPosModuleIdList.h>
|
|
24 |
#include <LbsCommon.h>
|
|
25 |
#include <LbsPositionInfo.h>
|
|
26 |
|
|
27 |
// CONSTANTS
|
|
28 |
|
|
29 |
// ================= MEMBER FUNCTIONS =======================
|
|
30 |
|
|
31 |
// ---------------------------------------------------------
|
|
32 |
// Constructor.
|
|
33 |
// ---------------------------------------------------------
|
|
34 |
CT_LbsClientPosTp169::CT_LbsClientPosTp169(CT_LbsServer& aParent): CT_LbsPortedStepBase(aParent)
|
|
35 |
{
|
|
36 |
_LIT(KTestName, "TP169 - Modules Db Tests");
|
|
37 |
SetTestStepName(KTestName);
|
|
38 |
}
|
|
39 |
|
|
40 |
// ---------------------------------------------------------
|
|
41 |
// Destructor.
|
|
42 |
// ---------------------------------------------------------
|
|
43 |
CT_LbsClientPosTp169::~CT_LbsClientPosTp169()
|
|
44 |
{
|
|
45 |
}
|
|
46 |
|
|
47 |
// ---------------------------------------------------------
|
|
48 |
// CT_LbsClientPosTp169::StartL
|
|
49 |
//
|
|
50 |
// (other items were commented in a header).
|
|
51 |
// ---------------------------------------------------------
|
|
52 |
//
|
|
53 |
void CT_LbsClientPosTp169::StartL()
|
|
54 |
{
|
|
55 |
_LIT(KErrorMsg1, "Wrong priority order in module list");
|
|
56 |
|
|
57 |
|
|
58 |
CPosModules* db = CPosModules::OpenL();
|
|
59 |
CleanupStack::PushL(db);
|
|
60 |
|
|
61 |
|
|
62 |
CPosModuleIdList* prioList = db->ModuleIdListLC();
|
|
63 |
|
|
64 |
//////////////////// TC194 //////////////////// List Modules
|
|
65 |
|
|
66 |
_LIT(KErrorMsg4, "Mismatch between list by settings & aquisition API");
|
|
67 |
_LIT(KErrorMsg2, "Installed module in list is returned as uninstalled by IsModuleInstalled");
|
|
68 |
TUid moduleUid;
|
|
69 |
TUid moduleid1;
|
|
70 |
TUint lastPrio = 0;
|
|
71 |
TUint thisPrio = 0;
|
|
72 |
TInt count = 0;
|
|
73 |
TPositionModuleInfo moduleInfo;
|
|
74 |
for (count = 0 ; count < prioList->Count() ; count++)
|
|
75 |
{
|
|
76 |
moduleUid = (*prioList)[count];
|
|
77 |
////////////////////////////////////
|
|
78 |
|
|
79 |
|
|
80 |
TBool IsInstalled=db->IsModuleInstalled(moduleUid);
|
|
81 |
AssertTrueL(IsInstalled,KErrorMsg2);
|
|
82 |
|
|
83 |
db->GetModuleInfoL((*prioList)[count], moduleInfo);
|
|
84 |
moduleid1=moduleInfo.ModuleId();
|
|
85 |
AssertTrueL(moduleid1==moduleUid,KErrorMsg4);
|
|
86 |
////////////////////////////////////
|
|
87 |
|
|
88 |
thisPrio = db->PriorityL(moduleUid);
|
|
89 |
|
|
90 |
if (count > 0)
|
|
91 |
{
|
|
92 |
AssertTrueL(thisPrio > lastPrio,
|
|
93 |
KErrorMsg1);
|
|
94 |
}
|
|
95 |
|
|
96 |
lastPrio = thisPrio;
|
|
97 |
}
|
|
98 |
|
|
99 |
CleanupStack::PopAndDestroy(prioList); // prioList
|
|
100 |
|
|
101 |
//////////////////// TC195 //////////////////// Get Module Properties
|
|
102 |
|
|
103 |
|
|
104 |
CPosModuleUpdate* moduleUpdate = CPosModuleUpdate::NewLC(); // destroy!
|
|
105 |
moduleUpdate->SetUpdateAvailability(ETrue);
|
|
106 |
moduleUpdate->SetUpdateCost(TPositionQuality::ECostCharge); // EEPosHigh
|
|
107 |
//////////////////////////////////////////////////
|
|
108 |
moduleUpdate->SetUpdateVisibility(ETrue);
|
|
109 |
db->UpdateModuleL(iUidTestPsy2, *moduleUpdate);
|
|
110 |
|
|
111 |
|
|
112 |
db->SetModulePriorityL(iUidTestPsy2, 3);
|
|
113 |
|
|
114 |
db->GetModuleInfoL(iUidTestPsy2,
|
|
115 |
moduleInfo);
|
|
116 |
|
|
117 |
|
|
118 |
|
|
119 |
TPositionQuality quality;
|
|
120 |
moduleInfo.GetPositionQuality(quality);
|
|
121 |
|
|
122 |
_LIT(KModName, "Test PSY 2");
|
|
123 |
_LIT(KStatusErrorText, "Wrong status data in module info");
|
|
124 |
_LIT(KVersionErrorText, "Wrong version data in module info");
|
|
125 |
_LIT(KUidErrorText, "Wrong uid data in module info");
|
|
126 |
_LIT(KNameErrorText, "Wrong name data in module info");
|
|
127 |
_LIT(KPosTechErrorText, "Wrong pos tech data in module info");
|
|
128 |
_LIT(KTTFFErrorText, "Wrong TTFF data in module info");
|
|
129 |
_LIT(KTTFErrorText, "Wrong TTF data in module info");
|
|
130 |
_LIT(KHAccErrorText, "Wrong HAcc data in module info");
|
|
131 |
_LIT(KVAccErrorText, "Wrong VAcc data in module info");
|
|
132 |
_LIT(KCostErrorText, "Wrong cost data in module info");
|
|
133 |
_LIT(KPowerCostErrorText, "Wrong power cost data in module info");
|
|
134 |
_LIT(KClassesErrorText, "Wrong class info in module info");
|
|
135 |
|
|
136 |
|
|
137 |
AssertTrueL(moduleInfo.IsAvailable(), KStatusErrorText);
|
|
138 |
TVersion version = moduleInfo.Version();
|
|
139 |
AssertTrueL(version.iMajor == 1, KVersionErrorText);
|
|
140 |
AssertTrueL(version.iMinor == 0, KVersionErrorText);
|
|
141 |
AssertTrueL(version.iBuild == 0, KVersionErrorText);
|
|
142 |
|
|
143 |
AssertTrueL(moduleInfo.ModuleId() == iUidTestPsy2, KUidErrorText);
|
|
144 |
TBuf<100> moduleName;
|
|
145 |
moduleInfo.GetModuleName(moduleName);
|
|
146 |
AssertTrueL(moduleName == KModName, KNameErrorText);
|
|
147 |
AssertTrueL(moduleInfo.TechnologyType() == TPositionModuleInfo::ETechnologyTerminal,
|
|
148 |
KPosTechErrorText);
|
|
149 |
|
|
150 |
AssertTrueL(moduleInfo.ClassesSupported(EPositionInfoFamily) ==
|
|
151 |
(EPositionGenericInfoClass | EPositionInfoClass),
|
|
152 |
KClassesErrorText);
|
|
153 |
|
|
154 |
AssertTrueL(quality.TimeToFirstFix() == TTimeIntervalMicroSeconds(3000000),
|
|
155 |
KTTFFErrorText);
|
|
156 |
AssertTrueL(quality.TimeToNextFix() == TTimeIntervalMicroSeconds(3000000),
|
|
157 |
KTTFErrorText);
|
|
158 |
AssertTrueL(quality.HorizontalAccuracy() == 2, KHAccErrorText);
|
|
159 |
AssertTrueL(quality.VerticalAccuracy() == 3, KVAccErrorText);
|
|
160 |
AssertTrueL(quality.CostIndicator() == TPositionQuality::ECostCharge,
|
|
161 |
KCostErrorText); // Updated cost value
|
|
162 |
AssertTrueL(quality.PowerConsumption() == TPositionQuality::EPowerZero,
|
|
163 |
KPowerCostErrorText);
|
|
164 |
|
|
165 |
//////////////////// TC196 //////////////////// Set Module Properties
|
|
166 |
|
|
167 |
_LIT(KErrorTp196b, "Cost not updated correctly");
|
|
168 |
_LIT(KErrorMsg3, "Wrong Visibility");
|
|
169 |
_LIT(KErrorMsgPrio, "Changing priority of an invisible module");
|
|
170 |
|
|
171 |
// Make sure test psy 2 is enabled.
|
|
172 |
CPosModuleUpdate* moduleUpdate196 = CPosModuleUpdate::NewLC(); // destroy!
|
|
173 |
moduleUpdate196->SetUpdateAvailability(ETrue);
|
|
174 |
moduleUpdate->SetUpdateCost(TPositionQuality::ECostZero);
|
|
175 |
db->UpdateModuleL(iUidTestPsy2, *moduleUpdate196);
|
|
176 |
|
|
177 |
// Disable psy
|
|
178 |
moduleUpdate196->SetUpdateAvailability(EFalse);
|
|
179 |
db->UpdateModuleL(iUidTestPsy2, *moduleUpdate196);
|
|
180 |
|
|
181 |
// Update cost variable to ECostZero
|
|
182 |
moduleUpdate196->SetUpdateCost(TPositionQuality::ECostZero);
|
|
183 |
db->UpdateModuleL(iUidTestPsy2, *moduleUpdate196);
|
|
184 |
db->GetModuleInfoL(iUidTestPsy2,
|
|
185 |
moduleInfo);
|
|
186 |
moduleInfo.GetPositionQuality(quality);
|
|
187 |
AssertTrueL(quality.CostIndicator() == TPositionQuality::ECostZero, KErrorTp196b);
|
|
188 |
|
|
189 |
// Update cost variable to ECostPossible
|
|
190 |
moduleUpdate196->SetUpdateCost(TPositionQuality::ECostPossible);
|
|
191 |
db->UpdateModuleL(iUidTestPsy2, *moduleUpdate196);
|
|
192 |
db->GetModuleInfoL(iUidTestPsy2,
|
|
193 |
moduleInfo);
|
|
194 |
moduleInfo.GetPositionQuality(quality);
|
|
195 |
AssertTrueL(quality.CostIndicator() == TPositionQuality::ECostPossible, KErrorTp196b);
|
|
196 |
|
|
197 |
// Update cost variable to high
|
|
198 |
moduleUpdate196->SetUpdateCost(TPositionQuality::ECostCharge);
|
|
199 |
db->UpdateModuleL(iUidTestPsy2, *moduleUpdate196);
|
|
200 |
db->GetModuleInfoL(iUidTestPsy2,
|
|
201 |
moduleInfo);
|
|
202 |
moduleInfo.GetPositionQuality(quality);
|
|
203 |
AssertTrueL(quality.CostIndicator() == TPositionQuality::ECostCharge, KErrorTp196b);
|
|
204 |
|
|
205 |
|
|
206 |
////////////////////////////////////
|
|
207 |
moduleUpdate196->SetUpdateAvailability(ETrue);
|
|
208 |
|
|
209 |
moduleUpdate196->SetUpdateVisibility(EFalse);
|
|
210 |
db->UpdateModuleL(iUidTestPsy2, *moduleUpdate196);
|
|
211 |
TBool IsVisble=db->IsModuleVisibleL(iUidTestPsy2);
|
|
212 |
AssertTrueL(IsVisble==EFalse,
|
|
213 |
KErrorMsg3);
|
|
214 |
|
|
215 |
// Change priority of an invisible module
|
|
216 |
|
|
217 |
TRAPD(err,db->SetModulePriorityL(iUidTestPsy2, 4));
|
|
218 |
AssertTrueL(err==KErrNotFound,KErrorMsgPrio);
|
|
219 |
|
|
220 |
|
|
221 |
moduleUpdate196->SetUpdateVisibility(ETrue);
|
|
222 |
db->UpdateModuleL(iUidTestPsy2, *moduleUpdate196);
|
|
223 |
IsVisble=db->IsModuleVisibleL(iUidTestPsy2);
|
|
224 |
AssertTrueL(IsVisble,KErrorMsg3);
|
|
225 |
////////////////////////////////////
|
|
226 |
|
|
227 |
//////////////////// TC197 //////////////////// Module Priority
|
|
228 |
|
|
229 |
// Change the priority of the external gps module, and check that the other
|
|
230 |
// modules are updated correctly
|
|
231 |
// Change from 6 to 3
|
|
232 |
|
|
233 |
_LIT(KErrorTextPrio, "Priority test failed after change of priority");
|
|
234 |
_LIT(KErrorVisibility1, "Invisible module is in list");
|
|
235 |
_LIT(KErrorVisibility2, "visible module is not in list after changing it from invisible");
|
|
236 |
db->SetModulePriorityL(iUidTestPsy2, 6);
|
|
237 |
prioList = db->ModuleIdListLC();
|
|
238 |
lastPrio = 0;
|
|
239 |
thisPrio = 0;
|
|
240 |
for (count = 0 ; count < prioList->Count() ; count++)
|
|
241 |
{
|
|
242 |
moduleUid = (*prioList)[count];
|
|
243 |
thisPrio = db->PriorityL(moduleUid);
|
|
244 |
|
|
245 |
if (count > 0)
|
|
246 |
{
|
|
247 |
AssertTrueL(thisPrio > lastPrio,
|
|
248 |
KErrorMsg1);
|
|
249 |
}
|
|
250 |
|
|
251 |
lastPrio = thisPrio;
|
|
252 |
}
|
|
253 |
|
|
254 |
// Remember the uid:s of the modules close to iUidTestPsy2:
|
|
255 |
TUid uid2a = (*prioList)[2];
|
|
256 |
TUid uid3a = (*prioList)[3];
|
|
257 |
TUid uid4a = (*prioList)[4];
|
|
258 |
TUid uid5a = (*prioList)[5];
|
|
259 |
TUid uid6a = (*prioList)[6];
|
|
260 |
TUid uid7a = (*prioList)[7];
|
|
261 |
TUid uid8a = (*prioList)[8];
|
|
262 |
TUid uid0a = (*prioList)[0];
|
|
263 |
|
|
264 |
db->SetModulePriorityL(iUidTestPsy2, 3);
|
|
265 |
|
|
266 |
CleanupStack::PopAndDestroy(prioList); // prioList
|
|
267 |
prioList = db->ModuleIdListLC();
|
|
268 |
|
|
269 |
TUid uid2b = (*prioList)[2];
|
|
270 |
TUid uid3b = (*prioList)[3];
|
|
271 |
TUid uid4b = (*prioList)[4];
|
|
272 |
TUid uid5b = (*prioList)[5];
|
|
273 |
TUid uid6b = (*prioList)[6];
|
|
274 |
TUid uid7b = (*prioList)[7];
|
|
275 |
TUid uid8b = (*prioList)[8];
|
|
276 |
TUid uid0b = (*prioList)[0];
|
|
277 |
|
|
278 |
AssertTrueL(uid2a == uid2b, KErrorTextPrio);
|
|
279 |
AssertTrueL(uid3a == uid4b, KErrorTextPrio);
|
|
280 |
AssertTrueL(uid4a == uid5b, KErrorTextPrio);
|
|
281 |
AssertTrueL(uid5a == uid6b, KErrorTextPrio);
|
|
282 |
AssertTrueL(uid6a == uid3b, KErrorTextPrio);
|
|
283 |
AssertTrueL(uid7a == uid7b, KErrorTextPrio);
|
|
284 |
AssertTrueL(uid8a == uid8b, KErrorTextPrio);
|
|
285 |
AssertTrueL(uid0a == uid0b, KErrorTextPrio);
|
|
286 |
|
|
287 |
db->SetModulePriorityL(iUidTestPsy2, 7);
|
|
288 |
|
|
289 |
CleanupStack::PopAndDestroy(prioList); // prioList
|
|
290 |
prioList = db->ModuleIdListLC();
|
|
291 |
|
|
292 |
uid2a = (*prioList)[2];
|
|
293 |
uid3a = (*prioList)[3];
|
|
294 |
uid4a = (*prioList)[4];
|
|
295 |
uid5a = (*prioList)[5];
|
|
296 |
uid6a = (*prioList)[6];
|
|
297 |
uid7a = (*prioList)[7];
|
|
298 |
uid8a = (*prioList)[8];
|
|
299 |
uid0a = (*prioList)[0];
|
|
300 |
TUid uid1a = (*prioList)[1];
|
|
301 |
|
|
302 |
AssertTrueL(uid2b == uid2a, KErrorTextPrio);
|
|
303 |
AssertTrueL(uid3b == uid7a, KErrorTextPrio);
|
|
304 |
AssertTrueL(uid4b == uid3a, KErrorTextPrio);
|
|
305 |
AssertTrueL(uid5b == uid4a, KErrorTextPrio);
|
|
306 |
AssertTrueL(uid6b == uid5a, KErrorTextPrio);
|
|
307 |
AssertTrueL(uid7b == uid6a, KErrorTextPrio);
|
|
308 |
AssertTrueL(uid8b == uid8a, KErrorTextPrio);
|
|
309 |
AssertTrueL(uid0b == uid0a, KErrorTextPrio);
|
|
310 |
|
|
311 |
|
|
312 |
TInt bottomPrio = prioList->Count() - 1;
|
|
313 |
|
|
314 |
// Change top priority to bottom priority
|
|
315 |
|
|
316 |
db->SetModulePriorityL(uid0a, bottomPrio);
|
|
317 |
CleanupStack::PopAndDestroy(prioList); // prioList
|
|
318 |
prioList = db->ModuleIdListLC();
|
|
319 |
|
|
320 |
AssertTrueL((*prioList)[0] == uid1a, KErrorTextPrio);
|
|
321 |
AssertTrueL(uid0a == (*prioList)[bottomPrio], KErrorTextPrio);
|
|
322 |
AssertTrueL(uid7a == (*prioList)[6], KErrorTextPrio);
|
|
323 |
|
|
324 |
|
|
325 |
// Change bottom priority to top priority
|
|
326 |
TUid topPrioUid = (*prioList)[0];
|
|
327 |
TUid bottomPrioUid = (*prioList)[bottomPrio];
|
|
328 |
TUid nextBottomPrioUid = (*prioList)[bottomPrio - 1];
|
|
329 |
|
|
330 |
db->SetModulePriorityL(bottomPrioUid, 0);
|
|
331 |
CleanupStack::PopAndDestroy(prioList); // prioList
|
|
332 |
prioList = db->ModuleIdListLC();
|
|
333 |
|
|
334 |
AssertTrueL((*prioList)[0] == bottomPrioUid, KErrorTextPrio);
|
|
335 |
AssertTrueL((*prioList)[1] == topPrioUid, KErrorTextPrio);
|
|
336 |
AssertTrueL((*prioList)[bottomPrio] == nextBottomPrioUid, KErrorTextPrio);
|
|
337 |
|
|
338 |
CleanupStack::PopAndDestroy(prioList); // prioList
|
|
339 |
|
|
340 |
////////////////////////////////////
|
|
341 |
|
|
342 |
db->SetModulePriorityL(iUidTestPsy2, 0);
|
|
343 |
|
|
344 |
prioList = db->ModuleIdListLC();
|
|
345 |
|
|
346 |
uid0a = (*prioList)[0];
|
|
347 |
uid1a = (*prioList)[1];
|
|
348 |
uid2a = (*prioList)[2];
|
|
349 |
uid3a = (*prioList)[3];
|
|
350 |
uid4a = (*prioList)[4];
|
|
351 |
uid5a = (*prioList)[5];
|
|
352 |
uid6a = (*prioList)[6];
|
|
353 |
uid7a = (*prioList)[7];
|
|
354 |
uid8a = (*prioList)[8];
|
|
355 |
|
|
356 |
moduleUpdate196->SetUpdateVisibility(EFalse);
|
|
357 |
db->UpdateModuleL(iUidTestPsy2, *moduleUpdate196);
|
|
358 |
|
|
359 |
CleanupStack::PopAndDestroy(prioList); // prioList
|
|
360 |
prioList = db->ModuleIdListLC();
|
|
361 |
|
|
362 |
TInt IsInList=prioList->Find(iUidTestPsy2);
|
|
363 |
AssertTrueL(IsInList==KErrNotFound, KErrorVisibility1);
|
|
364 |
|
|
365 |
|
|
366 |
uid0b = (*prioList)[0];
|
|
367 |
TUid uid1b = (*prioList)[1];
|
|
368 |
uid2b = (*prioList)[2];
|
|
369 |
uid3b = (*prioList)[3];
|
|
370 |
uid4b = (*prioList)[4];
|
|
371 |
uid5b = (*prioList)[5];
|
|
372 |
uid6b = (*prioList)[6];
|
|
373 |
uid7b = (*prioList)[7];
|
|
374 |
|
|
375 |
|
|
376 |
AssertTrueL(uid1a == uid0b, KErrorTextPrio);
|
|
377 |
AssertTrueL(uid2a == uid1b, KErrorTextPrio);
|
|
378 |
AssertTrueL(uid3a == uid2b, KErrorTextPrio);
|
|
379 |
AssertTrueL(uid4a == uid3b, KErrorTextPrio);
|
|
380 |
AssertTrueL(uid5a == uid4b, KErrorTextPrio);
|
|
381 |
AssertTrueL(uid6a == uid5b, KErrorTextPrio);
|
|
382 |
AssertTrueL(uid7a == uid6b, KErrorTextPrio);
|
|
383 |
AssertTrueL(uid8a == uid7b, KErrorTextPrio);
|
|
384 |
|
|
385 |
moduleUpdate196->SetUpdateVisibility(ETrue);
|
|
386 |
db->UpdateModuleL(iUidTestPsy2, *moduleUpdate196);
|
|
387 |
|
|
388 |
CleanupStack::PopAndDestroy(prioList); // prioList
|
|
389 |
prioList = db->ModuleIdListLC();
|
|
390 |
|
|
391 |
IsInList=prioList->Find(iUidTestPsy2);
|
|
392 |
|
|
393 |
TInt priority=db->PriorityL(iUidTestPsy2);
|
|
394 |
|
|
395 |
|
|
396 |
AssertTrueL(IsInList==priority, KErrorVisibility2);
|
|
397 |
|
|
398 |
CleanupStack::PopAndDestroy(prioList); // prioList
|
|
399 |
CleanupStack::PopAndDestroy(2, moduleUpdate);
|
|
400 |
|
|
401 |
////////////////////////////////////
|
|
402 |
|
|
403 |
CleanupStack::PopAndDestroy(db); // db
|
|
404 |
|
|
405 |
}
|
|
406 |
|
|
407 |
|
|
408 |
// ---------------------------------------------------------
|
|
409 |
// CT_LbsClientPosTp169::TestNaNFromPSY
|
|
410 |
//
|
|
411 |
// (other items were commented in a header).
|
|
412 |
// ---------------------------------------------------------
|
|
413 |
//
|
|
414 |
void CT_LbsClientPosTp169::TestNaNFromPSY()
|
|
415 |
{
|
|
416 |
_LIT(KFunctionName, "We are inside TestNaNFromPSY()");
|
|
417 |
INFO_PRINTF1(KFunctionName);
|
|
418 |
CPosModules* db = CPosModules::OpenL();
|
|
419 |
CleanupStack::PushL(db);
|
|
420 |
|
|
421 |
TPositionModuleInfo moduleInfo;
|
|
422 |
TBuf<100> moduleName;
|
|
423 |
|
|
424 |
// Use Panic Psy in this test, should have Horizontal accuracy defined to 0
|
|
425 |
// and vertical accuracy not defined at all in resource file (should default to 0)
|
|
426 |
// and when reading these attributes using the modulesdb they should be of type NaN (Not A Number)
|
|
427 |
CPosModuleUpdate* moduleUpdate = CPosModuleUpdate::NewLC();
|
|
428 |
moduleUpdate->SetUpdateAvailability(ETrue);
|
|
429 |
db->UpdateModuleL(iUidPanicPsy, *moduleUpdate);
|
|
430 |
|
|
431 |
db->GetModuleInfoL(iUidPanicPsy,
|
|
432 |
moduleInfo);
|
|
433 |
|
|
434 |
moduleInfo.GetModuleName(moduleName);
|
|
435 |
|
|
436 |
TPositionQuality quality;
|
|
437 |
moduleInfo.GetPositionQuality(quality);
|
|
438 |
|
|
439 |
if (!Math::IsNaN(quality.HorizontalAccuracy()))
|
|
440 |
{
|
|
441 |
_LIT(KErrorAndLeave, "HorizontalAccuracy should be NaN");
|
|
442 |
LogErrorAndLeaveL(KErrorAndLeave);
|
|
443 |
}
|
|
444 |
else
|
|
445 |
{
|
|
446 |
_LIT(KHorizontalAccuracy, "HorizontalAccuracy NaN");
|
|
447 |
INFO_PRINTF1(KHorizontalAccuracy);
|
|
448 |
}
|
|
449 |
|
|
450 |
if (!Math::IsNaN(quality.VerticalAccuracy()))
|
|
451 |
{
|
|
452 |
_LIT(KErrorAndLeave, "VerticalAccuracy should be NaN");
|
|
453 |
LogErrorAndLeaveL(KErrorAndLeave);
|
|
454 |
}
|
|
455 |
else
|
|
456 |
{
|
|
457 |
_LIT(KVerticalAccuracy, "VerticalAccuracy NaN");
|
|
458 |
INFO_PRINTF1(KVerticalAccuracy);
|
|
459 |
}
|
|
460 |
|
|
461 |
CleanupStack::PopAndDestroy(moduleUpdate);
|
|
462 |
CleanupStack::PopAndDestroy(db);
|
|
463 |
}
|
|
464 |
|
|
465 |
// ---------------------------------------------------------
|
|
466 |
// CT_LbsClientPosTp169::AssertTrueL
|
|
467 |
//
|
|
468 |
// (other items were commented in a header).
|
|
469 |
// ---------------------------------------------------------
|
|
470 |
//
|
|
471 |
void CT_LbsClientPosTp169::AssertTrueL(TBool aCondition, const TDesC& aErrorMsg)
|
|
472 |
{
|
|
473 |
if (!aCondition)
|
|
474 |
{
|
|
475 |
LogErrorAndLeaveL(aErrorMsg);
|
|
476 |
}
|
|
477 |
}
|
|
478 |
|
|
479 |
|
|
480 |
// ---------------------------------------------------------
|
|
481 |
// CT_LbsClientPosTp169::AssertTrueSecL
|
|
482 |
//
|
|
483 |
// (other items were commented in a header).
|
|
484 |
// ---------------------------------------------------------
|
|
485 |
//
|
|
486 |
void CT_LbsClientPosTp169::AssertTrueSecL(TBool aCondition, const TDesC& aErrorMsg, TInt aErrorCode)
|
|
487 |
{
|
|
488 |
if (!aCondition)
|
|
489 |
{
|
|
490 |
TBuf<100> buf;
|
|
491 |
buf.Format(aErrorMsg, aErrorCode);
|
|
492 |
LogErrorAndLeaveL(buf);
|
|
493 |
}
|
|
494 |
}
|
|
495 |
|
|
496 |
|