1 /* |
|
2 * Copyright (c) 2002-2009 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 the License "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: Specific class for NWE tests |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 // INCLUDE FILES |
|
22 #include "nwe.h" |
|
23 |
|
24 #include <e32svr.h> |
|
25 #include <stifparser.h> |
|
26 #include <stiftestinterface.h> |
|
27 #include <mmlist.h> |
|
28 |
|
29 // CONSTANTS |
|
30 const TPtrC BooleanFlag[] = |
|
31 { |
|
32 _L("EFalse"), |
|
33 _L("ETrue") |
|
34 }; |
|
35 |
|
36 const TPtrC NetworkMode[] = |
|
37 { |
|
38 _L("ENetworkModeUnknown"), |
|
39 _L("ENetworkModeUnregistered"), |
|
40 _L("ENetworkModeGsm"), |
|
41 _L("ENetworkModeAmps"), |
|
42 _L("ENetworkModeCdma95"), |
|
43 _L("ENetworkModeCdma2000"), |
|
44 _L("ENetworkModeWcdma") |
|
45 }; |
|
46 |
|
47 const TPtrC NetworkStatus[] = |
|
48 { |
|
49 _L("ENetworkStatusUnknown"), |
|
50 _L("ENetworkStatusAvailable"), |
|
51 _L("ENetworkStatusCurrent"), |
|
52 _L("ENetworkStatusForbidden") |
|
53 }; |
|
54 |
|
55 const TPtrC RegistrationStatus[] = |
|
56 { |
|
57 _L("ERegistrationUnknown"), |
|
58 _L("ENotRegisteredNoService"), |
|
59 _L("ENotRegisteredEmergencyOnly"), |
|
60 _L("ENotRegisteredSearching"), |
|
61 _L("ERegisteredBusy"), |
|
62 _L("ERegisteredOnHomeNetwork"), |
|
63 _L("ERegistrationDenied"), |
|
64 _L("ERegisteredRoaming") |
|
65 }; |
|
66 |
|
67 const TPtrC MobilePhoneSelectionMethod[] = |
|
68 { |
|
69 _L("ENetworkSelectionUnknown"), |
|
70 _L("ENetworkSelectionAutomatic"), |
|
71 _L("ENetworkSelectionManual"), |
|
72 _L("ENetworkSelectionHomeOnly") |
|
73 }; |
|
74 |
|
75 const TPtrC TMobilePhoneBandClass[] = |
|
76 { |
|
77 _L("ENetworkBandClassUnknown"), |
|
78 _L("ENetworkBandClassAOnly"), |
|
79 _L("ENetworkBandClassBOnly"), |
|
80 _L("ENetworkBandClassAPreferred"), |
|
81 _L("ENetworkBandClassBPreferred") |
|
82 }; |
|
83 |
|
84 const TPtrC TMobilePhoneOperation[] = |
|
85 { |
|
86 _L("ENetworkOperationUnknown"), |
|
87 _L("ENetworkOperationAnalogOnly"), |
|
88 _L("ENetworkOperationDigitalOnly"), |
|
89 _L("ENetworkOperationAnalogPreferred"), |
|
90 _L("ENetworkOperationDigitalPreferred") |
|
91 }; |
|
92 |
|
93 const TPtrC TMobileCallCipheringIndicator[] = |
|
94 { |
|
95 _L("ECipheringDisplayOff"), |
|
96 _L("ECipheringDisplayOn") |
|
97 }; |
|
98 |
|
99 const TPtrC TOperatorNameType[] = |
|
100 { |
|
101 _L("EOperatorNameNitzFull"), |
|
102 _L("EOperatorNameNitzShort"), |
|
103 _L("EOperatorNameProgrammableUcs2"), |
|
104 _L("EOperatorNameProgrammableLatin"), |
|
105 _L("EOperatorNameHardcodedUcs2"), |
|
106 _L("EOperatorNameHardcodedLatin"), |
|
107 _L("EOperatorNameCountryMcn"), |
|
108 _L("EOperatorNameMccMnc"), |
|
109 _L("EOperatorNameFlexiblePlmn"), |
|
110 _L("EOperatorNameHighestPriority") |
|
111 }; |
|
112 |
|
113 const TPtrC TMobilePhoneNetworkSecurity[] = |
|
114 { |
|
115 _L("ECipheringOff"), |
|
116 _L("ECipheringGSM"), |
|
117 _L("ECipheringWCDMA"), |
|
118 _L("ECipheringCDMA") |
|
119 }; |
|
120 |
|
121 _LIT8( KLine, "---------------------------------" ); |
|
122 |
|
123 |
|
124 // ============================ MEMBER FUNCTIONS =============================== |
|
125 |
|
126 // ----------------------------------------------------------------------------- |
|
127 // CNWE::Delete |
|
128 // Delete here all resources allocated and opened from test methods. |
|
129 // Called from destructor. |
|
130 // ----------------------------------------------------------------------------- |
|
131 // |
|
132 void CNWE::Delete() |
|
133 { |
|
134 _LIT8 (KDelete, "CNWE::Delete" ); |
|
135 iNWELog->Log((TDesC8)KDelete ); |
|
136 } |
|
137 |
|
138 // ----------------------------------------------------------------------------- |
|
139 // CNWE::RunMethodL |
|
140 // Run specified method. Contains also table of test mothods and their names. |
|
141 // ----------------------------------------------------------------------------- |
|
142 // |
|
143 TInt CNWE::RunMethodL( |
|
144 CStifItemParser& aItem ) |
|
145 { |
|
146 _LIT8( KLog, "CNWE: RunMethodL" ); |
|
147 iNWELog->Log( ( TDesC8 ) KLog ); |
|
148 |
|
149 static TStifFunctionInfo const KFunctions[] = |
|
150 { |
|
151 // Copy this line for every implemented function. |
|
152 // First string is the function name used in TestScripter script file. |
|
153 // Second is the actual implementation member function. |
|
154 ENTRY( "RunIscTestCase", CCore::RunIscTestCase ), |
|
155 ENTRY( "SyncIscTestCase", CCore::SyncIscTestCase ), |
|
156 ENTRY( "RunIscTestCaseStartNTSYAfterTestToolStart", |
|
157 CCore::RunIscTestCaseStartNTSYAfterTestToolStart), |
|
158 ENTRY( "SyncIscTestCaseStartNTSYAfterTestToolStart", |
|
159 CCore::SyncIscTestCaseStartNTSYAfterTestToolStart), |
|
160 ENTRY( "SetNetworkSelectionSetting", CNWE::SetNetworkSelectionSettingL ), |
|
161 ENTRY( "GetHomeNetwork", CNWE::GetHomeNetworkL ), |
|
162 ENTRY( "GetNetworkRegistrationStatus", CNWE::GetNetworkRegistrationStatusL ), |
|
163 ENTRY( "GetCipheringIndicatorStatus", CNWE::GetCipheringIndicatorStatusL ), |
|
164 ENTRY( "CustomGetCipheringInfo", CNWE::CustomGetCipheringInfoL ), |
|
165 ENTRY( "CustomNetWakeup", CNWE::CustomNetWakeupL ), |
|
166 ENTRY( "CustomGetOperatorName", CNWE::CustomGetOperatorNameL ), |
|
167 ENTRY( "CustomResetNetworkRegistrationStatus", CNWE::CustomResetNetworkRegistrationStatusL ), |
|
168 ENTRY( "CustomGetSystemNetworkModes", CNWE::CustomGetSystemNetworkModesL ), |
|
169 ENTRY( "CustomSetSystemNetworkMode", CNWE::CustomSetSystemNetworkModeL ), |
|
170 ENTRY( "CustomGetCurrentSystemNetworkModes", CNWE::CustomGetCurrentSystemNetworkModesL ), |
|
171 |
|
172 // not suppoted for S60 ver 3.2 |
|
173 #if ( NCP_COMMON_S60_VERSION_SUPPORT != S60_VERSION_32 ) |
|
174 ENTRY( "CustomSetBandSelection", CNWE::CustomSetBandSelectionL ), |
|
175 ENTRY( "CustomGetBandSelection", CNWE::CustomGetBandSelectionL ), |
|
176 #endif //NCP_COMMON_S60_VERSION_SUPPORT |
|
177 |
|
178 ENTRY( "ManualNetworkSearch", CNWE::ManualNetworkSearchL ), |
|
179 ENTRY( "ManualNetworkSearchCancel", CNWE::ManualNetworkSearchCancelL ), |
|
180 ENTRY( "ManualNetworkSelection", CNWE::ManualNetworkSelectionL ), |
|
181 ENTRY( "ManualNetworkSelectionCancel", CNWE::ManualNetworkSelectionCancelL ), |
|
182 ENTRY( "NotifyNetworkConnectionFailure", CNWE::NotifyNetworkConnectionFailure ), |
|
183 ENTRY( "GetNetworkInfo", CNWE::GetNetworkInfo ), |
|
184 ENTRY( "SetNetworkInfo", CNWE::SetNetworkInfo ), |
|
185 ENTRY( "WaitForCallStatusChange", CNWE::WaitForCallStatusChange ), |
|
186 ENTRY( "RunIscTestCaseIgnoreXMLsWhenRealCellmoInUseFlagIsDefined", |
|
187 CCore::RunIscTestCaseIgnoreXMLsWhenRealCellmoInUseFlagIsDefined ), |
|
188 ENTRY( "SyncIscTestCaseDoNotSyncIfRealCellmoInUseFlagIsDefined", |
|
189 CCore::SyncIscTestCaseDoNotSyncIfRealCellmoInUseFlagIsDefined ), |
|
190 ENTRY( "SetOperInfoAPAC", CCore::SetOperInfoAPAC ), |
|
191 ENTRY( "GetCellInfo", CNWE::GetCellInfo ), |
|
192 ENTRY( "NotifyNWRegStatusChangeCompareParameterSetting", |
|
193 CNWE::NotifyNWRegStatusChangeCompareParameterSettingL ), |
|
194 ENTRY( "NotifyNetworkSelectionSettingChangeCompareParameterSetting", |
|
195 CNWE::NotifyNetworkSelectionSettingChangeCompareParameterSettingL ), |
|
196 ENTRY( "NotifyCurrentNetworkChangeCompareParameterSetting", |
|
197 CNWE::NotifyCurrentNetworkChangeCompareParameterSettingL ), |
|
198 ENTRY( "SetShortAndLongOperName", CNWE::SetShortAndLongOperNameL ), |
|
199 ENTRY( "HandleSpecifiedRequests", CCore::HandleSpecifiedRequests), |
|
200 ENTRY( "InitializeIPCRequestTable", CCore::InitializeIPCRequestTable), |
|
201 ENTRY( "SetExpectedCompleteIPC", CCore::SetExpectedCompleteIPC), |
|
202 }; |
|
203 |
|
204 const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo ); |
|
205 |
|
206 return RunInternalL( KFunctions, count, aItem ); |
|
207 } |
|
208 |
|
209 // ----------------------------------------------------------------------------- |
|
210 // CNWE::SetNetworkSelectionSettingL |
|
211 // SetNetworkSelection method function. |
|
212 // ----------------------------------------------------------------------------- |
|
213 // |
|
214 TInt CNWE::SetNetworkSelectionSettingL( CStifItemParser& aItem ) |
|
215 { |
|
216 _LIT8(KSetNetworkSelectionSetting, "CNWE::SetNetworkSelectionSettingL"); |
|
217 iNWELog->Log((TDesC8)KSetNetworkSelectionSetting); |
|
218 |
|
219 TInt ret( KErrNotFound ); |
|
220 TBool selection = ETrue; |
|
221 TPtrC string; |
|
222 aItem.GetNextString( string ); |
|
223 |
|
224 // Set NetworkSelection |
|
225 if ( _L("Manual") == string ) |
|
226 { |
|
227 iNWELog->Log( _L("NetworkSelectionManual.") ); |
|
228 iNWSelSetting.iMethod = RMobilePhone::ENetworkSelectionManual; |
|
229 } |
|
230 else if ( _L("Automatic") == string ) |
|
231 { |
|
232 iNWELog->Log( _L("NetworkSelectionAutomatic.") ); |
|
233 iNWSelSetting.iMethod = RMobilePhone::ENetworkSelectionAutomatic; |
|
234 } |
|
235 else if ( _L("Unknown") == string ) |
|
236 { |
|
237 iNWELog->Log( _L("NetworkSelectionUnknown.") ); |
|
238 iNWSelSetting.iMethod = RMobilePhone::ENetworkSelectionUnknown; |
|
239 } |
|
240 else |
|
241 { |
|
242 iNWELog->Log( _L("Set NetworkSelection not possible: %d"), ret ); |
|
243 selection = EFalse; |
|
244 } |
|
245 |
|
246 if ( selection ) |
|
247 { |
|
248 CMmDataPackage dataPackage; |
|
249 dataPackage.PackData(&iNWSelSetting); |
|
250 |
|
251 ret = HandleRequestL( EMobilePhoneSetNetworkSelectionSetting, |
|
252 &dataPackage ); |
|
253 |
|
254 if ( !iHandleSpecifiedRequests ) |
|
255 { |
|
256 iSetNetworkSelectionSettingOngoing = ETrue; |
|
257 } |
|
258 |
|
259 if ( KErrNone == ret ) |
|
260 { |
|
261 _LIT8( KSendOk, "Set NetworkSelectionSetting request send ok" ); |
|
262 iNWELog->Log((TDesC8)KSendOk ); |
|
263 } |
|
264 else |
|
265 { |
|
266 _LIT8( KSendFailed, "Set NetworkSelectionSetting request send failed: %d" ); |
|
267 iNWELog->Log((TDesC8)KSendFailed, ret ); |
|
268 } |
|
269 } |
|
270 else |
|
271 { |
|
272 ret = KErrNotSupported; |
|
273 } |
|
274 |
|
275 return ret; |
|
276 } |
|
277 |
|
278 // ----------------------------------------------------------------------------- |
|
279 // CNWE::CompleteSetNetworkSelectionSetting |
|
280 // Complete SetNetworkSelection method function. |
|
281 // ----------------------------------------------------------------------------- |
|
282 // |
|
283 void CNWE::CompleteSetNetworkSelectionSetting( TInt aResult ) |
|
284 { |
|
285 _LIT8( KResult, "CNWE::CompleteSetNetworkSelectionSetting result: %d" ); |
|
286 iNWELog->Log((TDesC8)KResult, aResult ); |
|
287 |
|
288 if ( ( iSetNetworkSelectionSettingOngoing ) || |
|
289 ( iHandleSpecifiedRequests ) ) |
|
290 { |
|
291 iSetNetworkSelectionSettingOngoing = EFalse; |
|
292 _LIT8( KResultComplete, "SetNetworkSelectionSetting Completed" ); |
|
293 iNWELog->Log((TDesC8)KResultComplete ); |
|
294 |
|
295 Signal( aResult ); |
|
296 } |
|
297 } |
|
298 |
|
299 // ----------------------------------------------------------------------------- |
|
300 // CNWE::GetHomeNetworkL |
|
301 // GetHomeNetwork method function. |
|
302 // ----------------------------------------------------------------------------- |
|
303 // |
|
304 TInt CNWE::GetHomeNetworkL( CStifItemParser& aItem ) |
|
305 { |
|
306 _LIT8(KGetHomeNetwork, "CNWE::GetHomeNetworkL"); |
|
307 iNWELog->Log((TDesC8)KGetHomeNetwork); |
|
308 |
|
309 TInt ret( KErrNotFound ); |
|
310 TPtrC string; |
|
311 |
|
312 aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing ); |
|
313 |
|
314 iSavedDisplayTagForComparison[0].Zero(); |
|
315 aItem.GetNextString( string ); |
|
316 |
|
317 // Hard coded APAC name string: |
|
318 // - Operator name: CSL |
|
319 // - Unicode name: 0x8A0A, 0x806F, 0x96FB, 0x4FE1 |
|
320 // - MCC 454, MNC 18 |
|
321 if ( _L("APAC_NAME") == string ) |
|
322 { |
|
323 iSavedDisplayTagForComparison[0].Append( 0x8A0A ); |
|
324 iSavedDisplayTagForComparison[0].Append( 0x806F ); |
|
325 iSavedDisplayTagForComparison[0].Append( 0x96FB ); |
|
326 iSavedDisplayTagForComparison[0].Append( 0x4FE1 ); |
|
327 } |
|
328 else |
|
329 { |
|
330 iSavedDisplayTagForComparison[0].Append( string ); |
|
331 } |
|
332 |
|
333 aItem.GetNextString( string ); |
|
334 iSavedShortNameForComparison[0].Zero(); |
|
335 |
|
336 if ( _L("NO_SHORT_NAME") != string ) |
|
337 { |
|
338 iSavedShortNameForComparison[0].Append( string ); |
|
339 } |
|
340 |
|
341 aItem.GetNextString( string ); |
|
342 iSavedLongNameForComparison[0].Zero(); |
|
343 |
|
344 if ( _L("NO_LONG_NAME") != string ) |
|
345 { |
|
346 iSavedLongNameForComparison[0].Append( string ); |
|
347 } |
|
348 |
|
349 ret = HandleRequestL( EMobilePhoneGetHomeNetwork ); |
|
350 iGetHomeNetworkOngoing = ETrue; |
|
351 |
|
352 if ( KErrNone == ret ) |
|
353 { |
|
354 _LIT8( KOk, "GetHomeNetwork request send ok: %d" ); |
|
355 iNWELog->Log((TDesC8)KOk, ret ); |
|
356 } |
|
357 else |
|
358 { |
|
359 _LIT8( KFail, "GetHomeNetwork request send fails: %d" ); |
|
360 iNWELog->Log((TDesC8)KFail, ret ); |
|
361 } |
|
362 |
|
363 return ret; |
|
364 } |
|
365 |
|
366 // ----------------------------------------------------------------------------- |
|
367 // CNWE::CompleteGetHomeNetwork |
|
368 // Complete GetHomeNetwork method function. |
|
369 // ----------------------------------------------------------------------------- |
|
370 // |
|
371 void CNWE::CompleteGetHomeNetwork( |
|
372 TInt aResult, |
|
373 CMmDataPackage* aDataPackage ) |
|
374 { |
|
375 _LIT8( KResult, "CNWE::CompleteGetHomeNetwork result: %d" ); |
|
376 iNWELog->Log((TDesC8)KResult, aResult ); |
|
377 |
|
378 if ( KErrNone == aResult ) |
|
379 { |
|
380 aDataPackage->UnPackData( iNWInfo ); |
|
381 PrintCurrentNetworkInfo( iNWInfo ); |
|
382 } |
|
383 else |
|
384 { |
|
385 _LIT8( KFail, "CompleteGetHomeNetwork Failed: %d" ); |
|
386 iNWELog->Log((TDesC8)KFail, aResult ); |
|
387 } |
|
388 |
|
389 if ( ( 0 != iSavedDisplayTagForComparison[0].Compare( _L( "DONT_CARE_NETWORK_NAME" ) ) ) && |
|
390 ( KErrNone == aResult ) ) |
|
391 { |
|
392 if ( ( iSavedDisplayTagForComparison[0] != iNWInfo.iDisplayTag ) || |
|
393 ( iSavedShortNameForComparison[0] != iNWInfo.iShortName ) || |
|
394 ( iSavedLongNameForComparison[0] != iNWInfo.iLongName ) ) |
|
395 { |
|
396 _LIT8( KResultFail, "CompleteGetHomeNetwork - operator names do not match" ); |
|
397 aResult = KErrGeneral; |
|
398 } |
|
399 } |
|
400 |
|
401 if ( ( iGetHomeNetworkOngoing ) || |
|
402 ( iHandleSpecifiedRequests ) ) |
|
403 { |
|
404 iGetHomeNetworkOngoing = EFalse; |
|
405 _LIT8( KResultComplete, "GetHomeNetwork Completed" ); |
|
406 iNWELog->Log((TDesC8)KResultComplete ); |
|
407 |
|
408 Signal( aResult ); |
|
409 } |
|
410 } |
|
411 |
|
412 // ----------------------------------------------------------------------------- |
|
413 // CNWE::PrintCurrentNetworkInfo |
|
414 // Prints current network info |
|
415 // ----------------------------------------------------------------------------- |
|
416 // |
|
417 void CNWE::PrintCurrentNetworkInfo( |
|
418 RMobilePhone::TMobilePhoneNetworkInfoV5 aNetworkInfo ) |
|
419 { |
|
420 iNWELog->Log((TDesC8)KLine ); |
|
421 _LIT8( KText, "CURRENT NETWORK INFO" ); |
|
422 iNWELog->Log((TDesC8)KText ); |
|
423 _LIT8( KMode, "Mode: " ); |
|
424 iNWELog->Log((TDesC8)KMode ); |
|
425 iNWELog->Log( NetworkMode[aNetworkInfo.iMode] ); |
|
426 _LIT8( KStatus, "Status: " ); |
|
427 iNWELog->Log((TDesC8)KStatus ); |
|
428 iNWELog->Log( NetworkStatus[aNetworkInfo.iStatus] ); |
|
429 _LIT8( KCountry, "Country Code: " ); |
|
430 iNWELog->Log((TDesC8)KCountry ); |
|
431 iNWELog->Log( aNetworkInfo.iCountryCode ); |
|
432 _LIT8( KNetworkId, "NetworkId: " ); |
|
433 iNWELog->Log((TDesC8)KNetworkId ); |
|
434 iNWELog->Log( aNetworkInfo.iNetworkId ); |
|
435 _LIT8( KHsdpaCellIndicator, "HSDPA available in cell: " ); |
|
436 iNWELog->Log((TDesC8)KHsdpaCellIndicator ); |
|
437 iNWELog->Log( BooleanFlag[aNetworkInfo.iHsdpaAvailableIndicator] ); |
|
438 _LIT8( KDisplayTag, "DisplayTag: " ); |
|
439 iNWELog->Log((TDesC8)KDisplayTag ); |
|
440 iNWELog->Log( aNetworkInfo.iDisplayTag ); |
|
441 _LIT8( KShortName, "ShortName: " ); |
|
442 iNWELog->Log((TDesC8)KShortName ); |
|
443 iNWELog->Log( aNetworkInfo.iShortName ); |
|
444 _LIT8( KLongName, "LongName: " ); |
|
445 iNWELog->Log((TDesC8)KLongName ); |
|
446 iNWELog->Log( aNetworkInfo.iLongName ); |
|
447 iNWELog->Log((TDesC8)KLine ); |
|
448 } |
|
449 |
|
450 // ----------------------------------------------------------------------------- |
|
451 // CNWE::GetNetworkRegistrationStatusL |
|
452 // GetNetworkRegistrationStatus method function. |
|
453 // ----------------------------------------------------------------------------- |
|
454 // |
|
455 TInt CNWE::GetNetworkRegistrationStatusL( CStifItemParser& aItem ) |
|
456 { |
|
457 _LIT8(KGetNetworkRegistrationStatus, "CNWE::GetNetworkRegistrationStatusL" ); |
|
458 iNWELog->Log((TDesC8)KGetNetworkRegistrationStatus ); |
|
459 |
|
460 TInt ret( KErrNotFound ); |
|
461 iHSXPATestOngoing = EFalse; |
|
462 |
|
463 TPtrC string; |
|
464 |
|
465 aItem.GetNextString( string ); |
|
466 iSavedDisplayTagForComparison[0].Zero(); |
|
467 |
|
468 // Hard coded APAC name string: |
|
469 // - Operator name: CSL |
|
470 // - Unicode name: 0x8A0A, 0x806F, 0x96FB, 0x4FE1 |
|
471 // - MCC 454, MNC 18 |
|
472 if ( _L("APAC_NAME") == string ) |
|
473 { |
|
474 iSavedDisplayTagForComparison[0].Append( 0x8A0A ); |
|
475 iSavedDisplayTagForComparison[0].Append( 0x806F ); |
|
476 iSavedDisplayTagForComparison[0].Append( 0x96FB ); |
|
477 iSavedDisplayTagForComparison[0].Append( 0x4FE1 ); |
|
478 } |
|
479 else |
|
480 { |
|
481 iSavedDisplayTagForComparison[0].Append( string ); |
|
482 } |
|
483 |
|
484 aItem.GetNextString( string ); |
|
485 iSavedShortNameForComparison[0].Zero(); |
|
486 |
|
487 if ( _L("NO_SHORT_NAME") != string ) |
|
488 { |
|
489 iSavedShortNameForComparison[0].Append( string ); |
|
490 } |
|
491 |
|
492 aItem.GetNextString( string ); |
|
493 iSavedLongNameForComparison[0].Zero(); |
|
494 |
|
495 if ( _L("NO_LONG_NAME") != string ) |
|
496 { |
|
497 iSavedLongNameForComparison[0].Append( string ); |
|
498 } |
|
499 |
|
500 aItem.GetNextString( string ); |
|
501 |
|
502 if ( _L("HSXPATest") == string ) |
|
503 { |
|
504 iHSXPATestOngoing = ETrue; |
|
505 aItem.GetNextString( string ); |
|
506 if ( _L("HSUPA") == string || _L("HSDPA") == string || _L("HSDPAandHSUPA") == string ) |
|
507 { |
|
508 iSavedNetworkInfo.iHsdpaAvailableIndicator = ETrue; |
|
509 } |
|
510 else |
|
511 { |
|
512 iSavedNetworkInfo.iHsdpaAvailableIndicator = EFalse; |
|
513 } |
|
514 } |
|
515 |
|
516 ret = HandleRequestL( EMobilePhoneGetNetworkRegistrationStatus ); |
|
517 iGetNetworkRegistrationStatusOngoing = ETrue; |
|
518 |
|
519 if ( KErrNone == ret ) |
|
520 { |
|
521 _LIT8(KResultOk, "GetNetworkRegistrationStatus request send ok" ); |
|
522 iNWELog->Log((TDesC8)KResultOk); |
|
523 } |
|
524 else |
|
525 { |
|
526 _LIT8(KResultFail, "GetNetworkRegistrationStatus request send fails: %d" ); |
|
527 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
528 } |
|
529 |
|
530 return ret; |
|
531 } |
|
532 |
|
533 // ----------------------------------------------------------------------------- |
|
534 // CNWE::CompleteGetNetworkRegistrationStatus |
|
535 // Complete GetNetworkRegistrationStatus method function. |
|
536 // ----------------------------------------------------------------------------- |
|
537 // |
|
538 void CNWE::CompleteGetNetworkRegistrationStatus( TInt aResult ) |
|
539 { |
|
540 _LIT8(KResult, "CNWE::CompleteGetNetworkRegistrationStatus result: %d" ); |
|
541 iNWELog->Log((TDesC8)KResult, aResult ); |
|
542 |
|
543 if ( ( iGetNetworkRegistrationStatusOngoing ) || |
|
544 ( iHandleSpecifiedRequests ) ) |
|
545 { |
|
546 if ( iHandleSpecifiedRequests ) |
|
547 { |
|
548 if ( iHSXPATestOngoing ) |
|
549 { |
|
550 if ( ( iSavedNetworkInfo.iHsdpaAvailableIndicator != iNetworkInfo.iHsdpaAvailableIndicator ) && |
|
551 ( KErrNone == aResult ) ) |
|
552 { |
|
553 aResult = KErrGeneral; |
|
554 } |
|
555 } |
|
556 else |
|
557 { |
|
558 if ( ( iNWRegStatusForComparison != iRegistrationStatus ) && |
|
559 ( KErrNone == aResult ) ) |
|
560 { |
|
561 aResult = KErrGeneral; |
|
562 } |
|
563 } |
|
564 } |
|
565 |
|
566 iGetNetworkRegistrationStatusOngoing = EFalse; |
|
567 _LIT8( KResultComplete, "GetNetworkRegistrationStatus Completed" ); |
|
568 iNWELog->Log((TDesC8)KResultComplete ); |
|
569 |
|
570 Signal( aResult ); |
|
571 } |
|
572 } |
|
573 |
|
574 // ----------------------------------------------------------------------------- |
|
575 // CNWE::NotifyNWRegStatusChangeCompareParameterSettingL |
|
576 // NotifyNWRegStatusChangeCompareParameterSetting method function. |
|
577 // ----------------------------------------------------------------------------- |
|
578 // |
|
579 TInt CNWE::NotifyNWRegStatusChangeCompareParameterSettingL( |
|
580 CStifItemParser& aItem ) |
|
581 { |
|
582 _LIT8( KNotifyNWRegStatusChangeCompareParameterSettingL, |
|
583 "CNWE::NotifyNWRegStatusChangeCompareParameterSettingL"); |
|
584 iNWELog->Log((TDesC8)KNotifyNWRegStatusChangeCompareParameterSettingL); |
|
585 |
|
586 TPtrC string; |
|
587 |
|
588 iNWRegStatusForComparison = RMobilePhone::ERegistrationUnknown; |
|
589 iNetworkStatusForComparison = RMobilePhone::ENetworkStatusUnknown; |
|
590 |
|
591 aItem.GetNextString( string ); |
|
592 |
|
593 if ( _L("ERegisteredOnHomeNetwork") == string ) |
|
594 { |
|
595 iNWRegStatusForComparison = RMobilePhone::ERegisteredOnHomeNetwork; |
|
596 } |
|
597 else if ( _L("ERegistrationDenied") == string ) |
|
598 { |
|
599 iNWRegStatusForComparison = RMobilePhone::ERegistrationDenied; |
|
600 } |
|
601 else if ( _L("ERegisteredRoaming") == string ) |
|
602 { |
|
603 iNWRegStatusForComparison = RMobilePhone::ERegisteredRoaming; |
|
604 } |
|
605 |
|
606 aItem.GetNextString( string ); |
|
607 |
|
608 if ( _L("ENetworkStatusCurrent") == string ) |
|
609 { |
|
610 iNetworkStatusForComparison = RMobilePhone::ENetworkStatusCurrent; |
|
611 } |
|
612 |
|
613 aItem.GetNextString( string ); |
|
614 |
|
615 if ( _L("ALLOW_ALSO_NOK_RESULT_FROM_TSY") == string ) |
|
616 { |
|
617 iAllowAlsoNokStatusFromTSY = ETrue; |
|
618 } |
|
619 else |
|
620 { |
|
621 iAllowAlsoNokStatusFromTSY = EFalse; |
|
622 } |
|
623 |
|
624 return KErrNone; |
|
625 } |
|
626 |
|
627 // ----------------------------------------------------------------------------- |
|
628 // CNWE::NotifyNetworkRegistrationStatusChange |
|
629 // Notify Change of Network Registration Status |
|
630 // ----------------------------------------------------------------------------- |
|
631 // |
|
632 void CNWE::NotifyNetworkRegistrationStatusChange( |
|
633 TInt aResult, |
|
634 CMmDataPackage* aDataPackage ) |
|
635 { |
|
636 if ( ( iNotifyList[ENotifyNetworkRegistrationStatusChange] ) || |
|
637 ( iHandleSpecifiedRequests ) ) |
|
638 { |
|
639 _LIT8(KRegStatusChange, "CNWE::NotifyNetworkRegistrationStatusChange" ); |
|
640 iNWELog->Log((TDesC8)KRegStatusChange); |
|
641 |
|
642 if ( ( KErrNone == aResult ) || |
|
643 ( iAllowAlsoNokStatusFromTSY ) ) |
|
644 { |
|
645 aDataPackage->UnPackData( iRegistrationStatus, iNetworkStatus ); |
|
646 iNWELog->Log((TDesC8)KLine ); |
|
647 iNWELog->Log((TDesC8)KRegStatusChange); |
|
648 _LIT8(KRegStatus, "Registration Status: " ); |
|
649 iNWELog->Log((TDesC8)KRegStatus ); |
|
650 iNWELog->Log( RegistrationStatus[iRegistrationStatus] ); |
|
651 _LIT8(KNetWorkStatus, "Network Status: " ); |
|
652 iNWELog->Log((TDesC8)KNetWorkStatus ); |
|
653 iNWELog->Log( NetworkStatus[iNetworkStatus] ); |
|
654 iNWELog->Log((TDesC8)KLine ); |
|
655 } |
|
656 else |
|
657 { |
|
658 _LIT8(KFailed, "NotifyNetworkRegistrationStatusChange Failed" ); |
|
659 iNWELog->Log((TDesC8)KFailed); |
|
660 } |
|
661 } |
|
662 |
|
663 if ( iHandleSpecifiedRequests ) |
|
664 { |
|
665 if ( ( iNWRegStatusForComparison != iRegistrationStatus ) || |
|
666 ( iNetworkStatusForComparison != iNetworkStatus ) ) |
|
667 { |
|
668 aResult = KErrGeneral; |
|
669 } |
|
670 |
|
671 Signal( aResult ); |
|
672 } |
|
673 } |
|
674 |
|
675 // ----------------------------------------------------------------------------- |
|
676 // CNWE::NotifyNetworkSelectionSettingChangeCompareParameterSettingL |
|
677 // NotifyNetworkSelectionSettingChangeCompareParameterSetting method function. |
|
678 // ----------------------------------------------------------------------------- |
|
679 // |
|
680 TInt CNWE::NotifyNetworkSelectionSettingChangeCompareParameterSettingL( |
|
681 CStifItemParser& aItem ) |
|
682 { |
|
683 _LIT8( KNetworkRegistrationStatusChangeCompareParameterSetting, |
|
684 "CNWE::NotifyNetworkSelectionSettingChangeCompareParameterSettingL"); |
|
685 iNWELog->Log((TDesC8)KNetworkRegistrationStatusChangeCompareParameterSetting); |
|
686 |
|
687 TPtrC string; |
|
688 |
|
689 iNetworkSelectionForComparison.iMethod = RMobilePhone::ENetworkSelectionUnknown; |
|
690 iNetworkSelectionForComparison.iBandClass = RMobilePhone::ENetworkBandClassUnknown; |
|
691 iNetworkSelectionForComparison.iOperationMode = RMobilePhone::ENetworkOperationUnknown; |
|
692 |
|
693 aItem.GetNextString( string ); |
|
694 |
|
695 if ( _L("ENetworkSelectionAutomatic") == string ) |
|
696 { |
|
697 iNetworkSelectionForComparison.iMethod = |
|
698 RMobilePhone::ENetworkSelectionAutomatic; |
|
699 } |
|
700 else if ( _L("ENetworkSelectionUnknown") == string ) |
|
701 { |
|
702 iNetworkSelectionForComparison.iMethod = |
|
703 RMobilePhone::ENetworkSelectionUnknown; |
|
704 } |
|
705 else if ( _L("ENetworkSelectionManual") == string ) |
|
706 { |
|
707 iNetworkSelectionForComparison.iMethod = |
|
708 RMobilePhone::ENetworkSelectionManual; |
|
709 } |
|
710 |
|
711 aItem.GetNextString( string ); |
|
712 |
|
713 if ( _L("ENetworkBandClassUnknown") == string ) |
|
714 { |
|
715 iNetworkSelectionForComparison.iBandClass = |
|
716 RMobilePhone::ENetworkBandClassUnknown; |
|
717 } |
|
718 |
|
719 aItem.GetNextString( string ); |
|
720 |
|
721 if ( _L("ENetworkOperationUnknown") == string ) |
|
722 { |
|
723 iNetworkSelectionForComparison.iOperationMode = |
|
724 RMobilePhone::ENetworkOperationUnknown; |
|
725 } |
|
726 |
|
727 return KErrNone; |
|
728 } |
|
729 |
|
730 // ----------------------------------------------------------------------------- |
|
731 // CNWE::NotifyNetworkSelectionSettingChange |
|
732 // Notify Change of Network Selection Setting |
|
733 // ----------------------------------------------------------------------------- |
|
734 // |
|
735 void CNWE::NotifyNetworkSelectionSettingChange( |
|
736 TInt aResult, |
|
737 CMmDataPackage* aDataPackage ) |
|
738 { |
|
739 if ( ( iNotifyList[ENotifyNetworkSelectionSettingChange] ) || |
|
740 ( iHandleSpecifiedRequests ) ) |
|
741 { |
|
742 _LIT8(KNotifyNWSelSetChange, "CNWE::NotifyNetworkSelectionSettingChange" ); |
|
743 iNWELog->Log((TDesC8)KNotifyNWSelSetChange ); |
|
744 |
|
745 if ( ( KErrNone == aResult ) || |
|
746 ( iAllowAlsoNokStatusFromTSY ) ) |
|
747 { |
|
748 aDataPackage->UnPackData( iNetworkSelection ); |
|
749 |
|
750 iNWELog->Log((TDesC8)KLine ); |
|
751 _LIT8(KSelectionSettingChange, "NotifyNetworkSelectionSettingChange" ); |
|
752 iNWELog->Log((TDesC8)KSelectionSettingChange ); |
|
753 _LIT8(KMethod, "Selection Method: " ); |
|
754 iNWELog->Log((TDesC8)KMethod ); |
|
755 iNWELog->Log( MobilePhoneSelectionMethod[iNetworkSelection.iMethod] ); |
|
756 _LIT8(KBand, "Band Class: " ); |
|
757 iNWELog->Log((TDesC8)KBand ); |
|
758 iNWELog->Log( TMobilePhoneBandClass[iNetworkSelection.iBandClass] ); |
|
759 _LIT8(KOperation, "Operation: " ); |
|
760 iNWELog->Log((TDesC8)KOperation ); |
|
761 iNWELog->Log( TMobilePhoneOperation[iNetworkSelection.iOperationMode] ); |
|
762 iNWELog->Log((TDesC8)KLine ); |
|
763 } |
|
764 else |
|
765 { |
|
766 _LIT8(KFailed, "NotifyNetworkSelectionSettingChange Failed" ); |
|
767 iNWELog->Log((TDesC8)KFailed); |
|
768 } |
|
769 } |
|
770 |
|
771 if ( iHandleSpecifiedRequests ) |
|
772 { |
|
773 if ( ( iNetworkSelection.iMethod != iNetworkSelectionForComparison.iMethod ) || |
|
774 ( iNetworkSelection.iBandClass != iNetworkSelectionForComparison.iBandClass ) || |
|
775 ( iNetworkSelection.iOperationMode != iNetworkSelectionForComparison.iOperationMode ) ) |
|
776 { |
|
777 aResult = KErrGeneral; |
|
778 } |
|
779 |
|
780 Signal( aResult ); |
|
781 } |
|
782 } |
|
783 |
|
784 // ----------------------------------------------------------------------------- |
|
785 // CNWE::NotifyCurrentNetworkChangeCompareParameterSettingL |
|
786 // NotifyCurrentNetworkChangeCompareParameterSetting method function. |
|
787 // ----------------------------------------------------------------------------- |
|
788 // |
|
789 TInt CNWE::NotifyCurrentNetworkChangeCompareParameterSettingL( |
|
790 CStifItemParser& aItem ) |
|
791 { |
|
792 _LIT8(KNotifyCurrentNetworkChangeCompareParameterSetting, |
|
793 "CNWE::NotifyCurrentNetworkChangeCompareParameterSettingL"); |
|
794 iNWELog->Log((TDesC8)KNotifyCurrentNetworkChangeCompareParameterSetting); |
|
795 |
|
796 aItem.GetNextInt( iLocationAreaForComparison.iAreaKnown ); |
|
797 aItem.GetNextInt( iLocationAreaForComparison.iLocationAreaCode ); |
|
798 aItem.GetNextInt( iLocationAreaForComparison.iCellId ); |
|
799 |
|
800 TPtrC string; |
|
801 aItem.GetNextString( string ); |
|
802 |
|
803 if ( _L("DONT_CARE_NETWORK_NAME") == string ) |
|
804 { |
|
805 iSavedDisplayTagForComparison[0].Zero(); |
|
806 iSavedDisplayTagForComparison[0].Append( string ); |
|
807 iSavedShortNameForComparison[0].Zero(); |
|
808 iSavedShortNameForComparison[0].Append( string ); |
|
809 iSavedLongNameForComparison[0].Zero(); |
|
810 iSavedLongNameForComparison[0].Append( string ); |
|
811 } |
|
812 |
|
813 return KErrNone; |
|
814 } |
|
815 |
|
816 // ----------------------------------------------------------------------------- |
|
817 // CNWE::NotifyCurrentNetworkChange |
|
818 // NotifyChange of Current Network |
|
819 // ----------------------------------------------------------------------------- |
|
820 // |
|
821 void CNWE::NotifyCurrentNetworkChange( |
|
822 TInt aResult, |
|
823 CMmDataPackage* aDataPackage ) |
|
824 { |
|
825 |
|
826 if ( ( iNotifyList[ENotifyCurrentNetworkChange] ) || |
|
827 ( iHandleSpecifiedRequests ) ) |
|
828 { |
|
829 _LIT8(KNotifyCurrentNetworkChange, "CNWE::NotifyCurrentNetworkChange" ); |
|
830 iNWELog->Log((TDesC8)KNotifyCurrentNetworkChange ); |
|
831 |
|
832 if ( KErrNone == aResult ) |
|
833 { |
|
834 aDataPackage->UnPackData( iNetworkInfo, iLocationArea ); |
|
835 |
|
836 PrintCurrentNetworkInfo( iNetworkInfo ); |
|
837 |
|
838 iNWELog->Log((TDesC8)KLine ); |
|
839 _LIT8(KLocationArea, "LOCATION AREA INFO" ); |
|
840 iNWELog->Log((TDesC8)KLocationArea); |
|
841 _LIT8(KAreaKnown, "Area Known:" ); |
|
842 iNWELog->Log((TDesC8)KAreaKnown ); |
|
843 iNWELog->Log( BooleanFlag[iLocationArea.iAreaKnown] ); |
|
844 _LIT8(KLocationAreaCode, "Location Area Code: %d" ); |
|
845 iNWELog->Log((TDesC8)KLocationAreaCode, iLocationArea.iLocationAreaCode ); |
|
846 _LIT8(KCellId, "Cell Id: %d" ); |
|
847 iNWELog->Log((TDesC8)KCellId, iLocationArea.iCellId); |
|
848 iNWELog->Log((TDesC8)KLine ); |
|
849 } |
|
850 else |
|
851 { |
|
852 _LIT8(Fail, "NotifyCurrentNetworkChange Failed" ); |
|
853 iNWELog->Log((TDesC8)Fail); |
|
854 } |
|
855 } |
|
856 |
|
857 if ( ( 0 != iSavedDisplayTagForComparison[0].Compare( _L( "DONT_CARE_NETWORK_NAME" ) ) ) && |
|
858 ( KErrNone == aResult ) ) |
|
859 { |
|
860 if ( ( iSavedDisplayTagForComparison[0] != iNetworkInfo.iDisplayTag ) || |
|
861 ( iSavedShortNameForComparison[0] != iNetworkInfo.iShortName ) || |
|
862 ( iSavedLongNameForComparison[0] != iNetworkInfo.iLongName ) ) |
|
863 { |
|
864 _LIT8( KResultFail, "NotifyCurrentNetworkChange - operator names do not match" ); |
|
865 iNWELog->Log((TDesC8)KResultFail); |
|
866 aResult = KErrGeneral; |
|
867 } |
|
868 } |
|
869 |
|
870 if ( iHandleSpecifiedRequests ) |
|
871 { |
|
872 if ( ( iLocationArea.iAreaKnown != iLocationAreaForComparison.iAreaKnown ) || |
|
873 ( iLocationArea.iLocationAreaCode != iLocationAreaForComparison.iLocationAreaCode ) || |
|
874 ( iLocationArea.iCellId != iLocationAreaForComparison.iCellId ) ) |
|
875 { |
|
876 aResult = KErrGeneral; |
|
877 } |
|
878 |
|
879 Signal( aResult ); |
|
880 } |
|
881 |
|
882 if ( iNetworkModeTestOnGoing ) |
|
883 { |
|
884 SetNetworkInfo( aResult, aDataPackage, EMobilePhoneNotifyCurrentNetworkChange ); |
|
885 } |
|
886 } |
|
887 |
|
888 // ----------------------------------------------------------------------------- |
|
889 // CNWE::NotifyModeChange |
|
890 // Notify Change of Mode |
|
891 // ----------------------------------------------------------------------------- |
|
892 // |
|
893 void CNWE::NotifyModeChange( |
|
894 TInt aResult, |
|
895 CMmDataPackage* aDataPackage ) |
|
896 { |
|
897 if ( ( iNotifyList[ENotifyModeChange] ) || |
|
898 ( iHandleSpecifiedRequests ) ) |
|
899 { |
|
900 _LIT8(KNotifyModeChange, "CNWE::NotifyModeChange" ); |
|
901 iNWELog->Log((TDesC8)KNotifyModeChange ); |
|
902 |
|
903 if ( KErrNone == aResult ) |
|
904 { |
|
905 aDataPackage->UnPackData( iNetworkMode ); |
|
906 |
|
907 iNWELog->Log((TDesC8)KLine ); |
|
908 _LIT8(KText, "ModeChange" ); |
|
909 iNWELog->Log((TDesC8)KText); |
|
910 _LIT8(KMode, "Mode: " ); |
|
911 iNWELog->Log((TDesC8)KMode ); |
|
912 iNWELog->Log( NetworkMode[iNetworkMode] ); |
|
913 iNWELog->Log((TDesC8)KLine ); |
|
914 } |
|
915 else |
|
916 { |
|
917 _LIT8(KFail, "NotifyModeChange Failed" ); |
|
918 iNWELog->Log((TDesC8)KFail); |
|
919 } |
|
920 } |
|
921 |
|
922 if ( iHandleSpecifiedRequests ) |
|
923 { |
|
924 if ( iNetworkModeStatus[0] != iNetworkMode ) |
|
925 { |
|
926 aResult = KErrGeneral; |
|
927 } |
|
928 |
|
929 Signal( aResult ); |
|
930 } |
|
931 } |
|
932 |
|
933 // ----------------------------------------------------------------------------- |
|
934 // CNWE::GetCipheringIndicatorStatusL |
|
935 // GetCipheringIndicatorStatus method function. |
|
936 // ----------------------------------------------------------------------------- |
|
937 // |
|
938 TInt CNWE::GetCipheringIndicatorStatusL( CStifItemParser& aItem ) |
|
939 { |
|
940 _LIT8(KGetCipheringIndicatorStatus, "CNWE::GetCipheringIndicatorStatusL" ); |
|
941 iNWELog->Log((TDesC8)KGetCipheringIndicatorStatus ); |
|
942 |
|
943 TInt ret( KErrNotFound ); |
|
944 TPtrC string; |
|
945 |
|
946 aItem.GetNextString( string ); |
|
947 |
|
948 if ( _L("SIM_SERV_CIPHERING_INDICATOR_DISPLAY_REQUIRED") == string ) |
|
949 { |
|
950 iCipherIndicatorStatusForComparison = RMobilePhone::ECipheringDisplayOn; |
|
951 } |
|
952 else |
|
953 { |
|
954 iCipherIndicatorStatusForComparison = RMobilePhone::ECipheringDisplayOff; |
|
955 } |
|
956 |
|
957 aItem.GetNextString( string ); |
|
958 |
|
959 if ( _L("SET_ONLY_COMPARISON_VALUE") == string ) |
|
960 { |
|
961 // Do nothing, but set ret value, because iCipherIndicatorStatusForComparison |
|
962 // is set for comparison when EMobilePhoneGetCipheringIndicatorStatus has been |
|
963 // received after sequence: |
|
964 // NET_CIPHERING_IND received (cmmnetmesshandler and cmmcustommesshandler |
|
965 // SIM_READ_CI_REQ is sent from cmmcustommesshandler |
|
966 // SIM_READ_CI_RESP has been received and that response causes complete |
|
967 // with IPC EMobilePhoneGetCipheringIndicatorStatus |
|
968 ret = KErrNone; |
|
969 } |
|
970 else |
|
971 { |
|
972 ret = HandleRequestL( EMobilePhoneGetCipheringIndicatorStatus ); |
|
973 iGetCipheringIndicatorStatusOngoing = ETrue; |
|
974 |
|
975 if ( KErrNone == ret ) |
|
976 { |
|
977 _LIT8( KResultOk, "GetCipheringIndicatorStatus request send ok" ); |
|
978 iNWELog->Log((TDesC8)KResultOk); |
|
979 } |
|
980 else |
|
981 { |
|
982 _LIT8( KResultFail, "GetCipheringIndicatorStatus request send fails: %d" ); |
|
983 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
984 } |
|
985 } |
|
986 |
|
987 return ret; |
|
988 } |
|
989 |
|
990 // ----------------------------------------------------------------------------- |
|
991 // CNWE::CompleteGetCipheringIndicatorStatus |
|
992 // Complete GetCipheringIndicatorStatus method function. |
|
993 // ----------------------------------------------------------------------------- |
|
994 // |
|
995 void CNWE::CompleteGetCipheringIndicatorStatus |
|
996 ( |
|
997 TInt aResult, // Completion result value |
|
998 CMmDataPackage* aDataPackage // pointer to DataPackage |
|
999 ) |
|
1000 { |
|
1001 // checking results and unpacking message |
|
1002 _LIT8( KResult, "CNWE::CompleteGetCipheringIndicatorStatus result: %d" ); |
|
1003 iNWELog->Log((TDesC8)KResult, aResult ); |
|
1004 |
|
1005 if ( KErrNone == aResult ) |
|
1006 { |
|
1007 aDataPackage->UnPackData( &iCipherIndicatorStatus ); |
|
1008 |
|
1009 iNWELog->Log((TDesC8)KLine ); |
|
1010 _LIT8( KCipIndStatus, "Ciphering Indicator Status: " ); |
|
1011 iNWELog->Log((TDesC8)KCipIndStatus ); |
|
1012 iNWELog->Log( TMobileCallCipheringIndicator[*iCipherIndicatorStatus] ); |
|
1013 iNWELog->Log((TDesC8)KLine ); |
|
1014 } |
|
1015 else |
|
1016 { |
|
1017 _LIT8( KResultFail, "CompleteGetCipheringIndicatorStatus Failed: %d" ); |
|
1018 iNWELog->Log((TDesC8)KResultFail, aResult ); |
|
1019 } |
|
1020 |
|
1021 if ( ( iGetCipheringIndicatorStatusOngoing ) || |
|
1022 ( iHandleSpecifiedRequests ) ) |
|
1023 { |
|
1024 iGetCipheringIndicatorStatusOngoing = EFalse; |
|
1025 |
|
1026 _LIT8( KResultComplete, "GetCipheringIndicatorStatus Completed" ); |
|
1027 iNWELog->Log((TDesC8)KResultComplete ); |
|
1028 |
|
1029 if ( ( iCipherIndicatorStatusForComparison != *iCipherIndicatorStatus ) && |
|
1030 ( KErrNone == aResult ) && |
|
1031 ( iHandleSpecifiedRequests ) ) |
|
1032 { |
|
1033 aResult = KErrGeneral; |
|
1034 } |
|
1035 |
|
1036 Signal( aResult ); |
|
1037 } |
|
1038 } |
|
1039 |
|
1040 // ----------------------------------------------------------------------------- |
|
1041 // CNWE::CustomGetCipheringInfoL |
|
1042 // CustomGetCipheringInfo method function. |
|
1043 // ----------------------------------------------------------------------------- |
|
1044 // |
|
1045 TInt CNWE::CustomGetCipheringInfoL( CStifItemParser& aItem ) |
|
1046 { |
|
1047 _LIT8(KCustomGetCipheringInfo, "CNWE::CustomGetCipheringInfoL" ); |
|
1048 iNWELog->Log((TDesC8)KCustomGetCipheringInfo ); |
|
1049 |
|
1050 TInt ret( KErrNotFound ); |
|
1051 TPtrC string; |
|
1052 |
|
1053 aItem.GetNextString( string ); |
|
1054 |
|
1055 if ( _L("SIM_SERV_CIPHERING_INDICATOR_DISPLAY_REQUIRED") == string ) |
|
1056 { |
|
1057 iCipherIndicatorOnOff = ETrue; |
|
1058 iCipherIndicatorStatusForComparison = RMobilePhone::ECipheringDisplayOn; |
|
1059 } |
|
1060 |
|
1061 ret = HandleRequestL( ECustomGetCipheringInfoIPC ); |
|
1062 iCustomGetCipheringInfoOngoing = ETrue; |
|
1063 |
|
1064 if ( KErrNone == ret ) |
|
1065 { |
|
1066 _LIT8( KResultOk, "CustomGetCipheringInfo request send ok" ); |
|
1067 iNWELog->Log((TDesC8)KResultOk); |
|
1068 } |
|
1069 else |
|
1070 { |
|
1071 _LIT8( KResultFail, "CustomGetCipheringInfo request send fails: %d" ); |
|
1072 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
1073 } |
|
1074 |
|
1075 return ret; |
|
1076 } |
|
1077 |
|
1078 // ----------------------------------------------------------------------------- |
|
1079 // CNWE::CompleteCustomGetCipheringInfo |
|
1080 // Complete CustomGetCipheringInfo method function. |
|
1081 // ----------------------------------------------------------------------------- |
|
1082 // |
|
1083 void CNWE::CompleteCustomGetCipheringInfo |
|
1084 ( |
|
1085 TInt aResult, // Completion result value |
|
1086 CMmDataPackage* aDataPackage // pointer to DataPackage |
|
1087 ) |
|
1088 { |
|
1089 // checking results and unpacking message |
|
1090 _LIT8( KResult, "CNWE::CompleteCustomGetCipheringInfo result: %d" ); |
|
1091 iNWELog->Log((TDesC8)KResult, aResult ); |
|
1092 |
|
1093 TBool cipherInfo(EFalse); |
|
1094 |
|
1095 if ( KErrNone == aResult ) |
|
1096 { |
|
1097 aDataPackage->UnPackData( cipherInfo ); |
|
1098 |
|
1099 iNWELog->Log((TDesC8)KLine ); |
|
1100 _LIT8( KCipInfo, "Status of the Ciphering indication: %d" ); |
|
1101 iNWELog->Log((TDesC8)KCipInfo, ( TInt ) cipherInfo ); |
|
1102 iNWELog->Log((TDesC8)KLine ); |
|
1103 } |
|
1104 else |
|
1105 { |
|
1106 _LIT8( KResultFail, "CompleteCustomGetCipheringInfo Failed: %d" ); |
|
1107 iNWELog->Log((TDesC8)KResultFail, aResult ); |
|
1108 } |
|
1109 |
|
1110 if ( ( iCustomGetCipheringInfoOngoing ) || |
|
1111 ( iHandleSpecifiedRequests ) ) |
|
1112 { |
|
1113 iCustomGetCipheringInfoOngoing = EFalse; |
|
1114 _LIT8( KResultComplete, "CustomGetCipheringInfo Completed" ); |
|
1115 iNWELog->Log((TDesC8)KResultComplete ); |
|
1116 |
|
1117 if ( ( iCipherIndicatorOnOff != cipherInfo ) && |
|
1118 ( KErrNone == aResult ) && |
|
1119 ( iHandleSpecifiedRequests ) ) |
|
1120 { |
|
1121 aResult = KErrGeneral; |
|
1122 } |
|
1123 |
|
1124 Signal( aResult ); |
|
1125 } |
|
1126 } |
|
1127 |
|
1128 // ----------------------------------------------------------------------------- |
|
1129 // CNWE::CustomNetWakeupL |
|
1130 // CustomNetWakeup method function. |
|
1131 // ----------------------------------------------------------------------------- |
|
1132 // |
|
1133 TInt CNWE::CustomNetWakeupL( CStifItemParser& /*aItem*/ ) |
|
1134 { |
|
1135 _LIT8(KCustomNetWakeup, "CNWE::CustomNetWakeupL" ); |
|
1136 iNWELog->Log((TDesC8)KCustomNetWakeup ); |
|
1137 |
|
1138 TInt ret( KErrNotFound ); |
|
1139 |
|
1140 ret = HandleRequestL( ECustomNetWakeupIPC ); |
|
1141 iCustomNetWakeupOngoing = ETrue; |
|
1142 |
|
1143 if ( KErrNone == ret ) |
|
1144 { |
|
1145 _LIT8( KResultOk, "CustomNetWakeup request send ok" ); |
|
1146 iNWELog->Log((TDesC8)KResultOk); |
|
1147 } |
|
1148 else |
|
1149 { |
|
1150 _LIT8( KResultFail, "CustomNetWakeup request send fails: %d" ); |
|
1151 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
1152 } |
|
1153 |
|
1154 return ret; |
|
1155 } |
|
1156 |
|
1157 // ----------------------------------------------------------------------------- |
|
1158 // CNWE::CompleteCustomNetWakeup |
|
1159 // Complete CustomNetWakeup method function. |
|
1160 // ----------------------------------------------------------------------------- |
|
1161 // |
|
1162 void CNWE::CompleteCustomNetWakeup |
|
1163 ( |
|
1164 TInt aResult // Completion result value |
|
1165 ) |
|
1166 { |
|
1167 _LIT8( KResult, "CNWE::CompleteCustomNetWakeup result: %d" ); |
|
1168 iNWELog->Log((TDesC8)KResult, aResult ); |
|
1169 |
|
1170 if ( ( iCustomNetWakeupOngoing ) || |
|
1171 ( iHandleSpecifiedRequests ) ) |
|
1172 { |
|
1173 iCustomNetWakeupOngoing = EFalse; |
|
1174 _LIT8( KResultComplete, "CustomNetWakeup Completed" ); |
|
1175 iNWELog->Log((TDesC8)KResultComplete ); |
|
1176 |
|
1177 Signal( aResult ); |
|
1178 } |
|
1179 } |
|
1180 |
|
1181 // ----------------------------------------------------------------------------- |
|
1182 // CNWE::CustomGetOperatorNameL |
|
1183 // CustomGetOperatorName method function. |
|
1184 // ----------------------------------------------------------------------------- |
|
1185 // |
|
1186 TInt CNWE::CustomGetOperatorNameL( CStifItemParser& aItem ) |
|
1187 { |
|
1188 _LIT8(KCustomGetOperatorName, "CNWE::CustomGetOperatorNameL" ); |
|
1189 iNWELog->Log((TDesC8)KCustomGetOperatorName ); |
|
1190 |
|
1191 TPtrC string; |
|
1192 |
|
1193 aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing ); |
|
1194 |
|
1195 aItem.GetNextString( string ); |
|
1196 iSavedDisplayTagForComparison[0].Zero(); |
|
1197 |
|
1198 // Hard coded APAC name string: |
|
1199 // - Operator name: CSL |
|
1200 // - Unicode name: 0x8A0A, 0x806F, 0x96FB, 0x4FE1 |
|
1201 // - MCC 454, MNC 18 |
|
1202 if ( _L("APAC_NAME") == string ) |
|
1203 { |
|
1204 iSavedDisplayTagForComparison[0].Append( 0x8A0A ); |
|
1205 iSavedDisplayTagForComparison[0].Append( 0x806F ); |
|
1206 iSavedDisplayTagForComparison[0].Append( 0x96FB ); |
|
1207 iSavedDisplayTagForComparison[0].Append( 0x4FE1 ); |
|
1208 } |
|
1209 else |
|
1210 { |
|
1211 iSavedDisplayTagForComparison[0].Append( string ); |
|
1212 } |
|
1213 |
|
1214 aItem.GetNextString( string ); |
|
1215 iSavedShortNameForComparison[0].Zero(); |
|
1216 |
|
1217 if ( _L("NO_SHORT_NAME") != string ) |
|
1218 { |
|
1219 iSavedShortNameForComparison[0].Append( string ); |
|
1220 } |
|
1221 |
|
1222 aItem.GetNextString( string ); |
|
1223 iSavedLongNameForComparison[0].Zero(); |
|
1224 |
|
1225 if ( _L("NO_LONG_NAME") != string ) |
|
1226 { |
|
1227 iSavedLongNameForComparison[0].Append( string ); |
|
1228 } |
|
1229 |
|
1230 aItem.GetNextString( string ); |
|
1231 iSavedOperNameForComparison.Zero(); |
|
1232 |
|
1233 // Hard coded APAC name string: |
|
1234 // - Operator name: CSL |
|
1235 // - Unicode name: 0x8A0A, 0x806F, 0x96FB, 0x4FE1 |
|
1236 // - MCC 454, MNC 18 |
|
1237 if ( _L("APAC_NAME") == string ) |
|
1238 { |
|
1239 iSavedOperNameForComparison.Append( 0x8A0A ); |
|
1240 iSavedOperNameForComparison.Append( 0x806F ); |
|
1241 iSavedOperNameForComparison.Append( 0x96FB ); |
|
1242 iSavedOperNameForComparison.Append( 0x4FE1 ); |
|
1243 } |
|
1244 else |
|
1245 { |
|
1246 iSavedOperNameForComparison.Append( string ); |
|
1247 } |
|
1248 |
|
1249 aItem.GetNextString( string ); |
|
1250 iSavedOperNameTypeForComparison.Zero(); |
|
1251 iSavedOperNameTypeForComparison.Append( string ); |
|
1252 |
|
1253 TInt ret( KErrNotFound ); |
|
1254 |
|
1255 aItem.GetNextString( string ); |
|
1256 |
|
1257 if ( _L("SET_ONLY_COMPARISON_VALUE") == string ) |
|
1258 { |
|
1259 // Set only expected values for comparison |
|
1260 ret = KErrNone; |
|
1261 } |
|
1262 else |
|
1263 { |
|
1264 ret = HandleRequestL( ECustomGetOperatorNameIPC ); |
|
1265 iCustomGetOperatorNameOngoing = ETrue; |
|
1266 |
|
1267 if ( KErrNone == ret ) |
|
1268 { |
|
1269 _LIT8( KResultOk, "CustomGetOperatorName request send ok" ); |
|
1270 iNWELog->Log((TDesC8)KResultOk); |
|
1271 } |
|
1272 else |
|
1273 { |
|
1274 _LIT8( KResultFail, "CustomGetOperatorName request send fails: %d" ); |
|
1275 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
1276 } |
|
1277 } |
|
1278 |
|
1279 return ret; |
|
1280 } |
|
1281 |
|
1282 // ----------------------------------------------------------------------------- |
|
1283 // CNWE::CompleteCustomGetOperatorName |
|
1284 // Complete CustomGetOperatorName method function. |
|
1285 // ----------------------------------------------------------------------------- |
|
1286 // |
|
1287 void CNWE::CompleteCustomGetOperatorName |
|
1288 ( |
|
1289 TInt aResult, // Completion result value |
|
1290 CMmDataPackage* aDataPackage // pointer to DataPackage |
|
1291 ) |
|
1292 { |
|
1293 // checking results and unpacking message |
|
1294 _LIT8( KResult, "CNWE::CompleteCustomGetOperatorName result: %d" ); |
|
1295 iNWELog->Log((TDesC8)KResult, aResult ); |
|
1296 |
|
1297 RMmCustomAPI::TOperatorNameType operNameType; |
|
1298 |
|
1299 if ( KErrNone == aResult ) |
|
1300 { |
|
1301 aDataPackage->UnPackData( iOperatorName ); |
|
1302 |
|
1303 iNWELog->Log((TDesC8)KLine ); |
|
1304 _LIT8( KOperatorNameType, "Operator name type: " ); |
|
1305 iNWELog->Log((TDesC8)KOperatorNameType ); |
|
1306 iNWELog->Log( TOperatorNameType[iOperatorName.iType] ); |
|
1307 _LIT8( KOperatorName, "Operator name: " ); |
|
1308 iNWELog->Log((TDesC8)KOperatorName ); |
|
1309 iNWELog->Log( iOperatorName.iName ); |
|
1310 iNWELog->Log((TDesC8)KLine ); |
|
1311 } |
|
1312 else |
|
1313 { |
|
1314 _LIT8( KResultFail, "CompleteCustomGetOperatorName Failed: %d" ); |
|
1315 iNWELog->Log((TDesC8)KResultFail, aResult ); |
|
1316 } |
|
1317 |
|
1318 if ( ( 0 != iSavedOperNameForComparison.Compare( _L( "DONT_CARE_NETWORK_NAME" ) ) ) && |
|
1319 ( KErrNone == aResult ) ) |
|
1320 { |
|
1321 if ( iSavedOperNameForComparison != iOperatorName.iName ) |
|
1322 { |
|
1323 aResult = KErrGeneral; |
|
1324 _LIT8( KResultFail, "CompleteCustomGetOperatorName - operator names do not match" ); |
|
1325 iNWELog->Log((TDesC8)KResultFail, aResult ); |
|
1326 } |
|
1327 |
|
1328 if ( 0 == iSavedOperNameTypeForComparison.Compare( _L( "EOperatorNameHardcodedLatin" ) ) ) |
|
1329 { |
|
1330 operNameType = RMmCustomAPI::EOperatorNameHardcodedLatin; |
|
1331 } |
|
1332 else if ( 0 == iSavedOperNameTypeForComparison.Compare( _L( "EOperatorNameHardcodedUcs2" ) ) ) |
|
1333 { |
|
1334 operNameType = RMmCustomAPI::EOperatorNameHardcodedUcs2; |
|
1335 } |
|
1336 else if ( 0 == iSavedOperNameTypeForComparison.Compare( _L( "EOperatorNameNitzFull" ) ) ) |
|
1337 { |
|
1338 operNameType = RMmCustomAPI::EOperatorNameNitzFull; |
|
1339 } |
|
1340 else if ( 0 == iSavedOperNameTypeForComparison.Compare( _L( "EOperatorNameNitzShort" ) ) ) |
|
1341 { |
|
1342 operNameType = RMmCustomAPI::EOperatorNameNitzShort; |
|
1343 } |
|
1344 else if ( 0 == iSavedOperNameTypeForComparison.Compare( _L( "EOperatorNameFlexiblePlmn" ) ) ) |
|
1345 { |
|
1346 operNameType = RMmCustomAPI::EOperatorNameFlexiblePlmn; |
|
1347 } |
|
1348 else if ( 0 == iSavedOperNameTypeForComparison.Compare( _L( "EOperatorNameCountryMcn" ) ) ) |
|
1349 { |
|
1350 operNameType = RMmCustomAPI::EOperatorNameCountryMcn; |
|
1351 } |
|
1352 else if ( 0 == iSavedOperNameTypeForComparison.Compare( _L( "EOperatorNameMccMnc" ) ) ) |
|
1353 { |
|
1354 operNameType = RMmCustomAPI::EOperatorNameMccMnc; |
|
1355 } |
|
1356 else |
|
1357 { |
|
1358 // Default value for comparison if any of values above hasn't been given in the function |
|
1359 // CustomGetOperatorName call and will cause test case fail if typical operator name type |
|
1360 // have been received from network (latin or ucs2). |
|
1361 operNameType = RMmCustomAPI::EOperatorNameHighestPriority; |
|
1362 } |
|
1363 |
|
1364 if ( operNameType != iOperatorName.iType ) |
|
1365 { |
|
1366 aResult = KErrGeneral; |
|
1367 _LIT8( KResultFail, "CompleteCustomGetOperatorName - operator name type doesn't match" ); |
|
1368 iNWELog->Log((TDesC8)KResultFail, aResult ); |
|
1369 } |
|
1370 } |
|
1371 |
|
1372 if ( ( iCustomGetOperatorNameOngoing ) || |
|
1373 ( iHandleSpecifiedRequests ) ) |
|
1374 { |
|
1375 iCustomGetOperatorNameOngoing = EFalse; |
|
1376 _LIT8( KResultComplete, "CustomGetOperatorName Completed" ); |
|
1377 iNWELog->Log((TDesC8)KResultComplete ); |
|
1378 |
|
1379 Signal( aResult ); |
|
1380 } |
|
1381 } |
|
1382 |
|
1383 // ----------------------------------------------------------------------------- |
|
1384 // CNWE::CustomResetNetworkRegistrationStatusL |
|
1385 // CustomResetNetworkRegistrationStatus method function. |
|
1386 // ----------------------------------------------------------------------------- |
|
1387 // |
|
1388 TInt CNWE::CustomResetNetworkRegistrationStatusL( CStifItemParser& /*aItem*/ ) |
|
1389 { |
|
1390 _LIT8(KCustomResetNetRegStat, "CNWE::CustomResetNetworkRegistrationStatusL" ); |
|
1391 iNWELog->Log((TDesC8)KCustomResetNetRegStat ); |
|
1392 |
|
1393 TInt ret( KErrNotFound ); |
|
1394 |
|
1395 ret = HandleRequestL( ECustomResetNetServerIPC ); |
|
1396 iCustomResetNetworkRegistrationStatusOngoing = ETrue; |
|
1397 |
|
1398 if ( KErrNone == ret ) |
|
1399 { |
|
1400 _LIT8( KResultOk, "CustomResetNetworkRegistrationStatus request send ok" ); |
|
1401 iNWELog->Log((TDesC8)KResultOk); |
|
1402 } |
|
1403 else |
|
1404 { |
|
1405 _LIT8( KResultFail, "CustomResetNetworkRegistrationStatus request send fails: %d" ); |
|
1406 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
1407 } |
|
1408 |
|
1409 return ret; |
|
1410 } |
|
1411 |
|
1412 // ----------------------------------------------------------------------------- |
|
1413 // CNWE::CompleteCustomResetNetworkRegistrationStatus |
|
1414 // Complete CustomResetNetworkRegistrationStatus method function. |
|
1415 // ----------------------------------------------------------------------------- |
|
1416 // |
|
1417 void CNWE::CompleteCustomResetNetworkRegistrationStatus( TInt aResult ) |
|
1418 { |
|
1419 _LIT8( KResult, "CNWE::CompleteCustomResetNetworkRegistrationStatus result: %d" ); |
|
1420 iNWELog->Log((TDesC8)KResult, aResult ); |
|
1421 |
|
1422 if ( ( iCustomResetNetworkRegistrationStatusOngoing ) || |
|
1423 ( iHandleSpecifiedRequests ) ) |
|
1424 { |
|
1425 iCustomResetNetworkRegistrationStatusOngoing = EFalse; |
|
1426 _LIT8( KResultComplete, "CustomResetNetworkRegistrationStatus Completed" ); |
|
1427 iNWELog->Log((TDesC8)KResultComplete ); |
|
1428 |
|
1429 Signal( aResult ); |
|
1430 } |
|
1431 } |
|
1432 |
|
1433 // ----------------------------------------------------------------------------- |
|
1434 // CNWE::CustomGetSystemNetworkModesL |
|
1435 // CustomGetSystemNetworkModes method function. |
|
1436 // ----------------------------------------------------------------------------- |
|
1437 // |
|
1438 TInt CNWE::CustomGetSystemNetworkModesL( CStifItemParser& aItem ) |
|
1439 { |
|
1440 _LIT8(KCustomGetSystemNetworkModes, "CNWE::CustomGetSystemNetworkModesL" ); |
|
1441 iNWELog->Log((TDesC8)KCustomGetSystemNetworkModes ); |
|
1442 |
|
1443 TInt ret( KErrNotFound ); |
|
1444 TPtrC string; |
|
1445 |
|
1446 aItem.GetNextString( string ); |
|
1447 |
|
1448 iNetworkModeForComparison = 3; // KCapsNetworkModeDual |
|
1449 |
|
1450 if ( _L("NET_GSM_RAT") == string ) |
|
1451 { |
|
1452 iNetworkModeForComparison = 1; |
|
1453 } |
|
1454 if ( _L("NET_UMTS_RAT") == string ) |
|
1455 { |
|
1456 iNetworkModeForComparison = 2; |
|
1457 } |
|
1458 |
|
1459 TBool useCurrentRats = EFalse; |
|
1460 CMmDataPackage dataPackage; |
|
1461 dataPackage.PackData(&useCurrentRats); |
|
1462 |
|
1463 ret = HandleRequestL( |
|
1464 ECustomGetSystemNetworkModesIPC, |
|
1465 &dataPackage ); |
|
1466 |
|
1467 iCustomGetSystemNetworkModesOngoing = ETrue; |
|
1468 |
|
1469 if ( KErrNone == ret ) |
|
1470 { |
|
1471 _LIT8( KResultOk, "CustomGetSystemNetworkModes request send ok" ); |
|
1472 iNWELog->Log((TDesC8)KResultOk); |
|
1473 } |
|
1474 else |
|
1475 { |
|
1476 _LIT8( KResultFail, "CustomGetSystemNetworkModes request send fails: %d" ); |
|
1477 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
1478 } |
|
1479 |
|
1480 return ret; |
|
1481 } |
|
1482 |
|
1483 // ----------------------------------------------------------------------------- |
|
1484 // CNWE::CompleteCustomGetSystemNetworkModes |
|
1485 // Complete CustomGetSystemNetworkModes method function. |
|
1486 // ----------------------------------------------------------------------------- |
|
1487 // |
|
1488 void CNWE::CompleteCustomGetSystemNetworkModes |
|
1489 ( |
|
1490 TInt aResult, // Completion result value |
|
1491 CMmDataPackage* aDataPackage // pointer to DataPackage |
|
1492 ) |
|
1493 { |
|
1494 // checking results and unpacking message |
|
1495 _LIT8( KResult, "CNWE::CompleteCustomGetSystemNetworkModes result: %d" ); |
|
1496 iNWELog->Log((TDesC8)KResult, aResult ); |
|
1497 |
|
1498 TInt networkMode; |
|
1499 |
|
1500 if ( KErrNone == aResult ) |
|
1501 { |
|
1502 aDataPackage->UnPackData( networkMode ); |
|
1503 |
|
1504 iNWELog->Log((TDesC8)KLine ); |
|
1505 _LIT8( KNetworkMode, "System Network mode: %d" ); |
|
1506 iNWELog->Log((TDesC8)KNetworkMode, networkMode ); |
|
1507 |
|
1508 if ( networkMode == 1 ) |
|
1509 { |
|
1510 _LIT8( KNetworkMode, "KCapsNetworkModeGsm" ); |
|
1511 iNWELog->Log((TDesC8)KNetworkMode ); |
|
1512 } |
|
1513 else if ( networkMode == 2 ) |
|
1514 { |
|
1515 _LIT8( KNetworkMode, "KCapsNetworkModeUmts" ); |
|
1516 iNWELog->Log((TDesC8)KNetworkMode ); |
|
1517 } |
|
1518 else if ( networkMode == 3 ) |
|
1519 { |
|
1520 _LIT8( KNetworkMode, "KCapsNetworkModeDual" ); |
|
1521 iNWELog->Log((TDesC8)KNetworkMode ); |
|
1522 } |
|
1523 iNWELog->Log((TDesC8)KLine ); |
|
1524 } |
|
1525 else |
|
1526 { |
|
1527 _LIT8( KResultFail, "CompleteCustomGetSystemNetworkModes Failed: %d" ); |
|
1528 iNWELog->Log((TDesC8)KResultFail, aResult ); |
|
1529 } |
|
1530 |
|
1531 if ( ( iCustomGetSystemNetworkModesOngoing ) || |
|
1532 ( iHandleSpecifiedRequests ) ) |
|
1533 { |
|
1534 iCustomGetSystemNetworkModesOngoing = EFalse; |
|
1535 _LIT8( KResultComplete, "CustomGetSystemNetworkModes Completed" ); |
|
1536 iNWELog->Log((TDesC8)KResultComplete ); |
|
1537 |
|
1538 if ( ( iNetworkModeForComparison != networkMode ) && |
|
1539 ( iHandleSpecifiedRequests ) ) |
|
1540 { |
|
1541 aResult = KErrGeneral; |
|
1542 } |
|
1543 |
|
1544 Signal( aResult ); |
|
1545 } |
|
1546 } |
|
1547 |
|
1548 // ----------------------------------------------------------------------------- |
|
1549 // CNWE::CustomSetSystemNetworkModeL |
|
1550 // CustomSetSystemNetworkMode method function. |
|
1551 // ----------------------------------------------------------------------------- |
|
1552 // |
|
1553 TInt CNWE::CustomSetSystemNetworkModeL( CStifItemParser& aItem ) |
|
1554 { |
|
1555 _LIT8(KCustomSetSystemNetworkMode, "CNWE::CustomSetSystemNetworkModeL" ); |
|
1556 iNWELog->Log((TDesC8)KCustomSetSystemNetworkMode ); |
|
1557 |
|
1558 TInt ret( KErrNotFound ); |
|
1559 |
|
1560 TBool selection = ETrue; |
|
1561 TPtrC string; |
|
1562 aItem.GetNextString( string ); |
|
1563 |
|
1564 if ( _L( "NetworkGsm" ) == string ) |
|
1565 { |
|
1566 _LIT8( KNetworkGsm, "KCapsNetworkModeGsm" ); |
|
1567 iNWELog->Log((TDesC8)KNetworkGsm ); |
|
1568 iNetworkModeCaps = RMmCustomAPI::KCapsNetworkModeGsm; |
|
1569 } |
|
1570 else if ( _L ( "NetworkUmts" ) == string ) |
|
1571 { |
|
1572 _LIT8( KNetworkUmts, "KCapsNetworkModeUmts" ); |
|
1573 iNWELog->Log((TDesC8)KNetworkUmts ); |
|
1574 iNetworkModeCaps = RMmCustomAPI::KCapsNetworkModeUmts; |
|
1575 } |
|
1576 else if ( _L ( "NetworkDual" ) == string ) |
|
1577 { |
|
1578 _LIT8( KNetworkDual, "KCapsNetworkModeDual" ); |
|
1579 iNWELog->Log((TDesC8)KNetworkDual ); |
|
1580 iNetworkModeCaps = RMmCustomAPI::KCapsNetworkModeDual; |
|
1581 } |
|
1582 else |
|
1583 { |
|
1584 _LIT8( KFail, "Set CustomSetCapsNetworkMode not possible: %d" ); |
|
1585 iNWELog->Log((TDesC8)KFail, ret ); |
|
1586 selection = EFalse; |
|
1587 } |
|
1588 |
|
1589 if ( selection ) |
|
1590 { |
|
1591 CMmDataPackage dataPackage; |
|
1592 dataPackage.PackData(&iNetworkModeCaps); |
|
1593 |
|
1594 ret = HandleRequestL( |
|
1595 ECustomSetSystemNetworkModeIPC, |
|
1596 &dataPackage ); |
|
1597 |
|
1598 iCustomSetSystemNetworkModeOngoing = ETrue; |
|
1599 |
|
1600 if ( KErrNone == ret ) |
|
1601 { |
|
1602 _LIT8( KResultOk, "CustomSetSystemNetworkMode request send ok" ); |
|
1603 iNWELog->Log((TDesC8)KResultOk); |
|
1604 } |
|
1605 else |
|
1606 { |
|
1607 _LIT8( KResultFail, "CustomSetSystemNetworkMode request send fails: %d" ); |
|
1608 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
1609 } |
|
1610 } |
|
1611 else |
|
1612 { |
|
1613 ret = KErrNotSupported; |
|
1614 } |
|
1615 |
|
1616 return ret; |
|
1617 } |
|
1618 |
|
1619 // ----------------------------------------------------------------------------- |
|
1620 // CNWE::CompleteCustomSetSystemNetworkMode |
|
1621 // Complete CustomSetSystemNetworkMode method function. |
|
1622 // ----------------------------------------------------------------------------- |
|
1623 // |
|
1624 void CNWE::CompleteCustomSetSystemNetworkMode( TInt aResult ) |
|
1625 { |
|
1626 _LIT8( KResult, "CNWE::CompleteCustomSetSystemNetworkMode result: %d" ); |
|
1627 iNWELog->Log((TDesC8)KResult, aResult ); |
|
1628 |
|
1629 if ( ( iCustomSetSystemNetworkModeOngoing ) || |
|
1630 ( iHandleSpecifiedRequests ) ) |
|
1631 { |
|
1632 iCustomSetSystemNetworkModeOngoing = EFalse; |
|
1633 _LIT8( KResultComplete, "CustomSetSystemNetworkMode Completed" ); |
|
1634 iNWELog->Log((TDesC8)KResultComplete ); |
|
1635 |
|
1636 Signal( aResult ); |
|
1637 } |
|
1638 } |
|
1639 |
|
1640 // ----------------------------------------------------------------------------- |
|
1641 // CNWE::CustomGetCurrentSystemNetworkModesL |
|
1642 // CustomGetCurrentSystemNetworkModes method function. |
|
1643 // ----------------------------------------------------------------------------- |
|
1644 // |
|
1645 TInt CNWE::CustomGetCurrentSystemNetworkModesL( CStifItemParser& aItem ) |
|
1646 { |
|
1647 _LIT8(KCustomGetCurrentSystemNetworkModes, |
|
1648 "CNWE::CustomGetCurrentSystemNetworkModesL" ); |
|
1649 iNWELog->Log((TDesC8)KCustomGetCurrentSystemNetworkModes ); |
|
1650 |
|
1651 TInt ret( KErrNotFound ); |
|
1652 TPtrC string; |
|
1653 |
|
1654 aItem.GetNextString( string ); |
|
1655 |
|
1656 iNetworkModeForComparison = 4; // KCapsNetworkModeDual |
|
1657 |
|
1658 if ( _L("MTC_GSM_RAT") == string ) |
|
1659 { |
|
1660 iNetworkModeForComparison = 1; |
|
1661 } |
|
1662 |
|
1663 if ( _L("MTC_UMTS_RAT") == string ) |
|
1664 { |
|
1665 iNetworkModeForComparison = 2; |
|
1666 } |
|
1667 |
|
1668 ret = HandleRequestL( ECustomGetCurrentSystemNetworkModesIPC ); |
|
1669 iCustomGetCurrentSystemNetworkModesOngoing = ETrue; |
|
1670 |
|
1671 if ( KErrNone == ret ) |
|
1672 { |
|
1673 _LIT8( KResultOk, "CustomGetCurrentSystemNetworkModes request send ok" ); |
|
1674 iNWELog->Log((TDesC8)KResultOk); |
|
1675 } |
|
1676 else |
|
1677 { |
|
1678 _LIT8( KResultFail, "CustomGetCurrentSystemNetworkModes request send fails: %d" ); |
|
1679 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
1680 } |
|
1681 |
|
1682 return ret; |
|
1683 } |
|
1684 |
|
1685 // ----------------------------------------------------------------------------- |
|
1686 // CNWE::CompleteCustomGetCurrentSystemNetworkModes |
|
1687 // Complete CustomGetCurrentSystemNetworkModes method function. |
|
1688 // ----------------------------------------------------------------------------- |
|
1689 // |
|
1690 void CNWE::CompleteCustomGetCurrentSystemNetworkModes |
|
1691 ( |
|
1692 TInt aResult, // Completion result value |
|
1693 CMmDataPackage* aDataPackage // pointer to DataPackage |
|
1694 ) |
|
1695 { |
|
1696 // checking results and unpacking message |
|
1697 _LIT8( KResult, "CNWE::CompleteCustomGetCurrentSystemNetworkModes result: %d" ); |
|
1698 iNWELog->Log((TDesC8)KResult, aResult ); |
|
1699 |
|
1700 TInt networkMode; |
|
1701 |
|
1702 if ( KErrNone == aResult ) |
|
1703 { |
|
1704 aDataPackage->UnPackData( networkMode ); |
|
1705 |
|
1706 iNWELog->Log((TDesC8)KLine ); |
|
1707 _LIT8( KNetworkMode, "Current System Network mode: %d" ); |
|
1708 iNWELog->Log((TDesC8)KNetworkMode, networkMode ); |
|
1709 |
|
1710 if ( networkMode == 1 ) |
|
1711 { |
|
1712 _LIT8( KNetworkMode, "KCapsNetworkModeGsm" ); |
|
1713 iNWELog->Log((TDesC8)KNetworkMode ); |
|
1714 } |
|
1715 else if ( networkMode == 2 ) |
|
1716 { |
|
1717 _LIT8( KNetworkMode, "KCapsNetworkModeUmts" ); |
|
1718 iNWELog->Log((TDesC8)KNetworkMode ); |
|
1719 } |
|
1720 else if ( networkMode == 4 ) |
|
1721 { |
|
1722 _LIT8( KNetworkMode, "KCapsNetworkModeDual" ); |
|
1723 iNWELog->Log((TDesC8)KNetworkMode ); |
|
1724 } |
|
1725 iNWELog->Log((TDesC8)KLine ); |
|
1726 } |
|
1727 else |
|
1728 { |
|
1729 _LIT8( KResultFail, "CompleteCustomGetCurrentSystemNetworkModes Failed: %d" ); |
|
1730 iNWELog->Log((TDesC8)KResultFail, aResult ); |
|
1731 } |
|
1732 |
|
1733 if ( ( iCustomGetCurrentSystemNetworkModesOngoing ) || |
|
1734 ( iHandleSpecifiedRequests ) ) |
|
1735 { |
|
1736 iCustomGetCurrentSystemNetworkModesOngoing = EFalse; |
|
1737 _LIT8( KResultComplete, "CustomGetCurrentSystemNetworkModes Completed" ); |
|
1738 iNWELog->Log((TDesC8)KResultComplete ); |
|
1739 |
|
1740 if ( ( iNetworkModeForComparison != networkMode ) && |
|
1741 ( iHandleSpecifiedRequests ) ) |
|
1742 { |
|
1743 aResult = KErrGeneral; |
|
1744 } |
|
1745 |
|
1746 Signal( aResult ); |
|
1747 } |
|
1748 } |
|
1749 |
|
1750 // ----------------------------------------------------------------------------- |
|
1751 // CNWE::NotifySignalStrengthChange |
|
1752 // NotifyChange of Signal Strength |
|
1753 // ----------------------------------------------------------------------------- |
|
1754 // |
|
1755 void CNWE::NotifySignalStrengthChange |
|
1756 ( |
|
1757 TInt aResult, // Completion result value |
|
1758 CMmDataPackage* aDataPackage // pointer to DataPackage |
|
1759 ) |
|
1760 { |
|
1761 if ( ( iNotifyList[ENotifySignalStrengthChange] ) || |
|
1762 ( iHandleSpecifiedRequests ) ) |
|
1763 { |
|
1764 _LIT8(KSignalStrengthChange, "CNWE::NotifySignalStrengthChange" ); |
|
1765 iNWELog->Log((TDesC8)KSignalStrengthChange ); |
|
1766 |
|
1767 TInt8 signalBars; |
|
1768 TInt32 signalStrength; |
|
1769 |
|
1770 // checking results and unpacking message |
|
1771 if ( KErrNone == aResult ) |
|
1772 { |
|
1773 aDataPackage->UnPackData( signalBars, signalStrength ); |
|
1774 |
|
1775 iNWELog->Log((TDesC8)KLine ); |
|
1776 _LIT8(KSignalBars, "Signal Bars: %d" ); |
|
1777 iNWELog->Log((TDesC8)KSignalBars, signalBars ); |
|
1778 _LIT8(KSignalStrength, "Signal Strength in dBm: %d" ); |
|
1779 iNWELog->Log((TDesC8)KSignalStrength, signalStrength ); |
|
1780 iNWELog->Log((TDesC8)KLine ); |
|
1781 } |
|
1782 else |
|
1783 { |
|
1784 _LIT8(Fail, "NotifySignalStrengthChange Failed" ); |
|
1785 iNWELog->Log((TDesC8)Fail); |
|
1786 } |
|
1787 } |
|
1788 } |
|
1789 |
|
1790 // ----------------------------------------------------------------------------- |
|
1791 // CNWE::NotifyNITZInfoChange |
|
1792 // NotifyChange of NITZ Info |
|
1793 // ----------------------------------------------------------------------------- |
|
1794 // |
|
1795 void CNWE::NotifyNITZInfoChange |
|
1796 ( |
|
1797 TInt aResult, // Completion result value |
|
1798 CMmDataPackage* aDataPackage // pointer to DataPackage |
|
1799 ) |
|
1800 { |
|
1801 if ( ( iNotifyList[ENotifyNITZInfoChange] ) || |
|
1802 ( iHandleSpecifiedRequests ) ) |
|
1803 { |
|
1804 _LIT8(KNITZInfoChange, "CNWE::NotifyNITZInfoChange" ); |
|
1805 iNWELog->Log((TDesC8)KNITZInfoChange ); |
|
1806 |
|
1807 // checking results and unpacking message |
|
1808 if ( KErrNone == aResult ) |
|
1809 { |
|
1810 aDataPackage->UnPackData( iNITZInfo ); |
|
1811 |
|
1812 iNWELog->Log((TDesC8)KLine ); |
|
1813 _LIT8(KNITZInfo, "NITZ Info and Zone Information" ); |
|
1814 iNWELog->Log((TDesC8)KNITZInfo ); |
|
1815 _LIT8(KDate, "Date info = Year, Month, Day: %d %d %d" ); |
|
1816 // Month: Offset from zero, so add one before displaying the month number. |
|
1817 // Day: Offset from zero, so add one before displaying the day number. |
|
1818 iNWELog->Log((TDesC8)KDate, iNITZInfo.Year(), iNITZInfo.Month()+1, iNITZInfo.Day()+1 ); |
|
1819 _LIT8(KTime, "Time info = Hour, Minute, Second, Microsecond: %d %d %d %d" ); |
|
1820 iNWELog->Log((TDesC8)KTime, iNITZInfo.Hour(), iNITZInfo.Minute(), iNITZInfo.Second(), iNITZInfo.MicroSecond() ); |
|
1821 _LIT8(KDST, "Daylight Saving Time adjustment for summer time: %d" ); |
|
1822 iNWELog->Log((TDesC8)KDST, iNITZInfo.iDST ); |
|
1823 _LIT8(KTimeZone, "Time zone, expressed in +/- 15 minute offsets from GMT: %d" ); |
|
1824 iNWELog->Log((TDesC8)KTimeZone, iNITZInfo.iTimeZone ); |
|
1825 iNWELog->Log((TDesC8)KLine ); |
|
1826 } |
|
1827 |
|
1828 if ( ( iHandleSpecifiedRequests ) && |
|
1829 ( ( 2008 != iNITZInfo.Year() ) || |
|
1830 ( EFebruary != iNITZInfo.Month() ) || |
|
1831 ( 2 != iNITZInfo.Day() ) || |
|
1832 ( 20 != iNITZInfo.Hour() ) || |
|
1833 ( 24 != iNITZInfo.Minute() ) || |
|
1834 ( 0 != iNITZInfo.Second() ) || |
|
1835 ( 0 != iNITZInfo.MicroSecond() ) || |
|
1836 ( 0 != iNITZInfo.iDST ) || |
|
1837 ( 0 != iNITZInfo.iTimeZone ) ) ) |
|
1838 { |
|
1839 aResult = KErrGeneral; |
|
1840 } |
|
1841 else |
|
1842 { |
|
1843 _LIT8(Fail, "NotifyNITZInfoChange Failed" ); |
|
1844 iNWELog->Log((TDesC8)Fail); |
|
1845 } |
|
1846 |
|
1847 Signal( aResult ); |
|
1848 } |
|
1849 } |
|
1850 |
|
1851 // ----------------------------------------------------------------------------- |
|
1852 // CNWE::NotifyNetworkSecurityLevelChange |
|
1853 // NotifyChange of NetworkSecurityLevel |
|
1854 // ----------------------------------------------------------------------------- |
|
1855 // |
|
1856 void CNWE::NotifyNetworkSecurityLevelChange |
|
1857 ( |
|
1858 TInt aResult, // Completion result value |
|
1859 CMmDataPackage* aDataPackage // pointer to DataPackage |
|
1860 ) |
|
1861 { |
|
1862 if ( ( iNotifyList[ENotifyNetworkSecurityLevelChange] ) || |
|
1863 ( iHandleSpecifiedRequests ) ) |
|
1864 { |
|
1865 _LIT8(KNetworkSecLevelChange, "CNWE::NotifyNetworkSecurityLevelChange" ); |
|
1866 iNWELog->Log((TDesC8)KNetworkSecLevelChange ); |
|
1867 |
|
1868 // checking results and unpacking message |
|
1869 if ( KErrNone == aResult ) |
|
1870 { |
|
1871 aDataPackage->UnPackData( &iNetworkSecurityLevel ); |
|
1872 |
|
1873 iNWELog->Log((TDesC8)KLine ); |
|
1874 _LIT8(KNetworkSecurityLevel, "Network Security Level Change Information: " ); |
|
1875 iNWELog->Log((TDesC8)KNetworkSecurityLevel ); |
|
1876 iNWELog->Log( TMobilePhoneNetworkSecurity[*iNetworkSecurityLevel] ); |
|
1877 iNWELog->Log((TDesC8)KLine ); |
|
1878 |
|
1879 if ( ( iHandleSpecifiedRequests ) && |
|
1880 ( RMobilePhone::ECipheringGSM != *iNetworkSecurityLevel ) ) |
|
1881 { |
|
1882 aResult = KErrGeneral; |
|
1883 } |
|
1884 } |
|
1885 else |
|
1886 { |
|
1887 _LIT8(Fail, "NotifyNetworkSecurityLevelChange Failed: %d" ); |
|
1888 iNWELog->Log((TDesC8)Fail, aResult ); |
|
1889 } |
|
1890 |
|
1891 Signal( aResult ); |
|
1892 } |
|
1893 } |
|
1894 |
|
1895 // ----------------------------------------------------------------------------- |
|
1896 // CNWE::ManualNetworkSearchL |
|
1897 // ManualNetworkSearch method function. |
|
1898 // ----------------------------------------------------------------------------- |
|
1899 // |
|
1900 TInt CNWE::ManualNetworkSearchL( CStifItemParser& aItem ) |
|
1901 { |
|
1902 _LIT8(KManualNetworkSearch, "CNWE::ManualNetworkSearchL" ); |
|
1903 iNWELog->Log((TDesC8)KManualNetworkSearch ); |
|
1904 |
|
1905 TPtrC string; |
|
1906 |
|
1907 aItem.GetNextString( string ); |
|
1908 iSavedDisplayTagForComparison[0].Zero(); |
|
1909 iSavedDisplayTagForComparison[0].Append( string ); |
|
1910 iSavedShortNameForComparison[0].Zero(); |
|
1911 iSavedShortNameForComparison[0].Append( string ); |
|
1912 iSavedLongNameForComparison[0].Zero(); |
|
1913 iSavedLongNameForComparison[0].Append( string ); |
|
1914 |
|
1915 aItem.GetNextString( string ); |
|
1916 iSavedDisplayTagForComparison[1].Zero(); |
|
1917 iSavedDisplayTagForComparison[1].Append( string ); |
|
1918 iSavedShortNameForComparison[1].Zero(); |
|
1919 iSavedShortNameForComparison[1].Append( string ); |
|
1920 iSavedLongNameForComparison[1].Zero(); |
|
1921 iSavedLongNameForComparison[1].Append( string ); |
|
1922 |
|
1923 aItem.GetNextString( string ); |
|
1924 iSavedDisplayTagForComparison[2].Zero(); |
|
1925 iSavedDisplayTagForComparison[2].Append( string ); |
|
1926 iSavedShortNameForComparison[2].Zero(); |
|
1927 iSavedShortNameForComparison[2].Append( string ); |
|
1928 iSavedLongNameForComparison[2].Zero(); |
|
1929 iSavedLongNameForComparison[2].Append( string ); |
|
1930 |
|
1931 aItem.GetNextString( string ); |
|
1932 iSavedDisplayTagForComparison[3].Zero(); |
|
1933 iSavedDisplayTagForComparison[3].Append( string ); |
|
1934 iSavedShortNameForComparison[3].Zero(); |
|
1935 iSavedShortNameForComparison[3].Append( string ); |
|
1936 iSavedLongNameForComparison[3].Zero(); |
|
1937 iSavedLongNameForComparison[3].Append( string ); |
|
1938 |
|
1939 if ( ( iHandleSpecifiedRequests ) && |
|
1940 ( 0 != iSavedDisplayTagForComparison[0].Compare ( _L( "DONT_CARE_NETWORK_NAME" ) ) ) ) |
|
1941 { |
|
1942 aItem.GetNextString( string ); |
|
1943 iNetworkIdForComparison[0].Zero(); |
|
1944 iNetworkIdForComparison[0].Append( string ); |
|
1945 |
|
1946 aItem.GetNextString( string ); |
|
1947 iCountryCodeForComparison[0].Zero(); |
|
1948 iCountryCodeForComparison[0].Append( string ); |
|
1949 |
|
1950 aItem.GetNextString( string ); |
|
1951 iNetworkIdForComparison[1].Zero(); |
|
1952 iNetworkIdForComparison[1].Append( string ); |
|
1953 |
|
1954 aItem.GetNextString( string ); |
|
1955 iCountryCodeForComparison[1].Zero(); |
|
1956 iCountryCodeForComparison[1].Append( string ); |
|
1957 |
|
1958 aItem.GetNextString( string ); |
|
1959 iNetworkIdForComparison[2].Zero(); |
|
1960 iNetworkIdForComparison[2].Append( string ); |
|
1961 |
|
1962 aItem.GetNextString( string ); |
|
1963 iCountryCodeForComparison[2].Zero(); |
|
1964 iCountryCodeForComparison[2].Append( string ); |
|
1965 |
|
1966 aItem.GetNextString( string ); |
|
1967 iNetworkIdForComparison[3].Zero(); |
|
1968 iNetworkIdForComparison[3].Append( string ); |
|
1969 |
|
1970 aItem.GetNextString( string ); |
|
1971 iCountryCodeForComparison[3].Zero(); |
|
1972 iCountryCodeForComparison[3].Append( string ); |
|
1973 } |
|
1974 |
|
1975 TInt ret( KErrNotFound ); |
|
1976 |
|
1977 ret = HandleRequestL( EMobilePhoneGetDetectedNetworksV2Phase1 ); |
|
1978 iManualNetworkSearchOngoing = ETrue; |
|
1979 |
|
1980 if ( KErrNone == ret ) |
|
1981 { |
|
1982 _LIT8( KResultOk, "ManualNetworkSearch request send ok" ); |
|
1983 iNWELog->Log((TDesC8)KResultOk); |
|
1984 } |
|
1985 else |
|
1986 { |
|
1987 _LIT8( KResultFail, "ManualNetworkSearch request send fails: %d" ); |
|
1988 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
1989 } |
|
1990 |
|
1991 return ret; |
|
1992 } |
|
1993 |
|
1994 // ----------------------------------------------------------------------------- |
|
1995 // CNWE::CompleteManualNetworkSearch |
|
1996 // Complete ManualNetworkSearch method function. |
|
1997 // ----------------------------------------------------------------------------- |
|
1998 // |
|
1999 void CNWE::CompleteManualNetworkSearch |
|
2000 ( |
|
2001 TInt aResult, // Completion result value |
|
2002 CMmDataPackage* aDataPackage // pointer to DataPackage |
|
2003 ) |
|
2004 { |
|
2005 // checking results and unpacking message |
|
2006 _LIT8( KResult, "CNWE::CompleteManualNetworkSearch result: %d" ); |
|
2007 iNWELog->Log((TDesC8)KResult, aResult ); |
|
2008 |
|
2009 if ( KErrNone == aResult ) |
|
2010 { |
|
2011 CMobilePhoneNetworkListV2* list = NULL; |
|
2012 aDataPackage->UnPackData ( list ); |
|
2013 |
|
2014 iNWELog->Log((TDesC8)KLine ); |
|
2015 _LIT8( KNetworkList, "Searched Network List: " ); |
|
2016 iNWELog->Log((TDesC8)KNetworkList ); |
|
2017 iNWELog->Log((TDesC8)KLine ); |
|
2018 |
|
2019 for ( TInt i=0; i<list->Enumerate(); i++) |
|
2020 { |
|
2021 const RMobilePhone::TMobilePhoneNetworkInfoV2& entry = list->GetEntryL(i); |
|
2022 |
|
2023 _LIT8( KNetworkId, "Network ID: " ); |
|
2024 iNWELog->Log((TDesC8)KNetworkId ); |
|
2025 iNWELog->Log( entry.iNetworkId ); |
|
2026 |
|
2027 _LIT8( KCountryCode, "Country Code: " ); |
|
2028 iNWELog->Log((TDesC8)KCountryCode ); |
|
2029 iNWELog->Log( entry.iCountryCode ); |
|
2030 |
|
2031 _LIT8( KDisplayTag, "Display Tag: " ); |
|
2032 iNWELog->Log((TDesC8)KDisplayTag ); |
|
2033 iNWELog->Log( entry.iDisplayTag ); |
|
2034 |
|
2035 _LIT8( KLongName, "Long Name: " ); |
|
2036 iNWELog->Log((TDesC8)KLongName ); |
|
2037 iNWELog->Log( entry.iLongName ); |
|
2038 |
|
2039 _LIT8( KShortName, "Short Name: " ); |
|
2040 iNWELog->Log((TDesC8)KShortName ); |
|
2041 iNWELog->Log( entry.iShortName ); |
|
2042 |
|
2043 iNWELog->Log((TDesC8)KLine ); |
|
2044 |
|
2045 if ( ( 0 != iSavedDisplayTagForComparison[i].Compare ( _L( "DONT_CARE_NETWORK_NAME" ) ) ) && |
|
2046 ( KErrNone == aResult ) ) |
|
2047 { |
|
2048 if ( ( iSavedDisplayTagForComparison[i] != entry.iDisplayTag ) || |
|
2049 ( iSavedShortNameForComparison[i] != entry.iShortName ) || |
|
2050 ( iSavedLongNameForComparison[i] != entry.iLongName ) ) |
|
2051 { |
|
2052 _LIT8( KResultFail, "CompleteManualNetworkSearch - operator names do not match" ); |
|
2053 iNWELog->Log((TDesC8)KResultFail); |
|
2054 aResult = KErrGeneral; |
|
2055 } |
|
2056 |
|
2057 if ( ( iHandleSpecifiedRequests ) && |
|
2058 ( ( iNetworkIdForComparison[i] != entry.iNetworkId ) || |
|
2059 ( iCountryCodeForComparison[i] != entry.iCountryCode ) ) ) |
|
2060 { |
|
2061 _LIT8( KResultFail, "CompleteManualNetworkSearch - Network ID or Country Code don't match" ); |
|
2062 iNWELog->Log((TDesC8)KResultFail); |
|
2063 aResult = KErrGeneral; |
|
2064 } |
|
2065 } |
|
2066 } |
|
2067 |
|
2068 _LIT8( KNetworkListEnd, "Searched Network List Ended" ); |
|
2069 iNWELog->Log((TDesC8)KNetworkListEnd ); |
|
2070 iNWELog->Log((TDesC8)KLine ); |
|
2071 } |
|
2072 else |
|
2073 { |
|
2074 _LIT8( KResultFail, "CompleteManualNetworkSearch, Error case: %d" ); |
|
2075 iNWELog->Log((TDesC8)KResultFail, aResult ); |
|
2076 |
|
2077 if ( KErrCancel == aResult |
|
2078 && iManualNetworkSearchOngoing |
|
2079 && iManualNetworkSearchCancelOngoing ) |
|
2080 { |
|
2081 iManualNetworkSearchOngoing = EFalse; |
|
2082 |
|
2083 _LIT8( KResultComplete, "ManualNetworkSearch Completed with Cancel" ); |
|
2084 iNWELog->Log((TDesC8)KResultComplete ); |
|
2085 |
|
2086 Signal( aResult ); |
|
2087 } |
|
2088 } |
|
2089 |
|
2090 if ( iManualNetworkSearchOngoing && !iManualNetworkSearchCancelOngoing ) |
|
2091 { |
|
2092 iManualNetworkSearchOngoing = EFalse; |
|
2093 |
|
2094 _LIT8( KResultComplete, "ManualNetworkSearch Completed" ); |
|
2095 iNWELog->Log((TDesC8)KResultComplete ); |
|
2096 |
|
2097 Signal( aResult ); |
|
2098 } |
|
2099 |
|
2100 if ( iNetworkModeTestOnGoing ) |
|
2101 { |
|
2102 SetNetworkInfo( aResult, aDataPackage, EMobilePhoneGetDetectedNetworksV2Phase1 ); |
|
2103 } |
|
2104 } |
|
2105 |
|
2106 // ----------------------------------------------------------------------------- |
|
2107 // CNWE::ManualNetworkSearchCancelL |
|
2108 // ManualNetworkSearchCancel method function. |
|
2109 // ----------------------------------------------------------------------------- |
|
2110 // |
|
2111 TInt CNWE::ManualNetworkSearchCancelL( CStifItemParser& /*aItem*/ ) |
|
2112 { |
|
2113 _LIT8(KManualNetworkSearchCancel, "CNWE::ManualNetworkSearchCancelL" ); |
|
2114 iNWELog->Log((TDesC8)KManualNetworkSearchCancel ); |
|
2115 |
|
2116 TInt ret( KErrNotFound ); |
|
2117 |
|
2118 ret = HandleRequestL( EMobilePhoneGetDetectedNetworksCancel ); |
|
2119 iManualNetworkSearchCancelOngoing = ETrue; |
|
2120 |
|
2121 if ( KErrNone == ret ) |
|
2122 { |
|
2123 _LIT8( KResultOk, "ManualNetworkSearchCancel request send ok" ); |
|
2124 iNWELog->Log((TDesC8)KResultOk); |
|
2125 } |
|
2126 else |
|
2127 { |
|
2128 _LIT8( KResultFail, "ManualNetworkSearchCancel request send fails: %d" ); |
|
2129 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
2130 } |
|
2131 |
|
2132 return ret; |
|
2133 } |
|
2134 |
|
2135 // ----------------------------------------------------------------------------- |
|
2136 // CNWE::CompleteManualNetworkSearchCancel |
|
2137 // Complete ManualNetworkSearchCancel method function. |
|
2138 // ----------------------------------------------------------------------------- |
|
2139 // |
|
2140 void CNWE::CompleteManualNetworkSearchCancel( TInt aResult ) |
|
2141 { |
|
2142 _LIT8( KResult, "CNWE::CompleteManualNetworkSearchCancel result: %d" ); |
|
2143 iNWELog->Log((TDesC8)KResult, aResult ); |
|
2144 |
|
2145 if ( ( iManualNetworkSearchCancelOngoing ) || |
|
2146 ( iHandleSpecifiedRequests ) ) |
|
2147 { |
|
2148 iManualNetworkSearchCancelOngoing = EFalse; |
|
2149 _LIT8( KResultComplete, "ManualNetworkSearchCancel Completed" ); |
|
2150 iNWELog->Log((TDesC8)KResultComplete ); |
|
2151 |
|
2152 Signal( aResult ); |
|
2153 } |
|
2154 } |
|
2155 |
|
2156 // ----------------------------------------------------------------------------- |
|
2157 // CNWE::ManualNetworkSelectionL |
|
2158 // ManualNetworkSelection method function. |
|
2159 // ----------------------------------------------------------------------------- |
|
2160 // |
|
2161 TInt CNWE::ManualNetworkSelectionL( CStifItemParser& aItem ) |
|
2162 { |
|
2163 _LIT8(KManualNetworkSelection, "CNWE::ManualNetworkSelectionL" ); |
|
2164 iNWELog->Log((TDesC8)KManualNetworkSelection ); |
|
2165 |
|
2166 TInt ret( KErrNotFound ); |
|
2167 |
|
2168 TPtrC string; |
|
2169 |
|
2170 RMobilePhone::TMobilePhoneNetworkManualSelection manualSelection; |
|
2171 aItem.GetNextString( string ); |
|
2172 manualSelection.iNetwork.Copy( string ); |
|
2173 aItem.GetNextString( string ); |
|
2174 manualSelection.iCountry.Copy( string ); |
|
2175 |
|
2176 TBool isManual = ETrue; |
|
2177 |
|
2178 CMmDataPackage dataPackage; |
|
2179 dataPackage.PackData( &isManual, &manualSelection ); |
|
2180 |
|
2181 ret = HandleRequestL( EMobilePhoneSelectNetwork, &dataPackage ); |
|
2182 iManualNetworkSelectionOngoing = ETrue; |
|
2183 |
|
2184 if ( KErrNone == ret ) |
|
2185 { |
|
2186 _LIT8( KResultOk, "ManualNetworkSelection request send ok" ); |
|
2187 iNWELog->Log((TDesC8)KResultOk); |
|
2188 } |
|
2189 else |
|
2190 { |
|
2191 _LIT8( KResultFail, "ManualNetworkSelection request send fails: %d" ); |
|
2192 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
2193 } |
|
2194 |
|
2195 return ret; |
|
2196 } |
|
2197 |
|
2198 // ----------------------------------------------------------------------------- |
|
2199 // CNWE::CompleteManualNetworkSelection |
|
2200 // Complete ManualNetworkSearchCancel method function. |
|
2201 // ----------------------------------------------------------------------------- |
|
2202 // |
|
2203 void CNWE::CompleteManualNetworkSelection( TInt aResult ) |
|
2204 { |
|
2205 _LIT8( KResult, "CNWE::CompleteManualNetworkSelection result: %d" ); |
|
2206 iNWELog->Log((TDesC8)KResult, aResult ); |
|
2207 |
|
2208 if ( iManualNetworkSelectionOngoing && !iManualNetworkSelectionCancelOngoing ) |
|
2209 { |
|
2210 iManualNetworkSelectionOngoing = EFalse; |
|
2211 _LIT8( KResultComplete, "ManualNetworkSelection Completed" ); |
|
2212 iNWELog->Log((TDesC8)KResultComplete ); |
|
2213 |
|
2214 Signal( aResult ); |
|
2215 } |
|
2216 } |
|
2217 |
|
2218 // ----------------------------------------------------------------------------- |
|
2219 // CNWE::ManualNetworkSelectionCancelL |
|
2220 // ManualNetworkSelectionCancel method function. |
|
2221 // ----------------------------------------------------------------------------- |
|
2222 // |
|
2223 TInt CNWE::ManualNetworkSelectionCancelL( CStifItemParser& /*aItem*/ ) |
|
2224 { |
|
2225 _LIT8(KManualNetworkSelectionCancel, "CNWE::ManualNetworkSelectionCancelL" ); |
|
2226 iNWELog->Log((TDesC8)KManualNetworkSelectionCancel ); |
|
2227 |
|
2228 TInt ret( KErrNotFound ); |
|
2229 |
|
2230 ret = HandleRequestL( EMobilePhoneSelectNetworkCancel ); |
|
2231 iManualNetworkSelectionCancelOngoing = ETrue; |
|
2232 |
|
2233 if ( KErrNone == ret ) |
|
2234 { |
|
2235 _LIT8( KResultOk, "ManualNetworkSelectionCancel request send ok" ); |
|
2236 iNWELog->Log((TDesC8)KResultOk); |
|
2237 } |
|
2238 else |
|
2239 { |
|
2240 _LIT8( KResultFail, "ManualNetworkSelectionCancel request send fails: %d" ); |
|
2241 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
2242 } |
|
2243 |
|
2244 return ret; |
|
2245 } |
|
2246 |
|
2247 // ----------------------------------------------------------------------------- |
|
2248 // CNWE::CompleteManualNetworkSelectionCancel |
|
2249 // Complete ManualNetworkSelectionCancel method function. |
|
2250 // ----------------------------------------------------------------------------- |
|
2251 // |
|
2252 void CNWE::CompleteManualNetworkSelectionCancel( TInt aResult ) |
|
2253 { |
|
2254 _LIT8( KResult, "CNWE::CompleteManualNetworkSelectionCancel result: %d" ); |
|
2255 iNWELog->Log((TDesC8)KResult, aResult ); |
|
2256 |
|
2257 if ( ( iManualNetworkSelectionCancelOngoing ) || |
|
2258 ( iHandleSpecifiedRequests ) ) |
|
2259 { |
|
2260 iManualNetworkSelectionCancelOngoing = EFalse; |
|
2261 _LIT8( KResultComplete, "ManualNetworkSelectionCancel Completed" ); |
|
2262 iNWELog->Log((TDesC8)KResultComplete ); |
|
2263 |
|
2264 Signal( aResult ); |
|
2265 } |
|
2266 } |
|
2267 |
|
2268 // ----------------------------------------------------------------------------- |
|
2269 // CNWE::Notify network connection failure |
|
2270 // ----------------------------------------------------------------------------- |
|
2271 // |
|
2272 TInt CNWE::NotifyNetworkConnectionFailure( CStifItemParser& aItem ) |
|
2273 { |
|
2274 iNWELog->Log(_L8("CNWE::NotifyNetworkConnectionFailure") ); |
|
2275 iNetworkFailureTestOnGoing = ETrue; |
|
2276 |
|
2277 if ( iHandleSpecifiedRequests ) |
|
2278 { |
|
2279 TPtrC string; |
|
2280 |
|
2281 aItem.GetNextString( string ); |
|
2282 nspsIsOffOnForComparison = EFalse; |
|
2283 if ( _L("NSPS_IS_ON") == string ) |
|
2284 { |
|
2285 nspsIsOffOnForComparison = ETrue; |
|
2286 } |
|
2287 |
|
2288 aItem.GetNextString( string ); |
|
2289 if ( ( _L("NET_REG_STATUS_NOSERV_NOSIM") == string ) || |
|
2290 ( _L("NET_REG_STATUS_NOSERV_SIM_REJECTED_BY_NW") == string ) ) |
|
2291 { |
|
2292 iNWRegStatusForComparison = RMobilePhone::ERegistrationDenied; |
|
2293 } |
|
2294 } |
|
2295 |
|
2296 return KErrNone; |
|
2297 } |
|
2298 |
|
2299 // ----------------------------------------------------------------------------- |
|
2300 // CNWE::Complete NotifyNetworkConnectionFailure |
|
2301 // ----------------------------------------------------------------------------- |
|
2302 // |
|
2303 void CNWE::CompleteNotifyNetworkConnectionFailure( TInt aResult/*, CMmDataPackage&*/ /*aData*/) |
|
2304 { |
|
2305 iNWELog->Log(_L8("CNWE::CompleteNotifyNetworkConnectionFailure, err=%d"),aResult); |
|
2306 |
|
2307 if ( ( iNetworkFailureTestOnGoing ) || |
|
2308 ( iHandleSpecifiedRequests ) ) |
|
2309 { |
|
2310 iNetworkFailureTestOnGoing = EFalse; |
|
2311 iNWELog->Log(_L8("CNWE::CompleteNotifyNetworkConnectionFailure") ); |
|
2312 Signal( aResult ); |
|
2313 } |
|
2314 } |
|
2315 |
|
2316 // ----------------------------------------------------------------------------- |
|
2317 // CNWE::GetNetworkInfo |
|
2318 // GetNetworkInfo method function. |
|
2319 // ----------------------------------------------------------------------------- |
|
2320 // |
|
2321 TInt CNWE::GetNetworkInfo( CStifItemParser& aItem ) |
|
2322 { |
|
2323 _LIT8(KGetNetworkInfo, "CNWE::GetNetworkInfo" ); |
|
2324 iNWELog->Log((TDesC8)KGetNetworkInfo ); |
|
2325 |
|
2326 TInt ret( KErrNotFound ); |
|
2327 |
|
2328 iNetworkModeTestOnGoing = ETrue; |
|
2329 |
|
2330 TBool supported( ETrue ); |
|
2331 |
|
2332 TPtrC function; |
|
2333 TPtrC mode; |
|
2334 TPtrC onlyComparisonValue; |
|
2335 |
|
2336 aItem.GetNextString( function ); |
|
2337 aItem.GetNextString( mode ); |
|
2338 aItem.GetNextString( onlyComparisonValue ); |
|
2339 |
|
2340 // Set "supported" as "EFalse" so comparison value for complete value checking |
|
2341 // is set. |
|
2342 if ( _L("SET_ONLY_COMPARISON_VALUE") == onlyComparisonValue ) |
|
2343 { |
|
2344 supported = EFalse; |
|
2345 ret = KErrNone; |
|
2346 iNetworkModeTestOnGoing = EFalse; |
|
2347 } |
|
2348 |
|
2349 if ( function == _L( "NetworkMode" ) ) |
|
2350 { |
|
2351 if ( _L( "NetworkModeUnknown" ) == mode ) |
|
2352 { |
|
2353 iNetworkModeStatus[0] = RMobilePhone::ENetworkModeUnknown; |
|
2354 } |
|
2355 else if ( _L( "NetworkModeUnregistered" ) == mode ) |
|
2356 { |
|
2357 iNetworkModeStatus[0] = RMobilePhone::ENetworkModeUnregistered; |
|
2358 } |
|
2359 else if ( _L( "NetworkModeGsm" ) == mode ) |
|
2360 { |
|
2361 iNetworkModeStatus[0] = RMobilePhone::ENetworkModeGsm; |
|
2362 } |
|
2363 else if ( _L( "NetworkModeAmps" ) == mode ) |
|
2364 { |
|
2365 iNetworkModeStatus[0] = RMobilePhone::ENetworkModeAmps; |
|
2366 } |
|
2367 else if ( _L( "NetworkModeCdma95" ) == mode ) |
|
2368 { |
|
2369 iNetworkModeStatus[0] = RMobilePhone::ENetworkModeCdma95; |
|
2370 } |
|
2371 else if ( _L( "NetworkModeCdma2000" ) == mode ) |
|
2372 { |
|
2373 iNetworkModeStatus[0] = RMobilePhone::ENetworkModeCdma2000; |
|
2374 } |
|
2375 else if ( _L( "NetworkModeWcdma" ) == mode ) |
|
2376 { |
|
2377 iNetworkModeStatus[0] = RMobilePhone::ENetworkModeWcdma; |
|
2378 } |
|
2379 else |
|
2380 { |
|
2381 iNWELog->Log( _L8("Selected network mode not supported") ); |
|
2382 supported = EFalse; |
|
2383 } |
|
2384 } |
|
2385 else if ( function == _L( "LocationArea" ) ) |
|
2386 { |
|
2387 if ( _L( "True" ) == mode ) |
|
2388 { |
|
2389 iLocationAreaKnown[0] = ETrue; |
|
2390 } |
|
2391 else if ( _L( "False" ) == mode ) |
|
2392 { |
|
2393 iLocationAreaKnown[0] = EFalse; |
|
2394 } |
|
2395 else |
|
2396 { |
|
2397 iNWELog->Log( _L8("Selected area mode not supported") ); |
|
2398 supported = EFalse; |
|
2399 } |
|
2400 } |
|
2401 else |
|
2402 { |
|
2403 iNWELog->Log( _L8("Selected mode not supported") ); |
|
2404 supported = EFalse; |
|
2405 } |
|
2406 |
|
2407 if ( supported ) |
|
2408 { |
|
2409 if ( function == _L( "NetworkMode" ) ) |
|
2410 { |
|
2411 ret = HandleRequestL( EMobilePhoneGetNetworkRegistrationStatus ); |
|
2412 } |
|
2413 else |
|
2414 { |
|
2415 ret = HandleRequestL( ECustomGetOperatorNameIPC ); |
|
2416 } |
|
2417 |
|
2418 if ( KErrNone == ret ) |
|
2419 { |
|
2420 _LIT8( KResultOk, "GetNetworkInfo request send ok" ); |
|
2421 iNWELog->Log((TDesC8)KResultOk); |
|
2422 } |
|
2423 else |
|
2424 { |
|
2425 _LIT8( KResultFail, "GetNetworkInfo request send fails: %d" ); |
|
2426 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
2427 } |
|
2428 } |
|
2429 |
|
2430 return ret; |
|
2431 } |
|
2432 |
|
2433 // ----------------------------------------------------------------------------- |
|
2434 // CNWE::SetNetworkInfo |
|
2435 // Setting network info |
|
2436 // ----------------------------------------------------------------------------- |
|
2437 // |
|
2438 void CNWE::SetNetworkInfo( |
|
2439 TInt aResult, |
|
2440 CMmDataPackage* aDataPackage, |
|
2441 TInt aCompletedIpc ) |
|
2442 { |
|
2443 _LIT8(KSetNetworkInfo, "CNWE::SetNetworkInfo" ); |
|
2444 iNWELog->Log((TDesC8)KSetNetworkInfo ); |
|
2445 |
|
2446 iNetworkModeTestOnGoing = EFalse; |
|
2447 |
|
2448 RMobilePhone::TMobilePhoneNetworkInfoV5 networkInfo; |
|
2449 RMobilePhone::TMobilePhoneLocationAreaV1 locationArea; |
|
2450 |
|
2451 if ( aCompletedIpc == EMobilePhoneNotifyCurrentNetworkChange ) |
|
2452 { |
|
2453 aDataPackage->UnPackData( networkInfo, locationArea ); |
|
2454 |
|
2455 _LIT8(KWAreaInfo, "Received location area known: %d" ); |
|
2456 iNWELog->Log((TDesC8)KWAreaInfo, locationArea.iAreaKnown ); |
|
2457 |
|
2458 iLocationAreaKnown[1] = locationArea.iAreaKnown; |
|
2459 |
|
2460 _LIT8(KDAreaInfo, "Expected location area known: %d" ); |
|
2461 iNWELog->Log((TDesC8)KDAreaInfo, iLocationAreaKnown[0] ); |
|
2462 |
|
2463 //if received values correspond to the values given manually |
|
2464 if ( iNetworkModeStatus[0] == iNetworkModeStatus[1] && iLocationAreaKnown[0] == iLocationAreaKnown[1] ) |
|
2465 { |
|
2466 iNWELog->Log( _L8("Values from the network match to the ones been set") ); |
|
2467 Signal( KErrNone ); |
|
2468 } |
|
2469 else |
|
2470 { |
|
2471 iNWELog->Log( _L8("Values from the network doesn't match to the ones been set") ); |
|
2472 |
|
2473 //self made error code that can be easily noticed |
|
2474 Signal( -1111 ); |
|
2475 } |
|
2476 } |
|
2477 else if ( aCompletedIpc == EMobilePhoneNotifyModeChange ) |
|
2478 { |
|
2479 aDataPackage->UnPackData( iNetworkModeStatus[1] ); |
|
2480 |
|
2481 _LIT8(KWNetworkInfo, "Received network mode : %d" ); |
|
2482 iNWELog->Log((TDesC8)KWNetworkInfo, iNetworkModeStatus[1] ); |
|
2483 |
|
2484 _LIT8(KDNetworkInfo, "Expected network mode : %d" ); |
|
2485 iNWELog->Log((TDesC8)KDNetworkInfo, iNetworkModeStatus[0] ); |
|
2486 |
|
2487 //initialize values for a new test |
|
2488 iNetworkModeStatus[0] = RMobilePhone::ENetworkModeUnknown; |
|
2489 iNetworkModeStatus[1] = RMobilePhone::ENetworkModeUnknown; |
|
2490 iLocationAreaKnown[0] = EFalse; |
|
2491 iLocationAreaKnown[1] = EFalse; |
|
2492 |
|
2493 Signal( aResult ); |
|
2494 } |
|
2495 } |
|
2496 |
|
2497 // ----------------------------------------------------------------------------- |
|
2498 // CNWE::WaitForCallStatusChange |
|
2499 // WaitForCallStatusChange method function. |
|
2500 // ----------------------------------------------------------------------------- |
|
2501 // |
|
2502 TInt CNWE::WaitForCallStatusChange( CStifItemParser& /*aItem*/ ) |
|
2503 { |
|
2504 _LIT8(KManualNetworkSelection, "CNWE::WaitForCallStatusChange" ); |
|
2505 iNWELog->Log((TDesC8)KManualNetworkSelection ); |
|
2506 |
|
2507 TInt ret( KErrNone ); |
|
2508 |
|
2509 return ret; |
|
2510 } |
|
2511 |
|
2512 // ----------------------------------------------------------------------------- |
|
2513 // CNWE::CompleteCallStatusChange |
|
2514 // Comolete call status change |
|
2515 // ----------------------------------------------------------------------------- |
|
2516 // |
|
2517 void CNWE::CompleteCallStatusChange( |
|
2518 TInt aResult, |
|
2519 CMmDataPackage* aDataPackage ) |
|
2520 { |
|
2521 iNWELog->Log(_L8("CNWE::CompleteCallStatusChange, err=%d"),aResult); |
|
2522 |
|
2523 RMobileCall::TMobileCallStatus* callStatus; |
|
2524 aDataPackage->UnPackData( &callStatus ); |
|
2525 |
|
2526 switch( *callStatus ) |
|
2527 { |
|
2528 case RMobileCall::EStatusConnected: |
|
2529 { |
|
2530 _LIT8(KConnected, "Call Status: Connected" ); |
|
2531 iNWELog->Log((TDesC8)KConnected ); |
|
2532 Signal( aResult ); |
|
2533 break; |
|
2534 } |
|
2535 case RMobileCall::EStatusIdle: |
|
2536 { |
|
2537 _LIT8(KIdle, "Call Status: Idle" ); |
|
2538 iNWELog->Log((TDesC8)KIdle ); |
|
2539 Signal( aResult ); |
|
2540 break; |
|
2541 } |
|
2542 default: |
|
2543 { |
|
2544 break; |
|
2545 } |
|
2546 } |
|
2547 } |
|
2548 |
|
2549 // ----------------------------------------------------------------------------- |
|
2550 // CNWE::GetCellInfo |
|
2551 // GetCellInfo method function. |
|
2552 // ----------------------------------------------------------------------------- |
|
2553 // |
|
2554 TInt CNWE::GetCellInfo( CStifItemParser& aItem ) |
|
2555 { |
|
2556 _LIT8(KGetCellInfo, "CNWE::GetCellInfo" ); |
|
2557 iNWELog->Log((TDesC8)KGetCellInfo ); |
|
2558 |
|
2559 TInt ret( KErrNotFound ); |
|
2560 TInt temp; |
|
2561 |
|
2562 // Indexes used in parameter validation |
|
2563 aItem.GetNextInt( iNmrListIndex ); |
|
2564 aItem.GetNextInt( iDetailedCellInfoIndex ); |
|
2565 |
|
2566 // Store given parameters |
|
2567 aItem.GetNextInt( |
|
2568 iRefECIDInfo.iCellInfo.iWcdmaCellInfo.iPrimaryScrambilingCode ); |
|
2569 aItem.GetNextInt( |
|
2570 iRefECIDInfo.iCellInfo.iWcdmaCellInfo.iFrequencyInfo.iFddDL ); |
|
2571 |
|
2572 aItem.GetNextInt( temp ); |
|
2573 iRefECIDInfo.iCellInfo.iWcdmaCellInfo.iNwkMeasureReport[iNmrListIndex]. |
|
2574 iCarrierRSSI = temp; |
|
2575 |
|
2576 aItem.GetNextInt( temp ); |
|
2577 iRefECIDInfo.iCellInfo.iWcdmaCellInfo.iNwkMeasureReport[iNmrListIndex]. |
|
2578 iCellMeasuredResult[iDetailedCellInfoIndex].iCID = temp; |
|
2579 |
|
2580 ret = HandleRequestL( ECustomGetCellInfoIPC ); |
|
2581 |
|
2582 if ( KErrNone == ret ) |
|
2583 { |
|
2584 _LIT8( KResultOk, "GetCellInfo request send ok" ); |
|
2585 iNWELog->Log((TDesC8)KResultOk); |
|
2586 } |
|
2587 else |
|
2588 { |
|
2589 _LIT8( KResultFail, "GetCellInfo request send fails: %d" ); |
|
2590 iNWELog->Log((TDesC8)KResultFail, ret ); |
|
2591 } |
|
2592 |
|
2593 return ret; |
|
2594 } |
|
2595 |
|
2596 // ----------------------------------------------------------------------------- |
|
2597 // CNWE::CompleteGetCellInfo |
|
2598 // Complete GetCellInfo method function. |
|
2599 // ----------------------------------------------------------------------------- |
|
2600 // |
|
2601 void CNWE::CompleteGetCellInfo( TInt aResult, CMmDataPackage* aDataPackage ) |
|
2602 { |
|
2603 _LIT8( KResult, "CNWE::CompleteGetCellInfo, result: %d" ); |
|
2604 iNWELog->Log( ( TDesC8 ) KResult, aResult ); |
|
2605 |
|
2606 TECIDInfo tempECIDInfo; |
|
2607 aDataPackage->UnPackData( tempECIDInfo.iCellInfo ); |
|
2608 |
|
2609 // Check parameters |
|
2610 if ( tempECIDInfo.iCellInfo.iWcdmaCellInfo.iPrimaryScrambilingCode != |
|
2611 iRefECIDInfo.iCellInfo.iWcdmaCellInfo.iPrimaryScrambilingCode || |
|
2612 |
|
2613 tempECIDInfo.iCellInfo.iWcdmaCellInfo.iFrequencyInfo.iFddDL != |
|
2614 iRefECIDInfo.iCellInfo.iWcdmaCellInfo.iFrequencyInfo.iFddDL || |
|
2615 |
|
2616 tempECIDInfo.iCellInfo.iWcdmaCellInfo.iNwkMeasureReport[iNmrListIndex]. |
|
2617 iCarrierRSSI != |
|
2618 iRefECIDInfo.iCellInfo.iWcdmaCellInfo. |
|
2619 iNwkMeasureReport[iNmrListIndex].iCarrierRSSI || |
|
2620 |
|
2621 tempECIDInfo.iCellInfo.iWcdmaCellInfo.iNwkMeasureReport[iNmrListIndex]. |
|
2622 iCellMeasuredResult[iDetailedCellInfoIndex].iCID != |
|
2623 iRefECIDInfo.iCellInfo.iWcdmaCellInfo. |
|
2624 iNwkMeasureReport[iNmrListIndex]. |
|
2625 iCellMeasuredResult[iDetailedCellInfoIndex].iCID ) |
|
2626 { |
|
2627 aResult = KErrGeneral; |
|
2628 _LIT8( KResult, "CNWE::CompleteGetCellInfo, Error: Invalid parameter" ); |
|
2629 iNWELog->Log( ( TDesC8 ) KResult ); |
|
2630 } |
|
2631 |
|
2632 Signal( aResult ); |
|
2633 } |
|
2634 |
|
2635 // not suppoted for S60 ver 3.2 |
|
2636 #if ( NCP_COMMON_S60_VERSION_SUPPORT != S60_VERSION_32 ) |
|
2637 |
|
2638 // ----------------------------------------------------------------------------- |
|
2639 // CNWE::CustomSetBandSelectionL |
|
2640 // CustomSetBandSelection method function. |
|
2641 // ----------------------------------------------------------------------------- |
|
2642 // |
|
2643 TInt CNWE::CustomSetBandSelectionL( CStifItemParser& aItem ) |
|
2644 { |
|
2645 _LIT8( KCustomSetBandSelection, "CNWE::CustomSetBandSelectionL" ); |
|
2646 iNWELog->Log( ( TDesC8 ) KCustomSetBandSelection ); |
|
2647 |
|
2648 TInt ret( KErrNone ); |
|
2649 |
|
2650 TPtrC modeString; |
|
2651 aItem.GetNextString( modeString ); |
|
2652 |
|
2653 TPtrC bandString; |
|
2654 aItem.GetNextString( bandString ); |
|
2655 |
|
2656 if ( _L( "NetworkUmts" ) == modeString ) |
|
2657 { |
|
2658 _LIT8( KNetworkUmts, "KCapsNetworkModeUmts" ); |
|
2659 iNWELog->Log( ( TDesC8 ) KNetworkUmts ); |
|
2660 iNetworkModeCaps = RMmCustomAPI::KCapsNetworkModeUmts; |
|
2661 } |
|
2662 else if ( _L( "NetworkDual" ) == modeString ) |
|
2663 { |
|
2664 _LIT8( KNetworkDual, "KCapsNetworkModeDual" ); |
|
2665 iNWELog->Log( ( TDesC8 ) KNetworkDual ); |
|
2666 iNetworkModeCaps = RMmCustomAPI::KCapsNetworkModeDual; |
|
2667 } |
|
2668 else |
|
2669 { |
|
2670 _LIT8( KFail, "CustomSetBandSelection, Unknown Mode" ); |
|
2671 iNWELog->Log( ( TDesC8 ) KFail ); |
|
2672 ret = KErrNotSupported; |
|
2673 } |
|
2674 |
|
2675 if ( _L( "BandAny" ) == bandString ) |
|
2676 { |
|
2677 _LIT8( KBandAny, "ENetworkBandAny" ); |
|
2678 iNWELog->Log( ( TDesC8 ) KBandAny ); |
|
2679 iNetworkBand = RMmCustomAPI::ENetworkBandAny; |
|
2680 } |
|
2681 else if ( _L( "Band850" ) == bandString ) |
|
2682 { |
|
2683 _LIT8( KBand850, "ENetworkBandUmts850" ); |
|
2684 iNWELog->Log( ( TDesC8 ) KBand850 ); |
|
2685 iNetworkBand = RMmCustomAPI::ENetworkBandUmts850; |
|
2686 } |
|
2687 else if ( _L( "Band2100" ) == bandString ) |
|
2688 { |
|
2689 _LIT8( KBand2100, "ENetworkBandUmts2100" ); |
|
2690 iNWELog->Log( ( TDesC8 ) KBand2100 ); |
|
2691 iNetworkBand = RMmCustomAPI::ENetworkBandUmts2100; |
|
2692 } |
|
2693 else |
|
2694 { |
|
2695 _LIT8( KFail, "CustomSetBandSelection, Unknown Band" ); |
|
2696 iNWELog->Log( ( TDesC8 ) KFail ); |
|
2697 ret = KErrNotSupported; |
|
2698 } |
|
2699 |
|
2700 if ( KErrNone == ret ) |
|
2701 { |
|
2702 CMmDataPackage dataPackage; |
|
2703 dataPackage.PackData( &iNetworkBand, &iNetworkModeCaps ); |
|
2704 |
|
2705 ret = HandleRequestL( ECustomSetBandSelectionIPC, &dataPackage ); |
|
2706 |
|
2707 iCustomSetBandSelectionOngoing = ETrue; |
|
2708 |
|
2709 if ( KErrNone == ret ) |
|
2710 { |
|
2711 _LIT8( KResultOk, "CustomSetBandSelection, Request send ok" ); |
|
2712 iNWELog->Log( ( TDesC8 ) KResultOk ); |
|
2713 } |
|
2714 else |
|
2715 { |
|
2716 _LIT8( KResultFail, |
|
2717 "CustomSetBandSelection, Request send failed: %d" ); |
|
2718 iNWELog->Log( ( TDesC8 ) KResultFail, ret ); |
|
2719 } |
|
2720 } |
|
2721 |
|
2722 return ret; |
|
2723 } |
|
2724 |
|
2725 // ----------------------------------------------------------------------------- |
|
2726 // CNWE::CompleteCustomSetBandSelection |
|
2727 // Complete CustomSetBandSelection method function. |
|
2728 // ----------------------------------------------------------------------------- |
|
2729 // |
|
2730 void CNWE::CompleteCustomSetBandSelection( TInt aResult ) |
|
2731 { |
|
2732 _LIT8( KResult, "CNWE::CompleteCustomSetBandSelection, result: %d" ); |
|
2733 iNWELog->Log( ( TDesC8 ) KResult, aResult ); |
|
2734 |
|
2735 if ( ( iCustomSetBandSelectionOngoing ) || |
|
2736 ( iHandleSpecifiedRequests ) ) |
|
2737 { |
|
2738 iCustomSetBandSelectionOngoing = EFalse; |
|
2739 |
|
2740 _LIT8( KResultComplete, "CustomSetBandSelection, Completed" ); |
|
2741 iNWELog->Log( ( TDesC8 ) KResultComplete ); |
|
2742 iNWELog->Log( ( TDesC8 ) KLine ); |
|
2743 |
|
2744 Signal( aResult ); |
|
2745 } |
|
2746 } |
|
2747 |
|
2748 // ----------------------------------------------------------------------------- |
|
2749 // CNWE::CustomGetBandSelectionL |
|
2750 // CustomGetBandSelection method function. |
|
2751 // ----------------------------------------------------------------------------- |
|
2752 // |
|
2753 TInt CNWE::CustomGetBandSelectionL( CStifItemParser& aItem ) |
|
2754 { |
|
2755 _LIT8( KCustomGetBandSelection, "CNWE::CustomGetBandSelectionL" ); |
|
2756 iNWELog->Log( ( TDesC8 ) KCustomGetBandSelection ); |
|
2757 |
|
2758 TPtrC modeString; |
|
2759 aItem.GetNextString( modeString ); |
|
2760 |
|
2761 TPtrC bandString; |
|
2762 aItem.GetNextString( bandString ); |
|
2763 |
|
2764 TInt ret( KErrNone ); |
|
2765 |
|
2766 if ( _L( "NetworkUmts" ) == modeString ) |
|
2767 { |
|
2768 _LIT8( KNetworkUmts, "KCapsNetworkModeUmts" ); |
|
2769 iNWELog->Log( ( TDesC8 ) KNetworkUmts ); |
|
2770 iNetworkModeCaps = RMmCustomAPI::KCapsNetworkModeUmts; |
|
2771 } |
|
2772 else if ( _L( "NetworkDual" ) == modeString ) |
|
2773 { |
|
2774 _LIT8( KNetworkDual, "KCapsNetworkModeDual" ); |
|
2775 iNWELog->Log( ( TDesC8 ) KNetworkDual ); |
|
2776 iNetworkModeCaps = RMmCustomAPI::KCapsNetworkModeDual; |
|
2777 } |
|
2778 else if ( _L( "NetworkGsm" ) == modeString ) |
|
2779 { |
|
2780 _LIT8( KNetworkGsm, "KCapsNetworkModeGsm" ); |
|
2781 iNWELog->Log( ( TDesC8 ) KNetworkGsm ); |
|
2782 iNetworkModeCaps = RMmCustomAPI::KCapsNetworkModeGsm; |
|
2783 } |
|
2784 else |
|
2785 { |
|
2786 _LIT8( KFail, "CustomSetBandSelection, Unknown network mode" ); |
|
2787 iNWELog->Log( ( TDesC8 ) KFail ); |
|
2788 ret = KErrNotSupported; |
|
2789 } |
|
2790 |
|
2791 if ( _L( "BandAny" ) == bandString ) |
|
2792 { |
|
2793 _LIT8( KBandAny, "ENetworkBandAny" ); |
|
2794 iNWELog->Log( ( TDesC8 ) KBandAny ); |
|
2795 iNetworkBand = RMmCustomAPI::ENetworkBandAny; |
|
2796 } |
|
2797 else if ( _L( "Band850" ) == bandString ) |
|
2798 { |
|
2799 _LIT8( KBand850, "ENetworkBandUmts850" ); |
|
2800 iNWELog->Log( ( TDesC8 ) KBand850 ); |
|
2801 iNetworkBand = RMmCustomAPI::ENetworkBandUmts850; |
|
2802 } |
|
2803 else if ( _L( "Band2100" ) == bandString ) |
|
2804 { |
|
2805 _LIT8( KBand2100, "ENetworkBandUmts2100" ); |
|
2806 iNWELog->Log( ( TDesC8 ) KBand2100 ); |
|
2807 iNetworkBand = RMmCustomAPI::ENetworkBandUmts2100; |
|
2808 } |
|
2809 else |
|
2810 { |
|
2811 _LIT8( KFail, "CustomSetBandSelection, Unknown Band. Test case will not support type like this."); |
|
2812 iNWELog->Log( ( TDesC8 ) KFail ); |
|
2813 ret = KErrNotSupported; |
|
2814 } |
|
2815 |
|
2816 ret = HandleRequestL( ECustomGetBandSelectionIPC ); |
|
2817 iCustomGetBandSelectionOngoing = ETrue; |
|
2818 |
|
2819 if ( KErrNone == ret ) |
|
2820 { |
|
2821 _LIT8( KResultOk, "CustomGetBandSelection, Request send ok" ); |
|
2822 iNWELog->Log( ( TDesC8 ) KResultOk ); |
|
2823 } |
|
2824 else |
|
2825 { |
|
2826 _LIT8( KResultFail, "CustomGetBandSelection, Request failed: %d" ); |
|
2827 iNWELog->Log( ( TDesC8 ) KResultFail, ret ); |
|
2828 } |
|
2829 |
|
2830 return ret; |
|
2831 } |
|
2832 |
|
2833 // ----------------------------------------------------------------------------- |
|
2834 // CNWE::CompleteCustomGetBandSelection |
|
2835 // Complete CustomGetBandSelection method function. |
|
2836 // ----------------------------------------------------------------------------- |
|
2837 // |
|
2838 void CNWE::CompleteCustomGetBandSelection( |
|
2839 TInt aResult, |
|
2840 CMmDataPackage* aDataPackage ) |
|
2841 { |
|
2842 // checking results and unpacking message |
|
2843 _LIT8( KResult, "CNWE::CompleteCustomGetBandSelection, result: %d" ); |
|
2844 iNWELog->Log( ( TDesC8 ) KResult, aResult ); |
|
2845 |
|
2846 if ( KErrNone == aResult ) |
|
2847 { |
|
2848 RMmCustomAPI::TNetworkModeCaps networkModeCaps; |
|
2849 RMmCustomAPI::TBandSelection networkBand; |
|
2850 |
|
2851 aDataPackage->UnPackData( networkBand, networkModeCaps ); |
|
2852 |
|
2853 iNWELog->Log( ( TDesC8 ) KLine ); |
|
2854 _LIT8( KBandSel, "Selected band: %d" ); |
|
2855 iNWELog->Log( ( TDesC8 ) KBandSel, iNetworkBand ); |
|
2856 |
|
2857 if ( networkBand != iNetworkBand ) |
|
2858 { |
|
2859 _LIT8( KNWBandError, "Network band mismatched" ); |
|
2860 iNWELog->Log( ( TDesC8 ) KNWBandError ); |
|
2861 aResult = KErrGeneral; |
|
2862 } |
|
2863 |
|
2864 if ( networkModeCaps != iNetworkModeCaps ) |
|
2865 { |
|
2866 _LIT8( KNWModeError, "Network band mode mismatched" ); |
|
2867 iNWELog->Log( ( TDesC8 ) KNWModeError ); |
|
2868 aResult = KErrArgument; |
|
2869 } |
|
2870 |
|
2871 iNWELog->Log( ( TDesC8 ) KLine ); |
|
2872 } |
|
2873 else |
|
2874 { |
|
2875 _LIT8( KResultFail, "CompleteCustomGetBandSelection, Failed: %d" ); |
|
2876 iNWELog->Log( ( TDesC8 ) KResultFail, aResult ); |
|
2877 } |
|
2878 |
|
2879 if ( ( iCustomGetBandSelectionOngoing ) || |
|
2880 ( iHandleSpecifiedRequests ) ) |
|
2881 { |
|
2882 iCustomGetBandSelectionOngoing = EFalse; |
|
2883 |
|
2884 _LIT8( KResultComplete, "CustomGetBandSelection, Completed" ); |
|
2885 iNWELog->Log( ( TDesC8 ) KResultComplete ); |
|
2886 |
|
2887 Signal( aResult ); |
|
2888 } |
|
2889 } |
|
2890 |
|
2891 #endif //NCP_COMMON_S60_VERSION_SUPPORT |
|
2892 |
|
2893 // ----------------------------------------------------------------------------- |
|
2894 // CNWE::NotifyPrivacyConfirmation |
|
2895 // EMobileCallNotifyPrivacyConfirmation |
|
2896 // ----------------------------------------------------------------------------- |
|
2897 // |
|
2898 void CNWE::NotifyPrivacyConfirmation( |
|
2899 TInt aResult, // Completion result value |
|
2900 CMmDataPackage* aDataPackage // pointer to DataPackage |
|
2901 ) |
|
2902 { |
|
2903 _LIT8( KNotifyPrivacyConfirmation, "CNWE::NotifyPrivacyConfirmation" ); |
|
2904 iNWELog->Log( ( TDesC8 ) KNotifyPrivacyConfirmation ); |
|
2905 |
|
2906 RMobilePhone::TMobilePhonePrivacy status; |
|
2907 aDataPackage->UnPackData( status ); |
|
2908 |
|
2909 if ( status != RMobilePhone::EPrivacyOn ) |
|
2910 { |
|
2911 aResult = KErrGeneral; |
|
2912 } |
|
2913 |
|
2914 Signal( aResult ); |
|
2915 } |
|
2916 |
|
2917 // ----------------------------------------------------------------------------- |
|
2918 // CNWE::NotifyCipheringInfoChangeIPC |
|
2919 // ECustomNotifyCipheringInfoChangeIPC |
|
2920 // ----------------------------------------------------------------------------- |
|
2921 // |
|
2922 void CNWE::NotifyCipheringInfoChangeIPC( |
|
2923 TInt aResult, // Completion result value |
|
2924 CMmDataPackage* aDataPackage // pointer to DataPackage |
|
2925 ) |
|
2926 { |
|
2927 _LIT8( KNotifyCipheringInfoChangeIPC, "CNWE::NotifyCipheringInfoChangeIPC" ); |
|
2928 iNWELog->Log( ( TDesC8 ) KNotifyCipheringInfoChangeIPC ); |
|
2929 |
|
2930 TBool cipherIndicatorStatus( EFalse ); |
|
2931 TBool cipheringOn( EFalse ); |
|
2932 aDataPackage->UnPackData( cipherIndicatorStatus, cipheringOn ); |
|
2933 |
|
2934 // Expected that both are ETrue |
|
2935 if ( ( !cipherIndicatorStatus ) || |
|
2936 ( !cipheringOn ) ) |
|
2937 { |
|
2938 aResult = KErrGeneral; |
|
2939 } |
|
2940 |
|
2941 Signal( aResult ); |
|
2942 } |
|
2943 |
|
2944 // ----------------------------------------------------------------------------- |
|
2945 // CNWE::NotifyNSPSStatusIPC |
|
2946 // ECustomNotifyNSPSStatusIPC |
|
2947 // ----------------------------------------------------------------------------- |
|
2948 // |
|
2949 void CNWE::NotifyNSPSStatusIPC |
|
2950 ( |
|
2951 TInt aResult, // Completion result value |
|
2952 CMmDataPackage* aDataPackage // pointer to DataPackage |
|
2953 ) |
|
2954 { |
|
2955 _LIT8( KNotifyNSPSStatusIPC, "CNWE::NotifyNSPSStatusIPC" ); |
|
2956 iNWELog->Log( ( TDesC8 ) KNotifyNSPSStatusIPC ); |
|
2957 |
|
2958 TBool nspsIsOn ( EFalse ); |
|
2959 aDataPackage->UnPackData ( nspsIsOn ); |
|
2960 |
|
2961 if ( nspsIsOn != nspsIsOffOnForComparison ) |
|
2962 { |
|
2963 aResult = KErrGeneral; |
|
2964 } |
|
2965 |
|
2966 Signal( aResult ); |
|
2967 } |
|
2968 |
|
2969 // ----------------------------------------------------------------------------- |
|
2970 // CNWE::SetShortAndLongOperNameL |
|
2971 // SetShortAndLongOperName method function. |
|
2972 // ----------------------------------------------------------------------------- |
|
2973 // |
|
2974 TInt CNWE::SetShortAndLongOperNameL( CStifItemParser& aItem ) |
|
2975 { |
|
2976 _LIT8( KSetShortAndLongOperName, "CNWE::SetShortAndLongOperNameL"); |
|
2977 iNWELog->Log((TDesC8)KSetShortAndLongOperName); |
|
2978 |
|
2979 TPtrC string; |
|
2980 |
|
2981 aItem.GetNextString( string ); |
|
2982 iSavedShortNameForComparison[0].Zero(); |
|
2983 iSavedShortNameForComparison[0].Append( string ); |
|
2984 |
|
2985 aItem.GetNextString( string ); |
|
2986 iSavedLongNameForComparison[0].Zero(); |
|
2987 iSavedLongNameForComparison[0].Append( string ); |
|
2988 |
|
2989 return KErrNone; |
|
2990 } |
|
2991 |
|
2992 // End of File |
|