|
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 "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: Implementation of RVmbxNumber class. |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INCLUDE FILES |
|
20 |
|
21 #include <vmnumber.h> |
|
22 #include <e32std.h> |
|
23 #include <avkon.hrh> |
|
24 #include <bautils.h> |
|
25 #include <eikenv.h> |
|
26 #include <commonphoneparser.h> |
|
27 #include <aknnotewrappers.h> |
|
28 #include <StringLoader.h> |
|
29 #include <data_caging_path_literals.hrh> |
|
30 #include <PhCltUtils.h> |
|
31 #include <vmbx.rsg> |
|
32 // includes for phonebook search |
|
33 #include <cphonecntfactory.h> |
|
34 #include <cphcntsingleitemfetch.h> |
|
35 #include <featmgr.h> |
|
36 #include <AknIconArray.h> |
|
37 #include <AknsUtils.h> |
|
38 |
|
39 #ifdef RD_STARTUP_CHANGE |
|
40 #include <startupdomainpskeys.h>//for KPSSimStatus |
|
41 #endif |
|
42 |
|
43 #include <AknQueryDialog.h> |
|
44 |
|
45 /***************************************************** |
|
46 * Series 60 Customer / ETel |
|
47 * Series 60 ETel API |
|
48 *****************************************************/ |
|
49 #include <mpbutil.h> |
|
50 #include <utf.h> //CnvUtfConverter |
|
51 #include "voicemailboxprivatecrkeys.h" |
|
52 #include "voicemailboxdomaincrkeys.h" |
|
53 #include <PSVariables.h> |
|
54 #include <e32property.h> |
|
55 #include "vmdialog.h" |
|
56 #include "vmlist.h" |
|
57 #include "vmblogger.h" |
|
58 #include <vm.mbg> |
|
59 #include "vmspshandler.h" |
|
60 #include "vmbshandler.h" |
|
61 |
|
62 // CONSTANTS |
|
63 const TInt KVmFlagOpened = 0x00000001; |
|
64 const TInt KVmFlagPhoneOpened = 0x00000002; |
|
65 const TInt KVmFlagSimReadSupport = 0x00000004; |
|
66 const TInt KVmFlagPhoneModuleLoaded = 0x00000008; |
|
67 const TInt KVmFlagNotifyRequested = 0x00000010; |
|
68 const TInt KVmFlagNotifyOnActiveLineOnly = 0x00000020; |
|
69 const TInt KVmFlagPhonebookBeingCached = 0x00000040; |
|
70 const TInt KVmFlagSimWriteSupport = 0x00000080; |
|
71 const TInt KVmFlagSimVmbxNumSupport = 0x00000100; |
|
72 // Flag of external API saving number to phone |
|
73 const TInt KForceSavedToPhoneMem = 0x00000400; |
|
74 |
|
75 //flag of CS defined number |
|
76 const TInt KVmFlagCSNumberDefined = 0x00000001; |
|
77 //flag of Vedio defined number |
|
78 const TInt KVmFlagVideoNumberDefined = 0x00000002; |
|
79 //flag of VoIP defined number |
|
80 const TInt KVmFlagVoIpNumberDefined = 0x00000004; |
|
81 // phone application uid |
|
82 const TInt KPhoneApplicationUid = 0x100058B3; |
|
83 |
|
84 _LIT (KVmbxResourceFileDrive, "Z:"); |
|
85 // The file directory is in literal KDC_RESOURCE_FILES_DIR |
|
86 // (in data data_caging_path_literals.hrh) |
|
87 _LIT (KVmbxResourceFileName, "Vmbx.rsc"); |
|
88 |
|
89 // Phonebook entry name |
|
90 _LIT( KVmbxPhoneBookEntryName, "Vmbx" ); // If changed, remember to update |
|
91 // the size of KVmbxPhoneBookEntryNameLength in VmNumber.h |
|
92 const TInt KVmbxPhonebookRetriesIfInUse = 20; |
|
93 const TInt KVmbxPhonebookRetryDelay = 100000; // 0.1s |
|
94 |
|
95 const TInt KVmbxPhonebookBufferSize = 150; // Estimated max size 128 |
|
96 |
|
97 _LIT( KVmbxOnePlus, "1" ); |
|
98 |
|
99 // Format of the IAP selection list query. |
|
100 _LIT( KQueryItemFormat, "%d\t%S" ); |
|
101 //for the mbm file |
|
102 _LIT( KVmMbmDrive, "Z:" ); |
|
103 _LIT( KVmLibMbmFile, "vm.mbm" ); |
|
104 |
|
105 const TInt KVmNumOverwrite = 1; |
|
106 |
|
107 const TInt KVmNamStoreMDNId = RMobileNamStore::EMobileDirectoryNumber; |
|
108 // MIN is not included in mmetel std params. Third extended param |
|
109 const TInt KVmNamStoreMINId = RMobileNamStore::ENumStandardNamParameters + 3; |
|
110 const TInt KVmPhNumMinLength = 3; |
|
111 const TInt KVmLbxItemsArraySize = 3; |
|
112 const TInt KVmOriginalNumLength = 256; |
|
113 const TInt KVmPhoneNumDigitsMinLength = 2; |
|
114 const TInt KVmPhoneNumDigitsMaxLength = 40; |
|
115 const TInt KVmbxOnlyDefinedOneNumber = 1; |
|
116 const TInt KMailBoxLimitForPrompt = 1; |
|
117 |
|
118 _LIT (KVmbxIllegalSimCharacter, "w"); |
|
119 _LIT (KTestNumber, "12345"); |
|
120 |
|
121 const TInt KVmExtFileSize = 20; |
|
122 const TInt KVmMaxStoreSize = 48; |
|
123 |
|
124 const TInt KDefaultServiceId = 0; // default ServerId |
|
125 const TInt KCSorVideoServiceId = 1; // CS or Video ServerId |
|
126 const TInt KDefaultDefinedNumberCount = 0; // default defined number count |
|
127 |
|
128 // When the define VM_USE_TSY is set, SIM phonebook will be used and |
|
129 // methods won't work if a compatible TSY/DOS environment is not present. |
|
130 |
|
131 /***************************************************** |
|
132 * Series 60 Customer / ETel |
|
133 * Series 60 ETel API |
|
134 *****************************************************/ |
|
135 // & |
|
136 /***************************************************** |
|
137 * Series 60 Customer / ETel |
|
138 * Series 60 ETel API |
|
139 *****************************************************/ |
|
140 |
|
141 #ifndef __WINS__ // SIM phonebook stalls in WINS |
|
142 #define VM_USE_TSY |
|
143 #endif |
|
144 // ================= MEMBER FUNCTIONS ========================================== |
|
145 |
|
146 |
|
147 |
|
148 // ============================ MEMBER FUNCTIONS =============================== |
|
149 |
|
150 // ----------------------------------------------------------------------------- |
|
151 // RVmbxNumber::RVmbxNumber |
|
152 // C++ default constructor can NOT contain any code, that |
|
153 // might leave. |
|
154 // ----------------------------------------------------------------------------- |
|
155 // |
|
156 EXPORT_C RVmbxNumber::RVmbxNumber() : iNotifyCallBack( NULL ), |
|
157 iUserAlsObserver( NULL ), |
|
158 iPhoneBookInfoPckg( iPhoneBookInfo ), |
|
159 iPhoneVoicemailInfoPckg( iPhoneVoicemailInfo ), |
|
160 iRSatSession(), |
|
161 iRSatClient( *this ), |
|
162 iNotifyHandler( NULL ), |
|
163 iSession( NULL ), |
|
164 iResourceFileOffset( 0 ), |
|
165 iFlags( KForceSavedToPhoneMem ), |
|
166 iQuery( NULL ), |
|
167 iClosedPtr( NULL ), |
|
168 iCoeEnv( NULL ), |
|
169 iVmNumOpts( EVmNumOptsBlank ), |
|
170 iVmUiOpts( 0 ), |
|
171 iSynchronize( EFalse ), |
|
172 iType( EVmbxNone ), |
|
173 iVMSimQueryDialog( NULL ), |
|
174 iUSimSupport( EFalse ), |
|
175 iVideoQuery( NULL ), |
|
176 iTypeSelectionQuery( NULL ), |
|
177 iAlphaStringFound( EFalse ), |
|
178 iAlphaStringFromSIM( NULL ), |
|
179 iNumberFound( EFalse ), |
|
180 iUSimFirstRoundTest( ETrue ), |
|
181 iCntFetch( NULL ), |
|
182 iVmSpsHandler( NULL ), |
|
183 iVmBsHandler( NULL ), |
|
184 iFeatMgrInitialized( EFalse ), |
|
185 iSimCardFound( EFalse ) |
|
186 { |
|
187 VMBLOGSTRING( "VMBX: RVmbxNumber::RVmbxNumber =>" ); |
|
188 |
|
189 // Default sets to Phone memory, this can be changed in RVmbxNUmber::Open() |
|
190 iMemoryLocation = EVmbxPhoneMemory; |
|
191 |
|
192 //Create repository and notify handler. |
|
193 TRAPD( error, |
|
194 FeatureManager::InitializeLibL(); |
|
195 iFeatMgrInitialized = ETrue; |
|
196 VMBLOGSTRING( "VMBX: RVmbxNumber::RVmbxNumber: FeatureManager initialized" ); |
|
197 |
|
198 iSession = CRepository::NewL( KCRUidVoiceMailbox ); |
|
199 VMBLOGSTRING( "VMBX: RVmbxNumber::RVmbxNumber: CRepository created" ); |
|
200 |
|
201 if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) ) |
|
202 { |
|
203 iVmSpsHandler = CVmSPSHandler::NewL(); |
|
204 VMBLOGSTRING( "VMBX: RVmbxNumber::RVmbxNumber: CVmSPSHandler created" ); |
|
205 } |
|
206 |
|
207 iVmBsHandler = CVmBSHandler::NewL(); |
|
208 VMBLOGSTRING( "VMBX: RVmbxNumber::RVmbxNumber: CVmBSHandler created" ); |
|
209 ); |
|
210 |
|
211 if ( error != KErrNone ) |
|
212 { |
|
213 VMBLOGSTRING2( "VMBX: RVmbxNumber::RVmbxNumber : \ |
|
214 Initialization error %I", error ); |
|
215 _LIT(KVmbxConstructorPanicType,"RVmbxNumber::RVmbxNumber"); |
|
216 User::Panic( KVmbxConstructorPanicType, error ); |
|
217 } |
|
218 |
|
219 VMBLOGSTRING( "VMBX: RVmbxNumber::RVmbxNumber <=" ); |
|
220 } |
|
221 |
|
222 // ----------------------------------------------------------------------------- |
|
223 // RVmbxNumber::~RVmbxNumber |
|
224 // Destructor |
|
225 // ----------------------------------------------------------------------------- |
|
226 // |
|
227 EXPORT_C RVmbxNumber::~RVmbxNumber() |
|
228 { |
|
229 VMBLOGSTRING( "VMBX: RVmbxNumber::~RVmbxNumber =>" ); |
|
230 |
|
231 if ( iNotifyHandler ) |
|
232 { |
|
233 iNotifyHandler->StopListening(); |
|
234 delete iNotifyHandler; |
|
235 } |
|
236 |
|
237 delete iSession; |
|
238 delete iAlphaStringFromSIM; |
|
239 |
|
240 delete iVmSpsHandler; |
|
241 delete iVmBsHandler; |
|
242 |
|
243 if ( iFeatMgrInitialized ) |
|
244 { |
|
245 FeatureManager::UnInitializeLib(); |
|
246 } |
|
247 |
|
248 VMBLOGSTRING( "VMBX: RVmbxNumber::~RVmbxNumber <=" ); |
|
249 } |
|
250 |
|
251 |
|
252 |
|
253 // ----------------------------------------------------------------------------- |
|
254 // RVmbxNumber::Open |
|
255 // Opens a new ETel connection |
|
256 // ----------------------------------------------------------------------------- |
|
257 // |
|
258 /***************************************************** |
|
259 * Series 60 Customer / ETel |
|
260 * Series 60 ETel API |
|
261 *****************************************************/ |
|
262 EXPORT_C TInt RVmbxNumber::Open() |
|
263 { |
|
264 VMBLOGSTRING( "VMBX: RVmbxNumber::Open =>" ); |
|
265 |
|
266 TInt ret( KErrGeneral ); |
|
267 // initialize the CenRep number in the bankup store |
|
268 ret = BackUpSimNumber( KEmptyVoiceMailNumber, KVmbxTmpNumberLinePrimary ); |
|
269 VMBLOGSTRING2( "RVmbxNumber::Open(): Clear KVmbxTmpNumberLinePrimary result = %d", |
|
270 ret ); |
|
271 ret = BackUpSimNumber( KEmptyVoiceMailNumber, KVmbxTmpNumberLineAuxiliary ); |
|
272 VMBLOGSTRING2( "RVmbxNumber::Open(): Clear KVmbxTmpNumberLineAuxiliary result = %d", |
|
273 ret ); |
|
274 VMBLOGSTRING( "RVmbxNumber::Open(): Clear Tmp numbers from CenRep" ); |
|
275 if ( iFlags & KVmFlagOpened ) |
|
276 { |
|
277 VMBLOGSTRING( "VMBX: RVmbxNumber::Open: Opened already" ); |
|
278 ret = KErrNone; |
|
279 } |
|
280 else |
|
281 { |
|
282 ret = ConnectETelServer(); |
|
283 if ( !ret ) |
|
284 { |
|
285 // try to load ETel TSY module |
|
286 ret = iTelServer.LoadPhoneModule( KMmTsyModuleName ); |
|
287 if ( !ret ) |
|
288 { |
|
289 iFlags |= KVmFlagPhoneModuleLoaded; |
|
290 |
|
291 RTelServer::TPhoneInfo info; |
|
292 ret = iTelServer.GetPhoneInfo( 0, info ); |
|
293 if ( !ret ) |
|
294 { |
|
295 ret = iPhone.Open( iTelServer, info.iName ); |
|
296 if ( !ret ) |
|
297 { |
|
298 iFlags |= KVmFlagPhoneOpened; |
|
299 } |
|
300 } |
|
301 } |
|
302 } |
|
303 |
|
304 if ( !ret ) |
|
305 { |
|
306 ret = Open( iPhone ); |
|
307 } |
|
308 else |
|
309 { |
|
310 Close(); |
|
311 } |
|
312 } |
|
313 VMBLOGSTRING( "VMBX: RVmbxNumber::Open <=" ); |
|
314 return ret; |
|
315 } |
|
316 |
|
317 // ----------------------------------------------------------------------------- |
|
318 // RVmbxNumber::Open |
|
319 // Opens a new ETel connection, when there is existing ETel connection already |
|
320 // ----------------------------------------------------------------------------- |
|
321 // |
|
322 /***************************************************** |
|
323 * Series 60 Customer / ETel |
|
324 * Series 60 ETel API |
|
325 *****************************************************/ |
|
326 EXPORT_C TInt RVmbxNumber::Open( RMobilePhone& aPhone ) |
|
327 { |
|
328 VMBLOGSTRING( "VMBX: RVmbxNumber::Open =>" ); |
|
329 TInt result( KErrNone ); |
|
330 TInt alsline( EAlsLine1 ); |
|
331 |
|
332 if ( iFlags & KVmFlagOpened ) |
|
333 { |
|
334 VMBLOGSTRING( "VMBX: RVmbxNumber::Open: Opened already" ); |
|
335 return KErrNone; |
|
336 } |
|
337 iPhone = aPhone; |
|
338 |
|
339 result = iSession->Get( KVmUsesSimMemory, iMemoryLocation ); |
|
340 |
|
341 if ( KErrNone != result ) |
|
342 { |
|
343 if ( KErrNotFound == result ) |
|
344 { |
|
345 iMemoryLocation = EVmbxPhoneMemory; |
|
346 } |
|
347 else |
|
348 { |
|
349 Close(); |
|
350 VMBLOGSTRING( "VMBX: RVmbxNumber::Open: Memory location error" ); |
|
351 return result; |
|
352 } |
|
353 } |
|
354 |
|
355 VMBLOGSTRING2( "iMemoryLocation = %d", iMemoryLocation ); |
|
356 |
|
357 // Connect to system agent |
|
358 RProperty property; |
|
359 TInt psErr( KErrNone ); |
|
360 |
|
361 #ifdef RD_STARTUP_CHANGE |
|
362 psErr = property.Attach( KPSUidStartup, KPSSimStatus ); |
|
363 #else |
|
364 psErr = property.Attach( KUidSystemCategory, KPSUidSimCStatusValue ); |
|
365 #endif |
|
366 if ( KErrNone != psErr ) |
|
367 { |
|
368 VMBLOGSTRING( "VMBX: RVmbxNumber::Open: SIM status property error" ); |
|
369 return psErr; |
|
370 } |
|
371 |
|
372 result = iSsSettings.Open( NULL ); |
|
373 |
|
374 if ( KErrNone != result ) |
|
375 { |
|
376 Close(); |
|
377 VMBLOGSTRING( "VMBX: RVmbxNumber::Open: SS setting opening error" ); |
|
378 return result; |
|
379 } |
|
380 |
|
381 // ignore error |
|
382 iSsSettings.Register( ESSSettingsAls, *this ); |
|
383 |
|
384 // get the current ALS line |
|
385 if ( KErrNone != GetAlsLine( alsline ) ) |
|
386 { |
|
387 alsline = EAlsLine1; // if problems, assume primary line |
|
388 } |
|
389 |
|
390 #ifdef VM_USE_TSY |
|
391 |
|
392 TInt nValue; |
|
393 psErr = property.Get( nValue ); |
|
394 TBool simStatus = EFalse; |
|
395 iUSimSupport = IsUsimSupport(); |
|
396 VMBLOGSTRING2( "iUSimSupport = %d", iUSimSupport ); |
|
397 // Sim aceess test on startup |
|
398 iStartUpTest = ETrue; |
|
399 #ifdef RD_STARTUP_CHANGE |
|
400 |
|
401 if ( ( FeatureManager::FeatureSupported( KFeatureIdSimCard ) ) |
|
402 && ( ESimNotPresent != nValue ) ) |
|
403 { |
|
404 simStatus = ETrue; |
|
405 } |
|
406 |
|
407 #else //RD_STARTUP_CHANGE |
|
408 |
|
409 if ( ( FeatureManager::FeatureSupported( KFeatureIdSimCard ) ) |
|
410 && ( EPSCSimRemoved != nValue ) ) |
|
411 { |
|
412 simStatus = ETrue; |
|
413 } |
|
414 #endif // RD_STARTUP_CHANGE |
|
415 if ( FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ) ) |
|
416 { |
|
417 if ( iUSimSupport ) |
|
418 { |
|
419 simStatus = ETrue; |
|
420 } |
|
421 } |
|
422 |
|
423 VMBLOGSTRING2( "simStatus = %d", simStatus ); |
|
424 if ( simStatus )//Is simCard supproted and it is not removed |
|
425 { |
|
426 iSimCardFound = ETrue; |
|
427 // If UICC supported, then open USIM phone book. |
|
428 if ( iUSimSupport ) |
|
429 { |
|
430 iMbdnPhonebookOk = EFalse; |
|
431 // Get identifiers from MBI-file |
|
432 if ( EAlsLine1 == alsline ) |
|
433 { |
|
434 result = MailboxNumbersIdentifiers(); |
|
435 VMBLOGSTRING2( "Identifier result = %d", result ); |
|
436 if ( KErrPathNotFound == result ) |
|
437 { |
|
438 // try open vmbx-phonebook next |
|
439 iPhoneBookType = EVMBXPhoneBook; |
|
440 } |
|
441 else |
|
442 { |
|
443 iPhoneBookType = EMBDNPhoneBook; |
|
444 // set ALS line, if identifier reading returns -1 |
|
445 if ( KErrNotFound == result ) |
|
446 { |
|
447 iPhoneVoicemailInfo.iVoice = alsline; |
|
448 } |
|
449 |
|
450 // try to open mbdn-type phonebook |
|
451 result = iPhoneBook.Open( iPhone, KETelIccMbdnPhoneBook ); |
|
452 VMBLOGSTRING2( "Mbdn phonebook opening result = %I ", result ); |
|
453 if ( KErrNone == result ) |
|
454 { |
|
455 // Get phonebook info |
|
456 result = PhoneBookInfo(); |
|
457 } |
|
458 // close phonebook when error in opening or GetInfo |
|
459 if ( KErrNone != result ) |
|
460 { |
|
461 VMBLOGSTRING( "Close MBDN phonebook" ); |
|
462 iPhoneBook.Close(); |
|
463 } |
|
464 // close phonebook when no number founf to test vmbx-phonebook |
|
465 else if ( ( KErrNone == result ) && iNoNumberFound ) |
|
466 { |
|
467 VMBLOGSTRING( "mbdn close, number not found" ); |
|
468 iMbdnPhonebookOk = ETrue; |
|
469 iPhoneBook.Close(); |
|
470 // try open vmbx-phonebook next |
|
471 iPhoneBookType = EVMBXPhoneBook; |
|
472 } |
|
473 } |
|
474 } |
|
475 |
|
476 if ( EAlsLine2 == alsline || EVMBXPhoneBook == iPhoneBookType ) |
|
477 { |
|
478 // try to open vmbx-type phonebook |
|
479 result = iPhoneBook.Open( iPhone, KETelIccVoiceMailBox ); |
|
480 VMBLOGSTRING2( "Vmbx phonebook opening result = %I ", result ); |
|
481 if ( KErrNone == result ) |
|
482 { |
|
483 // check that this phonebook supports reading |
|
484 result = PhoneBookInfo(); |
|
485 VMBLOGSTRING( "VmbxPhoneBook opened" ); |
|
486 } |
|
487 } |
|
488 // reopen mbdn-phonebook when vmbx-phonebook has no number |
|
489 if ( iMbdnPhonebookOk && iNoNumberFound ) |
|
490 { |
|
491 VMBLOGSTRING( "reopen mbdn" ); |
|
492 iPhoneBook.Close(); |
|
493 // try open vmbx-phonebook next |
|
494 iPhoneBookType = EMBDNPhoneBook; |
|
495 // try to open mbdn-type phonebook |
|
496 result = iPhoneBook.Open( iPhone, KETelIccMbdnPhoneBook ); |
|
497 VMBLOGSTRING2( "Mbdn phonebook opening result = %I ", result ); |
|
498 if ( KErrNone == result ) |
|
499 { |
|
500 // Get phonebook info |
|
501 result = PhoneBookInfo(); |
|
502 } |
|
503 // close phonebook when error in opening or GetInfo |
|
504 if ( KErrNone != result ) |
|
505 { |
|
506 VMBLOGSTRING( "Close MBDN phonebook" ); |
|
507 iPhoneBook.Close(); |
|
508 } |
|
509 } |
|
510 } |
|
511 // open SIM book |
|
512 else |
|
513 { |
|
514 // No need to prevent for changing memory location |
|
515 iUSimFirstRoundTest = EFalse; |
|
516 result = iPhoneBook.Open( iPhone, KETelIccVoiceMailBox ); |
|
517 iPhoneBookType = EVMBXPhoneBook; |
|
518 VMBLOGSTRING( "VmbxPhoneBook opened" ); |
|
519 |
|
520 if ( KErrNone == result ) |
|
521 { |
|
522 result = PhoneBookInfo(); |
|
523 } |
|
524 } |
|
525 |
|
526 // set readonly state if aquired |
|
527 if ( IsReadOnlySIM() ) |
|
528 { |
|
529 iFlags &= ~KVmFlagSimWriteSupport; |
|
530 VMBLOGSTRING( "VMBX: RVmbxNumber::Open: ReadOnly set" ); |
|
531 } |
|
532 |
|
533 if ( KErrNone != result && KErrInUse != result ) |
|
534 { |
|
535 // Fatal error |
|
536 Close(); |
|
537 property.Close(); |
|
538 VMBLOGSTRING( "VMBX: RVmbxNumber::Open: Phonebook info error" ); |
|
539 |
|
540 return result; |
|
541 } |
|
542 |
|
543 // If no SIM support for vmbx numbers, we don't need |
|
544 //ETel for anything. -> close all ETel resources |
|
545 if ( !( iFlags & |
|
546 (KVmFlagPhonebookBeingCached | KVmFlagSimReadSupport ) ) ) |
|
547 { |
|
548 CloseETel(); |
|
549 } |
|
550 } |
|
551 // Sim access rights are tested only in start up |
|
552 iStartUpTest = EFalse; |
|
553 #endif // VM_USE_TSY |
|
554 |
|
555 property.Close(); |
|
556 |
|
557 if ( FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) ) |
|
558 { |
|
559 result = iSession->Get( KVmNumOpts,iVmNumOpts ); |
|
560 |
|
561 if ( KErrNone != result ) |
|
562 { |
|
563 if ( KErrNotFound == result ) |
|
564 { |
|
565 iVmNumOpts = EVmNumOptsBlank; |
|
566 } |
|
567 else |
|
568 { |
|
569 Close(); |
|
570 VMBLOGSTRING( "VMBX: RVmbxNumber::Open: NumOpt error" ); |
|
571 return result; |
|
572 } |
|
573 } |
|
574 } |
|
575 result = iSession->Get( KVmUIOpts, iVmUiOpts ); |
|
576 |
|
577 if ( KErrNone != result ) |
|
578 { |
|
579 if ( KErrNotFound == result ) |
|
580 { |
|
581 iVmUiOpts = 0; |
|
582 } |
|
583 else |
|
584 { |
|
585 Close(); |
|
586 VMBLOGSTRING( "VMBX: RVmbxNumber::Open: NumOpt error" ); |
|
587 return result; |
|
588 } |
|
589 } |
|
590 |
|
591 iCoeEnv = CEikonEnv::Static(); |
|
592 |
|
593 // load the resources for queries and notes |
|
594 if ( iCoeEnv ) |
|
595 { |
|
596 __ASSERT_DEBUG( iCoeEnv, |
|
597 User::Panic( KVmbxPanicCategory, EVmbxNoCoeEnv ) ); |
|
598 |
|
599 // load the resources for queries and notes |
|
600 TInt tmpStatus; |
|
601 TRAP( tmpStatus, LoadResourceL() ); |
|
602 result = tmpStatus; |
|
603 |
|
604 if ( result ) |
|
605 { |
|
606 Close(); |
|
607 } |
|
608 else |
|
609 { |
|
610 iFlags |= KVmFlagOpened; |
|
611 } |
|
612 } |
|
613 |
|
614 HandleNumberStores( alsline ); |
|
615 |
|
616 VMBLOGSTRING( "VMBX: RVmbxNumber::Open <=" ); |
|
617 return result; |
|
618 } |
|
619 |
|
620 // ----------------------------------------------------------------------------- |
|
621 // RVmbxNumber::ConnectETelServer |
|
622 // Connects to ETel server |
|
623 // ----------------------------------------------------------------------------- |
|
624 // |
|
625 /***************************************************** |
|
626 * Series 60 Customer / ETel |
|
627 * Series 60 ETel API |
|
628 *****************************************************/ |
|
629 TInt RVmbxNumber::ConnectETelServer() |
|
630 { |
|
631 VMBLOGSTRING( "VMBX: RVmbxNumber::ConnectETelServer =>" ); |
|
632 const TInt KRetryCount = 7; |
|
633 const TInt KRetryTimeout = 100000; |
|
634 TInt status( KErrNone ); |
|
635 |
|
636 for ( TInt i( 0 ); i < KRetryCount; i++ ) |
|
637 { |
|
638 status = iTelServer.Connect(); |
|
639 if ( !status ) |
|
640 { |
|
641 break; |
|
642 } |
|
643 User::After( KRetryTimeout ); |
|
644 } |
|
645 VMBLOGSTRING( "VMBX: RVmbxNumber::ConnectETelServer <=" ); |
|
646 return status; |
|
647 } |
|
648 |
|
649 // ----------------------------------------------------------------------------- |
|
650 // RVmbxNumber::GetVmbxNumber |
|
651 // Fetches the specified vmbx number |
|
652 // ----------------------------------------------------------------------------- |
|
653 // |
|
654 /***************************************************** |
|
655 * Series 60 Customer / ETel |
|
656 * Series 60 ETel API |
|
657 *****************************************************/ |
|
658 EXPORT_C TInt RVmbxNumber::GetVmbxNumber( TDes& aNumber, |
|
659 TVmbxNumberEntry aEntry ) |
|
660 { |
|
661 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmbxNumber =>" ); |
|
662 __ASSERT_DEBUG( iFlags & ( KVmFlagOpened ), |
|
663 User::Panic(KVmbxPanicCategory, EVmbxNotConnected) ); |
|
664 __ASSERT_DEBUG( aNumber.MaxLength() >= KVmbxMaxNumberLength, |
|
665 User::Panic(KVmbxPanicCategory, EVmbxDescriptorTooSmall) ); |
|
666 |
|
667 TInt lineNumber( aEntry ); |
|
668 |
|
669 if ( aEntry == EAlsActiveLineEntry ) |
|
670 { |
|
671 // get the current ALS line |
|
672 if ( GetAlsLine( lineNumber ) != KErrNone ) |
|
673 { |
|
674 lineNumber = EAlsLine1; // if problems, assume primary line |
|
675 } |
|
676 } |
|
677 TInt ret( KErrNotFound ); |
|
678 TBuf< KVmbxMaxNumberLength > number; |
|
679 TBuf< KVmbxMaxNumberLength > line2AlsNumber; |
|
680 |
|
681 //VMN callback# |
|
682 if ( FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) && |
|
683 ( iVmUiOpts & KVmNumOverwrite ) ) |
|
684 { |
|
685 ret = GetVmNumFromVMN( number ); |
|
686 if ( ret == KErrNone ) |
|
687 { |
|
688 aNumber.Copy( number ); |
|
689 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmbxNumber OK" ); |
|
690 return ret; |
|
691 } |
|
692 else if ( ret != KErrNotFound ) |
|
693 { |
|
694 VMBLOGSTRING2( "VMBX: RVmbxNumber:: \ |
|
695 GetVmbxNumber error = %I", ret ); |
|
696 return ret; |
|
697 } |
|
698 } |
|
699 |
|
700 TBool isFromSD = EFalse; |
|
701 TBool isFromSim = EFalse; |
|
702 |
|
703 // Get saved number |
|
704 switch ( iVmNumOpts ) |
|
705 { |
|
706 case EVmNumOptsBlank: |
|
707 { |
|
708 // On ALS1 read number from sim, if sim is active |
|
709 // On ALS2 always read number from sim when vmbx phone memory in use |
|
710 if ( IsSimMemory() && ( ( EAlsLine1 == lineNumber ) |
|
711 || ( EAlsLine2 == lineNumber ) ) ) |
|
712 { |
|
713 ret = GetVmNumFromSIM( number, lineNumber ); |
|
714 isFromSim = ETrue; |
|
715 // If there is no voice mailbox number available on SIM, |
|
716 // a note(qtn_...) should be shown, |
|
717 // when pressing '1' + 'send' key or long pressing '1' key |
|
718 // to try to call voice mailbox by phone application. |
|
719 if ( ( !UserEditNumber( lineNumber ) |
|
720 || !IsPhoneMemForcedEdit( lineNumber ) ) && |
|
721 ( ( KErrNotFound == ret ) || ( KErrNotSupported == ret ) ) |
|
722 && !AllowedToChangeTheNumber() ) |
|
723 { |
|
724 // get current active process |
|
725 RProcess curProcess; |
|
726 TInt curProcessId( curProcess.SecureId().iId ); |
|
727 VMBLOGSTRING2( "VMBX: RVmbxNumber:: Get cur process id: \ |
|
728 curProcessId = %I", curProcessId ); |
|
729 |
|
730 if ( KPhoneApplicationUid == curProcessId ) |
|
731 { |
|
732 TBool thisClosed( EFalse ); |
|
733 iClosedPtr = &thisClosed; |
|
734 |
|
735 // This check is done because phone client calls |
|
736 // GetVmbxNumber and then SelectTypeL, |
|
737 // which causes note qtn_... to be shown twice |
|
738 if ( IsNoNumberNoteAllowed() ) |
|
739 { |
|
740 // show the information note to user |
|
741 TRAP_IGNORE( |
|
742 ShowInformationNoteL( R_VOICE_NO_VMBX_NUMBER_NOTE ) ) |
|
743 } |
|
744 |
|
745 iClosedPtr = NULL; |
|
746 if ( thisClosed ) |
|
747 { |
|
748 //End Key Pressed |
|
749 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmbxNumber: \ |
|
750 End key pressed" ); |
|
751 return KErrCancel; |
|
752 } |
|
753 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmbxNumber \ |
|
754 No voice mailbox number available on SIM" ); |
|
755 } |
|
756 } |
|
757 if ( KErrNone == ret ) |
|
758 { |
|
759 ResetUserEditNumber( lineNumber ); |
|
760 } |
|
761 VMBLOGSTRING2( "GetVmNumFromSIM = %I", ret ); |
|
762 } |
|
763 else |
|
764 { |
|
765 ret = KErrNotFound; |
|
766 } |
|
767 break; |
|
768 } |
|
769 case EVmNumOptsDedicatedVMN: |
|
770 { |
|
771 ret = GetVmNumFromVMN( number ); |
|
772 break; |
|
773 } |
|
774 case EVmNumOptsMIN: |
|
775 case EVmNumOptsOnePlusMIN: |
|
776 { |
|
777 ret = GetVmNumFromNamStore( number, EVmbxMIN ); |
|
778 break; |
|
779 } |
|
780 case EVmNumOptsMDN: |
|
781 case EVmNumOptsOnePlusMDN: |
|
782 { |
|
783 ret = GetVmNumFromNamStore( number ); |
|
784 break; |
|
785 } |
|
786 case EVmNumOptsMDNCustom: |
|
787 case EVmNumOptsOnePlusMDNCustom: |
|
788 { |
|
789 ret = GetVmNumFromSD( number, lineNumber ); |
|
790 if ( ret != KErrNone ) |
|
791 { |
|
792 ret = GetVmNumFromNamStore( number ); |
|
793 } |
|
794 break; |
|
795 } |
|
796 case EVmNumOptsSharedData: |
|
797 { |
|
798 ret = GetVmNumFromSD( number, lineNumber ); |
|
799 isFromSD = ETrue; |
|
800 break; |
|
801 } |
|
802 default: |
|
803 // |
|
804 break; |
|
805 } |
|
806 |
|
807 // On ALS2, if number exists on SD, then use it |
|
808 // if ALS2 number found in SIM, but not in phone memory, |
|
809 // reset flag for automatic SIM number use. |
|
810 // Number found from SIM is saved to SD later |
|
811 |
|
812 if ( lineNumber == EAlsLine2 ) |
|
813 { |
|
814 TInt alsReturnValue = GetVmNumFromSD( line2AlsNumber, lineNumber ); |
|
815 if ( ( alsReturnValue == KErrNone ) && ( line2AlsNumber.Length() ) ) |
|
816 { |
|
817 VMBLOGSTRING( "GetVmbxNumber::ALS2 number found from CenRep" ); |
|
818 number.Copy( line2AlsNumber ); |
|
819 isFromSD = ETrue; |
|
820 } |
|
821 else |
|
822 { |
|
823 if ( ( KErrNone == ret ) && isFromSim ) |
|
824 { |
|
825 VMBLOGSTRING( "[VMBX] GetVmbxNumber::ALS 2 number found from SIM" ); |
|
826 ResetUserEditNumber( lineNumber ); |
|
827 } |
|
828 else |
|
829 { |
|
830 number.Zero(); |
|
831 } |
|
832 } |
|
833 } |
|
834 |
|
835 // No number retrieved so try to read SD for number |
|
836 // (Phone memory in use) |
|
837 if ( ret != KErrNone ) |
|
838 { |
|
839 switch( iVmNumOpts ) |
|
840 { |
|
841 case EVmNumOptsBlank: |
|
842 case EVmNumOptsDedicatedVMN: |
|
843 case EVmNumOptsMIN: |
|
844 case EVmNumOptsOnePlusMIN: |
|
845 case EVmNumOptsMDN: |
|
846 case EVmNumOptsOnePlusMDN: |
|
847 { |
|
848 if ( !IsSimMemory() ) |
|
849 { |
|
850 ret = GetVmNumFromSD( number, lineNumber ); |
|
851 VMBLOGSTRING2( "GetVmNumFromSD = %I", ret ); |
|
852 isFromSD = ETrue; |
|
853 } |
|
854 else |
|
855 { |
|
856 aNumber.Copy( number ); |
|
857 VMBLOGSTRING2( "number = %S", &number ); |
|
858 } |
|
859 break; |
|
860 } |
|
861 default: |
|
862 break; |
|
863 } |
|
864 } |
|
865 |
|
866 if ( ret == KErrNone ) |
|
867 { |
|
868 if ( number.Length() ) |
|
869 { |
|
870 VMBLOGSTRING( "Number length > 0" ); |
|
871 //Synchronize the number in storage with the retrieved number |
|
872 if ( iVmNumOpts != EVmNumOptsMDNCustom && |
|
873 iVmNumOpts != EVmNumOptsOnePlusMDNCustom && |
|
874 !isFromSD ) |
|
875 { |
|
876 iSynchronize = ETrue; |
|
877 |
|
878 if ( ( iFlags & KVmFlagSimWriteSupport ) || |
|
879 ( lineNumber == EAlsLine2 ) ) |
|
880 { |
|
881 TInt error( KErrNone ); |
|
882 // If number is not fetched from SIM and SIM memory active |
|
883 // on primary line, number saved to SIM. |
|
884 if ( UsesSimMemory() ) |
|
885 { |
|
886 if ( !isFromSim ) |
|
887 { |
|
888 error = SaveVmbxNumberToSim( number, aEntry ); |
|
889 VMBLOGSTRING2( "SaveVmbxNumberToSim = %I", error ); |
|
890 } |
|
891 } |
|
892 else |
|
893 { |
|
894 error = SaveVmbxNumberToPhone( number, aEntry ); |
|
895 VMBLOGSTRING2( "SaveVmbxNumberToPhone = %I", error ); |
|
896 } |
|
897 } |
|
898 else |
|
899 { |
|
900 iFlags &= (~KForceSavedToPhoneMem); |
|
901 SaveVmbxNumber( number, aEntry ); |
|
902 } |
|
903 } |
|
904 |
|
905 if ( iVmNumOpts == EVmNumOptsOnePlusMIN || |
|
906 iVmNumOpts == EVmNumOptsOnePlusMDN ) |
|
907 { |
|
908 if ( KVmbxMaxNumberLength < number.Length() + 1 ) |
|
909 { |
|
910 VMBLOGSTRING( "GetVmbxNumber::Number too long" ); |
|
911 return KErrTooBig; |
|
912 } |
|
913 // Add 1 plus |
|
914 number.Insert( 0, KVmbxOnePlus ); |
|
915 } |
|
916 |
|
917 aNumber.Copy( number ); |
|
918 } |
|
919 else |
|
920 { |
|
921 VMBLOGSTRING( "GetVmbxNumber::No number found." ); |
|
922 ret = KErrNotFound; |
|
923 } |
|
924 } |
|
925 |
|
926 VMBLOGSTRING2( "VMBX: RVmbxNumber::GetVmbxNumber error = %I", ret ); |
|
927 if ( ret != KErrNone ) |
|
928 { |
|
929 return KErrNotFound; |
|
930 } |
|
931 |
|
932 if ( IsEmergencyNumberL( aNumber ) ) |
|
933 { |
|
934 aNumber.Zero(); |
|
935 ret = KErrNotFound; |
|
936 } |
|
937 |
|
938 return ret; |
|
939 } |
|
940 |
|
941 // ----------------------------------------------------------------------------- |
|
942 // RVmbxNumber::QueryNumberL |
|
943 // Check wether the voice mailbox number can be changed |
|
944 // ----------------------------------------------------------------------------- |
|
945 // |
|
946 EXPORT_C TBool RVmbxNumber::QueryNumberL( TVmbxQueryType aQueryType, |
|
947 TDes& aNumber, |
|
948 TBool aShowQuery) |
|
949 { |
|
950 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: =>" ); |
|
951 __ASSERT_DEBUG( aNumber.MaxLength() >= KVmbxMaxNumberLength, |
|
952 User::Panic( KVmbxPanicCategory, EVmbxDescriptorTooSmall ) ); |
|
953 __ASSERT_DEBUG( aNumber.Length() <= KVmbxMaxNumberLength, |
|
954 User::Panic( KVmbxPanicCategory, EVmbxNumberTooLong ) ); |
|
955 |
|
956 VMBLOGSTRING2( "aQueryType = %d", aQueryType ); |
|
957 VMBLOGSTRING2( "iPhoneBookType = %d", iPhoneBookType ); |
|
958 |
|
959 TBool result( EFalse ); |
|
960 if ( EVmQueryProcess == iQueryingState ) |
|
961 { |
|
962 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: \ |
|
963 running forever case" ); |
|
964 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: <=" ); |
|
965 return result; |
|
966 } |
|
967 |
|
968 if ( !AllowedToChangeTheNumber() ) |
|
969 { |
|
970 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: \ |
|
971 Number not allowed to change" ); |
|
972 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: <=" ); |
|
973 User::Leave( KErrAccessDenied ); |
|
974 } |
|
975 |
|
976 // Vmbx type is set for FetchNumberFromPhonebookL |
|
977 iType = EVmbx; |
|
978 |
|
979 __ASSERT_DEBUG( aNumber.MaxLength() >= KVmbxMaxNumberLength, |
|
980 User::Panic( KVmbxPanicCategory, EVmbxDescriptorTooSmall ) ); |
|
981 __ASSERT_DEBUG( aNumber.Length() <= KVmbxMaxNumberLength, |
|
982 User::Panic( KVmbxPanicCategory, EVmbxNumberTooLong ) ); |
|
983 |
|
984 // Close() sets thisClosed to ETrue |
|
985 TBool thisClosed( EFalse ); |
|
986 |
|
987 TBuf<KVmbxMaxNumberLength> vmbxNumber; |
|
988 |
|
989 TInt alsline( EAlsLine1 ); |
|
990 // get the current ALS line |
|
991 if ( GetAlsLine( alsline ) != KErrNone ) |
|
992 { |
|
993 // if problems, assume primary line |
|
994 alsline = EAlsLine1; |
|
995 } |
|
996 VMBLOGSTRING2( "VMBX: RVmbxNumber::QueryNumberL: ALSline = %d", |
|
997 alsline ); |
|
998 |
|
999 if ( iFlags & KVmFlagSimReadSupport ) |
|
1000 { |
|
1001 VMBLOGSTRING( "RVmbxNumber::QueryNumberL: SIM Read support" ) |
|
1002 TBool querySim( EFalse ); |
|
1003 |
|
1004 if ( alsline == EAlsLine1 ) |
|
1005 { |
|
1006 // Do sim query when not defined query |
|
1007 // or 6f17 Sim memory not active and query wanted |
|
1008 if ( ( aQueryType == EVmbxNotDefinedQuery ) || |
|
1009 ( !IsSimMemory() && aShowQuery && |
|
1010 ( iMemoryLocation == EVmbxPhoneMemory ) ) ) |
|
1011 { |
|
1012 VMBLOGSTRING( "RVmbxNumber::QueryNumberL: Query on line1" ); |
|
1013 querySim = ETrue; |
|
1014 } |
|
1015 } |
|
1016 else //EAlsLine2 |
|
1017 { |
|
1018 // Allways and only when vmbx phonebook in use |
|
1019 if ( iPhoneBookType == EVMBXPhoneBook ) |
|
1020 { |
|
1021 VMBLOGSTRING( "RVmbxNumber::QueryNumberL: Query on line2" ); |
|
1022 querySim = ETrue; |
|
1023 } |
|
1024 } |
|
1025 |
|
1026 if ( querySim ) |
|
1027 { |
|
1028 iClosedPtr = &thisClosed; |
|
1029 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: Q SIM number" ); |
|
1030 |
|
1031 TBool isSimNumber = QuerySimNumberL( vmbxNumber ); |
|
1032 |
|
1033 VMBLOGSTRING2( "VMBX: RVmbxNumber::QueryNumberL: SIM number %S", |
|
1034 &vmbxNumber ); |
|
1035 |
|
1036 iClosedPtr = NULL; |
|
1037 |
|
1038 if ( thisClosed ) |
|
1039 { |
|
1040 //End Key Pressed |
|
1041 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: \ |
|
1042 End key pressed" ); |
|
1043 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: <=" ); |
|
1044 return EFalse; |
|
1045 } |
|
1046 |
|
1047 if ( isSimNumber ) |
|
1048 { |
|
1049 // save to phone memory when ALS2 in use |
|
1050 // or read-only sim on ALS1 |
|
1051 if ( ( alsline == EAlsLine2 ) || |
|
1052 ( ( alsline == EAlsLine1 ) && |
|
1053 !( iFlags & KVmFlagSimWriteSupport ) ) ) |
|
1054 { |
|
1055 VMBLOGSTRING( "Save number To Phone" ); |
|
1056 SaveVmbxNumberToPhone( vmbxNumber, EAlsActiveLineEntry ); |
|
1057 // confirmation note is not needed if number is taken |
|
1058 // from SIM automatically |
|
1059 if ( UserEditNumber( alsline ) || |
|
1060 IsPhoneMemForcedEdit( alsline ) ) |
|
1061 { |
|
1062 ResetUserEditNumber( alsline ); |
|
1063 ShowConfirmationNoteL( R_SIM_NUMBER_NOTE ); |
|
1064 } |
|
1065 } |
|
1066 else |
|
1067 { |
|
1068 // confirmation note is not needed if number is taken |
|
1069 // from SIM automatically |
|
1070 if ( UserEditNumber( alsline ) || |
|
1071 IsPhoneMemForcedEdit( alsline ) ) |
|
1072 { |
|
1073 ShowConfirmationNoteL( R_SIM_NUMBER_NOTE ); |
|
1074 } |
|
1075 } |
|
1076 aNumber.Copy( vmbxNumber ); |
|
1077 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL Number from \ |
|
1078 Sim accepted" ); |
|
1079 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: <=" ); |
|
1080 return ETrue; |
|
1081 } |
|
1082 } |
|
1083 } |
|
1084 |
|
1085 TBuf<KVmOriginalNumLength> originalNumber; |
|
1086 originalNumber.Copy( aNumber ); |
|
1087 |
|
1088 iQueryingState = EVmQueryProcess; |
|
1089 //QueryNumberL dialog |
|
1090 FOREVER |
|
1091 { |
|
1092 vmbxNumber.Copy( aNumber ); |
|
1093 |
|
1094 // get the correct query prompt from resource file |
|
1095 HBufC* prompt = StringLoader::LoadLC( ( aQueryType == |
|
1096 EVmbxNotDefinedQuery |
|
1097 ? R_DEFINE_NUMBER_PROMPT |
|
1098 : R_CHANGE_NUMBER_PROMPT ), |
|
1099 iCoeEnv ); |
|
1100 |
|
1101 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL string loaded" ); |
|
1102 iClosedPtr = &thisClosed; |
|
1103 |
|
1104 // Convert output to accommodate the current locale |
|
1105 AknTextUtils::LanguageSpecificNumberConversion( vmbxNumber ); |
|
1106 |
|
1107 TInt ret; // return value of the query |
|
1108 |
|
1109 // ETrue to open the query again after closing single fetch dialog |
|
1110 TBool searchUsed; |
|
1111 |
|
1112 // enable search if number length is 0 |
|
1113 TBool searchEnabled( vmbxNumber.Length() ? EFalse : ETrue ); |
|
1114 |
|
1115 do |
|
1116 { |
|
1117 // show query with the correct prompt |
|
1118 iQuery = CVmTextQueryDialog::NewL( vmbxNumber, |
|
1119 *prompt, searchEnabled ); |
|
1120 |
|
1121 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL ExecuteLD" ); |
|
1122 ret = iQuery->ExecuteLD( R_VMBX_NUMBER_QUERY ); |
|
1123 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL ExecuteLD done" ); |
|
1124 |
|
1125 iQuery = NULL; |
|
1126 searchUsed = EFalse; |
|
1127 |
|
1128 if ( searchEnabled && ret && !vmbxNumber.Length() ) |
|
1129 { |
|
1130 searchUsed = ETrue; |
|
1131 // Show phonebook's single fetch dialog |
|
1132 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL Fetch from Pb" ); |
|
1133 TRAPD( error, FetchNumberFromPhonebook2L( vmbxNumber ) ); |
|
1134 VMBLOGSTRING2( "VMBX: RVmbxNumber::QueryNumberL Fetch from Pb done \ |
|
1135 error = %d", error ); |
|
1136 |
|
1137 // If application is killed via FSW, contact selection query |
|
1138 // returns KLeaveExit. This should propagate to "root" |
|
1139 // application where it reaches the active scheduler loop |
|
1140 // and thus allows proper application exit when the loop exits. |
|
1141 // Therefore propagate the error to caller and do not ignore it. |
|
1142 if ( KLeaveExit == error ) |
|
1143 { |
|
1144 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL KLeaveExit" ); |
|
1145 User::Leave( error ); |
|
1146 } |
|
1147 |
|
1148 // user has pressed End Key |
|
1149 if ( thisClosed ) |
|
1150 { |
|
1151 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: \ |
|
1152 End key pressed" ); |
|
1153 CleanupStack::PopAndDestroy( prompt ); |
|
1154 |
|
1155 iQueryingState = EVmQueryNormal; |
|
1156 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: <=" ); |
|
1157 return EFalse; |
|
1158 } |
|
1159 |
|
1160 if ( error ) // Back pressed in Contact UI |
|
1161 { |
|
1162 // Now the phone book fetch dialog was closed, |
|
1163 // get out of the loop |
|
1164 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL Fetch done" ); |
|
1165 ret = 0; |
|
1166 break; |
|
1167 } |
|
1168 } |
|
1169 } while ( searchUsed ); |
|
1170 |
|
1171 iClosedPtr = NULL; |
|
1172 |
|
1173 CleanupStack::PopAndDestroy( prompt ); |
|
1174 |
|
1175 if ( ret != KErrNone ) |
|
1176 { |
|
1177 if ( !vmbxNumber.Length() ) |
|
1178 { |
|
1179 iFlags &= (~KForceSavedToPhoneMem); |
|
1180 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL has number" ); |
|
1181 // Resets the flag that indicates that the user has edited VMBX number |
|
1182 ResetUserEditNumber( alsline ); |
|
1183 TInt status = |
|
1184 SaveVmbxNumber( vmbxNumber, EAlsActiveLineEntry ); |
|
1185 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL number save" ); |
|
1186 |
|
1187 if ( status == KErrNone ) |
|
1188 { |
|
1189 // If number does not exist, |
|
1190 // number from SIM is used if it's available |
|
1191 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL save ok" ); |
|
1192 if ( UseSimNumIfAvailable( vmbxNumber, alsline ) |
|
1193 && vmbxNumber.Length() ) |
|
1194 { |
|
1195 // If number is taken from SIM, |
|
1196 // show appropriate confirmation note |
|
1197 ShowConfirmationNoteL( R_SIM_NUMBER_NOTE ); |
|
1198 } |
|
1199 aNumber.Copy( vmbxNumber ); |
|
1200 if ( !vmbxNumber.Length() ) |
|
1201 { |
|
1202 // show "not defined" note |
|
1203 ShowConfirmationNoteL( R_NOTE_EMPTY_NUMBER ); |
|
1204 } |
|
1205 result = ETrue; |
|
1206 break; |
|
1207 } |
|
1208 else if ( status == KErrCancel ) |
|
1209 { |
|
1210 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL save \ |
|
1211 cancel" ); |
|
1212 |
|
1213 aNumber.Copy( vmbxNumber ); |
|
1214 continue; |
|
1215 } |
|
1216 else |
|
1217 { |
|
1218 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: \ |
|
1219 Number saving error" ); |
|
1220 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: <=" ); |
|
1221 User::LeaveIfError( status ); |
|
1222 } |
|
1223 } |
|
1224 else |
|
1225 { |
|
1226 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL no number" ); |
|
1227 SetUserEditNumber( alsline ); |
|
1228 } |
|
1229 |
|
1230 // Convert back to western digits |
|
1231 ConvertToWesternDigits( vmbxNumber ); |
|
1232 |
|
1233 // check the given number here (emergency numbers not allowed) |
|
1234 if ( IsValidPhoneNumber( vmbxNumber ) |
|
1235 && !IsEmergencyNumberL( vmbxNumber ) ) |
|
1236 { |
|
1237 iFlags &= ~KForceSavedToPhoneMem; |
|
1238 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: save num 2" ); |
|
1239 TInt status = SaveVmbxNumber( vmbxNumber, EAlsActiveLineEntry ); |
|
1240 |
|
1241 if ( status == KErrNone ) |
|
1242 { |
|
1243 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: save \ |
|
1244 num 2 ok" ); |
|
1245 aNumber.Copy( vmbxNumber ); |
|
1246 if ( UsesSimMemory() ) |
|
1247 { |
|
1248 ShowConfirmationNoteL( |
|
1249 R_SAVED_NOTE_SIM_MEMORY ); |
|
1250 } |
|
1251 else |
|
1252 { |
|
1253 ShowConfirmationNoteL( |
|
1254 R_SAVED_NOTE_PHONE_MEMORY ); |
|
1255 } |
|
1256 result = ETrue; |
|
1257 break; |
|
1258 } |
|
1259 else if ( status == KErrCancel ) |
|
1260 {// The query number dialog was cancelled, so continue |
|
1261 aNumber.Copy( vmbxNumber ); |
|
1262 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: save \ |
|
1263 num 2 cancel" ); |
|
1264 continue; |
|
1265 } |
|
1266 else if ( status == KErrArgument ) |
|
1267 { |
|
1268 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: save \ |
|
1269 num 2 err arg" ); |
|
1270 result = EFalse; |
|
1271 } |
|
1272 else |
|
1273 { |
|
1274 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: \ |
|
1275 Invalid number" ); |
|
1276 result = EFalse; |
|
1277 } |
|
1278 } |
|
1279 |
|
1280 if ( !result ) |
|
1281 { |
|
1282 // show "invalid number" note and wait |
|
1283 // for a short timeout |
|
1284 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: invalid \ |
|
1285 number show note" ); |
|
1286 |
|
1287 prompt = StringLoader::LoadLC( R_INVALID_NUMBER_NOTE, |
|
1288 iCoeEnv ); |
|
1289 |
|
1290 iClosedPtr = &thisClosed; |
|
1291 |
|
1292 CAknInformationNote* note = |
|
1293 new( ELeave ) CAknInformationNote( ETrue ); |
|
1294 note->ExecuteLD( *prompt ); |
|
1295 |
|
1296 iClosedPtr = NULL; |
|
1297 |
|
1298 CleanupStack::PopAndDestroy( prompt ); |
|
1299 |
|
1300 if ( !thisClosed ) |
|
1301 { |
|
1302 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: invalid \ |
|
1303 number query again" ); |
|
1304 continue; // the number was invalid -> query again. |
|
1305 } |
|
1306 } |
|
1307 } |
|
1308 |
|
1309 // retrieve the original number in the query |
|
1310 // as user has cancelled the query... |
|
1311 aNumber.Copy( originalNumber ); |
|
1312 break; // user canceled the query |
|
1313 } |
|
1314 iQueryingState = EVmQueryNormal; |
|
1315 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryNumberL: <=" ); |
|
1316 return result; |
|
1317 } |
|
1318 |
|
1319 // ----------------------------------------------------------------------------- |
|
1320 // RVmbxNumber::QuerySimNumberL |
|
1321 // Routine to query and save SIM number from user |
|
1322 // ----------------------------------------------------------------------------- |
|
1323 // |
|
1324 TBool RVmbxNumber::QuerySimNumberL( TDes& aNumber, TVmbxNumberEntry aEntry ) |
|
1325 { |
|
1326 VMBLOGSTRING( "VMBX: RVmbxNumber::QuerySimNumberL: =>" ); |
|
1327 TInt lineNumber( aEntry ); |
|
1328 |
|
1329 if ( aEntry == EAlsActiveLineEntry ) |
|
1330 { |
|
1331 // get the current ALS line |
|
1332 if ( GetAlsLine( lineNumber ) != KErrNone ) |
|
1333 { |
|
1334 lineNumber = EAlsLine1; // if problems, assume primary line |
|
1335 } |
|
1336 } |
|
1337 TInt ret( KErrNotFound ); |
|
1338 |
|
1339 ret = GetVmNumFromSIM( aNumber, lineNumber ); |
|
1340 |
|
1341 if ( ret ) |
|
1342 { |
|
1343 return EFalse; |
|
1344 } |
|
1345 |
|
1346 VMBLOGSTRING2( "iMemoryLocation = %d", iMemoryLocation ); |
|
1347 |
|
1348 TBool doSimQuery( EFalse ); |
|
1349 if ( ( lineNumber == EAlsLine2 ) && ( iPhoneBookType == EVMBXPhoneBook ) ) |
|
1350 { |
|
1351 VMBLOGSTRING( "Sim query allowed on line2" ); |
|
1352 doSimQuery = ETrue; |
|
1353 } |
|
1354 else if ( ( iMemoryLocation == EVmbxPhoneMemory ) && |
|
1355 ( 0 != aNumber.Length() ) ) |
|
1356 { |
|
1357 VMBLOGSTRING( "Sim query allowed on line1" ); |
|
1358 doSimQuery = ETrue; |
|
1359 } |
|
1360 |
|
1361 if ( doSimQuery ) |
|
1362 { |
|
1363 TInt retVal = EVmbxSimNumNotAccepted; |
|
1364 // If number not defined, query is not needed as number |
|
1365 // found in SIM is used automatically |
|
1366 if ( VmbxNumDefInPhoneMemory( lineNumber ) ) |
|
1367 { |
|
1368 // If number found in SIM is the same as the number stored in phone memory, |
|
1369 // skip query |
|
1370 if ( !NumStoredInPhone( aNumber, lineNumber ) ) |
|
1371 { |
|
1372 HBufC* label = StringLoader::LoadLC( R_SAVED_SIM_NUMBER_INTO_USE, |
|
1373 aNumber ); |
|
1374 iVMSimQueryDialog = CVMSimQueryDilaog::NewL(); |
|
1375 iVMSimQueryDialog->SetVMSimPromptL( *label ); |
|
1376 CleanupStack::PopAndDestroy( label ); |
|
1377 retVal= iVMSimQueryDialog->ExecuteLD( |
|
1378 R_VMBX_TAKE_SIM_NUMBER_INTO_USE ); |
|
1379 if ( iVMSimQueryDialog == NULL ) |
|
1380 { |
|
1381 VMBLOGSTRING( "VMBX: RVmbxNumber::QuerySimNumberL: \ |
|
1382 No number inserted" ); |
|
1383 return EFalse; |
|
1384 } |
|
1385 iVMSimQueryDialog = NULL; |
|
1386 if ( retVal ) |
|
1387 { |
|
1388 SetUserEditNumber( lineNumber ); |
|
1389 } |
|
1390 } |
|
1391 } |
|
1392 else |
|
1393 { |
|
1394 // IF VMBX number not defined and number found in SIM, |
|
1395 // number from SIM is used |
|
1396 retVal = EVmbxSimNumAccepted; |
|
1397 ResetUserEditNumber( lineNumber ); |
|
1398 } |
|
1399 |
|
1400 // sim number accepted on line 1 |
|
1401 if ( retVal && ( lineNumber == EAlsLine1 ) ) |
|
1402 { |
|
1403 VMBLOGSTRING( "sim number accepted on line 1" ); |
|
1404 // No write support on sim, use phone memory |
|
1405 if ( !( iFlags & KVmFlagSimWriteSupport ) ) |
|
1406 { |
|
1407 iSession->Set( KVmUsesSimMemory, EVmbxPhoneMemory ); |
|
1408 iMemoryLocation = EVmbxPhoneMemory; |
|
1409 } |
|
1410 else |
|
1411 { |
|
1412 iSession->Set( KVmUsesSimMemory, EVmbxSimMemory ); |
|
1413 iMemoryLocation = EVmbxSimMemory; |
|
1414 } |
|
1415 VMBLOGSTRING( "return ETrue" ); |
|
1416 return ETrue; |
|
1417 } |
|
1418 // sim number accepted on line 2 |
|
1419 else if ( retVal && ( lineNumber == EAlsLine2 ) ) |
|
1420 { |
|
1421 VMBLOGSTRING( "Sim number accepted on line2" ); |
|
1422 return ETrue; |
|
1423 } |
|
1424 // user selection "No" |
|
1425 else |
|
1426 { |
|
1427 VMBLOGSTRING( "VMBX: RVmbxNumber::QuerySimNumberL: \ |
|
1428 No number inserted" ); |
|
1429 return EFalse; |
|
1430 } |
|
1431 } |
|
1432 VMBLOGSTRING( "VMBX: RVmbxNumber::QuerySimNumberL: <=" ); |
|
1433 return EFalse; |
|
1434 } |
|
1435 |
|
1436 // ----------------------------------------------------------------------------- |
|
1437 // RVmbxNumber::ConvertToWesternDigits |
|
1438 // Converts a phone number to western format |
|
1439 // ----------------------------------------------------------------------------- |
|
1440 // |
|
1441 void RVmbxNumber::ConvertToWesternDigits( TDes& aDes ) const |
|
1442 { |
|
1443 VMBLOGSTRING( "VMBX: RVmbxNumber::ConvertToWesternDigits: =>" ); |
|
1444 AknTextUtils::ConvertDigitsTo( aDes, EDigitTypeWestern ); |
|
1445 VMBLOGSTRING( "VMBX: RVmbxNumber::ConvertToWesternDigits: <=" ); |
|
1446 } |
|
1447 |
|
1448 // ----------------------------------------------------------------------------- |
|
1449 // RVmbxNumber::SaveVmbxNumber |
|
1450 // Saves vmbx number to phone or sim memory |
|
1451 // ----------------------------------------------------------------------------- |
|
1452 // |
|
1453 /***************************************************** |
|
1454 * Series 60 Customer / ETel |
|
1455 * Series 60 ETel API |
|
1456 *****************************************************/ |
|
1457 EXPORT_C TInt RVmbxNumber::SaveVmbxNumber( const TDesC& aNumber, |
|
1458 TVmbxNumberEntry aEntry ) |
|
1459 { |
|
1460 VMBLOGSTRING( "VMBX: RVmbxNumber::SaveVmbxNumber: =>" ); |
|
1461 TInt status( KErrNone ); |
|
1462 TInt alsline( EAlsLine1 ); |
|
1463 // get the current ALS line |
|
1464 if ( GetAlsLine( alsline ) != KErrNone ) |
|
1465 { |
|
1466 alsline = EAlsLine1; // if problems, assume primary line |
|
1467 } |
|
1468 |
|
1469 if ( EAlsLine1 == alsline) |
|
1470 { |
|
1471 // Ask place to save if sim available for saving |
|
1472 if ( iFlags & KVmFlagSimWriteSupport ) |
|
1473 { |
|
1474 TInt index( 0 ); |
|
1475 TInt ret( 0 ); |
|
1476 |
|
1477 CAknListQueryDialog* dlg( NULL ); |
|
1478 TRAP_IGNORE( dlg = new( ELeave ) CAknListQueryDialog( &index ) ); |
|
1479 |
|
1480 if ( dlg ) |
|
1481 { |
|
1482 TRAP_IGNORE( ret = dlg->ExecuteLD( R_VMBX_MEMORY_LIST_QUERY ) ); |
|
1483 dlg = NULL; |
|
1484 } |
|
1485 |
|
1486 if ( ret ) |
|
1487 { |
|
1488 // user selected to save number to Sim |
|
1489 if ( EVmbxSimMemory == index ) |
|
1490 { |
|
1491 iMemoryLocation = EVmbxSimMemory; |
|
1492 iSession->Set( KVmUsesSimMemory, EVmbxSimMemory ); |
|
1493 |
|
1494 status = SaveVmbxNumberToSim( aNumber, aEntry ); |
|
1495 VMBLOGSTRING( "VMBX: RVmbxNumber::SaveVmbxNumber: \ |
|
1496 Number saved to Sim" ); |
|
1497 } |
|
1498 // user selected to save number to Phone memory |
|
1499 else if ( EVmbxPhoneMemory == index ) |
|
1500 { |
|
1501 iMemoryLocation = EVmbxPhoneMemory; |
|
1502 iSession->Set( KVmUsesSimMemory, EVmbxPhoneMemory ); |
|
1503 if ( iFlags & KForceSavedToPhoneMem ) |
|
1504 { |
|
1505 SetPhoneMemForcedEdit( alsline ); |
|
1506 } |
|
1507 |
|
1508 status = SaveVmbxNumberToPhone( aNumber, aEntry ); |
|
1509 VMBLOGSTRING( "VMBX: RVmbxNumber::SaveVmbxNumber: \ |
|
1510 Number saved to phone memory" ); |
|
1511 } |
|
1512 } |
|
1513 else// The user has selected Cancel.. so no changes, return KErrCancel |
|
1514 { |
|
1515 VMBLOGSTRING( "VMBX: RVmbxNumber::SaveVmbxNumber: canceled" ); |
|
1516 status = KErrCancel; |
|
1517 } |
|
1518 } |
|
1519 // Line1 in use and no sim available, so use Phone memory |
|
1520 else |
|
1521 { |
|
1522 // Sim write not support and external clients invoke the function |
|
1523 // set phone memory forced edit |
|
1524 if ( iFlags & KForceSavedToPhoneMem ) |
|
1525 { |
|
1526 SetPhoneMemForcedEdit( alsline ); |
|
1527 } |
|
1528 iMemoryLocation = EVmbxPhoneMemory; |
|
1529 iSession->Set( KVmUsesSimMemory, EVmbxPhoneMemory ); |
|
1530 status = SaveVmbxNumberToPhone( aNumber, EAlsActiveLineEntry ); |
|
1531 VMBLOGSTRING( "VMBX: RVmbxNumber::SaveVmbxNumber: \ |
|
1532 Number saved to phone memory" ); |
|
1533 } |
|
1534 } |
|
1535 // EAlsLine2 |
|
1536 else |
|
1537 { |
|
1538 // Sim write not support and external clients invoke the function |
|
1539 // set phone memory forced edit |
|
1540 if ( ( iFlags & KForceSavedToPhoneMem ) && |
|
1541 ! ( iFlags & KVmFlagSimWriteSupport ) ) |
|
1542 { |
|
1543 SetPhoneMemForcedEdit( alsline ); |
|
1544 } |
|
1545 status = SaveVmbxNumberToPhone( aNumber, EAlsActiveLineEntry ); |
|
1546 } |
|
1547 VMBLOGSTRING( "VMBX: RVmbxNumber::SaveVmbxNumber: <=" ); |
|
1548 return status; |
|
1549 } |
|
1550 |
|
1551 |
|
1552 // ----------------------------------------------------------------------------- |
|
1553 // RVmbxNumber::SaveVmbxNumberToSim |
|
1554 // Saves vmbx number to sim memory |
|
1555 // ----------------------------------------------------------------------------- |
|
1556 // |
|
1557 /***************************************************** |
|
1558 * Series 60 Customer / ETel |
|
1559 * Series 60 ETel API |
|
1560 *****************************************************/ |
|
1561 TInt RVmbxNumber::SaveVmbxNumberToSim( const TDesC& aNumber, |
|
1562 TVmbxNumberEntry aEntry ) |
|
1563 { |
|
1564 VMBLOGSTRING( "VMBX: RVmbxNumber::SaveVmbxNumberToSim: =>" ); |
|
1565 |
|
1566 // AllowedToChangeTheNumber() check not done in this method |
|
1567 // in order to always allow saving. |
|
1568 TInt alsline( EAlsLine1 ); |
|
1569 // get the current ALS line |
|
1570 if ( GetAlsLine( alsline ) != KErrNone ) |
|
1571 { |
|
1572 alsline = EAlsLine1; // if problems, assume primary line |
|
1573 } |
|
1574 // ALS line2 not supported when saving to SIM |
|
1575 if ( alsline == EAlsLine2 ) |
|
1576 { |
|
1577 VMBLOGSTRING( "Sim usage for ALS Line2 not supported, \ |
|
1578 return KErrArgument " ); |
|
1579 return KErrArgument; |
|
1580 } |
|
1581 |
|
1582 // number containing "w"-character not allowed to save to sim |
|
1583 if ( aNumber.Find( KVmbxIllegalSimCharacter ) != KErrNotFound ) |
|
1584 { |
|
1585 VMBLOGSTRING( "w-char not allowed, return KErrArgument " ); |
|
1586 return KErrArgument; |
|
1587 } |
|
1588 |
|
1589 __ASSERT_DEBUG( iFlags & KVmFlagOpened, |
|
1590 User::Panic( KVmbxPanicCategory, EVmbxNotConnected ) ); |
|
1591 __ASSERT_DEBUG( aNumber.Length() <= KVmbxMaxNumberLength, |
|
1592 User::Panic( KVmbxPanicCategory, EVmbxNumberTooLong ) ); |
|
1593 |
|
1594 TInt lineNumber( aEntry ); |
|
1595 TInt error( KErrNone ); |
|
1596 |
|
1597 if ( aEntry == EAlsActiveLineEntry ) |
|
1598 { |
|
1599 // get the active ALS line |
|
1600 lineNumber = alsline; |
|
1601 } |
|
1602 |
|
1603 #ifdef VM_USE_TSY |
|
1604 // Update maxLength info |
|
1605 // First read number from sim. |
|
1606 // Then get info of the max size. |
|
1607 // Finally determine actual max size using retrieved info. |
|
1608 // Note! GetInfo reads data from cache, which is updated when write |
|
1609 // attempt is done. So if Ext-files are taken into use by some |
|
1610 // other application while Vmbx is opened, then correct info |
|
1611 // cannot fetch by GetInfo. (This appears when trying to save |
|
1612 // long number twice and first one fails and second is saved |
|
1613 // successfully.) |
|
1614 TBuf<KVmbxMaxNumberLength> numberOnSim; |
|
1615 // return value ignored here, because no meaning for size determination |
|
1616 GetVmNumFromSIM( numberOnSim, lineNumber ); |
|
1617 |
|
1618 TInt ret = DoPhonebookOperation( EVmbxPhonebookGetInfo ); |
|
1619 |
|
1620 if ( ret != KErrNone ) |
|
1621 { |
|
1622 VMBLOGSTRING2( "DoPhonebookOperation getinfo retval = %I", ret ); |
|
1623 return ret; |
|
1624 } |
|
1625 else |
|
1626 { |
|
1627 CalculateActualMaxLengthOnSim( numberOnSim.Length() ); |
|
1628 } |
|
1629 |
|
1630 // store in SIM phonebook |
|
1631 if ( iVmNumOpts == EVmNumOptsBlank ) |
|
1632 { |
|
1633 if ( aNumber.Length() <= iPhoneBookInfo.iMaxNumLength ) |
|
1634 { |
|
1635 VMBLOGSTRING( "SaveVmbxNumberToSim::Num length <= maxNumLength" ); |
|
1636 if ( iFlags & KVmFlagPhonebookBeingCached ) |
|
1637 { |
|
1638 error = DoPhonebookOperation( EVmbxPhonebookGetInfo ); |
|
1639 } |
|
1640 |
|
1641 if ( !error && ( iFlags & KVmFlagSimWriteSupport ) ) |
|
1642 { |
|
1643 TVmbxEntry entry; |
|
1644 entry.iIndex = lineNumber; |
|
1645 |
|
1646 if ( aNumber.Length() ) |
|
1647 { |
|
1648 entry.iTelNumber.Copy( aNumber ); |
|
1649 entry.iText.Copy( KVmbxPhoneBookEntryName ); |
|
1650 entry.iText.AppendNum( lineNumber ); |
|
1651 error = DoPhonebookOperation( EVmbxPhonebookWrite, |
|
1652 &entry ); |
|
1653 VMBLOGSTRING3( "VMBX: RVmbxNumber::SaveVmbxNumberToSim: \ |
|
1654 Write SIM entry %I, status: %I", lineNumber, error ); |
|
1655 } |
|
1656 else |
|
1657 { |
|
1658 error = DoPhonebookOperation( EVmbxPhonebookDelete, |
|
1659 &entry ); |
|
1660 VMBLOGSTRING3( "VMBX: RVmbxNumber::SaveVmbxNumberToSim: \ |
|
1661 Delete SIM entry %I, status: %I", lineNumber, error ); |
|
1662 } |
|
1663 } |
|
1664 } |
|
1665 else |
|
1666 { |
|
1667 error = KErrArgument; |
|
1668 } |
|
1669 } |
|
1670 else |
|
1671 { |
|
1672 error = KErrNotFound; |
|
1673 } |
|
1674 #else // <= VM_USE_TSY |
|
1675 error = KErrNotFound; |
|
1676 #endif // VM_USE_TSY |
|
1677 VMBLOGSTRING( "VMBX: RVmbxNumber::SaveVmbxNumberToSim: <=" ); |
|
1678 return error; //to be removed |
|
1679 } |
|
1680 |
|
1681 // ----------------------------------------------------------------------------- |
|
1682 // RVmbxNumber::SaveVmbxNumberToPhone() |
|
1683 // Saves vmbx number to phone memory |
|
1684 // ----------------------------------------------------------------------------- |
|
1685 // |
|
1686 /***************************************************** |
|
1687 * Series 60 Customer / ETel |
|
1688 * Series 60 ETel API |
|
1689 *****************************************************/ |
|
1690 TInt RVmbxNumber::SaveVmbxNumberToPhone( const TDesC& aNumber, |
|
1691 TVmbxNumberEntry aEntry ) |
|
1692 { |
|
1693 VMBLOGSTRING( "VMBX: RVmbxNumber::SaveVmbxNumberToPhone: =>" ); |
|
1694 |
|
1695 __ASSERT_DEBUG( iFlags & KVmFlagOpened, |
|
1696 User::Panic( KVmbxPanicCategory, EVmbxNotConnected ) ); |
|
1697 __ASSERT_DEBUG( aNumber.Length() <= KVmbxMaxNumberLength, |
|
1698 User::Panic( KVmbxPanicCategory, EVmbxNumberTooLong ) ); |
|
1699 |
|
1700 // AllowedToChangeTheNumber() check not done in this method |
|
1701 // in order to always allow saving. |
|
1702 TInt lineNumber( aEntry ); |
|
1703 TInt error( KErrNone ); |
|
1704 |
|
1705 if ( aEntry == EAlsActiveLineEntry ) |
|
1706 { |
|
1707 // get the current ALS line |
|
1708 if ( GetAlsLine( lineNumber ) != KErrNone ) |
|
1709 { |
|
1710 lineNumber = EAlsLine1; // if problems, assume primary line |
|
1711 } |
|
1712 } |
|
1713 |
|
1714 TUint32 keyword = lineNumber == |
|
1715 EAlsLine1Entry ? KVmbxNumberLinePrimary: KVmbxNumberLineAuxiliary; |
|
1716 error = iSession->Set( keyword, aNumber ); |
|
1717 |
|
1718 if ( !error ) |
|
1719 { |
|
1720 // Client will generate the event itself on request. |
|
1721 if ( iFlags & KVmFlagNotifyRequested ) |
|
1722 { |
|
1723 HandleNotifyString( keyword, aNumber ); |
|
1724 } |
|
1725 } |
|
1726 VMBLOGSTRING( "VMBX: RVmbxNumber::SaveVmbxNumberToPhone: <=" ); |
|
1727 return error; |
|
1728 } |
|
1729 |
|
1730 // ----------------------------------------------------------------------------- |
|
1731 // RVmbxNumber::NotifyVmbxNumberChangeL |
|
1732 // Issues a notify request on a vmbx number change |
|
1733 // ----------------------------------------------------------------------------- |
|
1734 // |
|
1735 EXPORT_C void RVmbxNumber::NotifyVmbxNumberChangeL( |
|
1736 MVmbxNotifyHandler* aHandler, TBool aNotifyOnActiveLineOnly ) |
|
1737 { |
|
1738 VMBLOGSTRING( "VMBX: RVmbxNumber::NotifyVmbxNumberChangeL: =>" ); |
|
1739 __ASSERT_DEBUG( iFlags & ( KVmFlagOpened ), |
|
1740 User::Panic( KVmbxPanicCategory, EVmbxNotConnected ) ); |
|
1741 |
|
1742 iNotifyCallBack = aHandler; |
|
1743 SubscribeSATNotificationsL(); // subscribe SAT notifications |
|
1744 |
|
1745 // only issue a new notify request if there isn't one already |
|
1746 if ( !( iFlags & KVmFlagNotifyRequested ) ) |
|
1747 { |
|
1748 iNotifyHandler = CCenRepNotifyHandler::NewL( *this, *iSession ); |
|
1749 iNotifyHandler->StartListeningL(); |
|
1750 |
|
1751 iFlags |= KVmFlagNotifyRequested; |
|
1752 } |
|
1753 |
|
1754 if ( aNotifyOnActiveLineOnly ) |
|
1755 { |
|
1756 iFlags |= KVmFlagNotifyOnActiveLineOnly; |
|
1757 } |
|
1758 else |
|
1759 { |
|
1760 iFlags &= ( ~KVmFlagNotifyOnActiveLineOnly ); |
|
1761 } |
|
1762 VMBLOGSTRING( "VMBX: RVmbxNumber::NotifyVmbxNumberChangeL: <=" ); |
|
1763 } |
|
1764 |
|
1765 // ----------------------------------------------------------------------------- |
|
1766 // RVmbxNumber::SubscribeSATNotificationsL |
|
1767 // Subscribe SAT notifications |
|
1768 // ----------------------------------------------------------------------------- |
|
1769 void RVmbxNumber::SubscribeSATNotificationsL() |
|
1770 { |
|
1771 if ( iPhoneBookType == EMBDNPhoneBook ) |
|
1772 { |
|
1773 iRSatSession.ConnectL(); |
|
1774 iRSatClient.OpenL( iRSatSession ); |
|
1775 iObservedFileList.Append( KMbdnEf ); |
|
1776 iObservedFileList.Append( KMbiEf ); |
|
1777 iRSatClient.NotifyFileChangeL( iObservedFileList ); |
|
1778 } |
|
1779 } |
|
1780 |
|
1781 // ----------------------------------------------------------------------------- |
|
1782 // RVmbxNumber::NotifyVmbxNumberChangeCancel |
|
1783 // Cancels a notify request on a vmbx number change. |
|
1784 // ----------------------------------------------------------------------------- |
|
1785 // |
|
1786 EXPORT_C void RVmbxNumber::NotifyVmbxNumberChangeCancel() |
|
1787 { |
|
1788 VMBLOGSTRING( "VMBX: RVmbxNumber::NotifyVmbxNumberChangeCancel: =>" ); |
|
1789 __ASSERT_DEBUG( iFlags & KVmFlagOpened, |
|
1790 User::Panic( KVmbxPanicCategory, EVmbxNotConnected ) ); |
|
1791 |
|
1792 iNotifyHandler->StopListening(); |
|
1793 |
|
1794 iFlags &= ( ~KVmFlagNotifyRequested ); |
|
1795 VMBLOGSTRING( "VMBX: RVmbxNumber::NotifyVmbxNumberChangeCancel: <=" ); |
|
1796 } |
|
1797 |
|
1798 // ----------------------------------------------------------------------------- |
|
1799 // RVmbxNumber::NotifyAlsLineChangeL |
|
1800 // Issues a notify request on active ALS line change |
|
1801 // ----------------------------------------------------------------------------- |
|
1802 // |
|
1803 EXPORT_C void RVmbxNumber::NotifyAlsLineChangeL( MVmbxAlsObserver* aObserver ) |
|
1804 { |
|
1805 VMBLOGSTRING( "VMBX: RVmbxNumber::NotifyAlsLineChangeL: =>" ); |
|
1806 __ASSERT_DEBUG( iFlags & KVmFlagOpened, |
|
1807 User::Panic( KVmbxPanicCategory, EVmbxNotConnected ) ); |
|
1808 iUserAlsObserver = aObserver; |
|
1809 VMBLOGSTRING( "VMBX: RVmbxNumber::NotifyAlsLineChangeL: <=" ); |
|
1810 } |
|
1811 |
|
1812 // ----------------------------------------------------------------------------- |
|
1813 // RVmbxNumber::NotifyAlsLineChangeCancel |
|
1814 // Cancels a notify request on ALS line change |
|
1815 // ----------------------------------------------------------------------------- |
|
1816 // |
|
1817 EXPORT_C void RVmbxNumber::NotifyAlsLineChangeCancel() |
|
1818 { |
|
1819 VMBLOGSTRING( "VMBX: RVmbxNumber::NotifyAlsLineChangeCancel: =>" ); |
|
1820 __ASSERT_DEBUG( iFlags & KVmFlagOpened, |
|
1821 User::Panic(KVmbxPanicCategory, EVmbxNotConnected) ); |
|
1822 iUserAlsObserver = NULL; |
|
1823 VMBLOGSTRING( "VMBX: RVmbxNumber::NotifyAlsLineChangeCancel: <=" ); |
|
1824 } |
|
1825 |
|
1826 // ----------------------------------------------------------------------------- |
|
1827 // RVmbxNumber::Close |
|
1828 // Closes the resources allocated in Open |
|
1829 // ----------------------------------------------------------------------------- |
|
1830 // |
|
1831 /***************************************************** |
|
1832 * Series 60 Customer / ETel |
|
1833 * Series 60 ETel API |
|
1834 *****************************************************/ |
|
1835 EXPORT_C void RVmbxNumber::Close() |
|
1836 { |
|
1837 VMBLOGSTRING( "VMBX: RVmbxNumber::Close: =>" ); |
|
1838 if ( iCntFetch ) |
|
1839 { |
|
1840 delete iCntFetch; |
|
1841 iCntFetch = NULL; |
|
1842 } |
|
1843 |
|
1844 iRSatClient.Cancel(); |
|
1845 iRSatClient.Close(); |
|
1846 iRSatSession.Close(); |
|
1847 if ( iClosedPtr ) |
|
1848 { |
|
1849 *iClosedPtr = ETrue; |
|
1850 iClosedPtr = NULL; |
|
1851 } |
|
1852 |
|
1853 if ( iVMSimQueryDialog ) |
|
1854 { |
|
1855 TRAP_IGNORE( iVMSimQueryDialog->VMSimDismissDialogL() ); |
|
1856 iVMSimQueryDialog = NULL; |
|
1857 } |
|
1858 |
|
1859 if ( iQuery ) |
|
1860 { |
|
1861 delete iQuery; |
|
1862 iQuery = NULL; |
|
1863 } |
|
1864 |
|
1865 if ( iVideoQuery ) |
|
1866 { |
|
1867 delete iVideoQuery; |
|
1868 iVideoQuery = NULL; |
|
1869 } |
|
1870 // Type selection query |
|
1871 if ( iTypeSelectionQuery ) |
|
1872 { |
|
1873 delete iTypeSelectionQuery; |
|
1874 iTypeSelectionQuery = NULL; |
|
1875 } |
|
1876 |
|
1877 iVmbxServiceSelection.Close(); |
|
1878 if ( iResourceFileOffset ) |
|
1879 { |
|
1880 iCoeEnv->DeleteResourceFile( iResourceFileOffset ); |
|
1881 iResourceFileOffset = 0; |
|
1882 } |
|
1883 |
|
1884 CloseETel(); |
|
1885 |
|
1886 iUserAlsObserver = NULL; |
|
1887 |
|
1888 // these automatically cancel all observations as well |
|
1889 |
|
1890 iSsSettings.Close(); |
|
1891 |
|
1892 iFlags = 0; |
|
1893 VMBLOGSTRING( "VMBX: RVmbxNumber::Close: <=" ); |
|
1894 } |
|
1895 |
|
1896 // ----------------------------------------------------------------------------- |
|
1897 // RVmbxNumber::LoadResourceL |
|
1898 // Loads the resources needed for queries and confirmation notes |
|
1899 // ----------------------------------------------------------------------------- |
|
1900 // |
|
1901 void RVmbxNumber::LoadResourceL() |
|
1902 { |
|
1903 VMBLOGSTRING( "VMBX: RVmbxNumber::LoadResourceL: =>" ); |
|
1904 TFileName fileName; |
|
1905 fileName += KVmbxResourceFileDrive; |
|
1906 fileName += KDC_RESOURCE_FILES_DIR; |
|
1907 fileName += KVmbxResourceFileName; |
|
1908 BaflUtils::NearestLanguageFile( iCoeEnv->FsSession(), fileName ); |
|
1909 iResourceFileOffset = iCoeEnv->AddResourceFileL( fileName ); |
|
1910 VMBLOGSTRING( "VMBX: RVmbxNumber::LoadResourceL: <=" ); |
|
1911 } |
|
1912 |
|
1913 // ----------------------------------------------------------------------------- |
|
1914 // RVmbxNumber::AllowedToChangeTheNumber |
|
1915 // Check wether the voice mailbox number can be changed |
|
1916 // ----------------------------------------------------------------------------- |
|
1917 // |
|
1918 EXPORT_C TBool RVmbxNumber::AllowedToChangeTheNumber() |
|
1919 { |
|
1920 VMBLOGSTRING( "VMBX: RVmbxNumber::AllowedToChangeTheNumber: =>" ); |
|
1921 TBool ret( ETrue ); |
|
1922 |
|
1923 if ( EUiNmbrChangeNotAllowed & iVmUiOpts ) |
|
1924 { |
|
1925 ret = EFalse; |
|
1926 } |
|
1927 VMBLOGSTRING2( "RVmbxNumber::AllowedToChangeTheNumber \ |
|
1928 iVmUiOpts = %M", iVmUiOpts ); |
|
1929 VMBLOGSTRING( "VMBX: RVmbxNumber::AllowedToChangeTheNumber: <=" ); |
|
1930 return ret; |
|
1931 } |
|
1932 |
|
1933 // ----------------------------------------------------------------------------- |
|
1934 // RVmbxNumber::HandleNotifyString |
|
1935 // To notify the client about changes for string value keys |
|
1936 // ----------------------------------------------------------------------------- |
|
1937 // |
|
1938 void RVmbxNumber::HandleNotifyString( TUint32 aKey, const TDesC16& aValue ) |
|
1939 { |
|
1940 VMBLOGSTRING( "VMBX: RVmbxNumber::HandleNotifyString: =>" ); |
|
1941 TInt alsline( EAlsLine1 ); |
|
1942 |
|
1943 // get the current ALS line |
|
1944 if ( GetAlsLine( alsline ) != KErrNone ) |
|
1945 { |
|
1946 alsline = EAlsLine1; // if problems, assume primary line |
|
1947 } |
|
1948 if ( iNotifyCallBack ) |
|
1949 { |
|
1950 TInt notifyLine( 0 ); |
|
1951 |
|
1952 if ( aKey == KVmbxNumberLinePrimary ) |
|
1953 { |
|
1954 notifyLine = EAlsLine1Entry; |
|
1955 } |
|
1956 else if ( aKey == KVmbxNumberLineAuxiliary ) |
|
1957 { |
|
1958 notifyLine = EAlsLine2Entry; |
|
1959 } |
|
1960 |
|
1961 if ( ( iFlags & KVmFlagNotifyOnActiveLineOnly ) && alsline != notifyLine ) |
|
1962 { |
|
1963 VMBLOGSTRING( "VMBX: RVmbxNumber::HandleNotifyString: \ |
|
1964 Line not notifyline" ); |
|
1965 return; |
|
1966 } |
|
1967 |
|
1968 if ( notifyLine == EAlsLine1Entry || notifyLine == EAlsLine2Entry ) |
|
1969 { |
|
1970 TRAPD( err, iNotifyCallBack->HandleNotifyL( notifyLine, aValue ) ); |
|
1971 if ( err != KErrNone ) |
|
1972 { |
|
1973 VMBLOGSTRING( "VMBX: RVmbxNumber::HandleNotifyString: \ |
|
1974 Notify handle error" ); |
|
1975 _LIT( KVmbxPanicType,"iNotifyCallBack->HandleNotifyL" ); |
|
1976 User::Panic( KVmbxPanicType, err ); |
|
1977 } |
|
1978 } |
|
1979 } |
|
1980 VMBLOGSTRING( "VMBX: RVmbxNumber::HandleNotifyString: <=" ); |
|
1981 } |
|
1982 |
|
1983 // ----------------------------------------------------------------------------- |
|
1984 // RVmbxNumber::HandleNotifyGeneric |
|
1985 // To notify the client about changes in keys when the whole repository |
|
1986 // is listened for. |
|
1987 // ----------------------------------------------------------------------------- |
|
1988 // |
|
1989 void RVmbxNumber::HandleNotifyGeneric( TUint32 aKey ) |
|
1990 { |
|
1991 VMBLOGSTRING( "VMBX: RVmbxNumber::HandleNotifyGeneric: =>" ); |
|
1992 if ( aKey == NCentralRepositoryConstants::KInvalidNotificationId ) |
|
1993 { |
|
1994 |
|
1995 // We have to check which keys have changed. |
|
1996 } |
|
1997 else |
|
1998 { |
|
1999 |
|
2000 //Check the key value of the particular key being changed and |
|
2001 //do further processing. |
|
2002 } |
|
2003 |
|
2004 if ( iQuery ) |
|
2005 { |
|
2006 // if the vmbx number is saved,notify to dismiss the query. |
|
2007 iQuery->DismissQueryDlg(); |
|
2008 } |
|
2009 if ( iVideoQuery ) |
|
2010 { |
|
2011 // if the video number is saved,notify to dismiss the query. |
|
2012 iVideoQuery->DismissQueryDlg(); |
|
2013 } |
|
2014 VMBLOGSTRING( "VMBX: RVmbxNumber::HandleNotifyGeneric: <=" ); |
|
2015 } |
|
2016 |
|
2017 |
|
2018 // ----------------------------------------------------------------------------- |
|
2019 // RVmbxNumber::PhoneSettingChanged |
|
2020 // To notify changes in SS settings in phone |
|
2021 // ----------------------------------------------------------------------------- |
|
2022 // |
|
2023 void RVmbxNumber::PhoneSettingChanged( TSSSettingsSetting aSetting, |
|
2024 TInt aNewValue ) |
|
2025 { |
|
2026 VMBLOGSTRING( "VMBX: RVmbxNumber::PhoneSettingChanged: =>" ); |
|
2027 TInt alsline( EAlsLine1 ); |
|
2028 if ( aSetting == ESSSettingsAls ) |
|
2029 { |
|
2030 alsline = ( aNewValue == |
|
2031 ESSSettingsAlsAlternate ? EAlsLine2Entry : EAlsLine1Entry ); |
|
2032 |
|
2033 if ( iUserAlsObserver ) |
|
2034 { |
|
2035 TRAP_IGNORE( iUserAlsObserver->HandleAlsChangeL( |
|
2036 ( TVmbxAlsLine ) alsline ) ); |
|
2037 } |
|
2038 } |
|
2039 VMBLOGSTRING( "VMBX: RVmbxNumber::PhoneSettingChanged: <=" ); |
|
2040 } |
|
2041 |
|
2042 // ----------------------------------------------------------------------------- |
|
2043 // RVmbxNumber::GetAlsLine |
|
2044 // Fetches ALS line from SS settings |
|
2045 // ----------------------------------------------------------------------------- |
|
2046 // |
|
2047 EXPORT_C TInt RVmbxNumber::GetAlsLine( TInt& aLineNumber ) const |
|
2048 { |
|
2049 VMBLOGSTRING( "VMBX: RVmbxNumber::GetAlsLine: =>" ); |
|
2050 aLineNumber = EAlsLine1; |
|
2051 |
|
2052 TInt alsline( ESSSettingsAlsPrimary ); |
|
2053 |
|
2054 TInt ret = CONST_CAST( RVmbxNumber*, this )->iSsSettings.Get( |
|
2055 ESSSettingsAls, alsline ); |
|
2056 |
|
2057 if ( alsline == ESSSettingsAlsAlternate ) |
|
2058 { |
|
2059 aLineNumber = EAlsLine2; |
|
2060 } |
|
2061 VMBLOGSTRING( "VMBX: RVmbxNumber::GetAlsLine: <=" ); |
|
2062 return ret; |
|
2063 } |
|
2064 |
|
2065 // ----------------------------------------------------------------------------- |
|
2066 // RVmbxNumber::ShowConfirmationNoteL |
|
2067 // Shows confirmation note to user |
|
2068 // ----------------------------------------------------------------------------- |
|
2069 // |
|
2070 void RVmbxNumber::ShowConfirmationNoteL( TInt aResourceId ) const |
|
2071 { |
|
2072 VMBLOGSTRING( "VMBX: RVmbxNumber::ShowConfirmationNoteL: =>" ); |
|
2073 HBufC* prompt = StringLoader::LoadLC( aResourceId, iCoeEnv ); |
|
2074 |
|
2075 CAknConfirmationNote* note = new( ELeave ) CAknConfirmationNote( ETrue ); |
|
2076 |
|
2077 note->ExecuteLD( *prompt ); |
|
2078 |
|
2079 CleanupStack::PopAndDestroy( prompt ); |
|
2080 VMBLOGSTRING( "VMBX: RVmbxNumber::ShowConfirmationNoteL: <=" ); |
|
2081 } |
|
2082 |
|
2083 // ----------------------------------------------------------------------------- |
|
2084 // RVmbxNumber::IsValidPhoneNumber |
|
2085 // Validates phone number |
|
2086 // ----------------------------------------------------------------------------- |
|
2087 // |
|
2088 TBool RVmbxNumber::IsValidPhoneNumber( const TDesC& aNumber ) const |
|
2089 { |
|
2090 VMBLOGSTRING( "VMBX: RVmbxNumber::IsValidPhoneNumber: =>" ); |
|
2091 TBool isValid( EFalse ); |
|
2092 |
|
2093 if ( aNumber.Length() >= KVmPhNumMinLength ) |
|
2094 { |
|
2095 TInt index( 0 ); |
|
2096 TInt digits( 0 ); |
|
2097 |
|
2098 // Skip the possible '*'s and '#'s in the beginning. |
|
2099 while ( index < aNumber.Length() && |
|
2100 ( aNumber[ index ] == '#' || aNumber[ index ] == '*' || |
|
2101 aNumber[ index ] == ' ') ) |
|
2102 { |
|
2103 index++; |
|
2104 } |
|
2105 |
|
2106 // Skip the possible '+'. |
|
2107 if ( index < aNumber.Length() && aNumber[ index ] == '+' ) |
|
2108 { |
|
2109 index++; |
|
2110 } |
|
2111 |
|
2112 // Count the digits. |
|
2113 // For this let's use another index so that the following |
|
2114 // operation will start from the beginning of the actual |
|
2115 // vmbx number |
|
2116 TInt loopindex = index; |
|
2117 |
|
2118 while ( loopindex < aNumber.Length() && |
|
2119 ( aNumber[ loopindex ] >= '0' && aNumber[ loopindex ] <= '9' |
|
2120 || aNumber[ loopindex ] == ' ') ) |
|
2121 { |
|
2122 if ( aNumber[ loopindex ] != ' ' ) |
|
2123 { |
|
2124 digits++; |
|
2125 } |
|
2126 loopindex++; |
|
2127 } |
|
2128 |
|
2129 // Check that there are only allowed characters in the remaining string. |
|
2130 while ( index < aNumber.Length() ) |
|
2131 { |
|
2132 TText t = aNumber[ index ]; |
|
2133 |
|
2134 if ( (t < '0' && t > '9') || t == ' ' ) |
|
2135 { |
|
2136 break; |
|
2137 } |
|
2138 index++; |
|
2139 } |
|
2140 |
|
2141 // If only legal characters were encountered, index is now same as |
|
2142 // the length of the string. |
|
2143 |
|
2144 // phone number part must have 2...41 digits |
|
2145 // '+' is only allowed as the first character in the string |
|
2146 if ( digits >= KVmPhoneNumDigitsMinLength && |
|
2147 digits <= KVmPhoneNumDigitsMaxLength && |
|
2148 index == aNumber.Length()) |
|
2149 { |
|
2150 isValid = ETrue; |
|
2151 } |
|
2152 } |
|
2153 VMBLOGSTRING( "VMBX: RVmbxNumber::IsValidPhoneNumber: <=" ); |
|
2154 return isValid; |
|
2155 } |
|
2156 |
|
2157 // ----------------------------------------------------------------------------- |
|
2158 // RVmbxNumber::IsEmergencyNumberL |
|
2159 // Checks if a number is an emergency number. |
|
2160 // ----------------------------------------------------------------------------- |
|
2161 // |
|
2162 TBool RVmbxNumber::IsEmergencyNumberL( const TDesC& aNumber ) |
|
2163 { |
|
2164 VMBLOGSTRING( "VMBX: RVmbxNumber::IsEmergencyNumberL: =>" ); |
|
2165 TBool isEmergency = EFalse; |
|
2166 |
|
2167 // Emergency Call API does not strip invalid characters like Call UI does, so it is done manually here. |
|
2168 TPhCltTelephoneNumber number( aNumber.Left( KPhCltTelephoneNumberLength ) ); |
|
2169 PhCltUtils::RemoveInvalidChars( number ); |
|
2170 |
|
2171 CPhCltEmergencyCall* emergencyCall = CPhCltEmergencyCall::NewL( this ); |
|
2172 |
|
2173 TInt result = emergencyCall->IsEmergencyPhoneNumber( number, isEmergency ); |
|
2174 delete emergencyCall; |
|
2175 if ( result != KErrNone ) |
|
2176 { |
|
2177 return EFalse; |
|
2178 } |
|
2179 VMBLOGSTRING( "VMBX: RVmbxNumber::IsEmergencyNumberL: <=" ); |
|
2180 return isEmergency; |
|
2181 } |
|
2182 |
|
2183 // --------------------------------------------------------- |
|
2184 // RVmbxNumber::HandleEmergencyDialL() |
|
2185 // --------------------------------------------------------- |
|
2186 // |
|
2187 void RVmbxNumber::HandleEmergencyDialL( const TInt /*aStatus*/ ) |
|
2188 { |
|
2189 // No action |
|
2190 } |
|
2191 |
|
2192 |
|
2193 // ----------------------------------------------------------------------------- |
|
2194 // RVmbxNumber::PhoneBookInfo |
|
2195 // Fetches information about the SIM phonebook for vmbx numbers |
|
2196 // ----------------------------------------------------------------------------- |
|
2197 // |
|
2198 /***************************************************** |
|
2199 * Series 60 Customer / ETel |
|
2200 * Series 60 ETel API |
|
2201 *****************************************************/ |
|
2202 TInt RVmbxNumber::PhoneBookInfo() |
|
2203 { |
|
2204 VMBLOGSTRING( "VMBX: RVmbxNumber::PhoneBookInfo: =>" ); |
|
2205 TRequestStatus status( KErrNone ); |
|
2206 TInt alsline( EAlsLine1 ); |
|
2207 |
|
2208 // get the current ALS line |
|
2209 if ( GetAlsLine( alsline ) != KErrNone ) |
|
2210 { |
|
2211 alsline = EAlsLine1; // if problems, assume primary line |
|
2212 } |
|
2213 |
|
2214 // This may return KErrInUse if phonebook is being cached |
|
2215 iPhoneBook.GetInfo( status, iPhoneBookInfoPckg ); |
|
2216 User::WaitForRequest( status ); // Wait for asynchronous call to finish |
|
2217 |
|
2218 VMBLOGSTRING2( "VMBX: RVmbxNumber::PhoneBookInfo: \ |
|
2219 SIM Phonebook info read, status: %I", status.Int() ); |
|
2220 VMBLOGSTRING2( "VMBX: RVmbxNumber::PhoneBookInfo: \ |
|
2221 SIM Phonebook write access = %I", |
|
2222 iPhoneBookInfo.iCaps & RMobilePhoneBookStore::KCapsWriteAccess ? 1 : 0); |
|
2223 iFlags &= ~KVmFlagPhonebookBeingCached; |
|
2224 iFlags &= ~KVmFlagSimVmbxNumSupport; |
|
2225 |
|
2226 VMBLOGSTRING2( "MaxNum length from sim: %I", iPhoneBookInfo.iMaxNumLength ); |
|
2227 if ( status == KErrInUse || status == KErrNotReady ) |
|
2228 { |
|
2229 iFlags |= KVmFlagPhonebookBeingCached; |
|
2230 VMBLOGSTRING( "Phonebook Being Cached" ); |
|
2231 } |
|
2232 else if ( status == KErrNone ) |
|
2233 { |
|
2234 //If read access, only then write access possible |
|
2235 if ( iPhoneBookInfo.iCaps & RMobilePhoneBookStore::KCapsReadAccess ) |
|
2236 { |
|
2237 VMBLOGSTRING( "ReadAccess ok" ); |
|
2238 iFlags |= KVmFlagSimReadSupport; |
|
2239 |
|
2240 if ( iPhoneBookInfo.iCaps & RMobilePhoneBookStore::KCapsWriteAccess ) |
|
2241 { |
|
2242 VMBLOGSTRING( "WriteAccess ok" ); |
|
2243 iFlags |= KVmFlagSimWriteSupport; |
|
2244 iFlags |= KVmFlagSimVmbxNumSupport; |
|
2245 } |
|
2246 // Sim access rights are tested only in start up |
|
2247 if ( iStartUpTest ) |
|
2248 { |
|
2249 TestAndSetSimAccessFlags(); |
|
2250 } |
|
2251 } |
|
2252 //As there is no sim support set the memory to phone memory |
|
2253 else |
|
2254 { |
|
2255 // No write capability and line1 in use |
|
2256 if ( ( iMemoryLocation != EVmbxPhoneMemory ) && |
|
2257 ( alsline == EAlsLine1 ) ) |
|
2258 { |
|
2259 iMemoryLocation = EVmbxPhoneMemory; |
|
2260 iSession->Set( KVmUsesSimMemory, EVmbxPhoneMemory ); |
|
2261 } |
|
2262 iFlags &= ~KVmFlagSimReadSupport; |
|
2263 } |
|
2264 } |
|
2265 // no caps fetched |
|
2266 else |
|
2267 { |
|
2268 if ( ( iMemoryLocation != EVmbxPhoneMemory ) && |
|
2269 ( alsline == EAlsLine1 ) ) |
|
2270 {//as there is no sim support set the memory to phone memory |
|
2271 iMemoryLocation = EVmbxPhoneMemory; |
|
2272 iSession->Set( KVmUsesSimMemory, EVmbxPhoneMemory ); |
|
2273 } |
|
2274 iFlags &= ~KVmFlagSimReadSupport; |
|
2275 VMBLOGSTRING( "USim not supported" ); |
|
2276 status = KErrNone; |
|
2277 } |
|
2278 VMBLOGSTRING( "VMBX: RVmbxNumber::PhoneBookInfo: <=" ); |
|
2279 return status.Int(); |
|
2280 } |
|
2281 |
|
2282 // ----------------------------------------------------------------------------- |
|
2283 // RVmbxNumber::IsReadOnlySIM |
|
2284 // Checks if writing to sim is prohibited |
|
2285 // ----------------------------------------------------------------------------- |
|
2286 // |
|
2287 TBool RVmbxNumber::IsReadOnlySIM() |
|
2288 { |
|
2289 VMBLOGSTRING( "VMBX: RVmbxNumber::IsReadOnlySIM. =>" ); |
|
2290 |
|
2291 TBool readOnlySIM = EFalse; |
|
2292 iSession->Get( KReadOnlySim, readOnlySIM ); |
|
2293 VMBLOGSTRING2( "VMBX: RVmbxNumber::IsReadOnlySIM: \ |
|
2294 read only flag = %I", readOnlySIM ); |
|
2295 return readOnlySIM; |
|
2296 } |
|
2297 |
|
2298 // ----------------------------------------------------------------------------- |
|
2299 // RVmbxNumber::DoPhonebookOperation |
|
2300 // Does a vmbx phonebook operation |
|
2301 // ----------------------------------------------------------------------------- |
|
2302 // |
|
2303 TInt RVmbxNumber::DoPhonebookOperation( TVmbxPhonebookOperation aOperation, |
|
2304 TVmbxEntry* aEntry ) |
|
2305 { |
|
2306 VMBLOGSTRING( "VMBX: RVmbxNumber::DoPhonebookOperation: =>" ); |
|
2307 TInt result( KErrNone ); |
|
2308 TInt retryCounter( KVmbxPhonebookRetriesIfInUse ); |
|
2309 |
|
2310 FOREVER |
|
2311 { |
|
2312 retryCounter--; |
|
2313 |
|
2314 switch ( aOperation ) |
|
2315 { |
|
2316 case EVmbxPhonebookGetInfo: |
|
2317 { |
|
2318 result = PhoneBookInfo(); |
|
2319 break; |
|
2320 } |
|
2321 case EVmbxPhonebookRead: |
|
2322 { |
|
2323 TRAPD( readErr, PhonebookReadL( *aEntry ) ); |
|
2324 if ( readErr != KErrNone && readErr != KErrNotFound ) |
|
2325 { |
|
2326 result = KErrNotSupported; |
|
2327 } |
|
2328 break; |
|
2329 } |
|
2330 case EVmbxPhonebookWrite: |
|
2331 { |
|
2332 result = PhonebookWrite( *aEntry ); |
|
2333 break; |
|
2334 } |
|
2335 case EVmbxPhonebookDelete: |
|
2336 { |
|
2337 result = PhonebookDelete( *aEntry ); |
|
2338 break; |
|
2339 } |
|
2340 default: |
|
2341 { |
|
2342 __ASSERT_DEBUG( 0, User::Panic( KVmbxPanicCategory, |
|
2343 EVmbxUnhandledOperation) ); |
|
2344 break; |
|
2345 } |
|
2346 } |
|
2347 |
|
2348 if ( result != KErrInUse || retryCounter <= 0 ) |
|
2349 { |
|
2350 break; |
|
2351 } |
|
2352 |
|
2353 iFlags |= KVmFlagPhonebookBeingCached; |
|
2354 User::After( KVmbxPhonebookRetryDelay ); |
|
2355 } |
|
2356 // set readonly state if aquired |
|
2357 if ( IsReadOnlySIM() ) |
|
2358 { |
|
2359 iFlags &= ~KVmFlagSimWriteSupport; |
|
2360 VMBLOGSTRING( "VMBX: RVmbxNumber::DoPhonebookOperation: ReadOnly set" ); |
|
2361 } |
|
2362 |
|
2363 VMBLOGSTRING( "VMBX: RVmbxNumber::DoPhonebookOperation: <=" ); |
|
2364 return result; |
|
2365 } |
|
2366 |
|
2367 // ----------------------------------------------------------------------------- |
|
2368 // RVmbxNumber::PhonebookReadL |
|
2369 // Reads an entry from the ICC-based phonebook |
|
2370 // ----------------------------------------------------------------------------- |
|
2371 // |
|
2372 /***************************************************** |
|
2373 * Series 60 Customer / ETel |
|
2374 * Series 60 ETel API |
|
2375 *****************************************************/ |
|
2376 void RVmbxNumber::PhonebookReadL( TVmbxEntry& aEntry ) |
|
2377 { |
|
2378 VMBLOGSTRING( "VMBX: RVmbxNumber::PhonebookReadL: =>" ); |
|
2379 TRequestStatus status( KErrNone ); |
|
2380 TInt numEntries( 1 ); |
|
2381 TBuf8<KVmbxPhonebookBufferSize> pbData; |
|
2382 pbData.FillZ(); |
|
2383 pbData.Zero(); |
|
2384 TInt result( KErrNone ); |
|
2385 |
|
2386 // Reset variables |
|
2387 iNumberFound = EFalse; |
|
2388 if ( iAlphaStringFound ) |
|
2389 { |
|
2390 delete iAlphaStringFromSIM; |
|
2391 iAlphaStringFromSIM = NULL; |
|
2392 } |
|
2393 iAlphaStringFound = EFalse; |
|
2394 |
|
2395 if ( iPhoneBookType == EMBDNPhoneBook ) |
|
2396 { |
|
2397 VMBLOGSTRING( "start MBDN PhoneBook read" ); |
|
2398 iPhoneBook.Read( status, iPhoneVoicemailInfo.iVoice, |
|
2399 numEntries, pbData ); |
|
2400 } |
|
2401 else |
|
2402 { |
|
2403 // Record#1 in sim is for line1 number and Record#2 in sim is for |
|
2404 // line2 number so line is used to fetch |
|
2405 VMBLOGSTRING( "start VMBX PhoneBook read" ); |
|
2406 iPhoneBook.Read( status, aEntry.iIndex, numEntries, pbData ); |
|
2407 } |
|
2408 |
|
2409 User::WaitForRequest( status ); // Wait for asynchronous call to finish |
|
2410 VMBLOGSTRING2( "PhoneBook read status = %I", status.Int() ); |
|
2411 |
|
2412 if ( status == KErrNone || status == KErrNotFound ) |
|
2413 { |
|
2414 if ( pbData.Length() ) |
|
2415 { |
|
2416 // -> Search Tags "ETagPBNumber" and "ETagPBText" |
|
2417 // and read (decode) them |
|
2418 TUint8 tagValue(0); |
|
2419 CPhoneBookBuffer::TPhBkTagType dataType( |
|
2420 CPhoneBookBuffer::EPhBkTypeNoData ); |
|
2421 |
|
2422 CPhoneBookBuffer* pbkBuffer = NULL; |
|
2423 TRAPD( err, pbkBuffer = new(ELeave) CPhoneBookBuffer() ); |
|
2424 if ( err != KErrNone ) |
|
2425 { |
|
2426 VMBLOGSTRING( "VMBX: RVmbxNumber::PhonebookReadL: \ |
|
2427 Phonebook creation error" ); |
|
2428 User::Leave( err ); |
|
2429 } |
|
2430 |
|
2431 pbkBuffer->Set( &pbData ); |
|
2432 pbkBuffer->StartRead(); |
|
2433 |
|
2434 // Read first "new-entry-tag" |
|
2435 result = pbkBuffer->GetTagAndType( tagValue, dataType ); |
|
2436 |
|
2437 if ( result != KErrNone || tagValue != RMobilePhoneBookStore::ETagPBNewEntry) |
|
2438 { |
|
2439 delete pbkBuffer; |
|
2440 VMBLOGSTRING( "VMBX: RVmbxNumber::PhonebookReadL: \ |
|
2441 Unknown error" ); |
|
2442 User::Leave( KErrUnknown ); // Something wrong in TLV |
|
2443 } |
|
2444 |
|
2445 // search number and text fields from TLV entry |
|
2446 result = pbkBuffer->GetTagAndType( tagValue, dataType ); |
|
2447 |
|
2448 while ( result == KErrNone && pbkBuffer->RemainingReadLength() > 0 ) |
|
2449 { |
|
2450 VMBLOGSTRING2("VMBX: RVmbxNumber::PhonebookReadL(): tagValue: %d", tagValue ) |
|
2451 VMBLOGSTRING2("VMBX: RVmbxNumber::PhonebookReadL(): dataType: %d", dataType ) |
|
2452 |
|
2453 // Check for text field |
|
2454 if ( tagValue == RMobilePhoneBookStore::ETagPBText ) |
|
2455 { |
|
2456 // Alpha string field found from TLV entry, |
|
2457 // assuming 16bit data |
|
2458 TPtrC16 alphaPtrC; |
|
2459 result = pbkBuffer->GetValue( alphaPtrC ); |
|
2460 if ( result == KErrNone ) |
|
2461 { |
|
2462 iAlphaStringFromSIM = alphaPtrC.AllocL(); |
|
2463 iAlphaStringFound = ETrue; |
|
2464 VMBLOGSTRING2("VMBX: RVmbxNumber::PhonebookReadL(): iAlphaStringFromSIM: %S", iAlphaStringFromSIM ) |
|
2465 } |
|
2466 } |
|
2467 // Check for number field |
|
2468 else if ( tagValue == RMobilePhoneBookStore::ETagPBNumber ) |
|
2469 { |
|
2470 // Number field found from TLV entry, assuming 16bit data |
|
2471 TPtrC16 numberPtrC; |
|
2472 result = pbkBuffer->GetValue( numberPtrC ); |
|
2473 iNumberFound = ETrue; |
|
2474 VMBLOGSTRING("VMBX: RVmbxNumber::PhonebookReadL(): ETagPBNumber found."); |
|
2475 |
|
2476 if ( result == KErrNone ) |
|
2477 { |
|
2478 // Error code is returned if number not fit to |
|
2479 // local buffer. |
|
2480 if ( numberPtrC.Length() > aEntry.iTelNumber.MaxLength() ) |
|
2481 { |
|
2482 delete pbkBuffer; |
|
2483 VMBLOGSTRING( "VMBX: RVmbxNumber::PhonebookReadL: \ |
|
2484 Overflow error" ); |
|
2485 User::Leave( KErrOverflow ); |
|
2486 } |
|
2487 else |
|
2488 { |
|
2489 // copy number to local buffer |
|
2490 aEntry.iTelNumber.Copy( numberPtrC ); |
|
2491 VMBLOGSTRING2("VMBX: RVmbxNumber::PhonebookReadL(): ETagPBNumber found. Number: %S", &aEntry.iTelNumber ); |
|
2492 } |
|
2493 } |
|
2494 } |
|
2495 else |
|
2496 { |
|
2497 // skip field |
|
2498 pbkBuffer->SkipValue( dataType ); |
|
2499 } |
|
2500 // Read next field type |
|
2501 result = pbkBuffer->GetTagAndType( tagValue, dataType ); |
|
2502 } |
|
2503 |
|
2504 // Number and Alpha fields not found from TLV entry |
|
2505 if ( !iAlphaStringFound && !iNumberFound ) |
|
2506 { |
|
2507 delete pbkBuffer; |
|
2508 VMBLOGSTRING( "VMBX: RVmbxNumber::PhonebookReadL: \ |
|
2509 Not found error" ); |
|
2510 User::Leave( KErrNotFound ); |
|
2511 } |
|
2512 delete pbkBuffer; |
|
2513 } |
|
2514 else |
|
2515 { |
|
2516 VMBLOGSTRING( "VMBX: RVmbxNumber::PhonebookReadL: Not found error" ); |
|
2517 iNumberFromSim.FillZ(); |
|
2518 iNumberFromSim.Zero(); |
|
2519 User::Leave( KErrNotFound ); |
|
2520 } |
|
2521 } |
|
2522 else |
|
2523 { |
|
2524 // sim read-only and number fetched by GetPhonebookInfo |
|
2525 // so return number |
|
2526 if ( iNumberFromSim.Length() && !( iFlags & KVmFlagSimWriteSupport ) ) |
|
2527 { |
|
2528 aEntry.iTelNumber.Copy( iNumberFromSim ); |
|
2529 iMemoryLocation = EVmbxPhoneMemory; |
|
2530 iSession->Set( KVmUsesSimMemory, EVmbxPhoneMemory ); |
|
2531 VMBLOGSTRING2( "Number value = %S", &iNumberFromSim ); |
|
2532 VMBLOGSTRING2( "iMemoryLocation = %d", iMemoryLocation ); |
|
2533 VMBLOGSTRING( "Startuptest ongoing, read only sim, number fetched" ); |
|
2534 } |
|
2535 else |
|
2536 { |
|
2537 User::Leave( status.Int() ); |
|
2538 } |
|
2539 } |
|
2540 VMBLOGSTRING( "VMBX: RVmbxNumber::PhonebookReadL: <=" ); |
|
2541 } |
|
2542 |
|
2543 // ----------------------------------------------------------------------------- |
|
2544 // RVmbxNumber::PhonebookWrite |
|
2545 // Writes an entry into ICC-based phonebook |
|
2546 // ----------------------------------------------------------------------------- |
|
2547 // |
|
2548 /***************************************************** |
|
2549 * Series 60 Customer / ETel |
|
2550 * Series 60 ETel API |
|
2551 *****************************************************/ |
|
2552 TInt RVmbxNumber::PhonebookWrite( TVmbxEntry& aEntry ) |
|
2553 { |
|
2554 VMBLOGSTRING( "VMBX: RVmbxNumber::PhonebookWrite: =>" ); |
|
2555 TRequestStatus status( KErrNone ); |
|
2556 TBuf8<KVmbxPhonebookBufferSize> pbData; |
|
2557 pbData.FillZ(); |
|
2558 |
|
2559 CPhoneBookBuffer* pbkBuffer = NULL; |
|
2560 TRAPD( err, pbkBuffer = new(ELeave) CPhoneBookBuffer() ); |
|
2561 if (err != KErrNone) |
|
2562 { |
|
2563 VMBLOGSTRING( "VMBX: RVmbxNumber::PhonebookWrite: \ |
|
2564 Phonebook creation error" ); |
|
2565 return err; |
|
2566 } |
|
2567 |
|
2568 pbkBuffer->Set( &pbData ); |
|
2569 |
|
2570 // New entry |
|
2571 status = pbkBuffer->AddNewEntryTag(); |
|
2572 |
|
2573 // Add index |
|
2574 // Type of index is TUint16 in Multimode ETel and TInt in old ETel. |
|
2575 status = pbkBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBAdnIndex, |
|
2576 (TUint16)aEntry.iIndex ); |
|
2577 |
|
2578 // Add name if it existed on SIM card |
|
2579 // Type of ETagPBText is TDes16 |
|
2580 if ( iAlphaStringFound ) |
|
2581 { |
|
2582 status = pbkBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBText, |
|
2583 *iAlphaStringFromSIM ); |
|
2584 } |
|
2585 |
|
2586 // Add number |
|
2587 // Type of ETagPBNumber is TDes16 |
|
2588 status = pbkBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBNumber, |
|
2589 aEntry.iTelNumber ); |
|
2590 if ( iPhoneBookType == EMBDNPhoneBook ) |
|
2591 { |
|
2592 TInt index = iPhoneVoicemailInfo.iVoice; |
|
2593 iPhoneBook.Write( status, pbData, index ); |
|
2594 VMBLOGSTRING( "Mbdn writing" ); |
|
2595 } |
|
2596 else |
|
2597 { |
|
2598 iPhoneBook.Write( status, pbData, aEntry.iIndex ); |
|
2599 VMBLOGSTRING( "6f17 writing" ); |
|
2600 } |
|
2601 User::WaitForRequest( status ); // Wait for asynchronous call to finish |
|
2602 VMBLOGSTRING2( "PhonebookWrite: status=%I", status.Int() ); |
|
2603 |
|
2604 delete pbkBuffer; |
|
2605 VMBLOGSTRING( "VMBX: RVmbxNumber::PhonebookWrite: <=" ); |
|
2606 return status.Int(); |
|
2607 } |
|
2608 |
|
2609 // ----------------------------------------------------------------------------- |
|
2610 // RVmbxNumber::PhonebookDelete |
|
2611 // Removes an entry from ICC-based phonebook |
|
2612 // ----------------------------------------------------------------------------- |
|
2613 // |
|
2614 /***************************************************** |
|
2615 * Series 60 Customer / ETel |
|
2616 * Series 60 ETel API |
|
2617 *****************************************************/ |
|
2618 TInt RVmbxNumber::PhonebookDelete( TVmbxEntry& aEntry ) |
|
2619 { |
|
2620 VMBLOGSTRING( "VMBX: RVmbxNumber::PhonebookDelete: =>" ); |
|
2621 TRequestStatus status( KErrNone ); |
|
2622 if ( iPhoneBookType == EMBDNPhoneBook ) |
|
2623 { |
|
2624 TInt index = iPhoneVoicemailInfo.iVoice; |
|
2625 iPhoneBook.Delete( status, index ); |
|
2626 } |
|
2627 else |
|
2628 { |
|
2629 iPhoneBook.Delete( status, aEntry.iIndex ); |
|
2630 } |
|
2631 User::WaitForRequest( status ); // Wait for asynchronous call to finish |
|
2632 VMBLOGSTRING( "VMBX: RVmbxNumber::PhonebookDelete: <=" ); |
|
2633 return status.Int(); |
|
2634 } |
|
2635 |
|
2636 |
|
2637 // ----------------------------------------------------------------------------- |
|
2638 // RVmbxNumber::FetchNumberFromPhonebook2L |
|
2639 // Create and show Phonebook's Single Fetch Dialog |
|
2640 // ----------------------------------------------------------------------------- |
|
2641 // |
|
2642 void RVmbxNumber::FetchNumberFromPhonebook2L( TDes& aPhoneNumber ) |
|
2643 { |
|
2644 VMBLOGSTRING( "VMBX: RVmbxNumber::FetchNumberFromPhonebook2L: =>" ); |
|
2645 |
|
2646 CPhCntFactory* contactFactory = CreateCntFactoryL(); |
|
2647 CleanupStack::PushL( contactFactory ); |
|
2648 iCntFetch = NULL; |
|
2649 iCntFetch = contactFactory->CreateSingleItemFetchL(); |
|
2650 CPhCntSelection* contactSelect = NULL; |
|
2651 |
|
2652 TRAPD( error, contactSelect = iCntFetch->SelectPhoneNumberLD() ); |
|
2653 // Task swapper close activated |
|
2654 if ( error != KErrNone ) |
|
2655 { |
|
2656 contactSelect = NULL; |
|
2657 iCntFetch = NULL; |
|
2658 User::Leave( error ); //close application |
|
2659 } |
|
2660 |
|
2661 // This check is needed because contactselect is NULL in case of user |
|
2662 // presses back in contact fetch dialog. It will NOT leave. |
|
2663 if ( contactSelect ) |
|
2664 { |
|
2665 if ( contactSelect->Number().Length() ) |
|
2666 { |
|
2667 aPhoneNumber = contactSelect->Number().Left( KVmbxMaxNumberLength ); |
|
2668 } |
|
2669 delete contactSelect; |
|
2670 contactSelect = NULL; |
|
2671 } |
|
2672 |
|
2673 iCntFetch = NULL; |
|
2674 CleanupStack::PopAndDestroy( contactFactory ); |
|
2675 |
|
2676 //for removing special chars from number fetched from phone book |
|
2677 TText ch = 0; |
|
2678 TInt len = aPhoneNumber.Length(); |
|
2679 for ( TInt cnt = 0; cnt < len; cnt++ ) |
|
2680 { |
|
2681 ch = aPhoneNumber[cnt]; |
|
2682 switch ( ch ) |
|
2683 { |
|
2684 case '(': |
|
2685 case ')': |
|
2686 case '-': |
|
2687 case ' ': |
|
2688 { |
|
2689 aPhoneNumber.Delete( cnt, 1 ); |
|
2690 cnt--; |
|
2691 len = aPhoneNumber.Length(); |
|
2692 break; |
|
2693 } |
|
2694 default: |
|
2695 break; |
|
2696 } |
|
2697 } |
|
2698 |
|
2699 |
|
2700 VMBLOGSTRING( "VMBX: RVmbxNumber::FetchNumberFromPhonebook2L: <=" ); |
|
2701 } |
|
2702 |
|
2703 // ----------------------------------------------------------------------------- |
|
2704 // RVmbxNumber::GetVmNumFromSIM |
|
2705 // Retrieves voice mailbox number from SIM/R-UIM |
|
2706 // ----------------------------------------------------------------------------- |
|
2707 // |
|
2708 #ifdef VM_USE_TSY |
|
2709 TInt RVmbxNumber::GetVmNumFromSIM( TDes& aNumber, TInt aLineNumber ) |
|
2710 #else |
|
2711 TInt RVmbxNumber::GetVmNumFromSIM( TDes& /*aNumber*/, TInt /*aLineNumber*/ ) |
|
2712 #endif |
|
2713 { |
|
2714 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmNumFromSIM: =>" ); |
|
2715 TInt ret( KErrNotFound ); |
|
2716 |
|
2717 #ifdef VM_USE_TSY |
|
2718 |
|
2719 if ( iFlags & KVmFlagPhonebookBeingCached ) |
|
2720 { |
|
2721 ret = DoPhonebookOperation( EVmbxPhonebookGetInfo ); |
|
2722 |
|
2723 if ( ret != KErrNone ) |
|
2724 { |
|
2725 VMBLOGSTRING2( "DoPhonebookOperation getinfo retval = %I", ret ); |
|
2726 return ret; |
|
2727 } |
|
2728 } |
|
2729 |
|
2730 // Now we have SIM support information updated |
|
2731 if ( iFlags & KVmFlagSimReadSupport ) |
|
2732 { |
|
2733 TVmbxEntry entry; |
|
2734 entry.iIndex = aLineNumber; // 1 or 2 |
|
2735 ret = DoPhonebookOperation( EVmbxPhonebookRead, &entry ); |
|
2736 VMBLOGSTRING3( "VMBX: RVmbxNumber::GetVmNumFromSIM: \ |
|
2737 Read SIM entry %I, status: %I", aLineNumber, ret ); |
|
2738 |
|
2739 if ( ret == KErrNone ) |
|
2740 { |
|
2741 if ( !entry.iTelNumber.Length() ) |
|
2742 { |
|
2743 ret = KErrNotFound; |
|
2744 } |
|
2745 else |
|
2746 { |
|
2747 aNumber.Copy( entry.iTelNumber ); |
|
2748 } |
|
2749 } |
|
2750 } |
|
2751 else |
|
2752 { |
|
2753 ret = KErrNotSupported; |
|
2754 } |
|
2755 |
|
2756 if ( IsEmergencyNumberL( aNumber ) ) |
|
2757 { |
|
2758 aNumber.Zero(); |
|
2759 ret = KErrNotFound; |
|
2760 } |
|
2761 |
|
2762 VMBLOGSTRING2( "Number = %S", &aNumber ); |
|
2763 #endif // VM_USE_TSY |
|
2764 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmNumFromSIM: <=" ); |
|
2765 return ret; |
|
2766 } |
|
2767 |
|
2768 // ----------------------------------------------------------------------------- |
|
2769 // RVmbxNumber::GetVmNumFromVMN |
|
2770 // Retrieves voice mailbox number from VMN summary info |
|
2771 // ----------------------------------------------------------------------------- |
|
2772 // |
|
2773 TInt RVmbxNumber::GetVmNumFromVMN( TDes& aNumber ) |
|
2774 { |
|
2775 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmNumFromVMN: =>" ); |
|
2776 TBuf<KVmbxMaxNumberLength> number; |
|
2777 TInt ret( KErrNotFound ); |
|
2778 TInt value = 0; |
|
2779 |
|
2780 ret = iSession->Get( KVmSummaryInfoIsSet, value ); |
|
2781 |
|
2782 if ( !ret && value == 1 ) |
|
2783 { |
|
2784 ret = iSession->Get( KVmCallbackNumber, number ); |
|
2785 if ( !ret ) |
|
2786 { |
|
2787 if ( number.Length() ) |
|
2788 { |
|
2789 aNumber.Copy( number ); |
|
2790 } |
|
2791 else |
|
2792 { |
|
2793 ret = KErrNotFound; |
|
2794 } |
|
2795 } |
|
2796 } |
|
2797 |
|
2798 if ( IsEmergencyNumberL( aNumber ) ) |
|
2799 { |
|
2800 aNumber.Zero(); |
|
2801 ret = KErrNotFound; |
|
2802 } |
|
2803 |
|
2804 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmNumFromVMN: <=" ); |
|
2805 return ret; |
|
2806 } |
|
2807 |
|
2808 // ----------------------------------------------------------------------------- |
|
2809 // RVmbxNumber::GetVmNumFromNamStore |
|
2810 // Retrieves voice mailbox number from NAM |
|
2811 // ----------------------------------------------------------------------------- |
|
2812 // |
|
2813 TInt RVmbxNumber::GetVmNumFromNamStore( TDes& aNumber, TInt aNumType ) |
|
2814 { |
|
2815 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmNumFromNamStore: =>" ); |
|
2816 TRequestStatus ret( KErrNotFound ); |
|
2817 RMobileNamStore namStore; |
|
2818 |
|
2819 ret = namStore.Open( iPhone ); |
|
2820 if ( ret != KErrNone ) |
|
2821 { |
|
2822 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmNumFromNamStore: \ |
|
2823 NameStore error %I, ret.Int()" ); |
|
2824 return ret.Int(); |
|
2825 } |
|
2826 |
|
2827 RMobileNamStore::TMobileNamStoreInfoV1 namInfo; |
|
2828 RMobileNamStore::TMobileNamStoreInfoV1Pckg namInfoPckg( namInfo ); |
|
2829 |
|
2830 namStore.GetInfo( ret, namInfoPckg ); |
|
2831 User::WaitForRequest( ret ); |
|
2832 if ( ret == KErrNone ) |
|
2833 { |
|
2834 RMobileNamStore::TMobileNamEntryV1 namEntry; |
|
2835 RMobileNamStore::TMobileNamEntryV1Pckg namEntryPckg( namEntry ); |
|
2836 |
|
2837 namEntry.iNamId = namInfo.iActiveNam; |
|
2838 |
|
2839 switch ( aNumType ) |
|
2840 { |
|
2841 case EVmbxMDN: |
|
2842 { |
|
2843 namEntry.iParamIdentifier = KVmNamStoreMDNId; |
|
2844 break; |
|
2845 } |
|
2846 case EVmbxMIN: |
|
2847 { |
|
2848 namEntry.iParamIdentifier = KVmNamStoreMINId; |
|
2849 break; |
|
2850 } |
|
2851 default: |
|
2852 break; |
|
2853 } |
|
2854 |
|
2855 namStore.Read( ret, namEntryPckg ); |
|
2856 User::WaitForRequest( ret ); |
|
2857 if ( ret == KErrNone ) |
|
2858 { |
|
2859 ret = CnvUtfConverter::ConvertToUnicodeFromUtf8( |
|
2860 aNumber, // Unicode |
|
2861 namEntry.iData ); // Utf8 |
|
2862 } |
|
2863 } |
|
2864 |
|
2865 if ( IsEmergencyNumberL( aNumber ) ) |
|
2866 { |
|
2867 aNumber.Zero(); |
|
2868 ret = KErrNotFound; |
|
2869 } |
|
2870 |
|
2871 namStore.Close(); |
|
2872 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmNumFromNamStore: <=" ); |
|
2873 return ret.Int(); |
|
2874 } |
|
2875 |
|
2876 // ----------------------------------------------------------------------------- |
|
2877 // RVmbxNumber::GetVmNumFromSD |
|
2878 // Retrieves voice mailbox number from Shared Data |
|
2879 // ----------------------------------------------------------------------------- |
|
2880 // |
|
2881 TInt RVmbxNumber::GetVmNumFromSD( TDes& aNumber, TInt aLineNumber ) |
|
2882 { |
|
2883 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmNumFromSD: =>" ); |
|
2884 TBuf< KVmbxMaxNumberLength > number; |
|
2885 TInt ret( KErrNotFound ); |
|
2886 |
|
2887 TUint32 keyword = aLineNumber == |
|
2888 EAlsLine1Entry?KVmbxNumberLinePrimary: KVmbxNumberLineAuxiliary; |
|
2889 ret = iSession->Get( keyword, number ); |
|
2890 |
|
2891 if ( !ret ) |
|
2892 { |
|
2893 if ( number.Length() ) |
|
2894 { |
|
2895 aNumber.Copy( number ); |
|
2896 } |
|
2897 else |
|
2898 { |
|
2899 ret = KErrNotFound; |
|
2900 } |
|
2901 } |
|
2902 if ( IsEmergencyNumberL( aNumber ) ) |
|
2903 { |
|
2904 aNumber.Zero(); |
|
2905 ret = KErrNotFound; |
|
2906 } |
|
2907 |
|
2908 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmNumFromSD: <=" ); |
|
2909 return ret; |
|
2910 } |
|
2911 |
|
2912 // ----------------------------------------------------------------------------- |
|
2913 // RVmbxNumber::CloseETel |
|
2914 // Closes all ETel resources |
|
2915 // ----------------------------------------------------------------------------- |
|
2916 // |
|
2917 void RVmbxNumber::CloseETel() |
|
2918 { |
|
2919 VMBLOGSTRING( "VMBX: RVmbxNumber::CloseETel: =>" ); |
|
2920 iPhoneBook.Close(); |
|
2921 |
|
2922 if ( iFlags & KVmFlagPhoneOpened ) |
|
2923 { |
|
2924 iPhone.Close(); |
|
2925 } |
|
2926 |
|
2927 if ( iFlags & KVmFlagPhoneModuleLoaded ) |
|
2928 { |
|
2929 iTelServer.UnloadPhoneModule( KMmTsyModuleName ); |
|
2930 } |
|
2931 iTelServer.Close(); |
|
2932 |
|
2933 // Clear corresponding flags |
|
2934 iFlags &= ~KVmFlagSimReadSupport; |
|
2935 iFlags &= ~KVmFlagSimWriteSupport; |
|
2936 iFlags &= ~KVmFlagPhoneModuleLoaded; |
|
2937 iFlags &= ~KVmFlagPhoneOpened; |
|
2938 iFlags &= ~KVmFlagPhonebookBeingCached; |
|
2939 VMBLOGSTRING( "VMBX: RVmbxNumber::CloseETel: <=" ); |
|
2940 } |
|
2941 |
|
2942 // ----------------------------------------------------------------------------- |
|
2943 // RVmbxNumber::AppendStrToArrayL |
|
2944 // Appends string from resourse to descriptor array |
|
2945 // ----------------------------------------------------------------------------- |
|
2946 // |
|
2947 void RVmbxNumber::AppendStrToArrayL( TInt aResourceId, CDesCArray& aArray ) |
|
2948 { |
|
2949 VMBLOGSTRING( "VMBX: RVmbxNumber::AppendStrToArrayL: =>" ); |
|
2950 HBufC* tmp = StringLoader::LoadLC( aResourceId, iCoeEnv ); |
|
2951 aArray.AppendL( *tmp ); |
|
2952 CleanupStack::PopAndDestroy( tmp ); |
|
2953 VMBLOGSTRING( "VMBX: RVmbxNumber::AppendStrToArrayL: <=" ); |
|
2954 } |
|
2955 |
|
2956 // ----------------------------------------------------------------------------- |
|
2957 // RVmbxNumber::SetHeaderFromResourceL |
|
2958 // Set query dialog header text from resource string |
|
2959 // ----------------------------------------------------------------------------- |
|
2960 // |
|
2961 void RVmbxNumber::SetHeaderFromResourceL( TInt aResourceId, |
|
2962 CAknQueryDialog& aDlg ) |
|
2963 { |
|
2964 VMBLOGSTRING( "VMBX: RVmbxNumber::SetHeaderFromResourceL: =>" ); |
|
2965 HBufC* headingText = StringLoader::LoadLC( aResourceId, iCoeEnv ); |
|
2966 aDlg.SetHeaderTextL( *headingText ); |
|
2967 CleanupStack::PopAndDestroy( headingText ); |
|
2968 VMBLOGSTRING( "VMBX: RVmbxNumber::SetHeaderFromResourceL: <=" ); |
|
2969 } |
|
2970 |
|
2971 // ----------------------------------------------------------------------------- |
|
2972 // RVmbxNumber::QueryAddressL |
|
2973 // Fetches Voip address (returns ETrue when success) |
|
2974 // ----------------------------------------------------------------------------- |
|
2975 // |
|
2976 EXPORT_C TBool RVmbxNumber::QueryAddressL( TVmbxQueryType /*aQueryType*/, |
|
2977 TDes& /*aNumber*/ ) |
|
2978 { |
|
2979 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryAddressL: =>" ); |
|
2980 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryAddressL: METHOD NOT SUPPORTED ANYMORE" ); |
|
2981 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryAddressL: <=" ); |
|
2982 return EFalse; |
|
2983 } |
|
2984 |
|
2985 // ----------------------------------------------------------------------------- |
|
2986 // RVmbxNumber::SelectTypeL |
|
2987 // Select which type of Vmbx |
|
2988 // ----------------------------------------------------------------------------- |
|
2989 // |
|
2990 EXPORT_C TInt RVmbxNumber::SelectTypeL( TBool aTitle ) |
|
2991 { |
|
2992 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: =>" ); |
|
2993 if ( !AllowedToChangeTheNumber() && EVmbxDefine == aTitle ) |
|
2994 { |
|
2995 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: \ |
|
2996 Not Allow to define voice mail number" ); |
|
2997 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: <=" ); |
|
2998 return EVmbxNone; |
|
2999 } |
|
3000 |
|
3001 if ( VideoSupported() ) |
|
3002 { |
|
3003 TInt index( 0 ); |
|
3004 |
|
3005 RArray<TInt> vmbxTypeArray; |
|
3006 CleanupClosePushL( vmbxTypeArray ); |
|
3007 |
|
3008 iTypeSelectionQuery = CVmListQueryDialog::NewL( &index ); |
|
3009 iTypeSelectionQuery->PrepareLC( R_MAILBOX_LISTQUERY ); |
|
3010 |
|
3011 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: Not only Voice" ); |
|
3012 |
|
3013 // Select which type voice mailbox number to call, CS or Video |
|
3014 if ( EVmbxCall == aTitle ) |
|
3015 { |
|
3016 // Set prompt |
|
3017 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: aTitle = call" ); |
|
3018 |
|
3019 SetHeaderFromResourceL( R_CALLTO_LBX_PROMPT, *iTypeSelectionQuery ); |
|
3020 |
|
3021 // Fill items to array |
|
3022 CDesCArrayFlat* lbxItems = |
|
3023 new (ELeave) CDesCArrayFlat( KVmLbxItemsArraySize ); |
|
3024 CleanupStack::PushL( lbxItems ); |
|
3025 |
|
3026 TBuf<KVmbxMaxNumberLength> vmbxNumber; |
|
3027 |
|
3028 // Check CS number |
|
3029 if ( KErrNone == GetVmbxNumber( vmbxNumber ) ) |
|
3030 { |
|
3031 AppendStrToArrayL( R_CALLTO_LBX_CS_MAILBOX_ITEM, *lbxItems ); |
|
3032 User::LeaveIfError( vmbxTypeArray.Append( EVmbx ) ); |
|
3033 iType = EVmbx; |
|
3034 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: EVmbx" ); |
|
3035 } |
|
3036 // Check Video number |
|
3037 if ( VideoSupported() && |
|
3038 KErrNone == GetVideoMbxNumber( vmbxNumber ) ) |
|
3039 { |
|
3040 AppendStrToArrayL( R_CALLTO_LBX_VIDEO_MAILBOX_ITEM, |
|
3041 *lbxItems ); |
|
3042 User::LeaveIfError( vmbxTypeArray.Append( EVmbxVideo ) ); |
|
3043 iType = EVmbxVideo; |
|
3044 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: EVmbxVideo" ); |
|
3045 } |
|
3046 |
|
3047 iTypeSelectionQuery->SetItemTextArray( lbxItems ); |
|
3048 // vest ownership to lbx |
|
3049 iTypeSelectionQuery->SetOwnershipType( ELbmOwnsItemArray ); |
|
3050 CleanupStack::Pop( lbxItems ); |
|
3051 } |
|
3052 // Select which type of VMBX number to define, CS or Video |
|
3053 else |
|
3054 { |
|
3055 // Set prompt |
|
3056 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: aTitle = define" ); |
|
3057 |
|
3058 SetHeaderFromResourceL( R_DEFINE_VIDEO_OR_VOICE_LBX_PROMPT, |
|
3059 *iTypeSelectionQuery ); |
|
3060 |
|
3061 // Fill items to array |
|
3062 CDesCArrayFlat* lbxItems = |
|
3063 new (ELeave) CDesCArrayFlat( KVmLbxItemsArraySize ); |
|
3064 CleanupStack::PushL( lbxItems ); |
|
3065 |
|
3066 AppendStrToArrayL( R_DEFINE_LBX_CS_MAILBOX_ITEM, *lbxItems ); |
|
3067 User::LeaveIfError( vmbxTypeArray.Append( EVmbx ) ); |
|
3068 |
|
3069 if ( VideoSupported() ) |
|
3070 { |
|
3071 AppendStrToArrayL( R_DEFINE_LBX_VIDEO_MAILBOX_ITEM, |
|
3072 *lbxItems ); |
|
3073 User::LeaveIfError( vmbxTypeArray.Append( EVmbxVideo ) ); |
|
3074 } |
|
3075 |
|
3076 iTypeSelectionQuery->SetItemTextArray( lbxItems ); |
|
3077 // vest ownership to lbx |
|
3078 iTypeSelectionQuery->SetOwnershipType( ELbmOwnsItemArray ); |
|
3079 CleanupStack::Pop( lbxItems ); |
|
3080 } |
|
3081 |
|
3082 VMBLOGSTRING2( "VMBX: RVmbxNumber::SelectTypeL array count %d", |
|
3083 vmbxTypeArray.Count()); |
|
3084 |
|
3085 if ( ( EVmbxCall == aTitle ) && |
|
3086 ( KVmbxOnlyDefinedOneNumber == vmbxTypeArray.Count() ) ) |
|
3087 { |
|
3088 // call directly |
|
3089 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: Only one" ); |
|
3090 CleanupStack::PopAndDestroy( iTypeSelectionQuery ); |
|
3091 } |
|
3092 else |
|
3093 { |
|
3094 if ( iTypeSelectionQuery->RunLD() ) |
|
3095 { |
|
3096 iType = vmbxTypeArray[ index ]; |
|
3097 } |
|
3098 else |
|
3099 { |
|
3100 iType = EVmbxNone; |
|
3101 } |
|
3102 } |
|
3103 |
|
3104 iTypeSelectionQuery = NULL; |
|
3105 //close and destroy vmbxTypeArray |
|
3106 CleanupStack::PopAndDestroy( &vmbxTypeArray ); |
|
3107 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: <=" ); |
|
3108 return iType; |
|
3109 } |
|
3110 // Only supported CS |
|
3111 else |
|
3112 { |
|
3113 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: <=" ); |
|
3114 return EVmbx; |
|
3115 } |
|
3116 } |
|
3117 |
|
3118 |
|
3119 // ----------------------------------------------------------------------------- |
|
3120 // RVmbxNumber::SaveVmbxAddressL |
|
3121 // Save voice mailbox address to RCSC |
|
3122 // ----------------------------------------------------------------------------- |
|
3123 // |
|
3124 EXPORT_C TInt RVmbxNumber::SaveVmbxAddressL( TDes& /*aAddress*/ ) |
|
3125 { |
|
3126 VMBLOGSTRING( "VMBX: RVmbxNumber::SaveVmbxAddressL(TDes& aAddress): Method deprecated" ); |
|
3127 return KErrNotSupported; |
|
3128 } |
|
3129 |
|
3130 |
|
3131 // ---------------------------------------------------------------------------- |
|
3132 // RVmbxNumber::IsVoIPProfilesFound |
|
3133 // Check if VoIP profiles is found. |
|
3134 // ---------------------------------------------------------------------------- |
|
3135 // |
|
3136 EXPORT_C TBool RVmbxNumber::IsVoIPProfilesFound() |
|
3137 { |
|
3138 VMBLOGSTRING( "VMBX: RVmbxNumber::IsVoIPProfilesFound" ); |
|
3139 |
|
3140 return iVmSpsHandler->IsVoIPProfilesFound(); |
|
3141 } |
|
3142 |
|
3143 |
|
3144 EXPORT_C TBool RVmbxNumber::IsIpVoiceMailboxServices() |
|
3145 { |
|
3146 VMBLOGSTRING( "VMBX: RVmbxNumber::IsIpVoiceMailboxServices: =>" ); |
|
3147 |
|
3148 TBool ret( EFalse ); |
|
3149 |
|
3150 if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) ) |
|
3151 { |
|
3152 RArray<TUint> profileIds; |
|
3153 |
|
3154 GetServiceIds( profileIds ); |
|
3155 |
|
3156 TInt count = profileIds.Count(); |
|
3157 |
|
3158 profileIds.Close(); |
|
3159 |
|
3160 if ( count > 0 ) |
|
3161 { |
|
3162 ret = ETrue; |
|
3163 } |
|
3164 else |
|
3165 { |
|
3166 ret = EFalse; |
|
3167 } |
|
3168 } |
|
3169 |
|
3170 VMBLOGSTRING( "VMBX: RVmbxNumber::IsIpVoiceMailboxServices: <=" ); |
|
3171 return ret; |
|
3172 } |
|
3173 |
|
3174 // ---------------------------------------------------------------------------- |
|
3175 // RVmbxNumber::IsSimMemory |
|
3176 // Returns if the memory location for vmbx is sim memory |
|
3177 // ---------------------------------------------------------------------------- |
|
3178 // |
|
3179 EXPORT_C TBool RVmbxNumber::IsSimMemory() |
|
3180 { |
|
3181 VMBLOGSTRING( "VMBX: RVmbxNumber::IsSimMemory: =>" ); |
|
3182 TBool ret( EFalse ); |
|
3183 TInt alsLine( EAlsLine1 ); |
|
3184 // get the current ALS line |
|
3185 if ( GetAlsLine( alsLine ) != KErrNone ) |
|
3186 { |
|
3187 alsLine = EAlsLine1; // if problems, assume primary line |
|
3188 } |
|
3189 if ( iSimCardFound ) |
|
3190 { |
|
3191 // if number automatically fetched from read only SIM |
|
3192 // or ALS2 is active |
|
3193 if ( ( !( iFlags & KVmFlagSimWriteSupport ) ) || EAlsLine2 == alsLine ) |
|
3194 { |
|
3195 ret = ( !UserEditNumber( alsLine ) && |
|
3196 !IsPhoneMemForcedEdit( alsLine ) ); |
|
3197 } |
|
3198 // if number stored in writable SIM |
|
3199 else |
|
3200 { |
|
3201 ret = UsesSimMemory(); |
|
3202 } |
|
3203 } |
|
3204 VMBLOGSTRING( "VMBX: RVmbxNumber::IsSimMemory: <=" ); |
|
3205 VMBLOGSTRING3( "VMBX: RVmbxNumber::IsSimMemory: sim memory is used \ |
|
3206 iSimCardFound: %I, ret: %I", iSimCardFound, ret ); |
|
3207 return ret; |
|
3208 } |
|
3209 |
|
3210 // ----------------------------------------------------------------------------- |
|
3211 // RVmbxNumber::GetVideoMbxNumber |
|
3212 // Fetches the specified video mailbox number |
|
3213 // ----------------------------------------------------------------------------- |
|
3214 // |
|
3215 EXPORT_C TInt RVmbxNumber::GetVideoMbxNumber( TDes& aNumber, |
|
3216 TVmbxNumberEntry aEntry ) |
|
3217 { |
|
3218 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVideoMbxNumber: =>" ); |
|
3219 TInt ret = VideoSupported(); |
|
3220 |
|
3221 if ( ret ) |
|
3222 { |
|
3223 TInt lineNumber( aEntry ); |
|
3224 TBuf< KVmbxMaxNumberLength > number; |
|
3225 if ( EAlsActiveLineEntry == aEntry ) |
|
3226 { |
|
3227 // get the current ALS line |
|
3228 if ( KErrNone != GetAlsLine( lineNumber ) ) |
|
3229 { |
|
3230 lineNumber = EAlsLine1; // if problems, assume primary line |
|
3231 } |
|
3232 } |
|
3233 |
|
3234 TUint32 keyword = lineNumber == |
|
3235 EAlsLine1Entry ? KVideoMbxNumberLinePrimary : KVideoMbxNumberLineAuxiliary; |
|
3236 ret = iSession->Get( keyword, number ); |
|
3237 |
|
3238 if ( KErrNone == ret ) |
|
3239 { |
|
3240 if ( number.Length() ) |
|
3241 { |
|
3242 aNumber.Copy( number ); |
|
3243 } |
|
3244 else |
|
3245 { |
|
3246 ret = KErrNotFound; |
|
3247 } |
|
3248 } |
|
3249 |
|
3250 if ( IsEmergencyNumberL( aNumber ) ) |
|
3251 { |
|
3252 aNumber.Zero(); |
|
3253 ret = KErrNotFound; |
|
3254 } |
|
3255 } |
|
3256 else |
|
3257 { |
|
3258 ret = KErrNotFound; |
|
3259 } |
|
3260 VMBLOGSTRING2( "VMBX: RVmbxNumber::GetVideoMbxNumber:<=\ |
|
3261 Video supported = %d", ret ); |
|
3262 return ret; |
|
3263 } |
|
3264 |
|
3265 // ----------------------------------------------------------------------------- |
|
3266 // RVmbxNumber::QueryVideoMbxNumberL |
|
3267 // Queries a video mailbox number |
|
3268 // ----------------------------------------------------------------------------- |
|
3269 // |
|
3270 EXPORT_C TBool RVmbxNumber::QueryVideoMbxNumberL( TVmbxQueryType aQueryType, |
|
3271 TDes& aNumber ) |
|
3272 { |
|
3273 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryVideoMbxNumberL: =>" ); |
|
3274 TBool result( EFalse ); |
|
3275 |
|
3276 __ASSERT_DEBUG( aNumber.MaxLength() >= KVmbxMaxNumberLength, |
|
3277 User::Panic(KVmbxPanicCategory, EVmbxDescriptorTooSmall) ); |
|
3278 __ASSERT_DEBUG( aNumber.Length() <= KVmbxMaxNumberLength, |
|
3279 User::Panic(KVmbxPanicCategory, EVmbxNumberTooLong) ); |
|
3280 |
|
3281 if ( !AllowedToChangeTheNumber() ) |
|
3282 { |
|
3283 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryVideoMbxNumberL: \ |
|
3284 Video number not allowed to change" ); |
|
3285 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryVideoMbxNumberL: <=" ); |
|
3286 User::Leave( KErrAccessDenied ); |
|
3287 } |
|
3288 |
|
3289 TBuf< KVmbxMaxNumberLength > number; |
|
3290 TBool thisClosed( EFalse ); |
|
3291 // Close() sets thisClosed to ETrue |
|
3292 |
|
3293 FOREVER |
|
3294 { |
|
3295 number.Copy( aNumber ); |
|
3296 |
|
3297 // get the correct query prompt from resource file |
|
3298 HBufC* prompt = StringLoader::LoadLC( |
|
3299 ( aQueryType == EVmbxNotDefinedQuery ? |
|
3300 R_VIDEO_DEFINE_NUMBER_PROMPT : |
|
3301 R_VIDEO_CHANGE_NUMBER_PROMPT), |
|
3302 iCoeEnv ); |
|
3303 |
|
3304 iClosedPtr = &thisClosed; |
|
3305 |
|
3306 // Convert output to accommodate the current locale |
|
3307 AknTextUtils::LanguageSpecificNumberConversion( number ); |
|
3308 |
|
3309 TInt ret; // return value of the query |
|
3310 TBool searchUsed; // ETrue to open the query again after |
|
3311 //closing single fetch dialog |
|
3312 |
|
3313 // enable search if number length is 0 |
|
3314 TBool searchEnabled( number.Length() ? EFalse : ETrue ); |
|
3315 |
|
3316 do |
|
3317 { |
|
3318 // show query with the correct prompt |
|
3319 iVideoQuery = CVmTextQueryDialog::NewL( number, |
|
3320 *prompt, searchEnabled ); |
|
3321 |
|
3322 ret = iVideoQuery->ExecuteLD( R_VMBX_NUMBER_QUERY ); |
|
3323 |
|
3324 iVideoQuery = NULL; |
|
3325 searchUsed = EFalse; |
|
3326 |
|
3327 if ( searchEnabled && ret && !number.Length() ) |
|
3328 { |
|
3329 searchUsed = ETrue; |
|
3330 // Show phonebook's single fetch dialog |
|
3331 TRAPD( error, FetchNumberFromPhonebook2L( number ) ); |
|
3332 |
|
3333 // user has pressed End Key |
|
3334 if ( thisClosed ) |
|
3335 { |
|
3336 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryVideoMbxNumberL: \ |
|
3337 End key pressed" ); |
|
3338 CleanupStack::PopAndDestroy( prompt ); |
|
3339 return EFalse; |
|
3340 } |
|
3341 |
|
3342 if ( error ) // Back pressed in Contact UI |
|
3343 { |
|
3344 // Now the phone book fetch dialog |
|
3345 // was closed, get out of the loop |
|
3346 ret = EFalse; |
|
3347 break; |
|
3348 } |
|
3349 } |
|
3350 } while( searchUsed ); |
|
3351 |
|
3352 iClosedPtr = NULL; |
|
3353 |
|
3354 CleanupStack::PopAndDestroy( prompt ); |
|
3355 |
|
3356 if ( ret ) |
|
3357 { |
|
3358 if ( !number.Length() ) |
|
3359 { |
|
3360 User::LeaveIfError( SaveVideoMbxNumber( number, |
|
3361 EAlsActiveLineEntry ) ); |
|
3362 aNumber.Copy( number ); |
|
3363 |
|
3364 // show "not defined" note |
|
3365 ShowConfirmationNoteL( R_VIDEO_NOTE_EMPTY_NUMBER ); |
|
3366 result = ETrue; |
|
3367 break; |
|
3368 } |
|
3369 |
|
3370 // Convert back to western digits |
|
3371 ConvertToWesternDigits( number ); |
|
3372 |
|
3373 // check the given number here (emergency numbers not allowed) |
|
3374 if ( IsValidPhoneNumber( number ) && !IsEmergencyNumberL( number ) ) |
|
3375 { |
|
3376 TInt status = SaveVideoMbxNumber( number, EAlsActiveLineEntry ); |
|
3377 |
|
3378 if ( status == KErrNone ) |
|
3379 { |
|
3380 aNumber.Copy( number ); |
|
3381 ShowConfirmationNoteL( R_VIDEO_SAVED_NOTE ); |
|
3382 result = ETrue; |
|
3383 break; |
|
3384 } |
|
3385 } |
|
3386 |
|
3387 if ( !result ) |
|
3388 { |
|
3389 // show "invalid number" note and wait for a short timeout |
|
3390 prompt = StringLoader::LoadLC( R_INVALID_NUMBER_NOTE, iCoeEnv ); |
|
3391 |
|
3392 iClosedPtr = &thisClosed; |
|
3393 |
|
3394 CAknInformationNote* note = |
|
3395 new( ELeave ) CAknInformationNote( ETrue ); |
|
3396 note->ExecuteLD( *prompt ); |
|
3397 |
|
3398 iClosedPtr = NULL; |
|
3399 |
|
3400 CleanupStack::PopAndDestroy( prompt ); |
|
3401 |
|
3402 if ( !thisClosed ) |
|
3403 { |
|
3404 continue; // the number was invalid -> query again. |
|
3405 } |
|
3406 } |
|
3407 } |
|
3408 break; // user canceled the query |
|
3409 } |
|
3410 VMBLOGSTRING( "VMBX: RVmbxNumber::QueryVideoMbxNumberL: <=" ); |
|
3411 return result; |
|
3412 } |
|
3413 |
|
3414 // ----------------------------------------------------------------------------- |
|
3415 // RVmbxNumber::SaveVideoMbxNumber |
|
3416 // Saves the vmbx number. (in phone file system) |
|
3417 // ----------------------------------------------------------------------------- |
|
3418 // |
|
3419 EXPORT_C TInt RVmbxNumber::SaveVideoMbxNumber( const TDesC& aNumber, |
|
3420 TVmbxNumberEntry aEntry ) |
|
3421 { |
|
3422 VMBLOGSTRING( "VMBX: RVmbxNumber::SaveVideoMbxNumber: =>" ); |
|
3423 TInt error( KErrNone ); |
|
3424 __ASSERT_DEBUG( iFlags & KVmFlagOpened, |
|
3425 User::Panic(KVmbxPanicCategory, EVmbxNotConnected) ); |
|
3426 __ASSERT_DEBUG( aNumber.Length() <= KVmbxMaxNumberLength, |
|
3427 User::Panic(KVmbxPanicCategory, EVmbxNumberTooLong) ); |
|
3428 |
|
3429 TInt lineNumber( aEntry ); |
|
3430 if ( aEntry == EAlsActiveLineEntry ) |
|
3431 { |
|
3432 // get the current ALS line |
|
3433 if ( GetAlsLine( lineNumber ) != KErrNone ) |
|
3434 { |
|
3435 lineNumber = EAlsLine1; // if problems, assume primary line |
|
3436 } |
|
3437 } |
|
3438 TUint32 keyword = lineNumber == |
|
3439 EAlsLine1Entry ? KVideoMbxNumberLinePrimary: KVideoMbxNumberLineAuxiliary; |
|
3440 |
|
3441 error = iSession->Set( keyword, aNumber ); |
|
3442 if ( !error ) |
|
3443 { |
|
3444 // Client will generate the event itself on request. |
|
3445 if ( iFlags & KVmFlagNotifyRequested ) |
|
3446 { |
|
3447 HandleNotifyString( keyword, aNumber ); |
|
3448 } |
|
3449 } |
|
3450 VMBLOGSTRING( "VMBX: RVmbxNumber::SaveVideoMbxNumber: <=" ); |
|
3451 return error; |
|
3452 } |
|
3453 |
|
3454 // ----------------------------------------------------------------------------- |
|
3455 // RVmbxNumber::IsUsimSupport |
|
3456 // ----------------------------------------------------------------------------- |
|
3457 TBool RVmbxNumber::IsUsimSupport() |
|
3458 { |
|
3459 VMBLOGSTRING( "VMBX: RVmbxNumber::IsUsimSupport: =>" ); |
|
3460 TBool ret( EFalse ); |
|
3461 TInt alsline( EAlsLine1 ); |
|
3462 |
|
3463 // get the current ALS line |
|
3464 if ( GetAlsLine( alsline ) != KErrNone ) |
|
3465 { |
|
3466 alsline = EAlsLine1; // if problems, assume primary line |
|
3467 } |
|
3468 |
|
3469 // SIM access not supported for ALS line2 |
|
3470 if ( FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ) && |
|
3471 ( alsline == EAlsLine1 ) ) |
|
3472 { |
|
3473 TUint32 capability; |
|
3474 TInt err = iPhone.GetIccAccessCaps( capability ); |
|
3475 VMBLOGSTRING3( "VMBX: RVmbxNumber::IsUsimSupport: Err = %I,\ |
|
3476 Capa = %I ", err, capability ); |
|
3477 |
|
3478 if ( ( err == KErrNone ) && |
|
3479 ( capability & RMobilePhone::KCapsUSimAccessSupported ) ) |
|
3480 { |
|
3481 VMBLOGSTRING( "USim access caps ok"); |
|
3482 ret = ETrue; |
|
3483 } |
|
3484 } |
|
3485 else |
|
3486 { |
|
3487 ret = EFalse; |
|
3488 } |
|
3489 VMBLOGSTRING( "VMBX: RVmbxNumber::IsUsimSupport: <=" ); |
|
3490 return ret; |
|
3491 } |
|
3492 |
|
3493 // ----------------------------------------------------------------------------- |
|
3494 // Series 60 Customer / MSatRefreshOserver |
|
3495 // Series 60 MSatRefreshObserver API |
|
3496 // ----------------------------------------------------------------------------- |
|
3497 TBool RVmbxNumber::AllowRefresh( |
|
3498 TSatRefreshType aType, const TSatRefreshFiles& aFiles ) |
|
3499 { |
|
3500 VMBLOGSTRING( "VMBX: RVmbxNumber::AllowRefresh: =>" ); |
|
3501 TBool allowRefresh( ETrue ); |
|
3502 if ( aType == EFileChangeNotification ) |
|
3503 { |
|
3504 const TInt elFile1( aFiles.Locate( KMbdnEf ) ); |
|
3505 const TInt elFile2( aFiles.Locate( KMbiEf) ); |
|
3506 |
|
3507 if ( ( KErrNotFound == elFile1) && |
|
3508 ( KErrNotFound == elFile2 ) ) |
|
3509 { |
|
3510 allowRefresh = EFalse; |
|
3511 } |
|
3512 |
|
3513 } |
|
3514 else |
|
3515 { |
|
3516 allowRefresh = EFalse; |
|
3517 } |
|
3518 VMBLOGSTRING( "VMBX: RVmbxNumber::AllowRefresh: <=" ); |
|
3519 return allowRefresh; |
|
3520 } |
|
3521 |
|
3522 // ----------------------------------------------------------------------------- |
|
3523 // Series 60 Customer / MSatRefreshOserver |
|
3524 // Series 60 MSatRefreshObserver API |
|
3525 // ----------------------------------------------------------------------------- |
|
3526 void RVmbxNumber::Refresh( TSatRefreshType aType, |
|
3527 const TSatRefreshFiles& aFiles ) |
|
3528 { |
|
3529 VMBLOGSTRING( "VMBX: RVmbxNumber::Refresh: =>" ); |
|
3530 if ( aType == EFileChangeNotification ) |
|
3531 { |
|
3532 const TInt elFile1( aFiles.Locate( KMbdnEf ) ); |
|
3533 const TInt elFile2( aFiles.Locate( KMbiEf ) ); |
|
3534 |
|
3535 if ( ( KErrNotFound != elFile1) || ( KErrNotFound != elFile2 ) ) |
|
3536 { |
|
3537 //do phone book getInfo |
|
3538 TInt error( KErrNone ); |
|
3539 error = DoPhonebookOperation( EVmbxPhonebookGetInfo ); |
|
3540 if ( !error ) |
|
3541 { |
|
3542 TVmbxEntry entry; |
|
3543 entry.iIndex = 1; |
|
3544 TInt ret = DoPhonebookOperation( EVmbxPhonebookRead, &entry ); |
|
3545 |
|
3546 // Notify SAT Server that refresh initiated file read is done |
|
3547 iRSatClient.RefreshEFRead( EFalse ); |
|
3548 |
|
3549 if ( ( iNotifyCallBack ) && ( entry.iTelNumber.Length() > 0 ) |
|
3550 && ( iMemoryLocation == EVmbxSimMemory ) ) |
|
3551 { |
|
3552 TInt notifyLine( 0 ); |
|
3553 TRAPD( err, iNotifyCallBack->HandleNotifyL( notifyLine, |
|
3554 entry.iTelNumber ) ); |
|
3555 if ( err ) |
|
3556 { |
|
3557 _LIT(KVmbxPanicType,"iNotifyCallBack->HandleNotifyL"); |
|
3558 User::Panic( KVmbxPanicType, err ); |
|
3559 } |
|
3560 } |
|
3561 } |
|
3562 } |
|
3563 } |
|
3564 VMBLOGSTRING( "VMBX: RVmbxNumber::Refresh: <=" ); |
|
3565 } |
|
3566 |
|
3567 // ----------------------------------------------------------------------------- |
|
3568 // RVmbxNumber::MailboxNumbersIdentifiers |
|
3569 // Gets identifiers of the records in sim from MBI-file in sim |
|
3570 // ----------------------------------------------------------------------------- |
|
3571 // |
|
3572 TInt RVmbxNumber::MailboxNumbersIdentifiers() |
|
3573 { |
|
3574 VMBLOGSTRING( "VMBX: RVmbxNumber::MailboxNumbersIdentifiers: =>" ); |
|
3575 TRequestStatus status; |
|
3576 |
|
3577 // Get identifiers |
|
3578 iPhone.GetMailboxNumbers( status, iPhoneVoicemailInfoPckg ); |
|
3579 |
|
3580 // Wait for asynchronous call to finish |
|
3581 User::WaitForRequest( status ); |
|
3582 VMBLOGSTRING2( "Identifier read status = %I", status.Int() ); |
|
3583 VMBLOGSTRING2( "iVoice value: %d", iPhoneVoicemailInfo.iVoice ); |
|
3584 VMBLOGSTRING( "VMBX: RVmbxNumber::MailboxNumbersIdentifiers: <=" ); |
|
3585 return status.Int(); |
|
3586 } |
|
3587 |
|
3588 // ----------------------------------------------------------------------------- |
|
3589 // RVmbxNumber::MailboxNumbersIdentifiers |
|
3590 // Gets identifiers of the records in sim from MBI-file in sim |
|
3591 // ----------------------------------------------------------------------------- |
|
3592 // |
|
3593 void RVmbxNumber::TestAndSetSimAccessFlags() |
|
3594 { |
|
3595 VMBLOGSTRING( "VMBX: RVmbxNumber::TestAndSetSimAccessFlags: =>" ); |
|
3596 // Caps are not valid for read-only Sim, so check if writing |
|
3597 // to sim fails. |
|
3598 // Assume that a number exist |
|
3599 iNoNumberFound = EFalse; |
|
3600 TBool isTestNumberUsed = EFalse; |
|
3601 // read sim data first |
|
3602 TVmbxEntry entry; |
|
3603 entry.iIndex = EAlsLine1; |
|
3604 |
|
3605 TInt readError = DoPhonebookOperation( EVmbxPhonebookRead, &entry ); |
|
3606 |
|
3607 // KErrNotFound is returned when number length is zero, then |
|
3608 // testnumber is used to test write support |
|
3609 if ( readError == KErrNone || readError == KErrNotFound ) |
|
3610 { |
|
3611 // save number for later use |
|
3612 if ( entry.iTelNumber.Length() ) |
|
3613 { |
|
3614 iNumberFromSim.Copy( entry.iTelNumber ); |
|
3615 } |
|
3616 // number not found, test with testnumber |
|
3617 else if ( entry.iTelNumber.Length() == 0 ) |
|
3618 { |
|
3619 // no number found |
|
3620 iNoNumberFound = ETrue; |
|
3621 VMBLOGSTRING( "Use test number for testing write support" ); |
|
3622 entry.iTelNumber.Copy( KTestNumber ) ; |
|
3623 isTestNumberUsed = ETrue; |
|
3624 } |
|
3625 |
|
3626 VMBLOGSTRING( "Try writing" ); |
|
3627 |
|
3628 TInt writeError = DoPhonebookOperation( EVmbxPhonebookWrite, &entry ); |
|
3629 VMBLOGSTRING2( "Write: %I", writeError ); |
|
3630 |
|
3631 // write error, set write flag to not supported |
|
3632 // and phone memory in use |
|
3633 if ( writeError ) |
|
3634 { |
|
3635 VMBLOGSTRING( "WriteAccess not ok" ); |
|
3636 iFlags &= ~KVmFlagSimWriteSupport; |
|
3637 } |
|
3638 // tested with and sim has write access so delete test number from sim |
|
3639 else if ( isTestNumberUsed && writeError == KErrNone ) |
|
3640 { |
|
3641 VMBLOGSTRING( "Remove test number from sim" ); |
|
3642 DoPhonebookOperation( EVmbxPhonebookDelete, &entry ); |
|
3643 } |
|
3644 } |
|
3645 // read error, set read and write flag to not supported |
|
3646 // and phone memory in use |
|
3647 else |
|
3648 { |
|
3649 VMBLOGSTRING( "ReadAccess not ok" ); |
|
3650 iFlags &= ~KVmFlagSimReadSupport; |
|
3651 |
|
3652 VMBLOGSTRING( "WriteAccess not ok" ); |
|
3653 iFlags &= ~KVmFlagSimWriteSupport; |
|
3654 // The first USim phonebook type is tested, |
|
3655 // keep memorylocation unchanged |
|
3656 if ( iUSimFirstRoundTest ) |
|
3657 { |
|
3658 VMBLOGSTRING2( "iMemoryLocation = %d", iMemoryLocation ); |
|
3659 iUSimFirstRoundTest = EFalse; |
|
3660 } |
|
3661 else |
|
3662 { |
|
3663 iMemoryLocation = EVmbxPhoneMemory; |
|
3664 iSession->Set( KVmUsesSimMemory, EVmbxPhoneMemory ); |
|
3665 VMBLOGSTRING2( "iMemoryLocation = %d", iMemoryLocation ); |
|
3666 } |
|
3667 } |
|
3668 |
|
3669 VMBLOGSTRING( "VMBX: RVmbxNumber::TestAndSetSimAccessFlags: <=" ); |
|
3670 } |
|
3671 |
|
3672 // ----------------------------------------------------------------------------- |
|
3673 // RVmbxNumber::MailboxNumbersIdentifiers |
|
3674 // Gets identifiers of the records in sim from MBI-file in sim |
|
3675 // ----------------------------------------------------------------------------- |
|
3676 // |
|
3677 void RVmbxNumber::CalculateActualMaxLengthOnSim( TInt aSimNumberLength ) |
|
3678 { |
|
3679 VMBLOGSTRING( "VMBX: RVmbxNumber::CalculateActualMaxLength: =>" ); |
|
3680 VMBLOGSTRING2("iPhoneBookInfo.iMaxNumLength = %I", iPhoneBookInfo.iMaxNumLength ); |
|
3681 VMBLOGSTRING2("aSimNumberLength = %I", aSimNumberLength ); |
|
3682 |
|
3683 // If max length is less than 20 or -1 returned, then |
|
3684 // max length must be detemined from number length that is |
|
3685 // saved on sim. |
|
3686 if ( iPhoneBookInfo.iMaxNumLength == KVmExtFileSize || |
|
3687 iPhoneBookInfo.iMaxNumLength == -1 ) |
|
3688 { |
|
3689 // number on sim is less than 21 |
|
3690 if ( aSimNumberLength <= KVmExtFileSize ) |
|
3691 { |
|
3692 iPhoneBookInfo.iMaxNumLength = KVmExtFileSize; |
|
3693 } |
|
3694 // number on sim is more than 20 but less than 40 |
|
3695 else if ( KVmExtFileSize < aSimNumberLength && |
|
3696 aSimNumberLength <= KVmPhoneNumDigitsMaxLength ) |
|
3697 { |
|
3698 iPhoneBookInfo.iMaxNumLength = KVmPhoneNumDigitsMaxLength; |
|
3699 } |
|
3700 // number on sim is more than 40 |
|
3701 else |
|
3702 { |
|
3703 iPhoneBookInfo.iMaxNumLength = KVmMaxStoreSize; |
|
3704 } |
|
3705 } |
|
3706 // If max length is 40, and number length on sim is more |
|
3707 // than 20 but less than 41, then 48 is available on sim. |
|
3708 else if ( iPhoneBookInfo.iMaxNumLength == KVmPhoneNumDigitsMaxLength && |
|
3709 KVmExtFileSize < aSimNumberLength && |
|
3710 aSimNumberLength <= KVmPhoneNumDigitsMaxLength ) |
|
3711 { |
|
3712 iPhoneBookInfo.iMaxNumLength = KVmMaxStoreSize; |
|
3713 } |
|
3714 VMBLOGSTRING2("iPhoneBookInfo.iMaxNumLength = %I", iPhoneBookInfo.iMaxNumLength ); |
|
3715 |
|
3716 VMBLOGSTRING( "VMBX: RVmbxNumber::CalculateActualMaxLength: <=" ); |
|
3717 } |
|
3718 |
|
3719 // ----------------------------------------------------------------------------- |
|
3720 // RVmbxNumber::VideoSupported |
|
3721 // Returns video support state |
|
3722 // ----------------------------------------------------------------------------- |
|
3723 // |
|
3724 TBool RVmbxNumber::VideoSupported() |
|
3725 { |
|
3726 VMBLOGSTRING( "VMBX: RVmbxNumber::VideoSupported: =>" ); |
|
3727 |
|
3728 TBool supported( EFalse ); |
|
3729 |
|
3730 if ( FeatureManager::FeatureSupported( KFeatureIdCsVideoTelephony ) ) |
|
3731 { |
|
3732 TInt result = iSession->Get( KVideoMbxSupport, supported ); |
|
3733 if ( result != KErrNone ) |
|
3734 { |
|
3735 supported = EFalse; |
|
3736 } |
|
3737 } |
|
3738 |
|
3739 VMBLOGSTRING2("VMBX: RVmbxNumber::VideoSupported: supported = %d", supported ); |
|
3740 return supported; |
|
3741 } |
|
3742 |
|
3743 // ----------------------------------------------------------------------------- |
|
3744 // RVmbxNumber::GetVmbxAddressL |
|
3745 // Retrieves voice mailbox address from RCSC |
|
3746 // ----------------------------------------------------------------------------- |
|
3747 // |
|
3748 EXPORT_C TInt RVmbxNumber::GetVmbxAddressL( TDes& /*aAddress*/ ) |
|
3749 { |
|
3750 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmbxAddressL(TDes& aAddress): Method deprecated" ); |
|
3751 VMBLOGSTRING( "Use GetVmbxAddressL(TDes& aAddress, TUint aServiceId) instead" ); |
|
3752 |
|
3753 return KErrNotSupported; |
|
3754 } |
|
3755 |
|
3756 // ----------------------------------------------------------------------------- |
|
3757 // RVmbxNumber::GetVmbxAddress |
|
3758 // Retrieves voice mailbox address from SPS |
|
3759 // ----------------------------------------------------------------------------- |
|
3760 // |
|
3761 EXPORT_C TInt RVmbxNumber::GetVmbxAddress( TDes& aAddress, TUint aServiceId ) |
|
3762 { |
|
3763 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmbxAddress: =>" ); |
|
3764 TInt ret( KErrNotSupported ); |
|
3765 |
|
3766 if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) ) |
|
3767 { |
|
3768 TVmbxServiceInfo serviceInfo; |
|
3769 serviceInfo.iServiceId = aServiceId; |
|
3770 ret = GetServiceInfo( serviceInfo ); |
|
3771 VMBLOGSTRING2( "VMBX: RVmbxNumber::GetVmbxAddress: error: %d", ret ); |
|
3772 if ( KErrNone == ret ) |
|
3773 { |
|
3774 if ( serviceInfo.iAddress.Length() > aAddress.MaxLength() ) |
|
3775 { |
|
3776 ret = KErrOverflow; |
|
3777 } |
|
3778 else |
|
3779 { |
|
3780 aAddress.Copy( serviceInfo.iAddress ); |
|
3781 } |
|
3782 } |
|
3783 VMBLOGSTRING2( "VMBX: RVmbxNumber::GetVmbxAddress: error: %d", ret ); |
|
3784 } |
|
3785 |
|
3786 VMBLOGSTRING( "VMBX: RVmbxNumber::GetVmbxAddress: <=" ); |
|
3787 return ret; |
|
3788 } |
|
3789 |
|
3790 // ----------------------------------------------------------------------------- |
|
3791 // RVmbxNumber::SelectTypeL |
|
3792 // |
|
3793 // ----------------------------------------------------------------------------- |
|
3794 // |
|
3795 EXPORT_C TInt RVmbxNumber::SelectTypeL( TBool aTitle, TUint& aServiceId ) |
|
3796 { |
|
3797 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: =>" ); |
|
3798 |
|
3799 if ( !AllowedToChangeTheNumber() && EVmbxDefine == aTitle ) |
|
3800 { |
|
3801 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: \ |
|
3802 Not Allow to define voice mail number" ); |
|
3803 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: <=" ); |
|
3804 return EVmbxNone; |
|
3805 } |
|
3806 |
|
3807 if ( EVmbxCall != aTitle ) |
|
3808 { |
|
3809 User::Leave( KErrNotSupported ); |
|
3810 } |
|
3811 // the sum of defined numbers |
|
3812 TInt definedNumber( 0 ); |
|
3813 TInt definedFlag( 0 ); |
|
3814 CheckDefinedNumberCountL(definedNumber, definedFlag, aServiceId ); |
|
3815 |
|
3816 // Pop up selection dialog only if there are more than 2 defined numbers |
|
3817 if ( KMailBoxLimitForPrompt < definedNumber ) |
|
3818 { |
|
3819 TInt index( 0 ); |
|
3820 // Clear the old service information |
|
3821 iVmbxServiceSelection.Reset(); |
|
3822 |
|
3823 // Create selection list query and show it. |
|
3824 iTypeSelectionQuery = new (ELeave) CAknListQueryDialog( &index ); |
|
3825 iTypeSelectionQuery->PrepareLC( R_VOIP_REL2_2_CALL_TO ); |
|
3826 |
|
3827 // Create descriptor array for connection networks, connection networks |
|
3828 // icons and load connection network images to memory.. |
|
3829 CDesCArrayFlat* lbxItems = |
|
3830 new (ELeave) CDesCArrayFlat( KVmLbxItemsArraySize ); |
|
3831 CleanupStack::PushL( lbxItems ); |
|
3832 CArrayPtr<CGulIcon>* icons = |
|
3833 new (ELeave) CAknIconArray( KVmLbxItemsArraySize ); |
|
3834 CleanupStack::PushL( icons ); |
|
3835 |
|
3836 ConstructDefaultIconsL( icons ); |
|
3837 |
|
3838 // Create final list box item data. |
|
3839 TBuf<512> queryItem( KNullDesC ); |
|
3840 if( definedFlag & KVmFlagCSNumberDefined ) |
|
3841 { |
|
3842 HBufC* csName = StringLoader::LoadLC( R_CALLTO_LBX_CS_MAILBOX_ITEM, |
|
3843 iCoeEnv ); |
|
3844 queryItem.Format( KQueryItemFormat, 0, csName ); |
|
3845 CleanupStack::PopAndDestroy( csName ); |
|
3846 |
|
3847 // Append text to the item array. |
|
3848 lbxItems->AppendL( queryItem ); |
|
3849 // CS's hardcoded service value is 1 |
|
3850 User::LeaveIfError( iVmbxServiceSelection.Append( |
|
3851 TVmbxServiceSelection( EVmbx, 1 ) ) ); |
|
3852 } |
|
3853 |
|
3854 if( definedFlag & KVmFlagVideoNumberDefined ) |
|
3855 { |
|
3856 HBufC* videoName = |
|
3857 StringLoader::LoadLC( R_CALLTO_LBX_VIDEO_MAILBOX_ITEM, |
|
3858 iCoeEnv ); |
|
3859 // Create final list box item data. |
|
3860 queryItem.Format( KQueryItemFormat, 1, videoName ); |
|
3861 CleanupStack::PopAndDestroy( videoName ); |
|
3862 |
|
3863 // Append text to the item array. |
|
3864 lbxItems->AppendL( queryItem ); |
|
3865 // Video's hardcoded service value is 1 |
|
3866 User::LeaveIfError( iVmbxServiceSelection.Append( |
|
3867 TVmbxServiceSelection( EVmbxVideo, 1 ) ) ); |
|
3868 } |
|
3869 if( definedFlag & KVmFlagVoIpNumberDefined ) |
|
3870 { |
|
3871 // Get all Service Ids |
|
3872 RArray<TUint> profileIds; |
|
3873 CleanupClosePushL( profileIds ); |
|
3874 GetServiceIds( profileIds ); |
|
3875 |
|
3876 for ( TInt i( 0 ); i < profileIds.Count(); i++ ) |
|
3877 { |
|
3878 TVmbxServiceInfo serviceInfo; |
|
3879 serviceInfo.iServiceId = profileIds[ i ]; |
|
3880 GetServiceInfo( serviceInfo ); |
|
3881 |
|
3882 HBufC* voipName = HBufC::NewLC( serviceInfo.iName.Length() ); |
|
3883 voipName->Des().Copy( serviceInfo.iName ); |
|
3884 |
|
3885 TInt iconId( KErrNotFound ); |
|
3886 TRAPD( error, AddBrandIconL( icons, profileIds[ i ], iconId ) ); |
|
3887 |
|
3888 // If branded icon is not available, use hardcoded value 2 which is |
|
3889 // default VoIP icons value |
|
3890 if ( KErrNone != error || KErrNotFound == iconId ) |
|
3891 { |
|
3892 iconId = 2; |
|
3893 } |
|
3894 |
|
3895 // Create final list box item data. |
|
3896 queryItem.Format( KQueryItemFormat, iconId, voipName ); |
|
3897 CleanupStack::PopAndDestroy( voipName ); |
|
3898 |
|
3899 //Append text to the item array. |
|
3900 lbxItems->AppendL( queryItem ); |
|
3901 User::LeaveIfError( iVmbxServiceSelection.Append( |
|
3902 TVmbxServiceSelection( EVmbxIP, serviceInfo.iServiceId ) ) ); |
|
3903 } |
|
3904 |
|
3905 CleanupStack::PopAndDestroy( &profileIds ); |
|
3906 } |
|
3907 |
|
3908 iTypeSelectionQuery->SetIconArrayL( icons ); |
|
3909 iTypeSelectionQuery->SetItemTextArray( lbxItems ); |
|
3910 iTypeSelectionQuery->SetOwnershipType( ELbmOwnsItemArray ); |
|
3911 |
|
3912 CleanupStack::Pop( icons ); |
|
3913 CleanupStack::Pop( lbxItems ); |
|
3914 |
|
3915 if ( iTypeSelectionQuery->RunLD() ) |
|
3916 { |
|
3917 TVmbxServiceSelection serviceType = iVmbxServiceSelection[ index ]; |
|
3918 iType = serviceType.iServiceType; |
|
3919 aServiceId = serviceType.iServiceId; |
|
3920 VMBLOGSTRING2( "VMBX: RVmbxNumber::VoIP vmbx with service id %d selected", aServiceId ); |
|
3921 } |
|
3922 else |
|
3923 { |
|
3924 iType = EVmbxNone; |
|
3925 aServiceId = 0; |
|
3926 } |
|
3927 iTypeSelectionQuery = NULL; |
|
3928 } |
|
3929 |
|
3930 VMBLOGSTRING( "VMBX: RVmbxNumber::SelectTypeL: <=" ); |
|
3931 return iType; |
|
3932 } |
|
3933 // ----------------------------------------------------------------------------- |
|
3934 // RVmbxNumber::CheckDefinedNumberCountL |
|
3935 // |
|
3936 // ----------------------------------------------------------------------------- |
|
3937 // |
|
3938 TInt RVmbxNumber::CheckDefinedNumberCountL( TInt& aDefinedNumber, |
|
3939 TInt& aDefinedFlag, TUint& aServiceId ) |
|
3940 { |
|
3941 VMBLOGSTRING( "VMBX: RVmbxNumber::CheckDefinedNumberCountL: =>" ); |
|
3942 iType = EVmbxNone; |
|
3943 aServiceId = KDefaultServiceId; |
|
3944 // the sum of defined numbers |
|
3945 TInt definedNumber( KDefaultDefinedNumberCount ); |
|
3946 TInt definedServiceTypes( 0 ); |
|
3947 TInt definedFlag( 0 ); |
|
3948 |
|
3949 TBuf<KVmbxMaxNumberLength> tmpNumber(KNullDesC); |
|
3950 |
|
3951 // First check what mailboxes are defined. |
|
3952 // Skip querying if only one mailbox with number/address defined. |
|
3953 // 1. Get voice number |
|
3954 if ( KErrNone == GetVmbxNumber( tmpNumber ) ) |
|
3955 { |
|
3956 VMBLOGSTRING( "VMBX: RVmbxNumber::CheckDefinedNumberCountL: CS vmbx number defined"); |
|
3957 definedNumber++; |
|
3958 definedServiceTypes++; |
|
3959 iType = EVmbx; |
|
3960 aServiceId = KCSorVideoServiceId; |
|
3961 definedFlag |= KVmFlagCSNumberDefined; |
|
3962 } |
|
3963 |
|
3964 // 2. Get video number |
|
3965 if ( VideoSupported() && KErrNone == GetVideoMbxNumber( tmpNumber ) ) |
|
3966 { |
|
3967 VMBLOGSTRING( "VMBX: RVmbxNumber::CheckDefinedNumberCountL: Video mbx number defined"); |
|
3968 definedNumber++; |
|
3969 definedServiceTypes++; |
|
3970 if( KMailBoxLimitForPrompt == definedNumber) |
|
3971 { |
|
3972 iType = EVmbxVideo; |
|
3973 } |
|
3974 aServiceId = KCSorVideoServiceId; |
|
3975 definedFlag |= KVmFlagVideoNumberDefined; |
|
3976 } |
|
3977 |
|
3978 // 3. Get count of all Service Ids of VoIP |
|
3979 RArray<TUint> profileIds; |
|
3980 CleanupClosePushL( profileIds ); |
|
3981 |
|
3982 if ( KErrNone == GetServiceIds( profileIds ) ) |
|
3983 { |
|
3984 TInt idCount( profileIds.Count() ); |
|
3985 VMBLOGSTRING2( "VMBX: RVmbxNumber::CheckDefinedNumberCountL: %d IP vmbx services defined", idCount ); |
|
3986 |
|
3987 if ( idCount ) |
|
3988 { |
|
3989 definedNumber += idCount; |
|
3990 definedServiceTypes++; |
|
3991 // If only VoIP and only one service support Vmbx, |
|
3992 // then use it directly without prompting. |
|
3993 if ( KMailBoxLimitForPrompt == definedNumber ) |
|
3994 { |
|
3995 iType = EVmbxIP; |
|
3996 aServiceId = profileIds[ 0 ]; |
|
3997 } |
|
3998 definedFlag |= KVmFlagVoIpNumberDefined; |
|
3999 } |
|
4000 } |
|
4001 |
|
4002 CleanupStack::PopAndDestroy( &profileIds ); |
|
4003 aDefinedNumber = definedNumber; |
|
4004 aDefinedFlag = definedFlag; |
|
4005 VMBLOGSTRING2( "VMBX: RVmbxNumber::CheckDefinedNumberCountL: definedNumber = %d", |
|
4006 definedNumber ); |
|
4007 VMBLOGSTRING( "VMBX: RVmbxNumber::CheckDefinedNumberCountL: <=" ); |
|
4008 |
|
4009 if ( 1 < definedServiceTypes ) |
|
4010 { |
|
4011 iType = EVmbxNone; |
|
4012 } |
|
4013 return iType; |
|
4014 } |
|
4015 |
|
4016 // ---------------------------------------------------------------------------- |
|
4017 // RVmbxNumber::GetServiceIds |
|
4018 // |
|
4019 // ---------------------------------------------------------------------------- |
|
4020 // |
|
4021 EXPORT_C TInt RVmbxNumber::GetServiceIds( RArray<TUint>& aProfileIds ) |
|
4022 { |
|
4023 VMBLOGSTRING( "VMBX: RVmbxNumber::GetServiceIds: =>" ); |
|
4024 TInt ret( KErrNotFound ); |
|
4025 if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) ) |
|
4026 { |
|
4027 TRAP( ret, iVmSpsHandler->GetServiceIdsL( aProfileIds ) ); |
|
4028 } |
|
4029 VMBLOGSTRING( "VMBX: RVmbxNumber::GetServiceIds: <=" ); |
|
4030 return ret; |
|
4031 } |
|
4032 |
|
4033 // ---------------------------------------------------------------------------- |
|
4034 // RVmbxNumber::GetServiceInfo |
|
4035 // |
|
4036 // ---------------------------------------------------------------------------- |
|
4037 // |
|
4038 EXPORT_C TInt RVmbxNumber::GetServiceInfo( TVmbxServiceInfo& aServiceInfo ) |
|
4039 { |
|
4040 VMBLOGSTRING( "VMBX: RVmbxNumber::GetServiceInfo: =>" ); |
|
4041 TInt ret( KErrNotFound ); |
|
4042 if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) ) |
|
4043 { |
|
4044 ret = iVmSpsHandler->GetServiceInfo( aServiceInfo ); |
|
4045 } |
|
4046 VMBLOGSTRING( "VMBX: RVmbxNumber::GetServiceInfo: <=" ); |
|
4047 return ret; |
|
4048 } |
|
4049 |
|
4050 // ---------------------------------------------------------------------------- |
|
4051 // RVmbxNumber::NotifyServiceChange |
|
4052 // |
|
4053 // ---------------------------------------------------------------------------- |
|
4054 // |
|
4055 EXPORT_C void RVmbxNumber::NotifyServiceChange( |
|
4056 MServiceNotifyHandler* aHandler ) |
|
4057 { |
|
4058 VMBLOGSTRING( "VMBX: RVmbxNumber::NotifyServiceChange: =>" ); |
|
4059 |
|
4060 if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) ) |
|
4061 { |
|
4062 iVmSpsHandler->NotifyServiceChange( aHandler ); |
|
4063 } |
|
4064 |
|
4065 VMBLOGSTRING( "VMBX: RVmbxNumber::NotifyServiceChange: <=" ); |
|
4066 } |
|
4067 |
|
4068 // ---------------------------------------------------------------------------- |
|
4069 // RVmbxNumber::NotifyServiceChangeCancel |
|
4070 // |
|
4071 // ---------------------------------------------------------------------------- |
|
4072 // |
|
4073 EXPORT_C void RVmbxNumber::NotifyServiceChangeCancel() |
|
4074 { |
|
4075 VMBLOGSTRING( "VMBX: RVmbxNumber::NotifyServiceChangeCancel: =>" ); |
|
4076 |
|
4077 if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) ) |
|
4078 { |
|
4079 iVmSpsHandler->NotifyServiceChangeCancel(); |
|
4080 } |
|
4081 |
|
4082 VMBLOGSTRING( "VMBX: RVmbxNumber::NotifyServiceChangeCancel: <=" ); |
|
4083 } |
|
4084 |
|
4085 // ---------------------------------------------------------------------------- |
|
4086 // RVmbxNumber::BrandIdL |
|
4087 // |
|
4088 // ---------------------------------------------------------------------------- |
|
4089 // |
|
4090 EXPORT_C void RVmbxNumber::BrandIdL( TInt aServiceId, TDes8& aBrandId ) |
|
4091 { |
|
4092 VMBLOGSTRING( "VMBX: RVmbxNumber::BrandIdL: =>" ); |
|
4093 |
|
4094 if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) ) |
|
4095 { |
|
4096 iVmSpsHandler->BrandIdL( aServiceId, aBrandId ); |
|
4097 } |
|
4098 |
|
4099 VMBLOGSTRING( "VMBX: RVmbxNumber::BrandIdL: <=" ); |
|
4100 } |
|
4101 |
|
4102 // ---------------------------------------------------------------------------- |
|
4103 // RVmbxNumber::GetBrandedIconL |
|
4104 // |
|
4105 // ---------------------------------------------------------------------------- |
|
4106 // |
|
4107 EXPORT_C void RVmbxNumber::GetBrandedIconL( |
|
4108 const TDesC8& aBrandingId, |
|
4109 CFbsBitmap*& aBrandedBitmap, |
|
4110 CFbsBitmap*& aBrandedBitmapMask ) |
|
4111 { |
|
4112 VMBLOGSTRING( "VMBX: RVmbxNumber::GetBrandedIconL: =>" ); |
|
4113 |
|
4114 iVmBsHandler->GetBrandedIconL( |
|
4115 aBrandingId, aBrandedBitmap, aBrandedBitmapMask ); |
|
4116 |
|
4117 VMBLOGSTRING( "VMBX: RVmbxNumber::GetBrandedIconL: <=" ); |
|
4118 } |
|
4119 |
|
4120 // ---------------------------------------------------------------------------- |
|
4121 // RVmbxNumber::ConstructDefaultIconsL |
|
4122 // |
|
4123 // ---------------------------------------------------------------------------- |
|
4124 // |
|
4125 EXPORT_C void RVmbxNumber::ConstructDefaultIconsL( |
|
4126 CArrayPtr<CGulIcon>* aIcons ) |
|
4127 { |
|
4128 VMBLOGSTRING( "VMBX: RVmbxNumber::ConstructDefaultIconsL: =>" ); |
|
4129 |
|
4130 CFbsBitmap* bitmap; |
|
4131 CFbsBitmap* mask; |
|
4132 |
|
4133 //Get the mbm file path |
|
4134 TFileName mbmfile( KVmMbmDrive ); |
|
4135 mbmfile.Append( KDC_APP_BITMAP_DIR ); |
|
4136 mbmfile.Append( KVmLibMbmFile ); |
|
4137 |
|
4138 //default CS icon |
|
4139 AknIconUtils::CreateIconL( bitmap, mask, mbmfile, |
|
4140 EMbmVmQgn_prop_nrtyp_mobile, |
|
4141 EMbmVmQgn_prop_nrtyp_mobile_mask ); |
|
4142 |
|
4143 aIcons->AppendL( CGulIcon::NewL( bitmap, mask ) ); |
|
4144 |
|
4145 //default Video icon |
|
4146 AknIconUtils::CreateIconL( bitmap, mask, mbmfile, |
|
4147 EMbmVmQgn_prop_nrtyp_video, |
|
4148 EMbmVmQgn_prop_nrtyp_video_mask ); |
|
4149 |
|
4150 aIcons->AppendL( CGulIcon::NewL( bitmap, mask ) ); |
|
4151 |
|
4152 //default VoIP icon |
|
4153 AknIconUtils::CreateIconL( bitmap, mask, mbmfile, |
|
4154 EMbmVmQgn_prop_nrtyp_voip, |
|
4155 EMbmVmQgn_prop_nrtyp_voip_mask ); |
|
4156 |
|
4157 aIcons->AppendL( CGulIcon::NewL( bitmap, mask ) ); |
|
4158 |
|
4159 VMBLOGSTRING( "VMBX: RVmbxNumber::ConstructDefaultIconsL: <=" ); |
|
4160 } |
|
4161 // ----------------------------------------------------------------------------- |
|
4162 // RVmbxNumber::AddBrandIconL |
|
4163 // |
|
4164 // ----------------------------------------------------------------------------- |
|
4165 // |
|
4166 void RVmbxNumber::AddBrandIconL( |
|
4167 CArrayPtr<CGulIcon>* aIcons, |
|
4168 TUint aServiceId, |
|
4169 TInt& aIconId ) |
|
4170 { |
|
4171 // Set branding icon to context pane if available. |
|
4172 TBuf8<KVmSettingsUiBrandingIdLength> brandId( KNullDesC8 ); |
|
4173 |
|
4174 BrandIdL( aServiceId, brandId ); |
|
4175 |
|
4176 CFbsBitmap* brandedBitmap = NULL; |
|
4177 CFbsBitmap* brandedBitmapMask = NULL; |
|
4178 |
|
4179 // Get branded bitmap |
|
4180 TRAPD( err, GetBrandedIconL( brandId, brandedBitmap, brandedBitmapMask ) ); |
|
4181 |
|
4182 if ( KErrNone == err ) |
|
4183 { |
|
4184 // The count of list icons(before adding branding icon to the list) |
|
4185 // must be the branded icon list id |
|
4186 aIconId = aIcons->Count(); |
|
4187 // Create new icon and add it to the icon list |
|
4188 aIcons->AppendL( CGulIcon::NewL( brandedBitmap, brandedBitmapMask ) ); |
|
4189 } |
|
4190 else |
|
4191 { |
|
4192 delete brandedBitmap; |
|
4193 delete brandedBitmapMask; |
|
4194 } |
|
4195 } |
|
4196 |
|
4197 |
|
4198 // ----------------------------------------------------------------------------- |
|
4199 // RVmbxNumber::VmbxNumDefInPhoneMemory |
|
4200 // Checks is VMBX number defined in phone memory |
|
4201 // ----------------------------------------------------------------------------- |
|
4202 // |
|
4203 TBool RVmbxNumber::VmbxNumDefInPhoneMemory( TInt aLineNumber ) |
|
4204 { |
|
4205 VMBLOGSTRING( "VMBX: RVmbxNumber::VmbxNumDefInPhoneMemory: =>" ); |
|
4206 TBool numDefined( EFalse ); |
|
4207 TBuf< KVmbxMaxNumberLength > number; |
|
4208 TUint32 lineNumber = aLineNumber == |
|
4209 EAlsLine1 ? KVmbxNumberLinePrimary: KVmbxNumberLineAuxiliary; |
|
4210 |
|
4211 if ( KErrNone == iSession->Get( lineNumber, number ) ) |
|
4212 { |
|
4213 if ( aLineNumber == EAlsLine1 ) |
|
4214 { |
|
4215 if ( iMemoryLocation == EVmbxPhoneMemory && |
|
4216 number.Length() ) |
|
4217 { |
|
4218 numDefined = ETrue; |
|
4219 } |
|
4220 } |
|
4221 else if ( aLineNumber == EAlsLine2 && number.Length() ) |
|
4222 { |
|
4223 numDefined = ETrue; |
|
4224 } |
|
4225 } |
|
4226 |
|
4227 VMBLOGSTRING2("VMBX: RVmbxNumber::VmbxNumDefInPhoneMemory: numDefined = %d", |
|
4228 numDefined ); |
|
4229 return numDefined; |
|
4230 } |
|
4231 |
|
4232 // ----------------------------------------------------------------------------- |
|
4233 // RVmbxNumber::NumStoredInPhone |
|
4234 // Checks is the given number stored in phone memory |
|
4235 // ----------------------------------------------------------------------------- |
|
4236 // |
|
4237 TBool RVmbxNumber::NumStoredInPhone( const TDesC& aNumber, TInt aLineNumber ) |
|
4238 { |
|
4239 VMBLOGSTRING( "VMBX: RVmbxNumber::NumStoredInPhone: =>" ); |
|
4240 TBool numStoredInPhone( EFalse ); |
|
4241 TBuf< KVmbxMaxNumberLength > number; |
|
4242 TUint32 lineNumber = aLineNumber == |
|
4243 EAlsLine1 ? KVmbxNumberLinePrimary : KVmbxNumberLineAuxiliary; |
|
4244 |
|
4245 if ( KErrNone == iSession->Get( lineNumber, number ) ) |
|
4246 { |
|
4247 if ( !( number.Compare( aNumber ) ) ) |
|
4248 { |
|
4249 numStoredInPhone = ETrue; |
|
4250 } |
|
4251 } |
|
4252 |
|
4253 VMBLOGSTRING2( "VMBX: RVmbxNumber::NumStoredInPhone: numStoredInPhone = %d", |
|
4254 numStoredInPhone ); |
|
4255 return numStoredInPhone; |
|
4256 } |
|
4257 |
|
4258 // ----------------------------------------------------------------------------- |
|
4259 // RVmbxNumber::BackUpSimNumber |
|
4260 // Saves VMBX number to the backup store |
|
4261 // ----------------------------------------------------------------------------- |
|
4262 // |
|
4263 TInt RVmbxNumber::BackUpSimNumber( const TDesC& aNumber, TInt aLineNumber ) |
|
4264 { |
|
4265 VMBLOGSTRING( "VMBX: RVmbxNumber::BackUpSimNumber: =>" ); |
|
4266 TUint32 lineNumber = aLineNumber == EAlsLine1 ? |
|
4267 KVmbxTmpNumberLinePrimary : KVmbxTmpNumberLineAuxiliary; |
|
4268 |
|
4269 VMBLOGSTRING( "VMBX: RVmbxNumber::BackUpSimNumber: <=" ); |
|
4270 return ( iSession->Set( lineNumber, aNumber )); |
|
4271 } |
|
4272 |
|
4273 // ----------------------------------------------------------------------------- |
|
4274 // RVmbxNumber::FetchSimNumberBackUp |
|
4275 // Fetches VMBX number from backup store |
|
4276 // ----------------------------------------------------------------------------- |
|
4277 // |
|
4278 TInt RVmbxNumber::FetchSimNumberBackUp( TDes& aNumber, TInt aLineNumber ) |
|
4279 { |
|
4280 VMBLOGSTRING( "VMBX: RVmbxNumber::FetchSimNumberBackUp: =>" ); |
|
4281 TUint32 lineNumber = aLineNumber == EAlsLine1 ? |
|
4282 KVmbxTmpNumberLinePrimary : KVmbxTmpNumberLineAuxiliary; |
|
4283 |
|
4284 VMBLOGSTRING( "VMBX: RVmbxNumber::FetchSimNumberBackUp: <=" ); |
|
4285 return ( iSession->Get( lineNumber, aNumber )); |
|
4286 } |
|
4287 |
|
4288 // ----------------------------------------------------------------------------- |
|
4289 // RVmbxNumber::ClearVMBXNumberFromPhone |
|
4290 // Fetches VMBX number from backup store |
|
4291 // ----------------------------------------------------------------------------- |
|
4292 // |
|
4293 TInt RVmbxNumber::ClearVMBXNumberFromPhone( TInt aLineNumber ) |
|
4294 { |
|
4295 VMBLOGSTRING( "VMBX: RVmbxNumber::ClearVMBXNumberFromPhone: =>" ); |
|
4296 |
|
4297 TInt error( KErrNone ); |
|
4298 |
|
4299 if ( aLineNumber == EAlsLine1 ) |
|
4300 { |
|
4301 error = SaveVmbxNumberToPhone( KEmptyVoiceMailNumber, EAlsLine1Entry ); |
|
4302 if ( KErrNone == error && |
|
4303 ( KErrNone == iSession->Set( KVmUsesSimMemory, EVmbxSimMemory ) ) ) |
|
4304 { |
|
4305 iMemoryLocation = EVmbxSimMemory; |
|
4306 VMBLOGSTRING( |
|
4307 "VMBX: RVmbxNumber::ClearVMBXNumberFromPhone: Line 1" ); |
|
4308 } |
|
4309 } |
|
4310 else if ( aLineNumber == EAlsLine2 ) |
|
4311 { |
|
4312 error = SaveVmbxNumberToPhone( KEmptyVoiceMailNumber, EAlsLine2Entry ); |
|
4313 if ( KErrNone == error ) |
|
4314 { |
|
4315 VMBLOGSTRING( |
|
4316 "VMBX: RVmbxNumber::ClearVMBXNumberFromPhone: Line 2"); |
|
4317 } |
|
4318 } |
|
4319 else |
|
4320 { |
|
4321 error = KErrArgument; |
|
4322 } |
|
4323 VMBLOGSTRING( "VMBX: RVmbxNumber::ClearVMBXNumberFromPhone: <=" ); |
|
4324 return error; |
|
4325 } |
|
4326 |
|
4327 // ----------------------------------------------------------------------------- |
|
4328 // RVmbxNumber::UserEditNumber |
|
4329 // Indicates if user has edited VMBX number |
|
4330 // ----------------------------------------------------------------------------- |
|
4331 // |
|
4332 TBool RVmbxNumber::UserEditNumber( TInt aLineNumber ) |
|
4333 { |
|
4334 VMBLOGSTRING( "VMBX: RVmbxNumber::UserEditNumber: =>" ); |
|
4335 TBool nbrEdited( EFalse ); |
|
4336 |
|
4337 TUint32 lineNumber = aLineNumber == EAlsLine1 ? |
|
4338 KUserEditedNumber : KUserEditedNumberAuxiliary; |
|
4339 |
|
4340 iSession->Get( lineNumber, nbrEdited ); |
|
4341 |
|
4342 VMBLOGSTRING2( "VMBX: RVmbxNumber::UserEditNumber: result = %d", |
|
4343 nbrEdited ); |
|
4344 return EVmbxUserEdit == nbrEdited; |
|
4345 } |
|
4346 |
|
4347 // ----------------------------------------------------------------------------- |
|
4348 // RVmbxNumber::SetUserEditNumber |
|
4349 // Sets the flag indicating that the user has edited VMBX number |
|
4350 // ----------------------------------------------------------------------------- |
|
4351 // |
|
4352 TInt RVmbxNumber::SetUserEditNumber( TInt aLineNumber ) |
|
4353 { |
|
4354 VMBLOGSTRING( "VMBX: RVmbxNumber::SetUserEditNumber: =>" ); |
|
4355 |
|
4356 TUint32 lineNumber = aLineNumber == EAlsLine1 ? |
|
4357 KUserEditedNumber : KUserEditedNumberAuxiliary; |
|
4358 |
|
4359 VMBLOGSTRING( "VMBX: RVmbxNumber::SetUserEditNumber: <=" ); |
|
4360 return ( iSession->Set( lineNumber, EVmbxUserEdit ) ); |
|
4361 } |
|
4362 |
|
4363 // ----------------------------------------------------------------------------- |
|
4364 // RVmbxNumber::ResetUserEditNumber |
|
4365 // Resets the flag that indicates that the user has edited VMBX number |
|
4366 // ----------------------------------------------------------------------------- |
|
4367 // |
|
4368 TInt RVmbxNumber::ResetUserEditNumber( TInt aLineNumber ) |
|
4369 { |
|
4370 VMBLOGSTRING( "VMBX: RVmbxNumber::ResetUserEditNumber: =>" ); |
|
4371 |
|
4372 TUint32 lineNumber = aLineNumber == EAlsLine1 ? |
|
4373 KUserEditedNumber : KUserEditedNumberAuxiliary; |
|
4374 |
|
4375 VMBLOGSTRING( "VMBX: RVmbxNumber::ResetUserEditNumber: <=" ); |
|
4376 return ( iSession->Set( lineNumber, EVmbxNotUserEdit ) ); |
|
4377 } |
|
4378 |
|
4379 // ----------------------------------------------------------------------------- |
|
4380 // RVmbxNumber::UseSimNumIfAvailable |
|
4381 // Fetches VMBX number stored in SIM if number is available |
|
4382 // ----------------------------------------------------------------------------- |
|
4383 // |
|
4384 TBool RVmbxNumber::UseSimNumIfAvailable( TDes& aNumber, TInt aLineNumber ) |
|
4385 { |
|
4386 TBuf< KVmbxMaxNumberLength > number; |
|
4387 TBool ret( EFalse ); |
|
4388 TInt error( KErrNone ); |
|
4389 TVmbxNumberEntry numberEntry = aLineNumber == EAlsLine1 ? |
|
4390 EAlsLine1Entry : EAlsLine2Entry; |
|
4391 |
|
4392 VMBLOGSTRING( "VMBX: RVmbxNumber::UseSimNumIfAvailable: =>" ); |
|
4393 |
|
4394 // If readonly SIM which supports VMBX number |
|
4395 // number is fetched from the backup store |
|
4396 if ( ( !( iFlags & KVmFlagSimWriteSupport ) && ( iFlags & KVmFlagSimVmbxNumSupport ) ) |
|
4397 && ( ( aLineNumber == EAlsLine1 && EVmbxPhoneMemory == iMemoryLocation ) || |
|
4398 aLineNumber == EAlsLine2 ) ) |
|
4399 { |
|
4400 error = FetchSimNumberBackUp( number, aLineNumber ); |
|
4401 if ( KErrNone == error ) |
|
4402 { |
|
4403 aNumber.Copy( number ); |
|
4404 SaveVmbxNumberToPhone( aNumber, numberEntry ); |
|
4405 VMBLOGSTRING( |
|
4406 "VMBX: RVmbxNumber::UseSimNumIfAvailable: number from backup store" ); |
|
4407 ret = ETrue; |
|
4408 } |
|
4409 } |
|
4410 // If writable SIM which supports VMBX number |
|
4411 // number is fetched from SIM |
|
4412 else if ( iFlags & KVmFlagSimWriteSupport && |
|
4413 ( ( aLineNumber == EAlsLine1 && EVmbxPhoneMemory == iMemoryLocation ) || |
|
4414 aLineNumber == EAlsLine2 ) ) |
|
4415 { |
|
4416 error = GetVmNumFromSIM( number, aLineNumber ); |
|
4417 if ( KErrNone == error ) |
|
4418 { |
|
4419 aNumber.Copy( number ); |
|
4420 if ( EAlsLine1 == aLineNumber ) |
|
4421 { |
|
4422 iMemoryLocation = EVmbxSimMemory; |
|
4423 iSession->Set( KVmUsesSimMemory, EVmbxSimMemory ); |
|
4424 } |
|
4425 VMBLOGSTRING( |
|
4426 "VMBX: RVmbxNumber::UseSimNumIfAvailable: number from SIM" ); |
|
4427 ret = ETrue; |
|
4428 } |
|
4429 } |
|
4430 VMBLOGSTRING( "VMBX: RVmbxNumber::UseSimNumIfAvailable: <=" ); |
|
4431 return ret; |
|
4432 } |
|
4433 |
|
4434 // ----------------------------------------------------------------------------- |
|
4435 // RVmbxNumber::HandleNumberStores |
|
4436 // Handles the updating of a number stores in phone memory |
|
4437 // ----------------------------------------------------------------------------- |
|
4438 // |
|
4439 TInt RVmbxNumber::HandleNumberStores( TInt aLineNumber ) |
|
4440 { |
|
4441 TInt error( KErrNone ); |
|
4442 TBuf< KVmbxMaxNumberLength > line2number; |
|
4443 |
|
4444 VMBLOGSTRING( "VMBX: RVmbxNumber::HandleNumberStores: =>" ); |
|
4445 |
|
4446 if ( iNumberFromSim.Length() ) |
|
4447 { |
|
4448 VMBLOGSTRING( "VMBX: RVmbxNumber::HandleNumberStores: Sim number found" ); |
|
4449 // If number found in read only SIM |
|
4450 // backup is made |
|
4451 if ( !( iFlags & KVmFlagSimWriteSupport ) ) |
|
4452 { |
|
4453 if ( aLineNumber == EAlsLine2 ) |
|
4454 { |
|
4455 error = GetVmNumFromSIM( line2number, EAlsLine2Entry ); |
|
4456 if ( KErrNone == error ) |
|
4457 { |
|
4458 error = BackUpSimNumber( line2number, aLineNumber ); |
|
4459 VMBLOGSTRING( "VMBX: RVmbxNumber::HandleNumberStores: Back up ALS 2 Sim number " ); |
|
4460 } |
|
4461 } |
|
4462 else |
|
4463 { |
|
4464 error = BackUpSimNumber( iNumberFromSim, aLineNumber ); |
|
4465 VMBLOGSTRING( "VMBX: RVmbxNumber::HandleNumberStores: Back up ALS 1 Sim number" ); |
|
4466 } |
|
4467 } |
|
4468 // If number found in SIM, old stored number is erased if |
|
4469 // it's not defined by the user or updated via external clients |
|
4470 if ( !UserEditNumber( aLineNumber ) && |
|
4471 !IsPhoneMemForcedEdit( aLineNumber ) ) |
|
4472 { |
|
4473 ClearVMBXNumberFromPhone( EAlsLine1 ); |
|
4474 ClearVMBXNumberFromPhone( EAlsLine2 ); |
|
4475 VMBLOGSTRING( "[VMBX]: RVmbxNumber::HandleNumberStores: Clear old VMBX number" ); |
|
4476 } |
|
4477 } |
|
4478 else |
|
4479 { |
|
4480 // Changing or defining the number from UI (user) not allowed |
|
4481 if ( !UserEditNumber( aLineNumber ) |
|
4482 && !IsPhoneMemForcedEdit( aLineNumber ) ) |
|
4483 { |
|
4484 ClearVMBXNumberFromPhone( EAlsLine1 ); |
|
4485 ClearVMBXNumberFromPhone( EAlsLine2 ); |
|
4486 VMBLOGSTRING( "VMBX: RVmbxNumber::HandleNumberStores: Clear old VMBX number" ); |
|
4487 } |
|
4488 } |
|
4489 VMBLOGSTRING( "VMBX: RVmbxNumber::HandleNumberStores: <=" ); |
|
4490 return error; |
|
4491 } |
|
4492 |
|
4493 // ---------------------------------------------------------------------------- |
|
4494 // RVmbxNumber::UsesSimMemory |
|
4495 // Returns if the SIM memory is used on ALS 1 |
|
4496 // ---------------------------------------------------------------------------- |
|
4497 // |
|
4498 TBool RVmbxNumber::UsesSimMemory() |
|
4499 { |
|
4500 VMBLOGSTRING( "VMBX: RVmbxNumber::UsesSimMemory: =>" ); |
|
4501 TBool ret( EFalse ); |
|
4502 TInt alsline( EAlsLine1 ); |
|
4503 // get the current ALS line |
|
4504 if ( GetAlsLine( alsline ) != KErrNone ) |
|
4505 { |
|
4506 alsline = EAlsLine1; // if problems, assume primary line |
|
4507 } |
|
4508 |
|
4509 iSession->Get( KVmUsesSimMemory, iMemoryLocation ); |
|
4510 if ( ( iMemoryLocation == EVmbxSimMemory ) && ( alsline == EAlsLine1 ) ) |
|
4511 { |
|
4512 VMBLOGSTRING( "VMBX: RVmbxNumber::UsesSimMemory: SimMemory active" ); |
|
4513 ret = ETrue; |
|
4514 } |
|
4515 VMBLOGSTRING( "VMBX: RVmbxNumber::UsesSimMemory: <=" ); |
|
4516 return ret; |
|
4517 } |
|
4518 |
|
4519 // ---------------------------------------------------------------------------- |
|
4520 // RVmbxNumber::IsPhoneMemForcedEdit |
|
4521 // Returns if VMBX number stored in phone memory via external clients |
|
4522 // ---------------------------------------------------------------------------- |
|
4523 // |
|
4524 TBool RVmbxNumber::IsPhoneMemForcedEdit( const TInt aLineNumber ) |
|
4525 { |
|
4526 VMBLOGSTRING( "VMBX: RVmbxNumber:: IsPhoneMemForcedEdit: =>" ); |
|
4527 TInt nbrEdited( NULL ); |
|
4528 |
|
4529 TUint32 lineNumber = aLineNumber == EAlsLine1 ? |
|
4530 KUserEditedNumber : KUserEditedNumberAuxiliary; |
|
4531 |
|
4532 iSession->Get( lineNumber, nbrEdited ); |
|
4533 |
|
4534 VMBLOGSTRING2( "VMBX: RVmbxNumber:: IsPhoneMemForcedEdit: value = %d", |
|
4535 nbrEdited ); |
|
4536 return EvmbxPhoneMemForcedEdit == nbrEdited; |
|
4537 } |
|
4538 |
|
4539 // ----------------------------------------------------------------------------- |
|
4540 // RVmbxNumber::SetPhoneMemForcedEdit |
|
4541 // Sets the flag indicating that external clients have edited VMBX number |
|
4542 // ----------------------------------------------------------------------------- |
|
4543 // |
|
4544 TInt RVmbxNumber::SetPhoneMemForcedEdit( TInt aLineNumber ) |
|
4545 { |
|
4546 VMBLOGSTRING( "VMBX: RVmbxNumber::SetPhoneMemForcedEdit: =>" ); |
|
4547 |
|
4548 TUint32 lineNumber = aLineNumber == EAlsLine1 ? |
|
4549 KUserEditedNumber : KUserEditedNumberAuxiliary; |
|
4550 |
|
4551 VMBLOGSTRING( "VMBX: RVmbxNumber::SetPhoneMemForcedEdit: <=" ); |
|
4552 return iSession->Set( lineNumber, EvmbxPhoneMemForcedEdit ); |
|
4553 } |
|
4554 |
|
4555 // ----------------------------------------------------------------------------- |
|
4556 // RVmbxNumber::ShowInformationNoteL |
|
4557 // Shows information note to user |
|
4558 // ----------------------------------------------------------------------------- |
|
4559 // |
|
4560 void RVmbxNumber::ShowInformationNoteL( const TInt aResourceId ) const |
|
4561 { |
|
4562 VMBLOGSTRING( "VMBX: RVmbxNumber::ShowInformationNoteL: =>" ); |
|
4563 HBufC* prompt = StringLoader::LoadLC( aResourceId, iCoeEnv ); |
|
4564 |
|
4565 CAknInformationNote* note = new ( ELeave ) CAknInformationNote ( ETrue ); |
|
4566 note->ExecuteLD( *prompt ); |
|
4567 |
|
4568 CleanupStack::PopAndDestroy( prompt ); |
|
4569 VMBLOGSTRING( "VMBX: RVmbxNumber::ShowInformationNoteL: <=" ); |
|
4570 } |
|
4571 |
|
4572 // ----------------------------------------------------------------------------- |
|
4573 // RVmbxNumber::IsNoNumberNoteAllowed |
|
4574 // check whether the note should be shown |
|
4575 // ----------------------------------------------------------------------------- |
|
4576 // |
|
4577 TBool RVmbxNumber::IsNoNumberNoteAllowed() |
|
4578 { |
|
4579 VMBLOGSTRING( "VMBX: RVmbxNumber::IsNoNumberNoteAllowed: =>" ); |
|
4580 TBool result( EFalse ); |
|
4581 |
|
4582 TInt videoRet( KErrNotFound ); |
|
4583 TBool isVideoSupport( VideoSupported() ); |
|
4584 TBool isVoipSupport( IsIpVoiceMailboxServices() ); |
|
4585 TBool psAddressFound( EFalse ); |
|
4586 |
|
4587 if ( isVideoSupport ) |
|
4588 { |
|
4589 HBufC* tmpNumber = HBufC::New( KVmbxMaxNumberLength ); |
|
4590 if ( tmpNumber ) |
|
4591 { |
|
4592 TPtr tmpPrt( tmpNumber->Des() ); |
|
4593 videoRet = GetVideoMbxNumber( tmpPrt ); |
|
4594 VMBLOGSTRING2( "VMBX: RVmbxNumber::IsNoNumberNoteAllowed \ |
|
4595 get videonum result=%d", videoRet ); |
|
4596 } |
|
4597 delete tmpNumber; |
|
4598 tmpNumber = NULL; |
|
4599 } |
|
4600 |
|
4601 if ( isVoipSupport ) |
|
4602 { |
|
4603 RArray<TUint> profileIds; |
|
4604 GetServiceIds( profileIds ); |
|
4605 |
|
4606 TVmbxServiceInfo serviceInfo; |
|
4607 serviceInfo.iAddress.Zero(); |
|
4608 for ( TInt i = 0; i < profileIds.Count() |
|
4609 && !psAddressFound; i++ ) |
|
4610 { |
|
4611 serviceInfo.iServiceId = profileIds[ i ]; |
|
4612 GetServiceInfo( serviceInfo ); |
|
4613 |
|
4614 VMBLOGSTRING2( "VMBX: RVmbxNumber::IsNoNumberNoteAllowed \ |
|
4615 PS address length=%d", serviceInfo.iAddress.Length() ); |
|
4616 if ( serviceInfo.iAddress.Length() ) |
|
4617 { |
|
4618 psAddressFound = ETrue; |
|
4619 } |
|
4620 } |
|
4621 |
|
4622 profileIds.Close(); |
|
4623 } |
|
4624 |
|
4625 // This check is done because phone client calls GetVmbxNumber |
|
4626 // and then SelectTypeL, which causes note qtn_... to be shown twice |
|
4627 // so the note can be shown in below several condition: |
|
4628 // the voice mailbox number is not defined, |
|
4629 // when video feature and |
|
4630 // voip feature are not supported. |
|
4631 // the video number is not defined, when video feature |
|
4632 // is supported but voip feature is not supported. |
|
4633 // the voip address is not defined, when voip feature |
|
4634 // is supported but video feature is not supported. |
|
4635 // both the video number and the voip address are not |
|
4636 // defined, when both video feature and |
|
4637 // voip feature are supported. |
|
4638 |
|
4639 if ( ( !isVideoSupport && !isVoipSupport ) |
|
4640 || ( ( isVideoSupport && KErrNotFound == videoRet ) |
|
4641 && !isVoipSupport ) |
|
4642 || ( ( isVoipSupport && !psAddressFound |
|
4643 && !isVideoSupport ) ) |
|
4644 || ( isVideoSupport && isVoipSupport |
|
4645 && KErrNotFound == videoRet && |
|
4646 !psAddressFound ) ) |
|
4647 { |
|
4648 result = ETrue; |
|
4649 } |
|
4650 |
|
4651 VMBLOGSTRING( "VMBX: RVmbxNumber::IsNoNumberNoteAllowed: <=" ); |
|
4652 return result; |
|
4653 } |
|
4654 |
|
4655 // End of File |