|
1 /* |
|
2 * Copyright (c) 2007-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: SUPL Settings class |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 #include <f32file.h> |
|
21 #include <badesca.h> // CDesCArrayFlat |
|
22 #include <bautils.h> // file helpers |
|
23 #include <eikenv.h> |
|
24 #include <e32cmn.h> |
|
25 #include <centralrepository.h> //for central repository |
|
26 |
|
27 //#define PRINT_MESSAGE //for logging |
|
28 #define ENABLE_DEBUG |
|
29 |
|
30 #include "epos_csuplsettings.h" |
|
31 #include "epos_csettingsdatabasehandler.h" |
|
32 #include "epos_csuplsettingparams.h" |
|
33 #include "epos_csuplsettingextensionparams.h" |
|
34 #include "epos_csuplsettingsconstants.h" |
|
35 #include "epos_csuplsettingsinternalconstants.h" |
|
36 #include "epos_csuplserverprivatecrkeys.h" //for keys of default setting values stored in cen rep |
|
37 #include "epos_csuplsettingsinternalcrkeys.h" //for keys of setting change events used for notification |
|
38 |
|
39 // Implementation specific constants |
|
40 |
|
41 //some string length contants |
|
42 const int KDateStringLen = 64; |
|
43 const int KGenericStringLen = 255; |
|
44 const int KShortStringLen = 32; |
|
45 |
|
46 const TInt KMaxLenSLPAddress = 64; |
|
47 const TInt KMaxLenIAPName = 16; |
|
48 |
|
49 //integer values used to set or reset a boolen flag corresponding to slp properties |
|
50 const TInt KEmergencySupport = 1; |
|
51 const TInt KTlsEnabled = 2; |
|
52 const TInt KPskTlsUsed = 4; |
|
53 const TInt KServerEnabled = 8; |
|
54 const TInt KSimChangeRemove = 32; |
|
55 const TInt KUsageInHomeNw = 64; |
|
56 const TInt KEditable = 128; |
|
57 |
|
58 //values used to set and retrieve major and minor version numbers from a single int |
|
59 const TInt KVersionMinorMask = 255; |
|
60 const TInt KVersionMajorMask = 8; |
|
61 |
|
62 //values used to set and retrieve mcc,mnc values from a single int |
|
63 const TInt KMccShift = 20; |
|
64 const TInt KMncMask = 1023; |
|
65 const TInt KMncShift= 10; |
|
66 |
|
67 |
|
68 const TInt KMinPriorityValue = 1; //The minimum value for the priority field |
|
69 |
|
70 //all strings related to SQL Statements used to form valid SQL statements |
|
71 |
|
72 _LIT(KSecureDBDrive,"c:"); |
|
73 _LIT(KSecureDBName,"settings.db"); |
|
74 _LIT(KCreateTable, "CREATE TABLE"); |
|
75 _LIT(KCreateTableName," SUPLSETTINGS "); |
|
76 _LIT(KInsertIntoTable," INSERT INTO "); |
|
77 _LIT(KValues," VALUES"); |
|
78 _LIT(KDeleteRecord,"DELETE FROM "); |
|
79 _LIT(KUpdateRecord,"UPDATE "); |
|
80 _LIT(KWhere," WHERE "); |
|
81 _LIT(KSET," SET "); |
|
82 _LIT(KSelect,"SELECT "); |
|
83 _LIT(KFrom," FROM "); |
|
84 _LIT(KMax," MAX "); |
|
85 _LIT(KOrderBy," ORDER BY "); |
|
86 _LIT(KOpeningBracket,"("); |
|
87 _LIT(KClosingBracket,")"); |
|
88 _LIT(KCommaSeparator,","); |
|
89 _LIT(KQuotes,"'"); |
|
90 _LIT(KEquals," = "); |
|
91 _LIT(KGreaterOrEquals," >= "); |
|
92 _LIT(KGreaterThan," > "); |
|
93 _LIT(KStar," * "); |
|
94 _LIT(KCount," Count "); |
|
95 _LIT(KColSLPId,"SlpID"); |
|
96 _LIT(KColSLPAddress,"SLPName"); |
|
97 _LIT(KColManuName, "ManuName"); |
|
98 _LIT(KColProtocolVersionMajor,"MajorVersion"); |
|
99 _LIT(KColIap,"IAP"); |
|
100 _LIT(KColTimeLastUse,"LastTimeUsed"); |
|
101 _LIT(KColTimeLastTried,"LastTimeTried"); |
|
102 _LIT(KColNetInfoLastUse,"NetInfoLastUse"); |
|
103 _LIT(KColNetLastUseCId,"NwInfoLastUseCId"); |
|
104 _LIT(KColNetLastUseParams,"NwInfoLastUseParams"); |
|
105 _LIT(KColNetInfoLastSucess,"NetInfoLastSucess"); |
|
106 _LIT(KColNetLastSuccParams,"NwInfoLastSuccParams"); |
|
107 _LIT(KColNetLastSuccCId,"NwInfoLastSuccCId"); |
|
108 //EEmergencySupport,ETlsEnabled,EPskTlsUsed,EServerEnabled,ESimChangeRemove,EUsageInHomeNw,EEditable |
|
109 _LIT(KColOtherProperties,"OtherProperties"); |
|
110 _LIT(KColPriority,"Priority"); |
|
111 _LIT(KCaseInsensitive," COLLATE NOCASE "); |
|
112 _LIT(KValuePriority,":Priority"); |
|
113 _LIT(KValueSlpId,":SlpId"); |
|
114 _LIT(KDataTypeInteger," INTEGER "); |
|
115 _LIT(KDataTypeString," VARCHAR"); |
|
116 _LIT(KDataTypeTime," TIMESTAMP NULL"); |
|
117 _LIT(KPrimaryKey,"PRIMARY KEY AUTOINCREMENT"); |
|
118 _LIT(KDateTimeFormat,"%M%D%Y%/0%1%/1%2%/2%3%/3 %-B%:0%J%:1%T%:2%S%:3%+B"); // MM/DD/YYYY hh:mm:ss AM/PM |
|
119 |
|
120 _LIT(KSessionTableName," SESSIONSETTINGS "); |
|
121 _LIT(KColSessionId,"SessionID"); |
|
122 _LIT(KColSessionName,"SessionName"); |
|
123 _LIT(KColNotificationPresent,"NotificationPresent"); |
|
124 _LIT(KColTriggerNotificationStatus, "NotificationStatus"); |
|
125 _LIT(KColTriggerType,"TriggerType"); |
|
126 _LIT(KColRequestType,"RequestType"); |
|
127 _LIT(KColOutstandingTrigger,"OutstandingTrigger"); |
|
128 _LIT(KColInterval,"Interval"); |
|
129 |
|
130 _LIT(KColServerId,"ServerId"); |
|
131 _LIT(KColIap1,"Iap1"); |
|
132 _LIT(KColIap2,"Iap2"); |
|
133 _LIT(KColServerAddress,"ServerAddress"); |
|
134 _LIT(KColServerAddType,"ServerAddType"); |
|
135 |
|
136 |
|
137 |
|
138 // --------------------------------------------------------------------------- |
|
139 // CSettingsDatabaseHandler::NewL() |
|
140 // --------------------------------------------------------------------------- |
|
141 CSettingsDatabaseHandler* CSettingsDatabaseHandler::NewL() |
|
142 { |
|
143 CSettingsDatabaseHandler* tmp = new (ELeave)CSettingsDatabaseHandler(); |
|
144 CleanupStack::PushL(tmp); |
|
145 tmp->ConstructL(); |
|
146 CleanupStack::Pop(); |
|
147 return tmp; |
|
148 } |
|
149 |
|
150 // --------------------------------------------------------------------------- |
|
151 // CSettingsDatabaseHandler::~CSettingsDatabaseHandler() |
|
152 // |
|
153 // Destructor method |
|
154 // --------------------------------------------------------------------------- |
|
155 CSettingsDatabaseHandler::~CSettingsDatabaseHandler() |
|
156 { |
|
157 if(iSettingsRep) |
|
158 { |
|
159 delete iSettingsRep; |
|
160 iSettingsRep = NULL; |
|
161 } |
|
162 if(iSettingsNotifierRep) |
|
163 { |
|
164 delete iSettingsNotifierRep; |
|
165 iSettingsNotifierRep = NULL; |
|
166 } |
|
167 iDb.Close(); |
|
168 LogQuery(_L("Deleted Settings DB Handle CLosed")); |
|
169 } |
|
170 |
|
171 // --------------------------------------------------------------------------- |
|
172 // CSettingsDatabaseHandler::ConstructL() |
|
173 // |
|
174 // Second phase construction. Can Leave. |
|
175 // --------------------------------------------------------------------------- |
|
176 void CSettingsDatabaseHandler::ConstructL() |
|
177 { |
|
178 iSettingsRep = CRepository::NewL(KCRUidSuplConfiguration); |
|
179 iSettingsNotifierRep = CRepository::NewL(KCRUidSuplSettings); |
|
180 CreateOpenSecureDatabaseL(); |
|
181 } |
|
182 |
|
183 // --------------------------------------------------------------------------- |
|
184 // CSettingsDatabaseHandler::CSettingsDatabaseHandler() |
|
185 // |
|
186 // Constructor |
|
187 // --------------------------------------------------------------------------- |
|
188 CSettingsDatabaseHandler::CSettingsDatabaseHandler() |
|
189 { |
|
190 |
|
191 } |
|
192 |
|
193 // --------------------------------------------------------------------------- |
|
194 // CSettingsDatabaseHandler::CreateOpenSecureDatabaseL() |
|
195 // |
|
196 // Create a new database and open. The database will be in exclusive access mode. |
|
197 // --------------------------------------------------------------------------- |
|
198 |
|
199 void CSettingsDatabaseHandler::CreateOpenSecureDatabaseL(/*const TDesC& aDbFile*/) |
|
200 { |
|
201 //create a security policy for the database |
|
202 const TSecurityPolicy KPolicy1(ECapabilityReadUserData,ECapabilityWriteUserData); |
|
203 const TSecurityPolicy KPolicy2(ECapabilityReadUserData); |
|
204 |
|
205 TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass); |
|
206 RSqlSecurityPolicy securityPolicy; |
|
207 CleanupClosePushL(securityPolicy); |
|
208 TInt err = securityPolicy.Create(defaultPolicy); |
|
209 |
|
210 PrintErrorMessage(_L(""),err,4); |
|
211 |
|
212 |
|
213 User::LeaveIfError(err); |
|
214 |
|
215 securityPolicy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, KPolicy1); |
|
216 securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, KPolicy2); |
|
217 |
|
218 |
|
219 |
|
220 TBuf<KShortStringLen> dbPath; |
|
221 TBuf<KShortStringLen> pathBuf; |
|
222 err = GetDBPathFromCR(pathBuf); |
|
223 |
|
224 PrintErrorMessage(pathBuf,err,7); |
|
225 |
|
226 if(pathBuf.Length()) //if there is a DB path existing in the CenRep try to open that |
|
227 { |
|
228 dbPath.Copy(KSecureDBDrive); |
|
229 dbPath.Append(pathBuf); |
|
230 dbPath.Append(KSecureDBName); |
|
231 err = iDb.Open(dbPath); // Check if DB exists |
|
232 PrintErrorMessage(dbPath,err,3); |
|
233 } |
|
234 |
|
235 |
|
236 if( KErrNotFound == err || pathBuf.Length() <= 0) // if there is no DB Path in the cen rep or the Db does not exist |
|
237 { |
|
238 RProcess process; |
|
239 TBuf<KShortStringLen> uidname; |
|
240 TInt error = process.SecureId().iId; |
|
241 if(error < 0) // if there is no secure id associated with the app use the UID3 value |
|
242 { |
|
243 TUidType tempUidType = process.Type(); |
|
244 const TUid& uid = tempUidType[2]; |
|
245 uidname.Copy(uid.Name()); |
|
246 } |
|
247 else // use the secure id value to create the DB |
|
248 { |
|
249 TSecureId secureID = process.SecureId(); |
|
250 TUid uid = TUid::Uid(error); |
|
251 uidname.Copy(uid.Name()); |
|
252 |
|
253 } |
|
254 dbPath.Zero(); |
|
255 dbPath.Append(KSecureDBDrive); |
|
256 dbPath.Append(uidname); |
|
257 dbPath.Append(KSecureDBName); |
|
258 err = iDb.Create(dbPath, securityPolicy); // create the db with the path that was formed |
|
259 |
|
260 PrintErrorMessage(dbPath,err,0); |
|
261 |
|
262 User::LeaveIfError(err); |
|
263 |
|
264 //DB created successfully copy the DB path to CenRep |
|
265 StoreDBPathToCR(uidname); |
|
266 CreateTableL(); |
|
267 CreateSessionTableL(); |
|
268 } |
|
269 CleanupStack::PopAndDestroy();//securityPolicy; |
|
270 |
|
271 PrintErrorMessage(dbPath,err,3); |
|
272 User::LeaveIfError(err); |
|
273 } |
|
274 |
|
275 // --------------------------------------------------------------------------- |
|
276 // CSettingsDatabaseHandler::RemoveDb() |
|
277 // |
|
278 // |
|
279 // --------------------------------------------------------------------------- |
|
280 TInt CSettingsDatabaseHandler::RemoveDb() |
|
281 { |
|
282 Close(); |
|
283 // iDbs.DeleteDatabase(KWordDatabase,KSecureUid); |
|
284 return KErrNone; |
|
285 } |
|
286 |
|
287 // --------------------------------------------------------------------------- |
|
288 // CSettingsDatabaseHandler::Close() |
|
289 // |
|
290 // Close the database. |
|
291 // --------------------------------------------------------------------------- |
|
292 TInt CSettingsDatabaseHandler::Close() |
|
293 { |
|
294 iDb.Close(); |
|
295 LogQuery(_L("CLOSED DB")); |
|
296 return KErrNone; |
|
297 } |
|
298 |
|
299 |
|
300 // --------------------------------------------------------------------------- |
|
301 // CSettingsDatabaseHandler::CreateTableL() |
|
302 // |
|
303 // Creates the SUPL Settings table. Leaves, if the table cannot be created. |
|
304 // --------------------------------------------------------------------------- |
|
305 void CSettingsDatabaseHandler::CreateTableL() |
|
306 { |
|
307 |
|
308 iSQLString.Copy(KCreateTable); |
|
309 iSQLString.Append(KCreateTableName); |
|
310 iSQLString.Append(KOpeningBracket); |
|
311 |
|
312 iSQLString.Append(KColSLPId); |
|
313 iSQLString.Append(KDataTypeInteger); |
|
314 iSQLString.Append(KPrimaryKey); |
|
315 iSQLString.Append(KCommaSeparator); |
|
316 |
|
317 iSQLString.Append(KColSLPAddress); |
|
318 iSQLString.Append(KDataTypeString); |
|
319 iSQLString.Append(KOpeningBracket); |
|
320 iSQLString.AppendNum(KMaxLenSLPAddress); |
|
321 iSQLString.Append(KClosingBracket); |
|
322 iSQLString.Append(KCommaSeparator); |
|
323 |
|
324 iSQLString.Append(KColProtocolVersionMajor); |
|
325 iSQLString.Append(KDataTypeInteger); |
|
326 iSQLString.Append(KCommaSeparator); |
|
327 |
|
328 iSQLString.Append(KColPriority); |
|
329 iSQLString.Append(KDataTypeInteger); |
|
330 iSQLString.Append(KCommaSeparator); |
|
331 |
|
332 iSQLString.Append(KColManuName); |
|
333 iSQLString.Append(KDataTypeString); |
|
334 iSQLString.Append(KOpeningBracket); |
|
335 iSQLString.AppendNum(KGenericStringLen); |
|
336 iSQLString.Append(KClosingBracket); |
|
337 iSQLString.Append(KCommaSeparator); |
|
338 |
|
339 iSQLString.Append(KColIap); |
|
340 iSQLString.Append(KDataTypeString); |
|
341 iSQLString.Append(KOpeningBracket); |
|
342 iSQLString.AppendNum(KMaxLenIAPName); |
|
343 iSQLString.Append(KClosingBracket); |
|
344 iSQLString.Append(KCommaSeparator); |
|
345 |
|
346 iSQLString.Append(KColTimeLastUse); |
|
347 iSQLString.Append(KDataTypeTime); |
|
348 iSQLString.Append(KCommaSeparator); |
|
349 |
|
350 iSQLString.Append(KColTimeLastTried); |
|
351 iSQLString.Append(KDataTypeTime); |
|
352 iSQLString.Append(KCommaSeparator); |
|
353 |
|
354 iSQLString.Append(KColNetInfoLastUse); |
|
355 iSQLString.Append(KDataTypeInteger); |
|
356 iSQLString.Append(KCommaSeparator); |
|
357 |
|
358 iSQLString.Append(KColNetInfoLastSucess); |
|
359 iSQLString.Append(KDataTypeInteger); |
|
360 iSQLString.Append(KCommaSeparator); |
|
361 |
|
362 iSQLString.Append(KColNetLastUseCId); |
|
363 iSQLString.Append(KDataTypeInteger); |
|
364 iSQLString.Append(KCommaSeparator); |
|
365 iSQLString.Append(KColNetLastUseParams); |
|
366 iSQLString.Append(KDataTypeInteger); |
|
367 iSQLString.Append(KCommaSeparator); |
|
368 iSQLString.Append(KColNetLastSuccCId); |
|
369 iSQLString.Append(KDataTypeInteger); |
|
370 iSQLString.Append(KCommaSeparator); |
|
371 iSQLString.Append(KColNetLastSuccParams); |
|
372 iSQLString.Append(KDataTypeInteger); |
|
373 iSQLString.Append(KCommaSeparator); |
|
374 |
|
375 iSQLString.Append(KColOtherProperties); |
|
376 iSQLString.Append(KDataTypeInteger); |
|
377 iSQLString.Append(KCommaSeparator); |
|
378 |
|
379 iSQLString.Append(KColServerId); |
|
380 iSQLString.Append(KDataTypeString); |
|
381 iSQLString.Append(KOpeningBracket); |
|
382 iSQLString.AppendNum(KMaxServerIdLen); |
|
383 iSQLString.Append(KClosingBracket); |
|
384 iSQLString.Append(KCommaSeparator); |
|
385 |
|
386 iSQLString.Append(KColIap1); |
|
387 iSQLString.Append(KDataTypeString); |
|
388 iSQLString.Append(KOpeningBracket); |
|
389 iSQLString.AppendNum(KMaxLenIAPName); |
|
390 iSQLString.Append(KClosingBracket); |
|
391 iSQLString.Append(KCommaSeparator); |
|
392 |
|
393 iSQLString.Append(KColIap2); |
|
394 iSQLString.Append(KDataTypeString); |
|
395 iSQLString.Append(KOpeningBracket); |
|
396 iSQLString.AppendNum(KMaxLenIAPName); |
|
397 iSQLString.Append(KClosingBracket); |
|
398 iSQLString.Append(KCommaSeparator); |
|
399 |
|
400 iSQLString.Append(KColServerAddress); |
|
401 iSQLString.Append(KDataTypeString); |
|
402 iSQLString.Append(KOpeningBracket); |
|
403 iSQLString.AppendNum(KMaxServerAddLen); |
|
404 iSQLString.Append(KClosingBracket); |
|
405 iSQLString.Append(KCommaSeparator); |
|
406 |
|
407 iSQLString.Append(KColServerAddType); |
|
408 iSQLString.Append(KDataTypeString); |
|
409 iSQLString.Append(KOpeningBracket); |
|
410 iSQLString.AppendNum(KMaxServerAddTypeLen); |
|
411 iSQLString.Append(KClosingBracket); |
|
412 |
|
413 iSQLString.Append(KClosingBracket); |
|
414 |
|
415 TInt err = iDb.Exec(iSQLString); |
|
416 |
|
417 PrintErrorMessage(iSQLString,err,1); |
|
418 |
|
419 User::LeaveIfError(err); |
|
420 |
|
421 } |
|
422 |
|
423 // --------------------------------------------------------------------------- |
|
424 // CSettingsDatabaseHandler::InsertSLPRecordL() |
|
425 // |
|
426 // This method is used to insert SLP record into the SUPL Settings DB |
|
427 // --------------------------------------------------------------------------- |
|
428 void CSettingsDatabaseHandler::InsertSLPRecordL(const CServerParams* aServParamValues,TInt64& aSlpId) |
|
429 { |
|
430 |
|
431 HBufC* SLPAddress = HBufC::NewLC( KMaxHSLPAddrLen); |
|
432 HBufC* IAPName = HBufC::NewLC( KMaxIAPLen); |
|
433 HBufC* manuName = HBufC::NewLC(KMaxHSLPAddrLen); |
|
434 |
|
435 TBuf<KMaxServerAddTypeLen> serverAddTypeDefault; |
|
436 serverAddTypeDefault.Copy(_L("FQDN")); |
|
437 |
|
438 TUint16* buf = NULL; |
|
439 TPtr nullDefault(buf,0); |
|
440 |
|
441 TBuf<KDateStringLen> lastUseDateTimeFormat; |
|
442 TBuf<KDateStringLen> lasttriedDateTimeFormat; |
|
443 |
|
444 TInt err = KErrNone; |
|
445 |
|
446 TInt64 slpId; |
|
447 TInt protocolVersion = 0; |
|
448 TTime timeLastUse; |
|
449 TTime timeLastTried; |
|
450 |
|
451 TInt32 netInfoLastUse = 0; |
|
452 TInt32 netInfoLastSucess = 0; |
|
453 TBool serverEnabled,simChangeRemove,usageInHomeNw,editable; |
|
454 |
|
455 TInt ret = 0; |
|
456 ret = aServParamValues->Get(slpId,SLPAddress->Des(),IAPName->Des(),serverEnabled,simChangeRemove,usageInHomeNw,editable); |
|
457 if(ret == KErrNotFound) |
|
458 { |
|
459 CleanupStack::PopAndDestroy(3); //SLPAddress,IAPName,manuName |
|
460 aSlpId = -1; |
|
461 PrintErrorMessage(_L(""),KErrNotFound,8); |
|
462 User::Leave(KErrGeneral); |
|
463 } |
|
464 if(IsSlpExists(*SLPAddress)) |
|
465 { |
|
466 PrintErrorMessage(_L(""),KErrAlreadyExists,8); |
|
467 User::Leave(KErrAlreadyExists); |
|
468 } |
|
469 err = GetDefaultCRValues(KSuplProtoclVersion,protocolVersion); //get default values to be set from CR |
|
470 PrintErrorMessage(_L(""),err,8); |
|
471 User::LeaveIfError(err); |
|
472 TBool emergencySupport; |
|
473 err = GetDefaultCRValues(KSuplEmergencySupport,emergencySupport); //get default values to be set from CR |
|
474 PrintErrorMessage(_L(""),err,8); |
|
475 User::LeaveIfError(err); |
|
476 TBool tlsEnabled; |
|
477 err = GetDefaultCRValues(KSuplTlsEnable,tlsEnabled); //get default values to be set from CR |
|
478 PrintErrorMessage(_L(""),err,8); |
|
479 User::LeaveIfError(err); |
|
480 TBool pskTlsUsed; |
|
481 err = GetDefaultCRValues(KSuplPskTlsEnable,pskTlsUsed); //get default values to be set from CR |
|
482 PrintErrorMessage(_L(""),err,8); |
|
483 User::LeaveIfError(err); |
|
484 |
|
485 timeLastUse.FormatL(lastUseDateTimeFormat,KDateTimeFormat); |
|
486 timeLastTried.FormatL(lasttriedDateTimeFormat,KDateTimeFormat); |
|
487 //form other properties int based on the returned TBool Values |
|
488 TInt OtherProperties = 0; //set to all false |
|
489 |
|
490 if(emergencySupport) |
|
491 { |
|
492 OtherProperties |= KEmergencySupport; |
|
493 } |
|
494 if(tlsEnabled) |
|
495 { |
|
496 OtherProperties |= KTlsEnabled; |
|
497 } |
|
498 if(pskTlsUsed) |
|
499 { |
|
500 OtherProperties |= KPskTlsUsed; |
|
501 } |
|
502 if(serverEnabled) |
|
503 { |
|
504 OtherProperties |= KServerEnabled; |
|
505 } |
|
506 if(simChangeRemove) |
|
507 { |
|
508 OtherProperties |= KSimChangeRemove; |
|
509 } |
|
510 if(usageInHomeNw) |
|
511 { |
|
512 OtherProperties |= KUsageInHomeNw; |
|
513 } |
|
514 if(editable) |
|
515 { |
|
516 OtherProperties |= KEditable; |
|
517 } |
|
518 |
|
519 TBuf<KGenericStringLen> tempBuf; |
|
520 tempBuf.Copy(*SLPAddress); |
|
521 tempBuf.Trim(); |
|
522 |
|
523 iSQLString.Copy(KInsertIntoTable); |
|
524 iSQLString.Append(KCreateTableName); |
|
525 iSQLString.Append(KOpeningBracket); |
|
526 |
|
527 iSQLString.Append(KColSLPAddress); |
|
528 iSQLString.Append(KCommaSeparator); |
|
529 |
|
530 |
|
531 iSQLString.Append(KColPriority); |
|
532 iSQLString.Append(KCommaSeparator); |
|
533 |
|
534 iSQLString.Append(KColProtocolVersionMajor); |
|
535 iSQLString.Append(KCommaSeparator); |
|
536 |
|
537 iSQLString.Append(KColManuName); |
|
538 iSQLString.Append(KCommaSeparator); |
|
539 |
|
540 iSQLString.Append(KColIap); |
|
541 iSQLString.Append(KCommaSeparator); |
|
542 |
|
543 iSQLString.Append(KColTimeLastUse); |
|
544 iSQLString.Append(KCommaSeparator); |
|
545 |
|
546 iSQLString.Append(KColTimeLastTried); |
|
547 iSQLString.Append(KCommaSeparator); |
|
548 |
|
549 iSQLString.Append(KColNetInfoLastUse); |
|
550 iSQLString.Append(KCommaSeparator); |
|
551 |
|
552 iSQLString.Append(KColNetInfoLastSucess); |
|
553 iSQLString.Append(KCommaSeparator); |
|
554 |
|
555 iSQLString.Append(KColOtherProperties); |
|
556 iSQLString.Append(KCommaSeparator); |
|
557 |
|
558 iSQLString.Append(KColServerId); |
|
559 iSQLString.Append(KCommaSeparator); |
|
560 |
|
561 iSQLString.Append(KColIap1); |
|
562 iSQLString.Append(KCommaSeparator); |
|
563 |
|
564 iSQLString.Append(KColIap2); |
|
565 iSQLString.Append(KCommaSeparator); |
|
566 |
|
567 iSQLString.Append(KColServerAddress); |
|
568 iSQLString.Append(KCommaSeparator); |
|
569 |
|
570 iSQLString.Append(KColServerAddType); |
|
571 |
|
572 iSQLString.Append(KClosingBracket); |
|
573 |
|
574 iSQLString.Append(KValues); |
|
575 |
|
576 iSQLString.Append(KOpeningBracket); |
|
577 |
|
578 iSQLString.Append(KQuotes); |
|
579 iSQLString.Append(tempBuf); |
|
580 iSQLString.Append(KQuotes); |
|
581 iSQLString.Append(KCommaSeparator); |
|
582 |
|
583 TInt priority = 0; |
|
584 GetMaxPriorityL(priority); |
|
585 iSQLString.AppendNum(priority); // set all servers to max priority by default |
|
586 iSQLString.Append(KCommaSeparator); |
|
587 |
|
588 iSQLString.AppendNum(protocolVersion); |
|
589 iSQLString.Append(KCommaSeparator); |
|
590 |
|
591 iSQLString.Append(KQuotes); |
|
592 iSQLString.Append(*manuName); |
|
593 iSQLString.Append(KQuotes); |
|
594 iSQLString.Append(KCommaSeparator); |
|
595 |
|
596 iSQLString.Append(KQuotes); |
|
597 iSQLString.Append(*IAPName); |
|
598 iSQLString.Append(KQuotes); |
|
599 iSQLString.Append(KCommaSeparator); |
|
600 |
|
601 |
|
602 iSQLString.Append(KQuotes); |
|
603 iSQLString.Append(lastUseDateTimeFormat); |
|
604 iSQLString.Append(KQuotes); |
|
605 iSQLString.Append(KCommaSeparator); |
|
606 |
|
607 iSQLString.Append(KQuotes); |
|
608 iSQLString.Append(lasttriedDateTimeFormat); |
|
609 iSQLString.Append(KQuotes); |
|
610 iSQLString.Append(KCommaSeparator); |
|
611 |
|
612 iSQLString.AppendNum(netInfoLastUse); |
|
613 iSQLString.Append(KCommaSeparator); |
|
614 |
|
615 iSQLString.AppendNum(netInfoLastSucess); |
|
616 iSQLString.Append(KCommaSeparator); |
|
617 |
|
618 iSQLString.AppendNum(OtherProperties); |
|
619 iSQLString.Append(KCommaSeparator); |
|
620 |
|
621 iSQLString.Append(KQuotes); |
|
622 iSQLString.Append(nullDefault); |
|
623 iSQLString.Append(KQuotes); |
|
624 iSQLString.Append(KCommaSeparator); |
|
625 |
|
626 iSQLString.Append(KQuotes); |
|
627 iSQLString.Append(nullDefault); |
|
628 iSQLString.Append(KQuotes); |
|
629 iSQLString.Append(KCommaSeparator); |
|
630 |
|
631 iSQLString.Append(KQuotes); |
|
632 iSQLString.Append(nullDefault); |
|
633 iSQLString.Append(KQuotes); |
|
634 iSQLString.Append(KCommaSeparator); |
|
635 |
|
636 iSQLString.Append(KQuotes); |
|
637 iSQLString.Append(nullDefault); |
|
638 iSQLString.Append(KQuotes); |
|
639 iSQLString.Append(KCommaSeparator); |
|
640 |
|
641 iSQLString.Append(KQuotes); |
|
642 iSQLString.Append(serverAddTypeDefault); |
|
643 iSQLString.Append(KQuotes); |
|
644 |
|
645 iSQLString.Append(KClosingBracket); |
|
646 |
|
647 CleanupStack::PopAndDestroy(3); //SLPAddress,IAPName,manuName |
|
648 |
|
649 err = iDb.Exec(_L("BEGIN")); |
|
650 err = iDb.Exec(iSQLString); |
|
651 PrintErrorMessage(iSQLString,err,2); |
|
652 if(err < 0) |
|
653 User::Leave(KErrGeneral); |
|
654 aSlpId = GetLastInsertedSLPID(); |
|
655 iDb.Exec(_L("COMMIT")); |
|
656 |
|
657 err = NotifyDBChange(MSuplSettingsObserver::ESuplSettingsDBAddEvent,aSlpId); |
|
658 |
|
659 } |
|
660 |
|
661 // ---------------------------------------------------------------------------- |
|
662 // CSettingsDatabaseHandler::DeleteSLPRecordL() |
|
663 // |
|
664 // This method is used to delete a SLP record corresponding to the given SLP ID |
|
665 // ---------------------------------------------------------------------------- |
|
666 void CSettingsDatabaseHandler::DeleteSLPRecordL(TInt64 aSLPId) |
|
667 { |
|
668 if(!IsSlpExists(aSLPId)) //no slp exists with the given id so return error |
|
669 { |
|
670 PrintErrorMessage(_L(""),KErrNotFound,9); |
|
671 User::Leave(KErrNotFound); |
|
672 } |
|
673 |
|
674 iSQLString.Copy(KDeleteRecord); |
|
675 iSQLString.Append(KCreateTableName); |
|
676 iSQLString.Append(KWhere); |
|
677 iSQLString.Append(KColSLPId); |
|
678 iSQLString.Append(KEquals); |
|
679 iSQLString.AppendNum(aSLPId); |
|
680 |
|
681 TInt err = iDb.Exec(iSQLString); |
|
682 PrintErrorMessage(iSQLString,err,5); |
|
683 if(err < 0) |
|
684 User::Leave(KErrGeneral); |
|
685 NormalizePriorityL(); |
|
686 err = NotifyDBChange(MSuplSettingsObserver::ESuplSettingsDBDeleteEvent,aSLPId); // notify about a change in the database |
|
687 |
|
688 } |
|
689 // --------------------------------------------------------------------------- |
|
690 // CSettingsDatabaseHandler::UpdateSLPRecordL() |
|
691 // |
|
692 // This method is used to update a column of string value corresponding |
|
693 // to a particular slp |
|
694 // --------------------------------------------------------------------------- |
|
695 |
|
696 void CSettingsDatabaseHandler::UpdateSLPRecordL(TInt64 aSLPId,CSuplSettingsInternal::TServerParam aParameter,const TDesC& aValue) |
|
697 { |
|
698 if(!IsSlpExists(aSLPId)) //no slp exists with the given id so return error |
|
699 { |
|
700 PrintErrorMessage(_L(""),KErrArgument,9); |
|
701 User::Leave(KErrArgument); |
|
702 } |
|
703 switch(aParameter) |
|
704 { |
|
705 case CSuplSettingsInternal::EIap: |
|
706 if(aValue.Length() > KMaxIAPLen || aValue.Length() <= 0) //check for max length of IAP |
|
707 { |
|
708 PrintErrorMessage(_L(""),KErrArgument,9); |
|
709 User::Leave(KErrArgument); |
|
710 } |
|
711 |
|
712 break; |
|
713 case CSuplSettingsInternal::EServerAddress: |
|
714 { |
|
715 TInt64 slpId; |
|
716 if(IsSlpExists(aValue,slpId)) |
|
717 { |
|
718 if(slpId == aSLPId)//the requested server already has the server name set |
|
719 return; |
|
720 PrintErrorMessage(_L(""),KErrAlreadyExists,9); |
|
721 User::Leave(KErrAlreadyExists); |
|
722 } |
|
723 if(aValue.Length() > KGenericStringLen || aValue.Length() <= 0) |
|
724 { |
|
725 PrintErrorMessage(_L(""),KErrArgument,9); |
|
726 User::Leave(KErrArgument); |
|
727 } |
|
728 } |
|
729 break; |
|
730 default: |
|
731 if(aValue.Length() > KGenericStringLen || aValue.Length() <= 0) |
|
732 { |
|
733 PrintErrorMessage(_L(""),KErrArgument,9); |
|
734 User::Leave(KErrArgument); |
|
735 } |
|
736 break; |
|
737 |
|
738 } |
|
739 |
|
740 |
|
741 iSQLString.Copy(KUpdateRecord); |
|
742 iSQLString.Append(KCreateTableName); |
|
743 iSQLString.Append(KSET); |
|
744 |
|
745 TBuf<KGenericStringLen> tempBuf; |
|
746 tempBuf.Copy(aValue); |
|
747 //remove additional spaces |
|
748 tempBuf.Trim(); |
|
749 FormSLPQueryL(aParameter,tempBuf,iSQLString); |
|
750 |
|
751 iSQLString.Append(KWhere); |
|
752 iSQLString.Append(KColSLPId); |
|
753 iSQLString.Append(KEquals); |
|
754 iSQLString.AppendNum(aSLPId); |
|
755 |
|
756 TInt err = iDb.Exec(iSQLString); |
|
757 PrintErrorMessage(iSQLString,err,6); |
|
758 if(err < 0) |
|
759 User::Leave(KErrGeneral); |
|
760 err = NotifyDBChange(MSuplSettingsObserver::ESuplSettingsDBUpdateEvent,aSLPId); |
|
761 |
|
762 } |
|
763 |
|
764 // --------------------------------------------------------------------------- |
|
765 // CSettingsDatabaseHandler::UpdateSLPRecordL() |
|
766 // |
|
767 // This method is used to update a column of integer value corresponding |
|
768 // to a particular slp |
|
769 // --------------------------------------------------------------------------- |
|
770 |
|
771 void CSettingsDatabaseHandler::UpdateSLPRecordL(TInt64 aSLPId,CSuplSettingsInternal::TServerParam aParameter,TInt aValue) |
|
772 { |
|
773 |
|
774 if(!IsSlpExists(aSLPId)) |
|
775 { |
|
776 PrintErrorMessage(_L(""),KErrArgument,9); |
|
777 User::Leave(KErrArgument); |
|
778 } |
|
779 iSLPId = aSLPId; |
|
780 |
|
781 iSQLString.Copy(KUpdateRecord); |
|
782 iSQLString.Append(KCreateTableName); |
|
783 iSQLString.Append(KSET); |
|
784 |
|
785 FormSLPQueryL(aParameter,aValue,iSQLString); |
|
786 |
|
787 iSQLString.Append(KWhere); |
|
788 iSQLString.Append(KColSLPId); |
|
789 iSQLString.Append(KEquals); |
|
790 iSQLString.AppendNum(aSLPId); |
|
791 |
|
792 TInt err = iDb.Exec(iSQLString); |
|
793 PrintErrorMessage(iSQLString,err,6); |
|
794 if(err < 0) |
|
795 User::Leave(KErrGeneral); |
|
796 err = NotifyDBChange(MSuplSettingsObserver::ESuplSettingsDBUpdateEvent,aSLPId); |
|
797 } |
|
798 |
|
799 // --------------------------------------------------------------------------- |
|
800 // CSettingsDatabaseHandler::UpdateSLPRecordL() |
|
801 // |
|
802 // This method is used to update a column of TTime value corresponding to |
|
803 // a particular slp |
|
804 // --------------------------------------------------------------------------- |
|
805 |
|
806 void CSettingsDatabaseHandler::UpdateSLPRecordL(TInt64 aSLPId,CSuplSettingsInternal::TServerParam aParameter,TTime aValue) |
|
807 { |
|
808 |
|
809 iSQLString.Copy(KUpdateRecord); |
|
810 iSQLString.Append(KCreateTableName); |
|
811 iSQLString.Append(KSET); |
|
812 |
|
813 FormSLPQueryL(aParameter,aValue,iSQLString); |
|
814 |
|
815 iSQLString.Append(KWhere); |
|
816 iSQLString.Append(KColSLPId); |
|
817 iSQLString.Append(KEquals); |
|
818 iSQLString.AppendNum(aSLPId); |
|
819 |
|
820 TInt err = iDb.Exec(iSQLString); |
|
821 |
|
822 PrintErrorMessage(iSQLString,err,6); |
|
823 |
|
824 if(err < 0) |
|
825 User::Leave(KErrGeneral); |
|
826 err = NotifyDBChange(MSuplSettingsObserver::ESuplSettingsDBUpdateEvent,aSLPId); |
|
827 } |
|
828 // --------------------------------------------------------------------------- |
|
829 // CSettingsDatabaseHandler::UpdateSLPRecordL() |
|
830 // |
|
831 // This method is used to update all configurable parameters corresponding |
|
832 // to a partiular SLP |
|
833 // --------------------------------------------------------------------------- |
|
834 void CSettingsDatabaseHandler::UpdateSLPRecordL(const CServerParams* aParamValues) |
|
835 { |
|
836 |
|
837 TInt64 slpId; |
|
838 HBufC* SLPAddress = HBufC::NewLC( KMaxHSLPAddrLen); |
|
839 |
|
840 HBufC* IAPName = HBufC::NewLC( KMaxIAPLen); |
|
841 TBool serverEnabled,simChangeRemove,usageInHomeNw,editable; |
|
842 |
|
843 |
|
844 TInt ret = 0; |
|
845 ret = aParamValues->Get(slpId,SLPAddress->Des(),IAPName->Des(),serverEnabled,simChangeRemove,usageInHomeNw,editable); |
|
846 if(ret == KErrNotFound || slpId == -1 ) |
|
847 { |
|
848 CleanupStack::PopAndDestroy(2); //SLPAddress,IAPName |
|
849 PrintErrorMessage(_L(""),KErrArgument,9); |
|
850 User::Leave(KErrArgument); |
|
851 } |
|
852 if(!IsSlpExists(slpId)) |
|
853 { |
|
854 CleanupStack::PopAndDestroy(2); //SLPAddress,IAPName |
|
855 PrintErrorMessage(_L(""),KErrNotFound,9); |
|
856 User::Leave(KErrNotFound); |
|
857 } |
|
858 |
|
859 //form other properties int based on the returned TBool Values |
|
860 TInt OtherProperties = 0; //set to all false |
|
861 ret = GetOtherPropertyValue(slpId,OtherProperties); //get the current value of all flags |
|
862 if(ret != KErrNone) |
|
863 { |
|
864 CleanupStack::PopAndDestroy(2);//SLPAddress,IAPName |
|
865 PrintErrorMessage(_L(""),KErrGeneral,9); |
|
866 User::Leave(KErrGeneral); |
|
867 } |
|
868 |
|
869 if(serverEnabled) |
|
870 { |
|
871 OtherProperties |= KServerEnabled; |
|
872 } |
|
873 else |
|
874 { |
|
875 OtherProperties &= ~KServerEnabled; |
|
876 } |
|
877 if(simChangeRemove) |
|
878 { |
|
879 OtherProperties |= KSimChangeRemove; |
|
880 } |
|
881 else |
|
882 { |
|
883 OtherProperties &= ~KSimChangeRemove; |
|
884 } |
|
885 if(usageInHomeNw) |
|
886 { |
|
887 OtherProperties |= KUsageInHomeNw; |
|
888 } |
|
889 else |
|
890 { |
|
891 OtherProperties &= ~KUsageInHomeNw; |
|
892 } |
|
893 if(editable) |
|
894 { |
|
895 OtherProperties |= KEditable; |
|
896 } |
|
897 else |
|
898 { |
|
899 OtherProperties &= ~KEditable; |
|
900 } |
|
901 |
|
902 TBuf<KGenericStringLen> tempBuf; |
|
903 tempBuf.Copy(*SLPAddress); |
|
904 tempBuf.Trim(); |
|
905 iSQLString.Copy(KUpdateRecord); |
|
906 iSQLString.Append(KCreateTableName); |
|
907 iSQLString.Append(KSET); |
|
908 iSQLString.Append(KColSLPAddress); |
|
909 iSQLString.Append(KEquals); |
|
910 iSQLString.Append(KQuotes); |
|
911 iSQLString.Append(tempBuf); |
|
912 iSQLString.Append(KQuotes); |
|
913 iSQLString.Append(KCommaSeparator); |
|
914 |
|
915 iSQLString.Append(KColIap); |
|
916 iSQLString.Append(KEquals); |
|
917 iSQLString.Append(KQuotes); |
|
918 iSQLString.Append(*IAPName); |
|
919 iSQLString.Append(KQuotes); |
|
920 iSQLString.Append(KCommaSeparator); |
|
921 |
|
922 |
|
923 iSQLString.Append(KColOtherProperties); |
|
924 iSQLString.Append(KEquals); |
|
925 iSQLString.Append(KQuotes); |
|
926 iSQLString.AppendNum(OtherProperties); |
|
927 iSQLString.Append(KQuotes); |
|
928 |
|
929 iSQLString.Append(KWhere); |
|
930 iSQLString.Append(KColSLPId); |
|
931 iSQLString.Append(KEquals); |
|
932 iSQLString.AppendNum(slpId); |
|
933 |
|
934 TInt err = iDb.Exec(iSQLString); |
|
935 PrintErrorMessage(iSQLString,err,6); |
|
936 CleanupStack::PopAndDestroy(2); |
|
937 if(err < 0) |
|
938 { |
|
939 PrintErrorMessage(_L(""),KErrGeneral,9); |
|
940 User::Leave(KErrGeneral); |
|
941 } |
|
942 |
|
943 err = NotifyDBChange(MSuplSettingsObserver::ESuplSettingsDBUpdateEvent,slpId); |
|
944 } |
|
945 // --------------------------------------------------------------------------- |
|
946 // CSettingsDatabaseHandler::UpdateSLPRecordL() |
|
947 // |
|
948 // This method is used to update a column corresponding to version number |
|
949 // of a particular slp |
|
950 // --------------------------------------------------------------------------- |
|
951 void CSettingsDatabaseHandler::UpdateSLPRecordL(TInt64 aSLPId,TInt aMajor, TInt aMinor) |
|
952 { |
|
953 if(!IsSlpExists(aSLPId)) |
|
954 { |
|
955 PrintErrorMessage(_L(""),KErrArgument,9); |
|
956 User::Leave(KErrArgument); |
|
957 } |
|
958 if(aMajor < 0 || aMajor > 255 || aMinor < 0 || aMinor > 255 ) |
|
959 { |
|
960 PrintErrorMessage(_L(""),KErrArgument,9); |
|
961 User::Leave(KErrArgument); |
|
962 } |
|
963 TInt protocolVersion = aMajor<< KVersionMajorMask | aMinor; |
|
964 |
|
965 iSQLString.Copy(KUpdateRecord); |
|
966 iSQLString.Append(KCreateTableName); |
|
967 iSQLString.Append(KSET); |
|
968 iSQLString.Append(KColProtocolVersionMajor); |
|
969 iSQLString.Append(KEquals); |
|
970 iSQLString.Append(KQuotes); |
|
971 iSQLString.AppendNum(protocolVersion); |
|
972 iSQLString.Append(KQuotes); |
|
973 iSQLString.Append(KWhere); |
|
974 iSQLString.Append(KColSLPId); |
|
975 iSQLString.Append(KEquals); |
|
976 iSQLString.AppendNum(aSLPId); |
|
977 |
|
978 TInt err = iDb.Exec(iSQLString); |
|
979 |
|
980 PrintErrorMessage(iSQLString,err,6); |
|
981 |
|
982 if(err < 0) |
|
983 User::Leave(KErrGeneral); |
|
984 err = NotifyDBChange(MSuplSettingsObserver::ESuplSettingsDBUpdateEvent,aSLPId); |
|
985 } |
|
986 // --------------------------------------------------------------------------- |
|
987 // CSettingsDatabaseHandler::UpdateSLPRecordL() |
|
988 // |
|
989 // This method is used to update a column corresponding to N/w Info Last Use/ |
|
990 // Last Success of a particular slp |
|
991 // --------------------------------------------------------------------------- |
|
992 void CSettingsDatabaseHandler::UpdateSLPRecordL(TInt64 aSLPId,CSuplSettingsInternal::TServerParam aParamType , |
|
993 const CSuplSettingsInternal::TSuplSettingsNetworkType aNetType, |
|
994 const TInt aMcc, const TInt aMnc, const TInt aCid, const TInt aLac) |
|
995 { |
|
996 if(!IsSlpExists(aSLPId)) |
|
997 { |
|
998 PrintErrorMessage(_L(""),KErrArgument,9); |
|
999 User::Leave(KErrArgument); |
|
1000 } |
|
1001 if(aMcc < 0 || aMcc > 999 || aMnc < 0 || aMnc > 999 || aLac < 0 || aLac > 65535)//these params are 8 bit ints and cant go beyond 255 |
|
1002 { |
|
1003 PrintErrorMessage(_L(""),KErrArgument,9); |
|
1004 User::Leave(KErrArgument); |
|
1005 } |
|
1006 TInt64 nwparams = aMcc << KMccShift | aMnc << KMncShift | aLac; |
|
1007 |
|
1008 |
|
1009 iSQLString.Copy(KUpdateRecord); |
|
1010 iSQLString.Append(KCreateTableName); |
|
1011 iSQLString.Append(KSET); |
|
1012 switch(aParamType) |
|
1013 { |
|
1014 case CSuplSettingsInternal::ENetInfoLastUse: |
|
1015 iSQLString.Append(KColNetInfoLastUse); |
|
1016 iSQLString.Append(KEquals); |
|
1017 iSQLString.Append(KQuotes); |
|
1018 iSQLString.AppendNum(aNetType); |
|
1019 iSQLString.Append(KQuotes); |
|
1020 iSQLString.Append(KCommaSeparator); |
|
1021 |
|
1022 iSQLString.Append(KColNetLastUseCId); |
|
1023 iSQLString.Append(KEquals); |
|
1024 iSQLString.Append(KQuotes); |
|
1025 iSQLString.AppendNum(aCid); |
|
1026 iSQLString.Append(KQuotes); |
|
1027 iSQLString.Append(KCommaSeparator); |
|
1028 |
|
1029 iSQLString.Append(KColNetLastUseParams); |
|
1030 iSQLString.Append(KEquals); |
|
1031 iSQLString.Append(KQuotes); |
|
1032 iSQLString.AppendNum(nwparams); |
|
1033 iSQLString.Append(KQuotes); |
|
1034 break; |
|
1035 case CSuplSettingsInternal::ENetInfoLastSucess: |
|
1036 iSQLString.Append(KColNetInfoLastSucess); |
|
1037 iSQLString.Append(KEquals); |
|
1038 iSQLString.Append(KQuotes); |
|
1039 iSQLString.AppendNum(aNetType); |
|
1040 iSQLString.Append(KQuotes); |
|
1041 iSQLString.Append(KCommaSeparator); |
|
1042 |
|
1043 iSQLString.Append(KColNetLastSuccCId); |
|
1044 iSQLString.Append(KEquals); |
|
1045 iSQLString.Append(KQuotes); |
|
1046 iSQLString.AppendNum(aCid); |
|
1047 iSQLString.Append(KQuotes); |
|
1048 iSQLString.Append(KCommaSeparator); |
|
1049 |
|
1050 iSQLString.Append(KColNetLastSuccParams); |
|
1051 iSQLString.Append(KEquals); |
|
1052 iSQLString.Append(KQuotes); |
|
1053 iSQLString.AppendNum(nwparams); |
|
1054 iSQLString.Append(KQuotes); |
|
1055 break; |
|
1056 default: |
|
1057 User::Leave(KErrGeneral); |
|
1058 break; |
|
1059 } |
|
1060 |
|
1061 iSQLString.Append(KWhere); |
|
1062 iSQLString.Append(KColSLPId); |
|
1063 iSQLString.Append(KEquals); |
|
1064 iSQLString.AppendNum(aSLPId); |
|
1065 |
|
1066 TInt err = iDb.Exec(iSQLString); |
|
1067 |
|
1068 PrintErrorMessage(iSQLString,err,6); |
|
1069 if(err < 0) |
|
1070 User::Leave(KErrGeneral); |
|
1071 err = NotifyDBChange(MSuplSettingsObserver::ESuplSettingsDBUpdateEvent,aSLPId); |
|
1072 } |
|
1073 // --------------------------------------------------------------------------- |
|
1074 // CSettingsDatabaseHandler::UpdateDefaultServerL() |
|
1075 // |
|
1076 // This method is used to update all configurable parameters corresponding |
|
1077 // to a default SLP |
|
1078 // --------------------------------------------------------------------------- |
|
1079 void CSettingsDatabaseHandler::UpdateDefaultServerL(const CServerParams* aParamValues) |
|
1080 { |
|
1081 |
|
1082 TInt64 defaultSlpId; |
|
1083 GetDefaultSLPId(defaultSlpId); |
|
1084 if(defaultSlpId == -1) // no server set as default |
|
1085 { |
|
1086 PrintErrorMessage(_L(""),KErrNotFound,10); |
|
1087 User::Leave(KErrNotFound); |
|
1088 } |
|
1089 |
|
1090 HBufC* SLPAddress = HBufC::NewLC( KMaxHSLPAddrLen); |
|
1091 HBufC* IAPName = HBufC::NewLC( KMaxIAPLen); |
|
1092 |
|
1093 TBool serverEnabled,simChangeRemove,usageInHomeNw,editable; |
|
1094 |
|
1095 |
|
1096 TInt ret = 0; |
|
1097 TInt64 slpId; |
|
1098 ret = aParamValues->Get(slpId,SLPAddress->Des(),IAPName->Des(),serverEnabled,simChangeRemove,usageInHomeNw,editable); |
|
1099 if(ret == KErrNotFound ) |
|
1100 { |
|
1101 CleanupStack::PopAndDestroy(2); //SLPAddress,IAPName |
|
1102 PrintErrorMessage(_L(""),KErrArgument,10); |
|
1103 User::Leave(KErrArgument); |
|
1104 } |
|
1105 |
|
1106 //form other properties int based on the returned TBool Values |
|
1107 TInt OtherProperties = 0; //set to all false |
|
1108 ret = GetOtherPropertyValue(defaultSlpId,OtherProperties); //get the current value of all flags |
|
1109 if(ret != KErrNone) |
|
1110 { |
|
1111 CleanupStack::PopAndDestroy(2); //SLPAddress,IAPName |
|
1112 PrintErrorMessage(_L(""),KErrGeneral,10); |
|
1113 User::Leave(KErrGeneral); |
|
1114 } |
|
1115 |
|
1116 |
|
1117 if(serverEnabled) |
|
1118 { |
|
1119 OtherProperties |= KServerEnabled; |
|
1120 } |
|
1121 else |
|
1122 { |
|
1123 OtherProperties &= ~KServerEnabled; |
|
1124 } |
|
1125 if(simChangeRemove) |
|
1126 { |
|
1127 OtherProperties |= KSimChangeRemove; |
|
1128 } |
|
1129 else |
|
1130 { |
|
1131 OtherProperties &= ~KSimChangeRemove; |
|
1132 } |
|
1133 if(usageInHomeNw) |
|
1134 { |
|
1135 OtherProperties |= KUsageInHomeNw; |
|
1136 } |
|
1137 else |
|
1138 { |
|
1139 OtherProperties &= ~KUsageInHomeNw; |
|
1140 } |
|
1141 if(editable) |
|
1142 { |
|
1143 OtherProperties |= KEditable; |
|
1144 } |
|
1145 else |
|
1146 { |
|
1147 OtherProperties &= ~KEditable; |
|
1148 } |
|
1149 |
|
1150 TBuf<KGenericStringLen> tempBuf; |
|
1151 tempBuf.Copy(*SLPAddress); |
|
1152 tempBuf.Trim(); |
|
1153 iSQLString.Copy(KUpdateRecord); |
|
1154 iSQLString.Append(KCreateTableName); |
|
1155 iSQLString.Append(KSET); |
|
1156 iSQLString.Append(KColSLPAddress); |
|
1157 iSQLString.Append(KEquals); |
|
1158 iSQLString.Append(KQuotes); |
|
1159 iSQLString.Append(tempBuf); |
|
1160 iSQLString.Append(KQuotes); |
|
1161 iSQLString.Append(KCommaSeparator); |
|
1162 |
|
1163 iSQLString.Append(KColIap); |
|
1164 iSQLString.Append(KEquals); |
|
1165 iSQLString.Append(KQuotes); |
|
1166 iSQLString.Append(*IAPName); |
|
1167 iSQLString.Append(KQuotes); |
|
1168 iSQLString.Append(KCommaSeparator); |
|
1169 |
|
1170 iSQLString.Append(KColOtherProperties); |
|
1171 iSQLString.Append(KEquals); |
|
1172 iSQLString.Append(KQuotes); |
|
1173 iSQLString.AppendNum(OtherProperties); |
|
1174 iSQLString.Append(KQuotes); |
|
1175 |
|
1176 iSQLString.Append(KWhere); |
|
1177 iSQLString.Append(KColSLPId); |
|
1178 iSQLString.Append(KEquals); |
|
1179 iSQLString.AppendNum(defaultSlpId); |
|
1180 |
|
1181 TInt err = iDb.Exec(iSQLString); |
|
1182 PrintErrorMessage(iSQLString,err,6); |
|
1183 CleanupStack::PopAndDestroy(2); //SLPAddress,IAPName |
|
1184 if(err < 0) |
|
1185 { |
|
1186 User::Leave(KErrGeneral); |
|
1187 } |
|
1188 |
|
1189 err = NotifyDBChange(MSuplSettingsObserver::ESuplSettingsDBUpdateEvent,defaultSlpId); |
|
1190 |
|
1191 } |
|
1192 // --------------------------------------------------------------------------- |
|
1193 // CSettingsDatabaseHandler::SetSLPAsDefaultL() |
|
1194 // |
|
1195 // This method is used to set a SLP with a particular id as default |
|
1196 // --------------------------------------------------------------------------- |
|
1197 void CSettingsDatabaseHandler::SetSLPAsDefaultL(TInt64 aSLPId) |
|
1198 { |
|
1199 if(!IsSlpExists(aSLPId)) |
|
1200 { |
|
1201 PrintErrorMessage(_L(""),KErrNotFound,12); |
|
1202 User::LeaveIfError(KErrNotFound); |
|
1203 } |
|
1204 |
|
1205 SetPriorityL(aSLPId,KMinPriorityValue); |
|
1206 PrintErrorMessage(_L(""),KErrNone,12); |
|
1207 } |
|
1208 // --------------------------------------------------------------------------- |
|
1209 // CSettingsDatabaseHandler::GetDefaultSLPId() |
|
1210 // |
|
1211 // This method is used to get SLP Id of the default server |
|
1212 // --------------------------------------------------------------------------- |
|
1213 TInt CSettingsDatabaseHandler::GetDefaultSLPId(TInt64& aSlpId) |
|
1214 { |
|
1215 aSlpId = -1; |
|
1216 |
|
1217 iSQLString.Copy(KSelect); |
|
1218 iSQLString.Append(KStar); |
|
1219 iSQLString.Append(KFrom); |
|
1220 iSQLString.Append(KCreateTableName); |
|
1221 iSQLString.Append(KOrderBy); |
|
1222 iSQLString.Append(KColPriority); |
|
1223 iSQLString.Append(KCommaSeparator); |
|
1224 iSQLString.Append(KColSLPId); |
|
1225 |
|
1226 RSqlStatement stmt; |
|
1227 TInt err = stmt.Prepare(iDb, iSQLString); |
|
1228 TInt columnIndexSLPID = stmt.ColumnIndex(KColSLPId); |
|
1229 TInt columnIndexPriority = stmt.ColumnIndex(KColPriority); |
|
1230 //Get the first slp in the list in the order of priority/slp id |
|
1231 while((err=stmt.Next())==KSqlAtRow) |
|
1232 { |
|
1233 aSlpId = stmt.ColumnInt(columnIndexSLPID); |
|
1234 break; |
|
1235 } |
|
1236 |
|
1237 stmt.Close(); |
|
1238 PrintErrorMessage(iSQLString,err,13); |
|
1239 if(aSlpId == -1) |
|
1240 { |
|
1241 PrintErrorMessage(_L(""),KErrNotFound,14); |
|
1242 return KErrNotFound; |
|
1243 } |
|
1244 PrintErrorMessage(_L(""),KErrNone,14); |
|
1245 return KErrNone; |
|
1246 } |
|
1247 |
|
1248 // --------------------------------------------------------------------------- |
|
1249 // CSettingsDatabaseHandler::FormSLPQueryL() |
|
1250 // |
|
1251 // Forms part of the query string, used to form a query string that contains |
|
1252 // a TTIme value in it |
|
1253 // --------------------------------------------------------------------------- |
|
1254 void CSettingsDatabaseHandler::FormSLPQueryL(CSuplSettingsInternal::TServerParam aParameter,TTime aValue,TDes& aQueryString) |
|
1255 { |
|
1256 TBuf<64> dateTimeFormat; |
|
1257 aValue.FormatL(dateTimeFormat,KDateTimeFormat); |
|
1258 |
|
1259 switch(aParameter) |
|
1260 { |
|
1261 case CSuplSettingsInternal::ETimeLastTried: |
|
1262 { |
|
1263 aQueryString.Append(KColTimeLastTried); |
|
1264 break; |
|
1265 } |
|
1266 case CSuplSettingsInternal::ETimeLastUse: |
|
1267 { |
|
1268 aQueryString.Append(KColTimeLastUse); |
|
1269 break; |
|
1270 } |
|
1271 default:User::Leave(KErrArgument); |
|
1272 } |
|
1273 |
|
1274 aQueryString.Append(KEquals); |
|
1275 aQueryString.Append(KQuotes); |
|
1276 aQueryString.Append(dateTimeFormat); |
|
1277 aQueryString.Append(KQuotes); |
|
1278 } |
|
1279 |
|
1280 // --------------------------------------------------------------------------- |
|
1281 // CSettingsDatabaseHandler::FormSLPQueryL() |
|
1282 // |
|
1283 // Forms part of the query string, used to form a query string that contains |
|
1284 // a TInt value in it |
|
1285 // --------------------------------------------------------------------------- |
|
1286 |
|
1287 void CSettingsDatabaseHandler::FormSLPQueryL(CSuplSettingsInternal::TServerParam aParameter,TInt aValue,TDes& aQueryString) |
|
1288 { |
|
1289 switch(aParameter) |
|
1290 { |
|
1291 case CSuplSettingsInternal::ENetInfoLastUse: |
|
1292 { |
|
1293 aQueryString.Append(KColNetInfoLastUse); |
|
1294 break; |
|
1295 } |
|
1296 case CSuplSettingsInternal::ENetInfoLastSucess: |
|
1297 { |
|
1298 aQueryString.Append(KColNetInfoLastSucess); |
|
1299 break; |
|
1300 } |
|
1301 case CSuplSettingsInternal::EEmergencySupport: |
|
1302 case CSuplSettingsInternal::ETlsEnabled: |
|
1303 case CSuplSettingsInternal::EPskTlsUsed: |
|
1304 case CSuplSettingsInternal::EServerEnabled: |
|
1305 case CSuplSettingsInternal::EManufacturer: |
|
1306 case CSuplSettingsInternal::ESimChangeRemove: |
|
1307 case CSuplSettingsInternal::EUsageInHomeNw: |
|
1308 case CSuplSettingsInternal::EEditable: |
|
1309 { |
|
1310 aValue = SetOtherPropertiesL(aParameter,aValue); |
|
1311 aQueryString.Append(KColOtherProperties); |
|
1312 break; |
|
1313 } |
|
1314 default: |
|
1315 { |
|
1316 User::Leave(KErrArgument); |
|
1317 break; |
|
1318 } |
|
1319 |
|
1320 |
|
1321 } |
|
1322 aQueryString.Append(KEquals); |
|
1323 aQueryString.AppendNum(aValue); |
|
1324 } |
|
1325 // --------------------------------------------------------------------------- |
|
1326 // CSettingsDatabaseHandler::FormSLPQueryL() |
|
1327 // |
|
1328 // Forms part of the query string, used to form a query string that contains |
|
1329 // a String value in it |
|
1330 // --------------------------------------------------------------------------- |
|
1331 void CSettingsDatabaseHandler::FormSLPQueryL(CSuplSettingsInternal::TServerParam aParameter,const TDesC& aValue,TDes& aQueryString) |
|
1332 { |
|
1333 switch(aParameter) |
|
1334 { |
|
1335 |
|
1336 case CSuplSettingsInternal::EServerAddress: |
|
1337 { |
|
1338 aQueryString.Append(KColSLPAddress); |
|
1339 break; |
|
1340 } |
|
1341 |
|
1342 case CSuplSettingsInternal::EIap: |
|
1343 { |
|
1344 aQueryString.Append(KColIap); |
|
1345 break; |
|
1346 } |
|
1347 case CSuplSettingsInternal::EManufacturer: |
|
1348 { |
|
1349 aQueryString.Append(KColManuName); |
|
1350 break; |
|
1351 } |
|
1352 |
|
1353 default:User::Leave(KErrArgument); |
|
1354 } |
|
1355 |
|
1356 aQueryString.Append(KEquals); |
|
1357 aQueryString.Append(KQuotes); |
|
1358 aQueryString.Append(aValue); |
|
1359 aQueryString.Append(KQuotes); |
|
1360 } |
|
1361 |
|
1362 |
|
1363 |
|
1364 // --------------------------------------------------------------------------- |
|
1365 // CSettingsDatabaseHandler::GetNwInfoPropertiesL() |
|
1366 // |
|
1367 // This method is used to retrieve a colummn corresponding to N/w Info Last |
|
1368 // Use/Last Success of a particular slp |
|
1369 // --------------------------------------------------------------------------- |
|
1370 void CSettingsDatabaseHandler::GetNwInfoPropertiesL(TInt64 aSLPId,CSuplSettingsInternal::TServerParam& aParamType , |
|
1371 CSuplSettingsInternal::TSuplSettingsNetworkType& aNetType,TInt& aMcc,TInt& aMnc, |
|
1372 TInt& aCid, TInt& aLac) |
|
1373 { |
|
1374 if(!IsSlpExists(aSLPId)) |
|
1375 { |
|
1376 PrintErrorMessage(_L(""),KErrArgument,14); |
|
1377 User::Leave(KErrArgument); |
|
1378 } |
|
1379 |
|
1380 iSQLString.Copy(KSelect); |
|
1381 iSQLString.Append(KStar); |
|
1382 iSQLString.Append(KFrom); |
|
1383 iSQLString.Append(KCreateTableName); |
|
1384 iSQLString.Append(KWhere); |
|
1385 iSQLString.Append(KColSLPId); |
|
1386 iSQLString.Append(KEquals); |
|
1387 iSQLString.AppendNum(aSLPId); |
|
1388 |
|
1389 RSqlStatement stmt; |
|
1390 TInt err = stmt.Prepare(iDb, iSQLString); |
|
1391 if(err != KErrNone) |
|
1392 { |
|
1393 PrintErrorMessage(_L(""),KErrGeneral,14); |
|
1394 User::Leave(KErrGeneral); |
|
1395 } |
|
1396 |
|
1397 TInt columnIndexNwType = 0; |
|
1398 TInt columnIndexCid = 0; |
|
1399 TInt columnIndexParams = 0; |
|
1400 TInt64 nwParams = 0; |
|
1401 |
|
1402 |
|
1403 switch(aParamType) |
|
1404 { |
|
1405 case CSuplSettingsInternal::ENetInfoLastSucess: |
|
1406 columnIndexNwType = stmt.ColumnIndex(KColNetInfoLastSucess); |
|
1407 columnIndexParams = stmt.ColumnIndex(KColNetLastSuccParams); |
|
1408 columnIndexCid = stmt.ColumnIndex(KColNetLastSuccCId); |
|
1409 break; |
|
1410 case CSuplSettingsInternal::ENetInfoLastUse: |
|
1411 columnIndexNwType = stmt.ColumnIndex(KColNetInfoLastUse); |
|
1412 columnIndexParams = stmt.ColumnIndex(KColNetLastUseParams); |
|
1413 columnIndexCid = stmt.ColumnIndex(KColNetLastUseCId); |
|
1414 break; |
|
1415 default: |
|
1416 User::Leave(KErrGeneral); |
|
1417 } |
|
1418 while((err=stmt.Next())==KSqlAtRow) |
|
1419 { |
|
1420 aNetType = (CSuplSettingsInternal::TSuplSettingsNetworkType) stmt.ColumnInt(columnIndexNwType); |
|
1421 aCid = stmt.ColumnInt(columnIndexCid); |
|
1422 nwParams = stmt.ColumnInt64(columnIndexParams); |
|
1423 } |
|
1424 aMcc = nwParams>>KMccShift; |
|
1425 aMnc = (nwParams>>KMncShift)& KMncMask; |
|
1426 aLac = nwParams & KMncMask; |
|
1427 PrintErrorMessage(_L(""),KErrNone,14); |
|
1428 #ifdef PRINT_MESSAGE |
|
1429 TBuf<5> mccBuf; |
|
1430 mccBuf.AppendNum(aMcc); |
|
1431 TBuf<5> mncBuf; |
|
1432 mncBuf.AppendNum(aMnc); |
|
1433 TBuf<5> lacBuf; |
|
1434 lacBuf.AppendNum(aLac); |
|
1435 LogQuery(mccBuf); |
|
1436 LogQuery(mncBuf); |
|
1437 LogQuery(lacBuf); |
|
1438 #endif |
|
1439 stmt.Close(); |
|
1440 } |
|
1441 // --------------------------------------------------------------------------- |
|
1442 // CSettingsDatabaseHandler::SetOtherPropertiesL() |
|
1443 // |
|
1444 // |
|
1445 // --------------------------------------------------------------------------- |
|
1446 TInt CSettingsDatabaseHandler::SetOtherPropertiesL(CSuplSettingsInternal::TServerParam aParameter,TInt aValue) |
|
1447 { |
|
1448 TInt OtherProperty = 0; |
|
1449 TBuf<KGenericStringLen> sqlString; |
|
1450 sqlString.Copy(KSelect); |
|
1451 sqlString.Append(KColOtherProperties); |
|
1452 sqlString.Append(KFrom); |
|
1453 sqlString.Append(KCreateTableName); |
|
1454 sqlString.Append(KWhere); |
|
1455 sqlString.Append(KColSLPId); |
|
1456 sqlString.Append(KEquals); |
|
1457 sqlString.AppendNum(iSLPId); |
|
1458 |
|
1459 RSqlStatement stmt; |
|
1460 TInt err = stmt.Prepare(iDb, sqlString); |
|
1461 if(err != KErrNone) |
|
1462 User::Leave(KErrGeneral); |
|
1463 TInt columnIndex0=0; |
|
1464 while((err=stmt.Next())==KSqlAtRow) |
|
1465 { |
|
1466 OtherProperty = stmt.ColumnInt(columnIndex0); |
|
1467 } |
|
1468 |
|
1469 if(aValue == 1) |
|
1470 { |
|
1471 switch(aParameter) |
|
1472 { |
|
1473 case CSuplSettingsInternal::EEmergencySupport: |
|
1474 OtherProperty = OtherProperty | KEmergencySupport; break; |
|
1475 case CSuplSettingsInternal::ETlsEnabled: |
|
1476 OtherProperty = OtherProperty | KTlsEnabled; break; |
|
1477 case CSuplSettingsInternal::EPskTlsUsed: |
|
1478 OtherProperty = OtherProperty | KPskTlsUsed; break; |
|
1479 case CSuplSettingsInternal::EServerEnabled: |
|
1480 OtherProperty = OtherProperty | KServerEnabled; break; |
|
1481 |
|
1482 case CSuplSettingsInternal::ESimChangeRemove: |
|
1483 OtherProperty = OtherProperty | KSimChangeRemove; break; |
|
1484 case CSuplSettingsInternal::EUsageInHomeNw: |
|
1485 OtherProperty = OtherProperty | KUsageInHomeNw; break; |
|
1486 case CSuplSettingsInternal::EEditable: |
|
1487 OtherProperty = OtherProperty | KEditable; break; |
|
1488 default:{ User::Leave(KErrArgument);} |
|
1489 } |
|
1490 } |
|
1491 else |
|
1492 { |
|
1493 switch(aParameter) |
|
1494 { |
|
1495 case CSuplSettingsInternal::EEmergencySupport: |
|
1496 OtherProperty = OtherProperty & ~KEmergencySupport; break; |
|
1497 case CSuplSettingsInternal::ETlsEnabled: |
|
1498 OtherProperty = OtherProperty & ~KTlsEnabled; break; |
|
1499 case CSuplSettingsInternal::EPskTlsUsed: |
|
1500 OtherProperty = OtherProperty & ~KPskTlsUsed; break; |
|
1501 case CSuplSettingsInternal::EServerEnabled: |
|
1502 OtherProperty = OtherProperty & ~KServerEnabled; break; |
|
1503 |
|
1504 case CSuplSettingsInternal::ESimChangeRemove: |
|
1505 OtherProperty = OtherProperty & ~KSimChangeRemove; break; |
|
1506 case CSuplSettingsInternal::EUsageInHomeNw: |
|
1507 OtherProperty = OtherProperty & ~KUsageInHomeNw; break; |
|
1508 case CSuplSettingsInternal::EEditable: |
|
1509 OtherProperty = OtherProperty & ~KEditable; break; |
|
1510 default:User::Leave(KErrArgument); |
|
1511 } |
|
1512 } |
|
1513 stmt.Close(); |
|
1514 return OtherProperty; |
|
1515 } |
|
1516 // --------------------------------------------------------------------------- |
|
1517 // CSettingsDatabaseHandler::GetOtherPropertiesL() |
|
1518 // |
|
1519 // This method is used to get other flags associated with a slp |
|
1520 // --------------------------------------------------------------------------- |
|
1521 void CSettingsDatabaseHandler::GetOtherPropertiesL(TInt64 aSLPId,CSuplSettingsInternal::TServerParam aParameter,TInt& aValue) |
|
1522 { |
|
1523 if(!IsSlpExists(aSLPId)) |
|
1524 User::Leave(KErrArgument); |
|
1525 TInt OtherProperty = 0; |
|
1526 |
|
1527 iSQLString.Copy(KSelect); |
|
1528 iSQLString.Append(KColOtherProperties); |
|
1529 iSQLString.Append(KFrom); |
|
1530 iSQLString.Append(KCreateTableName); |
|
1531 iSQLString.Append(KWhere); |
|
1532 iSQLString.Append(KColSLPId); |
|
1533 iSQLString.Append(KEquals); |
|
1534 iSQLString.AppendNum(aSLPId); |
|
1535 |
|
1536 RSqlStatement stmt; |
|
1537 TInt err = stmt.Prepare(iDb, iSQLString); |
|
1538 if(err != KErrNone) |
|
1539 User::Leave(KErrGeneral); |
|
1540 TInt columnIndex0=0; |
|
1541 while((err=stmt.Next())==KSqlAtRow) |
|
1542 { |
|
1543 OtherProperty = stmt.ColumnInt(columnIndex0); |
|
1544 } |
|
1545 |
|
1546 switch(aParameter) |
|
1547 { |
|
1548 case CSuplSettingsInternal::EEmergencySupport: |
|
1549 OtherProperty = OtherProperty & KEmergencySupport; break; |
|
1550 case CSuplSettingsInternal::ETlsEnabled: |
|
1551 OtherProperty = OtherProperty & KTlsEnabled; break; |
|
1552 case CSuplSettingsInternal::EPskTlsUsed: |
|
1553 OtherProperty = OtherProperty & KPskTlsUsed; break; |
|
1554 case CSuplSettingsInternal::EServerEnabled: |
|
1555 OtherProperty = OtherProperty & KServerEnabled; break; |
|
1556 case CSuplSettingsInternal::ESimChangeRemove: |
|
1557 OtherProperty = OtherProperty & KSimChangeRemove; break; |
|
1558 case CSuplSettingsInternal::EUsageInHomeNw: |
|
1559 OtherProperty = OtherProperty & KUsageInHomeNw; break; |
|
1560 case CSuplSettingsInternal::EEditable: |
|
1561 OtherProperty = OtherProperty & KEditable; break; |
|
1562 default: |
|
1563 User::Leave(KErrArgument);break; |
|
1564 } |
|
1565 if(OtherProperty > 0) |
|
1566 { |
|
1567 aValue = ETrue; |
|
1568 } |
|
1569 else |
|
1570 aValue = EFalse; |
|
1571 |
|
1572 stmt.Close(); |
|
1573 } |
|
1574 // --------------------------------------------------------------------------- |
|
1575 // CSettingsDatabaseHandler::GetOtherPropertyValue() |
|
1576 // |
|
1577 // Used to retrieve other parameters associated with a slp |
|
1578 // --------------------------------------------------------------------------- |
|
1579 TInt CSettingsDatabaseHandler::GetOtherPropertyValue(TInt64 aSLPId,TInt& aOtherPropertyValue) |
|
1580 { |
|
1581 |
|
1582 TInt OtherProperty = 0; |
|
1583 |
|
1584 |
|
1585 iSQLString.Copy(KSelect); |
|
1586 iSQLString.Append(KColOtherProperties); |
|
1587 iSQLString.Append(KFrom); |
|
1588 iSQLString.Append(KCreateTableName); |
|
1589 iSQLString.Append(KWhere); |
|
1590 iSQLString.Append(KColSLPId); |
|
1591 iSQLString.Append(KEquals); |
|
1592 iSQLString.AppendNum(aSLPId); |
|
1593 |
|
1594 RSqlStatement stmt; |
|
1595 TInt err = stmt.Prepare(iDb, iSQLString); |
|
1596 if(err != KErrNone) |
|
1597 return KErrGeneral; |
|
1598 TInt columnIndex0=0; |
|
1599 while((err=stmt.Next())==KSqlAtRow) |
|
1600 { |
|
1601 OtherProperty = stmt.ColumnInt(columnIndex0); |
|
1602 } |
|
1603 |
|
1604 aOtherPropertyValue = OtherProperty; |
|
1605 stmt.Close(); |
|
1606 return KErrNone; |
|
1607 } |
|
1608 // --------------------------------------------------------------------------- |
|
1609 // CSettingsDatabaseHandler::GetLastInsertedSLPID() |
|
1610 // |
|
1611 // Returns the last inserted slp id |
|
1612 // --------------------------------------------------------------------------- |
|
1613 TInt64 CSettingsDatabaseHandler::GetLastInsertedSLPID() |
|
1614 { |
|
1615 |
|
1616 iSQLString.Copy(KSelect); |
|
1617 iSQLString.Append(KMax); |
|
1618 iSQLString.Append(KOpeningBracket); |
|
1619 iSQLString.Append(KColSLPId); |
|
1620 iSQLString.Append(KClosingBracket); |
|
1621 iSQLString.Append(KFrom); |
|
1622 iSQLString.Append(KCreateTableName); |
|
1623 |
|
1624 RSqlStatement stmt; |
|
1625 TInt err = stmt.Prepare(iDb, iSQLString); |
|
1626 if(err != KErrNone) |
|
1627 return KErrGeneral; |
|
1628 TInt64 SLPId = -1; |
|
1629 TInt columnIndex0 = 0; |
|
1630 |
|
1631 while((err=stmt.Next())==KSqlAtRow) |
|
1632 { |
|
1633 SLPId = stmt.ColumnInt(columnIndex0); |
|
1634 } |
|
1635 |
|
1636 PrintErrorMessage(iSQLString,err,-1); |
|
1637 |
|
1638 LogQuery(iSQLString); |
|
1639 |
|
1640 TBuf<KShortStringLen> buf(_L("Last SLP ID... ")); |
|
1641 buf.AppendNum(SLPId); |
|
1642 LogQuery(buf); |
|
1643 stmt.Close(); |
|
1644 return SLPId; |
|
1645 } |
|
1646 |
|
1647 // --------------------------------------------------------------------------- |
|
1648 // CSettingsDatabaseHandler::GetAllSLP() |
|
1649 // |
|
1650 // Returns a list of all SLPs in the order of priority |
|
1651 // --------------------------------------------------------------------------- |
|
1652 void CSettingsDatabaseHandler::GetAllSLPL(RPointerArray<CServerParams>& aParamValues) |
|
1653 { |
|
1654 TInt count = 0; |
|
1655 SlpCount(count); |
|
1656 if(count<= 0) |
|
1657 User::Leave(KErrNotFound); |
|
1658 |
|
1659 |
|
1660 iSQLString.Copy(KSelect); |
|
1661 iSQLString.Append(KStar); |
|
1662 iSQLString.Append(KFrom); |
|
1663 iSQLString.Append(KCreateTableName); // retrieve list of all SLPs in order of priority |
|
1664 iSQLString.Append(KOrderBy); |
|
1665 iSQLString.Append(KColPriority); |
|
1666 iSQLString.Append(KCommaSeparator); |
|
1667 iSQLString.Append(KColSLPId); |
|
1668 RSqlStatement stmt; |
|
1669 TInt err = stmt.Prepare(iDb, iSQLString); |
|
1670 PrintErrorMessage(iSQLString,err,13); |
|
1671 if(err != KErrNone) |
|
1672 User::Leave(KErrGeneral); |
|
1673 TInt64 SLPId = -1; |
|
1674 TBuf<KGenericStringLen> ServerAddress,Iap; |
|
1675 |
|
1676 TInt otherprops; |
|
1677 TBuf<KShortStringLen> otherpropbuf; |
|
1678 |
|
1679 |
|
1680 TBool serverEnabled = EFalse; |
|
1681 TBool simChangeRemove = EFalse; |
|
1682 TBool usageInHomeNw = EFalse; |
|
1683 TBool editable = EFalse; |
|
1684 |
|
1685 |
|
1686 TInt columnIndexSLPID = stmt.ColumnIndex(KColSLPId); |
|
1687 TInt columnIndexSLPAddress = stmt.ColumnIndex(KColSLPAddress); |
|
1688 TInt columnIndexIAP = stmt.ColumnIndex(KColIap); |
|
1689 TInt columnIndexOtherProperties = stmt.ColumnIndex(KColOtherProperties); |
|
1690 |
|
1691 while((err=stmt.Next())==KSqlAtRow) |
|
1692 { |
|
1693 CServerParams *params = CServerParams::NewL(); |
|
1694 SLPId = stmt.ColumnInt(columnIndexSLPID); |
|
1695 stmt.ColumnText(columnIndexSLPAddress,ServerAddress); |
|
1696 |
|
1697 stmt.ColumnText(columnIndexIAP,Iap); |
|
1698 otherprops = stmt.ColumnInt(columnIndexOtherProperties); |
|
1699 otherpropbuf.Zero(); |
|
1700 otherpropbuf.AppendNum(otherprops); |
|
1701 LogQuery(ServerAddress); |
|
1702 LogQuery(Iap); |
|
1703 LogQuery(otherpropbuf); |
|
1704 serverEnabled = otherprops & KServerEnabled; |
|
1705 simChangeRemove = otherprops & KSimChangeRemove; |
|
1706 usageInHomeNw = otherprops & KUsageInHomeNw; |
|
1707 editable = otherprops & KEditable; |
|
1708 params->Set(ServerAddress,Iap,serverEnabled,simChangeRemove,usageInHomeNw,editable,SLPId); |
|
1709 aParamValues.Append(params);//ownership transferred to RPointerArray |
|
1710 } |
|
1711 |
|
1712 stmt.Close(); |
|
1713 LogAllSLP(); |
|
1714 } |
|
1715 // --------------------------------------------------------------------------- |
|
1716 // CSettingsDatabaseHandler::GetAllSLP() |
|
1717 // |
|
1718 // --------------------------------------------------------------------------- |
|
1719 void CSettingsDatabaseHandler::GetAllSLPL(RPointerArray<CServerParams>& aParamValues,TRequestStatus& aStatus) |
|
1720 { |
|
1721 iStatus = &aStatus; |
|
1722 TInt count; |
|
1723 SlpCount(count); |
|
1724 if(count<= 0) |
|
1725 User::RequestComplete(iStatus,KErrNotFound); |
|
1726 |
|
1727 iSQLString.Copy(KSelect); |
|
1728 iSQLString.Append(KStar); |
|
1729 iSQLString.Append(KFrom); |
|
1730 iSQLString.Append(KCreateTableName); // retrieve list of all SLPs |
|
1731 iSQLString.Append(KOrderBy); |
|
1732 iSQLString.Append(KColPriority); |
|
1733 iSQLString.Append(KCommaSeparator); |
|
1734 iSQLString.Append(KColSLPId); |
|
1735 RSqlStatement stmt; |
|
1736 TInt err = stmt.Prepare(iDb, iSQLString); |
|
1737 PrintErrorMessage(iSQLString,err,13); |
|
1738 if(err != KErrNone) |
|
1739 User::RequestComplete(iStatus,KErrGeneral); |
|
1740 |
|
1741 TInt64 SLPId = -1; |
|
1742 TBuf<KGenericStringLen> ServerAddress,Iap; |
|
1743 |
|
1744 TInt otherprops; |
|
1745 TBuf<KShortStringLen> otherpropbuf; |
|
1746 |
|
1747 |
|
1748 TBool serverEnabled = EFalse; |
|
1749 TBool simChangeRemove = EFalse; |
|
1750 TBool usageInHomeNw = EFalse; |
|
1751 TBool editable = EFalse; |
|
1752 |
|
1753 |
|
1754 TInt columnIndexSLPID = stmt.ColumnIndex(KColSLPId); |
|
1755 TInt columnIndexSLPAddress = stmt.ColumnIndex(KColSLPAddress); |
|
1756 TInt columnIndexIAP = stmt.ColumnIndex(KColIap); |
|
1757 TInt columnIndexOtherProperties = stmt.ColumnIndex(KColOtherProperties); |
|
1758 |
|
1759 while((err=stmt.Next())==KSqlAtRow) |
|
1760 { |
|
1761 CServerParams *params = CServerParams::NewL(); |
|
1762 SLPId = stmt.ColumnInt(columnIndexSLPID); |
|
1763 stmt.ColumnText(columnIndexSLPAddress,ServerAddress); |
|
1764 |
|
1765 stmt.ColumnText(columnIndexIAP,Iap); |
|
1766 otherprops = stmt.ColumnInt(columnIndexOtherProperties); |
|
1767 otherpropbuf.Zero(); |
|
1768 otherpropbuf.AppendNum(otherprops); |
|
1769 LogQuery(ServerAddress); |
|
1770 LogQuery(Iap); |
|
1771 LogQuery(otherpropbuf); |
|
1772 serverEnabled = otherprops & KServerEnabled; |
|
1773 simChangeRemove = otherprops & KSimChangeRemove; |
|
1774 usageInHomeNw = otherprops & KUsageInHomeNw; |
|
1775 editable = otherprops & KEditable; |
|
1776 params->Set(ServerAddress,Iap,serverEnabled,simChangeRemove,usageInHomeNw,editable,SLPId); |
|
1777 aParamValues.Append(params);//ownership transferred to RPointerArray |
|
1778 } |
|
1779 |
|
1780 stmt.Close(); |
|
1781 LogAllSLP(); |
|
1782 User::RequestComplete(iStatus,KErrNone); |
|
1783 } |
|
1784 |
|
1785 // --------------------------------------------------------------------------- |
|
1786 // CSettingsDatabaseHandler::GetServerAddress() |
|
1787 // |
|
1788 // This method is used to retrieve server address for a slp of a particular id |
|
1789 // --------------------------------------------------------------------------- |
|
1790 TInt CSettingsDatabaseHandler::GetServerAddress(const TInt64 aSlpId, TDes& aServerAddress) |
|
1791 { |
|
1792 if(!IsSlpExists(aSlpId)) |
|
1793 return KErrArgument; |
|
1794 TBuf<KGenericStringLen> serveraddress; |
|
1795 |
|
1796 iSQLString.Copy(KSelect); |
|
1797 iSQLString.Append(KColSLPAddress); |
|
1798 iSQLString.Append(KFrom); |
|
1799 iSQLString.Append(KCreateTableName); |
|
1800 iSQLString.Append(KWhere); |
|
1801 iSQLString.Append(KColSLPId); |
|
1802 iSQLString.Append(KEquals); |
|
1803 iSQLString.Append(KQuotes); |
|
1804 iSQLString.AppendNum(aSlpId); |
|
1805 iSQLString.Append(KQuotes); |
|
1806 |
|
1807 RSqlStatement stmt; |
|
1808 TInt err = stmt.Prepare(iDb,iSQLString); |
|
1809 PrintErrorMessage(iSQLString,err,13); |
|
1810 if(err != KErrNone) |
|
1811 return KErrGeneral; |
|
1812 |
|
1813 TInt columnIndexSLPName = stmt.ColumnIndex(KColSLPAddress); |
|
1814 aServerAddress.Zero(); |
|
1815 |
|
1816 while((err=stmt.Next())==KSqlAtRow) |
|
1817 { |
|
1818 stmt.ColumnText(columnIndexSLPName,serveraddress); |
|
1819 } |
|
1820 |
|
1821 stmt.Close(); |
|
1822 if(aServerAddress.MaxLength() < serveraddress.Length()) |
|
1823 return KErrOverflow; |
|
1824 aServerAddress = serveraddress; |
|
1825 return KErrNone; |
|
1826 } |
|
1827 // ------------------------------------------------------------------------------- |
|
1828 // CSettingsDatabaseHandler::GetLastTriedTime() |
|
1829 // |
|
1830 // This method is to last tried time of a SLP corresponding to a particular Slp Id |
|
1831 // -------------------------------------------------------------------------------- |
|
1832 TInt CSettingsDatabaseHandler::GetLastTriedTime(const TInt64 aSlpId, TTime& aLastTriedTime) |
|
1833 { |
|
1834 if(!IsSlpExists(aSlpId)) |
|
1835 return KErrNotFound; |
|
1836 |
|
1837 iSQLString.Copy(KSelect); |
|
1838 iSQLString.Append(KColTimeLastTried); |
|
1839 iSQLString.Append(KFrom); |
|
1840 iSQLString.Append(KCreateTableName); |
|
1841 iSQLString.Append(KWhere); |
|
1842 iSQLString.Append(KColSLPId); |
|
1843 iSQLString.Append(KEquals); |
|
1844 iSQLString.Append(KQuotes); |
|
1845 iSQLString.AppendNum(aSlpId); |
|
1846 iSQLString.Append(KQuotes); |
|
1847 |
|
1848 TBuf<KGenericStringLen> timeString; |
|
1849 RSqlStatement stmt; |
|
1850 TInt err = stmt.Prepare(iDb,iSQLString); |
|
1851 PrintErrorMessage(iSQLString,err,13); |
|
1852 if(err != KErrNone) |
|
1853 return KErrGeneral; |
|
1854 |
|
1855 TInt columnIndexSLPName = stmt.ColumnIndex(KColTimeLastTried); |
|
1856 |
|
1857 while((err=stmt.Next())==KSqlAtRow) |
|
1858 { |
|
1859 stmt.ColumnText(columnIndexSLPName,timeString); |
|
1860 } |
|
1861 aLastTriedTime.Parse(timeString); |
|
1862 stmt.Close(); |
|
1863 |
|
1864 return KErrNone; |
|
1865 } |
|
1866 // ------------------------------------------------------------------------------ |
|
1867 // CSettingsDatabaseHandler::GetLastUsedTime() |
|
1868 // |
|
1869 // This method is to last used time of a SLP corresponding to a particular Slp Id |
|
1870 // ------------------------------------------------------------------------------ |
|
1871 TInt CSettingsDatabaseHandler::GetLastUsedTime(const TInt64 aSlpId, TTime& aLastUsedTime) |
|
1872 { |
|
1873 if(!IsSlpExists(aSlpId)) |
|
1874 return KErrArgument; |
|
1875 |
|
1876 iSQLString.Copy(KSelect); |
|
1877 iSQLString.Append(KColTimeLastUse); |
|
1878 iSQLString.Append(KFrom); |
|
1879 iSQLString.Append(KCreateTableName); |
|
1880 iSQLString.Append(KWhere); |
|
1881 iSQLString.Append(KColSLPId); |
|
1882 iSQLString.Append(KEquals); |
|
1883 iSQLString.Append(KQuotes); |
|
1884 iSQLString.AppendNum(aSlpId); |
|
1885 iSQLString.Append(KQuotes); |
|
1886 |
|
1887 TBuf<KGenericStringLen> timeString; |
|
1888 |
|
1889 RSqlStatement stmt; |
|
1890 TInt err = stmt.Prepare(iDb,iSQLString); |
|
1891 PrintErrorMessage(iSQLString,err,13); |
|
1892 if(err != KErrNone) |
|
1893 return KErrGeneral; |
|
1894 |
|
1895 TInt columnIndexSLPName = stmt.ColumnIndex(KColTimeLastUse); |
|
1896 |
|
1897 while((err=stmt.Next())==KSqlAtRow) |
|
1898 { |
|
1899 stmt.ColumnText(columnIndexSLPName,timeString); |
|
1900 } |
|
1901 aLastUsedTime.Parse(timeString); |
|
1902 stmt.Close(); |
|
1903 |
|
1904 return KErrNone; |
|
1905 } |
|
1906 // ------------------------------------------------------------------------------------- |
|
1907 // CSettingsDatabaseHandler::GetManufacturer() |
|
1908 // |
|
1909 // This method is to Get manufacturer name of a SLP corresponding to a particular Slp Id |
|
1910 // -------------------------------------------------------------------------------------- |
|
1911 TInt CSettingsDatabaseHandler::GetManufacturer(const TInt64 aSlpId, TDes& aManuName) |
|
1912 { |
|
1913 if(!IsSlpExists(aSlpId)) |
|
1914 return KErrArgument; |
|
1915 TBuf<KGenericStringLen> manuname; |
|
1916 |
|
1917 iSQLString.Copy(KSelect); |
|
1918 iSQLString.Append(KColManuName); |
|
1919 iSQLString.Append(KFrom); |
|
1920 iSQLString.Append(KCreateTableName); |
|
1921 iSQLString.Append(KWhere); |
|
1922 iSQLString.Append(KColSLPId); |
|
1923 iSQLString.Append(KEquals); |
|
1924 iSQLString.Append(KQuotes); |
|
1925 iSQLString.AppendNum(aSlpId); |
|
1926 iSQLString.Append(KQuotes); |
|
1927 |
|
1928 RSqlStatement stmt; |
|
1929 TInt err = stmt.Prepare(iDb,iSQLString); |
|
1930 PrintErrorMessage(iSQLString,err,13); |
|
1931 if(err != KErrNone) |
|
1932 return KErrGeneral; |
|
1933 |
|
1934 TInt columnIndexSLPName = stmt.ColumnIndex(KColManuName); |
|
1935 aManuName.Zero(); |
|
1936 |
|
1937 while((err=stmt.Next())==KSqlAtRow) |
|
1938 { |
|
1939 stmt.ColumnText(columnIndexSLPName,manuname); |
|
1940 } |
|
1941 |
|
1942 stmt.Close(); |
|
1943 |
|
1944 if(aManuName.MaxLength() < manuname.Length()) |
|
1945 return KErrOverflow; |
|
1946 aManuName = manuname; |
|
1947 return KErrNone; |
|
1948 } |
|
1949 // --------------------------------------------------------------------------- |
|
1950 // CSettingsDatabaseHandler::GetIAPName() |
|
1951 // |
|
1952 // This method is to Get IAP name of a SLP corresponding to a particular Slp Id |
|
1953 // --------------------------------------------------------------------------- |
|
1954 TInt CSettingsDatabaseHandler::GetIAPName(const TInt64 aSlpId, TDes& aIAPName) |
|
1955 { |
|
1956 if(!IsSlpExists(aSlpId)) |
|
1957 return KErrArgument; |
|
1958 TBuf<KGenericStringLen> iapname; |
|
1959 |
|
1960 iSQLString.Copy(KSelect); |
|
1961 iSQLString.Append(KColIap); |
|
1962 iSQLString.Append(KFrom); |
|
1963 iSQLString.Append(KCreateTableName); |
|
1964 iSQLString.Append(KWhere); |
|
1965 iSQLString.Append(KColSLPId); |
|
1966 iSQLString.Append(KEquals); |
|
1967 iSQLString.Append(KQuotes); |
|
1968 iSQLString.AppendNum(aSlpId); |
|
1969 iSQLString.Append(KQuotes); |
|
1970 |
|
1971 RSqlStatement stmt; |
|
1972 TInt err = stmt.Prepare(iDb,iSQLString); |
|
1973 PrintErrorMessage(iSQLString,err,13); |
|
1974 if(err != KErrNone) |
|
1975 return KErrGeneral; |
|
1976 |
|
1977 TInt columnIndexSLPName = stmt.ColumnIndex(KColIap); |
|
1978 aIAPName.Zero(); |
|
1979 while((err=stmt.Next())==KSqlAtRow) |
|
1980 { |
|
1981 stmt.ColumnText(columnIndexSLPName,iapname); |
|
1982 } |
|
1983 |
|
1984 stmt.Close(); |
|
1985 if(aIAPName.MaxLength() < iapname.Length()) |
|
1986 return KErrOverflow; |
|
1987 aIAPName = iapname; |
|
1988 return KErrNone; |
|
1989 } |
|
1990 // ------------------------------------------------------------------------------------ |
|
1991 // CSettingsDatabaseHandler::GetVersion() |
|
1992 // |
|
1993 // This method is to Get Protocol Version of a SLP corresponding to a particular Slp Id |
|
1994 // ------------------------------------------------------------------------------------ |
|
1995 TInt CSettingsDatabaseHandler::GetVersion(const TInt64 aSlpId,TInt& aMajor, TInt& aMinor) |
|
1996 { |
|
1997 if(!IsSlpExists(aSlpId)) |
|
1998 return KErrArgument; |
|
1999 |
|
2000 iSQLString.Copy(KSelect); |
|
2001 iSQLString.Append(KColProtocolVersionMajor); |
|
2002 iSQLString.Append(KFrom); |
|
2003 iSQLString.Append(KCreateTableName); |
|
2004 iSQLString.Append(KWhere); |
|
2005 iSQLString.Append(KColSLPId); |
|
2006 iSQLString.Append(KEquals); |
|
2007 iSQLString.Append(KQuotes); |
|
2008 iSQLString.AppendNum(aSlpId); |
|
2009 iSQLString.Append(KQuotes); |
|
2010 |
|
2011 RSqlStatement stmt; |
|
2012 TInt err = stmt.Prepare(iDb,iSQLString); |
|
2013 PrintErrorMessage(iSQLString,err,13); |
|
2014 |
|
2015 TInt columnIndexVersion = stmt.ColumnIndex(KColProtocolVersionMajor); |
|
2016 TInt protocolVersion = 0; |
|
2017 while((err=stmt.Next())==KSqlAtRow) |
|
2018 { |
|
2019 protocolVersion = stmt.ColumnInt(columnIndexVersion); |
|
2020 } |
|
2021 |
|
2022 stmt.Close(); |
|
2023 aMajor = protocolVersion >> KVersionMajorMask; |
|
2024 aMinor = protocolVersion & KVersionMinorMask; |
|
2025 return KErrNone; |
|
2026 } |
|
2027 // ------------------------------------------------------------------------------------- |
|
2028 // CSettingsDatabaseHandler::GetSlpInfoFromId() |
|
2029 // |
|
2030 // This method is retrieve all configurable parameters corresponding to a particular SLP |
|
2031 // ------------------------------------------------------------------------------------- |
|
2032 TInt CSettingsDatabaseHandler::GetSlpInfoFromId(const TInt64 aSlpId,CServerParams* aParamValues) |
|
2033 { |
|
2034 if(!IsSlpExists(aSlpId)) |
|
2035 return KErrNotFound; |
|
2036 |
|
2037 iSQLString.Copy(KSelect); |
|
2038 iSQLString.Append(KStar); |
|
2039 iSQLString.Append(KFrom); |
|
2040 iSQLString.Append(KCreateTableName); |
|
2041 iSQLString.Append(KWhere); |
|
2042 iSQLString.Append(KColSLPId); |
|
2043 iSQLString.Append(KEquals); |
|
2044 iSQLString.Append(KQuotes); |
|
2045 iSQLString.AppendNum(aSlpId); |
|
2046 iSQLString.Append(KQuotes); |
|
2047 |
|
2048 RSqlStatement stmt; |
|
2049 TInt err = stmt.Prepare(iDb, iSQLString); |
|
2050 PrintErrorMessage(iSQLString,err,13); |
|
2051 if(err != KErrNone) |
|
2052 return KErrGeneral; |
|
2053 |
|
2054 TInt64 SLPId = -1; |
|
2055 TBuf<KMaxHSLPAddrLen> serverAddress; |
|
2056 TBuf<KMaxIAPLen> Iap; |
|
2057 TInt otherprops; |
|
2058 TBuf<KShortStringLen> otherpropbuf; |
|
2059 |
|
2060 |
|
2061 TBool serverEnabled = EFalse; |
|
2062 TBool simChangeRemove = EFalse; |
|
2063 TBool usageInHomeNw = EFalse; |
|
2064 TBool editable = EFalse; |
|
2065 |
|
2066 TInt columnIndexSLPID = stmt.ColumnIndex(KColSLPId); |
|
2067 TInt columnIndexSLPAddress = stmt.ColumnIndex(KColSLPAddress); |
|
2068 |
|
2069 TInt columnIndexIAP = stmt.ColumnIndex(KColIap); |
|
2070 |
|
2071 TInt columnIndexOtherProperties = stmt.ColumnIndex(KColOtherProperties); |
|
2072 |
|
2073 while((err=stmt.Next())==KSqlAtRow) |
|
2074 { |
|
2075 SLPId = stmt.ColumnInt(columnIndexSLPID); |
|
2076 stmt.ColumnText(columnIndexSLPAddress,serverAddress); |
|
2077 stmt.ColumnText(columnIndexIAP,Iap); |
|
2078 |
|
2079 otherprops = stmt.ColumnInt(columnIndexOtherProperties); |
|
2080 |
|
2081 |
|
2082 serverEnabled = otherprops & KServerEnabled; |
|
2083 simChangeRemove = otherprops & KSimChangeRemove; |
|
2084 usageInHomeNw = otherprops & KUsageInHomeNw; |
|
2085 editable = otherprops & KEditable; |
|
2086 //logging |
|
2087 otherpropbuf.Zero(); |
|
2088 otherpropbuf.AppendNum(otherprops); |
|
2089 LogQuery(serverAddress); |
|
2090 LogQuery(Iap) ; |
|
2091 LogQuery(otherpropbuf); |
|
2092 } |
|
2093 |
|
2094 stmt.Close(); |
|
2095 |
|
2096 aParamValues->Set(serverAddress,Iap,serverEnabled,simChangeRemove,usageInHomeNw,editable,SLPId); |
|
2097 return KErrNone; |
|
2098 } |
|
2099 // -------------------------------------------------------------------------------------- |
|
2100 // CSettingsDatabaseHandler::GetSlpInfoFromAddress() |
|
2101 // |
|
2102 // This method is retrieve all configurable parameters corresponding to a particular SLP |
|
2103 // -------------------------------------------------------------------------------------- |
|
2104 TInt CSettingsDatabaseHandler::GetSlpInfoFromAddress(const TDesC& aServerAddress,CServerParams* aParamValues) |
|
2105 { |
|
2106 |
|
2107 TBuf<KGenericStringLen> tempBuf; |
|
2108 tempBuf.Copy(aServerAddress); |
|
2109 tempBuf.Trim(); |
|
2110 iSQLString.Copy(KSelect); |
|
2111 iSQLString.Append(KStar); |
|
2112 iSQLString.Append(KFrom); |
|
2113 iSQLString.Append(KCreateTableName); |
|
2114 iSQLString.Append(KWhere); |
|
2115 iSQLString.Append(KColSLPAddress); |
|
2116 iSQLString.Append(KEquals); |
|
2117 iSQLString.Append(KQuotes); |
|
2118 iSQLString.Append(tempBuf); |
|
2119 iSQLString.Append(KQuotes); |
|
2120 iSQLString.Append(KCaseInsensitive); |
|
2121 |
|
2122 RSqlStatement stmt; |
|
2123 TInt err = stmt.Prepare(iDb, iSQLString); |
|
2124 PrintErrorMessage(iSQLString,err,13); |
|
2125 if(err != KErrNone) |
|
2126 return KErrGeneral; |
|
2127 |
|
2128 TInt64 SLPId = -1; |
|
2129 TBuf<KMaxHSLPAddrLen> serverAddress; |
|
2130 TBuf<KMaxIAPLen> Iap; |
|
2131 |
|
2132 TInt otherprops; |
|
2133 TBuf<KShortStringLen> otherpropbuf; |
|
2134 |
|
2135 TBool serverEnabled = EFalse; |
|
2136 TBool simChangeRemove = EFalse; |
|
2137 TBool usageInHomeNw = EFalse; |
|
2138 TBool editable = EFalse; |
|
2139 |
|
2140 TInt columnIndexSLPID = stmt.ColumnIndex(KColSLPId); |
|
2141 TInt columnIndexSLPAddress = stmt.ColumnIndex(KColSLPAddress); |
|
2142 |
|
2143 TInt columnIndexIAP = stmt.ColumnIndex(KColIap); |
|
2144 TInt columnIndexOtherProperties = stmt.ColumnIndex(KColOtherProperties); |
|
2145 |
|
2146 while((err=stmt.Next())==KSqlAtRow) |
|
2147 { |
|
2148 SLPId = stmt.ColumnInt(columnIndexSLPID); |
|
2149 stmt.ColumnText(columnIndexSLPAddress,serverAddress); |
|
2150 |
|
2151 stmt.ColumnText(columnIndexIAP,Iap); |
|
2152 |
|
2153 otherprops = stmt.ColumnInt(columnIndexOtherProperties); |
|
2154 |
|
2155 |
|
2156 serverEnabled = otherprops & KServerEnabled; |
|
2157 simChangeRemove = otherprops & KSimChangeRemove; |
|
2158 usageInHomeNw = otherprops & KUsageInHomeNw; |
|
2159 editable = otherprops & KEditable; |
|
2160 //logging |
|
2161 otherpropbuf.Zero(); |
|
2162 otherpropbuf.AppendNum(otherprops); |
|
2163 LogQuery(serverAddress); |
|
2164 LogQuery(Iap); |
|
2165 |
|
2166 LogQuery(otherpropbuf); |
|
2167 } |
|
2168 |
|
2169 stmt.Close(); |
|
2170 |
|
2171 if(SLPId == -1)//we did not find any server by the slp id that was requested for |
|
2172 return KErrNotFound; |
|
2173 |
|
2174 aParamValues->Set(serverAddress,Iap,serverEnabled,simChangeRemove,usageInHomeNw,editable,SLPId); |
|
2175 return KErrNone; |
|
2176 } |
|
2177 // ------------------------------------------------------------------------------------ |
|
2178 // CSettingsDatabaseHandler::GetDefaultServer() |
|
2179 // |
|
2180 // This method is retrieve all configurable parameters corresponding to the default SLP |
|
2181 // ----------------------------------------------------------------------------------- |
|
2182 TInt CSettingsDatabaseHandler::GetDefaultServer(CServerParams* aParamValues) |
|
2183 { |
|
2184 |
|
2185 iSQLString.Copy(KSelect); |
|
2186 iSQLString.Append(KStar); |
|
2187 iSQLString.Append(KFrom); |
|
2188 iSQLString.Append(KCreateTableName); |
|
2189 iSQLString.Append(KOrderBy); |
|
2190 iSQLString.Append(KColPriority); |
|
2191 iSQLString.Append(KCommaSeparator); |
|
2192 iSQLString.Append(KColSLPId); |
|
2193 |
|
2194 RSqlStatement stmt; |
|
2195 TInt err = stmt.Prepare(iDb, iSQLString); |
|
2196 PrintErrorMessage(iSQLString,err,13); |
|
2197 if(err != KErrNone) |
|
2198 return KErrGeneral; |
|
2199 TInt64 SLPId = -1; |
|
2200 TBuf<KMaxHSLPAddrLen> serverAddress; |
|
2201 TBuf<KMaxIAPLen> Iap; |
|
2202 TInt otherprops; |
|
2203 TBuf<KShortStringLen> otherpropbuf; //for logging |
|
2204 |
|
2205 |
|
2206 |
|
2207 TBool serverEnabled = EFalse; |
|
2208 TBool simChangeRemove = EFalse; |
|
2209 TBool usageInHomeNw = EFalse; |
|
2210 TBool editable = EFalse; |
|
2211 |
|
2212 TInt columnIndexSLPID = stmt.ColumnIndex(KColSLPId); |
|
2213 TInt columnIndexSLPAddress = stmt.ColumnIndex(KColSLPAddress); |
|
2214 TInt columnIndexIAP = stmt.ColumnIndex(KColIap); |
|
2215 TInt columnIndexOtherProperties = stmt.ColumnIndex(KColOtherProperties); |
|
2216 |
|
2217 while((err=stmt.Next())==KSqlAtRow) |
|
2218 { |
|
2219 SLPId = stmt.ColumnInt(columnIndexSLPID); |
|
2220 stmt.ColumnText(columnIndexSLPAddress,serverAddress); |
|
2221 |
|
2222 stmt.ColumnText(columnIndexIAP,Iap); |
|
2223 otherprops = stmt.ColumnInt(columnIndexOtherProperties); |
|
2224 |
|
2225 serverEnabled = otherprops & KServerEnabled; |
|
2226 simChangeRemove = otherprops & KSimChangeRemove; |
|
2227 usageInHomeNw = otherprops & KUsageInHomeNw; |
|
2228 editable = otherprops & KEditable; |
|
2229 //logging |
|
2230 otherpropbuf.Zero(); |
|
2231 otherpropbuf.AppendNum(otherprops); |
|
2232 LogQuery(serverAddress); |
|
2233 LogQuery(Iap); |
|
2234 LogQuery(otherpropbuf); |
|
2235 break; //obtain only the first record as that would be the default server |
|
2236 } |
|
2237 if(SLPId == -1) // no record obtained so return error |
|
2238 { |
|
2239 PrintErrorMessage(_L(""),KErrNotFound,17); |
|
2240 return KErrNotFound; |
|
2241 } |
|
2242 stmt.Close(); |
|
2243 |
|
2244 aParamValues->Set(serverAddress,Iap,serverEnabled,simChangeRemove,usageInHomeNw,editable,SLPId); |
|
2245 return KErrNone; |
|
2246 } |
|
2247 // --------------------------------------------------------------------------- |
|
2248 // CSettingsDatabaseHandler::SlpCount() |
|
2249 // |
|
2250 // This method is retrieve the count of slp entries present |
|
2251 // --------------------------------------------------------------------------- |
|
2252 TInt CSettingsDatabaseHandler::SlpCount(TInt& aCount) |
|
2253 { |
|
2254 //Select all slps existing in the records |
|
2255 TBuf<KGenericStringLen> sqlString; |
|
2256 |
|
2257 sqlString.Copy(KSelect); |
|
2258 sqlString.Append(KCount); |
|
2259 sqlString.Append(KOpeningBracket); |
|
2260 sqlString.Append(KStar); |
|
2261 sqlString.Append(KClosingBracket); |
|
2262 sqlString.Append(KFrom); |
|
2263 sqlString.Append(KCreateTableName); |
|
2264 |
|
2265 |
|
2266 RSqlStatement stmt; |
|
2267 TInt err = stmt.Prepare(iDb, sqlString); |
|
2268 if(err != KErrNone) |
|
2269 return KErrGeneral; |
|
2270 TInt count = 0; |
|
2271 TInt columnIndex0 = 0; |
|
2272 while((err=stmt.Next())==KSqlAtRow) |
|
2273 { |
|
2274 count = stmt.ColumnInt(columnIndex0); //count number of rows |
|
2275 } |
|
2276 stmt.Close(); |
|
2277 PrintErrorMessage(_L(""),count,16); |
|
2278 if(count == 0 ) |
|
2279 { |
|
2280 return KErrNotFound; |
|
2281 } |
|
2282 aCount = count; |
|
2283 return KErrNone; |
|
2284 } |
|
2285 // --------------------------------------------------------------------------- |
|
2286 // CSettingsDatabaseHandler::IsSlpExists() |
|
2287 // |
|
2288 // This method is to check is a slp entry exists corresponding to a particular SLP Id |
|
2289 // --------------------------------------------------------------------------- |
|
2290 TBool CSettingsDatabaseHandler::IsSlpExists(const TInt64 aSlpId) |
|
2291 { |
|
2292 //Select all slps existing in the records corresponing to the Slp Id |
|
2293 TBuf<KGenericStringLen> sqlString; |
|
2294 sqlString.Copy(KSelect); |
|
2295 sqlString.Append(KCount); |
|
2296 sqlString.Append(KOpeningBracket); |
|
2297 sqlString.Append(KStar); |
|
2298 sqlString.Append(KClosingBracket); |
|
2299 sqlString.Append(KFrom); |
|
2300 sqlString.Append(KCreateTableName); |
|
2301 sqlString.Append(KWhere); |
|
2302 sqlString.Append(KColSLPId); |
|
2303 sqlString.Append(KEquals); |
|
2304 sqlString.Append(KQuotes); |
|
2305 sqlString.AppendNum(aSlpId); |
|
2306 sqlString.Append(KQuotes); |
|
2307 |
|
2308 |
|
2309 RSqlStatement stmt; |
|
2310 TInt err = stmt.Prepare(iDb, sqlString); |
|
2311 |
|
2312 TInt count = 0; |
|
2313 TInt columnIndex0 = 0; |
|
2314 while((err=stmt.Next())==KSqlAtRow) |
|
2315 { |
|
2316 count = stmt.ColumnInt(columnIndex0); //count number of rows |
|
2317 } |
|
2318 stmt.Close(); |
|
2319 if(count == 0) |
|
2320 { |
|
2321 PrintErrorMessage(_L(""),EFalse,15); |
|
2322 return EFalse; |
|
2323 } |
|
2324 PrintErrorMessage(_L(""),ETrue,15); |
|
2325 return ETrue; |
|
2326 } |
|
2327 // --------------------------------------------------------------------------- |
|
2328 // CSettingsDatabaseHandler::IsSlpExists() |
|
2329 // |
|
2330 // This method is to check is a slp entry exists corresponding to a particular |
|
2331 // SLP Address |
|
2332 // --------------------------------------------------------------------------- |
|
2333 TBool CSettingsDatabaseHandler::IsSlpExists(const TDesC& aServerAdress) |
|
2334 { |
|
2335 //Select all slps existing in the records corresponding to the Server Address |
|
2336 |
|
2337 TBuf<KGenericStringLen> tempBuf; |
|
2338 tempBuf.Copy(aServerAdress); |
|
2339 tempBuf.Trim(); |
|
2340 iSQLString.Copy(KSelect); |
|
2341 iSQLString.Append(KCount); |
|
2342 iSQLString.Append(KOpeningBracket); |
|
2343 iSQLString.Append(KStar); |
|
2344 iSQLString.Append(KClosingBracket); |
|
2345 iSQLString.Append(KFrom); |
|
2346 iSQLString.Append(KCreateTableName); |
|
2347 iSQLString.Append(KWhere); |
|
2348 iSQLString.Append(KColSLPAddress); |
|
2349 iSQLString.Append(KEquals); |
|
2350 iSQLString.Append(KQuotes); |
|
2351 iSQLString.Append(tempBuf); |
|
2352 iSQLString.Append(KQuotes); |
|
2353 iSQLString.Append(KCaseInsensitive); |
|
2354 |
|
2355 RSqlStatement stmt; |
|
2356 TInt err = stmt.Prepare(iDb, iSQLString); |
|
2357 |
|
2358 TInt count = 0; |
|
2359 TInt columnIndex0 = 0; |
|
2360 while((err=stmt.Next())==KSqlAtRow) |
|
2361 { |
|
2362 count = stmt.ColumnInt(columnIndex0); //count number of rows |
|
2363 } |
|
2364 stmt.Close(); |
|
2365 if(count == 0) |
|
2366 { |
|
2367 PrintErrorMessage(_L(""),EFalse,15); |
|
2368 return EFalse; |
|
2369 } |
|
2370 PrintErrorMessage(_L(""),ETrue,15); |
|
2371 return ETrue; |
|
2372 } |
|
2373 TBool CSettingsDatabaseHandler::IsSlpExists(const TDesC& aServerAddress,TInt64& aSlpId) |
|
2374 { |
|
2375 //Select all slps existing in the records corresponding to the Server Address |
|
2376 |
|
2377 iSQLString.Copy(KSelect); |
|
2378 iSQLString.Append(KColSLPId); |
|
2379 iSQLString.Append(KFrom); |
|
2380 iSQLString.Append(KCreateTableName); |
|
2381 iSQLString.Append(KWhere); |
|
2382 iSQLString.Append(KColSLPAddress); |
|
2383 iSQLString.Append(KEquals); |
|
2384 iSQLString.Append(KQuotes); |
|
2385 iSQLString.Append(aServerAddress); |
|
2386 iSQLString.Append(KQuotes); |
|
2387 iSQLString.Append(KCaseInsensitive); |
|
2388 |
|
2389 RSqlStatement stmt; |
|
2390 TInt err = stmt.Prepare(iDb, iSQLString); |
|
2391 aSlpId = -1; |
|
2392 TInt count = 0; // count the number of slps present in the records |
|
2393 TInt columnIndexSLPID = stmt.ColumnIndex(KColSLPId); |
|
2394 while((err=stmt.Next())==KSqlAtRow) |
|
2395 { |
|
2396 aSlpId = stmt.ColumnInt(columnIndexSLPID); |
|
2397 count++; |
|
2398 } |
|
2399 stmt.Close(); |
|
2400 if(count == 0) |
|
2401 { |
|
2402 PrintErrorMessage(_L(""),EFalse,15); |
|
2403 return EFalse; |
|
2404 } |
|
2405 PrintErrorMessage(_L(""),ETrue,15); |
|
2406 return ETrue; |
|
2407 } |
|
2408 // --------------------------------------------------------------------------- |
|
2409 // CSettingsDatabaseHandler::GetDefaultCRValues() |
|
2410 // |
|
2411 // This method is used to retrieve default settings value from the cen rep |
|
2412 // --------------------------------------------------------------------------- |
|
2413 TInt CSettingsDatabaseHandler::GetDefaultCRValues(TInt aKey,TInt& aValue) |
|
2414 { |
|
2415 TInt err; |
|
2416 |
|
2417 err = iSettingsRep->Get(aKey, aValue); |
|
2418 if (err != KErrNone) |
|
2419 return err; |
|
2420 return KErrNone; |
|
2421 } |
|
2422 // --------------------------------------------------------------------------- |
|
2423 // CSettingsDatabaseHandler::GetDBPathFromCR() |
|
2424 // |
|
2425 // This method is used to retrieve settings db path value from the cen rep |
|
2426 // --------------------------------------------------------------------------- |
|
2427 TInt CSettingsDatabaseHandler::GetDBPathFromCR(TDes& aPath) |
|
2428 { |
|
2429 TInt err; |
|
2430 |
|
2431 err = iSettingsNotifierRep->Get(KSuplSettigsDBPath, aPath); |
|
2432 if (err != KErrNone) |
|
2433 return err; |
|
2434 return KErrNone; |
|
2435 } |
|
2436 // --------------------------------------------------------------------------- |
|
2437 // CSettingsDatabaseHandler::StoreDBPathToCR() |
|
2438 // |
|
2439 // This method is used to store settings db path value to the cen rep |
|
2440 // --------------------------------------------------------------------------- |
|
2441 TInt CSettingsDatabaseHandler::StoreDBPathToCR(TDes& aPath) |
|
2442 { |
|
2443 TInt err; |
|
2444 err = iSettingsNotifierRep->Set(KSuplSettigsDBPath, aPath); |
|
2445 if (err != KErrNone) |
|
2446 return err; |
|
2447 return KErrNone; |
|
2448 } |
|
2449 |
|
2450 //----------------------------------------------------------------------------- |
|
2451 // CSettingsDatabaseHandler::NotifyDBChange() |
|
2452 // |
|
2453 // This method is used to notify that a change has occured in the DB via the CR |
|
2454 // ---------------------------------------------------------------------------- |
|
2455 TInt CSettingsDatabaseHandler::NotifyDBChange(MSuplSettingsObserver::TSuplSettingsEventType aChangedEventType,TInt64 aSlpId) |
|
2456 { |
|
2457 TInt err; |
|
2458 TReal idChanged = aSlpId; |
|
2459 err = iSettingsNotifierRep->Set(KSuplSettingsDBChangedSLPId,idChanged); |
|
2460 if(err != KErrNone) |
|
2461 return err; |
|
2462 TInt curEvent; |
|
2463 TInt keyValue; |
|
2464 err = iSettingsNotifierRep->Get(KSuplSettingsDBEvent,curEvent); |
|
2465 if(aChangedEventType == (MSuplSettingsObserver::TSuplSettingsEventType)curEvent) |
|
2466 { |
|
2467 keyValue = aChangedEventType+1; |
|
2468 } |
|
2469 else |
|
2470 keyValue = aChangedEventType; |
|
2471 err = iSettingsNotifierRep->Set(KSuplSettingsDBEvent,keyValue); |
|
2472 if(err != KErrNone) |
|
2473 return err; |
|
2474 return KErrNone; |
|
2475 } |
|
2476 //---------------------------------------------------------------------------- |
|
2477 // CSettingsDatabaseHandler::ChangePriority() |
|
2478 // |
|
2479 // This method is used to alter priority of a particular server |
|
2480 // --------------------------------------------------------------------------- |
|
2481 void CSettingsDatabaseHandler::ChangePriorityL(TInt aSlpId,TInt aValue,TBool aDirection) |
|
2482 { |
|
2483 if(!IsSlpExists(aSlpId)) |
|
2484 User::Leave(KErrNotFound); |
|
2485 if(aValue <= 0) |
|
2486 User::Leave(KErrArgument); |
|
2487 TInt count; |
|
2488 SlpCount(count); |
|
2489 |
|
2490 |
|
2491 TInt priorityToSet; |
|
2492 |
|
2493 GetPriorityL(aSlpId,priorityToSet); |
|
2494 |
|
2495 if(aDirection) |
|
2496 { |
|
2497 priorityToSet -= aValue; //move up |
|
2498 } |
|
2499 else |
|
2500 { |
|
2501 priorityToSet += aValue;//move down |
|
2502 } |
|
2503 if(priorityToSet > count || priorityToSet <= 0) |
|
2504 User::Leave(KErrArgument); |
|
2505 |
|
2506 //Select all slps existing in the records corresponding to the Server Address |
|
2507 |
|
2508 iSQLString.Copy(KSelect); |
|
2509 iSQLString.Append(KStar); |
|
2510 iSQLString.Append(KFrom); |
|
2511 iSQLString.Append(KCreateTableName); |
|
2512 iSQLString.Append(KWhere); |
|
2513 iSQLString.Append(KColPriority); |
|
2514 if(aDirection) |
|
2515 iSQLString.Append(KGreaterOrEquals); |
|
2516 else |
|
2517 iSQLString.Append(KGreaterThan); |
|
2518 iSQLString.Append(KQuotes); |
|
2519 iSQLString.AppendNum(priorityToSet); |
|
2520 iSQLString.Append(KQuotes); |
|
2521 iSQLString.Append(KOrderBy); |
|
2522 iSQLString.Append(KColPriority); |
|
2523 iSQLString.Append(KCommaSeparator); |
|
2524 iSQLString.Append(KColSLPId); |
|
2525 |
|
2526 RSqlStatement stmt; |
|
2527 TInt err = stmt.Prepare(iDb, iSQLString); |
|
2528 TInt64 SLPId; |
|
2529 TInt priority; |
|
2530 TInt columnIndexSLPID = stmt.ColumnIndex(KColSLPId); |
|
2531 TInt columnIndexPriority = stmt.ColumnIndex(KColPriority); |
|
2532 count = 0; // count the number of slps present in the records |
|
2533 RArray<TInt64> slpIndexArray; |
|
2534 //Get all slp ids whose priorities wil get affected |
|
2535 while((err=stmt.Next())==KSqlAtRow) |
|
2536 { |
|
2537 SLPId = stmt.ColumnInt64(columnIndexSLPID); |
|
2538 if(SLPId != aSlpId) |
|
2539 slpIndexArray.Append(stmt.ColumnInt64(columnIndexSLPID)); |
|
2540 } |
|
2541 stmt.Reset(); |
|
2542 stmt.Close(); |
|
2543 //update the priority of the requested server first |
|
2544 if(!aDirection) |
|
2545 priorityToSet++; |
|
2546 iSQLString.Zero(); |
|
2547 iSQLString.Append(KUpdateRecord); |
|
2548 iSQLString.Append(KCreateTableName); |
|
2549 iSQLString.Append(KSET); |
|
2550 iSQLString.Append(KColPriority); |
|
2551 iSQLString.Append(KEquals); |
|
2552 iSQLString.AppendNum(priorityToSet); |
|
2553 iSQLString.Append(KWhere); |
|
2554 iSQLString.Append(KColSLPId); |
|
2555 iSQLString.Append(KEquals); |
|
2556 iSQLString.AppendNum(aSlpId); |
|
2557 |
|
2558 err = iDb.Exec(iSQLString); |
|
2559 iSQLString.Zero(); |
|
2560 |
|
2561 iSQLString.Append(KUpdateRecord); |
|
2562 iSQLString.Append(KCreateTableName); |
|
2563 iSQLString.Append(KSET); |
|
2564 iSQLString.Append(KColPriority); |
|
2565 iSQLString.Append(KEquals); |
|
2566 iSQLString.Append(KValuePriority); |
|
2567 iSQLString.Append(KWhere); |
|
2568 iSQLString.Append(KColSLPId); |
|
2569 iSQLString.Append(KEquals); |
|
2570 iSQLString.Append(KValueSlpId); |
|
2571 |
|
2572 err = stmt.Prepare(iDb,iSQLString); |
|
2573 //update priority of other slps |
|
2574 TInt priorityParamIndex = stmt.ParameterIndex(KValuePriority); |
|
2575 TInt slpIdParamIndex = stmt.ParameterIndex(KValueSlpId); |
|
2576 |
|
2577 priority = priorityToSet + 1; |
|
2578 for(TInt i=0 ;i < slpIndexArray.Count(); i++,priority++) |
|
2579 { |
|
2580 err = stmt.BindInt(priorityParamIndex, priority); |
|
2581 err = stmt.BindInt(slpIdParamIndex, slpIndexArray[i]); |
|
2582 err = stmt.Exec(); |
|
2583 err = stmt.Reset(); |
|
2584 } |
|
2585 slpIndexArray.Close(); |
|
2586 stmt.Close(); |
|
2587 |
|
2588 NormalizePriorityL(); |
|
2589 |
|
2590 err = NotifyDBChange(MSuplSettingsObserver::ESuplSettingsDBUpdateEvent,0); //indicates that all the records may have been altered |
|
2591 LogAllSLP(); |
|
2592 } |
|
2593 //---------------------------------------------------------------------------- |
|
2594 //CSettingsDatabaseHandler::GetPriority() |
|
2595 //This method is used to retrieve priority of a particular SLP |
|
2596 // |
|
2597 //---------------------------------------------------------------------------- |
|
2598 void CSettingsDatabaseHandler::GetPriorityL(TInt aSlpId,TInt& aPriority) |
|
2599 { |
|
2600 |
|
2601 iSQLString.Copy(KSelect); |
|
2602 iSQLString.Append(KStar); |
|
2603 iSQLString.Append(KFrom); |
|
2604 iSQLString.Append(KCreateTableName); |
|
2605 iSQLString.Append(KWhere); |
|
2606 iSQLString.Append(KColSLPId); |
|
2607 iSQLString.Append(KEquals); |
|
2608 iSQLString.Append(KQuotes); |
|
2609 iSQLString.AppendNum(aSlpId); |
|
2610 iSQLString.Append(KQuotes); |
|
2611 iSQLString.Append(KOrderBy); |
|
2612 iSQLString.Append(KColPriority); |
|
2613 iSQLString.Append(KCommaSeparator); |
|
2614 iSQLString.Append(KColSLPId); |
|
2615 |
|
2616 RSqlStatement stmt; |
|
2617 TInt err = stmt.Prepare(iDb, iSQLString); |
|
2618 if(err != KErrNone) |
|
2619 User::LeaveIfError(KErrGeneral); |
|
2620 TInt priorityParamIndex = stmt.ColumnIndex(KColPriority); |
|
2621 while((err=stmt.Next())==KSqlAtRow) |
|
2622 { |
|
2623 aPriority = stmt.ColumnInt(priorityParamIndex); |
|
2624 break; |
|
2625 } |
|
2626 stmt.Close(); |
|
2627 } |
|
2628 |
|
2629 //---------------------------------------------------------------------------- |
|
2630 // CSettingsDatabaseHandler::SetPriority() |
|
2631 // |
|
2632 // This method is used to alter priority of a particular server |
|
2633 // --------------------------------------------------------------------------- |
|
2634 void CSettingsDatabaseHandler::GetMaxPriorityL(TInt& aPriorityValue) |
|
2635 { |
|
2636 TInt count; |
|
2637 SlpCount(count); |
|
2638 if(count <= 0)//no slp entries exist |
|
2639 { |
|
2640 aPriorityValue = KMinPriorityValue; |
|
2641 return; |
|
2642 } |
|
2643 |
|
2644 //Select all slps existing in the records corresponding to the Server Address |
|
2645 TBuf<KGenericStringLen> sqlString; |
|
2646 sqlString.Copy(KSelect); |
|
2647 sqlString.Append(KMax); |
|
2648 sqlString.Append(KOpeningBracket); |
|
2649 sqlString.Append(KColPriority); |
|
2650 sqlString.Append(KClosingBracket); |
|
2651 sqlString.Append(KFrom); |
|
2652 sqlString.Append(KCreateTableName); |
|
2653 |
|
2654 |
|
2655 RSqlStatement stmt; |
|
2656 TInt err = stmt.Prepare(iDb, sqlString); |
|
2657 TInt columnIndex0 = 0; |
|
2658 |
|
2659 while((err=stmt.Next())==KSqlAtRow) |
|
2660 { |
|
2661 aPriorityValue = stmt.ColumnInt(columnIndex0); |
|
2662 } |
|
2663 aPriorityValue++; |
|
2664 stmt.Close(); |
|
2665 } |
|
2666 |
|
2667 //---------------------------------------------------------------------------- |
|
2668 // CSettingsDatabaseHandler::SetPriority() |
|
2669 // |
|
2670 // This method is used to alter priority of a particular server |
|
2671 // --------------------------------------------------------------------------- |
|
2672 void CSettingsDatabaseHandler::SetPriorityL(TInt aSlpId,TInt aValue) |
|
2673 { |
|
2674 if(aValue <= 0) |
|
2675 User::Leave(KErrArgument); |
|
2676 TInt count; |
|
2677 SlpCount(count); |
|
2678 if(aValue > count) |
|
2679 User::Leave(KErrArgument); |
|
2680 //Select all slps existing in the records corresponding to the Server Address |
|
2681 |
|
2682 iSQLString.Copy(KSelect); |
|
2683 iSQLString.Append(KStar); |
|
2684 iSQLString.Append(KFrom); |
|
2685 iSQLString.Append(KCreateTableName); |
|
2686 iSQLString.Append(KWhere); |
|
2687 iSQLString.Append(KColPriority); |
|
2688 iSQLString.Append(KGreaterOrEquals); |
|
2689 iSQLString.Append(KQuotes); |
|
2690 iSQLString.AppendNum(aValue); |
|
2691 iSQLString.Append(KQuotes); |
|
2692 iSQLString.Append(KOrderBy); |
|
2693 iSQLString.Append(KColPriority); |
|
2694 iSQLString.Append(KCommaSeparator); |
|
2695 iSQLString.Append(KColSLPId); |
|
2696 |
|
2697 RSqlStatement stmt; |
|
2698 TInt err = stmt.Prepare(iDb, iSQLString); |
|
2699 TInt64 SLPId; |
|
2700 TInt priority; |
|
2701 TInt columnIndexSLPID = stmt.ColumnIndex(KColSLPId); |
|
2702 TInt columnIndexPriority = stmt.ColumnIndex(KColPriority); |
|
2703 count = 0; // count the number of slps present in the records |
|
2704 RArray<TInt64> slpIndexArray; |
|
2705 //Get all slp ids whose priorities wil get affected |
|
2706 while((err=stmt.Next())==KSqlAtRow) |
|
2707 { |
|
2708 SLPId = stmt.ColumnInt64(columnIndexSLPID); |
|
2709 if(SLPId != aSlpId) |
|
2710 slpIndexArray.Append(stmt.ColumnInt64(columnIndexSLPID)); |
|
2711 } |
|
2712 stmt.Reset(); |
|
2713 stmt.Close(); |
|
2714 //update the priority of the requested server first |
|
2715 iSQLString.Zero(); |
|
2716 iSQLString.Append(KUpdateRecord); |
|
2717 iSQLString.Append(KCreateTableName); |
|
2718 iSQLString.Append(KSET); |
|
2719 iSQLString.Append(KColPriority); |
|
2720 iSQLString.Append(KEquals); |
|
2721 iSQLString.AppendNum(aValue); |
|
2722 iSQLString.Append(KWhere); |
|
2723 iSQLString.Append(KColSLPId); |
|
2724 iSQLString.Append(KEquals); |
|
2725 iSQLString.AppendNum(aSlpId); |
|
2726 |
|
2727 err = iDb.Exec(iSQLString); |
|
2728 iSQLString.Zero(); |
|
2729 |
|
2730 iSQLString.Append(KUpdateRecord); |
|
2731 iSQLString.Append(KCreateTableName); |
|
2732 iSQLString.Append(KSET); |
|
2733 iSQLString.Append(KColPriority); |
|
2734 iSQLString.Append(KEquals); |
|
2735 iSQLString.Append(KValuePriority); |
|
2736 iSQLString.Append(KWhere); |
|
2737 iSQLString.Append(KColSLPId); |
|
2738 iSQLString.Append(KEquals); |
|
2739 iSQLString.Append(KValueSlpId); |
|
2740 |
|
2741 err = stmt.Prepare(iDb,iSQLString); |
|
2742 //update priority of other slps |
|
2743 TInt priorityParamIndex = stmt.ParameterIndex(KValuePriority); |
|
2744 TInt slpIdParamIndex = stmt.ParameterIndex(KValueSlpId); |
|
2745 |
|
2746 priority = aValue + 1; |
|
2747 for(TInt i=0 ;i < slpIndexArray.Count(); i++,priority++) |
|
2748 { |
|
2749 err = stmt.BindInt(priorityParamIndex, priority); |
|
2750 err = stmt.BindInt(slpIdParamIndex, slpIndexArray[i]); |
|
2751 err = stmt.Exec(); |
|
2752 err = stmt.Reset(); |
|
2753 } |
|
2754 slpIndexArray.Close(); |
|
2755 stmt.Close(); |
|
2756 |
|
2757 err = NotifyDBChange(MSuplSettingsObserver::ESuplSettingsDBUpdateEvent,0); //indicates that all the records may have been altered |
|
2758 LogAllSLP(); |
|
2759 } |
|
2760 //-------------------------------------------------------------------------------- |
|
2761 // CSettingsDatabaseHandler::NormalizePriorityL() |
|
2762 // |
|
2763 // This method is used to order the priority values in proper incremental sequence |
|
2764 // ------------------------------------------------------------------------------- |
|
2765 void CSettingsDatabaseHandler::NormalizePriorityL() |
|
2766 { |
|
2767 TInt count; |
|
2768 SlpCount(count); |
|
2769 if(count <= 0) |
|
2770 return; |
|
2771 |
|
2772 iSQLString.Copy(KSelect); |
|
2773 iSQLString.Append(KStar); |
|
2774 iSQLString.Append(KFrom); |
|
2775 iSQLString.Append(KCreateTableName); |
|
2776 iSQLString.Append(KOrderBy); |
|
2777 iSQLString.Append(KColPriority); |
|
2778 iSQLString.Append(KCommaSeparator); |
|
2779 iSQLString.Append(KColSLPId); |
|
2780 |
|
2781 RSqlStatement stmt; |
|
2782 TInt err = stmt.Prepare(iDb, iSQLString); |
|
2783 User::LeaveIfError(err); |
|
2784 |
|
2785 TInt columnIndexSLPID = stmt.ColumnIndex(KColSLPId); |
|
2786 RArray<TInt64> slpIdArray; |
|
2787 //Get all slp ids currently in the database |
|
2788 while((err=stmt.Next())==KSqlAtRow) |
|
2789 { |
|
2790 slpIdArray.Append(stmt.ColumnInt64(columnIndexSLPID)); |
|
2791 } |
|
2792 stmt.Reset(); |
|
2793 |
|
2794 iSQLString.Zero(); |
|
2795 |
|
2796 iSQLString.Append(KUpdateRecord); |
|
2797 iSQLString.Append(KCreateTableName); |
|
2798 iSQLString.Append(KSET); |
|
2799 iSQLString.Append(KColPriority); |
|
2800 iSQLString.Append(KEquals); |
|
2801 iSQLString.Append(KValuePriority); |
|
2802 iSQLString.Append(KWhere); |
|
2803 iSQLString.Append(KColSLPId); |
|
2804 iSQLString.Append(KEquals); |
|
2805 iSQLString.Append(KValueSlpId); |
|
2806 |
|
2807 err = stmt.Prepare(iDb,iSQLString); |
|
2808 //update priority of other slps |
|
2809 TInt priorityParamIndex = stmt.ParameterIndex(KValuePriority); |
|
2810 TInt slpIdParamIndex = stmt.ParameterIndex(KValueSlpId); |
|
2811 |
|
2812 TInt priorityToSet = KMinPriorityValue; |
|
2813 for(TInt i=0 ;i < slpIdArray.Count(); i++,priorityToSet++) |
|
2814 { |
|
2815 err = stmt.BindInt(priorityParamIndex, priorityToSet); |
|
2816 err = stmt.BindInt(slpIdParamIndex, slpIdArray[i]); |
|
2817 err = stmt.Exec(); |
|
2818 err = stmt.Reset(); |
|
2819 } |
|
2820 slpIdArray.Close(); |
|
2821 stmt.Close(); |
|
2822 |
|
2823 } |
|
2824 //---------------------------------------------------------------------------- |
|
2825 // CSettingsDatabaseHandler::RemoveOnSimChangeL() |
|
2826 // |
|
2827 // This method is used to delete all entries that have the sim change remove |
|
2828 // property set |
|
2829 // --------------------------------------------------------------------------- |
|
2830 void CSettingsDatabaseHandler::RemoveOnSimChangeL() |
|
2831 { |
|
2832 |
|
2833 iSQLString.Copy(KSelect); |
|
2834 iSQLString.Append(KStar); |
|
2835 iSQLString.Append(KFrom); |
|
2836 iSQLString.Append(KCreateTableName); // retrieve list of all SLPs |
|
2837 iSQLString.Append(KOrderBy); |
|
2838 iSQLString.Append(KColPriority); |
|
2839 iSQLString.Append(KCommaSeparator); |
|
2840 iSQLString.Append(KColSLPId); |
|
2841 RSqlStatement stmt; |
|
2842 TInt err = stmt.Prepare(iDb, iSQLString); |
|
2843 if(err != KErrNone) |
|
2844 User::Leave(KErrGeneral); |
|
2845 TInt64 slpId = -1; |
|
2846 TInt columnIndexSLPID = stmt.ColumnIndex(KColSLPId); |
|
2847 TBool simChangeRemove; |
|
2848 while((err=stmt.Next())==KSqlAtRow) |
|
2849 { |
|
2850 |
|
2851 slpId = stmt.ColumnInt64(columnIndexSLPID); |
|
2852 GetOtherPropertiesL(slpId,CSuplSettingsInternal::ESimChangeRemove,simChangeRemove); |
|
2853 if(simChangeRemove) //if sim change remove flag is set delete it |
|
2854 DeleteSLPRecordL(slpId); |
|
2855 } |
|
2856 |
|
2857 stmt.Close(); |
|
2858 LogAllSLP(); |
|
2859 } |
|
2860 |
|
2861 |
|
2862 // --------------------------------------------------------------------------- |
|
2863 // CSettingsDatabaseHandler::CreateSessionTableL() |
|
2864 // |
|
2865 // Creates the SUPL session settings table. Leaves, if the table cannot be created. |
|
2866 // --------------------------------------------------------------------------- |
|
2867 void CSettingsDatabaseHandler::CreateSessionTableL() |
|
2868 { |
|
2869 iSQLString.Copy(KCreateTable); |
|
2870 iSQLString.Append(KSessionTableName); |
|
2871 iSQLString.Append(KOpeningBracket); |
|
2872 |
|
2873 iSQLString.Append(KColSessionId); |
|
2874 iSQLString.Append(KDataTypeInteger); |
|
2875 iSQLString.Append(KPrimaryKey); |
|
2876 iSQLString.Append(KCommaSeparator); |
|
2877 |
|
2878 iSQLString.Append(KColSessionName); |
|
2879 iSQLString.Append(KDataTypeString); |
|
2880 iSQLString.Append(KOpeningBracket); |
|
2881 iSQLString.AppendNum(KMaxTriggerSessionNameLen); |
|
2882 iSQLString.Append(KClosingBracket); |
|
2883 iSQLString.Append(KCommaSeparator); |
|
2884 |
|
2885 iSQLString.Append(KColNotificationPresent); |
|
2886 iSQLString.Append(KDataTypeInteger); |
|
2887 iSQLString.Append(KCommaSeparator); |
|
2888 |
|
2889 iSQLString.Append(KColTriggerNotificationStatus); |
|
2890 iSQLString.Append(KDataTypeInteger); |
|
2891 iSQLString.Append(KCommaSeparator); |
|
2892 |
|
2893 iSQLString.Append(KColTriggerType); |
|
2894 iSQLString.Append(KDataTypeInteger); |
|
2895 iSQLString.Append(KCommaSeparator); |
|
2896 |
|
2897 iSQLString.Append(KColRequestType); |
|
2898 iSQLString.Append(KDataTypeInteger); |
|
2899 iSQLString.Append(KCommaSeparator); |
|
2900 |
|
2901 iSQLString.Append(KColOutstandingTrigger); |
|
2902 iSQLString.Append(KDataTypeInteger); |
|
2903 iSQLString.Append(KCommaSeparator); |
|
2904 |
|
2905 iSQLString.Append(KColInterval); |
|
2906 iSQLString.Append(KDataTypeInteger); |
|
2907 iSQLString.Append(KClosingBracket); |
|
2908 |
|
2909 TInt err = iDb.Exec(iSQLString); |
|
2910 |
|
2911 PrintErrorMessage(iSQLString,err,1); |
|
2912 |
|
2913 User::LeaveIfError(err); |
|
2914 |
|
2915 } |
|
2916 |
|
2917 // --------------------------------------------------------------------------- |
|
2918 // CSettingsDatabaseHandler::InsertSessionRecordL() |
|
2919 // |
|
2920 // This method is used to insert session record into the SUPL session DB |
|
2921 // --------------------------------------------------------------------------- |
|
2922 void CSettingsDatabaseHandler::InsertSessionRecordL(const CTriggerParams* aSessionParamValues) |
|
2923 { |
|
2924 if( !aSessionParamValues ) |
|
2925 { |
|
2926 User::Leave(KErrArgument); |
|
2927 } |
|
2928 HBufC* sessionName = HBufC::NewL( KMaxTriggerSessionNameLen); |
|
2929 |
|
2930 |
|
2931 TInt64 sessionId; |
|
2932 TBool notificationPresent; |
|
2933 TBool triggerNotificationStatus; |
|
2934 CTriggerParams::TTriggerType triggerType; |
|
2935 CTriggerParams::TRequestType requestType; |
|
2936 TUint64 outstandingTrigger; |
|
2937 TUint64 interval; |
|
2938 |
|
2939 TInt ret = aSessionParamValues->Get(sessionId,sessionName->Des(),notificationPresent,triggerNotificationStatus, |
|
2940 triggerType,requestType,outstandingTrigger,interval ); |
|
2941 |
|
2942 if(ret == KErrNotFound) |
|
2943 { |
|
2944 delete sessionName; |
|
2945 User::Leave(KErrGeneral); |
|
2946 } |
|
2947 |
|
2948 iSQLString.Copy(KInsertIntoTable); |
|
2949 iSQLString.Append(KSessionTableName); |
|
2950 iSQLString.Append(KOpeningBracket); |
|
2951 |
|
2952 iSQLString.Append(KColSessionId); |
|
2953 iSQLString.Append(KCommaSeparator); |
|
2954 |
|
2955 iSQLString.Append(KColSessionName); |
|
2956 iSQLString.Append(KCommaSeparator); |
|
2957 |
|
2958 iSQLString.Append(KColNotificationPresent); |
|
2959 iSQLString.Append(KCommaSeparator); |
|
2960 |
|
2961 iSQLString.Append(KColTriggerNotificationStatus); |
|
2962 iSQLString.Append(KCommaSeparator); |
|
2963 |
|
2964 iSQLString.Append(KColTriggerType); |
|
2965 iSQLString.Append(KCommaSeparator); |
|
2966 |
|
2967 iSQLString.Append(KColRequestType); |
|
2968 iSQLString.Append(KCommaSeparator); |
|
2969 |
|
2970 iSQLString.Append(KColOutstandingTrigger); |
|
2971 iSQLString.Append(KCommaSeparator); |
|
2972 |
|
2973 iSQLString.Append(KColInterval); |
|
2974 iSQLString.Append(KClosingBracket); |
|
2975 |
|
2976 iSQLString.Append(KValues); |
|
2977 |
|
2978 iSQLString.Append(KOpeningBracket); |
|
2979 |
|
2980 iSQLString.AppendNum(sessionId); |
|
2981 iSQLString.Append(KCommaSeparator); |
|
2982 |
|
2983 iSQLString.Append(KQuotes); |
|
2984 iSQLString.Append(sessionName->Des()); |
|
2985 iSQLString.Append(KQuotes); |
|
2986 iSQLString.Append(KCommaSeparator); |
|
2987 |
|
2988 iSQLString.AppendNum(notificationPresent); |
|
2989 iSQLString.Append(KCommaSeparator); |
|
2990 |
|
2991 iSQLString.AppendNum(triggerNotificationStatus); |
|
2992 iSQLString.Append(KCommaSeparator); |
|
2993 |
|
2994 iSQLString.AppendNum(triggerType); |
|
2995 iSQLString.Append(KCommaSeparator); |
|
2996 |
|
2997 iSQLString.AppendNum(requestType); |
|
2998 iSQLString.Append(KCommaSeparator); |
|
2999 |
|
3000 iSQLString.AppendNum(outstandingTrigger); |
|
3001 iSQLString.Append(KCommaSeparator); |
|
3002 |
|
3003 iSQLString.AppendNum(interval); |
|
3004 |
|
3005 iSQLString.Append(KClosingBracket); |
|
3006 |
|
3007 delete sessionName; |
|
3008 TInt err = iDb.Exec(_L("BEGIN")); |
|
3009 err = iDb.Exec(iSQLString); |
|
3010 if(err < 0) |
|
3011 User::Leave(KErrGeneral); |
|
3012 iDb.Exec(_L("COMMIT")); |
|
3013 |
|
3014 err = NotifySessionDBChange(MSuplSessionObserver::ESuplSessionDBAddEvent,sessionId); |
|
3015 |
|
3016 } |
|
3017 |
|
3018 // ---------------------------------------------------------------------------- |
|
3019 // CSettingsDatabaseHandler::DeleteSessionRecordL() |
|
3020 // |
|
3021 // This method is used to delete a session record corresponding to the given session ID |
|
3022 // ---------------------------------------------------------------------------- |
|
3023 void CSettingsDatabaseHandler::DeleteSessionRecordL(TInt64 aSessionId) |
|
3024 { |
|
3025 if(!IsSessionExists(aSessionId)) //no session exists with the given id so return error |
|
3026 { |
|
3027 User::Leave(KErrNotFound); |
|
3028 } |
|
3029 |
|
3030 iSQLString.Copy(KDeleteRecord); |
|
3031 iSQLString.Append(KSessionTableName); |
|
3032 iSQLString.Append(KWhere); |
|
3033 iSQLString.Append(KColSessionId); |
|
3034 iSQLString.Append(KEquals); |
|
3035 iSQLString.AppendNum(aSessionId); |
|
3036 |
|
3037 TInt err = iDb.Exec(iSQLString); |
|
3038 |
|
3039 if(err < 0) |
|
3040 User::Leave(KErrGeneral); |
|
3041 err = NotifySessionDBChange(MSuplSessionObserver::ESuplSessionDBDeleteEvent,aSessionId); // notify about a change in the database |
|
3042 |
|
3043 } |
|
3044 |
|
3045 // ---------------------------------------------------------------------------- |
|
3046 // CSettingsDatabaseHandler::DeleteAllSessionRecordsL() |
|
3047 // |
|
3048 // This method is used to delete all session records from session table |
|
3049 // ---------------------------------------------------------------------------- |
|
3050 void CSettingsDatabaseHandler::DeleteAllSessionRecordsL() |
|
3051 { |
|
3052 iSQLString.Copy(KDeleteRecord); |
|
3053 iSQLString.Append(KSessionTableName); |
|
3054 |
|
3055 TInt err = iDb.Exec(iSQLString); |
|
3056 |
|
3057 if(err < 0) |
|
3058 User::Leave(KErrGeneral); |
|
3059 } |
|
3060 |
|
3061 // --------------------------------------------------------------------------- |
|
3062 // CSettingsDatabaseHandler::UpdateSessionRecordL() |
|
3063 // |
|
3064 // This method is used to update a column of string value corresponding |
|
3065 // to a particular session |
|
3066 // --------------------------------------------------------------------------- |
|
3067 |
|
3068 void CSettingsDatabaseHandler::UpdateSessionRecordL(TInt64 aSessionId,CSuplSettingsInternal::TSessionParam aParameter,TUint64 aValue) |
|
3069 { |
|
3070 if(!IsSessionExists(aSessionId)) //no session exists with the given id so return error |
|
3071 { |
|
3072 User::Leave(KErrNotFound); |
|
3073 } |
|
3074 |
|
3075 iSQLString.Copy(KUpdateRecord); |
|
3076 iSQLString.Append(KSessionTableName); |
|
3077 iSQLString.Append(KSET); |
|
3078 |
|
3079 FormSessionQueryL(aParameter,aValue,iSQLString); |
|
3080 |
|
3081 iSQLString.Append(KWhere); |
|
3082 iSQLString.Append(KColSessionId); |
|
3083 iSQLString.Append(KEquals); |
|
3084 iSQLString.AppendNum(aSessionId); |
|
3085 |
|
3086 TInt err = iDb.Exec(iSQLString); |
|
3087 if(err < 0) |
|
3088 User::Leave(KErrGeneral); |
|
3089 err = NotifySessionDBChange(MSuplSessionObserver::ESuplSessionDBUpdateEvent,aSessionId); |
|
3090 |
|
3091 } |
|
3092 |
|
3093 // --------------------------------------------------------------------------- |
|
3094 // CSettingsDatabaseHandler::FormSessionQueryL() |
|
3095 // |
|
3096 // Forms part of the query string, used to form a query string that contains |
|
3097 // a String value in it |
|
3098 // --------------------------------------------------------------------------- |
|
3099 void CSettingsDatabaseHandler::FormSessionQueryL(CSuplSettingsInternal::TSessionParam aParameter,TUint64 aValue,TDes& aQueryString) |
|
3100 { |
|
3101 switch(aParameter) |
|
3102 { |
|
3103 case CSuplSettingsInternal::ETriggerNotificationStatus: |
|
3104 { |
|
3105 aQueryString.Append(KColTriggerNotificationStatus); |
|
3106 break; |
|
3107 } |
|
3108 case CSuplSettingsInternal::EOutstandingTriggers: |
|
3109 { |
|
3110 aQueryString.Append(KColOutstandingTrigger); |
|
3111 break; |
|
3112 } |
|
3113 |
|
3114 default: |
|
3115 User::Leave(KErrArgument); |
|
3116 } |
|
3117 |
|
3118 aQueryString.Append(KEquals); |
|
3119 aQueryString.Append(KQuotes); |
|
3120 aQueryString.AppendNum(aValue); |
|
3121 aQueryString.Append(KQuotes); |
|
3122 } |
|
3123 |
|
3124 |
|
3125 // --------------------------------------------------------------------------- |
|
3126 // CSettingsDatabaseHandler::GetAllSessionsL() |
|
3127 // |
|
3128 // Returns a list of all sessions in the order of priority |
|
3129 // --------------------------------------------------------------------------- |
|
3130 void CSettingsDatabaseHandler::GetAllSessionsL(RPointerArray<CTriggerParams>& aParamValues) |
|
3131 { |
|
3132 iSQLString.Copy(KSelect); |
|
3133 iSQLString.Append(KStar); |
|
3134 iSQLString.Append(KFrom); |
|
3135 iSQLString.Append(KSessionTableName); // retrieve list of all session in order of priority |
|
3136 iSQLString.Append(KOrderBy); |
|
3137 iSQLString.Append(KColSessionId); |
|
3138 RSqlStatement stmt; |
|
3139 TInt err = stmt.Prepare(iDb, iSQLString); |
|
3140 |
|
3141 if(err != KErrNone) |
|
3142 { |
|
3143 stmt.Close(); |
|
3144 User::Leave(KErrGeneral); |
|
3145 } |
|
3146 |
|
3147 |
|
3148 TInt64 sessionId; |
|
3149 TBool notificationPresent; |
|
3150 TBool triggerNotificationStatus; |
|
3151 CTriggerParams::TTriggerType triggerType; |
|
3152 CTriggerParams::TRequestType requestType; |
|
3153 TUint64 outstandingTrigger; |
|
3154 TUint64 interval; |
|
3155 TBuf<KGenericStringLen> sessionName; |
|
3156 |
|
3157 TInt columnIndexSessionID = stmt.ColumnIndex(KColSessionId); |
|
3158 TInt columnIndexSessionName = stmt.ColumnIndex(KColSessionName); |
|
3159 TInt columnIndexNotificationPresent = stmt.ColumnIndex(KColNotificationPresent); |
|
3160 TInt columnIndexTriggerNotificationStatus = stmt.ColumnIndex(KColTriggerNotificationStatus); |
|
3161 TInt columnIndexTriggerType = stmt.ColumnIndex(KColTriggerType); |
|
3162 TInt columnIndexRequestType = stmt.ColumnIndex(KColRequestType); |
|
3163 TInt columnIndexOutstandingTrigger = stmt.ColumnIndex(KColOutstandingTrigger); |
|
3164 TInt columnIndexInterval = stmt.ColumnIndex(KColInterval); |
|
3165 |
|
3166 // Reset client array |
|
3167 aParamValues.Reset(); |
|
3168 while((err=stmt.Next())==KSqlAtRow) |
|
3169 { |
|
3170 CTriggerParams *params = CTriggerParams::NewL(); |
|
3171 sessionId = stmt.ColumnInt(columnIndexSessionID); |
|
3172 stmt.ColumnText(columnIndexSessionName,sessionName); |
|
3173 notificationPresent = stmt.ColumnInt(columnIndexNotificationPresent); |
|
3174 triggerNotificationStatus = stmt.ColumnInt(columnIndexTriggerNotificationStatus); |
|
3175 triggerType = (CTriggerParams::TTriggerType) stmt.ColumnInt(columnIndexTriggerType); |
|
3176 requestType = (CTriggerParams::TRequestType) stmt.ColumnInt(columnIndexRequestType); |
|
3177 outstandingTrigger = stmt.ColumnInt(columnIndexOutstandingTrigger); |
|
3178 interval = stmt.ColumnInt(columnIndexInterval); |
|
3179 |
|
3180 params->Set(sessionId,sessionName,notificationPresent,triggerNotificationStatus,triggerType,requestType,outstandingTrigger,interval); |
|
3181 aParamValues.Append(params);//ownership transferred to RPointerArray |
|
3182 } |
|
3183 |
|
3184 stmt.Close(); |
|
3185 if(aParamValues.Count()==0) |
|
3186 { |
|
3187 User::Leave(KErrNotFound); |
|
3188 } |
|
3189 |
|
3190 } |
|
3191 |
|
3192 |
|
3193 // --------------------------------------------------------------------------- |
|
3194 // CSettingsDatabaseHandler::GetSessionL() |
|
3195 // |
|
3196 // Returns the session parameters for a given session id |
|
3197 // --------------------------------------------------------------------------- |
|
3198 void CSettingsDatabaseHandler::GetSessionL(TInt64 aSessionId, |
|
3199 CTriggerParams*& aParamValues) |
|
3200 { |
|
3201 if( !IsSessionExists(aSessionId) ) //no session exists with the given id so return error |
|
3202 { |
|
3203 User::Leave(KErrNotFound); |
|
3204 } |
|
3205 iSQLString.Copy(KSelect); |
|
3206 iSQLString.Append(KStar); |
|
3207 iSQLString.Append(KFrom); |
|
3208 iSQLString.Append(KSessionTableName); // retrieve list of all session in order of priority |
|
3209 iSQLString.Append(KWhere); |
|
3210 iSQLString.Append(KColSessionId); |
|
3211 iSQLString.Append(KEquals); |
|
3212 iSQLString.AppendNum(aSessionId); |
|
3213 |
|
3214 RSqlStatement stmt; |
|
3215 TInt err = stmt.Prepare(iDb,iSQLString); |
|
3216 if(err != KErrNone) |
|
3217 { |
|
3218 stmt.Close(); |
|
3219 User::Leave(KErrGeneral); |
|
3220 } |
|
3221 |
|
3222 TInt64 sessionId; |
|
3223 TBool notificationPresent; |
|
3224 TBool triggerNotificationStatus; |
|
3225 CTriggerParams::TTriggerType triggerType; |
|
3226 CTriggerParams::TRequestType requestType; |
|
3227 TUint64 outstandingTrigger; |
|
3228 TUint64 interval; |
|
3229 TBuf<KGenericStringLen> sessionName; |
|
3230 |
|
3231 TInt columnIndexSessionID = stmt.ColumnIndex(KColSessionId); |
|
3232 TInt columnIndexSessionName = stmt.ColumnIndex(KColSessionName); |
|
3233 TInt columnIndexNotificationPresent = stmt.ColumnIndex(KColNotificationPresent); |
|
3234 TInt columnIndexTriggerNotificationStatus = stmt.ColumnIndex(KColTriggerNotificationStatus); |
|
3235 TInt columnIndexTriggerType = stmt.ColumnIndex(KColTriggerType); |
|
3236 TInt columnIndexRequestType = stmt.ColumnIndex(KColRequestType); |
|
3237 TInt columnIndexOutstandingTrigger = stmt.ColumnIndex(KColOutstandingTrigger); |
|
3238 TInt columnIndexInterval = stmt.ColumnIndex(KColInterval); |
|
3239 while((err=stmt.Next())==KSqlAtRow) |
|
3240 { |
|
3241 sessionId = stmt.ColumnInt(columnIndexSessionID); |
|
3242 stmt.ColumnText(columnIndexSessionName,sessionName); |
|
3243 notificationPresent = stmt.ColumnInt(columnIndexNotificationPresent); |
|
3244 triggerNotificationStatus = stmt.ColumnInt(columnIndexTriggerNotificationStatus); |
|
3245 triggerType = (CTriggerParams::TTriggerType) stmt.ColumnInt(columnIndexTriggerType); |
|
3246 requestType = (CTriggerParams::TRequestType) stmt.ColumnInt(columnIndexRequestType); |
|
3247 outstandingTrigger = stmt.ColumnInt(columnIndexOutstandingTrigger); |
|
3248 interval = stmt.ColumnInt(columnIndexInterval); |
|
3249 |
|
3250 aParamValues->Set(sessionId,sessionName,notificationPresent,triggerNotificationStatus,triggerType,requestType,outstandingTrigger,interval); |
|
3251 } |
|
3252 |
|
3253 stmt.Close(); |
|
3254 } |
|
3255 |
|
3256 // --------------------------------------------------------------------------- |
|
3257 // CSettingsDatabaseHandler::SessionCount() |
|
3258 // |
|
3259 // This method is retrieve the count of session entries present |
|
3260 // --------------------------------------------------------------------------- |
|
3261 TInt CSettingsDatabaseHandler::SessionCount(TInt& aCount) |
|
3262 { |
|
3263 //Select all slps existing in the records |
|
3264 TBuf<KGenericStringLen> sqlString; |
|
3265 |
|
3266 sqlString.Copy(KSelect); |
|
3267 sqlString.Append(KCount); |
|
3268 sqlString.Append(KOpeningBracket); |
|
3269 sqlString.Append(KStar); |
|
3270 sqlString.Append(KClosingBracket); |
|
3271 sqlString.Append(KFrom); |
|
3272 sqlString.Append(KSessionTableName); |
|
3273 |
|
3274 |
|
3275 RSqlStatement stmt; |
|
3276 TInt err = stmt.Prepare(iDb, sqlString); |
|
3277 if(err != KErrNone) |
|
3278 { |
|
3279 stmt.Close(); |
|
3280 return KErrGeneral; |
|
3281 } |
|
3282 |
|
3283 aCount = 0; |
|
3284 TInt columnIndex0 = 0; |
|
3285 while((err=stmt.Next())==KSqlAtRow) |
|
3286 { |
|
3287 aCount = stmt.ColumnInt(columnIndex0); //count number of rows |
|
3288 } |
|
3289 stmt.Close(); |
|
3290 |
|
3291 if(aCount == 0 ) |
|
3292 { |
|
3293 return KErrNotFound; |
|
3294 } |
|
3295 return KErrNone; |
|
3296 } |
|
3297 // --------------------------------------------------------------------------- |
|
3298 // CSettingsDatabaseHandler::IsSessionExists() |
|
3299 // |
|
3300 // This method is to check if a session entry exists corresponding to a particular session Id |
|
3301 // --------------------------------------------------------------------------- |
|
3302 TBool CSettingsDatabaseHandler::IsSessionExists(const TInt64 aSessionId) |
|
3303 { |
|
3304 //Select all sessions existing in the records corresponing to the session Id |
|
3305 |
|
3306 TBuf<KGenericStringLen> sqlString; |
|
3307 |
|
3308 sqlString.Copy(KSelect); |
|
3309 sqlString.Append(KCount); |
|
3310 sqlString.Append(KOpeningBracket); |
|
3311 sqlString.Append(KStar); |
|
3312 sqlString.Append(KClosingBracket); |
|
3313 sqlString.Append(KFrom); |
|
3314 sqlString.Append(KSessionTableName); |
|
3315 sqlString.Append(KWhere); |
|
3316 sqlString.Append(KColSessionId); |
|
3317 sqlString.Append(KEquals); |
|
3318 sqlString.AppendNum(aSessionId); |
|
3319 |
|
3320 RSqlStatement stmt; |
|
3321 TInt err = stmt.Prepare(iDb, sqlString); |
|
3322 |
|
3323 TInt count = 0; |
|
3324 TInt columnIndex0 = 0; |
|
3325 while((err=stmt.Next())==KSqlAtRow) |
|
3326 { |
|
3327 count = stmt.ColumnInt(columnIndex0); //count number of rows |
|
3328 } |
|
3329 stmt.Close(); |
|
3330 if(count == 0) |
|
3331 { |
|
3332 return EFalse; |
|
3333 } |
|
3334 |
|
3335 return ETrue; |
|
3336 } |
|
3337 |
|
3338 // --------------------------------------------------------------------------- |
|
3339 // CSettingsDatabaseHandler::GetServerExtensionParamsL() |
|
3340 // |
|
3341 // This method is used to retrieve extended parameters of given server |
|
3342 // --------------------------------------------------------------------------- |
|
3343 void CSettingsDatabaseHandler::GetServerExtensionParamsL( TInt64 aSlpId,CServerExtensionParams* aServerExtnParams ) |
|
3344 { |
|
3345 if(!IsSlpExists(aSlpId)) |
|
3346 { |
|
3347 User::Leave(KErrNotFound); |
|
3348 } |
|
3349 iSQLString.Copy(KSelect); |
|
3350 iSQLString.Append(KStar); |
|
3351 iSQLString.Append(KFrom); |
|
3352 iSQLString.Append(KCreateTableName); // retrieve list of all session in order of priority |
|
3353 iSQLString.Append(KWhere); |
|
3354 iSQLString.Append(KColSLPId); |
|
3355 iSQLString.Append(KEquals); |
|
3356 iSQLString.AppendNum(aSlpId); |
|
3357 |
|
3358 RSqlStatement stmt; |
|
3359 TInt err = stmt.Prepare(iDb,iSQLString); |
|
3360 if(err != KErrNone) |
|
3361 { |
|
3362 stmt.Close(); |
|
3363 User::Leave(err); |
|
3364 } |
|
3365 |
|
3366 TBuf<KMaxServerIdLen> serverId; |
|
3367 TBuf<KMaxIAPLen> iap1; |
|
3368 TBuf<KMaxIAPLen> iap2; |
|
3369 TBuf<KMaxServerAddLen> serverAddr; |
|
3370 TBuf<KMaxServerAddTypeLen> serverAddrType; |
|
3371 |
|
3372 TInt columnIndexServerId = stmt.ColumnIndex(KColServerId); |
|
3373 TInt columnIndexIap1 = stmt.ColumnIndex(KColIap1); |
|
3374 TInt columnIndexIap2 = stmt.ColumnIndex(KColIap2); |
|
3375 TInt columnIndexServerAddress = stmt.ColumnIndex(KColServerAddress); |
|
3376 TInt columnIndexServerAddType = stmt.ColumnIndex(KColServerAddType); |
|
3377 |
|
3378 while((err=stmt.Next())==KSqlAtRow) |
|
3379 { |
|
3380 stmt.ColumnText(columnIndexServerId,serverId); |
|
3381 stmt.ColumnText(columnIndexIap1,iap1); |
|
3382 stmt.ColumnText(columnIndexIap2,iap2); |
|
3383 stmt.ColumnText(columnIndexServerAddress,serverAddr); |
|
3384 stmt.ColumnText(columnIndexServerAddType,serverAddrType); |
|
3385 |
|
3386 aServerExtnParams->Set(serverId,iap1,iap2,serverAddr,serverAddrType); |
|
3387 } |
|
3388 |
|
3389 stmt.Close(); |
|
3390 } |
|
3391 |
|
3392 // --------------------------------------------------------------------------- |
|
3393 // CSettingsDatabaseHandler::UpdateServerExtensionParamsL() |
|
3394 // |
|
3395 // This method is used to set extended parameters of a given server. |
|
3396 // --------------------------------------------------------------------------- |
|
3397 void CSettingsDatabaseHandler::UpdateServerExtensionParamsL( TInt64 aSlpId,CServerExtensionParams* aServerExtnParams ) |
|
3398 { |
|
3399 if(!IsSlpExists(aSlpId)) |
|
3400 { |
|
3401 User::Leave(KErrNotFound); |
|
3402 } |
|
3403 |
|
3404 HBufC* serverId = HBufC::NewLC( KMaxServerIdLen); |
|
3405 HBufC* iap1 = HBufC::NewLC( KMaxIAPLen); |
|
3406 HBufC* iap2 = HBufC::NewLC( KMaxIAPLen); |
|
3407 HBufC* serverAddr = HBufC::NewLC( KMaxServerAddLen); |
|
3408 HBufC* serverAddrType = HBufC::NewLC( KMaxServerAddTypeLen); |
|
3409 |
|
3410 TInt ret = 0; |
|
3411 ret = aServerExtnParams->Get(serverId->Des(),iap1->Des(),iap2->Des(),serverAddr->Des(),serverAddrType->Des()); |
|
3412 if(ret == KErrNotFound) |
|
3413 { |
|
3414 CleanupStack::PopAndDestroy(5); |
|
3415 User::Leave(KErrArgument); |
|
3416 } |
|
3417 |
|
3418 iSQLString.Copy(KUpdateRecord); |
|
3419 iSQLString.Append(KCreateTableName); |
|
3420 iSQLString.Append(KSET); |
|
3421 |
|
3422 iSQLString.Append(KColServerId); |
|
3423 iSQLString.Append(KEquals); |
|
3424 iSQLString.Append(KQuotes); |
|
3425 iSQLString.Append(*serverId); |
|
3426 iSQLString.Append(KQuotes); |
|
3427 iSQLString.Append(KCommaSeparator); |
|
3428 |
|
3429 iSQLString.Append(KColIap1); |
|
3430 iSQLString.Append(KEquals); |
|
3431 iSQLString.Append(KQuotes); |
|
3432 iSQLString.Append(*iap1); |
|
3433 iSQLString.Append(KQuotes); |
|
3434 iSQLString.Append(KCommaSeparator); |
|
3435 |
|
3436 iSQLString.Append(KColIap2); |
|
3437 iSQLString.Append(KEquals); |
|
3438 iSQLString.Append(KQuotes); |
|
3439 iSQLString.Append(*iap2); |
|
3440 iSQLString.Append(KQuotes); |
|
3441 iSQLString.Append(KCommaSeparator); |
|
3442 |
|
3443 iSQLString.Append(KColServerAddress); |
|
3444 iSQLString.Append(KEquals); |
|
3445 iSQLString.Append(KQuotes); |
|
3446 iSQLString.Append(*serverAddr); |
|
3447 iSQLString.Append(KQuotes); |
|
3448 iSQLString.Append(KCommaSeparator); |
|
3449 |
|
3450 iSQLString.Append(KColServerAddType); |
|
3451 iSQLString.Append(KEquals); |
|
3452 iSQLString.Append(KQuotes); |
|
3453 iSQLString.Append(*serverAddrType); |
|
3454 iSQLString.Append(KQuotes); |
|
3455 |
|
3456 iSQLString.Append(KWhere); |
|
3457 iSQLString.Append(KColSLPId); |
|
3458 iSQLString.Append(KEquals); |
|
3459 iSQLString.AppendNum(aSlpId); |
|
3460 |
|
3461 TInt err = iDb.Exec(iSQLString); |
|
3462 PrintErrorMessage(iSQLString,err,6); |
|
3463 CleanupStack::PopAndDestroy(5); |
|
3464 if(err < 0) |
|
3465 { |
|
3466 User::Leave(err); |
|
3467 } |
|
3468 } |
|
3469 |
|
3470 |
|
3471 |
|
3472 //----------------------------------------------------------------------------- |
|
3473 // CSettingsDatabaseHandler::NotifySessionDBChange() |
|
3474 // |
|
3475 // This method is used to notify that a change has occured in the DB via the CR |
|
3476 // ---------------------------------------------------------------------------- |
|
3477 TInt CSettingsDatabaseHandler::NotifySessionDBChange(MSuplSessionObserver::TSuplSessionEventType aChangedEventType,TInt64 aSessionId) |
|
3478 { |
|
3479 TInt err; |
|
3480 TReal idChanged = aSessionId; |
|
3481 err = iSettingsNotifierRep->Set(KSuplSessionDBChangedSessionId,idChanged); |
|
3482 if(err != KErrNone) |
|
3483 { |
|
3484 return err; |
|
3485 } |
|
3486 TInt curEvent; |
|
3487 TInt keyValue; |
|
3488 err = iSettingsNotifierRep->Get(KSuplSessionDBEvent,curEvent); |
|
3489 if(err != KErrNone) |
|
3490 { |
|
3491 return err; |
|
3492 } |
|
3493 if(aChangedEventType == (MSuplSessionObserver::TSuplSessionEventType)curEvent) |
|
3494 { |
|
3495 keyValue = aChangedEventType+1; |
|
3496 } |
|
3497 else |
|
3498 keyValue = aChangedEventType; |
|
3499 err = iSettingsNotifierRep->Set(KSuplSessionDBEvent,keyValue); |
|
3500 return err; |
|
3501 } |
|
3502 |
|
3503 // --------------------------------------------------------------------------- |
|
3504 // CSettingsDatabaseHandler::PrintErrorMessage(const TDesC& aQueryFired, |
|
3505 // TInt aErrorCode,TInt aOperationCode) |
|
3506 // |
|
3507 // Used to print error messages. Used for logging purposes |
|
3508 // (other items were commented in a header) |
|
3509 // --------------------------------------------------------------------------- |
|
3510 void CSettingsDatabaseHandler::PrintErrorMessage( |
|
3511 const TDesC& |
|
3512 #ifdef PRINT_MESSAGE |
|
3513 aQueryFired |
|
3514 #endif |
|
3515 ,TInt |
|
3516 #ifdef PRINT_MESSAGE |
|
3517 aErrorCode |
|
3518 #endif |
|
3519 ,TInt |
|
3520 #ifdef PRINT_MESSAGE |
|
3521 aOperationCode |
|
3522 #endif |
|
3523 ) |
|
3524 { |
|
3525 #ifdef PRINT_MESSAGE |
|
3526 |
|
3527 LogQuery(aQueryFired); |
|
3528 TBuf<64> buf; |
|
3529 |
|
3530 if(!(aOperationCode == 4 || aOperationCode == 3 || aOperationCode == 7)) |
|
3531 { |
|
3532 buf.Copy(iDb.LastErrorMessage()); |
|
3533 TRACETEXT(buf) |
|
3534 } |
|
3535 |
|
3536 switch(aOperationCode) |
|
3537 { |
|
3538 case 0: |
|
3539 { |
|
3540 buf.Copy(_L("DB Created with error code...")); |
|
3541 break; |
|
3542 } |
|
3543 case 1 : |
|
3544 { |
|
3545 buf.Copy(_L("Table Created With Error Code...")); |
|
3546 break; |
|
3547 } |
|
3548 case 2 : |
|
3549 { |
|
3550 buf.Copy(_L("Record Inserted With Error Code...")); |
|
3551 break; |
|
3552 } |
|
3553 case 3: |
|
3554 { |
|
3555 buf.Copy(_L("DB Opened with error code...")); |
|
3556 break; |
|
3557 } |
|
3558 case 4: |
|
3559 { |
|
3560 buf.Copy(_L("Security Policy error code ... ")); |
|
3561 break; |
|
3562 } |
|
3563 |
|
3564 case 5: |
|
3565 { |
|
3566 buf.Copy(_L("Record Deleted with error code...")); |
|
3567 break; |
|
3568 } |
|
3569 case 6: |
|
3570 { |
|
3571 buf.Copy(_L("Record Updated with error code...")); |
|
3572 break; |
|
3573 } |
|
3574 case 7: |
|
3575 { |
|
3576 buf.Copy(_L("Retrieved from CRep with error code")); |
|
3577 } |
|
3578 break; |
|
3579 case 8: |
|
3580 { |
|
3581 buf.Copy(_L("InsertSLPRecordL completed. Reason ")); |
|
3582 } |
|
3583 break; |
|
3584 case 9: |
|
3585 { |
|
3586 buf.Copy(_L("UpdateDefaultServerL completed. Reason ")); |
|
3587 } |
|
3588 break; |
|
3589 case 10: |
|
3590 { |
|
3591 buf.Copy(_L("UpdateSLPRecordL completed. Reason ")); |
|
3592 } |
|
3593 break; |
|
3594 case 11: |
|
3595 { |
|
3596 buf.Copy(_L("DeleteSLPRecordL completed. Reason ")); |
|
3597 } |
|
3598 case 12 : |
|
3599 { |
|
3600 buf.Copy(_L("SetSLPAsDefaultL completed. Reason ")); |
|
3601 } |
|
3602 break; |
|
3603 case 13 : |
|
3604 { |
|
3605 buf.Copy(_L("Record Retreived with error code...")); |
|
3606 break; |
|
3607 } |
|
3608 case 14: |
|
3609 { |
|
3610 buf.Copy(_L("GetDefaultSLPId completed. Reason")); |
|
3611 } |
|
3612 break; |
|
3613 case 15 : |
|
3614 { |
|
3615 buf.Copy(_L("IsSlpExists completed. Return Code ")); |
|
3616 } |
|
3617 break; |
|
3618 case 16: |
|
3619 { |
|
3620 buf.Copy(_L("SlpCount Completed. Count ")); |
|
3621 } |
|
3622 break; |
|
3623 case 17: |
|
3624 { |
|
3625 buf.Copy(_L("GetDefaultServer completed. Reason ")); |
|
3626 } |
|
3627 break; |
|
3628 case 18: |
|
3629 { |
|
3630 buf.Copy(_L("GetNwInfoPropertiesL completed. Reason ")); |
|
3631 } |
|
3632 break; |
|
3633 default: |
|
3634 { |
|
3635 buf.Copy(_L("Unknown Operation Completed With Error Code...")); |
|
3636 } |
|
3637 break; |
|
3638 } |
|
3639 |
|
3640 buf.AppendNum(aErrorCode); |
|
3641 TRACETEXT(buf) |
|
3642 |
|
3643 #endif |
|
3644 } |
|
3645 |
|
3646 // --------------------------------------------------------------------------- |
|
3647 // CSettingsDatabaseHandler::LogQuery(const TDesC& aBuffer) |
|
3648 // |
|
3649 // Used to print error messages. Used for logging purposes |
|
3650 // --------------------------------------------------------------------------- |
|
3651 void CSettingsDatabaseHandler::LogQuery(const TDesC& |
|
3652 #ifdef PRINT_MESSAGE |
|
3653 aBuffer |
|
3654 #endif |
|
3655 ) |
|
3656 { |
|
3657 #ifdef PRINT_MESSAGE |
|
3658 const TInt MaxLength = 125; |
|
3659 TBuf<MaxLength> buff; |
|
3660 TInt len = aBuffer.Length(); |
|
3661 if(len == 0) return; |
|
3662 TInt start = 0; |
|
3663 while(start<=len) |
|
3664 { |
|
3665 if( len - start > MaxLength) |
|
3666 buff.Copy(aBuffer.Mid(start,MaxLength)); |
|
3667 else |
|
3668 buff.Copy(aBuffer.Mid(start)); |
|
3669 |
|
3670 TRACETEXT(buff) |
|
3671 start = start + MaxLength; |
|
3672 |
|
3673 } |
|
3674 #endif |
|
3675 } |
|
3676 |
|
3677 // --------------------------------------------------------------------------- |
|
3678 // CSettingsDatabaseHandler::LogAllSLP() |
|
3679 // |
|
3680 // |
|
3681 // --------------------------------------------------------------------------- |
|
3682 |
|
3683 void CSettingsDatabaseHandler::LogAllSLP() |
|
3684 { |
|
3685 #ifdef PRINT_MESSAGE |
|
3686 TBuf<KCustomSqlMaxLength> sqlString; |
|
3687 sqlString.Append(KSelect); |
|
3688 sqlString.Append(KStar); |
|
3689 sqlString.Append(KFrom); |
|
3690 sqlString.Append(KCreateTableName); |
|
3691 sqlString.Append(KOrderBy); |
|
3692 sqlString.Append(KColPriority); |
|
3693 sqlString.Append(KCommaSeparator); |
|
3694 sqlString.Append(KColSLPId); |
|
3695 |
|
3696 RSqlStatement stmt; |
|
3697 TInt err = stmt.Prepare(iDb, sqlString); |
|
3698 |
|
3699 TInt64 SLPId = -1; |
|
3700 TBuf<256> ServerAddress,Manufacturer1,Iap; |
|
3701 TBuf<10> priorityBuf; |
|
3702 TBuf<256> lastusetime; |
|
3703 TBuf<256> lasttried; |
|
3704 TInt otherprops; |
|
3705 TBuf<10> otherpropbuf; |
|
3706 TBuf<10> slpIdBuf; |
|
3707 |
|
3708 TTime TimeLastUse; |
|
3709 TTime TimeLastTried; |
|
3710 TInt priority = 0; |
|
3711 TInt columnIndexSLPID = stmt.ColumnIndex(KColSLPId); |
|
3712 TInt columnIndexSLPAddress = stmt.ColumnIndex(KColSLPAddress); |
|
3713 TInt columnIndexMajorVersion = stmt.ColumnIndex(KColProtocolVersionMajor); |
|
3714 TInt columnIndexIAP = stmt.ColumnIndex(KColIap); |
|
3715 TInt columnIndexTimeLastUse = stmt.ColumnIndex(KColTimeLastUse); |
|
3716 TInt columnIndexTimeLastTried = stmt.ColumnIndex(KColTimeLastTried); |
|
3717 |
|
3718 TInt columnIndexNetInfoLastUse = stmt.ColumnIndex(KColNetInfoLastUse); |
|
3719 TInt columnIndexNetInfoLastSucess = stmt.ColumnIndex(KColNetInfoLastSucess); |
|
3720 TInt columnIndexOtherProperties = stmt.ColumnIndex(KColOtherProperties); |
|
3721 TInt columnIndexPriority = stmt.ColumnIndex(KColPriority); |
|
3722 while((err=stmt.Next())==KSqlAtRow) |
|
3723 { |
|
3724 SLPId = stmt.ColumnInt(columnIndexSLPID); |
|
3725 priority = stmt.ColumnInt(columnIndexPriority); |
|
3726 stmt.ColumnText(columnIndexSLPAddress,ServerAddress); |
|
3727 stmt.ColumnText(columnIndexIAP,Iap); |
|
3728 stmt.ColumnText(columnIndexTimeLastUse,lastusetime); |
|
3729 stmt.ColumnText(columnIndexTimeLastTried,lasttried); |
|
3730 otherprops = stmt.ColumnInt(columnIndexOtherProperties); |
|
3731 otherpropbuf.Zero(); |
|
3732 otherpropbuf.AppendNum(otherprops); |
|
3733 priorityBuf.Zero(); |
|
3734 priorityBuf.AppendNum(priority); |
|
3735 slpIdBuf.Zero(); |
|
3736 slpIdBuf.AppendNum(SLPId); |
|
3737 TRACETEXT(slpIdBuf) |
|
3738 TRACETEXT(priorityBuf) |
|
3739 TRACETEXT(ServerAddress) |
|
3740 TRACETEXT(Iap) |
|
3741 TRACETEXT(Manufacturer1) |
|
3742 TRACETEXT(lastusetime) |
|
3743 TRACETEXT(lasttried) |
|
3744 TRACETEXT(otherpropbuf) |
|
3745 |
|
3746 } |
|
3747 |
|
3748 stmt.Close(); |
|
3749 #endif |
|
3750 } |