|
1 /* |
|
2 * Copyright (c) 2009-2010 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: |
|
15 * Implementation of plugin base class |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 #include <datamobilitycommsdattypes.h> |
|
21 #include <cmpluginbaseeng.h> |
|
22 #include <cmpsettingsconsts.h> |
|
23 #include <FeatMgr.h> |
|
24 |
|
25 #include "ccmpluginbaseengtextresolver.h" |
|
26 |
|
27 #include "OstTraceDefinitions.h" |
|
28 #ifdef OST_TRACE_COMPILER_IN_USE |
|
29 #include "ccmpluginbaseengTraces.h" |
|
30 #endif |
|
31 |
|
32 |
|
33 using namespace CMManager; |
|
34 using namespace CommsDat; |
|
35 |
|
36 const TInt KApMaxConnNameLength = 30; |
|
37 _LIT( KFormatPostfix, "%02d" ); |
|
38 _LIT( KFormatLargePostfix, "%d" ); |
|
39 _LIT( KFormatNameWithPostfix, "%S(%S)" ); |
|
40 _LIT( KFormatNoPostfix, "%S" ); |
|
41 const TInt KMaxPostfixLength = 5; |
|
42 |
|
43 _LIT( KDefWapGatewayIpAddress, "0.0.0.0" ); |
|
44 |
|
45 _LIT( KLocationName, "Mobile" ); |
|
46 |
|
47 _LIT( KDefaultIapName, "Connection Method" ); |
|
48 |
|
49 |
|
50 EXPORT_C CCmClientPluginInstance* CCmClientPluginInstance::NewLC() |
|
51 { |
|
52 OstTraceFunctionEntry0( CCMCLIENTPLUGININSTANCE_NEWLC_ENTRY ); |
|
53 |
|
54 CCmClientPluginInstance* self = new( ELeave ) CCmClientPluginInstance(); |
|
55 CleanupStack::PushL( self ); |
|
56 self->ConstructL(); |
|
57 |
|
58 OstTraceFunctionExit0( CCMCLIENTPLUGININSTANCE_NEWLC_EXIT ); |
|
59 return self; |
|
60 } |
|
61 |
|
62 EXPORT_C CCmClientPluginInstance* CCmClientPluginInstance::NewL() |
|
63 { |
|
64 OstTraceFunctionEntry0( CCMCLIENTPLUGININSTANCE_NEWL_ENTRY ); |
|
65 |
|
66 CCmClientPluginInstance* self = CCmClientPluginInstance::NewLC(); |
|
67 CleanupStack::Pop( self ); |
|
68 |
|
69 OstTraceFunctionExit0( CCMCLIENTPLUGININSTANCE_NEWL_EXIT ); |
|
70 return self; |
|
71 } |
|
72 |
|
73 CCmClientPluginInstance::CCmClientPluginInstance() |
|
74 : |
|
75 iNamingMethod( ENamingUnique ), |
|
76 iLocationEnabled( EFalse ), |
|
77 iIapId( 0 ) |
|
78 { |
|
79 } |
|
80 |
|
81 EXPORT_C CCmClientPluginInstance::~CCmClientPluginInstance() |
|
82 { |
|
83 OstTraceFunctionEntry0( CCMCLIENTPLUGININSTANCE_CCMCLIENTPLUGININSTANCE_ENTRY ); |
|
84 |
|
85 iGenRecordArray.ResetAndDestroy(); |
|
86 iBearerSpecRecordArray.ResetAndDestroy(); |
|
87 |
|
88 OstTraceFunctionExit0( CCMCLIENTPLUGININSTANCE_CCMCLIENTPLUGININSTANCE_EXIT ); |
|
89 } |
|
90 |
|
91 // --------------------------------------------------------------------------- |
|
92 // Second phase constructor. |
|
93 // --------------------------------------------------------------------------- |
|
94 // |
|
95 void CCmClientPluginInstance::ConstructL() |
|
96 { |
|
97 OstTraceFunctionEntry0( CCMCLIENTPLUGININSTANCE_CONSTRUCTL_ENTRY ); |
|
98 OstTraceFunctionExit0( CCMCLIENTPLUGININSTANCE_CONSTRUCTL_EXIT ); |
|
99 } |
|
100 |
|
101 |
|
102 // --------------------------------------------------------------------------- |
|
103 // TCmPluginInitParam::TCmPluginInitParam |
|
104 // --------------------------------------------------------------------------- |
|
105 // |
|
106 EXPORT_C TCmPluginInitParam::TCmPluginInitParam( CommsDat::CMDBSession& aSession ) |
|
107 : |
|
108 iSessionRef( aSession ) |
|
109 { |
|
110 OstTraceFunctionEntry0( TCMPLUGININITPARAM_TCMPLUGININITPARAM_ENTRY ); |
|
111 |
|
112 iNotused1 = NULL; |
|
113 iNotused2 = NULL; |
|
114 |
|
115 OstTraceFunctionExit0( TCMPLUGININITPARAM_TCMPLUGININITPARAM_EXIT ); |
|
116 } |
|
117 |
|
118 // --------------------------------------------------------------------------- |
|
119 // CCmPluginBaseEng::CCmPluginBaseEng |
|
120 // --------------------------------------------------------------------------- |
|
121 // |
|
122 EXPORT_C CCmPluginBaseEng::CCmPluginBaseEng( TCmPluginInitParam *aInitParam ) |
|
123 : |
|
124 iSession( aInitParam->iSessionRef ), |
|
125 iNamingMethod( ENamingUnique ) |
|
126 { |
|
127 OstTraceFunctionEntry0( CCMPLUGINBASEENG_CCMPLUGINBASEENG_ENTRY ); |
|
128 |
|
129 iDtor_ID_Key.iUid = 0; |
|
130 iBearerType = 0; |
|
131 |
|
132 iIapRecord = NULL; |
|
133 iProxyRecord = NULL; |
|
134 iServiceRecord = NULL; |
|
135 iNetworkRecord = NULL; |
|
136 iLocationRecord = NULL; |
|
137 iWapAPRecord = NULL; |
|
138 iWapIPBearerRecord = NULL; |
|
139 iMetaDataRecord = NULL; |
|
140 |
|
141 iIapId = 0; |
|
142 iMetadataTableId = 0; |
|
143 iLocationEnabled = EFalse; |
|
144 |
|
145 OstTraceFunctionExit0( CCMPLUGINBASEENG_CCMPLUGINBASEENG_EXIT ); |
|
146 } |
|
147 |
|
148 // --------------------------------------------------------------------------- |
|
149 // CCmPluginBaseEng::~CCmPluginBaseEng |
|
150 // --------------------------------------------------------------------------- |
|
151 // |
|
152 EXPORT_C CCmPluginBaseEng::~CCmPluginBaseEng() |
|
153 { |
|
154 OstTraceFunctionEntry0( DUP1_CCMPLUGINBASEENG_CCMPLUGINBASEENG_ENTRY ); |
|
155 |
|
156 iIapId = 0; |
|
157 delete iIapRecord; iIapRecord = NULL; |
|
158 delete iProxyRecord; iProxyRecord = NULL; |
|
159 delete iServiceRecord; iServiceRecord = NULL; |
|
160 delete iNetworkRecord; iNetworkRecord = NULL; |
|
161 delete iLocationRecord; iLocationRecord = NULL; |
|
162 delete iWapAPRecord; iWapAPRecord = NULL; |
|
163 delete iWapIPBearerRecord; iWapIPBearerRecord = NULL; |
|
164 delete iMetaDataRecord; iMetaDataRecord = NULL; |
|
165 |
|
166 iLocationEnabled = EFalse; |
|
167 |
|
168 REComSession::DestroyedImplementation( iDtor_ID_Key ); |
|
169 |
|
170 OstTraceFunctionExit0( DUP1_CCMPLUGINBASEENG_CCMPLUGINBASEENG_EXIT ); |
|
171 } |
|
172 |
|
173 // --------------------------------------------------------------------------- |
|
174 // CCmPluginBaseEng::ConstructL |
|
175 // --------------------------------------------------------------------------- |
|
176 // |
|
177 EXPORT_C void CCmPluginBaseEng::ConstructL() |
|
178 { |
|
179 OstTraceFunctionEntry0( CCMPLUGINBASEENG_CONSTRUCTL_ENTRY ); |
|
180 |
|
181 TRAPD( err, iMetadataTableId = CCDIAPMetadataRecord::TableIdL( iSession ) ); |
|
182 if ( err ) |
|
183 { |
|
184 if ( err == KErrNotFound ) |
|
185 { |
|
186 iMetadataTableId = CCDIAPMetadataRecord::CreateTableL( iSession ); |
|
187 } |
|
188 else |
|
189 { |
|
190 User::LeaveIfError( err ); |
|
191 } |
|
192 } |
|
193 |
|
194 OstTraceFunctionExit0( CCMPLUGINBASEENG_CONSTRUCTL_EXIT ); |
|
195 } |
|
196 |
|
197 // --------------------------------------------------------------------------- |
|
198 // CCmPluginBaseEng::UpdateL |
|
199 // --------------------------------------------------------------------------- |
|
200 // |
|
201 EXPORT_C void CCmPluginBaseEng::UpdateL( |
|
202 CCmClientPluginInstance* aClientPluginInstance ) |
|
203 { |
|
204 OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEL_ENTRY ); |
|
205 |
|
206 PrepareToUpdateRecordsL( aClientPluginInstance ); |
|
207 |
|
208 UpdateServiceRecordL( aClientPluginInstance ); |
|
209 UpdateLocationRecordL( aClientPluginInstance ); |
|
210 UpdateNetworkRecordL( aClientPluginInstance ); |
|
211 UpdateIAPRecordL( aClientPluginInstance ); |
|
212 UpdateWapRecordL( aClientPluginInstance ); |
|
213 UpdateProxyRecordL( aClientPluginInstance ); |
|
214 UpdateMetadataRecordL( aClientPluginInstance ); |
|
215 UpdateConnPrefSettingL(); |
|
216 |
|
217 UpdateBearerRecordsL( |
|
218 aClientPluginInstance->iGenRecordArray, |
|
219 aClientPluginInstance->iBearerSpecRecordArray ); |
|
220 |
|
221 OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATEL_EXIT ); |
|
222 } |
|
223 |
|
224 // --------------------------------------------------------------------------- |
|
225 // Delete this connection methond. |
|
226 // Record ids are checked to be sure that we delete only records |
|
227 // that were loaded before. |
|
228 // --------------------------------------------------------------------------- |
|
229 // |
|
230 EXPORT_C void CCmPluginBaseEng::DeleteL() |
|
231 { |
|
232 OstTraceFunctionEntry0( CCMPLUGINBASEENG_DELETEL_ENTRY ); |
|
233 |
|
234 PrepareToDeleteRecordsL(); |
|
235 |
|
236 if ( iIapRecord && iIapRecord->RecordId() ) |
|
237 { |
|
238 iIapRecord->DeleteL( iSession ); |
|
239 } |
|
240 |
|
241 if ( iProxyRecord && iProxyRecord->RecordId() ) |
|
242 { |
|
243 iProxyRecord->DeleteL( iSession ); |
|
244 } |
|
245 |
|
246 if ( iServiceRecord && iServiceRecord->RecordId() ) |
|
247 { |
|
248 iServiceRecord->DeleteL( iSession ); |
|
249 } |
|
250 |
|
251 if ( iNetworkRecord && iNetworkRecord->RecordId() ) |
|
252 { |
|
253 iNetworkRecord->DeleteL( iSession ); |
|
254 } |
|
255 |
|
256 if ( iLocationRecord && iLocationRecord->RecordId() ) |
|
257 { |
|
258 iLocationRecord->DeleteL( iSession ); |
|
259 } |
|
260 |
|
261 if ( iWapAPRecord && iWapAPRecord->RecordId() ) |
|
262 { |
|
263 iWapAPRecord->DeleteL( iSession ); |
|
264 } |
|
265 |
|
266 if ( iWapIPBearerRecord && iWapIPBearerRecord->RecordId() ) |
|
267 { |
|
268 iWapIPBearerRecord->DeleteL( iSession ); |
|
269 } |
|
270 |
|
271 if ( iMetaDataRecord && iMetaDataRecord->RecordId() ) |
|
272 { |
|
273 iMetaDataRecord->DeleteL( iSession ); |
|
274 } |
|
275 |
|
276 DeleteBearerRecordsL(); |
|
277 |
|
278 OstTraceFunctionExit0( CCMPLUGINBASEENG_DELETEL_EXIT ); |
|
279 } |
|
280 |
|
281 // --------------------------------------------------------------------------- |
|
282 // CCmPluginBaseEng::ReLoad |
|
283 // --------------------------------------------------------------------------- |
|
284 // |
|
285 EXPORT_C void CCmPluginBaseEng::ReLoadL() |
|
286 { |
|
287 OstTraceFunctionEntry0( CCMPLUGINBASEENG_RELOAD_ENTRY ); |
|
288 |
|
289 delete iIapRecord; iIapRecord = NULL; |
|
290 delete iProxyRecord; iProxyRecord = NULL; |
|
291 delete iServiceRecord; iServiceRecord = NULL; |
|
292 delete iNetworkRecord; iNetworkRecord = NULL; |
|
293 delete iLocationRecord; iLocationRecord = NULL; |
|
294 delete iWapAPRecord; iWapAPRecord = NULL; |
|
295 delete iWapIPBearerRecord; iWapIPBearerRecord = NULL; |
|
296 delete iMetaDataRecord; iMetaDataRecord = NULL; |
|
297 |
|
298 iLocationEnabled = EFalse; |
|
299 |
|
300 ResetBearerRecords(); |
|
301 |
|
302 LoadL( iIapId ); |
|
303 |
|
304 OstTraceFunctionExit0( CCMPLUGINBASEENG_RELOAD_EXIT ); |
|
305 } |
|
306 |
|
307 // --------------------------------------------------------------------------- |
|
308 // CCmPluginBaseEng::LoadL |
|
309 // --------------------------------------------------------------------------- |
|
310 // |
|
311 EXPORT_C void CCmPluginBaseEng::LoadL( TUint32 aIapId ) |
|
312 { |
|
313 OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADL_ENTRY ); |
|
314 |
|
315 DoLoadL( aIapId ); |
|
316 |
|
317 OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADL_EXIT ); |
|
318 } |
|
319 |
|
320 // --------------------------------------------------------------------------- |
|
321 // CCmPluginBaseEng::CreateNewL |
|
322 // --------------------------------------------------------------------------- |
|
323 // |
|
324 EXPORT_C void CCmPluginBaseEng::CreateNewL( TUint32 aCmId ) |
|
325 { |
|
326 OstTraceFunctionEntry0( CCMPLUGINBASEENG_CREATENEWL_ENTRY ); |
|
327 |
|
328 if ( iIapId ) |
|
329 // we already have IAP id -> |
|
330 { |
|
331 User::Leave( KErrAlreadyExists ); |
|
332 } |
|
333 |
|
334 // optional record is disabled in default |
|
335 iLocationEnabled = EFalse; |
|
336 |
|
337 // create mandatory records |
|
338 iIapRecord = static_cast<CCDIAPRecord *> |
|
339 (CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord)); |
|
340 iNetworkRecord = static_cast<CCDNetworkRecord *> |
|
341 (CCDRecordBase::RecordFactoryL(KCDTIdNetworkRecord)); |
|
342 iProxyRecord = static_cast<CCDProxiesRecord *> |
|
343 (CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord)); |
|
344 NewWapRecordL(); |
|
345 iWapIPBearerRecord->iWAPGatewayAddress.SetL( KDefWapGatewayIpAddress ); |
|
346 |
|
347 iMetaDataRecord = NewMetadataRecordL( ETrue ); |
|
348 |
|
349 // call plugin to create its own records |
|
350 CreateServiceRecordL(); |
|
351 |
|
352 // Update iaprecord servicetype name |
|
353 HBufC* servicetypeName( NULL ); |
|
354 ServiceRecordNameLC( servicetypeName ); |
|
355 iIapRecord->iServiceType.SetL( *servicetypeName ); |
|
356 CleanupStack::PopAndDestroy( servicetypeName ); |
|
357 |
|
358 // Update iaprecord bearertype name |
|
359 HBufC* bearerTypeName( NULL ); |
|
360 BearerRecordNameLC( bearerTypeName ); |
|
361 iIapRecord->iBearerType.SetL( *bearerTypeName ); |
|
362 CleanupStack::PopAndDestroy( bearerTypeName ); |
|
363 |
|
364 CreateBearerRecordsL(); |
|
365 |
|
366 EnableProxyL( EFalse ); |
|
367 |
|
368 _LIT(KDefaultConnNameTextId, "txt_occ_setlabel_connection_name_val_connection"); |
|
369 HBufC* resolvedText( NULL ); |
|
370 resolvedText = CCmPluginBaseEngTextResolver::ResolveTextL( KDefaultConnNameTextId ); |
|
371 if ( resolvedText != NULL ) |
|
372 { |
|
373 SetDefaultNameL( *resolvedText ); |
|
374 } |
|
375 else |
|
376 { |
|
377 SetDefaultNameL( KDefaultIapName ); |
|
378 } |
|
379 |
|
380 delete resolvedText; |
|
381 resolvedText = NULL; |
|
382 |
|
383 iIapRecord->iNetworkWeighting = 0; // it's always 0. |
|
384 |
|
385 if ( aCmId != 0 ) |
|
386 { |
|
387 iIapRecord->SetRecordId( aCmId ); |
|
388 iIapId = 0; |
|
389 } |
|
390 else |
|
391 { |
|
392 iIapRecord->SetRecordId( KCDNewRecordRequest ); |
|
393 } |
|
394 |
|
395 OstTraceFunctionExit0( CCMPLUGINBASEENG_CREATENEWL_EXIT ); |
|
396 } |
|
397 |
|
398 // --------------------------------------------------------------------------- |
|
399 // CCmPluginBaseEng::CreateCopyL |
|
400 // --------------------------------------------------------------------------- |
|
401 // |
|
402 EXPORT_C CCmPluginBaseEng* CCmPluginBaseEng::CreateCopyL( |
|
403 CCmClientPluginInstance* /*aClientPluginInstance*/ ) |
|
404 { |
|
405 OstTraceFunctionEntry0( CCMPLUGINBASEENG_CREATECOPYL_ENTRY ); |
|
406 |
|
407 TCmPluginInitParam params( iSession ); |
|
408 |
|
409 CCmPluginBaseEng* copyInst = CreateInstanceL( params ); |
|
410 CleanupStack::PushL( copyInst ); |
|
411 |
|
412 PrepareToCopyDataL( copyInst ); |
|
413 |
|
414 CopyDataL( copyInst ); |
|
415 |
|
416 CleanupStack::Pop( copyInst ); |
|
417 |
|
418 OstTraceFunctionExit0( CCMPLUGINBASEENG_CREATECOPYL_EXIT ); |
|
419 |
|
420 return copyInst; |
|
421 } |
|
422 |
|
423 // --------------------------------------------------------------------------- |
|
424 // CCmPluginBaseEng::GetGenericTableIdsToBeObserved |
|
425 // --------------------------------------------------------------------------- |
|
426 // |
|
427 EXPORT_C void CCmPluginBaseEng::GetGenericTableIdsToBeObserved( |
|
428 RArray<TUint32>& aTableIdArray ) const |
|
429 { |
|
430 // Service and bearer records should be added by plugins |
|
431 |
|
432 aTableIdArray.Append( KCDTIdIAPRecord ); |
|
433 aTableIdArray.Append( KCDTIdWAPAccessPointRecord ); |
|
434 aTableIdArray.Append( KCDTIdProxiesRecord ); |
|
435 aTableIdArray.Append( iMetadataTableId ); |
|
436 } |
|
437 |
|
438 // --------------------------------------------------------------------------- |
|
439 // CCmPluginBaseEng::CopyDataL |
|
440 // --------------------------------------------------------------------------- |
|
441 // |
|
442 void CCmPluginBaseEng::CopyDataL( CCmPluginBaseEng* aCopyInstance ) |
|
443 { |
|
444 OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYDATAL_ENTRY ); |
|
445 |
|
446 aCopyInstance->iLocationEnabled = iLocationEnabled; |
|
447 aCopyInstance->iNamingMethod = iNamingMethod; |
|
448 CopyRecordsL( aCopyInstance ); |
|
449 |
|
450 OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYDATAL_EXIT ); |
|
451 } |
|
452 |
|
453 // --------------------------------------------------------------------------- |
|
454 // CCmPluginBaseEng::CopyRecordsL |
|
455 // --------------------------------------------------------------------------- |
|
456 // |
|
457 void CCmPluginBaseEng::CopyRecordsL( CCmPluginBaseEng* aCopyInstance ) |
|
458 { |
|
459 OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYRECORDSL_ENTRY ); |
|
460 |
|
461 CopyRecordDataL( KIapRecordIndex, aCopyInstance ); |
|
462 |
|
463 // Ensure that iap's name is set by the rules(Naming Method) |
|
464 SetNameL( iIapRecord->iRecordName.GetL(), |
|
465 aCopyInstance->iIapRecord, |
|
466 aCopyInstance->iNamingMethod ); |
|
467 |
|
468 CopyRecordDataL( KServiceRecordIndex, aCopyInstance ); |
|
469 CopyRecordDataL( KNetworkRecordIndex, aCopyInstance ); |
|
470 CopyRecordDataL( KWAPAPRecordIndex, aCopyInstance ); |
|
471 CopyRecordDataL( KWAPBearerRecordIndex, aCopyInstance ); |
|
472 CopyRecordDataL( KMetaDataRecordIndex, aCopyInstance ); |
|
473 CopyRecordDataL( KLocationRecordIndex, aCopyInstance ); |
|
474 CopyRecordDataL( KProxyRecordIndex, aCopyInstance ); |
|
475 |
|
476 CopyBearerRecordsL( aCopyInstance ); |
|
477 |
|
478 OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYRECORDSL_EXIT ); |
|
479 } |
|
480 |
|
481 // --------------------------------------------------------------------------- |
|
482 // CCmPluginBaseEng::CopyRecordDataL |
|
483 // --------------------------------------------------------------------------- |
|
484 // |
|
485 void CCmPluginBaseEng::CopyRecordDataL( TUint32 aRecordIdentifier, |
|
486 CCmPluginBaseEng* aCopyInstance ) |
|
487 { |
|
488 OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYRECORDDATAL_ENTRY ); |
|
489 |
|
490 switch( aRecordIdentifier ) |
|
491 { |
|
492 case KIapRecordIndex: |
|
493 { |
|
494 aCopyInstance->iIapRecord = |
|
495 static_cast<CCDIAPRecord*>( CCDRecordBase::CreateCopyRecordL( *iIapRecord ) ); |
|
496 } |
|
497 break; |
|
498 case KServiceRecordIndex: |
|
499 { |
|
500 aCopyInstance->iServiceRecord = CopyServiceRecordL(); |
|
501 } |
|
502 break; |
|
503 case KNetworkRecordIndex: |
|
504 { |
|
505 aCopyInstance->iNetworkRecord = |
|
506 static_cast<CCDNetworkRecord*>( CCDRecordBase::CreateCopyRecordL( *iNetworkRecord ) ); |
|
507 } |
|
508 break; |
|
509 case KWAPAPRecordIndex: |
|
510 { |
|
511 aCopyInstance->iWapAPRecord = |
|
512 static_cast<CCDWAPAccessPointRecord*>( CCDRecordBase::CreateCopyRecordL( *iWapAPRecord ) ); |
|
513 } |
|
514 break; |
|
515 case KWAPBearerRecordIndex: |
|
516 { |
|
517 aCopyInstance->iWapIPBearerRecord = |
|
518 static_cast<CCDWAPIPBearerRecord*>( CCDRecordBase::CreateCopyRecordL( *iWapIPBearerRecord ) ); |
|
519 } |
|
520 break; |
|
521 case KMetaDataRecordIndex: |
|
522 { |
|
523 aCopyInstance->iMetaDataRecord = new (ELeave) CCDIAPMetadataRecord( iMetadataTableId ); |
|
524 aCopyInstance->iMetaDataRecord->iIAP = IAPRecordElementId(); |
|
525 aCopyInstance->iMetaDataRecord->iMetadata.SetL( iMetaDataRecord->iMetadata ); |
|
526 aCopyInstance->iMetaDataRecord->iSeamlessness.SetL( iMetaDataRecord->iSeamlessness ); |
|
527 } |
|
528 break; |
|
529 case KLocationRecordIndex: |
|
530 { |
|
531 aCopyInstance->iWapIPBearerRecord = |
|
532 static_cast<CCDWAPIPBearerRecord*> |
|
533 ( CCDRecordBase::CreateCopyRecordL( *iWapIPBearerRecord ) ); |
|
534 } |
|
535 break; |
|
536 case KProxyRecordIndex: |
|
537 { |
|
538 if ( iProxyRecord ) |
|
539 { |
|
540 aCopyInstance->iProxyRecord = static_cast<CCDProxiesRecord*> |
|
541 ( CCDRecordBase::CreateCopyRecordL( *iProxyRecord ) ); |
|
542 } |
|
543 } |
|
544 break; |
|
545 default: |
|
546 { |
|
547 User::Leave( KErrArgument ); |
|
548 } |
|
549 } |
|
550 OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYRECORDDATAL_EXIT ); |
|
551 } |
|
552 |
|
553 // --------------------------------------------------------------------------- |
|
554 // CCmPluginBaseEng::DoLoadL |
|
555 // --------------------------------------------------------------------------- |
|
556 // |
|
557 void CCmPluginBaseEng::DoLoadL( TUint32 aIapId ) |
|
558 { |
|
559 OstTraceFunctionEntry0( CCMPLUGINBASEENG_DOLOADL_ENTRY ); |
|
560 |
|
561 PrepareToLoadRecordsL(); |
|
562 |
|
563 LoadIAPRecordL( aIapId ); |
|
564 LoadWapRecordL(); |
|
565 LoadMetadataRecordL(); |
|
566 LoadNetworkRecordL(); |
|
567 LoadLocationRecordL(); |
|
568 |
|
569 // This is a connectionmethodinfo instance, that has no |
|
570 // service and proxy setting. |
|
571 if ( KDummyBearerType != iBearerType ) |
|
572 { |
|
573 LoadServiceRecordL(); |
|
574 LoadProxyRecordL(); |
|
575 } |
|
576 |
|
577 LoadBearerRecordsL(); |
|
578 |
|
579 OstTraceFunctionExit0( CCMPLUGINBASEENG_DOLOADL_EXIT ); |
|
580 } |
|
581 |
|
582 // --------------------------------------------------------------------------- |
|
583 // CCmPluginBaseEng::PrepareToLoadRecordsL |
|
584 // --------------------------------------------------------------------------- |
|
585 // |
|
586 void CCmPluginBaseEng::PrepareToLoadRecordsL() |
|
587 { |
|
588 OstTraceFunctionEntry0( CCMPLUGINBASEENG_PREPARETOLOADRECORDSL_ENTRY ); |
|
589 |
|
590 iLocationEnabled = EFalse; |
|
591 PreparePluginToLoadRecordsL(); |
|
592 |
|
593 OstTraceFunctionExit0( CCMPLUGINBASEENG_PREPARETOLOADRECORDSL_EXIT ); |
|
594 } |
|
595 |
|
596 // --------------------------------------------------------------------------- |
|
597 // CCmPluginBaseEng::LoadIAPRecordL |
|
598 // --------------------------------------------------------------------------- |
|
599 // |
|
600 void CCmPluginBaseEng::LoadIAPRecordL( TUint32 aIapId ) |
|
601 { |
|
602 OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADIAPRECORDL_ENTRY ); |
|
603 |
|
604 iIapId = aIapId; |
|
605 |
|
606 // Load IAP record |
|
607 CCDIAPRecord *iapRecord = static_cast<CCDIAPRecord *>( |
|
608 CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) ); |
|
609 |
|
610 CleanupStack::PushL( iapRecord ); |
|
611 |
|
612 iapRecord->SetRecordId( iIapId ); |
|
613 iapRecord->LoadL( iSession ); |
|
614 |
|
615 CleanupStack::Pop( iapRecord ); |
|
616 iIapRecord = iapRecord; |
|
617 |
|
618 OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADIAPRECORDL_EXIT ); |
|
619 } |
|
620 |
|
621 // --------------------------------------------------------------------------- |
|
622 // CCmPluginBaseEng::LoadProxySettingL |
|
623 // --------------------------------------------------------------------------- |
|
624 // |
|
625 void CCmPluginBaseEng::LoadProxyRecordL() |
|
626 { |
|
627 OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADPROXYSETTINGL_ENTRY ); |
|
628 |
|
629 // Load Proxy record |
|
630 CMDBRecordSet<CCDProxiesRecord>* proxieRS = |
|
631 new( ELeave ) CMDBRecordSet<CCDProxiesRecord>( KCDTIdProxiesRecord ); |
|
632 CleanupStack::PushL(proxieRS); |
|
633 |
|
634 // Now try to find the linked proxy record |
|
635 // create new record |
|
636 CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord *>( |
|
637 CCDRecordBase::RecordFactoryL( KCDTIdProxiesRecord ) ); |
|
638 |
|
639 CleanupStack::PushL( proxyRecord ); |
|
640 |
|
641 // Prime record |
|
642 TPtrC serviceType( iIapRecord->iServiceType ); |
|
643 proxyRecord->iServiceType.SetL( serviceType ); |
|
644 proxieRS->iRecords.AppendL( proxyRecord ); // Ownership transfered. |
|
645 |
|
646 CleanupStack::Pop( proxyRecord ); |
|
647 proxyRecord = NULL; |
|
648 |
|
649 if ( proxieRS->FindL(iSession) ) |
|
650 { |
|
651 TInt i( 0 ); |
|
652 while( i < proxieRS->iRecords.Count() ) |
|
653 // Now that we have a list of services with the proper service type |
|
654 // search for our proxy record and remove it from the array, |
|
655 // then destroy the array. |
|
656 { |
|
657 CCDProxiesRecord* proxyRecord = (*proxieRS)[i]; |
|
658 |
|
659 // Compare the record id of these 2 services |
|
660 if ( TUint32( proxyRecord->iService ) == TUint32( iIapRecord->iService ) ) |
|
661 { |
|
662 iProxyRecord = proxyRecord; |
|
663 // Take ownership of this record |
|
664 proxieRS->iRecords.Remove( i ); |
|
665 break; |
|
666 } |
|
667 ++i; |
|
668 } |
|
669 } |
|
670 |
|
671 proxieRS->iRecords.ResetAndDestroy(); |
|
672 |
|
673 if ( !iProxyRecord ) |
|
674 { |
|
675 // This creates a proxy record, where usage is disabled. |
|
676 EnableProxyL( EFalse ); |
|
677 } |
|
678 |
|
679 CleanupStack::PopAndDestroy( proxieRS ); |
|
680 |
|
681 OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADPROXYSETTINGL_EXIT ); |
|
682 } |
|
683 |
|
684 // --------------------------------------------------------------------------- |
|
685 // CCmPluginBaseEng::LoadNetworkSettingL |
|
686 // --------------------------------------------------------------------------- |
|
687 // |
|
688 void CCmPluginBaseEng::LoadNetworkRecordL() |
|
689 { |
|
690 OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADNETWORKSETTINGL_ENTRY ); |
|
691 |
|
692 CCDNetworkRecord* networkRecord = static_cast<CCDNetworkRecord*>( |
|
693 CCDRecordBase::RecordFactoryL( KCDTIdNetworkRecord ) ); |
|
694 CleanupStack::PushL( networkRecord ); |
|
695 |
|
696 networkRecord->SetRecordId( iIapRecord->iNetwork ); |
|
697 TRAPD( err, networkRecord->LoadL( iSession ) ); |
|
698 if ( err == KErrNotFound ) |
|
699 { |
|
700 CleanupStack::PopAndDestroy( networkRecord ); |
|
701 |
|
702 networkRecord = static_cast<CCDNetworkRecord*>( |
|
703 CCDRecordBase::RecordFactoryL( KCDTIdNetworkRecord ) ); |
|
704 } |
|
705 else |
|
706 // KErrNotFound -> doesn't matter. We will do it UpdateL() |
|
707 { |
|
708 User::LeaveIfError( err ); |
|
709 |
|
710 CleanupStack::Pop( networkRecord ); |
|
711 } |
|
712 |
|
713 iNetworkRecord = networkRecord; |
|
714 |
|
715 OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADNETWORKSETTINGL_EXIT ); |
|
716 } |
|
717 |
|
718 // --------------------------------------------------------------------------- |
|
719 // CCmPluginBaseEng::LoadLocationSettingL |
|
720 // --------------------------------------------------------------------------- |
|
721 // |
|
722 void CCmPluginBaseEng::LoadLocationRecordL() |
|
723 { |
|
724 OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADLOCATIONSETTINGL_ENTRY ); |
|
725 |
|
726 CCDLocationRecord* locationRecord = static_cast<CCDLocationRecord*> |
|
727 (CCDRecordBase::RecordFactoryL(KCDTIdLocationRecord)); |
|
728 |
|
729 CleanupStack::PushL( locationRecord ); |
|
730 |
|
731 locationRecord->SetRecordId( iIapRecord->iLocation ); |
|
732 if ( locationRecord->FindL(iSession) ) |
|
733 { |
|
734 iLocationEnabled = ETrue; |
|
735 |
|
736 iLocationRecord = locationRecord; |
|
737 |
|
738 CleanupStack::Pop( locationRecord ); |
|
739 } |
|
740 else |
|
741 { |
|
742 iLocationEnabled = EFalse; |
|
743 |
|
744 CleanupStack::PopAndDestroy( locationRecord ); |
|
745 } |
|
746 OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADLOCATIONSETTINGL_EXIT ); |
|
747 } |
|
748 |
|
749 // --------------------------------------------------------------------------- |
|
750 // CCmPluginBaseEng::PrepareToUpdateRecordsL |
|
751 // --------------------------------------------------------------------------- |
|
752 // |
|
753 void CCmPluginBaseEng::PrepareToUpdateRecordsL( |
|
754 CCmClientPluginInstance* aClientPluginInstance ) |
|
755 { |
|
756 OstTraceFunctionEntry0( CCMPLUGINBASEENG_PREPARETOUPDATERECORDSL_ENTRY ); |
|
757 |
|
758 // Set the record attributes to bearer specific records |
|
759 CCDIAPRecord* iapRecord = |
|
760 static_cast<CCDIAPRecord*>( aClientPluginInstance->iGenRecordArray[KIapRecordIndex] ); |
|
761 |
|
762 for ( TInt i = 0; i < aClientPluginInstance->iBearerSpecRecordArray.Count(); i++ ) |
|
763 { |
|
764 CCDRecordBase* record = |
|
765 static_cast<CCDRecordBase*>( aClientPluginInstance->iBearerSpecRecordArray[i] ); |
|
766 |
|
767 CopyAttributes( iapRecord, record ); |
|
768 } |
|
769 |
|
770 PreparePluginToUpdateRecordsL( aClientPluginInstance->iGenRecordArray, |
|
771 aClientPluginInstance->iBearerSpecRecordArray ); |
|
772 |
|
773 OstTraceFunctionExit0( CCMPLUGINBASEENG_PREPARETOUPDATERECORDSL_EXIT ); |
|
774 } |
|
775 |
|
776 // --------------------------------------------------------------------------- |
|
777 // CCmPluginBaseEng::UpdateIAPRecordL |
|
778 // --------------------------------------------------------------------------- |
|
779 // |
|
780 void CCmPluginBaseEng::UpdateIAPRecordL( |
|
781 CCmClientPluginInstance* aClientPluginInstance ) |
|
782 { |
|
783 OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEIAPRECORDL_ENTRY ); |
|
784 |
|
785 CCDIAPRecord* iapRecord = |
|
786 static_cast<CCDIAPRecord*>( aClientPluginInstance->iGenRecordArray[KIapRecordIndex] ); |
|
787 |
|
788 if ( iIapId == 0 ) |
|
789 { |
|
790 // Otherwise predefined iapid |
|
791 if ( !iIapRecord->RecordId() ) |
|
792 { |
|
793 iIapRecord->SetRecordId( KCDNewRecordRequest ); |
|
794 } |
|
795 |
|
796 TUint32 id( 0 ); |
|
797 id = ServiceRecordId(); |
|
798 iIapRecord->iService = id; |
|
799 |
|
800 HBufC* name( NULL ); |
|
801 ServiceRecordNameLC( name ); |
|
802 iIapRecord->iServiceType.SetL( *name ); |
|
803 CleanupStack::PopAndDestroy( name ); |
|
804 |
|
805 BearerRecordIdL( id ); |
|
806 iIapRecord->iBearer = id; |
|
807 BearerRecordNameLC( name ); |
|
808 iIapRecord->iBearerType.SetL( *name ); |
|
809 CleanupStack::PopAndDestroy( name ); |
|
810 |
|
811 iIapRecord->iNetwork = iNetworkRecord->RecordId(); |
|
812 |
|
813 if ( iLocationRecord ) |
|
814 { |
|
815 iIapRecord->iLocation = iLocationRecord->RecordId(); |
|
816 } |
|
817 else |
|
818 { |
|
819 iIapRecord->iLocation = GetLocationIdL(); |
|
820 } |
|
821 |
|
822 CopyAttributes( iapRecord, iIapRecord ); |
|
823 CheckIfNameModifiedL( iapRecord, iIapRecord ); |
|
824 |
|
825 iIapRecord->StoreL( iSession ); |
|
826 |
|
827 iIapId = iIapRecord->RecordId(); |
|
828 aClientPluginInstance->iIapId = iIapId; |
|
829 |
|
830 CCDIAPRecord* tempIapRecord = static_cast<CCDIAPRecord*>( |
|
831 CCDRecordBase::CreateCopyRecordL( *iIapRecord ) ); |
|
832 CleanupStack::PushL( tempIapRecord ); |
|
833 tempIapRecord->SetElementId( iIapRecord->ElementId() ); |
|
834 |
|
835 aClientPluginInstance->iGenRecordArray.Remove( KIapRecordIndex ); |
|
836 CleanupStack::PushL( iapRecord ); |
|
837 |
|
838 aClientPluginInstance->iGenRecordArray.InsertL( |
|
839 static_cast<CommsDat::CCDRecordBase*>( tempIapRecord ), KIapRecordIndex ); |
|
840 |
|
841 CleanupStack::PopAndDestroy( iapRecord ); |
|
842 CleanupStack::Pop( tempIapRecord ); |
|
843 |
|
844 } |
|
845 else |
|
846 { |
|
847 delete iIapRecord; |
|
848 iIapRecord = NULL; |
|
849 |
|
850 iIapRecord = static_cast<CCDIAPRecord*> |
|
851 ( CCDRecordBase::CreateCopyRecordL( *iapRecord ) ); |
|
852 |
|
853 iIapRecord->SetElementId( iapRecord->ElementId() ); |
|
854 |
|
855 iIapRecord->ModifyL( iSession ); |
|
856 } |
|
857 OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATEIAPRECORDL_EXIT ); |
|
858 } |
|
859 |
|
860 // --------------------------------------------------------------------------- |
|
861 // CCmPluginBaseEng::UpdateProxyRecordL |
|
862 // --------------------------------------------------------------------------- |
|
863 // |
|
864 void CCmPluginBaseEng::UpdateProxyRecordL( |
|
865 CCmClientPluginInstance* aClientPluginInstance ) |
|
866 { |
|
867 OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEPROXYRECORDL_ENTRY ); |
|
868 |
|
869 CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>( |
|
870 aClientPluginInstance->iGenRecordArray[KIapRecordIndex] ); |
|
871 |
|
872 CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>( |
|
873 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ); |
|
874 |
|
875 CopyAttributes( iapRecord, proxyRecord ); |
|
876 CheckIfNameModifiedL( iapRecord, proxyRecord ); |
|
877 |
|
878 if ( proxyRecord->iUseProxyServer ) |
|
879 { |
|
880 delete iProxyRecord; |
|
881 iProxyRecord = NULL; |
|
882 |
|
883 iProxyRecord = static_cast<CCDProxiesRecord*> |
|
884 ( CCDRecordBase::CreateCopyRecordL( *proxyRecord ) ); |
|
885 iProxyRecord->SetElementId( proxyRecord->ElementId() ); |
|
886 |
|
887 if ( !iProxyRecord->RecordId() ) |
|
888 // new proxy setting -> create new record |
|
889 { |
|
890 iProxyRecord->iService = iServiceRecord->RecordId(); |
|
891 iProxyRecord->iServiceType.SetL( iIapRecord->iServiceType ); |
|
892 |
|
893 // By default protocol is set to "http" |
|
894 if ( TPtrC( proxyRecord->iProtocolName ).Length() == 0 ) |
|
895 { |
|
896 iProxyRecord->iProtocolName.SetL( KDefProxyProtocolName ); |
|
897 } |
|
898 |
|
899 iProxyRecord->SetRecordId( KCDNewRecordRequest ); |
|
900 iProxyRecord->StoreL( iSession ); |
|
901 proxyRecord->SetElementId( iProxyRecord->ElementId() ); |
|
902 proxyRecord->iService = iServiceRecord->RecordId(); |
|
903 proxyRecord->iServiceType.SetL( iIapRecord->iServiceType ); |
|
904 } |
|
905 else |
|
906 // already existing record -> update only |
|
907 { |
|
908 iProxyRecord->ModifyL( iSession ); |
|
909 } |
|
910 } |
|
911 else |
|
912 { |
|
913 if ( iProxyRecord->RecordId() ) |
|
914 { |
|
915 iProxyRecord->DeleteL( iSession ); |
|
916 } |
|
917 } |
|
918 OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATEPROXYRECORDL_EXIT ); |
|
919 } |
|
920 |
|
921 // --------------------------------------------------------------------------- |
|
922 // CCmPluginBaseEng::UpdateMetadataRecordL |
|
923 // --------------------------------------------------------------------------- |
|
924 // |
|
925 void CCmPluginBaseEng::UpdateMetadataRecordL( |
|
926 CCmClientPluginInstance* aClientPluginInstance ) |
|
927 { |
|
928 OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEMETADATARECORDL_ENTRY ); |
|
929 |
|
930 CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>( |
|
931 aClientPluginInstance->iGenRecordArray[KIapRecordIndex] ); |
|
932 |
|
933 CCDIAPMetadataRecord* metadataRecord = static_cast<CCDIAPMetadataRecord*>( |
|
934 aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] ); |
|
935 |
|
936 CopyAttributes( iapRecord, metadataRecord ); |
|
937 CheckIfNameModifiedL( iapRecord, metadataRecord ); |
|
938 |
|
939 delete iMetaDataRecord; |
|
940 iMetaDataRecord = NULL; |
|
941 |
|
942 // Get a new blank IAP metadata record. |
|
943 iMetaDataRecord = NewMetadataRecordL( EFalse ); |
|
944 |
|
945 iMetaDataRecord->SetElementId( metadataRecord->ElementId() ); |
|
946 iMetaDataRecord->iRecordName.SetL( metadataRecord->iRecordName ); |
|
947 iMetaDataRecord->iMetadata.SetL( metadataRecord->iMetadata ); |
|
948 iMetaDataRecord->iSeamlessness.SetL( metadataRecord->iSeamlessness ); |
|
949 |
|
950 if ( !iMetaDataRecord->RecordId() ) |
|
951 { |
|
952 iMetaDataRecord->iIAP = IAPRecordElementId(); |
|
953 iMetaDataRecord->SetRecordId( KCDNewRecordRequest ); |
|
954 iMetaDataRecord->StoreL( iSession ); |
|
955 metadataRecord->SetElementId( iMetaDataRecord->ElementId() ); |
|
956 } |
|
957 else |
|
958 { |
|
959 iMetaDataRecord->ModifyL( iSession ); |
|
960 } |
|
961 |
|
962 OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATEMETADATARECORDL_EXIT ); |
|
963 } |
|
964 |
|
965 // --------------------------------------------------------------------------- |
|
966 // CCmPluginBaseEng::UpdateServiceRecordL |
|
967 // --------------------------------------------------------------------------- |
|
968 // |
|
969 void CCmPluginBaseEng::UpdateServiceRecordL( |
|
970 CCmClientPluginInstance* aClientPluginInstance ) |
|
971 { |
|
972 OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATESERVICERECORDL_ENTRY ); |
|
973 |
|
974 CCDIAPRecord* iapRecord = |
|
975 static_cast<CCDIAPRecord*>( aClientPluginInstance->iGenRecordArray[KIapRecordIndex] ); |
|
976 |
|
977 CCDRecordBase* serviceRecord = |
|
978 static_cast<CCDRecordBase*>( aClientPluginInstance->iGenRecordArray[KServiceRecordIndex] ); |
|
979 |
|
980 CopyAttributes( iapRecord, serviceRecord ); |
|
981 |
|
982 UpdateServiceRecordL( aClientPluginInstance->iGenRecordArray, |
|
983 aClientPluginInstance->iBearerSpecRecordArray ); |
|
984 |
|
985 OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATESERVICERECORDL_EXIT ); |
|
986 } |
|
987 |
|
988 // --------------------------------------------------------------------------- |
|
989 // CCmPluginBaseEng::UpdateNetworkRecordL |
|
990 // --------------------------------------------------------------------------- |
|
991 // |
|
992 void CCmPluginBaseEng::UpdateNetworkRecordL( |
|
993 CCmClientPluginInstance* aClientPluginInstance ) |
|
994 { |
|
995 OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATENETWORKRECORDL_ENTRY ); |
|
996 |
|
997 CCDIAPRecord* iapRecord = |
|
998 static_cast<CCDIAPRecord*>( aClientPluginInstance->iGenRecordArray[KIapRecordIndex] ); |
|
999 |
|
1000 CCDNetworkRecord* networkRecord = |
|
1001 static_cast<CCDNetworkRecord*>( aClientPluginInstance->iGenRecordArray[KNetworkRecordIndex] ); |
|
1002 |
|
1003 CopyAttributes( iapRecord, networkRecord ); |
|
1004 |
|
1005 delete iNetworkRecord; |
|
1006 iNetworkRecord = NULL; |
|
1007 |
|
1008 CheckIfNameModifiedL( iapRecord, networkRecord ); |
|
1009 |
|
1010 iNetworkRecord = static_cast<CCDNetworkRecord*> |
|
1011 ( CCDRecordBase::CreateCopyRecordL( *networkRecord ) ); |
|
1012 |
|
1013 iNetworkRecord->SetElementId( networkRecord->ElementId() ); |
|
1014 |
|
1015 if ( !iNetworkRecord->RecordId() ) |
|
1016 { |
|
1017 iNetworkRecord->SetRecordId( KCDNewRecordRequest ); |
|
1018 iNetworkRecord->StoreL( iSession ); |
|
1019 networkRecord->SetElementId( iNetworkRecord->ElementId() ); |
|
1020 } |
|
1021 else |
|
1022 { |
|
1023 iNetworkRecord->ModifyL( iSession ); |
|
1024 } |
|
1025 OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATENETWORKRECORDL_EXIT ); |
|
1026 } |
|
1027 |
|
1028 // --------------------------------------------------------------------------- |
|
1029 // CCmPluginBaseEng::UpdateLocationRecordL |
|
1030 // --------------------------------------------------------------------------- |
|
1031 // |
|
1032 void CCmPluginBaseEng::UpdateLocationRecordL( |
|
1033 CCmClientPluginInstance* aClientPluginInstance ) |
|
1034 { |
|
1035 OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATELOCATIONRECORDL_ENTRY ); |
|
1036 |
|
1037 if ( iLocationEnabled ) |
|
1038 { |
|
1039 CCDIAPRecord* iapRecord = |
|
1040 static_cast<CCDIAPRecord*>( aClientPluginInstance->iGenRecordArray[KIapRecordIndex] ); |
|
1041 |
|
1042 CCDLocationRecord* locationRecord = |
|
1043 static_cast<CCDLocationRecord*>( aClientPluginInstance->iGenRecordArray[KLocationRecordIndex] ); |
|
1044 |
|
1045 // location record is not set as hidden because it can be shared between iaps |
|
1046 CopyAttributes( iapRecord, locationRecord ); |
|
1047 locationRecord->ClearAttributes( ECDHidden ); |
|
1048 |
|
1049 delete iLocationRecord; |
|
1050 iLocationRecord = NULL; |
|
1051 |
|
1052 iLocationRecord = static_cast<CCDLocationRecord*> |
|
1053 ( CCDRecordBase::CreateCopyRecordL( *locationRecord ) ); |
|
1054 |
|
1055 iLocationRecord->SetElementId( locationRecord->ElementId() ); |
|
1056 |
|
1057 CheckIfNameModifiedL( iapRecord, locationRecord ); |
|
1058 |
|
1059 if ( !iLocationRecord->RecordId() ) |
|
1060 { |
|
1061 iLocationRecord->SetRecordId( KCDNewRecordRequest ); |
|
1062 iLocationRecord->StoreL( iSession ); |
|
1063 } |
|
1064 else |
|
1065 { |
|
1066 iLocationRecord->ModifyL( iSession ); |
|
1067 } |
|
1068 } |
|
1069 else |
|
1070 { |
|
1071 if ( iLocationRecord ) |
|
1072 { |
|
1073 iLocationRecord->DeleteL( iSession ); |
|
1074 } |
|
1075 } |
|
1076 OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATELOCATIONRECORDL_EXIT ); |
|
1077 } |
|
1078 |
|
1079 // --------------------------------------------------------------------------- |
|
1080 // CCmPluginBaseEng::UpdateConnPrefSettingL |
|
1081 // --------------------------------------------------------------------------- |
|
1082 // |
|
1083 void CCmPluginBaseEng::UpdateConnPrefSettingL() |
|
1084 { |
|
1085 OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATECONNPREFSETTINGL_ENTRY ); |
|
1086 OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATECONNPREFSETTINGL_EXIT ); |
|
1087 } |
|
1088 |
|
1089 // --------------------------------------------------------------------------- |
|
1090 // CCmPluginBaseEng::EnableProxyL |
|
1091 // --------------------------------------------------------------------------- |
|
1092 // |
|
1093 void CCmPluginBaseEng::EnableProxyL( TBool aEnable ) |
|
1094 { |
|
1095 OstTraceFunctionEntry0( CCMPLUGINBASEENG_ENABLEPROXYL_ENTRY ); |
|
1096 |
|
1097 if ( !iServiceRecord ) |
|
1098 { |
|
1099 User::Leave( KErrNotSupported ); |
|
1100 } |
|
1101 |
|
1102 if ( !iProxyRecord ) |
|
1103 { |
|
1104 iProxyRecord = static_cast<CCDProxiesRecord *> |
|
1105 (CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord)); |
|
1106 } |
|
1107 |
|
1108 iProxyRecord->iUseProxyServer = aEnable; |
|
1109 |
|
1110 OstTraceFunctionExit0( CCMPLUGINBASEENG_ENABLEPROXYL_EXIT ); |
|
1111 } |
|
1112 |
|
1113 // --------------------------------------------------------------------------- |
|
1114 // CCmPluginBaseEng::EnableLocationL |
|
1115 // --------------------------------------------------------------------------- |
|
1116 // |
|
1117 void CCmPluginBaseEng::EnableLocationL( TBool aEnable ) |
|
1118 { |
|
1119 OstTraceFunctionEntry0( CCMPLUGINBASEENG_ENABLELOCATIONL_ENTRY ); |
|
1120 |
|
1121 if ( aEnable ) |
|
1122 { |
|
1123 if ( !iLocationRecord ) |
|
1124 { |
|
1125 iLocationRecord = static_cast<CCDLocationRecord *> |
|
1126 (CCDRecordBase::RecordFactoryL(KCDTIdLocationRecord)); |
|
1127 } |
|
1128 } |
|
1129 |
|
1130 iLocationEnabled = aEnable; |
|
1131 |
|
1132 OstTraceFunctionExit0( CCMPLUGINBASEENG_ENABLELOCATIONL_EXIT ); |
|
1133 } |
|
1134 |
|
1135 // --------------------------------------------------------------------------- |
|
1136 // CCmPluginBaseEng::LoadWapRecordL |
|
1137 // --------------------------------------------------------------------------- |
|
1138 // |
|
1139 void CCmPluginBaseEng::LoadWapRecordL() |
|
1140 { |
|
1141 OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADWAPRECORDL_ENTRY ); |
|
1142 |
|
1143 iWapIPBearerRecord = FindWAPRecordL(); |
|
1144 if ( iWapIPBearerRecord ) |
|
1145 { |
|
1146 CCDWAPAccessPointRecord *wapApRecord = static_cast<CCDWAPAccessPointRecord *> |
|
1147 (CCDRecordBase::RecordFactoryL(KCDTIdWAPAccessPointRecord)); |
|
1148 |
|
1149 CleanupStack::PushL( wapApRecord ); |
|
1150 |
|
1151 wapApRecord->SetRecordId( iWapIPBearerRecord->iWAPAccessPointId ); |
|
1152 TRAPD( err, wapApRecord->LoadL( iSession ) ); |
|
1153 if ( err == KErrNotFound ) |
|
1154 { |
|
1155 CleanupStack::PopAndDestroy( wapApRecord ); |
|
1156 |
|
1157 wapApRecord = static_cast<CCDWAPAccessPointRecord *> |
|
1158 (CCDRecordBase::RecordFactoryL(KCDTIdWAPAccessPointRecord)); |
|
1159 } |
|
1160 else |
|
1161 { |
|
1162 User::LeaveIfError( err ); |
|
1163 |
|
1164 CleanupStack::Pop( wapApRecord ); |
|
1165 } |
|
1166 |
|
1167 iWapAPRecord = wapApRecord; |
|
1168 } |
|
1169 else |
|
1170 // No WAP record found -> create a new one |
|
1171 { |
|
1172 NewWapRecordL(); |
|
1173 } |
|
1174 OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADWAPRECORDL_EXIT ); |
|
1175 } |
|
1176 |
|
1177 // --------------------------------------------------------------------------- |
|
1178 // CCmPluginBaseEng::LoadMetadataRecordL |
|
1179 // --------------------------------------------------------------------------- |
|
1180 // |
|
1181 void CCmPluginBaseEng::LoadMetadataRecordL() |
|
1182 { |
|
1183 OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADSEAMLESSNESSRECORDL_ENTRY ); |
|
1184 |
|
1185 iMetaDataRecord = FindMetadataRecordL(); |
|
1186 |
|
1187 OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADSEAMLESSNESSRECORDL_EXIT ); |
|
1188 } |
|
1189 |
|
1190 // --------------------------------------------------------------------------- |
|
1191 // CCmPluginBaseEng::UpdateWapRecordL |
|
1192 // --------------------------------------------------------------------------- |
|
1193 // |
|
1194 void CCmPluginBaseEng::UpdateWapRecordL( |
|
1195 CCmClientPluginInstance* aClientPluginInstance ) |
|
1196 { |
|
1197 OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEWAPRECORDL_ENTRY ); |
|
1198 |
|
1199 delete iWapAPRecord; |
|
1200 iWapAPRecord = NULL; |
|
1201 |
|
1202 delete iWapIPBearerRecord; |
|
1203 iWapIPBearerRecord = NULL; |
|
1204 |
|
1205 CCDIAPRecord* iapRecord = |
|
1206 static_cast<CCDIAPRecord*>( aClientPluginInstance->iGenRecordArray[KIapRecordIndex] ); |
|
1207 |
|
1208 CCDWAPAccessPointRecord* wapAPRecord = |
|
1209 static_cast<CCDWAPAccessPointRecord*>( aClientPluginInstance->iGenRecordArray[KWAPAPRecordIndex] ); |
|
1210 |
|
1211 CCDWAPIPBearerRecord* wapIPBearerRecord = |
|
1212 static_cast<CCDWAPIPBearerRecord*>( aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] ); |
|
1213 |
|
1214 CopyAttributes( iapRecord, wapAPRecord ); |
|
1215 CopyAttributes( iapRecord, wapIPBearerRecord ); |
|
1216 |
|
1217 CheckIfNameModifiedL( iapRecord, wapAPRecord ); |
|
1218 CheckIfNameModifiedL( iapRecord, wapIPBearerRecord ); |
|
1219 |
|
1220 iWapAPRecord = static_cast<CCDWAPAccessPointRecord*> |
|
1221 ( CCDRecordBase::CreateCopyRecordL( *wapAPRecord ) ); |
|
1222 iWapAPRecord->SetElementId( wapAPRecord->ElementId() ); |
|
1223 |
|
1224 iWapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*> |
|
1225 ( CCDRecordBase::CreateCopyRecordL( *wapIPBearerRecord ) ); |
|
1226 iWapIPBearerRecord->SetElementId( wapIPBearerRecord->ElementId() ); |
|
1227 |
|
1228 if ( !iWapAPRecord->RecordId() ) |
|
1229 { |
|
1230 iWapAPRecord->SetRecordId( KCDNewRecordRequest ); |
|
1231 iWapAPRecord->StoreL(iSession ); |
|
1232 wapAPRecord->SetElementId( iWapAPRecord->ElementId() ); |
|
1233 } |
|
1234 else |
|
1235 { |
|
1236 iWapAPRecord->ModifyL( iSession ); |
|
1237 } |
|
1238 |
|
1239 if ( !iWapIPBearerRecord->RecordId() ) |
|
1240 { |
|
1241 iWapIPBearerRecord->iWAPAccessPointId = iWapAPRecord->RecordId(); |
|
1242 iWapIPBearerRecord->iWAPIAP = iapRecord->RecordId(); |
|
1243 |
|
1244 iWapIPBearerRecord->SetRecordId( KCDNewRecordRequest ); |
|
1245 iWapIPBearerRecord->StoreL( iSession ); |
|
1246 wapIPBearerRecord->SetElementId( iWapIPBearerRecord->ElementId() ); |
|
1247 |
|
1248 wapIPBearerRecord->iWAPAccessPointId = iWapAPRecord->RecordId(); |
|
1249 wapIPBearerRecord->iWAPIAP = iapRecord->RecordId(); |
|
1250 } |
|
1251 else |
|
1252 { |
|
1253 iWapIPBearerRecord->ModifyL( iSession ); |
|
1254 } |
|
1255 OstTraceFunctionExit0( DUP1_CCMPLUGINBASEENG_UPDATEWAPRECORDL_EXIT ); |
|
1256 } |
|
1257 |
|
1258 // --------------------------------------------------------------------------- |
|
1259 // CCmPluginBaseEng::NewWapRecordL |
|
1260 // --------------------------------------------------------------------------- |
|
1261 // |
|
1262 void CCmPluginBaseEng::NewWapRecordL() |
|
1263 { |
|
1264 OstTraceFunctionEntry0( CCMPLUGINBASEENG_NEWWAPRECORDL_ENTRY ); |
|
1265 |
|
1266 if ( !iWapIPBearerRecord ) |
|
1267 { |
|
1268 iWapIPBearerRecord = static_cast<CCDWAPIPBearerRecord *> |
|
1269 ( CCDRecordBase::RecordFactoryL( KCDTIdWAPIPBearerRecord ) ); |
|
1270 iWapIPBearerRecord->iWAPProxyPort = 0; |
|
1271 iWapIPBearerRecord->iWAPWSPOption = ECmWapWspOptionConnectionOriented; |
|
1272 iWapIPBearerRecord->iWAPSecurity = EFalse; |
|
1273 } |
|
1274 |
|
1275 if ( !iWapAPRecord ) |
|
1276 { |
|
1277 iWapAPRecord = static_cast<CCDWAPAccessPointRecord *> |
|
1278 ( CCDRecordBase::RecordFactoryL( KCDTIdWAPAccessPointRecord ) ); |
|
1279 // SMS bearer is not supported by this version |
|
1280 iWapAPRecord->iWAPCurrentBearer.SetL( TPtrC( KCDTypeNameWAPIPBearer ) ); |
|
1281 } |
|
1282 OstTraceFunctionExit0( CCMPLUGINBASEENG_NEWWAPRECORDL_EXIT ); |
|
1283 } |
|
1284 |
|
1285 // --------------------------------------------------------------------------- |
|
1286 // CCmPluginBaseEng::NewMetadataRecordL |
|
1287 // --------------------------------------------------------------------------- |
|
1288 // |
|
1289 CCDIAPMetadataRecord* CCmPluginBaseEng::NewMetadataRecordL( TBool aSetDef ) |
|
1290 { |
|
1291 OstTraceFunctionEntry0( CCMPLUGINBASEENG_NEWSEAMLESSNESSRECORDL_ENTRY ); |
|
1292 |
|
1293 CCDIAPMetadataRecord* record = new( ELeave ) CCDIAPMetadataRecord( iMetadataTableId ); |
|
1294 |
|
1295 if ( aSetDef ) |
|
1296 { |
|
1297 TRAPD( err, record->iSeamlessness = GetBearerInfoIntL( ECmSeamlessnessLevel ) ); |
|
1298 if ( err ) |
|
1299 { |
|
1300 record->iSeamlessness = ESeamlessnessConfirmFirst; |
|
1301 } |
|
1302 } |
|
1303 |
|
1304 OstTraceFunctionExit0( CCMPLUGINBASEENG_NEWSEAMLESSNESSRECORDL_EXIT ); |
|
1305 return record; |
|
1306 } |
|
1307 |
|
1308 // --------------------------------------------------------------------------- |
|
1309 // CCmPluginBaseEng::SetAttribute |
|
1310 // --------------------------------------------------------------------------- |
|
1311 // |
|
1312 void CCmPluginBaseEng::SetAttribute( CCDRecordBase* aRecord, |
|
1313 TUint32 aAttribute, |
|
1314 TBool aSet ) |
|
1315 { |
|
1316 OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETATTRIBUTE_ENTRY ); |
|
1317 |
|
1318 if ( aSet ) |
|
1319 { |
|
1320 aRecord->SetAttributes( aAttribute ); |
|
1321 } |
|
1322 else |
|
1323 { |
|
1324 aRecord->ClearAttributes( aAttribute ); |
|
1325 } |
|
1326 |
|
1327 OstTraceFunctionExit0( CCMPLUGINBASEENG_SETATTRIBUTE_EXIT ); |
|
1328 } |
|
1329 |
|
1330 // --------------------------------------------------------------------------- |
|
1331 // CCmPluginBaseEng::CopyAttributes |
|
1332 // --------------------------------------------------------------------------- |
|
1333 // |
|
1334 void CCmPluginBaseEng::CopyAttributes( CCDRecordBase* aSrcRecord, |
|
1335 CCDRecordBase* aDstRecord ) |
|
1336 { |
|
1337 OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYATTRIBUTES_ENTRY ); |
|
1338 |
|
1339 if ( aSrcRecord == NULL || aDstRecord == NULL ) |
|
1340 { |
|
1341 return; |
|
1342 } |
|
1343 |
|
1344 // clear the target record attributes first |
|
1345 aDstRecord->ClearAttributes( aDstRecord->Attributes() ); |
|
1346 |
|
1347 aDstRecord->SetAttributes( aSrcRecord->Attributes() ); |
|
1348 |
|
1349 OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYATTRIBUTES_EXIT ); |
|
1350 } |
|
1351 |
|
1352 // --------------------------------------------------------------------------- |
|
1353 // CCmPluginBaseEng::FindWAPRecordL |
|
1354 // --------------------------------------------------------------------------- |
|
1355 // |
|
1356 CCDWAPIPBearerRecord* CCmPluginBaseEng::FindWAPRecordL() |
|
1357 { |
|
1358 OstTraceFunctionEntry0( CCMPLUGINBASEENG_FINDWAPRECORDL_ENTRY ); |
|
1359 |
|
1360 CMDBRecordSet<CCDWAPIPBearerRecord>* wapRS = |
|
1361 new(ELeave) |
|
1362 CMDBRecordSet<CCDWAPIPBearerRecord>(KCDTIdWAPIPBearerRecord); |
|
1363 CleanupStack::PushL( wapRS ); |
|
1364 |
|
1365 CCDWAPIPBearerRecord* wapBearerRecord = static_cast<CCDWAPIPBearerRecord *> |
|
1366 (CCDRecordBase::RecordFactoryL(KCDTIdWAPIPBearerRecord)); |
|
1367 |
|
1368 CleanupStack::PushL( wapBearerRecord ); |
|
1369 |
|
1370 wapBearerRecord->iWAPIAP = iIapId; |
|
1371 wapRS->iRecords.AppendL( wapBearerRecord ); |
|
1372 |
|
1373 CleanupStack::Pop( wapBearerRecord ); |
|
1374 wapBearerRecord = NULL; |
|
1375 |
|
1376 if ( wapRS->FindL(iSession) ) |
|
1377 { |
|
1378 wapBearerRecord = |
|
1379 static_cast<CCDWAPIPBearerRecord *>(wapRS->iRecords[0]); |
|
1380 |
|
1381 // we take over the ownership of this record |
|
1382 wapRS->iRecords.Remove( 0 ); |
|
1383 } |
|
1384 |
|
1385 CleanupStack::PopAndDestroy( wapRS ); |
|
1386 |
|
1387 OstTraceFunctionExit0( CCMPLUGINBASEENG_FINDWAPRECORDL_EXIT ); |
|
1388 |
|
1389 return wapBearerRecord; |
|
1390 } |
|
1391 |
|
1392 // --------------------------------------------------------------------------- |
|
1393 // CCmPluginBaseEng::FindSeamlessnessRecordL |
|
1394 // --------------------------------------------------------------------------- |
|
1395 // |
|
1396 CCDIAPMetadataRecord* CCmPluginBaseEng::FindMetadataRecordL() |
|
1397 { |
|
1398 OstTraceFunctionEntry0( CCMPLUGINBASEENG_FINDSEAMLESSNESSRECORDL_ENTRY ); |
|
1399 |
|
1400 CMDBRecordSet<CCDIAPMetadataRecord>* metadataRecordSet = |
|
1401 new(ELeave) CMDBRecordSet<CCDIAPMetadataRecord>( iMetadataTableId ); |
|
1402 CleanupStack::PushL( metadataRecordSet ); |
|
1403 |
|
1404 CCDIAPMetadataRecord* metadataRecord = |
|
1405 new (ELeave) CCDIAPMetadataRecord( iMetadataTableId ); |
|
1406 |
|
1407 CleanupStack::PushL( metadataRecord ); |
|
1408 |
|
1409 metadataRecord->iIAP = IAPRecordElementId(); |
|
1410 metadataRecordSet->iRecords.AppendL( metadataRecord ); |
|
1411 |
|
1412 CleanupStack::Pop( metadataRecord ); |
|
1413 metadataRecord = NULL; |
|
1414 |
|
1415 if ( metadataRecordSet->FindL( iSession ) ) |
|
1416 { |
|
1417 CMDBRecordBase* record = metadataRecordSet->iRecords[0]; |
|
1418 |
|
1419 metadataRecord = NewMetadataRecordL( EFalse ); |
|
1420 metadataRecord->SetRecordId( record->RecordId() ); |
|
1421 |
|
1422 // This can leave only in case of OOM. |
|
1423 metadataRecord->LoadL( iSession ); |
|
1424 } |
|
1425 else |
|
1426 { |
|
1427 metadataRecord = NewMetadataRecordL( ETrue ); |
|
1428 } |
|
1429 |
|
1430 CleanupStack::PopAndDestroy( metadataRecordSet ); |
|
1431 |
|
1432 OstTraceFunctionExit0( CCMPLUGINBASEENG_FINDSEAMLESSNESSRECORDL_EXIT ); |
|
1433 |
|
1434 return metadataRecord; |
|
1435 } |
|
1436 |
|
1437 // --------------------------------------------------------------------------- |
|
1438 // CCmPluginBaseEng::DoMakeValidNameL |
|
1439 // --------------------------------------------------------------------------- |
|
1440 // |
|
1441 HBufC* CCmPluginBaseEng::DoMakeValidNameL( const TDesC& aName, |
|
1442 const TUint32& aIapId ) |
|
1443 { |
|
1444 OstTraceFunctionEntry0( CCMPLUGINBASEENG_DOMAKEVALIDNAMEL_ENTRY ); |
|
1445 |
|
1446 TBool changed( EFalse ); |
|
1447 HBufC* temp = HBufC::NewLC( KApMaxConnNameLength ); |
|
1448 HBufC* temp2 = HBufC::NewLC( KApMaxConnNameLength ); |
|
1449 |
|
1450 HBufC* corrname = EnsureMaxLengthLC( aName, changed ); |
|
1451 *temp = *corrname; |
|
1452 TInt postfix( 0 ); |
|
1453 TInt pf( 0 ); |
|
1454 TInt i( 0 ); |
|
1455 TBool valid ( EFalse ); |
|
1456 |
|
1457 TPtrC prefix = GetPrefix( *corrname ); |
|
1458 |
|
1459 postfix = GetPostfix( *temp, prefix ); |
|
1460 postfix = -1; |
|
1461 do |
|
1462 { |
|
1463 valid = IsValidNameL( *temp, aIapId ); |
|
1464 if ( !valid ) |
|
1465 { |
|
1466 changed = ETrue; |
|
1467 postfix++; |
|
1468 // check the length of postfix, check text length accordingly |
|
1469 pf = postfix; |
|
1470 for (i=1; i<10; i++) |
|
1471 { |
|
1472 pf /= 10; |
|
1473 if ( !pf ) |
|
1474 break; |
|
1475 } |
|
1476 TPtr sgdptr( temp->Des() ); |
|
1477 TPtr sgdptr2( temp2->Des() ); |
|
1478 if ( postfix ) |
|
1479 { |
|
1480 if ( postfix < 10 ) |
|
1481 { |
|
1482 sgdptr2 = prefix.Left( KApMaxConnNameLength - i - 3 ); |
|
1483 } |
|
1484 else |
|
1485 { |
|
1486 sgdptr2 = prefix.Left( KApMaxConnNameLength - i - 2 ); |
|
1487 } |
|
1488 } |
|
1489 else |
|
1490 { |
|
1491 sgdptr2 = prefix.Left( KApMaxConnNameLength ); |
|
1492 } |
|
1493 if ( postfix ) |
|
1494 { |
|
1495 TBuf< KMaxPostfixLength > postfixString; |
|
1496 if ( postfix > 9 ) |
|
1497 { |
|
1498 postfixString.Format( KFormatLargePostfix, postfix ); |
|
1499 // TODO: AknTextUtils::LanguageSpecificNumberConversion( postfixString ); |
|
1500 } |
|
1501 else |
|
1502 { |
|
1503 postfixString.Format( KFormatPostfix, postfix ); |
|
1504 // TODO: AknTextUtils::LanguageSpecificNumberConversion( postfixString ); |
|
1505 } |
|
1506 sgdptr.Format( KFormatNameWithPostfix, &sgdptr2, |
|
1507 &postfixString ); |
|
1508 } |
|
1509 else |
|
1510 { |
|
1511 sgdptr.Format( KFormatNoPostfix, &sgdptr2 ); |
|
1512 } |
|
1513 } |
|
1514 } while ( !valid ); |
|
1515 |
|
1516 CleanupStack::PopAndDestroy( corrname ); |
|
1517 CleanupStack::PopAndDestroy( temp2 ); |
|
1518 |
|
1519 if ( changed ) |
|
1520 { |
|
1521 CleanupStack::Pop( temp ); |
|
1522 } |
|
1523 else |
|
1524 { |
|
1525 CleanupStack::PopAndDestroy( temp ); |
|
1526 temp = NULL; |
|
1527 } |
|
1528 |
|
1529 OstTraceFunctionExit0( CCMPLUGINBASEENG_DOMAKEVALIDNAMEL_EXIT ); |
|
1530 |
|
1531 return temp; |
|
1532 } |
|
1533 |
|
1534 // --------------------------------------------------------------------------- |
|
1535 // CCmPluginBaseEng::EnsureMaxLengthLC |
|
1536 // --------------------------------------------------------------------------- |
|
1537 // |
|
1538 HBufC* CCmPluginBaseEng::EnsureMaxLengthLC( const TDesC& aName, |
|
1539 TBool& aChanged ) |
|
1540 { |
|
1541 OstTraceFunctionEntry0( CCMPLUGINBASEENG_ENSUREMAXLENGTHLC_ENTRY ); |
|
1542 |
|
1543 TInt length = aName.Length(); |
|
1544 |
|
1545 aChanged = EFalse; |
|
1546 |
|
1547 if ( !length ) |
|
1548 { |
|
1549 // Name is required. |
|
1550 User::Leave( KErrArgument ); |
|
1551 } |
|
1552 |
|
1553 HBufC* corrname; |
|
1554 if ( KApMaxConnNameLength < length ) |
|
1555 { // name too long, truncate. |
|
1556 corrname = aName.Left( KApMaxConnNameLength ).AllocLC(); |
|
1557 aChanged = ETrue; |
|
1558 } |
|
1559 else |
|
1560 { |
|
1561 corrname = aName.AllocLC(); |
|
1562 corrname->Des().Trim(); |
|
1563 if ( corrname->Length() == 0 ) |
|
1564 { |
|
1565 User::Leave( KErrArgument ); |
|
1566 } |
|
1567 // comes here only if name is valid |
|
1568 if ( corrname->Length() != aName.Length() ) |
|
1569 { |
|
1570 aChanged = ETrue; |
|
1571 } |
|
1572 } |
|
1573 |
|
1574 OstTraceFunctionExit0( CCMPLUGINBASEENG_ENSUREMAXLENGTHLC_EXIT ); |
|
1575 |
|
1576 return corrname; |
|
1577 } |
|
1578 |
|
1579 // --------------------------------------------------------------------------- |
|
1580 // Given aName in the format <prefix> or <prefix><brace><integer><brace>, |
|
1581 // return a pointer to the leading part. |
|
1582 // That is, if there is trailing <space><integer>, |
|
1583 // then that is excluded; if there is no trailing part, then the original |
|
1584 // decriptor is returned. |
|
1585 // Examples: |
|
1586 // - "Foo" returns "Foo"; |
|
1587 // - "Foo 12" returns "Foo 12"; |
|
1588 // - "Foo(12)" returns "Foo"; |
|
1589 // - "Foo 12 (34)" returns "Foo 12 "; |
|
1590 // - "Foo bar" returns "Foo bar"; |
|
1591 // - "Foo " returns "Foo ". |
|
1592 // --------------------------------------------------------------------------- |
|
1593 TPtrC CCmPluginBaseEng::GetPrefix( const TDesC& aName ) |
|
1594 { |
|
1595 OstTraceFunctionEntry0( CCMPLUGINBASEENG_GETPREFIX_ENTRY ); |
|
1596 |
|
1597 TPtrC prefix = aName; |
|
1598 TInt lastBrace = aName.LocateReverse('('); |
|
1599 if ( lastBrace != KErrNotFound ) |
|
1600 { |
|
1601 // aName looks like "<prefix><brace><something>". |
|
1602 // See if <something> is an integer number. |
|
1603 TPtrC num = aName.Right( aName.Length() - lastBrace - 1 ); |
|
1604 TInt val; |
|
1605 TLex lex( num ); |
|
1606 if ( lex.Val( val ) == KErrNone ) |
|
1607 { |
|
1608 // Yes, the trailer is an integer. |
|
1609 prefix.Set( aName.Left( lastBrace ) ); |
|
1610 } |
|
1611 } |
|
1612 OstTraceFunctionExit0( CCMPLUGINBASEENG_GETPREFIX_EXIT ); |
|
1613 |
|
1614 return prefix; |
|
1615 } |
|
1616 |
|
1617 |
|
1618 // --------------------------------------------------------------------------- |
|
1619 // If aName is constructed from aPrefix with a postfix, get the numeric |
|
1620 // value of the postfix, e.g: |
|
1621 // - GetPostfix( "Foo (3)", "Foo" ) == 3 |
|
1622 // - GetPostfix( "Foo 23 (45)", "Foo 23" ) == 45 |
|
1623 // If aName is the same as aPrefix, return 0, e.g.: |
|
1624 // - GetPostfix( "Foo", "Foo" ) == 0 |
|
1625 // If aName is not constructed from aPrefix, return -1, e.g.: |
|
1626 // - GetPostfix( "Foobar", "Foo" ) == -1 |
|
1627 // - GetPostfix( "Fo 23 45", "Foo" ) == -1 |
|
1628 // --------------------------------------------------------------------------- |
|
1629 TInt CCmPluginBaseEng::GetPostfix( const TDesC& aName, const TDesC& aPrefix ) |
|
1630 { |
|
1631 OstTraceFunctionEntry0( CCMPLUGINBASEENG_GETPOSTFIX_ENTRY ); |
|
1632 |
|
1633 TInt postfix( KErrNotFound ); |
|
1634 TInt nameLength = aName.Length(); |
|
1635 TInt prefixLength = aPrefix.Length(); |
|
1636 if ( nameLength >= prefixLength && aName.FindF( aPrefix ) == 0 ) |
|
1637 { |
|
1638 // aName is longer or equal length, and |
|
1639 // aPrefix can be found in the beginning of aName. |
|
1640 if ( nameLength == prefixLength ) |
|
1641 { |
|
1642 // They have the same length; they equal. |
|
1643 postfix = 0; |
|
1644 } |
|
1645 else |
|
1646 { |
|
1647 if ( prefixLength > 0 ) |
|
1648 { |
|
1649 if ( aName[ prefixLength ] == '(' ) |
|
1650 { |
|
1651 // (Now we know that aName is longer than aPrefix.) |
|
1652 // aName looks like "aPrefix<brace><something>". |
|
1653 // See if <something> is an integer number. |
|
1654 TPtrC num = aName.Right( nameLength - prefixLength - 1 ); |
|
1655 TBuf< KApMaxConnNameLength > pf; |
|
1656 pf = num; |
|
1657 // TODO AknTextUtils::ConvertDigitsTo( pf, EDigitTypeWestern ); |
|
1658 TInt val; |
|
1659 TLex lex( pf ); |
|
1660 if ( lex.Val( val ) == KErrNone ) |
|
1661 { |
|
1662 // Yes, the trailer is an integer. |
|
1663 if ( val > 0 ) |
|
1664 { |
|
1665 postfix = val; |
|
1666 } |
|
1667 else |
|
1668 { |
|
1669 // signal that it is invalid... |
|
1670 postfix = -1; |
|
1671 } |
|
1672 } |
|
1673 } |
|
1674 } |
|
1675 else |
|
1676 { |
|
1677 postfix = -1; |
|
1678 } |
|
1679 } |
|
1680 } |
|
1681 OstTraceFunctionExit0( CCMPLUGINBASEENG_GETPOSTFIX_EXIT ); |
|
1682 |
|
1683 return postfix; |
|
1684 } |
|
1685 |
|
1686 // --------------------------------------------------------------------------- |
|
1687 // CCmPluginBaseEng::IsValidNameL |
|
1688 // --------------------------------------------------------------------------- |
|
1689 // |
|
1690 TBool CCmPluginBaseEng::IsValidNameL( const TDesC& aNameText, |
|
1691 const TUint32& aIapId ) |
|
1692 { |
|
1693 OstTraceFunctionEntry0( CCMPLUGINBASEENG_ISVALIDNAMEL_ENTRY ); |
|
1694 |
|
1695 TBool retVal( ETrue ); |
|
1696 |
|
1697 CMDBRecordSet<CCDIAPRecord>* iapRS = |
|
1698 new(ELeave) CMDBRecordSet<CCDIAPRecord>(KCDTIdIAPRecord); |
|
1699 CleanupStack::PushL(iapRS); |
|
1700 |
|
1701 CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord *> |
|
1702 (CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord)); |
|
1703 |
|
1704 CleanupStack::PushL( iapRecord ); |
|
1705 |
|
1706 // Prime record |
|
1707 iapRecord->iRecordName.SetL( aNameText ); |
|
1708 |
|
1709 iapRS->iRecords.AppendL( iapRecord ); |
|
1710 |
|
1711 CleanupStack::Pop( iapRecord ); |
|
1712 |
|
1713 iapRecord = NULL; |
|
1714 |
|
1715 if ( iapRS->FindL(iSession) ) |
|
1716 { |
|
1717 if ( iIapId ) |
|
1718 // this is not a new CM |
|
1719 { |
|
1720 for ( TInt i = 0; i < iapRS->iRecords.Count(); ++i ) |
|
1721 { |
|
1722 if ( iapRS->iRecords[i]->RecordId() != aIapId ) |
|
1723 // duplication because it's not our name |
|
1724 { |
|
1725 retVal = EFalse; |
|
1726 break; |
|
1727 } |
|
1728 } |
|
1729 } |
|
1730 else |
|
1731 // new CM -> any occurence is a duplication |
|
1732 { |
|
1733 retVal = EFalse; |
|
1734 } |
|
1735 } |
|
1736 |
|
1737 CleanupStack::PopAndDestroy( iapRS ); |
|
1738 |
|
1739 OstTraceFunctionExit0( CCMPLUGINBASEENG_ISVALIDNAMEL_EXIT ); |
|
1740 |
|
1741 return retVal; |
|
1742 } |
|
1743 |
|
1744 // --------------------------------------------------------------------------- |
|
1745 // CCmPluginBaseEng::EscapeTextLC |
|
1746 // --------------------------------------------------------------------------- |
|
1747 // |
|
1748 HBufC* CCmPluginBaseEng::EscapeTextLC( const TDesC& aLiteral ) |
|
1749 { |
|
1750 OstTraceFunctionEntry0( CCMPLUGINBASEENG_ESCAPETEXTLC_ENTRY ); |
|
1751 |
|
1752 TInt l( aLiteral.Length() ); |
|
1753 //> 2*, to ensure correct esc. even if ALL chars are quotes... |
|
1754 HBufC* retbuf = HBufC::NewLC( 2*l ); |
|
1755 TPtr ret = retbuf->Des(); |
|
1756 TUint quote( '\'' ); // TChar gives warnings in THUMB & ARMI |
|
1757 TInt i( 0 ); |
|
1758 |
|
1759 for ( i=0; i<l; i++ ) |
|
1760 { |
|
1761 ret.Append( aLiteral[i] ); |
|
1762 if ( aLiteral[i] == quote ) |
|
1763 { |
|
1764 // Duplicate quote. |
|
1765 ret.Append( quote ); |
|
1766 } |
|
1767 } |
|
1768 OstTraceFunctionExit0( CCMPLUGINBASEENG_ESCAPETEXTLC_EXIT ); |
|
1769 |
|
1770 return retbuf; |
|
1771 } |
|
1772 |
|
1773 // --------------------------------------------------------------------------- |
|
1774 // CCmPluginBaseEng::SetDefaultNameL |
|
1775 // --------------------------------------------------------------------------- |
|
1776 // |
|
1777 void CCmPluginBaseEng::SetDefaultNameL( const TDesC& aName ) |
|
1778 { |
|
1779 OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETDEFAULTNAMEL_ENTRY ); |
|
1780 |
|
1781 if ( iNamingMethod == ENamingNothing ) |
|
1782 { |
|
1783 iIapRecord->iRecordName.SetL( aName ); |
|
1784 } |
|
1785 else if ( iNamingMethod == ENamingUnique ) |
|
1786 { |
|
1787 HBufC* newName = DoMakeValidNameL( aName, iIapId ); |
|
1788 |
|
1789 if ( newName ) |
|
1790 // name converted to unique |
|
1791 { |
|
1792 CleanupStack::PushL( newName ); |
|
1793 iIapRecord->iRecordName.SetL( *newName ); |
|
1794 CleanupStack::PopAndDestroy( newName ); |
|
1795 } |
|
1796 else |
|
1797 { |
|
1798 iIapRecord->iRecordName.SetL( aName ); |
|
1799 } |
|
1800 } |
|
1801 else if ( iNamingMethod == ENamingNotAccept ) |
|
1802 { |
|
1803 if ( IsValidNameL( aName, iIapId ) ) |
|
1804 { |
|
1805 iIapRecord->iRecordName.SetL( aName ); |
|
1806 } |
|
1807 else |
|
1808 { |
|
1809 User::Leave( KErrArgument ); |
|
1810 } |
|
1811 } |
|
1812 else |
|
1813 { |
|
1814 User::Leave( KErrCorrupt ); |
|
1815 } |
|
1816 OstTraceFunctionExit0( CCMPLUGINBASEENG_SETDEFAULTNAMEL_EXIT ); |
|
1817 } |
|
1818 |
|
1819 // --------------------------------------------------------------------------- |
|
1820 // CCmPluginBaseEng::SetNameL |
|
1821 // --------------------------------------------------------------------------- |
|
1822 // |
|
1823 void CCmPluginBaseEng::SetNameL( |
|
1824 const TDesC& aName, |
|
1825 CommsDat::CCDRecordBase* aIapRecord, |
|
1826 const CMManager::TNamingMethod aNamingMethod ) |
|
1827 { |
|
1828 OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETNAMEL_ENTRY ); |
|
1829 |
|
1830 if ( aNamingMethod == ENamingNothing ) |
|
1831 { |
|
1832 aIapRecord->iRecordName.SetL( aName ); |
|
1833 } |
|
1834 else if ( aNamingMethod == ENamingUnique ) |
|
1835 { |
|
1836 TUint32 iapid = aIapRecord->RecordId(); |
|
1837 HBufC* newName = DoMakeValidNameL( aName, iapid ); |
|
1838 |
|
1839 if ( newName ) |
|
1840 // name converted to unique |
|
1841 { |
|
1842 CleanupStack::PushL( newName ); |
|
1843 aIapRecord->iRecordName.SetL( *newName ); |
|
1844 CleanupStack::PopAndDestroy( newName ); |
|
1845 } |
|
1846 else |
|
1847 { |
|
1848 aIapRecord->iRecordName.SetL( aName ); |
|
1849 } |
|
1850 } |
|
1851 else if ( aNamingMethod == ENamingNotAccept ) |
|
1852 { |
|
1853 if ( IsValidNameL( aName, aIapRecord->RecordId() ) ) |
|
1854 { |
|
1855 aIapRecord->iRecordName.SetL( aName ); |
|
1856 } |
|
1857 else |
|
1858 { |
|
1859 User::Leave( KErrArgument ); |
|
1860 } |
|
1861 } |
|
1862 else |
|
1863 { |
|
1864 User::Leave( KErrCorrupt ); |
|
1865 } |
|
1866 OstTraceFunctionExit0( CCMPLUGINBASEENG_SETNAMEL_EXIT ); |
|
1867 } |
|
1868 |
|
1869 // --------------------------------------------------------------------------- |
|
1870 // CCmPluginBaseEng::CheckIfNameModifiedL |
|
1871 // --------------------------------------------------------------------------- |
|
1872 EXPORT_C void CCmPluginBaseEng::CheckIfNameModifiedL( |
|
1873 CCDRecordBase* aSrcRecord, |
|
1874 CCDRecordBase* aDestRecord ) const |
|
1875 { |
|
1876 OstTraceFunctionEntry0( CCMPLUGINBASEENG_CHECKIFNAMEMODIFIEDL_ENTRY ); |
|
1877 |
|
1878 if ( !TPtrC( aSrcRecord->iRecordName ).CompareF( TPtrC( aDestRecord->iRecordName ) ) ) |
|
1879 // names matche |
|
1880 { |
|
1881 OstTraceFunctionExit0( CCMPLUGINBASEENG_CHECKIFNAMEMODIFIEDL_EXIT ); |
|
1882 return; |
|
1883 } |
|
1884 |
|
1885 aDestRecord->iRecordName.SetL( TPtrC( aSrcRecord->iRecordName ) ); |
|
1886 |
|
1887 OstTraceFunctionExit0( DUP1_CCMPLUGINBASEENG_CHECKIFNAMEMODIFIEDL_EXIT ); |
|
1888 } |
|
1889 |
|
1890 // --------------------------------------------------------------------------- |
|
1891 // CCmPluginBaseEng::IAPRecordElementId |
|
1892 // --------------------------------------------------------------------------- |
|
1893 TMDBElementId CCmPluginBaseEng::IAPRecordElementId() const |
|
1894 { |
|
1895 OstTraceFunctionEntry0( CCMPLUGINBASEENG_IAPRECORDELEMENTID_ENTRY ); |
|
1896 |
|
1897 return ( KCDMaskShowField & iIapRecord->ElementId() ); |
|
1898 } |
|
1899 |
|
1900 // --------------------------------------------------------------------------- |
|
1901 // CCmPluginBaseEng::IsProtected |
|
1902 // --------------------------------------------------------------------------- |
|
1903 TBool CCmPluginBaseEng::IsProtected() const |
|
1904 { |
|
1905 OstTraceFunctionEntry0( CCMPLUGINBASEENG_ISPROTECTED_ENTRY ); |
|
1906 |
|
1907 return ( iIapRecord->Attributes() & ECDProtectedWrite ); |
|
1908 } |
|
1909 |
|
1910 // --------------------------------------------------------------------------- |
|
1911 // CCmPluginBaseEng::GetLocationIdL |
|
1912 // --------------------------------------------------------------------------- |
|
1913 TUint32 CCmPluginBaseEng::GetLocationIdL() const |
|
1914 { |
|
1915 OstTraceFunctionEntry0( CCMPLUGINBASEENG_GETLOCATIONIDL_ENTRY ); |
|
1916 |
|
1917 TUint32 locId( 0 ); |
|
1918 CMDBRecordSet<CCDLocationRecord>* locRS = |
|
1919 new(ELeave) CMDBRecordSet<CCDLocationRecord>(KCDTIdLocationRecord); |
|
1920 CleanupStack::PushL( locRS ); |
|
1921 |
|
1922 CCDLocationRecord* locRecord = static_cast<CCDLocationRecord *> |
|
1923 (CCDRecordBase::RecordFactoryL(KCDTIdLocationRecord)); |
|
1924 |
|
1925 CleanupStack::PushL( locRecord ); |
|
1926 locRecord->iRecordName.SetL( KLocationName ); |
|
1927 locRS->iRecords.AppendL( locRecord ); |
|
1928 CleanupStack::Pop( locRecord ); |
|
1929 |
|
1930 if ( locRS->FindL(iSession) ) |
|
1931 { |
|
1932 locRecord = static_cast<CCDLocationRecord *>(locRS->iRecords[0]); |
|
1933 |
|
1934 locId = locRecord->RecordId(); |
|
1935 } |
|
1936 else |
|
1937 { |
|
1938 User::Leave( KErrNotFound ); |
|
1939 } |
|
1940 |
|
1941 CleanupStack::PopAndDestroy( locRS ); |
|
1942 |
|
1943 OstTraceFunctionExit0( CCMPLUGINBASEENG_GETLOCATIONIDL_EXIT ); |
|
1944 |
|
1945 return locId; |
|
1946 } |
|
1947 |
|
1948 // --------------------------------------------------------------------------- |
|
1949 // CCmPluginBaseEng::SetProxyServerNameL |
|
1950 // --------------------------------------------------------------------------- |
|
1951 void CCmPluginBaseEng::SetProxyServerNameL( const TDesC& aProxyServer, |
|
1952 CCDRecordBase* aProxyRecord ) |
|
1953 { |
|
1954 OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETPROXYSERVERNAMEL_ENTRY ); |
|
1955 |
|
1956 CCDProxiesRecord* proxyRecord = |
|
1957 static_cast<CCDProxiesRecord*>( aProxyRecord ); |
|
1958 |
|
1959 proxyRecord->iServerName.SetL( aProxyServer ); |
|
1960 if ( !aProxyServer.Length() ) |
|
1961 { |
|
1962 proxyRecord->iPortNumber = 0; |
|
1963 proxyRecord->iUseProxyServer = EFalse; |
|
1964 } |
|
1965 else |
|
1966 { |
|
1967 proxyRecord->iUseProxyServer = ETrue; |
|
1968 } |
|
1969 |
|
1970 OstTraceFunctionExit0( CCMPLUGINBASEENG_SETPROXYSERVERNAMEL_EXIT ); |
|
1971 } |
|
1972 |
|
1973 // --------------------------------------------------------------------------- |
|
1974 // CCmPluginBaseEng::CheckDNSServerAddressL |
|
1975 // --------------------------------------------------------------------------- |
|
1976 // |
|
1977 EXPORT_C void CCmPluginBaseEng::CheckDNSServerAddressL( TBool aIPv6, |
|
1978 CMDBField<TDesC>& aDNS1, |
|
1979 CMDBField<TDesC>& aDNS2, |
|
1980 CMDBField<TBool>& aDNSFromServer ) |
|
1981 { |
|
1982 OstTraceFunctionEntry0( CCMPLUGINBASEENG_CHECKDNSSERVERADDRESSL_ENTRY ); |
|
1983 |
|
1984 if ( !aDNSFromServer ) |
|
1985 { |
|
1986 if ( aIPv6 ) |
|
1987 { |
|
1988 if ( ClassifyIPv6Address( aDNS1 ) == EIPv6Unspecified ) |
|
1989 { |
|
1990 if ( ClassifyIPv6Address( aDNS2 ) != EIPv6Unspecified ) |
|
1991 { |
|
1992 aDNS1.SetL( aDNS2 ); |
|
1993 aDNS2.SetL( KDynamicIpv6Address ); |
|
1994 } |
|
1995 else |
|
1996 { |
|
1997 // Both are unspecified |
|
1998 aDNSFromServer = ETrue; |
|
1999 } |
|
2000 } |
|
2001 } |
|
2002 else // IPv4 |
|
2003 { |
|
2004 if ( IsUnspecifiedIPv4Address( aDNS1 ) ) |
|
2005 { |
|
2006 if ( !IsUnspecifiedIPv4Address( aDNS2 ) ) |
|
2007 { |
|
2008 aDNS1.SetL( aDNS2 ); |
|
2009 aDNS2.SetL( KUnspecifiedIPv4 ); |
|
2010 } |
|
2011 else |
|
2012 { |
|
2013 // Both are unspecified |
|
2014 aDNSFromServer = ETrue; |
|
2015 } |
|
2016 } |
|
2017 } |
|
2018 } |
|
2019 |
|
2020 OstTraceFunctionExit0( DUP1_CCMPLUGINBASEENG_CHECKDNSSERVERADDRESSL_EXIT ); |
|
2021 } |
|
2022 |
|
2023 //----------------------------------------------------------------------------- |
|
2024 // CCmPluginBaseEng::GetGenericCmRecordsL |
|
2025 // ----------------------------------------------------------------------------- |
|
2026 EXPORT_C void CCmPluginBaseEng::GetPluginDataL( |
|
2027 CCmClientPluginInstance* aClientPluginInstance ) |
|
2028 { |
|
2029 OstTraceFunctionEntry0( CCMPLUGINBASEENG_GETPLUGINDATAL_ENTRY ); |
|
2030 |
|
2031 if ( !aClientPluginInstance ) |
|
2032 { |
|
2033 User::Leave( KErrCorrupt ); |
|
2034 } |
|
2035 |
|
2036 aClientPluginInstance->iGenRecordArray.ResetAndDestroy(); |
|
2037 aClientPluginInstance->iBearerSpecRecordArray.ResetAndDestroy(); |
|
2038 |
|
2039 aClientPluginInstance->iNamingMethod = iNamingMethod; |
|
2040 aClientPluginInstance->iLocationEnabled = iLocationEnabled; |
|
2041 |
|
2042 if ( iIapRecord ) |
|
2043 { |
|
2044 CCDIAPRecord* iapRecord = |
|
2045 static_cast<CCDIAPRecord*>( CCDRecordBase::CreateCopyRecordL( *iIapRecord ) ); |
|
2046 CleanupStack::PushL( iapRecord ); |
|
2047 iapRecord->SetElementId( iIapRecord->ElementId() ); |
|
2048 aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( iapRecord ) ); |
|
2049 CleanupStack::Pop( iapRecord ); |
|
2050 } |
|
2051 else |
|
2052 { |
|
2053 User::Leave( KErrNotFound ); |
|
2054 } |
|
2055 |
|
2056 if ( iServiceRecord ) |
|
2057 { |
|
2058 CCDRecordBase* serviceRecord = CopyServiceRecordL(); |
|
2059 serviceRecord->SetElementId( iServiceRecord->ElementId() ); |
|
2060 CleanupStack::PushL( serviceRecord ); |
|
2061 aClientPluginInstance->iGenRecordArray.AppendL( serviceRecord ); |
|
2062 CleanupStack::Pop( serviceRecord ); |
|
2063 } |
|
2064 else |
|
2065 { |
|
2066 User::Leave( KErrNotFound ); |
|
2067 } |
|
2068 |
|
2069 if ( iNetworkRecord ) |
|
2070 { |
|
2071 CCDNetworkRecord* networkRecord = |
|
2072 static_cast<CCDNetworkRecord*>( CCDRecordBase::CreateCopyRecordL( *iNetworkRecord ) ); |
|
2073 CleanupStack::PushL( networkRecord ); |
|
2074 networkRecord->SetElementId( iNetworkRecord->ElementId() ); |
|
2075 aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( networkRecord ) ); |
|
2076 CleanupStack::Pop( networkRecord ); |
|
2077 } |
|
2078 else |
|
2079 { |
|
2080 User::Leave( KErrNotFound ); |
|
2081 } |
|
2082 |
|
2083 if ( iWapAPRecord ) |
|
2084 { |
|
2085 CCDWAPAccessPointRecord* wapAPRecord = |
|
2086 static_cast<CCDWAPAccessPointRecord*>( CCDRecordBase::CreateCopyRecordL( *iWapAPRecord ) ); |
|
2087 CleanupStack::PushL( wapAPRecord ); |
|
2088 wapAPRecord->SetElementId( iWapAPRecord->ElementId() ); |
|
2089 aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( wapAPRecord ) ); |
|
2090 CleanupStack::Pop( wapAPRecord ); |
|
2091 } |
|
2092 else |
|
2093 { |
|
2094 User::Leave( KErrNotFound ); |
|
2095 } |
|
2096 |
|
2097 if ( iWapIPBearerRecord ) |
|
2098 { |
|
2099 CCDWAPIPBearerRecord* wapIPBearerRecord = |
|
2100 static_cast<CCDWAPIPBearerRecord*>( CCDRecordBase::CreateCopyRecordL( *iWapIPBearerRecord ) ); |
|
2101 CleanupStack::PushL( wapIPBearerRecord ); |
|
2102 wapIPBearerRecord->SetElementId( iWapIPBearerRecord->ElementId() ); |
|
2103 aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( wapIPBearerRecord ) ); |
|
2104 CleanupStack::Pop( wapIPBearerRecord ); |
|
2105 } |
|
2106 else |
|
2107 { |
|
2108 User::Leave( KErrNotFound ); |
|
2109 } |
|
2110 |
|
2111 if ( iMetaDataRecord ) |
|
2112 { |
|
2113 CCDIAPMetadataRecord* metaDataRecord = |
|
2114 new( ELeave ) CCDIAPMetadataRecord( iMetadataTableId ); |
|
2115 CleanupStack::PushL( metaDataRecord ); |
|
2116 metaDataRecord->iIAP = IAPRecordElementId(); |
|
2117 metaDataRecord->iMetadata.SetL( iMetaDataRecord->iMetadata ); |
|
2118 metaDataRecord->iSeamlessness.SetL( iMetaDataRecord->iSeamlessness ); |
|
2119 metaDataRecord->SetElementId( iMetaDataRecord->ElementId() ); |
|
2120 // Record name is set during update. |
|
2121 |
|
2122 aClientPluginInstance->iGenRecordArray.AppendL( |
|
2123 static_cast<CommsDat::CCDRecordBase*>( metaDataRecord ) ); |
|
2124 CleanupStack::Pop( metaDataRecord ); |
|
2125 } |
|
2126 else |
|
2127 { |
|
2128 aClientPluginInstance->iGenRecordArray.AppendL( NULL ); |
|
2129 } |
|
2130 |
|
2131 if ( iLocationRecord ) |
|
2132 { |
|
2133 CCDLocationRecord* locationRecord = |
|
2134 static_cast<CCDLocationRecord*>( CCDRecordBase::CreateCopyRecordL( *iLocationRecord ) ); |
|
2135 CleanupStack::PushL( locationRecord ); |
|
2136 locationRecord->SetElementId( iLocationRecord->ElementId() ); |
|
2137 aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( locationRecord ) ); |
|
2138 CleanupStack::Pop( locationRecord ); |
|
2139 } |
|
2140 else |
|
2141 { |
|
2142 aClientPluginInstance->iGenRecordArray.AppendL( NULL ); |
|
2143 } |
|
2144 |
|
2145 if ( iProxyRecord ) |
|
2146 { |
|
2147 CCDProxiesRecord* proxyRecord = |
|
2148 static_cast<CCDProxiesRecord*>( CCDRecordBase::CreateCopyRecordL( *iProxyRecord ) ); |
|
2149 CleanupStack::PushL( proxyRecord ); |
|
2150 proxyRecord->SetElementId( iProxyRecord->ElementId() ); |
|
2151 aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( proxyRecord ) ); |
|
2152 CleanupStack::Pop( proxyRecord ); |
|
2153 } |
|
2154 else |
|
2155 { |
|
2156 aClientPluginInstance->iGenRecordArray.AppendL( NULL ); |
|
2157 } |
|
2158 |
|
2159 GetBearerSpecificRecordsL( aClientPluginInstance->iBearerSpecRecordArray ); |
|
2160 |
|
2161 OstTraceFunctionExit0( CCMPLUGINBASEENG_GETPLUGINDATAL_EXIT ); |
|
2162 } |
|
2163 |
|
2164 //----------------------------------------------------------------------------- |
|
2165 // CCmPluginBaseEng::GetIntAttributeL |
|
2166 // ----------------------------------------------------------------------------- |
|
2167 EXPORT_C TUint32 CCmPluginBaseEng::GetIntAttributeL( |
|
2168 TUint32 aAttribute, |
|
2169 CCmClientPluginInstance* aClientPluginInstance ) |
|
2170 { |
|
2171 OstTraceFunctionEntry0( CCMPLUGINBASEENG_GETINTATTRIBUTEL_ENTRY ); |
|
2172 |
|
2173 TUint32 retVal( 0 ); |
|
2174 |
|
2175 switch ( aAttribute ) |
|
2176 { |
|
2177 case ECmIapId: // If the CM has an ECmIapId then the ECmIapId is the ECmId. |
|
2178 case ECmId: |
|
2179 { |
|
2180 retVal = static_cast<CCDIAPRecord*>( |
|
2181 aClientPluginInstance->iGenRecordArray[KIapRecordIndex] )->RecordId(); |
|
2182 } |
|
2183 break; |
|
2184 case ECmWapId: |
|
2185 { |
|
2186 retVal = static_cast<CCDWAPIPBearerRecord*>( |
|
2187 aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )->iWAPAccessPointId; |
|
2188 } |
|
2189 break; |
|
2190 case ECmIapServiceId: |
|
2191 { |
|
2192 retVal = static_cast<CCDIAPRecord*>( |
|
2193 aClientPluginInstance->iGenRecordArray[KIapRecordIndex] )->iService; |
|
2194 } |
|
2195 break; |
|
2196 case ECmBearerType: |
|
2197 { |
|
2198 retVal = iBearerType; |
|
2199 } |
|
2200 break; |
|
2201 case ECmDefaultPriority: |
|
2202 { |
|
2203 retVal = KDataMobilitySelectionPolicyPriorityWildCard; |
|
2204 } |
|
2205 break; |
|
2206 case ECmDefaultUiPriority: |
|
2207 { |
|
2208 retVal = KDataMobilitySelectionPolicyPriorityWildCard; |
|
2209 } |
|
2210 break; |
|
2211 case ECmNamingMethod: |
|
2212 { |
|
2213 retVal = iNamingMethod; |
|
2214 } |
|
2215 break; |
|
2216 case ECmSeamlessnessLevel: |
|
2217 { |
|
2218 if ( iMetaDataRecord ) |
|
2219 { |
|
2220 retVal = static_cast<CCDIAPMetadataRecord*>( |
|
2221 aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] )->iSeamlessness; |
|
2222 } |
|
2223 else |
|
2224 { |
|
2225 User::Leave( KErrNotFound ); |
|
2226 } |
|
2227 } |
|
2228 break; |
|
2229 case ECmElementID: |
|
2230 { |
|
2231 if ( !iIapRecord ) |
|
2232 { |
|
2233 User::Leave( KErrNotReady ); |
|
2234 } |
|
2235 |
|
2236 retVal = ( KCDMaskShowField & ( static_cast<CCDIAPRecord*>( |
|
2237 aClientPluginInstance->iGenRecordArray[KIapRecordIndex] )->ElementId() ) ); |
|
2238 } |
|
2239 break; |
|
2240 |
|
2241 case ECmLoadResult: |
|
2242 { |
|
2243 retVal = KErrNone; |
|
2244 } |
|
2245 break; |
|
2246 |
|
2247 case ECmNetworkId: |
|
2248 { |
|
2249 retVal = static_cast<CCDIAPRecord*>( |
|
2250 aClientPluginInstance->iGenRecordArray[KIapRecordIndex] )->iNetwork; |
|
2251 } |
|
2252 break; |
|
2253 case ECmProxyPortNumber: |
|
2254 { |
|
2255 if ( !aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ) |
|
2256 { |
|
2257 User::Leave( KErrNotFound ); |
|
2258 } |
|
2259 |
|
2260 retVal = static_cast<CCDProxiesRecord*>( |
|
2261 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->iPortNumber; |
|
2262 } |
|
2263 break; |
|
2264 case ECmWapIPWSPOption: |
|
2265 { |
|
2266 retVal = static_cast<CCDWAPIPBearerRecord*>( |
|
2267 aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )->iWAPWSPOption; |
|
2268 } |
|
2269 break; |
|
2270 case ECmWapIPProxyPort: |
|
2271 { |
|
2272 retVal = static_cast<CCDWAPIPBearerRecord*>( |
|
2273 aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )->iWAPProxyPort; |
|
2274 } |
|
2275 break; |
|
2276 default: |
|
2277 { |
|
2278 retVal = GetBearerIntAttributeL( aAttribute, |
|
2279 aClientPluginInstance->iGenRecordArray, |
|
2280 aClientPluginInstance->iBearerSpecRecordArray ); |
|
2281 } |
|
2282 break; |
|
2283 } |
|
2284 |
|
2285 OstTraceFunctionExit0( CCMPLUGINBASEENG_GETINTATTRIBUTEL_EXIT ); |
|
2286 |
|
2287 return retVal; |
|
2288 } |
|
2289 |
|
2290 //----------------------------------------------------------------------------- |
|
2291 // CCmPluginBaseEng::GetBoolAttributeL |
|
2292 // ----------------------------------------------------------------------------- |
|
2293 EXPORT_C TBool CCmPluginBaseEng::GetBoolAttributeL( |
|
2294 TUint32 aAttribute, |
|
2295 CCmClientPluginInstance* aClientPluginInstance ) |
|
2296 { |
|
2297 OstTraceFunctionEntry0( CCMPLUGINBASEENG_GETBOOLATTRIBUTEL_ENTRY ); |
|
2298 |
|
2299 TBool retVal( EFalse ); |
|
2300 |
|
2301 switch ( aAttribute ) |
|
2302 { |
|
2303 case ECmProtected: |
|
2304 { |
|
2305 retVal = IsProtected(); |
|
2306 } |
|
2307 break; |
|
2308 case ECmHidden: |
|
2309 { |
|
2310 CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>( |
|
2311 aClientPluginInstance->iGenRecordArray[KIapRecordIndex] ); |
|
2312 retVal = iapRecord->Attributes() & ECDHidden; |
|
2313 } |
|
2314 break; |
|
2315 case ECmProxyUsageEnabled: |
|
2316 { |
|
2317 if ( !aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ) |
|
2318 { |
|
2319 retVal = EFalse; |
|
2320 } |
|
2321 |
|
2322 retVal = static_cast<CCDProxiesRecord*>( |
|
2323 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->iUseProxyServer; |
|
2324 } |
|
2325 break; |
|
2326 case ECmDestination: |
|
2327 { |
|
2328 TRAPD( err, retVal = GetBearerBoolAttributeL( aAttribute, |
|
2329 aClientPluginInstance->iGenRecordArray, |
|
2330 aClientPluginInstance->iBearerSpecRecordArray ) ); |
|
2331 if ( err ) |
|
2332 { |
|
2333 if ( err == KErrNotFound ) |
|
2334 { |
|
2335 retVal = EFalse; |
|
2336 } |
|
2337 else |
|
2338 { |
|
2339 User::Leave( err ); |
|
2340 } |
|
2341 } |
|
2342 } |
|
2343 break; |
|
2344 case ECmChargeCardUsageEnabled: |
|
2345 { |
|
2346 retVal = EFalse; |
|
2347 } |
|
2348 break; |
|
2349 case ECmCoverage: |
|
2350 // In default the plugin has no network coverage |
|
2351 { |
|
2352 TRAPD( err, retVal = GetBearerBoolAttributeL( aAttribute, |
|
2353 aClientPluginInstance->iGenRecordArray, |
|
2354 aClientPluginInstance->iBearerSpecRecordArray ) ); |
|
2355 if ( err ) |
|
2356 { |
|
2357 if ( err == KErrNotFound ) |
|
2358 { |
|
2359 retVal = EFalse; |
|
2360 } |
|
2361 else |
|
2362 { |
|
2363 User::Leave( err ); |
|
2364 } |
|
2365 } |
|
2366 } |
|
2367 break; |
|
2368 case ECmMetaHighlight: |
|
2369 { |
|
2370 CCDIAPMetadataRecord* metadataRecord = |
|
2371 static_cast<CCDIAPMetadataRecord*>( |
|
2372 aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] ); |
|
2373 retVal = metadataRecord->iMetadata & EMetaHighlight; |
|
2374 } |
|
2375 break; |
|
2376 case ECmMetaHiddenAgent: |
|
2377 { |
|
2378 CCDIAPMetadataRecord* metadataRecord = |
|
2379 static_cast<CCDIAPMetadataRecord*>( |
|
2380 aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] ); |
|
2381 retVal = metadataRecord->iMetadata & EMetaHiddenAgent; |
|
2382 } |
|
2383 break; |
|
2384 case ECmVirtual: |
|
2385 { |
|
2386 retVal = EFalse; |
|
2387 } |
|
2388 break; |
|
2389 case ECmWapIPSecurity: |
|
2390 { |
|
2391 retVal = static_cast<CCDWAPIPBearerRecord*>( |
|
2392 aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )->iWAPSecurity; |
|
2393 } |
|
2394 break; |
|
2395 default: |
|
2396 { |
|
2397 retVal = GetBearerBoolAttributeL( aAttribute, |
|
2398 aClientPluginInstance->iGenRecordArray, |
|
2399 aClientPluginInstance->iBearerSpecRecordArray ); |
|
2400 } |
|
2401 } |
|
2402 |
|
2403 OstTraceFunctionExit0( CCMPLUGINBASEENG_GETBOOLATTRIBUTEL_EXIT ); |
|
2404 |
|
2405 return retVal; |
|
2406 } |
|
2407 |
|
2408 // ----------------------------------------------------------------------------- |
|
2409 // CCmPluginBaseEng::GetStringAttributeL() |
|
2410 // ----------------------------------------------------------------------------- |
|
2411 // |
|
2412 EXPORT_C HBufC* CCmPluginBaseEng::GetStringAttributeL( |
|
2413 TUint32 aAttribute, |
|
2414 CCmClientPluginInstance* aClientPluginInstance ) |
|
2415 { |
|
2416 OstTraceFunctionEntry0( CCMPLUGINBASEENG_GETSTRINGATTRIBUTEL_ENTRY ); |
|
2417 |
|
2418 HBufC* retVal = NULL; |
|
2419 |
|
2420 switch ( aAttribute ) |
|
2421 { |
|
2422 case ECmStartPage: |
|
2423 { |
|
2424 CCDWAPAccessPointRecord* wapAPRecord = |
|
2425 static_cast<CCDWAPAccessPointRecord*>( |
|
2426 aClientPluginInstance->iGenRecordArray[KWAPAPRecordIndex] ); |
|
2427 |
|
2428 retVal = TPtrC( wapAPRecord->iWAPStartPage).AllocL(); |
|
2429 } |
|
2430 break; |
|
2431 case ECmName: |
|
2432 { |
|
2433 CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>( |
|
2434 aClientPluginInstance->iGenRecordArray[KIapRecordIndex] ); |
|
2435 retVal = TPtrC( iapRecord->iRecordName ).AllocL(); |
|
2436 } |
|
2437 break; |
|
2438 case ECmProxyServerName: |
|
2439 { |
|
2440 if ( !aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ) |
|
2441 { |
|
2442 User::Leave( KErrNotFound ); |
|
2443 } |
|
2444 |
|
2445 CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>( |
|
2446 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ); |
|
2447 |
|
2448 retVal = TPtrC( proxyRecord->iServerName ).AllocL(); |
|
2449 } |
|
2450 break; |
|
2451 case ECmProxyProtocolName: |
|
2452 { |
|
2453 if ( !aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ) |
|
2454 { |
|
2455 User::Leave( KErrNotFound ); |
|
2456 } |
|
2457 |
|
2458 CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>( |
|
2459 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ); |
|
2460 |
|
2461 retVal = TPtrC( proxyRecord->iExceptions ).AllocL(); |
|
2462 } |
|
2463 break; |
|
2464 case ECmProxyExceptions: |
|
2465 { |
|
2466 if ( !aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ) |
|
2467 { |
|
2468 User::Leave( KErrNotFound ); |
|
2469 } |
|
2470 |
|
2471 CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>( |
|
2472 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ); |
|
2473 |
|
2474 retVal = TPtrC( proxyRecord->iProtocolName ).AllocL(); |
|
2475 } |
|
2476 break; |
|
2477 case ECmWapIPGatewayAddress: |
|
2478 { |
|
2479 if ( !aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] ) |
|
2480 { |
|
2481 User::Leave( KErrNotFound ); |
|
2482 } |
|
2483 |
|
2484 CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>( |
|
2485 aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] ); |
|
2486 |
|
2487 retVal = TPtrC( wapIPBearerRecord->iWAPGatewayAddress ).AllocL(); |
|
2488 } |
|
2489 break; |
|
2490 case ECmWapIPProxyLoginName: |
|
2491 { |
|
2492 if ( !aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] ) |
|
2493 { |
|
2494 User::Leave( KErrNotFound ); |
|
2495 } |
|
2496 |
|
2497 CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>( |
|
2498 aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] ); |
|
2499 |
|
2500 retVal = TPtrC( wapIPBearerRecord->iWAPProxyLoginName ).AllocL(); |
|
2501 } |
|
2502 break; |
|
2503 case ECmWapIPProxyLoginPass: |
|
2504 { |
|
2505 if ( !aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] ) |
|
2506 { |
|
2507 User::Leave( KErrNotFound ); |
|
2508 } |
|
2509 |
|
2510 CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>( |
|
2511 aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] ); |
|
2512 |
|
2513 retVal = TPtrC( wapIPBearerRecord->iWAPProxyLoginPass ).AllocL(); |
|
2514 } |
|
2515 break; |
|
2516 default: |
|
2517 { |
|
2518 retVal = GetBearerStringAttributeL( aAttribute, |
|
2519 aClientPluginInstance->iGenRecordArray, |
|
2520 aClientPluginInstance->iBearerSpecRecordArray ); |
|
2521 } |
|
2522 } |
|
2523 |
|
2524 OstTraceFunctionExit0( CCMPLUGINBASEENG_GETSTRINGATTRIBUTEL_EXIT ); |
|
2525 |
|
2526 return retVal; |
|
2527 } |
|
2528 |
|
2529 // ----------------------------------------------------------------------------- |
|
2530 // CCmPluginBaseEng::GetString8AttributeL() |
|
2531 // ----------------------------------------------------------------------------- |
|
2532 // |
|
2533 EXPORT_C HBufC8* CCmPluginBaseEng::GetString8AttributeL( |
|
2534 TUint32 aAttribute, |
|
2535 CCmClientPluginInstance* aClientPluginInstance ) |
|
2536 { |
|
2537 OstTraceFunctionEntry0( CCMPLUGINBASEENG_GETSTRING8ATTRIBUTEL_ENTRY ); |
|
2538 |
|
2539 HBufC8* retVal = NULL; |
|
2540 |
|
2541 switch ( aAttribute ) |
|
2542 { |
|
2543 default: |
|
2544 { |
|
2545 retVal = GetBearerString8AttributeL( aAttribute, |
|
2546 aClientPluginInstance->iGenRecordArray, |
|
2547 aClientPluginInstance->iBearerSpecRecordArray ); |
|
2548 } |
|
2549 } |
|
2550 |
|
2551 OstTraceFunctionExit0( CCMPLUGINBASEENG_GETSTRING8ATTRIBUTEL_EXIT ); |
|
2552 |
|
2553 return retVal; |
|
2554 } |
|
2555 |
|
2556 //----------------------------------------------------------------------------- |
|
2557 // CCmPluginBaseEng::GetIntAttributeL |
|
2558 // ----------------------------------------------------------------------------- |
|
2559 EXPORT_C void CCmPluginBaseEng::SetIntAttributeL( |
|
2560 TUint32 aAttribute, |
|
2561 TUint32 aValue, |
|
2562 CCmClientPluginInstance* aClientPluginInstance ) |
|
2563 { |
|
2564 OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETINTATTRIBUTEL_ENTRY ); |
|
2565 |
|
2566 switch ( aAttribute ) |
|
2567 { |
|
2568 case ECmNamingMethod: |
|
2569 { |
|
2570 aClientPluginInstance->iNamingMethod = ( TNamingMethod )aValue; |
|
2571 } |
|
2572 break; |
|
2573 |
|
2574 case ECmCommsDBBearerType: |
|
2575 case ECmElementID: |
|
2576 case ECmIapId: |
|
2577 case ECmId: |
|
2578 { |
|
2579 User::Leave( KErrNotSupported ); |
|
2580 } |
|
2581 break; |
|
2582 |
|
2583 case ECmSeamlessnessLevel: |
|
2584 { |
|
2585 if ( aValue == ESeamlessnessConfirmFirst || aValue == ESeamlessnessShowprogress ) |
|
2586 { |
|
2587 static_cast<CCDIAPMetadataRecord*>( |
|
2588 aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] )-> |
|
2589 iSeamlessness.SetL( aValue ); |
|
2590 } |
|
2591 else |
|
2592 { |
|
2593 User::Leave( KErrNotSupported ); |
|
2594 } |
|
2595 } |
|
2596 break; |
|
2597 |
|
2598 case ECmNetworkId: |
|
2599 { |
|
2600 User::Leave( KErrNotSupported ); |
|
2601 } |
|
2602 break; |
|
2603 case ECmProxyPortNumber: |
|
2604 { |
|
2605 if ( !aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ) |
|
2606 { |
|
2607 CCDProxiesRecord* proxyRecord = |
|
2608 static_cast<CCDProxiesRecord*>( CCDRecordBase::CreateCopyRecordL( *iProxyRecord ) ); |
|
2609 CleanupStack::PushL( proxyRecord ); |
|
2610 proxyRecord->SetElementId( iProxyRecord->ElementId() ); |
|
2611 aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( proxyRecord ) ); |
|
2612 CleanupStack::Pop( proxyRecord ); |
|
2613 } |
|
2614 |
|
2615 static_cast<CCDProxiesRecord*>( |
|
2616 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ) |
|
2617 ->iPortNumber = aValue; |
|
2618 } |
|
2619 break; |
|
2620 case ECmWapIPWSPOption: |
|
2621 { |
|
2622 if ( aValue > KMaxTUint8 ) |
|
2623 { |
|
2624 User::Leave( KErrArgument ); |
|
2625 } |
|
2626 else |
|
2627 { |
|
2628 static_cast<CCDWAPIPBearerRecord*>( |
|
2629 aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )->iWAPWSPOption.SetL( aValue ); |
|
2630 } |
|
2631 } |
|
2632 break; |
|
2633 case ECmWapIPProxyPort: |
|
2634 { |
|
2635 static_cast<CCDWAPIPBearerRecord*>( |
|
2636 aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )->iWAPProxyPort.SetL( aValue ); |
|
2637 } |
|
2638 break; |
|
2639 default: |
|
2640 { |
|
2641 SetBearerIntAttributeL( aAttribute, |
|
2642 aValue, |
|
2643 aClientPluginInstance->iGenRecordArray, |
|
2644 aClientPluginInstance->iBearerSpecRecordArray ); |
|
2645 } |
|
2646 } |
|
2647 OstTraceFunctionExit0( CCMPLUGINBASEENG_SETINTATTRIBUTEL_EXIT ); |
|
2648 } |
|
2649 |
|
2650 //----------------------------------------------------------------------------- |
|
2651 // CCmPluginBaseEng::SetBoolAttributeL |
|
2652 // ----------------------------------------------------------------------------- |
|
2653 EXPORT_C void CCmPluginBaseEng::SetBoolAttributeL( |
|
2654 TUint32 aAttribute, |
|
2655 TBool aValue, |
|
2656 CCmClientPluginInstance* aClientPluginInstance ) |
|
2657 { |
|
2658 OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETBOOLATTRIBUTEL_ENTRY ); |
|
2659 |
|
2660 CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>( |
|
2661 aClientPluginInstance->iGenRecordArray[KIapRecordIndex] ); |
|
2662 |
|
2663 switch ( aAttribute ) |
|
2664 { |
|
2665 case ECmProtected: |
|
2666 { |
|
2667 /** |
|
2668 * ECDProtectedWrite attribute is set in |
|
2669 * - iap record |
|
2670 * - network record |
|
2671 * - iapmetadata record |
|
2672 * - wap records |
|
2673 * - proxy record |
|
2674 * And depending the bearer |
|
2675 * - service record |
|
2676 * - bearer record |
|
2677 * - other bearer specific records |
|
2678 */ |
|
2679 SetAttribute( iapRecord, ECDProtectedWrite, aValue ); |
|
2680 } |
|
2681 break; |
|
2682 case ECmHidden: |
|
2683 { |
|
2684 /** |
|
2685 * ECDHidden attribute is set in |
|
2686 * - iap record |
|
2687 * - network record |
|
2688 * - iapmetadata record |
|
2689 * - wap records |
|
2690 * - proxy record |
|
2691 * And depending the bearer |
|
2692 * - service record |
|
2693 * - bearer record |
|
2694 * - other bearer specific records |
|
2695 */ |
|
2696 SetAttribute( iapRecord, ECDHidden, aValue ); |
|
2697 } |
|
2698 break; |
|
2699 case ECmProxyUsageEnabled: |
|
2700 { |
|
2701 if ( !aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ) |
|
2702 { |
|
2703 CCDProxiesRecord* proxyRecord = |
|
2704 static_cast<CCDProxiesRecord*>( CCDRecordBase::CreateCopyRecordL( *iProxyRecord ) ); |
|
2705 CleanupStack::PushL( proxyRecord ); |
|
2706 proxyRecord->SetElementId( iProxyRecord->ElementId() ); |
|
2707 aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( proxyRecord ) ); |
|
2708 CleanupStack::Pop( proxyRecord ); |
|
2709 } |
|
2710 |
|
2711 static_cast<CCDProxiesRecord*>( |
|
2712 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ) |
|
2713 ->iUseProxyServer = aValue; |
|
2714 } |
|
2715 break; |
|
2716 case ECmChargeCardUsageEnabled: |
|
2717 { |
|
2718 User::Leave( KErrNotSupported ); |
|
2719 } |
|
2720 break; |
|
2721 case ECmLocationUsageEnabled: |
|
2722 { |
|
2723 EnableLocationL( aValue ); |
|
2724 } |
|
2725 break; |
|
2726 case ECmMetaHighlight: |
|
2727 { |
|
2728 CCDIAPMetadataRecord* metadataRecord = |
|
2729 static_cast<CCDIAPMetadataRecord*>( |
|
2730 aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] ); |
|
2731 if ( aValue ) |
|
2732 { |
|
2733 metadataRecord->iMetadata = EMetaHighlight | metadataRecord->iMetadata; |
|
2734 } |
|
2735 else |
|
2736 { |
|
2737 metadataRecord->iMetadata = ~EMetaHighlight & metadataRecord->iMetadata; |
|
2738 } |
|
2739 } |
|
2740 break; |
|
2741 case ECmMetaHiddenAgent: |
|
2742 { |
|
2743 CCDIAPMetadataRecord* metadataRecord = static_cast<CCDIAPMetadataRecord*>( |
|
2744 aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] ); |
|
2745 if ( aValue ) |
|
2746 { |
|
2747 metadataRecord->iMetadata = EMetaHiddenAgent | metadataRecord->iMetadata; |
|
2748 } |
|
2749 else |
|
2750 { |
|
2751 metadataRecord->iMetadata = ~EMetaHiddenAgent & metadataRecord->iMetadata; |
|
2752 } |
|
2753 } |
|
2754 break; |
|
2755 case ECmWapIPSecurity: |
|
2756 { |
|
2757 static_cast<CCDWAPIPBearerRecord*>( |
|
2758 aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )->iWAPSecurity.SetL( aValue ); |
|
2759 } |
|
2760 break; |
|
2761 default: |
|
2762 { |
|
2763 SetBearerBoolAttributeL( aAttribute, |
|
2764 aValue, |
|
2765 aClientPluginInstance->iGenRecordArray, |
|
2766 aClientPluginInstance->iBearerSpecRecordArray ); |
|
2767 } |
|
2768 } |
|
2769 OstTraceFunctionExit0( CCMPLUGINBASEENG_SETBOOLATTRIBUTEL_EXIT ); |
|
2770 } |
|
2771 |
|
2772 //----------------------------------------------------------------------------- |
|
2773 // CCmPluginBaseEng::SetStringAttributeL |
|
2774 // ----------------------------------------------------------------------------- |
|
2775 EXPORT_C void CCmPluginBaseEng::SetStringAttributeL( |
|
2776 TUint32 aAttribute, |
|
2777 const TDesC16& aValue, |
|
2778 CCmClientPluginInstance* aClientPluginInstance ) |
|
2779 { |
|
2780 OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETSTRINGATTRIBUTEL_ENTRY ); |
|
2781 |
|
2782 switch ( aAttribute ) |
|
2783 { |
|
2784 case ECmStartPage: |
|
2785 { |
|
2786 CCDWAPAccessPointRecord* wapAPRecord = |
|
2787 static_cast<CCDWAPAccessPointRecord*>( |
|
2788 aClientPluginInstance->iGenRecordArray[KWAPAPRecordIndex] ); |
|
2789 |
|
2790 wapAPRecord->iWAPStartPage.SetL( aValue ); |
|
2791 } |
|
2792 break; |
|
2793 case ECmName: |
|
2794 { |
|
2795 CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>( |
|
2796 aClientPluginInstance->iGenRecordArray[KIapRecordIndex] ); |
|
2797 |
|
2798 SetNameL( aValue, iapRecord, aClientPluginInstance->iNamingMethod ); |
|
2799 } |
|
2800 break; |
|
2801 case ECmProxyServerName: |
|
2802 { |
|
2803 CCDProxiesRecord* proxyRecord = |
|
2804 static_cast<CCDProxiesRecord*>( |
|
2805 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ); |
|
2806 if ( !proxyRecord ) |
|
2807 { |
|
2808 proxyRecord = static_cast<CCDProxiesRecord *> |
|
2809 ( CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord ) ); |
|
2810 |
|
2811 // map proxy record to this iap. |
|
2812 proxyRecord->iService = |
|
2813 static_cast<CCDProxiesRecord*>( |
|
2814 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->RecordId(); |
|
2815 |
|
2816 aClientPluginInstance->iGenRecordArray.Insert( proxyRecord, KProxyRecordIndex ); |
|
2817 } |
|
2818 |
|
2819 SetProxyServerNameL( aValue, proxyRecord ); |
|
2820 } |
|
2821 break; |
|
2822 case ECmProxyProtocolName: |
|
2823 { |
|
2824 CCDProxiesRecord* proxyRecord = |
|
2825 static_cast<CCDProxiesRecord*>( |
|
2826 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ); |
|
2827 if ( !proxyRecord ) |
|
2828 { |
|
2829 proxyRecord = static_cast<CCDProxiesRecord *> |
|
2830 ( CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord ) ); |
|
2831 |
|
2832 // map proxy record to this iap. |
|
2833 proxyRecord->iService = |
|
2834 static_cast<CCDProxiesRecord*>( |
|
2835 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->RecordId(); |
|
2836 |
|
2837 aClientPluginInstance->iGenRecordArray.Insert( proxyRecord, KProxyRecordIndex ); |
|
2838 } |
|
2839 |
|
2840 proxyRecord->iProtocolName.SetL( aValue ); |
|
2841 } |
|
2842 break; |
|
2843 case ECmProxyExceptions: |
|
2844 { |
|
2845 CCDProxiesRecord* proxyRecord = |
|
2846 static_cast<CCDProxiesRecord*>( |
|
2847 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] ); |
|
2848 if ( !proxyRecord ) |
|
2849 { |
|
2850 proxyRecord = static_cast<CCDProxiesRecord *> |
|
2851 ( CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord ) ); |
|
2852 |
|
2853 // map proxy record to this iap. |
|
2854 proxyRecord->iService = |
|
2855 static_cast<CCDProxiesRecord*>( |
|
2856 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->RecordId(); |
|
2857 |
|
2858 aClientPluginInstance->iGenRecordArray.Insert( proxyRecord, KProxyRecordIndex ); |
|
2859 } |
|
2860 |
|
2861 proxyRecord->iExceptions.SetL( aValue ); |
|
2862 } |
|
2863 break; |
|
2864 case ECmWapIPGatewayAddress: |
|
2865 { |
|
2866 CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>( |
|
2867 aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] ); |
|
2868 |
|
2869 wapIPBearerRecord->iWAPGatewayAddress.SetL( aValue ); |
|
2870 } |
|
2871 break; |
|
2872 case ECmWapIPProxyLoginName: |
|
2873 { |
|
2874 CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>( |
|
2875 aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] ); |
|
2876 |
|
2877 wapIPBearerRecord->iWAPProxyLoginName.SetL( aValue ); |
|
2878 } |
|
2879 break; |
|
2880 case ECmWapIPProxyLoginPass: |
|
2881 { |
|
2882 CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>( |
|
2883 aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] ); |
|
2884 |
|
2885 wapIPBearerRecord->iWAPProxyLoginPass.SetL( aValue ); |
|
2886 } |
|
2887 break; |
|
2888 default: |
|
2889 { |
|
2890 SetBearerStringAttributeL( aAttribute, |
|
2891 aValue, |
|
2892 aClientPluginInstance->iGenRecordArray, |
|
2893 aClientPluginInstance->iBearerSpecRecordArray ); |
|
2894 } |
|
2895 } |
|
2896 OstTraceFunctionExit0( CCMPLUGINBASEENG_SETSTRINGATTRIBUTEL_EXIT ); |
|
2897 } |
|
2898 |
|
2899 //----------------------------------------------------------------------------- |
|
2900 // CCmPluginBaseEng::SetString8AttributeL |
|
2901 // ----------------------------------------------------------------------------- |
|
2902 EXPORT_C void CCmPluginBaseEng::SetString8AttributeL( |
|
2903 TUint32 aAttribute, |
|
2904 const TDesC8& aValue, |
|
2905 CCmClientPluginInstance* aClientPluginInstance ) |
|
2906 { |
|
2907 OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETSTRING8ATTRIBUTEL_ENTRY ); |
|
2908 |
|
2909 switch ( aAttribute ) |
|
2910 { |
|
2911 default: |
|
2912 { |
|
2913 SetBearerString8AttributeL( aAttribute, |
|
2914 aValue, |
|
2915 aClientPluginInstance->iGenRecordArray, |
|
2916 aClientPluginInstance->iBearerSpecRecordArray ); |
|
2917 } |
|
2918 } |
|
2919 OstTraceFunctionExit0( CCMPLUGINBASEENG_SETSTRING8ATTRIBUTEL_EXIT ); |
|
2920 } |
|
2921 |
|
2922 // --------------------------------------------------------------------------- |
|
2923 // CCmPluginBaseEng::IsUnspecifiedIPv4Address |
|
2924 // --------------------------------------------------------------------------- |
|
2925 // |
|
2926 TBool CCmPluginBaseEng::IsUnspecifiedIPv4Address( const TDesC& aIpv4Address ) |
|
2927 { |
|
2928 OstTraceFunctionEntry0( _ISUNSPECIFIEDIPV4ADDRESS_ENTRY ); |
|
2929 |
|
2930 if ( aIpv4Address.Length() == 0 || !aIpv4Address.CompareF( KUnspecifiedIPv4 ) ) |
|
2931 { |
|
2932 OstTraceFunctionExit0( _ISUNSPECIFIEDIPV4ADDRESS_EXIT ); |
|
2933 return ETrue; |
|
2934 } |
|
2935 |
|
2936 OstTraceFunctionExit0( DUP1__ISUNSPECIFIEDIPV4ADDRESS_EXIT ); |
|
2937 |
|
2938 return EFalse; |
|
2939 } |
|
2940 |
|
2941 // --------------------------------------------------------------------------- |
|
2942 // CCmPluginBaseEng::ClassifyIPv6Address |
|
2943 // --------------------------------------------------------------------------- |
|
2944 // |
|
2945 TIPv6Types CCmPluginBaseEng::ClassifyIPv6Address( const TDesC& aIpv6Address ) |
|
2946 { |
|
2947 OstTraceFunctionEntry0( _CLASSIFYIPV6ADDRESS_ENTRY ); |
|
2948 |
|
2949 if ( aIpv6Address.Length() == 0 || !aIpv6Address.CompareF( KDynamicIpv6Address ) ) |
|
2950 { |
|
2951 OstTraceFunctionExit0( _CLASSIFYIPV6ADDRESS_EXIT ); |
|
2952 |
|
2953 return EIPv6Unspecified; |
|
2954 } |
|
2955 else if ( !aIpv6Address.CompareF( KKnownIp6NameServer1 ) || |
|
2956 !aIpv6Address.CompareF( KKnownIp6NameServer2 ) ) |
|
2957 { |
|
2958 OstTraceFunctionExit0( DUP1__CLASSIFYIPV6ADDRESS_EXIT ); |
|
2959 |
|
2960 return EIPv6WellKnown; |
|
2961 } |
|
2962 |
|
2963 OstTraceFunctionExit0( DUP2__CLASSIFYIPV6ADDRESS_EXIT ); |
|
2964 |
|
2965 return EIPv6UserDefined; |
|
2966 } |
|
2967 |
|
2968 // End of file |