|
1 // Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // Implements the functionality required to provide clients with |
|
15 // CallWaiting status and registration information. |
|
16 // |
|
17 // |
|
18 |
|
19 /** |
|
20 @file |
|
21 */ |
|
22 |
|
23 #include <testconfigfileparser.h> |
|
24 #include "CSimCallWaiting.h" |
|
25 #include "CSimPhone.h" |
|
26 #include "Simlog.h" |
|
27 |
|
28 const TInt KMobServiceIndxStart = 1; |
|
29 const TInt KMobServiceIndxEnd = 5; |
|
30 |
|
31 |
|
32 CSimCallWaiting* CSimCallWaiting::NewL(CSimPhone* aPhone) |
|
33 /** |
|
34 * Standard two-phase constructor. |
|
35 * @param aPhone The parent phone object. |
|
36 * @return CSimCallWaiting The new call waiting class. |
|
37 */ |
|
38 { |
|
39 CSimCallWaiting* self=new(ELeave) CSimCallWaiting(aPhone); |
|
40 CleanupStack::PushL(self); |
|
41 self->ConstructL(); |
|
42 CleanupStack::Pop(); |
|
43 return self; |
|
44 } |
|
45 |
|
46 CSimCallWaiting::CSimCallWaiting(CSimPhone* aPhone) |
|
47 : iPhone(aPhone) |
|
48 /** |
|
49 * Trivial first phase construction. |
|
50 * @param aPhone The parent phone object. |
|
51 */ |
|
52 { |
|
53 } |
|
54 |
|
55 void CSimCallWaiting::ConstructL() |
|
56 /** |
|
57 Second phase of 2-Phase Constructor |
|
58 Retrieves all the Call waiting related tags from the config file |
|
59 */ |
|
60 { |
|
61 LOGCALL1("Starting to parse Call waiting config parameters..."); |
|
62 |
|
63 iGetCWStatus = new(ELeave) CArrayPtrFlat<CListReadAllAttempt>(1); |
|
64 FindAndCreateCWListL(); |
|
65 LOGCALL1("...Finished parsing Call waiting config parameters..."); |
|
66 } |
|
67 |
|
68 void CSimCallWaiting::FindAndCreateCWListL() |
|
69 { |
|
70 /** |
|
71 Retrieves all the Call waiting tags that define the |
|
72 original status of Call waiting from the config file |
|
73 */ |
|
74 LOGCALL1("CSimPhone::FindAndCreateCWListL"); |
|
75 RMobilePhone::TMobilePhoneCWInfoEntryV1 entry; |
|
76 |
|
77 iCWList = CMobilePhoneCWList::NewL(); |
|
78 TInt count=CfgFile()->ItemCount(KCWList); |
|
79 const CTestConfigItem* item=NULL; |
|
80 TInt ret=KErrNone; |
|
81 |
|
82 LOGCALL1("Starting to Load and Parse CWList Config parameters"); |
|
83 TInt i; |
|
84 for(i=0;i<count;i++) |
|
85 { |
|
86 item=CfgFile()->Item(KCWList,i); |
|
87 if(!item) |
|
88 break; |
|
89 |
|
90 TInt serviceGroup, status; |
|
91 |
|
92 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,serviceGroup); |
|
93 if(ret!=KErrNone) |
|
94 { |
|
95 LOGPARSERR("serviceGroup",ret,0,&KCWList); |
|
96 continue; |
|
97 } |
|
98 |
|
99 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,status); |
|
100 if(ret!=KErrNone) |
|
101 { |
|
102 LOGPARSERR("status",ret,1,&KCWList); |
|
103 continue; |
|
104 } |
|
105 |
|
106 entry.iServiceGroup=(RMobilePhone::TMobileService)serviceGroup; |
|
107 entry.iStatus=(RMobilePhone::TMobilePhoneCWStatus)status; |
|
108 |
|
109 iCWList->AddEntryL(entry); |
|
110 } |
|
111 } |
|
112 |
|
113 CSimCallWaiting::~CSimCallWaiting() |
|
114 { |
|
115 delete iCWList; |
|
116 if (iGetCWStatus) |
|
117 iGetCWStatus->ResetAndDestroy(); |
|
118 delete iGetCWStatus; |
|
119 } |
|
120 |
|
121 TInt CSimCallWaiting::ExtFuncL(const TTsyReqHandle aReqHandle,const TInt aIpc, const TDataPackage& aPckg) |
|
122 { |
|
123 /** |
|
124 Handles the phone based requests that apply to call waiting |
|
125 @param aReqHandle Handle to the request |
|
126 @param aIpc request identifier |
|
127 @param aPckg contains additional information for the requests |
|
128 */ |
|
129 |
|
130 TAny* dataPtr = aPckg.Ptr1(); |
|
131 TAny* dataPtr2 = aPckg.Ptr2(); |
|
132 // The following requests can be completed even if the completion of another request is pending. |
|
133 switch(aIpc) |
|
134 { |
|
135 case EMobilePhoneSetCallWaitingStatus: |
|
136 return SetCallWaitingStatusL(aReqHandle, |
|
137 REINTERPRET_CAST(RMobilePhone::TMobileService*, dataPtr), |
|
138 REINTERPRET_CAST(RMobilePhone::TMobilePhoneServiceAction*,dataPtr2)); |
|
139 case EMobilePhoneNotifyCallWaitingStatusChange: |
|
140 return NotifyCallWaitingStatusChange(aReqHandle, REINTERPRET_CAST(RMobilePhone::TMobilePhoneCWInfoEntryV1*, dataPtr)); |
|
141 case EMobilePhoneGetWaitingStatusPhase1: |
|
142 return GetCallWaitingStatusPhase1(aReqHandle, |
|
143 REINTERPRET_CAST(CRetrieveMobilePhoneCWList::TGetCallWaitingRequest*, dataPtr), |
|
144 REINTERPRET_CAST(TInt*, dataPtr2)); |
|
145 case EMobilePhoneGetWaitingStatusPhase2: |
|
146 return GetCallWaitingStatusPhase2(aReqHandle, |
|
147 REINTERPRET_CAST(RMobilePhone::TClientId*, dataPtr), aPckg.Des2n()); |
|
148 default: |
|
149 break; |
|
150 } |
|
151 return KErrNotSupported; |
|
152 } |
|
153 |
|
154 TInt CSimCallWaiting::CancelService(const TInt aIpc, const TTsyReqHandle aReqHandle) |
|
155 { |
|
156 /** |
|
157 Cancels any phone based request regarding call waiting |
|
158 @param aIpc the IPC to cancel |
|
159 @param aReqHandle handle to the request |
|
160 */ |
|
161 switch(aIpc) |
|
162 { |
|
163 case EMobilePhoneSetCallWaitingStatus: |
|
164 return SetCallWaitingStatusCancel(aReqHandle); |
|
165 case EMobilePhoneNotifyCallWaitingStatusChange: |
|
166 return NotifyCallWaitingStatusChangeCancel(aReqHandle); |
|
167 default: |
|
168 break; |
|
169 } |
|
170 return KErrNone; |
|
171 } |
|
172 |
|
173 TInt CSimCallWaiting::NotifyCallWaitingStatusChange(const TTsyReqHandle aReqHandle, RMobilePhone::TMobilePhoneCWInfoEntryV1* aCW) |
|
174 { |
|
175 /** |
|
176 Requests to be notified of change in the Call Waiting status |
|
177 @param aReqHandle Handle to the request |
|
178 @param aCW contains the service group and new status that has changed |
|
179 */ |
|
180 __ASSERT_ALWAYS(!iCWNotification.iCWChangeInfoNotificationPending,SimPanic(ENotificationReqAlreadyOutstanding)); |
|
181 iCWNotification.iCWChangeInfoNotificationPending=ETrue; |
|
182 iCWNotification.iCWChangeInfoReqHandle=aReqHandle; |
|
183 iCWNotification.iCWInfo=aCW; |
|
184 LOGCALL1("Finished CSimCallWaiting::NotifyCallWaitingStatusChange"); |
|
185 return KErrNone; |
|
186 } |
|
187 |
|
188 TInt CSimCallWaiting::NotifyCallWaitingStatusChangeCancel(const TTsyReqHandle aReqHandle) |
|
189 { |
|
190 /** |
|
191 Cancels request to be notified of call Waiting status change |
|
192 @param aReqHandle Handle to the request |
|
193 */ |
|
194 if(iCWNotification.iCWChangeInfoNotificationPending) |
|
195 { |
|
196 iCWNotification.iCWChangeInfoNotificationPending=EFalse; |
|
197 iPhone->ReqCompleted(aReqHandle,KErrCancel); |
|
198 } |
|
199 return KErrNone; |
|
200 } |
|
201 |
|
202 TInt CSimCallWaiting::SetCallWaitingStatusL(const TTsyReqHandle aReqHandle, RMobilePhone::TMobileService* aService, RMobilePhone::TMobilePhoneServiceAction* aAction) |
|
203 { |
|
204 /** |
|
205 Sets the status for call Waiting |
|
206 @param aReqHandle Handle to the request |
|
207 @param aCB condition for which the client whishes to set the call Waiting status |
|
208 @param aInfo additional parameters to set the call Waiting status |
|
209 */ |
|
210 |
|
211 // make sure we know that the operation concluded sucessfully |
|
212 TRAPD(ret,UpdateCWListL(aService,aAction)); |
|
213 if ( ret != KErrNone ) |
|
214 { |
|
215 iPhone->ReqCompleted(aReqHandle,ret); |
|
216 } |
|
217 |
|
218 // otherwise proceed and notify all went well |
|
219 // Notify change |
|
220 if (iCWNotification.iCWChangeInfoNotificationPending) |
|
221 { |
|
222 |
|
223 (iCWNotification.iCWInfo->iServiceGroup)=*aService; |
|
224 |
|
225 switch (*aAction) |
|
226 { |
|
227 case RMobilePhone::EServiceActionRegister: |
|
228 case RMobilePhone::EServiceActionActivate: |
|
229 iCWNotification.iCWInfo->iStatus= RMobilePhone::ECallWaitingStatusActive; |
|
230 break; |
|
231 case RMobilePhone::EServiceActionDeactivate: |
|
232 case RMobilePhone::EServiceActionErase: |
|
233 iCWNotification.iCWInfo->iStatus= RMobilePhone::ECallWaitingStatusNotActive; |
|
234 break; |
|
235 case RMobilePhone::EServiceActionUnspecified: |
|
236 default: |
|
237 iCWNotification.iCWInfo->iStatus= RMobilePhone::ECallWaitingStatusUnknown; |
|
238 // no sense doing any further operation - leave |
|
239 User::Leave( KErrArgument ); |
|
240 break; |
|
241 } |
|
242 |
|
243 iCWNotification.iCWChangeInfoNotificationPending=EFalse; |
|
244 iPhone->ReqCompleted(iCWNotification.iCWChangeInfoReqHandle,KErrNone); |
|
245 } |
|
246 |
|
247 iPhone->ReqCompleted(aReqHandle,KErrNone); |
|
248 |
|
249 return KErrNone; |
|
250 } |
|
251 |
|
252 TInt CSimCallWaiting::SetCallWaitingStatusCancel(const TTsyReqHandle aReqHandle) |
|
253 { |
|
254 /** |
|
255 Cancels the request to sets the status for call waiting |
|
256 @param aReqHandle Handle to the request |
|
257 */ |
|
258 |
|
259 iPhone->ReqCompleted(aReqHandle,KErrCancel); |
|
260 return KErrNone; |
|
261 } |
|
262 |
|
263 |
|
264 |
|
265 const CTestConfigSection* CSimCallWaiting::CfgFile() |
|
266 /** |
|
267 * Returns a pointer to the current configuration file section. |
|
268 * |
|
269 * @return CTestConfigSection A pointer to the current configuration file data section. |
|
270 */ |
|
271 { |
|
272 return iPhone->CfgFile(); |
|
273 } |
|
274 |
|
275 TInt CSimCallWaiting::GetCallWaitingStatusPhase1(const TTsyReqHandle aTsyReqHandle, |
|
276 CRetrieveMobilePhoneCWList::TGetCallWaitingRequest* aReqData, |
|
277 TInt* aBufSize) |
|
278 { |
|
279 /** |
|
280 1st phase retrieval of the the call waiting status list |
|
281 @param aReqHandle Handle to the request |
|
282 @param aReqData information about the request |
|
283 @param aBufSize Size of the buffer the client has to allocate for the 2nd pahase |
|
284 */ |
|
285 LOGCALL1("CSimCallWaiting::GetCalWaitingStatusPhase1"); |
|
286 |
|
287 TInt ret=KErrNone; |
|
288 TInt leaveCode=KErrNone; |
|
289 TRAP(leaveCode, ret=ProcessGetCallWaitingStatusPhase1L(aTsyReqHandle, aReqData, aBufSize);); |
|
290 if (leaveCode != KErrNone) |
|
291 iPhone->ReqCompleted(aTsyReqHandle,leaveCode); |
|
292 |
|
293 LOGCALL1("CSimCallWaiting::GetCalWaitingStatusPhase1"); |
|
294 return ret; |
|
295 } |
|
296 |
|
297 TInt CSimCallWaiting::ProcessGetCallWaitingStatusPhase1L(const TTsyReqHandle aTsyReqHandle, |
|
298 CRetrieveMobilePhoneCWList::TGetCallWaitingRequest* aReqData, |
|
299 TInt* aBufSize) |
|
300 { |
|
301 /** Retrieve call waiting status of each line from phone, |
|
302 store each CB status response as a list entry, |
|
303 stream the list and then return size of this buffer to client |
|
304 @param aReqHandle Handle to the request |
|
305 @param aReqData information about the request |
|
306 @param aBufSize Size of the buffer the client has to allocate for the 2nd pahase |
|
307 */ |
|
308 LOGCALL1("CSimCallWaiting::ProcessGetCallWaitingStatusPhase1L"); |
|
309 |
|
310 CMobilePhoneCWList* list=CMobilePhoneCWList::NewL(); |
|
311 CleanupStack::PushL(list); |
|
312 |
|
313 TInt maxNum=iCWList->Enumerate(); |
|
314 //if testing all CB are non-active |
|
315 // then we have to return a single entry EAllServices |
|
316 if ( maxNum ) |
|
317 { |
|
318 for(TInt i=0;i<maxNum;i++) |
|
319 { |
|
320 list->AddEntryL(iCWList->GetEntryL(i)); |
|
321 } |
|
322 } |
|
323 else |
|
324 { |
|
325 // if the list is empty and the querry general then we have to return general info |
|
326 RMobilePhone::TMobilePhoneCWInfoEntryV1 entry; |
|
327 |
|
328 // Check that the data structure is supported by the simulated TSY version |
|
329 TInt err = iPhone->CheckSimTsyVersion(entry); |
|
330 if(err != KErrNone) |
|
331 { |
|
332 iPhone->ReqCompleted(aTsyReqHandle, err); |
|
333 return KErrNone; |
|
334 } |
|
335 |
|
336 entry.iServiceGroup = RMobilePhone::EAllServices; |
|
337 entry.iStatus = RMobilePhone::ECallWaitingStatusNotActive; |
|
338 list->AddEntryL( entry ); |
|
339 } |
|
340 |
|
341 // Store the streamed list and the client ID |
|
342 CListReadAllAttempt* read=CListReadAllAttempt::NewL(aReqData->iClient,aTsyReqHandle); |
|
343 CleanupStack::PushL(read); |
|
344 |
|
345 read->iListBuf = list->StoreLC(); |
|
346 CleanupStack::Pop(); // pop the CBufBase allocated by StoreLC |
|
347 |
|
348 iGetCWStatus->AppendL(read); |
|
349 CleanupStack::Pop(read); // pop the CListReadAllAttempt |
|
350 |
|
351 // return the CBufBase’s size to client |
|
352 *aBufSize=(read->iListBuf)->Size(); |
|
353 |
|
354 CleanupStack::PopAndDestroy(list); // pop&destroy list |
|
355 |
|
356 // Complete first phase of list retrieval |
|
357 iPhone->ReqCompleted(aTsyReqHandle,KErrNone); |
|
358 |
|
359 LOGCALL1("CSimCallWaiting::ProcessGetCallWaitingStatusPhase1L"); |
|
360 return KErrNone; |
|
361 } |
|
362 |
|
363 TInt CSimCallWaiting::GetCallWaitingStatusPhase2(const TTsyReqHandle aTsyReqHandle, |
|
364 RMobilePhone::TClientId* aClient, TDes8* aBuf) |
|
365 { |
|
366 /** |
|
367 2nd phase retrieval of the the call waiting status list |
|
368 @param aReqHandle Handle to the request |
|
369 @param aClient Ponter to the client |
|
370 @param aBuf Buffer containiong the call waiting status list |
|
371 */ |
|
372 LOGCALL1("CSimCallWaiting::GetCallWaitingStatusPhase2"); |
|
373 CListReadAllAttempt* read=NULL; |
|
374 // Find the get detected network attempt from this client |
|
375 for (TInt i=0; i<iGetCWStatus->Count(); ++i) |
|
376 { |
|
377 read = iGetCWStatus->At(i); |
|
378 if ((read->iClient.iSessionHandle==aClient->iSessionHandle) && |
|
379 (read->iClient.iSubSessionHandle==aClient->iSubSessionHandle)) |
|
380 { |
|
381 TPtr8 bufPtr((read->iListBuf)->Ptr(0)); |
|
382 // Copy the streamed list to the client |
|
383 aBuf->Copy(bufPtr); |
|
384 delete read; |
|
385 iGetCWStatus->Delete(i); |
|
386 iPhone->ReqCompleted(aTsyReqHandle,KErrNone); |
|
387 return KErrNone; |
|
388 } |
|
389 } |
|
390 // Should handle error case of not finding the matching client from read all phase 1 |
|
391 LOGCALL1("CSimCallWaiting::GetCallWaitingStatusPhase2"); |
|
392 return KErrNotFound; |
|
393 } |
|
394 |
|
395 TInt CSimCallWaiting::GetCallWaitingStatusCancel(const TTsyReqHandle aTsyReqHandle) |
|
396 { |
|
397 /* |
|
398 Cancels a Request to retrieve the call waiting status list |
|
399 @param aReqHandle Handle to the request |
|
400 */ |
|
401 LOGCALL1("CSimCallWaiting::GetCallWaitingStatusCancel"); |
|
402 iPhone->ReqCompleted(aTsyReqHandle,KErrNone); |
|
403 // Remove the read all attempt from iGetCBStatus |
|
404 CListReadAllAttempt* read=NULL; |
|
405 for (TInt i=0; i<iGetCWStatus->Count(); ++i) |
|
406 { |
|
407 read = iGetCWStatus->At(i); |
|
408 if (read->iReqHandle == aTsyReqHandle) |
|
409 { |
|
410 delete read; |
|
411 iGetCWStatus->Delete(i); |
|
412 break; |
|
413 } |
|
414 } |
|
415 iPhone->ReqCompleted(aTsyReqHandle,KErrCancel); |
|
416 LOGCALL1("CSimCallWaiting::GetCallWaitingStatusCancel"); |
|
417 return KErrNone; |
|
418 } |
|
419 |
|
420 inline void SplitOneEntryIntoSeparateGroupsL( |
|
421 CMobilePhoneCWList* aCWList, |
|
422 RMobilePhone::TMobilePhoneCWInfoEntryV1 aOrigEntry, |
|
423 RMobilePhone::TMobileService aExceptServiceGroup |
|
424 ) |
|
425 { |
|
426 /* |
|
427 Splits one entry valid for all basic service groups into individual entries |
|
428 and places them into a CMobilePhoneCBList. This excludes one service group. |
|
429 @param aCBList The list to which to store the entries |
|
430 @param aOrigEntry The original entry; details of which should be passed to individual group entries |
|
431 @param aExceptServiceGroup The group which has to be avoided |
|
432 */ |
|
433 // we have to split the entry into entries |
|
434 // per group with the same condition; excluding the specified service group |
|
435 RMobilePhone::TMobilePhoneCWInfoEntryV1 anotherEntry = aOrigEntry; |
|
436 |
|
437 //anotherEntry.iCondition = aOrigEntry.iCondition; |
|
438 //anotherEntry.iStatus = RMobilePhone::ECallBarringStatusActive; |
|
439 RMobilePhone::TMobileService service; |
|
440 |
|
441 for (TInt i=KMobServiceIndxStart; i<=KMobServiceIndxEnd;i++) |
|
442 { |
|
443 service=static_cast<RMobilePhone::TMobileService>(i); |
|
444 if( service != aExceptServiceGroup ) |
|
445 { |
|
446 anotherEntry.iServiceGroup=service; |
|
447 aCWList->AddEntryL(anotherEntry); |
|
448 } |
|
449 }//end for (another) |
|
450 } |
|
451 |
|
452 void CSimCallWaiting::UpdateCWListL(RMobilePhone::TMobileService* aServiceGroup, RMobilePhone::TMobilePhoneServiceAction* aAction ) |
|
453 { |
|
454 /* |
|
455 Updates the status of call waiting. |
|
456 @param aServiceGroup service group to set |
|
457 @param aAction ation to be performed |
|
458 */ |
|
459 |
|
460 // no sense processing if either condition or change info are NULLS |
|
461 User::LeaveIfNull(aServiceGroup); |
|
462 User::LeaveIfNull(aAction); |
|
463 |
|
464 |
|
465 //Lets do some work then |
|
466 RMobilePhone::TMobilePhoneCWInfoEntryV1 theNewEntry; |
|
467 |
|
468 theNewEntry.iServiceGroup = *aServiceGroup; |
|
469 |
|
470 switch (*aAction) |
|
471 { |
|
472 case RMobilePhone::EServiceActionRegister: |
|
473 case RMobilePhone::EServiceActionActivate: |
|
474 theNewEntry.iStatus= RMobilePhone::ECallWaitingStatusActive; |
|
475 break; |
|
476 case RMobilePhone::EServiceActionDeactivate: |
|
477 case RMobilePhone::EServiceActionErase: |
|
478 theNewEntry.iStatus= RMobilePhone::ECallWaitingStatusNotActive; |
|
479 break; |
|
480 case RMobilePhone::EServiceActionUnspecified: |
|
481 default: |
|
482 theNewEntry.iStatus= RMobilePhone::ECallWaitingStatusUnknown; |
|
483 // no sense doing any further operation - leave |
|
484 User::Leave( KErrArgument ); |
|
485 break; |
|
486 } |
|
487 |
|
488 // retain prev version of the list in local variable and in Cleanup stack |
|
489 CMobilePhoneCWList* thePrevCWList = CMobilePhoneCWList::NewL(); |
|
490 CleanupStack::PushL(thePrevCWList); |
|
491 // copy existing data into the temp storage |
|
492 for (TInt indx=0; indx<iCWList->Enumerate(); indx++) |
|
493 { |
|
494 thePrevCWList->AddEntryL(iCWList->GetEntryL(indx)); |
|
495 } |
|
496 delete iCWList; |
|
497 iCWList = NULL; |
|
498 |
|
499 // create a new version and hold it in the class member |
|
500 iCWList = CMobilePhoneCWList::NewL(); |
|
501 // get a hold of it in a local variable |
|
502 CMobilePhoneCWList* theNewCWList = iCWList; |
|
503 RMobilePhone::TMobilePhoneCWInfoEntryV1 entry; |
|
504 |
|
505 TInt count = thePrevCWList->Enumerate(); |
|
506 |
|
507 if (theNewEntry.iStatus == RMobilePhone::ECallWaitingStatusActive) |
|
508 { |
|
509 if (theNewEntry.iServiceGroup==RMobilePhone::EAllServices) |
|
510 { |
|
511 theNewCWList->AddEntryL(theNewEntry); |
|
512 } |
|
513 else |
|
514 { |
|
515 for (TInt i = 0; i<count; i++) |
|
516 { |
|
517 entry = thePrevCWList->GetEntryL(i); |
|
518 if(entry.iServiceGroup!=theNewEntry.iServiceGroup |
|
519 && entry.iServiceGroup!=RMobilePhone::EAllServices) |
|
520 theNewCWList->AddEntryL(entry); |
|
521 } |
|
522 theNewCWList->AddEntryL(theNewEntry); |
|
523 } |
|
524 } |
|
525 else //deactivate |
|
526 { |
|
527 if (theNewEntry.iServiceGroup==RMobilePhone::EAllServices) |
|
528 { |
|
529 theNewCWList->AddEntryL(theNewEntry); |
|
530 } |
|
531 else |
|
532 { |
|
533 for (TInt i = 0; i<count; i++) |
|
534 { |
|
535 entry = thePrevCWList->GetEntryL(i); |
|
536 if(entry.iServiceGroup==RMobilePhone::EAllServices) |
|
537 { |
|
538 //add to the list active entries for all servive groups but the one to be deactivated |
|
539 SplitOneEntryIntoSeparateGroupsL(theNewCWList,entry, theNewEntry.iServiceGroup); |
|
540 continue; |
|
541 } |
|
542 if(entry.iServiceGroup!=theNewEntry.iServiceGroup) |
|
543 { |
|
544 theNewCWList->AddEntryL(entry); |
|
545 } |
|
546 } |
|
547 } |
|
548 |
|
549 } |
|
550 // now delete the old memory |
|
551 CleanupStack::PopAndDestroy(thePrevCWList); |
|
552 } |
|
553 |