|
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 // This file contains the implementation of the Simulator TSY Data Call functionality. |
|
15 // The Call classes process the Call-based requests made by ETel clients |
|
16 // and passed down to the TSY by the ETel Server. |
|
17 // |
|
18 // |
|
19 |
|
20 /** |
|
21 @file |
|
22 */ |
|
23 |
|
24 #include <testconfigfileparser.h> |
|
25 #include "CSimDataCall.h" |
|
26 #include "CSimPhone.h" |
|
27 #include "Simlog.h" |
|
28 |
|
29 CSimDataCall* CSimDataCall::NewL(CSimLine* aLine,const TDesC& aName, CSimPhone* aPhone) |
|
30 /** |
|
31 * Standard two phase constructor. |
|
32 * |
|
33 * @param aLine pointer to the Line object. |
|
34 * @param aName name of the call to be constructed |
|
35 * @return CSimDataCall pointer to the data call object created |
|
36 * @leave Leaves if no memory or object is not created for any reason |
|
37 */ |
|
38 { |
|
39 CSimDataCall* dataCall=new(ELeave) CSimDataCall(aLine,aName,aPhone); |
|
40 TCleanupItem newCallDataClose(CloseCall,dataCall); |
|
41 CleanupStack::PushL(newCallDataClose); |
|
42 dataCall->ConstructL(); |
|
43 CleanupStack::Pop(); |
|
44 return dataCall; |
|
45 } |
|
46 |
|
47 CSimDataCall::CSimDataCall(CSimLine* aLine,const TName& aName, CSimPhone* aPhone) |
|
48 : CSimCall(aLine,aName,aPhone), iCommPortLoaned(EFalse) |
|
49 /** |
|
50 * Trivial constructor. Calls CSimCall to initialise its members |
|
51 */ |
|
52 { |
|
53 iCaps=Caps(); |
|
54 } |
|
55 |
|
56 void CSimDataCall::ConstructL() |
|
57 /** |
|
58 * Second phase of 2-Phase Constructor |
|
59 * Retrieves all the pausing duration tags from the config file |
|
60 * |
|
61 * @param aName name of the data call to be constructed |
|
62 */ |
|
63 { |
|
64 LOGDATA1("Starting to parse Data Call config parameters..."); |
|
65 |
|
66 iDiallingPause=iLine->CfgFile()->ItemValue(KDiallingPauseDuration,KDefaultDiallingPauseDuration); |
|
67 iConnectingPause=iLine->CfgFile()->ItemValue(KConnectingPauseDuration,KDefaultConnectingPauseDuration); |
|
68 iDisconnectingPause=iLine->CfgFile()->ItemValue(KDisconnectingPauseDuration,KDefaultDisconnectingPauseDuration); |
|
69 iAnswerIncomingPause=iLine->CfgFile()->ItemValue(KAnswerIncomingPauseDuration,KDefaultAnswerIncomingPauseDuration); |
|
70 iRemoteHangupPause=iLine->CfgFile()->ItemValue(KRemoteHangupPauseDuration,KDefaultRemoteHangupPauseDuration); |
|
71 |
|
72 // Read in the CommPort setup |
|
73 |
|
74 const CTestConfigItem* item=iLine->CfgFile()->Item(KDataCallCaps); |
|
75 if(item) |
|
76 { |
|
77 TPtrC8 speedCaps, protocolCaps, serviceCaps, qosCaps, codingCaps, asymmetryCaps; |
|
78 TPtrC8 rlpVersionCaps, v42bisCaps; |
|
79 TBool hscsdSupport, userInitUpgrade; |
|
80 TInt mClass, MaxRxTimeslots, MaxTxTimeslots, totalRxTxTimeslots; |
|
81 TUint8 digit = 0; |
|
82 |
|
83 TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,speedCaps); |
|
84 if(ret!=KErrNone) |
|
85 { |
|
86 LOGPARSERR("speedCaps",ret,0,&KDataCallCaps); |
|
87 } |
|
88 else |
|
89 if(AsciiToNum(speedCaps, digit)==KErrNone) |
|
90 iMobileCallCaps.iSpeedCaps = digit; |
|
91 |
|
92 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,protocolCaps); |
|
93 if(ret!=KErrNone) |
|
94 { |
|
95 LOGPARSERR("protocolCaps",ret,1,&KDataCallCaps); |
|
96 } |
|
97 else |
|
98 if(AsciiToNum(protocolCaps, digit)==KErrNone) |
|
99 iMobileCallCaps.iProtocolCaps = digit; |
|
100 |
|
101 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,serviceCaps); |
|
102 if(ret!=KErrNone) |
|
103 { |
|
104 LOGPARSERR("serviceCaps",ret,2,&KDataCallCaps); |
|
105 } |
|
106 else |
|
107 if(AsciiToNum(serviceCaps, digit)==KErrNone) |
|
108 iMobileCallCaps.iServiceCaps = digit; |
|
109 |
|
110 |
|
111 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,qosCaps); |
|
112 if(ret!=KErrNone) |
|
113 { |
|
114 LOGPARSERR("qosCaps",ret,3,&KDataCallCaps); |
|
115 } |
|
116 else |
|
117 if(AsciiToNum(qosCaps, digit)==KErrNone) |
|
118 iMobileCallCaps.iQoSCaps = digit; |
|
119 |
|
120 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,hscsdSupport); |
|
121 if(ret!=KErrNone) |
|
122 { |
|
123 LOGPARSERR("hscsdSupport",ret,4,&KDataCallCaps); |
|
124 } |
|
125 else |
|
126 iMobileCallCaps.iHscsdSupport = hscsdSupport; |
|
127 |
|
128 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,mClass); |
|
129 if(ret!=KErrNone) |
|
130 { |
|
131 LOGPARSERR("mClass",ret,5,&KDataCallCaps); |
|
132 } |
|
133 else |
|
134 iMobileCallCaps.iMClass = mClass; |
|
135 |
|
136 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,MaxRxTimeslots); |
|
137 if(ret!=KErrNone) |
|
138 { |
|
139 LOGPARSERR("MaxRxTimeslots",ret,6,&KDataCallCaps); |
|
140 } |
|
141 else |
|
142 iMobileCallCaps.iMaxRxTimeSlots = MaxRxTimeslots; |
|
143 |
|
144 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,MaxTxTimeslots); |
|
145 if(ret!=KErrNone) |
|
146 { |
|
147 LOGPARSERR("MaxTxTimeslots",ret,7,&KDataCallCaps); |
|
148 } |
|
149 else |
|
150 iMobileCallCaps.iMaxTxTimeSlots = MaxTxTimeslots; |
|
151 |
|
152 |
|
153 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,totalRxTxTimeslots); |
|
154 if(ret!=KErrNone) |
|
155 { |
|
156 LOGPARSERR("totalRxTxTimeslots",ret,8,&KDataCallCaps); |
|
157 } |
|
158 else |
|
159 iMobileCallCaps.iTotalRxTxTimeSlots = totalRxTxTimeslots; |
|
160 |
|
161 |
|
162 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,codingCaps); |
|
163 if(ret!=KErrNone) |
|
164 { |
|
165 LOGPARSERR("codingCaps",ret,9,&KDataCallCaps); |
|
166 } |
|
167 else |
|
168 if(AsciiToNum(codingCaps, digit)==KErrNone) |
|
169 iMobileCallCaps.iCodingCaps = digit; |
|
170 |
|
171 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,asymmetryCaps); |
|
172 if(ret!=KErrNone) |
|
173 { |
|
174 LOGPARSERR("asymmetryCaps",ret,10,&KDataCallCaps); |
|
175 } |
|
176 else |
|
177 if(AsciiToNum(asymmetryCaps, digit)==KErrNone) |
|
178 iMobileCallCaps.iAsymmetryCaps = digit; |
|
179 |
|
180 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,userInitUpgrade); |
|
181 if(ret!=KErrNone) |
|
182 { |
|
183 LOGPARSERR("userInitUpgrade",ret,11,&KDataCallCaps); |
|
184 } |
|
185 else |
|
186 iMobileCallCaps.iUserInitUpgrade = userInitUpgrade; |
|
187 |
|
188 |
|
189 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,rlpVersionCaps); |
|
190 if(ret!=KErrNone) |
|
191 { |
|
192 LOGPARSERR("rlpVersionCaps",ret,10,&KDataCallCaps); |
|
193 } |
|
194 else |
|
195 if(AsciiToNum(rlpVersionCaps, digit)==KErrNone) |
|
196 iMobileCallCaps.iRLPVersionCaps = digit; |
|
197 |
|
198 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,v42bisCaps); |
|
199 if(ret!=KErrNone) |
|
200 { |
|
201 LOGPARSERR("v42bisCaps",ret,10,&KDataCallCaps); |
|
202 } |
|
203 else |
|
204 if(AsciiToNum(v42bisCaps, digit)==KErrNone) |
|
205 iMobileCallCaps.iV42bisCaps = digit; |
|
206 } |
|
207 else //Default Values for Caps |
|
208 { |
|
209 iMobileCallCaps.iSpeedCaps=RMobileCall::KCapsSpeedAutobauding; |
|
210 iMobileCallCaps.iProtocolCaps=RMobileCall::KCapsProtocolV32; |
|
211 iMobileCallCaps.iServiceCaps=(RMobileCall::KCapsDataCircuitAsynchronous | RMobileCall::KCapsPacketAccessSyncUDI); |
|
212 iMobileCallCaps.iQoSCaps=RMobileCall::KCapsTransparentPreferred; |
|
213 iMobileCallCaps.iHscsdSupport=(TBool)(ETrue); |
|
214 iMobileCallCaps.iMClass=1; |
|
215 iMobileCallCaps.iMaxRxTimeSlots=5; |
|
216 iMobileCallCaps.iMaxTxTimeSlots=5; |
|
217 iMobileCallCaps.iTotalRxTxTimeSlots=10; |
|
218 iMobileCallCaps.iCodingCaps=(RMobileCall::KCapsAiurCoding48 | RMobileCall::KCapsAiurCoding96); |
|
219 iMobileCallCaps.iAsymmetryCaps=(RMobileCall::EAsymmetryUplink); |
|
220 iMobileCallCaps.iUserInitUpgrade=(TBool)(ETrue); |
|
221 iMobileCallCaps.iRLPVersionCaps = 1; |
|
222 iMobileCallCaps.iV42bisCaps = 1; |
|
223 } |
|
224 |
|
225 TInt count = iLine->CfgFile()->ItemCount(KDataRLPparams); |
|
226 TMobileCallRLPItem iMobileCallRLPItem; |
|
227 iMobileCallRLPList = new(ELeave) CArrayFixFlat<TMobileCallRLPItem>(5); |
|
228 |
|
229 if(count!=0) |
|
230 { |
|
231 for(TInt i=0;i<count;i++) |
|
232 { |
|
233 |
|
234 item = iLine->CfgFile()->Item(KDataRLPparams,i); |
|
235 if(!item) |
|
236 break; |
|
237 |
|
238 TInt iRlpVersion,iIWSMax,iIWSMin,iMWSMax,iMWSMin; |
|
239 TInt iT1Max,iT1Min,iN2Max,iN2Min,iT4Max,iT4Min; |
|
240 |
|
241 TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iRlpVersion); |
|
242 if(ret!=KErrNone) |
|
243 { |
|
244 LOGPARSERR("iRlpVersion",ret,0,&KDataRLPparams); |
|
245 } |
|
246 else |
|
247 iMobileCallRLPItem.iRlpVersion = iRlpVersion; |
|
248 |
|
249 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iIWSMax); |
|
250 if(ret!=KErrNone) |
|
251 { |
|
252 LOGPARSERR("iIWSMax",ret,0,&KDataRLPparams); |
|
253 } |
|
254 else |
|
255 iMobileCallRLPItem.iMobileCallRLP.iIWSMax = iIWSMax; |
|
256 |
|
257 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,iIWSMin); |
|
258 if(ret!=KErrNone) |
|
259 { |
|
260 LOGPARSERR("iIWSMin",ret,1,&KDataRLPparams); |
|
261 } |
|
262 else |
|
263 iMobileCallRLPItem.iMobileCallRLP.iIWSMin = iIWSMin; |
|
264 |
|
265 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,iMWSMax); |
|
266 if(ret!=KErrNone) |
|
267 { |
|
268 LOGPARSERR("iMWSMax",ret,2,&KDataRLPparams); |
|
269 } |
|
270 else |
|
271 iMobileCallRLPItem.iMobileCallRLP.iMWSMax = iMWSMax; |
|
272 |
|
273 |
|
274 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,iMWSMin); |
|
275 if(ret!=KErrNone) |
|
276 { |
|
277 LOGPARSERR("iMWSMin",ret,3,&KDataRLPparams); |
|
278 } |
|
279 else |
|
280 iMobileCallRLPItem.iMobileCallRLP.iMWSMin = iMWSMin; |
|
281 |
|
282 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,iT1Max); |
|
283 if(ret!=KErrNone) |
|
284 { |
|
285 LOGPARSERR("iT1Max",ret,4,&KDataRLPparams); |
|
286 } |
|
287 else |
|
288 iMobileCallRLPItem.iMobileCallRLP.iT1Max = iT1Max; |
|
289 |
|
290 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,iT1Min); |
|
291 if(ret!=KErrNone) |
|
292 { |
|
293 LOGPARSERR("iT1Min",ret,5,&KDataRLPparams); |
|
294 } |
|
295 else |
|
296 iMobileCallRLPItem.iMobileCallRLP.iT1Min = iT1Min; |
|
297 |
|
298 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,iN2Max); |
|
299 if(ret!=KErrNone) |
|
300 { |
|
301 LOGPARSERR("iN2Max",ret,6,&KDataRLPparams); |
|
302 } |
|
303 else |
|
304 iMobileCallRLPItem.iMobileCallRLP.iN2Max = iN2Max; |
|
305 |
|
306 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,iN2Min); |
|
307 if(ret!=KErrNone) |
|
308 { |
|
309 LOGPARSERR("iN2Min",ret,7,&KDataRLPparams); |
|
310 } |
|
311 else |
|
312 iMobileCallRLPItem.iMobileCallRLP.iN2Min = iN2Min; |
|
313 |
|
314 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,iT4Max); |
|
315 if(ret!=KErrNone) |
|
316 { |
|
317 LOGPARSERR("iT4Max",ret,8,&KDataRLPparams); |
|
318 } |
|
319 else |
|
320 iMobileCallRLPItem.iMobileCallRLP.iT4Max = iT4Max; |
|
321 |
|
322 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,iT4Min); |
|
323 if(ret!=KErrNone) |
|
324 { |
|
325 LOGPARSERR("iT4Min",ret,9,&KDataRLPparams); |
|
326 } |
|
327 else |
|
328 iMobileCallRLPItem.iMobileCallRLP.iT4Min = iT4Min; |
|
329 |
|
330 iMobileCallRLPList->AppendL(iMobileCallRLPItem); |
|
331 } |
|
332 } |
|
333 else |
|
334 { |
|
335 iMobileCallRLPItem.iRlpVersion=1; |
|
336 iMobileCallRLPItem.iMobileCallRLP.iIWSMax=10; |
|
337 iMobileCallRLPItem.iMobileCallRLP.iIWSMin=5; |
|
338 iMobileCallRLPItem.iMobileCallRLP.iMWSMax=8; |
|
339 iMobileCallRLPItem.iMobileCallRLP.iMWSMin=4; |
|
340 iMobileCallRLPItem.iMobileCallRLP.iT1Max=4; |
|
341 iMobileCallRLPItem.iMobileCallRLP.iT1Min=2; |
|
342 iMobileCallRLPItem.iMobileCallRLP.iN2Max=12; |
|
343 iMobileCallRLPItem.iMobileCallRLP.iN2Min=1; |
|
344 iMobileCallRLPItem.iMobileCallRLP.iT4Max=10; |
|
345 iMobileCallRLPItem.iMobileCallRLP.iT4Min=2; |
|
346 iMobileCallRLPList->AppendL(iMobileCallRLPItem); |
|
347 } |
|
348 |
|
349 item=iLine->CfgFile()->Item(KDynamicHSCSDInfo); |
|
350 if(item) |
|
351 { |
|
352 TPtrC8 iAiur,iCodings; |
|
353 TInt iRxTimeSlots,iTxTimeSlots; |
|
354 |
|
355 TUint8 digit=0; |
|
356 |
|
357 TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iAiur); |
|
358 if(ret!=KErrNone) |
|
359 { |
|
360 LOGPARSERR("iAiur",ret,0,&KDynamicHSCSDInfo); |
|
361 } |
|
362 else |
|
363 if(AsciiToNum(iAiur, digit)==KErrNone) |
|
364 iHscsdInfo.iAiur = (RMobileCall::TMobileCallAiur) digit; |
|
365 |
|
366 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,iRxTimeSlots); |
|
367 if(ret!=KErrNone) |
|
368 { |
|
369 LOGPARSERR("iRxTimeSlots",ret,1,&KDynamicHSCSDInfo); |
|
370 } |
|
371 else |
|
372 iHscsdInfo.iRxTimeSlots = iRxTimeSlots; |
|
373 |
|
374 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,iTxTimeSlots); |
|
375 if(ret!=KErrNone) |
|
376 { |
|
377 LOGPARSERR("iTxTimeSlots",ret,2,&KDynamicHSCSDInfo); |
|
378 } |
|
379 else |
|
380 iHscsdInfo.iTxTimeSlots = iTxTimeSlots; |
|
381 |
|
382 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,iCodings); |
|
383 if(ret!=KErrNone) |
|
384 { |
|
385 LOGPARSERR("iCodings",ret,3,&KDynamicHSCSDInfo); |
|
386 } |
|
387 else |
|
388 if(AsciiToNum(iCodings, digit)==KErrNone) |
|
389 iHscsdInfo.iCodings = (RMobileCall::TMobileCallTchCoding) digit; |
|
390 } |
|
391 else |
|
392 { |
|
393 iHscsdInfo.iAiur=RMobileCall::EAiurBps9600; |
|
394 iHscsdInfo.iRxTimeSlots=5; |
|
395 iHscsdInfo.iTxTimeSlots=10; |
|
396 iHscsdInfo.iCodings=RMobileCall::ETchCoding48; |
|
397 } |
|
398 |
|
399 item=iLine->CfgFile()->Item(KCommSetup); |
|
400 if(item) |
|
401 { |
|
402 TPtrC8 portName,csyName; |
|
403 TInt err=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,csyName); // The 3rd parameter (0) represents the index of the variable on the config file line |
|
404 if (err!=KErrNone) |
|
405 { |
|
406 LOGPARSERR("csyName",err,0,&KCommSetup); |
|
407 iCsyName.Copy(KDefaultCsyName); |
|
408 } |
|
409 else |
|
410 iCsyName.Copy(csyName); |
|
411 |
|
412 err=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,portName); // The 3rd parameter (1) represents the index of the variable on the config file line |
|
413 if (err!=KErrNone) |
|
414 { |
|
415 LOGPARSERR("portName",err,1,&KCommSetup); |
|
416 iPortName.Copy(KDefaultPortName); |
|
417 } |
|
418 else |
|
419 iPortName.Copy(portName); |
|
420 |
|
421 TInt dataRate,handshake; |
|
422 err=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,dataRate); // The 3rd parameter (2) represents the index of the variable on the config file line |
|
423 if (err!=KErrNone) |
|
424 { |
|
425 LOGPARSERR("dataRate",err,2,&KCommSetup); |
|
426 iConfig.iRate=KDefaultCommPortRate; |
|
427 } |
|
428 else |
|
429 iConfig.iRate=(TBps)dataRate; |
|
430 |
|
431 err=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,handshake); // The 3rd parameter (3) represents the index of the variable on the config file line |
|
432 if (err!=KErrNone) |
|
433 { |
|
434 LOGPARSERR("handshake",err,3,&KCommSetup); |
|
435 iConfig.iHandshake=KDefaultHandshake; |
|
436 } |
|
437 else |
|
438 iConfig.iHandshake=(TUint)handshake; |
|
439 } |
|
440 else |
|
441 { |
|
442 iCsyName.Copy(KDefaultCsyName); |
|
443 iPortName.Copy(KDefaultPortName); |
|
444 iConfig.iRate=KDefaultCommPortRate; |
|
445 iConfig.iHandshake=KDefaultHandshake; |
|
446 } |
|
447 |
|
448 // Read in the Bearer Service information |
|
449 item=iLine->CfgFile()->Item(KBearerService); |
|
450 if(item) |
|
451 { |
|
452 TInt bearerCaps,bearerSpeed; |
|
453 TInt err=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,bearerCaps); // The 3rd parameter (0) represents the index of the variable on the config file line |
|
454 if (err!=KErrNone) |
|
455 { |
|
456 LOGPARSERR("bearerCaps",err,0,&KBearerService); |
|
457 iBearerService.iBearerCaps=KDefaultBearerCaps; |
|
458 } |
|
459 else |
|
460 iBearerService.iBearerCaps=bearerCaps; |
|
461 |
|
462 err=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,bearerSpeed); // The 3rd parameter (1) represents the index of the variable on the config file line |
|
463 if (err!=KErrNone) |
|
464 { |
|
465 LOGPARSERR("bearerSpeed",err,1,&KBearerService); |
|
466 iBearerService.iBearerSpeed=KDefaultBearerSpeed; |
|
467 } |
|
468 else |
|
469 iBearerService.iBearerSpeed=(RCall::TCallBearerSpeed)bearerSpeed; |
|
470 |
|
471 } |
|
472 else |
|
473 { |
|
474 iBearerService.iBearerCaps=KDefaultBearerCaps; |
|
475 iBearerService.iBearerSpeed=KDefaultBearerSpeed; |
|
476 } |
|
477 |
|
478 iTimer=CSimTimer::NewL(iLine->iPhone); |
|
479 iNtRas=CSimNtRas::NewL(iLine->iPhone); |
|
480 CSimCall::ConstructL(); |
|
481 |
|
482 //If present read in remote party info tag |
|
483 TPtrC8 callingname, remotenumber; |
|
484 TInt delay=0; |
|
485 |
|
486 item=iLine->CfgFile()->Item(KNotifyRemotePartyInfo); |
|
487 |
|
488 TInt ret; |
|
489 |
|
490 if (item) |
|
491 { |
|
492 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,delay); |
|
493 if(ret!=KErrNone) |
|
494 { |
|
495 LOGPARSERR("delay",ret,0,&KNotifyRemotePartyInfo); |
|
496 } |
|
497 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,callingname); |
|
498 if(ret!=KErrNone) |
|
499 { |
|
500 LOGPARSERR("callingname",ret,1,&KNotifyRemotePartyInfo); |
|
501 } |
|
502 ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,remotenumber); |
|
503 if(ret!=KErrNone) |
|
504 { |
|
505 LOGPARSERR("remotenumber",ret,2,&KNotifyRemotePartyInfo); |
|
506 } |
|
507 |
|
508 iNotifyRemotePartyInfoTimer->iDelay = delay; |
|
509 iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iDirection = RMobileCall::EDirectionUnknown; |
|
510 iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iCallingName.Copy(callingname); |
|
511 iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iRemoteNumber.iTelNumber.Copy(remotenumber); |
|
512 iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iRemoteNumber.iTypeOfNumber = RMobilePhone::EInternationalNumber; |
|
513 iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iRemoteNumber.iNumberPlan = RMobilePhone::EIsdnNumberPlan; |
|
514 iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable; |
|
515 } |
|
516 else |
|
517 { |
|
518 iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iRemoteIdStatus = RMobileCall::ERemoteIdentityUnknown; |
|
519 } |
|
520 |
|
521 LOGDATA1("...Finished parsing Data Call config parameters..."); |
|
522 } |
|
523 |
|
524 CSimDataCall::~CSimDataCall() |
|
525 /** |
|
526 * Destroy all the objects constructed. |
|
527 * CSimTimer and CSimSysAgent objects are destroyed here |
|
528 */ |
|
529 { |
|
530 delete iNtRas; |
|
531 delete iTimer; |
|
532 if(iAnswerIncomingCall.iNotifyPending) |
|
533 iLine->ResetAutoAnswerCallObject(this); |
|
534 if(iMobileCallRLPList) |
|
535 { |
|
536 iMobileCallRLPList->Delete(0,iMobileCallRLPList->Count()); |
|
537 delete iMobileCallRLPList; |
|
538 } |
|
539 } |
|
540 |
|
541 TInt CSimDataCall::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,const TDataPackage& aPackage) |
|
542 /** |
|
543 * ExtFunc is called by the server when it has a "extended", i.e. non-core ETel request |
|
544 * for the TSY to process |
|
545 * A request handle, request type and request data are passed to the TSY |
|
546 * |
|
547 * @param aTsyReqHandle |
|
548 * @param aIpc IPc number representing the request |
|
549 * @param aPackage data for the request |
|
550 * @return KErrNone |
|
551 */ |
|
552 { |
|
553 TAny* dataPtr=aPackage.Ptr1(); |
|
554 TAny* dataPtr2=aPackage.Ptr2(); |
|
555 |
|
556 LOGDATA2("CSimDataCall::ExtFunc: IPC Number is %d",aIpc); |
|
557 // The request data has to extracted from TDataPackage and the TAny* pointers have to |
|
558 // be "cast" to the expected request data type |
|
559 |
|
560 switch (aIpc) |
|
561 { |
|
562 // |
|
563 // No Flow Control NOR Multiple Completion |
|
564 // |
|
565 case EMobileCallGetMobileCallCaps: |
|
566 return GetMobileCallCaps(aTsyReqHandle,aPackage.Des1n()); |
|
567 |
|
568 case EMobileCallGetMobileDataCallCaps: |
|
569 return GetMobileDataCallCaps(aTsyReqHandle,aPackage.Des1n()); |
|
570 |
|
571 case EMobileCallGetMobileDataCallRLPRange: |
|
572 return GetMobileDataCallRLPRange(aTsyReqHandle, |
|
573 REINTERPRET_CAST(TInt*,dataPtr), |
|
574 REINTERPRET_CAST(TDes8*,dataPtr2)); |
|
575 |
|
576 case EMobileCallSetDynamicHscsdParams: |
|
577 return SetDynamicHSCSDParams(aTsyReqHandle, |
|
578 REINTERPRET_CAST(RMobileCall::TMobileCallAiur*,dataPtr), |
|
579 REINTERPRET_CAST(TInt*,dataPtr2)); |
|
580 |
|
581 case EMobileCallGetCurrentHscsdInfo: |
|
582 return GetCurrentHSCSDInfo(aTsyReqHandle, aPackage.Des1n()); |
|
583 |
|
584 case EMobileCallGetMobileCallStatus: |
|
585 return GetMobileCallStatus(aTsyReqHandle, |
|
586 REINTERPRET_CAST(RMobileCall::TMobileCallStatus*,dataPtr)); |
|
587 |
|
588 case EMobileCallGetMobileCallInfo: |
|
589 return GetMobileCallInfo(aTsyReqHandle,aPackage.Des1n()); |
|
590 |
|
591 // |
|
592 // Multiple Completion Services with Immediate Server Repost |
|
593 // (Usually Notifications) |
|
594 // |
|
595 case EMobileCallNotifyMobileCallStatusChange: |
|
596 return NotifyMobileCallStatusChange(aTsyReqHandle, |
|
597 REINTERPRET_CAST(RMobileCall::TMobileCallStatus*, dataPtr)); |
|
598 |
|
599 case EMobileCallNotifyMobileCallCapsChange: |
|
600 return NotifyMobileCallCapsChange(aTsyReqHandle, aPackage.Des1n()); |
|
601 |
|
602 case EMobileCallNotifyMobileDataCallCapsChange: |
|
603 return NotifyMobileDataCapsChange(aTsyReqHandle, aPackage.Des1n()); |
|
604 |
|
605 case EMobileCallNotifyHscsdInfoChange: |
|
606 return NotifyHSCSDInfoChange(aTsyReqHandle, aPackage.Des1n()); |
|
607 |
|
608 case EMobileCallNotifyRemotePartyInfoChange: |
|
609 return NotifyRemotePartyInfoChange(aTsyReqHandle, aPackage.Des1n()); |
|
610 |
|
611 default: |
|
612 LOGDATA2("CSimDataCall::ExtFunc: Unsupported IPC detected - number %d",aIpc); |
|
613 break; |
|
614 } |
|
615 |
|
616 return KErrNotSupported; |
|
617 } |
|
618 |
|
619 TInt CSimDataCall::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle) |
|
620 /** |
|
621 * Cancel an outstanding request. |
|
622 * @param aIpc The IPC number of the request that must be cancelled. Note: this is not the |
|
623 * IPC number of the cancel request itself. |
|
624 * @param aTsyReqHandle The TSY Request Handle of the request to be cancelled. |
|
625 */ |
|
626 { |
|
627 switch(aIpc) |
|
628 { |
|
629 case EMobileCallNotifyMobileCallStatusChange: |
|
630 return NotifyMobileCallStatusChangeCancel(aTsyReqHandle); |
|
631 |
|
632 case EMobileCallNotifyMobileCallCapsChange: |
|
633 return NotifyMobileCallCapsChangeCancel(aTsyReqHandle); |
|
634 |
|
635 case EMobileCallNotifyMobileDataCallCapsChange: |
|
636 return NotifyMobileDataCapsChangeCancel(aTsyReqHandle); |
|
637 |
|
638 case EMobileCallSetDynamicHscsdParams: |
|
639 return SetDynamicHSCSDParamsCancel(aTsyReqHandle); |
|
640 |
|
641 case EMobileCallGetMobileDataCallCaps: |
|
642 return GetMobileDataCallCapsCancel(aTsyReqHandle); |
|
643 |
|
644 case EMobileCallGetMobileDataCallRLPRange: |
|
645 return GetMobileDataCallRLPRangeCancel(aTsyReqHandle); |
|
646 |
|
647 case EMobileCallNotifyHscsdInfoChange: |
|
648 return NotifyHSCSDInfoChangeCancel(aTsyReqHandle); |
|
649 |
|
650 case EMobileCallNotifyRemotePartyInfoChange: |
|
651 return NotifyRemotePartyInfoChangeCancel(); |
|
652 |
|
653 default: |
|
654 LOGDATA1("CSimDataCall::CancelService: No match for IPC, defering to base function"); |
|
655 break; |
|
656 } |
|
657 return CCallBase::CancelService(aIpc,aTsyReqHandle); |
|
658 } |
|
659 |
|
660 TInt CSimDataCall::Dial(const TTsyReqHandle aTsyReqHandle,const TDesC8* aCallParams,TDesC* /*aTelNumber*/) |
|
661 /** |
|
662 * Process a client's dial request. |
|
663 * |
|
664 * @param aTsyReqHandle |
|
665 * @param aCallParams the call parameters |
|
666 * @param aTelNumber The telephone number to dial |
|
667 * @return KErrNone |
|
668 */ |
|
669 { |
|
670 LOGDATA1(">>CSimDataCall::Dial"); |
|
671 iDialRequestHandle=aTsyReqHandle; |
|
672 PopulateCallParams(aCallParams); |
|
673 |
|
674 TInt err=ActionEvent(ECallEventDial,KErrNone); |
|
675 if(err!=KErrNone) |
|
676 ReqCompleted(aTsyReqHandle,err); |
|
677 |
|
678 LOGDATA1("<<CSimDataCall::Dial"); |
|
679 return KErrNone; |
|
680 } |
|
681 |
|
682 TInt CSimDataCall::DialCancel(const TTsyReqHandle /*aTsyReqHandle*/) |
|
683 /** |
|
684 * Cancels a dial Request |
|
685 * |
|
686 * @param aTsyReqHandle |
|
687 * @return KErrNone if successfully cancelled |
|
688 */ |
|
689 { |
|
690 LOGDATA1(">>CSimDataCall::DialCancel"); |
|
691 switch(iState) |
|
692 { |
|
693 case RMobileCall::EStatusIdle: |
|
694 case RMobileCall::EStatusConnected: |
|
695 SimPanic(EIllegalCancelRequest); // A DialCancel should never reach the TSY in this state. |
|
696 break; |
|
697 |
|
698 case RMobileCall::EStatusDialling: |
|
699 case RMobileCall::EStatusConnecting: |
|
700 iTimer->Cancel(); |
|
701 |
|
702 TInt err; |
|
703 err = KErrNone; |
|
704 TRAP(err, ChangeStateL(RMobileCall::EStatusIdle,EFalse,EFalse)); |
|
705 if (err != KErrNone) |
|
706 { |
|
707 ReqCompleted(iDialRequestHandle, err); |
|
708 } |
|
709 else |
|
710 { |
|
711 ReqCompleted(iDialRequestHandle, KErrCancel); |
|
712 } |
|
713 break; |
|
714 |
|
715 default: |
|
716 LOGDATA2("CSimDataCall::DialCancel: No action taken - state: %d",iState); |
|
717 break; |
|
718 } |
|
719 LOGDATA1("<<CSimDataCall::DialCancel"); |
|
720 return KErrNone; |
|
721 } |
|
722 |
|
723 TInt CSimDataCall::AnswerIncomingCall(const TTsyReqHandle aTsyReqHandle,const TDesC8* aCallParams) |
|
724 /** |
|
725 * Register a client's interest in answering the next incoming call. |
|
726 * First register interest in incoming calls with the line, then, if a call |
|
727 * is already ringing, start the answer procedure. |
|
728 * |
|
729 * @param aTsyReqHandle |
|
730 * @param aCallParams the call parameters |
|
731 * @return KErrNone |
|
732 */ |
|
733 { |
|
734 LOGDATA1(">>CSimDataCall::AnswerIncomingCall"); |
|
735 TInt err=iLine->SetAutoAnswerCallObject(this); |
|
736 if(err!=KErrNone) |
|
737 { |
|
738 ReqCompleted(aTsyReqHandle,err); |
|
739 return KErrNone; |
|
740 } |
|
741 |
|
742 PopulateCallParams(aCallParams); |
|
743 iAnswerIncomingCall.iNotifyPending=ETrue; |
|
744 iAnswerIncomingCall.iNotifyHandle=aTsyReqHandle; |
|
745 |
|
746 TInt ret=KErrNone; |
|
747 if(iState==RMobileCall::EStatusRinging) |
|
748 ActionEvent(ECallEventAnswerIncoming,KErrNone); |
|
749 else if(iLine->iState==RMobileCall::EStatusRinging) |
|
750 { |
|
751 TRAP(ret,ret=ChangeStateL(RMobileCall::EStatusRinging,EFalse,EFalse)); |
|
752 if(ret == KErrNone) |
|
753 { |
|
754 ret = ActionEvent(ECallEventAnswerIncoming,KErrNone); |
|
755 } |
|
756 } |
|
757 LOGDATA1("<<CSimDataCall::AnswerIncomingCall"); |
|
758 return ret; |
|
759 } |
|
760 |
|
761 TInt CSimDataCall::AnswerIncomingCallCancel(const TTsyReqHandle /*aTsyReqHandle*/) |
|
762 /** |
|
763 * Cancels a AnswerIncomingCall Request |
|
764 * |
|
765 * @param aTsyReqHandle |
|
766 * @return KErrNone if successfully cancelled |
|
767 */ |
|
768 { |
|
769 LOGDATA1(">>CSimDataCall::AnswerIncomingCallCancel"); |
|
770 if(iAnswerIncomingCall.iNotifyPending) |
|
771 { |
|
772 iAnswerIncomingCall.iNotifyPending=EFalse; |
|
773 iLine->ResetAutoAnswerCallObject(this); |
|
774 ReqCompleted(iAnswerIncomingCall.iNotifyHandle,KErrCancel); |
|
775 } |
|
776 LOGDATA1("<<CSimDataCall::AnswerIncomingCallCancel"); |
|
777 return KErrNone; |
|
778 } |
|
779 |
|
780 TInt CSimDataCall::Connect(const TTsyReqHandle aTsyReqHandle,const TDesC8* /*aCallParams*/) |
|
781 { |
|
782 ReqCompleted(aTsyReqHandle,KErrNotSupported); |
|
783 return KErrNone; |
|
784 } |
|
785 |
|
786 TInt CSimDataCall::ConnectCancel(const TTsyReqHandle aTsyReqHandle) |
|
787 { |
|
788 ReqCompleted(aTsyReqHandle,KErrNotSupported); |
|
789 return KErrNone; |
|
790 } |
|
791 |
|
792 TInt CSimDataCall::HangUp(const TTsyReqHandle aTsyReqHandle) |
|
793 /** |
|
794 * Process a client's HangUp request. |
|
795 * |
|
796 * @param aTsyReqHandle |
|
797 * @return KErrNone |
|
798 */ |
|
799 { |
|
800 LOGDATA1(">>CSimDataCall::HangUp"); |
|
801 iHangUpRequestHandle=aTsyReqHandle; |
|
802 TInt err=ActionEvent(ECallEventHangUp,KErrNone); |
|
803 if(err!=KErrNone) |
|
804 ReqCompleted(aTsyReqHandle,err); |
|
805 LOGDATA1("<<CSimDataCall::HangUp"); |
|
806 return KErrNone; |
|
807 } |
|
808 |
|
809 TInt CSimDataCall::HangUpCancel(const TTsyReqHandle /*aTsyReqHandle*/) |
|
810 /** |
|
811 * Cancels a HangUp Request |
|
812 * |
|
813 * @param aTsyReqHandle |
|
814 * @return KErrNone if successfully cancelled |
|
815 */ |
|
816 { |
|
817 LOGDATA1(">>CSimDataCall::HangUpCancel"); |
|
818 switch(iState) |
|
819 { |
|
820 case RMobileCall::EStatusIdle: |
|
821 SimPanic(EIllegalCancelRequest); // A DialCancel should never reach the TSY in this state. |
|
822 break; |
|
823 |
|
824 case RMobileCall::EStatusDisconnecting: |
|
825 iTimer->Cancel(); |
|
826 |
|
827 TInt err; |
|
828 err = KErrNone; |
|
829 TRAP(err, ChangeStateL(RMobileCall::EStatusIdle,EFalse,EFalse)); |
|
830 if (err != KErrNone) |
|
831 { |
|
832 ReqCompleted(iHangUpRequestHandle, err); |
|
833 } |
|
834 else |
|
835 { |
|
836 ReqCompleted(iHangUpRequestHandle, KErrCancel); |
|
837 } |
|
838 break; |
|
839 |
|
840 default: |
|
841 LOGDATA2("CSimDataCall::HangUpCancel: No action taken - state: %d",iState); |
|
842 break; |
|
843 } |
|
844 LOGDATA1("<<CSimDataCall::HangUpCancel"); |
|
845 return KErrNone; |
|
846 } |
|
847 |
|
848 TInt CSimDataCall::RelinquishOwnership() |
|
849 { |
|
850 return KErrNotSupported; |
|
851 } |
|
852 |
|
853 TInt CSimDataCall::GetBearerServiceInfo(const TTsyReqHandle aTsyReqHandle,RCall::TBearerService* aBearerService) |
|
854 /** |
|
855 * Retrieves the bearer service info. Bearer service information is only valid |
|
856 * when the call is active. |
|
857 */ |
|
858 { |
|
859 if(iState!=RMobileCall::EStatusConnected) |
|
860 { |
|
861 ReqCompleted(aTsyReqHandle,KErrEtelCallNotActive); |
|
862 return KErrNone; |
|
863 } |
|
864 |
|
865 *aBearerService=iBearerService; |
|
866 ReqCompleted(aTsyReqHandle,KErrNone); |
|
867 return KErrNone; |
|
868 } |
|
869 |
|
870 TInt CSimDataCall::GetCallParams(const TTsyReqHandle aTsyReqHandle, TDes8* aCallParams) |
|
871 /** |
|
872 * Retrives the call parameters. This function must handle both core and Multimode |
|
873 * extension versions of the function. Call parameter information is only valid |
|
874 * when the call is active. |
|
875 */ |
|
876 { |
|
877 if(iState!=RMobileCall::EStatusConnected) |
|
878 { |
|
879 ReqCompleted(aTsyReqHandle,KErrEtelCallNotActive); |
|
880 return KErrNone; |
|
881 } |
|
882 |
|
883 TPckg<RCall::TCallParams>* callParamPckg=(TPckg<RCall::TCallParams>*)aCallParams; |
|
884 RCall::TCallParams& callParam=(*callParamPckg)(); |
|
885 |
|
886 if(callParam.ExtensionId()==RMobileCall::KETelMobileDataCallParamsV1) |
|
887 { |
|
888 // If the passed package is MobileParams, then we can just unpackage and copy. |
|
889 RMobileCall::TMobileDataCallParamsV1Pckg* mobileCallParamPckg=(RMobileCall::TMobileDataCallParamsV1Pckg*)aCallParams; |
|
890 RMobileCall::TMobileDataCallParamsV1& mobileCallParam=(*mobileCallParamPckg)(); |
|
891 |
|
892 // Check that the data structure is supported by the simulated TSY version |
|
893 TInt err = iPhone->CheckSimTsyVersion(mobileCallParam); |
|
894 if(err != KErrNone) |
|
895 { |
|
896 ReqCompleted(aTsyReqHandle, err); |
|
897 return KErrNone; |
|
898 } |
|
899 |
|
900 mobileCallParam=iMobileCallParams; |
|
901 } |
|
902 |
|
903 else if(callParam.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV1) |
|
904 { |
|
905 TPckg<RMobileCall::TMobileHscsdCallParamsV1>* mobileCallParamPckg=(TPckg<RMobileCall::TMobileHscsdCallParamsV1>*)aCallParams; |
|
906 RMobileCall::TMobileHscsdCallParamsV1& mobileCallParam=(*mobileCallParamPckg)(); |
|
907 |
|
908 // Check that the data structure is supported by the simulated TSY version |
|
909 TInt err = iPhone->CheckSimTsyVersion(mobileCallParam); |
|
910 if(err != KErrNone) |
|
911 { |
|
912 ReqCompleted(aTsyReqHandle, err); |
|
913 return KErrNone; |
|
914 } |
|
915 |
|
916 mobileCallParam=iHscsdSettings; |
|
917 } |
|
918 else |
|
919 { |
|
920 // If, however, its a core (or an unrecognised extension), we must only copy the |
|
921 // core parameters. |
|
922 callParam.iSpeakerControl=iMobileCallParams.iSpeakerControl; |
|
923 callParam.iSpeakerVolume=iMobileCallParams.iSpeakerVolume; |
|
924 callParam.iInterval=iMobileCallParams.iInterval; |
|
925 callParam.iWaitForDialTone=iMobileCallParams.iWaitForDialTone; |
|
926 } |
|
927 |
|
928 ReqCompleted(aTsyReqHandle,KErrNone); |
|
929 return KErrNone; |
|
930 } |
|
931 |
|
932 TInt CSimDataCall::LoanDataPort(const TTsyReqHandle aReqHandle,RCall::TCommPort* aCommPort) |
|
933 /** |
|
934 * Loans the comm port to a client for subsequent streaming of data. |
|
935 * For the comm port to be loaned the call must be active and the port unloaned. |
|
936 */ |
|
937 { |
|
938 if(iState!=RMobileCall::EStatusConnected) |
|
939 { |
|
940 ReqCompleted(aReqHandle,KErrEtelCallNotActive); |
|
941 return KErrNone; |
|
942 } |
|
943 |
|
944 if(iCommPortLoaned) |
|
945 { |
|
946 ReqCompleted(aReqHandle,KErrEtelPortAlreadyLoaned); |
|
947 return KErrNone; |
|
948 } |
|
949 |
|
950 aCommPort->iCsy.Copy(iCsyName); |
|
951 aCommPort->iPort.Copy(iPortName); |
|
952 iCommPortLoaned=ETrue; |
|
953 ReqCompleted(aReqHandle,KErrNone); |
|
954 return KErrNone; |
|
955 } |
|
956 |
|
957 TInt CSimDataCall::LoanDataPortCancel(const TTsyReqHandle) |
|
958 /** |
|
959 * Cancels the LoanDataPort request. |
|
960 * The LoanDataPort function completes synchronously, so there is nothing to cancel. |
|
961 */ |
|
962 { |
|
963 return KErrNone; |
|
964 } |
|
965 |
|
966 TInt CSimDataCall::RecoverDataPort(const TTsyReqHandle aReqHandle) |
|
967 /** |
|
968 * Recovers the comm port. |
|
969 * The comm port must be loaned in order to recover it. |
|
970 */ |
|
971 { |
|
972 if(!iCommPortLoaned) |
|
973 { |
|
974 ReqCompleted(aReqHandle,KErrEtelPortNotLoanedToClient); |
|
975 return KErrNone; |
|
976 } |
|
977 |
|
978 iNtRas->Terminate(); |
|
979 iCommPortLoaned=EFalse; |
|
980 ReqCompleted(aReqHandle,KErrNone); |
|
981 return KErrNone; |
|
982 } |
|
983 |
|
984 TInt CSimDataCall::ActionEvent(TCallEvent aEvent,TInt aStatus) |
|
985 /** |
|
986 * Entry point when an event has occured that may advance the state machine. |
|
987 * The aEvent parameter describes the event. |
|
988 * |
|
989 * This function contains the main state machine for the data call. The outer layer |
|
990 * switches on the event type. Where appropriate, there are inner layer switches |
|
991 * or conditional statements to handle the different responses that may be required to |
|
992 * the same event occurring in different states. |
|
993 * |
|
994 * @param aEvent The Call event to handle |
|
995 * @return value represents the error state caused by the attempted state machine jump. |
|
996 */ |
|
997 { |
|
998 TInt ret=KErrNone; |
|
999 __ASSERT_ALWAYS(iState!=RMobileCall::EStatusUnknown,SimPanic(ECallStatusUnknownIllegal)); |
|
1000 |
|
1001 switch(aEvent) |
|
1002 { |
|
1003 case ECallEventDial: |
|
1004 LOGDATA1(">>CSimDataCall::ActionEvent = [ECallEventDial]"); |
|
1005 if(iState==RMobileCall::EStatusIdle) |
|
1006 { |
|
1007 TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusDialling,EFalse,EFalse)); |
|
1008 if(ret==KErrNone) |
|
1009 iTimer->Start(iDiallingPause,this); |
|
1010 } |
|
1011 else |
|
1012 return KErrEtelCallAlreadyActive; |
|
1013 break; |
|
1014 |
|
1015 case ECallEventHangUp: |
|
1016 { |
|
1017 LOGDATA1(">>CSimDataCall::ActionEvent = [ECallEventHangUp]"); |
|
1018 switch(iState) |
|
1019 { |
|
1020 case RMobileCall::EStatusConnected: |
|
1021 iCommPortLoaned=EFalse; |
|
1022 iNtRas->Terminate(); |
|
1023 // Note: No "break;" - fall through to the rest of the discconnecting code... |
|
1024 case RMobileCall::EStatusDialling: |
|
1025 case RMobileCall::EStatusRinging: |
|
1026 case RMobileCall::EStatusAnswering: |
|
1027 case RMobileCall::EStatusConnecting: |
|
1028 iTimer->Cancel(); |
|
1029 TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusDisconnecting,EFalse,EFalse)); |
|
1030 if(ret==KErrNone) |
|
1031 iTimer->Start(iDisconnectingPause,this); |
|
1032 break; |
|
1033 default: |
|
1034 return KErrEtelCallNotActive; |
|
1035 } |
|
1036 } |
|
1037 break; |
|
1038 |
|
1039 case ECallEventIncomingCall: |
|
1040 LOGDATA1(">>CSimDataCall::ActionEvent = [ECallEventIncomingCall]"); |
|
1041 if(iState==RMobileCall::EStatusIdle) |
|
1042 { |
|
1043 if(iAnswerIncomingCall.iNotifyPending) |
|
1044 { |
|
1045 TRAP(ret, ret=ProcessAnswerIncomingCallL()); |
|
1046 } |
|
1047 else |
|
1048 { |
|
1049 TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusRinging,EFalse,EFalse)); |
|
1050 if(ret!=KErrNone) |
|
1051 return ret; |
|
1052 } |
|
1053 } |
|
1054 else |
|
1055 return KErrEtelCallAlreadyActive; |
|
1056 break; |
|
1057 |
|
1058 case ECallEventAnswerIncoming: |
|
1059 LOGDATA1(">>CSimDataCall::ActionEvent = [ECallEventAnswerIncoming]"); |
|
1060 if(iState==RMobileCall::EStatusRinging) |
|
1061 { |
|
1062 TRAP(ret, ret=ProcessAnswerIncomingCallL()); |
|
1063 } |
|
1064 else |
|
1065 SimPanic(EIllegalStateInconsistancy); // The state is checked in AnswerIncomingCall, so there's been an inconsistancy if the state is out of line. |
|
1066 break; |
|
1067 |
|
1068 case ECallEventRemoteHangup: |
|
1069 LOGDATA1(">>CSimDataCall::ActionEvent = [ECallEventRemoteHangup]"); |
|
1070 if(iState==RMobileCall::EStatusConnected) |
|
1071 { |
|
1072 TRAP(ret, ret=ProcessRemoteHangupL()); |
|
1073 } |
|
1074 else |
|
1075 SimPanic(EIllegalStateInconsistancy); // The state is checked in RemoteHangup, so there's been an inconsistancy if the state is out of line. |
|
1076 break; |
|
1077 |
|
1078 case ECallEventTimeOut: |
|
1079 { |
|
1080 LOGDATA1(">>CSimVoiceCall::ActionEvent = [ECallEventTimeOut]"); |
|
1081 switch(iState) |
|
1082 { |
|
1083 case RMobileCall::EStatusDialling: |
|
1084 LOGDATA1(">>CSimDataCall::State = [EStatusDialling]"); |
|
1085 TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusConnecting,EFalse,EFalse)); |
|
1086 if(ret==KErrNone) |
|
1087 iTimer->Start(iConnectingPause,this); |
|
1088 return ret; |
|
1089 |
|
1090 case RMobileCall::EStatusConnecting: |
|
1091 LOGDATA1(">>CSimDataCall::State = [EStatusConnecting]"); |
|
1092 // If the config file has not spec'ed a CSY, then fail the dial... |
|
1093 if(iCsyName.Length()==0) |
|
1094 { |
|
1095 ReqCompleted(iDialRequestHandle,KErrEtelNoCarrier); |
|
1096 TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusIdle,EFalse,EFalse)); |
|
1097 |
|
1098 __ASSERT_ALWAYS(ret==KErrNone,SimPanic(EIllegalStateInconsistancy)); |
|
1099 return KErrNone; |
|
1100 } |
|
1101 ret=iNtRas->Connect(iCsyName,iPortName,iConfig,this); |
|
1102 if(ret!=KErrNone) |
|
1103 ReqCompleted(iDialRequestHandle,ret); |
|
1104 return ret; |
|
1105 |
|
1106 case RMobileCall::EStatusDisconnecting: |
|
1107 LOGDATA1(">>CSimDataCall::State = [EStatusDisconnecting]"); |
|
1108 TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusIdle,EFalse,EFalse)); |
|
1109 ReqCompleted(iHangUpRequestHandle,ret); |
|
1110 return ret; |
|
1111 |
|
1112 case RMobileCall::EStatusAnswering: |
|
1113 LOGDATA1(">>CSimDataCall::State = [EStatusAnswering]"); |
|
1114 TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusConnected,EFalse,EFalse)); |
|
1115 ReqCompleted(iAnswerIncomingCall.iNotifyHandle,ret); |
|
1116 return ret; |
|
1117 |
|
1118 default: |
|
1119 LOGDATA2(">>CSimDataCall::State = [%d]",iState); |
|
1120 break; |
|
1121 } |
|
1122 } |
|
1123 break; |
|
1124 |
|
1125 case ECallEventNtRasConnected: |
|
1126 if(aStatus!=KErrNone) |
|
1127 { |
|
1128 ReqCompleted(iDialRequestHandle,aStatus); |
|
1129 TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusIdle,EFalse,EFalse)); |
|
1130 __ASSERT_ALWAYS(ret==KErrNone,SimPanic(EIllegalStateInconsistancy)); |
|
1131 return KErrNone; |
|
1132 } |
|
1133 else |
|
1134 { |
|
1135 TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusConnected,EFalse,EFalse)); |
|
1136 ChangeDynamicInfo(); |
|
1137 ReqCompleted(iDialRequestHandle,ret); |
|
1138 return KErrNone; |
|
1139 } |
|
1140 default: |
|
1141 SimPanic(EIllegalStateInconsistancy); |
|
1142 break; |
|
1143 } |
|
1144 |
|
1145 return ret; |
|
1146 } |
|
1147 |
|
1148 |
|
1149 void CSimDataCall::TimerCallBack(TInt /*aId*/) |
|
1150 /** |
|
1151 * Timer callback function. When the timer goes off, it will call back into this |
|
1152 * function for further processing. |
|
1153 */ |
|
1154 { |
|
1155 LOGDATA1(">>CSimDataCall::TimerCallBack"); |
|
1156 TInt err=ActionEvent(ECallEventTimeOut,KErrNone); |
|
1157 __ASSERT_ALWAYS(err==KErrNone,SimPanic(ETimeOutEventActionFailed)); |
|
1158 LOGDATA1("<<CSimDataCall::TimerCallBack"); |
|
1159 } |
|
1160 |
|
1161 TInt CSimDataCall::ProcessAnswerIncomingCallL() |
|
1162 /** |
|
1163 * Answers an Incoming Call. |
|
1164 * First the call state must be changed to "answering", then the flag indicating |
|
1165 * that an answer incoming call request is no longer pending. Finally, a new |
|
1166 * call object must be assigned to receive the details of the next incoming call. |
|
1167 */ |
|
1168 { |
|
1169 LOGDATA1(">>CSimDataCall::ProcessAnswerIncomingCall"); |
|
1170 TInt ret=ChangeStateL(RMobileCall::EStatusAnswering,EFalse,EFalse); |
|
1171 if(ret!=KErrNone) |
|
1172 return ret; |
|
1173 iTimer->Start(iAnswerIncomingPause,this); |
|
1174 iAnswerIncomingCall.iNotifyPending=EFalse; |
|
1175 iLine->ResetAutoAnswerCallObject(this); |
|
1176 LOGDATA1("<<CSimDataCall::ProcessAnswerIncomingCall"); |
|
1177 return ret; |
|
1178 } |
|
1179 |
|
1180 TInt CSimDataCall::ProcessRemoteHangupL() |
|
1181 /** |
|
1182 * Hangs up a call from the remote end. |
|
1183 * First the call state must be changed to "disconnecting", then the flag indicating |
|
1184 * that a remote hangup request is no longer pending. Finally, a new |
|
1185 * call object must be assigned to be the next remotely hung up call. |
|
1186 */ |
|
1187 { |
|
1188 LOGDATA1(">>CSimDataCall::ProcessRemoteHangupL"); |
|
1189 TInt ret=ChangeStateL(RMobileCall::EStatusDisconnecting,EFalse,EFalse); |
|
1190 if(ret!=KErrNone) |
|
1191 return ret; |
|
1192 iTimer->Start(iRemoteHangupPause,this); |
|
1193 iLine->ResetRemoteHangupCallObject(this); |
|
1194 LOGDATA1("<<CSimDataCall::ProcessRemoteHangupL"); |
|
1195 return ret; |
|
1196 } |
|
1197 |
|
1198 |
|
1199 void CSimDataCall::PopulateCallParams(const TDesC8* aCallParams) |
|
1200 /** |
|
1201 * This function populates the call parameter member variable iMobileCallParams. |
|
1202 * The function must handle core and multimode extension call parameters. |
|
1203 * @param aCallParams A pointer to the call parameter variable. |
|
1204 */ |
|
1205 { |
|
1206 TPckg<RCall::TCallParams>* callParamPckg=(TPckg<RCall::TCallParams>*)aCallParams; |
|
1207 RCall::TCallParams& callParam=(*callParamPckg)(); |
|
1208 |
|
1209 if(callParam.ExtensionId()==RMobileCall::KETelMobileDataCallParamsV1) |
|
1210 { |
|
1211 // If the passed package is MobileParams, then we can just unpackage and copy. |
|
1212 RMobileCall::TMobileDataCallParamsV1Pckg* mobileCallParamPckg=(RMobileCall::TMobileDataCallParamsV1Pckg*)aCallParams; |
|
1213 RMobileCall::TMobileDataCallParamsV1& mobileCallParam=(*mobileCallParamPckg)(); |
|
1214 |
|
1215 iHscsdCall=EFalse; |
|
1216 iMobileCallParams=mobileCallParam; |
|
1217 } |
|
1218 else if(callParam.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV1) |
|
1219 { |
|
1220 TPckg<RMobileCall::TMobileHscsdCallParamsV1>* mobileCallParamPckg=(TPckg<RMobileCall::TMobileHscsdCallParamsV1>*)aCallParams; |
|
1221 RMobileCall::TMobileHscsdCallParamsV1& mobileCallParam=(*mobileCallParamPckg)(); |
|
1222 |
|
1223 iHscsdCall=ETrue; |
|
1224 iHscsdSettings=mobileCallParam; |
|
1225 } |
|
1226 else |
|
1227 { |
|
1228 // If, however, its core (or an unrecognised extension), we must first reset the member |
|
1229 // member variable before copying just the core parameters. |
|
1230 RMobileCall::TMobileDataCallParamsV1 mobileCallParam; |
|
1231 |
|
1232 iMobileCallParams=mobileCallParam; |
|
1233 iHscsdCall=EFalse; |
|
1234 iMobileCallParams.iSpeakerControl=callParam.iSpeakerControl; |
|
1235 iMobileCallParams.iSpeakerVolume=callParam.iSpeakerVolume; |
|
1236 iMobileCallParams.iInterval=callParam.iInterval; |
|
1237 iMobileCallParams.iWaitForDialTone=callParam.iWaitForDialTone; |
|
1238 } |
|
1239 } |
|
1240 |
|
1241 void CSimDataCall::NTRasCallBack(TInt aStatus) |
|
1242 /** |
|
1243 * NTRas callback function. This function will be called when the NTRAS |
|
1244 * Server has responded. |
|
1245 * @param aStatus Standard error value, indicating the success or failure of the NTRAS |
|
1246 * connection. |
|
1247 */ |
|
1248 { |
|
1249 TInt err=ActionEvent(ECallEventNtRasConnected,aStatus); |
|
1250 __ASSERT_ALWAYS(err==KErrNone,SimPanic(EIllegalStateInconsistancy)); |
|
1251 } |
|
1252 |
|
1253 TUint CSimDataCall::Caps() |
|
1254 /** |
|
1255 * Return the current capabilities of this call. |
|
1256 * @return TUint Current call capabilities. |
|
1257 */ |
|
1258 { |
|
1259 TUint caps=RCall::KCapsData; |
|
1260 GenerateCoreCallCaps(caps); |
|
1261 if(iState==RMobileCall::EStatusConnected) |
|
1262 { |
|
1263 if(iCommPortLoaned) |
|
1264 caps|=RCall::KCapsRecoverDataPort; |
|
1265 else |
|
1266 caps|=RCall::KCapsLoanDataPort; |
|
1267 } |
|
1268 return caps; |
|
1269 } |
|
1270 |
|
1271 TInt CSimDataCall::GetMobileDataCallCaps(const TTsyReqHandle aTsyReqHandle, TDes8* aCaps) |
|
1272 /** |
|
1273 * |
|
1274 * @param aTsyReqHandle specifies the request handle. |
|
1275 * @param aCaps is used to return the retrieved capabilities to the client. |
|
1276 * @return value returns the result of this operation |
|
1277 */ |
|
1278 { |
|
1279 TPckg<RMobileCall::TMobileCallDataCapsV1>* mobileCallCapsPckg=(TPckg<RMobileCall::TMobileCallDataCapsV1>*)aCaps; |
|
1280 RMobileCall::TMobileCallDataCapsV1& mobileCallCaps=(*mobileCallCapsPckg)(); |
|
1281 |
|
1282 // Check that the data structure is supported by the simulated TSY version |
|
1283 TInt err = iPhone->CheckSimTsyVersion(mobileCallCaps); |
|
1284 if(err != KErrNone) |
|
1285 { |
|
1286 ReqCompleted(aTsyReqHandle, err); |
|
1287 return KErrNone; |
|
1288 } |
|
1289 |
|
1290 if(mobileCallCaps.ExtensionId()==KETelExtMultimodeV1) |
|
1291 { |
|
1292 mobileCallCaps=iMobileCallCaps; |
|
1293 ReqCompleted(aTsyReqHandle,KErrNone); |
|
1294 return KErrNone; |
|
1295 } |
|
1296 else |
|
1297 { |
|
1298 ReqCompleted(aTsyReqHandle,KErrNotFound); |
|
1299 return KErrNotFound; |
|
1300 } |
|
1301 } |
|
1302 |
|
1303 TInt CSimDataCall::GetMobileDataCallCapsCancel(const TTsyReqHandle aTsyReqHandle) |
|
1304 /** |
|
1305 * |
|
1306 * @param aTsyReqHandle specifies the request handle to be canceled |
|
1307 * @return value returns the result of this operation |
|
1308 */ |
|
1309 { |
|
1310 ReqCompleted(aTsyReqHandle,KErrNone); |
|
1311 return KErrNone; |
|
1312 } |
|
1313 |
|
1314 TInt CSimDataCall::SetDynamicHSCSDParams(const TTsyReqHandle aTsyReqHandle, RMobileCall::TMobileCallAiur* aAiur, TInt* aRxTimeslots) |
|
1315 /** |
|
1316 * |
|
1317 * @param aTsyReqHandle specifies the request handle. |
|
1318 * @param aAiur is used to dynamically change Aiur for this call |
|
1319 * @param aRxTimeslots is used to dynamically change RxTimeslots for this call |
|
1320 * @return value returns the result of this operation |
|
1321 */ |
|
1322 { |
|
1323 iHscsdInfo.iRxTimeSlots=*aRxTimeslots; |
|
1324 iHscsdInfo.iAiur=*aAiur; |
|
1325 iHscsdSettings.iWantedRxTimeSlots=*aRxTimeslots; |
|
1326 iHscsdSettings.iWantedAiur=*aAiur; |
|
1327 |
|
1328 if(iNotifyInfo.iNotifyPending) |
|
1329 { |
|
1330 *(RMobileCall::TMobileCallHscsdInfoV1*)iNotifyInfo.iNotifyData=iHscsdInfo; |
|
1331 iNotifyInfo.iNotifyPending=EFalse; |
|
1332 ReqCompleted(iNotifyInfo.iNotifyHandle,KErrNone); |
|
1333 } |
|
1334 ReqCompleted(aTsyReqHandle,KErrNone); |
|
1335 return KErrNone; |
|
1336 } |
|
1337 |
|
1338 TInt CSimDataCall::SetDynamicHSCSDParamsCancel(const TTsyReqHandle aTsyReqHandle) |
|
1339 /** |
|
1340 * |
|
1341 * @param aTsyReqHandle specifies the request handle to be canceled |
|
1342 * @return value returns the result of this operation |
|
1343 */ |
|
1344 { |
|
1345 ReqCompleted(aTsyReqHandle,KErrNone); |
|
1346 return KErrNone; |
|
1347 } |
|
1348 |
|
1349 TInt CSimDataCall::GetCurrentHSCSDInfo(const TTsyReqHandle aTsyReqHandle, TDes8* aInfo) |
|
1350 /** |
|
1351 * |
|
1352 * @param aTsyReqHandle specifies the request handle. |
|
1353 * @param aInfo is used to return the current Hscsd information to the client |
|
1354 * @return value returns the result of this operation |
|
1355 */ |
|
1356 { |
|
1357 TPckg<RMobileCall::TMobileCallHscsdInfoV1>* hscsdInfoPckg=(TPckg<RMobileCall::TMobileCallHscsdInfoV1>*)aInfo; |
|
1358 RMobileCall::TMobileCallHscsdInfoV1& hscsdInfo=(*hscsdInfoPckg)(); |
|
1359 |
|
1360 // Check that the data structure is supported by the simulated TSY version |
|
1361 TInt err = iPhone->CheckSimTsyVersion(hscsdInfo); |
|
1362 if(err != KErrNone) |
|
1363 { |
|
1364 ReqCompleted(aTsyReqHandle, err); |
|
1365 return KErrNone; |
|
1366 } |
|
1367 |
|
1368 if(hscsdInfo.ExtensionId()==KETelExtMultimodeV1) |
|
1369 { |
|
1370 hscsdInfo=iHscsdInfo; |
|
1371 ReqCompleted(aTsyReqHandle,KErrNone); |
|
1372 return KErrNone; |
|
1373 } |
|
1374 else |
|
1375 { |
|
1376 ReqCompleted(aTsyReqHandle,KErrNotFound); |
|
1377 return KErrNotFound; |
|
1378 } |
|
1379 } |
|
1380 |
|
1381 TInt CSimDataCall::NotifyHSCSDInfoChange(const TTsyReqHandle aTsyReqHandle, TDes8* aHSCSDInfo) |
|
1382 /** |
|
1383 * |
|
1384 * @param aTsyReqHandle specifies the request handle. |
|
1385 * @param aInfo is used to return the current Hscsd information when the notification completes |
|
1386 * @return value returns the result of this operation |
|
1387 */ |
|
1388 { |
|
1389 __ASSERT_ALWAYS(!iNotifyInfo.iNotifyPending,SimPanic(ENotificationAlreadyPending)); |
|
1390 |
|
1391 iNotifyInfo.iNotifyPending = ETrue; |
|
1392 iNotifyInfo.iNotifyHandle = aTsyReqHandle; |
|
1393 |
|
1394 TPckg<RMobileCall::TMobileCallHscsdInfoV1>* hscsdInfo = (TPckg<RMobileCall::TMobileCallHscsdInfoV1>*)aHSCSDInfo; |
|
1395 RMobileCall::TMobileCallHscsdInfoV1& hscsdInfoV1 = (*hscsdInfo)(); |
|
1396 |
|
1397 // Check that the data structure is supported by the simulated TSY version |
|
1398 TInt err = iPhone->CheckSimTsyVersion(hscsdInfoV1); |
|
1399 if(err != KErrNone) |
|
1400 { |
|
1401 ReqCompleted(aTsyReqHandle, err); |
|
1402 return KErrNone; |
|
1403 } |
|
1404 |
|
1405 iNotifyInfo.iNotifyData = &hscsdInfoV1; |
|
1406 return KErrNone; |
|
1407 } |
|
1408 |
|
1409 TInt CSimDataCall::NotifyHSCSDInfoChangeCancel(const TTsyReqHandle /*aTsyReqHandle*/) |
|
1410 /** |
|
1411 * |
|
1412 * @param aTsyReqHandle specifies the request handle to be canceled |
|
1413 * @return value returns the result of this operation |
|
1414 */ |
|
1415 { |
|
1416 if(iNotifyInfo.iNotifyPending) |
|
1417 { |
|
1418 iNotifyInfo.iNotifyPending=EFalse; |
|
1419 ReqCompleted(iNotifyInfo.iNotifyHandle,KErrCancel); |
|
1420 } |
|
1421 return KErrNone; |
|
1422 } |
|
1423 |
|
1424 TInt CSimDataCall::NotifyMobileDataCapsChange(const TTsyReqHandle aTsyReqHandle, TDes8* /*aCaps*/) |
|
1425 { |
|
1426 /** |
|
1427 * |
|
1428 * @param aTsyReqHandle specifies the request handle to be canceled |
|
1429 * @return value returns the result of this operation |
|
1430 */ |
|
1431 ReqCompleted(aTsyReqHandle,KErrNotSupported); |
|
1432 return KErrNotSupported; |
|
1433 } |
|
1434 |
|
1435 TInt CSimDataCall::NotifyMobileDataCapsChangeCancel(const TTsyReqHandle aTsyReqHandle) |
|
1436 /** |
|
1437 * |
|
1438 * @param aTsyReqHandle specifies the request handle to be canceled |
|
1439 * @return value returns the result of this operation |
|
1440 */ |
|
1441 { |
|
1442 ReqCompleted(aTsyReqHandle,KErrNone); |
|
1443 return KErrNone; |
|
1444 } |
|
1445 |
|
1446 TInt CSimDataCall::GetMobileDataCallRLPRange(const TTsyReqHandle aTsyReqHandle, TInt* aRLPVersion, TDes8* aRLPRange) |
|
1447 { |
|
1448 /** |
|
1449 * |
|
1450 * @param aTsyReqHandle specifies the request handle to be canceled |
|
1451 * @param aRLPVersion specifies the version for RLP range retrieval |
|
1452 * @param aRLPRange is used to return the requested RLP range to the client |
|
1453 * @return value returns the result of this operation |
|
1454 */ |
|
1455 TInt ret=SearchRetrieveRlp(aRLPVersion,aRLPRange); |
|
1456 |
|
1457 ReqCompleted(aTsyReqHandle,ret); |
|
1458 return ret; |
|
1459 } |
|
1460 |
|
1461 TInt CSimDataCall::GetMobileDataCallRLPRangeCancel(const TTsyReqHandle aTsyReqHandle) |
|
1462 /** |
|
1463 * |
|
1464 * @param aTsyReqHandle specifies the request handle to be canceled |
|
1465 * @return value returns the result of this operation |
|
1466 */ |
|
1467 { |
|
1468 ReqCompleted(aTsyReqHandle,KErrNone); |
|
1469 return KErrNone; |
|
1470 } |
|
1471 |
|
1472 void CSimDataCall::ChangeDynamicInfo() |
|
1473 /** |
|
1474 * |
|
1475 * Private function to alter the current Hscsd information |
|
1476 */ |
|
1477 { |
|
1478 if(iHscsdCall) |
|
1479 { |
|
1480 // Change to the requested settings |
|
1481 iHscsdInfo.iAiur=iHscsdSettings.iWantedAiur; |
|
1482 iHscsdInfo.iRxTimeSlots=iHscsdSettings.iWantedRxTimeSlots; |
|
1483 iHscsdInfo.iTxTimeSlots=iHscsdSettings.iMaxTimeSlots-iHscsdSettings.iWantedRxTimeSlots; |
|
1484 iHscsdInfo.iCodings=(RMobileCall::TMobileCallTchCoding) iHscsdSettings.iCodings; |
|
1485 // Complete a pending notification event for changes in dynamic info of HSCSD |
|
1486 if(iNotifyInfo.iNotifyPending) |
|
1487 { |
|
1488 *(RMobileCall::TMobileCallHscsdInfoV1*)iNotifyInfo.iNotifyData=(RMobileCall::TMobileCallHscsdInfoV1)iHscsdInfo; |
|
1489 ReqCompleted(iNotifyInfo.iNotifyHandle,KErrNone); |
|
1490 } |
|
1491 } |
|
1492 } |
|
1493 |
|
1494 TInt CSimDataCall::SearchRetrieveRlp(TInt* aRLPVersion,TDes8* aRLPRange) |
|
1495 /** |
|
1496 * |
|
1497 * Private function to search the list of available RLP ranges per version |
|
1498 * and return the appropriate range. |
|
1499 */ |
|
1500 { |
|
1501 TInt count = iMobileCallRLPList->Count(); |
|
1502 TMobileCallRLPItem item; |
|
1503 |
|
1504 for(TInt i=0; i<count; i++) |
|
1505 { |
|
1506 item=iMobileCallRLPList->At(i); |
|
1507 if(item.iRlpVersion==*aRLPVersion) |
|
1508 { |
|
1509 *(RMobileCall::TMobileDataRLPRangesV1*)aRLPRange=item.iMobileCallRLP; |
|
1510 return KErrNone; |
|
1511 } |
|
1512 } |
|
1513 return KErrNotFound; |
|
1514 } |
|
1515 |