|
1 /* |
|
2 * Copyright (c) 2000 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 #include <ETelExt.h> |
|
19 |
|
20 // Multimode header files |
|
21 #include "etelmm.h" |
|
22 //#include <mmlist.h> |
|
23 |
|
24 #include "CSipSseTestTls.h" |
|
25 #include "musunittesting.h" |
|
26 //#include "mm_hold.h" |
|
27 |
|
28 /*GLDEF_C TInt E32Dll(TDllReason) |
|
29 // |
|
30 // DLL entry point |
|
31 // |
|
32 { |
|
33 return KErrNone; |
|
34 } |
|
35 */ |
|
36 /************************************************************************/ |
|
37 // |
|
38 // TMobileAddress |
|
39 // |
|
40 /************************************************************************/ |
|
41 |
|
42 EXPORT_C RMobilePhone::TMobileAddress::TMobileAddress() |
|
43 : iTypeOfNumber(EUnknownNumber), |
|
44 iNumberPlan(EUnknownNumberingPlan) |
|
45 { |
|
46 } |
|
47 |
|
48 void RMobilePhone::TMobileAddress::InternalizeL(RReadStream& aStream) |
|
49 /** |
|
50 * This method internalizes the mobile address from a stream |
|
51 * |
|
52 * \param aStream The read stream containing the mobile address |
|
53 */ |
|
54 { |
|
55 iTypeOfNumber=STATIC_CAST(TMobileTON, aStream.ReadUint32L()); |
|
56 iNumberPlan=STATIC_CAST(TMobileNPI, aStream.ReadUint32L()); |
|
57 aStream >> iTelNumber; |
|
58 } |
|
59 |
|
60 void RMobilePhone::TMobileAddress::ExternalizeL(RWriteStream& aStream) const |
|
61 /** |
|
62 * This method externalizes the mobile address into a stream |
|
63 * |
|
64 * \param aStream The write stream that will contain the mobile address |
|
65 */ |
|
66 { |
|
67 aStream.WriteUint32L(iTypeOfNumber); |
|
68 aStream.WriteUint32L(iNumberPlan); |
|
69 aStream << iTelNumber; |
|
70 } |
|
71 |
|
72 |
|
73 /************************************************************************/ |
|
74 // |
|
75 // RMobilePhone |
|
76 // |
|
77 /************************************************************************/ |
|
78 |
|
79 EXPORT_C RMobilePhone::RMobilePhone() |
|
80 : iMmPtrHolder(NULL) |
|
81 { |
|
82 } |
|
83 |
|
84 EXPORT_C void RMobilePhone::ConstructL() |
|
85 { |
|
86 RPhone::ConstructL(); |
|
87 // __ASSERT_ALWAYS(iMmPtrHolder==NULL,PanicClient(EEtelPanicHandleNotClosed)); |
|
88 // iMmPtrHolder = CMobilePhonePtrHolder::NewL(CMobilePhonePtrHolder::EMaxNumberPhonePtrSlots,CMobilePhonePtrHolder::EMaxNumberPhonePtrCSlots); |
|
89 } |
|
90 |
|
91 EXPORT_C void RMobilePhone::Destruct() |
|
92 { |
|
93 RPhone::Destruct(); |
|
94 // delete iMmPtrHolder; |
|
95 // iMmPtrHolder = NULL; |
|
96 } |
|
97 |
|
98 /************************************************************************/ |
|
99 // |
|
100 // TMultimodeType |
|
101 // |
|
102 /************************************************************************/ |
|
103 |
|
104 RMobilePhone::TMultimodeType::TMultimodeType() |
|
105 {} |
|
106 |
|
107 EXPORT_C TInt RMobilePhone::TMultimodeType::ExtensionId() const |
|
108 /** |
|
109 * This method returns the multimode API extension number of the class |
|
110 * |
|
111 * \return TInt An integer that will indicate the version of the type |
|
112 */ |
|
113 { |
|
114 return iExtensionId; |
|
115 } |
|
116 |
|
117 void RMobilePhone::TMultimodeType::InternalizeL(RReadStream& aStream) |
|
118 /** |
|
119 * This method internalizes the multimode type from a stream |
|
120 * |
|
121 * \param aStream The read stream containing the multimode type |
|
122 */ |
|
123 { |
|
124 iExtensionId=aStream.ReadInt32L(); |
|
125 } |
|
126 |
|
127 void RMobilePhone::TMultimodeType::ExternalizeL(RWriteStream& aStream) const |
|
128 /** |
|
129 * This method externalizes the multimode type into a stream |
|
130 * |
|
131 * \param aStream The write stream that will contain the multimode type |
|
132 */ |
|
133 { |
|
134 aStream.WriteInt32L(iExtensionId); |
|
135 } |
|
136 |
|
137 |
|
138 /***********************************************************************************/ |
|
139 // |
|
140 // MobilePhoneCapability functional unit |
|
141 // |
|
142 /***********************************************************************************/ |
|
143 |
|
144 EXPORT_C TInt RMobilePhone::GetMultimodeAPIVersion(TInt& aVersion) const |
|
145 /** |
|
146 * This method returns the current version of the multimode ETel API |
|
147 * |
|
148 * \param aVersion Will contain the current version of the multimode ETel API |
|
149 * \return KErrNone |
|
150 */ |
|
151 { |
|
152 aVersion=KETelExtMultimodeV1; |
|
153 return KErrNone; |
|
154 } |
|
155 |
|
156 EXPORT_C TInt RMobilePhone::GetMultimodeCaps(TUint32& aCaps) const |
|
157 /** |
|
158 * This method returns the multimode capabilities of the phone |
|
159 * |
|
160 * \retval aCaps An integer that will contain the bit-wise sum of the multimode capabilities |
|
161 * \return KErrNone |
|
162 */ |
|
163 { |
|
164 TPckg<TUint32> ptr1(aCaps); |
|
165 return Get(EMobilePhoneGetMultimodeCaps, ptr1); |
|
166 } |
|
167 |
|
168 EXPORT_C void RMobilePhone::GetPhoneStoreInfo(TRequestStatus& aReqStatus, TDes8& aInfo, const TDesC& aStoreName) const |
|
169 /** |
|
170 * This method returns the information related to a particular phone store |
|
171 * |
|
172 * \param aStoreName Specifies the name of the store, for which information is required |
|
173 * \retval aInfo A descriptor that will contain the phone store information |
|
174 */ |
|
175 { |
|
176 SetAndGet(EMobilePhoneGetPhoneStoreInfo,aReqStatus, aInfo, aStoreName); |
|
177 } |
|
178 |
|
179 /***********************************************************************************/ |
|
180 // |
|
181 // MobilePhoneSimAccess functional unit |
|
182 // |
|
183 /***********************************************************************************/ |
|
184 |
|
185 EXPORT_C TInt RMobilePhone::GetIccAccessCaps(TUint32& aCaps) const |
|
186 /** |
|
187 * This method returns the ICC (Integrated circuit card) access capabilities of the phone |
|
188 * |
|
189 * \retval aCaps An integer that will contain the bit-wise sum of the ICC access capabilities |
|
190 * \return KErrNone |
|
191 * \exception KErrNotSupported if ICC access is never supported |
|
192 */ |
|
193 { |
|
194 TPckg<TUint32> ptr1(aCaps); |
|
195 return Get(EMobilePhoneGetIccAccessCaps, ptr1); |
|
196 } |
|
197 |
|
198 EXPORT_C void RMobilePhone::NotifyIccAccessCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const |
|
199 /** |
|
200 * This notification completes if the ICC access capabilities of the phone change |
|
201 * |
|
202 * \retval aCaps An integer that will contain the new ICC access capabilities |
|
203 */ |
|
204 { |
|
205 /* __ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
206 |
|
207 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyIccAccessCapsChange,aCaps); |
|
208 |
|
209 Get(EMobilePhoneNotifyIccAccessCapsChange,aReqStatus,ptr1);*/ |
|
210 } |
|
211 |
|
212 EXPORT_C RMobilePhone::TMobilePhoneCspFileV1::TMobilePhoneCspFileV1() |
|
213 : iCallOfferingServices(0),iCallRestrictionServices(0),iOtherSuppServices(0), |
|
214 iCallCompletionServices(0),iTeleservices(0),iCphsTeleservices(0),iCphsFeatures(0), |
|
215 iNumberIdentServices(0),iPhase2PlusServices(0),iValueAddedServices(0) |
|
216 { |
|
217 iExtensionId=KETelExtMultimodeV1; |
|
218 } |
|
219 |
|
220 EXPORT_C void RMobilePhone::GetCustomerServiceProfile(TRequestStatus& aReqStatus, TDes8& aCsp) const |
|
221 /** |
|
222 * This method returns the Customer Service Profile (CSP) stored on the SIM |
|
223 * |
|
224 * \retval aCsp A descriptor that will contain the CSP information |
|
225 */ |
|
226 { |
|
227 // Get(EMobilePhoneGetCustomerServiceProfile, aReqStatus, aCsp); |
|
228 } |
|
229 |
|
230 EXPORT_C RMobilePhone::TMobilePhoneServiceTableV1::TMobilePhoneServiceTableV1() |
|
231 : iServices1To8(0),iServices9To16(0),iServices17To24(0),iServices25To32(0), |
|
232 iServices33To40(0) |
|
233 { |
|
234 iExtensionId=KETelExtMultimodeV1; |
|
235 } |
|
236 |
|
237 EXPORT_C void RMobilePhone::GetServiceTable(TRequestStatus& aReqStatus, TMobilePhoneServiceTable aTable, TDes8& aSst) const |
|
238 /** |
|
239 * This method returns the Service Table (SIM or CDMA) stored on the ICC |
|
240 * |
|
241 * \param aTable Specifies whether the SIM or CDMA service table is to be retrieved |
|
242 * \retval aTable A descriptor that will contain the service table information |
|
243 */ |
|
244 { |
|
245 /* __ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
246 |
|
247 iMmPtrHolder->iServiceTable = aTable; |
|
248 TPtrC8& ptr1=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1GetServiceTable, iMmPtrHolder->iServiceTable); |
|
249 |
|
250 SetAndGet(EMobilePhoneGetServiceTable, aReqStatus, ptr1, aSst);*/ |
|
251 } |
|
252 |
|
253 /***********************************************************************************/ |
|
254 // |
|
255 // MobilePhonePower functional unit |
|
256 // |
|
257 /***********************************************************************************/ |
|
258 |
|
259 EXPORT_C TInt RMobilePhone::GetBatteryCaps(TUint32& aCaps) const |
|
260 /** |
|
261 * This method returns the battery capabilities of the phone |
|
262 * |
|
263 * \retval aCaps An integer that will contain the bit-wise sum of the battery capabilities |
|
264 * \return KErrNone |
|
265 * \exception KErrNotSupported if battery information is not supported |
|
266 */ |
|
267 { |
|
268 // TPckg<TUint32> ptr1(aCaps); |
|
269 // return Get(EMobilePhoneGetBatteryCaps, ptr1); |
|
270 return 0; |
|
271 } |
|
272 |
|
273 EXPORT_C RMobilePhone::TMobilePhoneBatteryInfoV1::TMobilePhoneBatteryInfoV1() : |
|
274 iStatus(EPowerStatusUnknown), iChargeLevel(0) |
|
275 { |
|
276 iExtensionId=KETelExtMultimodeV1; |
|
277 } |
|
278 |
|
279 EXPORT_C void RMobilePhone::GetBatteryInfo(TRequestStatus& aReqStatus, TMobilePhoneBatteryInfoV1& aInfo) const |
|
280 /** |
|
281 * This method returns the current battery information of the phone |
|
282 * |
|
283 * \retval aInfo Will contain the battery information |
|
284 */ |
|
285 { |
|
286 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
287 |
|
288 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetBatteryInfo,aInfo); |
|
289 |
|
290 Get(EMobilePhoneGetBatteryInfo,aReqStatus,ptr1);*/ |
|
291 } |
|
292 |
|
293 EXPORT_C void RMobilePhone::NotifyBatteryInfoChange(TRequestStatus& aReqStatus, TMobilePhoneBatteryInfoV1& aInfo) const |
|
294 /** |
|
295 * This notification completes if the battery information changes |
|
296 * |
|
297 * \retval aInfo Will contain the new battery information |
|
298 */ |
|
299 { |
|
300 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
301 |
|
302 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyBatteryInfoChange,aInfo); |
|
303 |
|
304 Get(EMobilePhoneNotifyBatteryInfoChange,aReqStatus,ptr1);*/ |
|
305 } |
|
306 |
|
307 /***********************************************************************************/ |
|
308 // |
|
309 // MobilePhoneSignal functional unit |
|
310 // |
|
311 /***********************************************************************************/ |
|
312 |
|
313 EXPORT_C TInt RMobilePhone::GetSignalCaps(TUint32& aCaps) const |
|
314 /** |
|
315 * This method returns the signal strength capabilities of the phone |
|
316 * |
|
317 * \retval aCaps An integer that will contain the bit-wise sum of the signal strength capabilities |
|
318 * \return KErrNone |
|
319 * \exception KErrNotSupported if signal strength information is not supported |
|
320 */ |
|
321 { |
|
322 // TPckg<TUint32> ptr1(aCaps); |
|
323 // return Get(EMobilePhoneGetSignalCaps, ptr1); |
|
324 return 0; |
|
325 } |
|
326 |
|
327 EXPORT_C void RMobilePhone::GetSignalStrength(TRequestStatus& aReqStatus, TInt32& aSignalStrength, TInt8& aBar) const |
|
328 /** |
|
329 * This method returns the current signal strength of the phone |
|
330 * |
|
331 * \retval aSignalStrength Will contain the signal strength, expressed in dBm |
|
332 * \retval aBar Will contain the number of bars of signal strength to display |
|
333 */ |
|
334 { |
|
335 /* __ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
336 |
|
337 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetSignalStrength,aSignalStrength); |
|
338 TPtr8& ptr2=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot2GetSignalStrength,aBar); |
|
339 |
|
340 Get(EMobilePhoneGetSignalStrength,aReqStatus,ptr1,ptr2);*/ |
|
341 } |
|
342 |
|
343 EXPORT_C void RMobilePhone::NotifySignalStrengthChange(TRequestStatus& aReqStatus, TInt32& aSignalStrength, TInt8& aBar) const |
|
344 /** |
|
345 * This notification completes if the signal strength of the phone changes |
|
346 * |
|
347 * \retval aSignalStrength Will contain the new signal strength, expressed in dBm |
|
348 * \retval aBar Will contain the new number of bars of signal strength to display |
|
349 */ |
|
350 { |
|
351 /* __ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
352 |
|
353 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifySignalStrengthChange,aSignalStrength); |
|
354 TPtr8& ptr2=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot2NotifySignalStrengthChange,aBar); |
|
355 |
|
356 Get(EMobilePhoneNotifySignalStrengthChange, aReqStatus, ptr1, ptr2);*/ |
|
357 } |
|
358 |
|
359 /***********************************************************************************/ |
|
360 // |
|
361 // MobilePhoneIndicator functional unit |
|
362 // |
|
363 /***********************************************************************************/ |
|
364 |
|
365 EXPORT_C TInt RMobilePhone::GetIndicatorCaps(TUint32& aActionCaps, TUint32& aIndCaps) const |
|
366 /** |
|
367 * This method returns the indicator capabilities of the phone |
|
368 * |
|
369 * \retval aActionCaps An integer that will contain the bit-wise sum of TMobilePhoneIndicatorCaps flags |
|
370 * \retval aIndCaps An integer that will contain the bit-wise sum of supported TMobilePhoneIndicators flags |
|
371 * \return KErrNone |
|
372 * \exception KErrNotSupported if indicators are not supported |
|
373 */ |
|
374 { |
|
375 /*TPckg<TUint32> ptr1(aActionCaps); |
|
376 TPckg<TUint32> ptr2(aIndCaps); |
|
377 return Get(EMobilePhoneGetIndicatorCaps, ptr1, ptr2);*/ |
|
378 return 0; |
|
379 } |
|
380 |
|
381 EXPORT_C void RMobilePhone::GetIndicator(TRequestStatus& aReqStatus, TUint32& aIndicator) const |
|
382 /** |
|
383 * This method returns the current value of the supported indicators from the phone |
|
384 * |
|
385 * \retval aIndicator Will contain bit-wise sum of the current values of each indicator |
|
386 * \exception KErrNotSupported if indicators are not supported |
|
387 */ |
|
388 { |
|
389 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
390 |
|
391 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetIndicator,aIndicator); |
|
392 |
|
393 Get(EMobilePhoneGetIndicator,aReqStatus,ptr1);*/ |
|
394 } |
|
395 |
|
396 EXPORT_C void RMobilePhone::NotifyIndicatorChange(TRequestStatus& aReqStatus, TUint32& aIndicator) const |
|
397 /** |
|
398 * This notification completes if any of the supported indicators change state |
|
399 * |
|
400 * \retval aIndicator Will contain bit-wise sum of the new values of each indicator |
|
401 * \exception KErrNotSupported if indicators are not supported |
|
402 */ |
|
403 { |
|
404 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
405 |
|
406 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyIndicatorChange,aIndicator); |
|
407 |
|
408 Get(EMobilePhoneNotifyIndicatorChange, aReqStatus, ptr1);*/ |
|
409 } |
|
410 |
|
411 /***********************************************************************************/ |
|
412 // |
|
413 // MobilePhoneIdentity functional unit |
|
414 // |
|
415 /***********************************************************************************/ |
|
416 |
|
417 EXPORT_C TInt RMobilePhone::GetIdentityCaps(TUint32& aCaps) const |
|
418 /** |
|
419 * This method returns the identity capabilities of the phone |
|
420 * |
|
421 * \retval aCaps An integer that will contain the bit-wise sum of the identity capabilities |
|
422 * \return KErrNone |
|
423 * \exception KErrNotSupported if phone and subscriber identity information is not supported |
|
424 */ |
|
425 { |
|
426 // TPckg<TUint32> ptr1(aCaps); |
|
427 // return Get(EMobilePhoneGetIdentityCaps, ptr1); |
|
428 return 0; |
|
429 } |
|
430 |
|
431 EXPORT_C RMobilePhone::TMobilePhoneIdentityV1::TMobilePhoneIdentityV1() |
|
432 { |
|
433 iExtensionId=KETelExtMultimodeV1; |
|
434 } |
|
435 |
|
436 EXPORT_C void RMobilePhone::GetPhoneId(TRequestStatus& aReqStatus, TMobilePhoneIdentityV1& aId) const |
|
437 /** |
|
438 * This method returns the identity of the phone |
|
439 * |
|
440 * \retval aId Will contain the identity, which can consist of manufacturer, model, revision and serial numbers |
|
441 */ |
|
442 { |
|
443 /* __ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
444 |
|
445 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetPhoneId,aId); |
|
446 |
|
447 Get(EMobilePhoneGetPhoneId, aReqStatus, ptr1);*/ |
|
448 } |
|
449 |
|
450 EXPORT_C void RMobilePhone::GetSubscriberId(TRequestStatus& aReqStatus, TMobilePhoneSubscriberId& aId) const |
|
451 /** |
|
452 * This method returns the identity of the subscriber (IMSI) |
|
453 * |
|
454 * \retval aId Will contain the identity |
|
455 */ |
|
456 { |
|
457 /* __ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
458 |
|
459 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetSubscriberId,aId); |
|
460 |
|
461 Get(EMobilePhoneGetSubscriberId, aReqStatus, ptr1);*/ |
|
462 } |
|
463 |
|
464 /***********************************************************************************/ |
|
465 // |
|
466 // MobilePhoneDTMF functional unit |
|
467 // |
|
468 /***********************************************************************************/ |
|
469 |
|
470 EXPORT_C TInt RMobilePhone::GetDTMFCaps(TUint32& aCaps) const |
|
471 /** |
|
472 * This method returns the DTMF capabilities of the phone |
|
473 * |
|
474 * \retval aCaps An integer that will contain the bit-wise sum of the DTMF capabilities |
|
475 * \return KErrNone |
|
476 * \exception KErrNotSupported if DTMF is not supported |
|
477 */ |
|
478 { |
|
479 // TPckg<TUint32> ptr1(aCaps); |
|
480 // return Get(EMobilePhoneGetDTMFCaps, ptr1); |
|
481 return 0; |
|
482 } |
|
483 |
|
484 EXPORT_C void RMobilePhone::NotifyDTMFCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const |
|
485 /** |
|
486 * This notification completes if the DTMF capabilities of the phone change |
|
487 * |
|
488 * \retval aCaps An integer that will contain the new DTMF capabilities |
|
489 */ |
|
490 { |
|
491 /* __ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
492 |
|
493 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyDTMFCapsChange, aCaps); |
|
494 |
|
495 Get(EMobilePhoneNotifyDTMFCapsChange, aReqStatus, ptr1);*/ |
|
496 } |
|
497 |
|
498 EXPORT_C void RMobilePhone::SendDTMFTones(TRequestStatus& aReqStatus, const TDesC& aTones) const |
|
499 /** |
|
500 * This method sends a series of DTMF tones across a connected and active voice call |
|
501 * |
|
502 * \param aTones Supplies the tones to send |
|
503 */ |
|
504 { |
|
505 // Set(EMobilePhoneSendDTMFTones, aReqStatus, aTones); |
|
506 } |
|
507 |
|
508 EXPORT_C TInt RMobilePhone::StartDTMFTone(TChar aTone) const |
|
509 /** |
|
510 * This method starts the transmission of a single DTMF tone across a connected and active voice call |
|
511 * |
|
512 * \param aTone Supplies the tone to send |
|
513 */ |
|
514 { |
|
515 /*TPckgC<TChar> ptr1(aTone); |
|
516 return Set(EMobilePhoneStartDTMFTone,ptr1);*/ |
|
517 } |
|
518 |
|
519 EXPORT_C TInt RMobilePhone::StopDTMFTone() const |
|
520 /** |
|
521 * This method stops the transmission of a single DTMF tone across a connected and active voice call |
|
522 */ |
|
523 { |
|
524 // return Blank(EMobilePhoneStopDTMFTone); |
|
525 return 0; |
|
526 } |
|
527 |
|
528 EXPORT_C void RMobilePhone::NotifyStopInDTMFString(TRequestStatus& aRequestStatus) const |
|
529 /** |
|
530 * This notification completes if a stop character is found within a DTMF string |
|
531 */ |
|
532 { |
|
533 //Blank(EMobilePhoneNotifyStopInDTMFString,aRequestStatus); |
|
534 } |
|
535 |
|
536 EXPORT_C TInt RMobilePhone::ContinueDTMFStringSending(TBool aContinue) const |
|
537 /** |
|
538 * This method either continues or cancels the sending of a string of DTMF tones |
|
539 * It assumes that a stop character has previously been found within the string |
|
540 * |
|
541 * \param aContinue A boolean that specifies whether the sending will continue or stop |
|
542 */ |
|
543 { |
|
544 /*TPckg<TBool> ptr1(aContinue); |
|
545 return Set(EMobilePhoneContinueDTMFStringSending,ptr1);*/ |
|
546 } |
|
547 |
|
548 /***********************************************************************************/ |
|
549 // |
|
550 // MobilePhoneNetwork functional unit |
|
551 // |
|
552 /***********************************************************************************/ |
|
553 |
|
554 EXPORT_C RMobilePhone::TMobilePhoneNetworkInfoV1::TMobilePhoneNetworkInfoV1() |
|
555 : iMode(ENetworkModeUnknown), |
|
556 iStatus(ENetworkStatusUnknown), |
|
557 iBandInfo(EBandUnknown) |
|
558 { |
|
559 iExtensionId=KETelExtMultimodeV1; |
|
560 } |
|
561 |
|
562 void RMobilePhone::TMobilePhoneNetworkInfoV1::InternalizeL(RReadStream& aStream) |
|
563 /** |
|
564 * This method internalizes the mobile network information from a stream |
|
565 * |
|
566 * \param aStream The read stream containing the mobile network information |
|
567 */ |
|
568 { |
|
569 /* TMultimodeType::InternalizeL(aStream); |
|
570 iMode=STATIC_CAST(TMobilePhoneNetworkMode, aStream.ReadUint32L()); |
|
571 iStatus=STATIC_CAST(TMobilePhoneNetworkStatus, aStream.ReadUint32L()); |
|
572 iBandInfo=STATIC_CAST(TMobilePhoneNetworkBandInfo, aStream.ReadUint32L()); |
|
573 aStream >> iCountryCode; |
|
574 aStream >> iCdmaSID; |
|
575 aStream >> iAnalogSID; |
|
576 aStream >> iNetworkId; |
|
577 aStream >> iDisplayTag; |
|
578 aStream >> iShortName; |
|
579 aStream >> iLongName;*/ |
|
580 } |
|
581 |
|
582 void RMobilePhone::TMobilePhoneNetworkInfoV1::ExternalizeL(RWriteStream& aStream) const |
|
583 /** |
|
584 * This method externalizes the mobile network information into a stream |
|
585 * |
|
586 * \param aStream The write stream that will contain the mobile network information |
|
587 */ |
|
588 { |
|
589 /* TMultimodeType::ExternalizeL(aStream); |
|
590 aStream.WriteUint32L(iMode); |
|
591 aStream.WriteUint32L(iStatus); |
|
592 aStream.WriteUint32L(iBandInfo); |
|
593 aStream << iCountryCode; |
|
594 aStream << iCdmaSID; |
|
595 aStream << iAnalogSID; |
|
596 aStream << iNetworkId; |
|
597 aStream << iDisplayTag; |
|
598 aStream << iShortName; |
|
599 aStream << iLongName;*/ |
|
600 } |
|
601 |
|
602 EXPORT_C TInt RMobilePhone::GetNetworkCaps(TUint32& aCaps) const |
|
603 /** |
|
604 * This method returns the network capabilities of the phone |
|
605 * |
|
606 * \retval aCaps An integer that will contain the bit-wise sum of the network capabilities |
|
607 * \return KErrNone |
|
608 * \exception KErrNotSupported if network access/information is not supported |
|
609 */ |
|
610 { |
|
611 /*TPckg<TUint32> ptr1(aCaps); |
|
612 return Get(EMobilePhoneGetNetworkCaps, ptr1);*/ |
|
613 return 0; |
|
614 } |
|
615 |
|
616 EXPORT_C TInt RMobilePhone::GetCurrentMode(TMobilePhoneNetworkMode& aNetworkMode) const |
|
617 /** |
|
618 * This method returns the current mode of the phone |
|
619 * |
|
620 * \retval aNetworkMode Will contain the mode (GSM, WCDMA, CDMA, TDMA, AMPS) |
|
621 */ |
|
622 { |
|
623 TInt err = 0; |
|
624 CSipSseTestTls* tls = CSipSseTestTls::Storage(); |
|
625 if ( tls ) |
|
626 { |
|
627 aNetworkMode = tls->PhoneNetworkModeStatus(); |
|
628 err = tls->Error(); |
|
629 } |
|
630 |
|
631 return err; |
|
632 } |
|
633 |
|
634 EXPORT_C void RMobilePhone::NotifyModeChange(TRequestStatus& aReqStatus, TMobilePhoneNetworkMode& aNetworkMode) const |
|
635 /** |
|
636 * This notification completes if the mode of the phone changes |
|
637 * |
|
638 * \retval aNetworkMode Will contain the new mode (GSM, WCDMA, CDMA, TDMA, AMPS) |
|
639 */ |
|
640 { |
|
641 /* __ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
642 |
|
643 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyModeChange, aNetworkMode); |
|
644 |
|
645 Get(EMobilePhoneNotifyModeChange,aReqStatus, ptr1);*/ |
|
646 iReqStatus = &aReqStatus; |
|
647 iNetworkMode = &aNetworkMode; |
|
648 } |
|
649 |
|
650 void RMobilePhone::DoNotifyModeChange( TMobilePhoneNetworkMode aNetworkMode, TInt aErrorCode ) |
|
651 { |
|
652 *iNetworkMode = aNetworkMode; |
|
653 *iReqStatus = KRequestPending; |
|
654 TRequestStatus* stat = iReqStatus; |
|
655 User::RequestComplete( stat, aErrorCode ); |
|
656 |
|
657 } |
|
658 |
|
659 void RMobilePhone::CancelAsyncRequest(TInt aReqToCancel) const |
|
660 { |
|
661 *iReqStatus = KRequestPending; |
|
662 TRequestStatus* stat = iReqStatus; |
|
663 User::RequestComplete( stat, KErrNone ); |
|
664 } |
|
665 |
|
666 |
|
667 EXPORT_C void RMobilePhone::GetHomeNetwork(TRequestStatus& aReqStatus, TDes8& aNetworkInfo) const |
|
668 /** |
|
669 * This method returns information on the subscriber's home network |
|
670 * |
|
671 * \retval aNetworkInfo Will contain the home network information |
|
672 */ |
|
673 { |
|
674 //Get(EMobilePhoneGetHomeNetwork, aReqStatus, aNetworkInfo); |
|
675 } |
|
676 |
|
677 EXPORT_C RMobilePhone::TMobilePhoneLocationAreaV1::TMobilePhoneLocationAreaV1() |
|
678 : iAreaKnown(EFalse), iLocationAreaCode(0), iCellId(0) |
|
679 { |
|
680 iExtensionId=KETelExtMultimodeV1; |
|
681 } |
|
682 |
|
683 EXPORT_C void RMobilePhone::GetCurrentNetwork(TRequestStatus& aReqStatus, TDes8& aNetworkInfo, TMobilePhoneLocationAreaV1& aArea) const |
|
684 /** |
|
685 * This method returns information on the phone's current serving network |
|
686 * |
|
687 * \retval aNetworkInfo Will contain the information related to the current network |
|
688 * \retval aArea Will contain the phone's current location area |
|
689 */ |
|
690 { |
|
691 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
692 |
|
693 TPtr8& ptr2=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetCurrentNetwork, aArea); |
|
694 |
|
695 Get(EMobilePhoneGetCurrentNetwork, aReqStatus, aNetworkInfo, ptr2);*/ |
|
696 } |
|
697 |
|
698 EXPORT_C void RMobilePhone::NotifyCurrentNetworkChange(TRequestStatus& aReqStatus, TDes8& aNetworkInfo, TMobilePhoneLocationAreaV1& aArea) const |
|
699 /** |
|
700 * This notification completes if the serving network of the phone changes |
|
701 * |
|
702 * \retval aNetworkInfo Will contain the information related to the new network |
|
703 * \retval aArea Will contain the phone's new location area |
|
704 */ |
|
705 { |
|
706 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
707 |
|
708 TPtr8& ptr2=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyCurrentNetworkChange, aArea); |
|
709 |
|
710 Get(EMobilePhoneNotifyCurrentNetworkChange, aReqStatus, aNetworkInfo, ptr2);*/ |
|
711 } |
|
712 |
|
713 EXPORT_C void RMobilePhone::GetNetworkRegistrationStatus(TRequestStatus& aReqStatus, TMobilePhoneRegistrationStatus& aStatus) const |
|
714 /** |
|
715 * This method returns the phone's current network registration status |
|
716 * |
|
717 * \retval aStatus Will contain the network registration status |
|
718 */ |
|
719 { |
|
720 CSipSseTestTls* tls = CSipSseTestTls::Storage(); |
|
721 if ( tls ) |
|
722 { |
|
723 tls->RegistrationStatus( aStatus ); |
|
724 } |
|
725 |
|
726 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
727 |
|
728 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetNetworkRegistrationStatus, aStatus); |
|
729 |
|
730 Get(EMobilePhoneGetNetworkRegistrationStatus, aReqStatus, ptr1);*/ |
|
731 } |
|
732 |
|
733 EXPORT_C void RMobilePhone::NotifyNetworkRegistrationStatusChange(TRequestStatus& aReqStatus, TMobilePhoneRegistrationStatus& aStatus) const |
|
734 /** |
|
735 * This notification completes if the network registration status of the phone changes |
|
736 * |
|
737 * \retval aStatus Will contain the new network registration status |
|
738 */ |
|
739 { |
|
740 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
741 |
|
742 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyNetworkRegistrationStatusChange, aStatus); |
|
743 |
|
744 Get(EMobilePhoneNotifyNetworkRegistrationStatusChange, aReqStatus, ptr1);*/ |
|
745 CSipSseTestTls* tls = CSipSseTestTls::Storage(); |
|
746 if ( tls ) |
|
747 { |
|
748 tls->SetRegistrationStatus( &aStatus ); |
|
749 tls->SetRequestStatus( aReqStatus ); |
|
750 } |
|
751 } |
|
752 |
|
753 EXPORT_C RMobilePhone::TMobilePhoneNetworkSelectionV1::TMobilePhoneNetworkSelectionV1() |
|
754 : iMethod(ENetworkSelectionUnknown), |
|
755 iBandClass(ENetworkBandClassUnknown), |
|
756 iOperationMode(ENetworkOperationUnknown) |
|
757 { |
|
758 iExtensionId=KETelExtMultimodeV1; |
|
759 } |
|
760 |
|
761 EXPORT_C TInt RMobilePhone::GetNetworkSelectionSetting(TDes8& aSetting) const |
|
762 /** |
|
763 * This method returns the phone's current network selection setting |
|
764 * |
|
765 * \retval aSetting Will contain the network selection setting |
|
766 */ |
|
767 { |
|
768 //return Get(EMobilePhoneGetNetworkSelectionSetting, aSetting); |
|
769 return 0; |
|
770 } |
|
771 |
|
772 EXPORT_C void RMobilePhone::SetNetworkSelectionSetting(TRequestStatus& aReqStatus, const TDes8& aSetting) const |
|
773 /** |
|
774 * This method sets a new value for the phone's network selection setting |
|
775 * |
|
776 * \param aSetting Supplies the new network selection setting |
|
777 */ |
|
778 { |
|
779 //Set(EMobilePhoneSetNetworkSelectionSetting,aReqStatus,aSetting); |
|
780 } |
|
781 |
|
782 EXPORT_C void RMobilePhone::NotifyNetworkSelectionSettingChange(TRequestStatus& aReqStatus, TDes8& aSetting) const |
|
783 /** |
|
784 * This notification completes if the network selection setting of the phone changes |
|
785 * |
|
786 * \retval aSetting Will contain the new setting |
|
787 */ |
|
788 { |
|
789 //Get(EMobilePhoneNotifyNetworkSelectionSettingChange, aReqStatus, aSetting); |
|
790 } |
|
791 |
|
792 EXPORT_C void RMobilePhone::SelectNetwork(TRequestStatus& aReqStatus, TBool aIsManual, const TMobilePhoneNetworkManualSelection& aManualSelection) const |
|
793 /** |
|
794 * This method instructs the phone to initiate network selection |
|
795 * |
|
796 * \param aIsManual Specifies whether phone should manual or automatic network selection method |
|
797 * \param aManualSelection If aIsManual=ETrue, then this parameter contain the user's manually selected network |
|
798 */ |
|
799 { |
|
800 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
801 |
|
802 iMmPtrHolder->iIsManual = aIsManual; |
|
803 TPtrC8& ptr1=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SelectNetwork, iMmPtrHolder->iIsManual); |
|
804 TPtrC8& ptr2=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2SelectNetwork, aManualSelection); |
|
805 |
|
806 Set(EMobilePhoneSelectNetwork,aReqStatus, ptr1, ptr2);*/ |
|
807 } |
|
808 |
|
809 EXPORT_C RMobilePhone::TMobilePhoneNITZ::TMobilePhoneNITZ() |
|
810 : iNitzFieldsUsed(0), iTimeZone(0), iDST(0) |
|
811 { |
|
812 } |
|
813 |
|
814 EXPORT_C RMobilePhone::TMobilePhoneNITZ::TMobilePhoneNITZ(TInt aYear, TMonth aMonth, TInt aDay, TInt aHour, TInt aMinute, TInt aSecond, TInt aMicroSecond) |
|
815 : TDateTime(aYear,aMonth,aDay,aHour,aMinute,aSecond,aMicroSecond), iNitzFieldsUsed(0), iTimeZone(0), iDST(0) |
|
816 { |
|
817 } |
|
818 |
|
819 EXPORT_C TInt RMobilePhone::GetNITZInfo(TMobilePhoneNITZ& aNITZInfo) const |
|
820 /** |
|
821 * This method returns the current snapshot of network time & date information |
|
822 * |
|
823 * \retval aNITZInfo Will contain the time & date information |
|
824 */ |
|
825 { |
|
826 TPckg<TMobilePhoneNITZ> ptr1(aNITZInfo); |
|
827 return Get(EMobilePhoneGetNITZInfo,ptr1); |
|
828 } |
|
829 |
|
830 EXPORT_C void RMobilePhone::NotifyNITZInfoChange(TRequestStatus& aReqStatus, TMobilePhoneNITZ& aNITZInfo) const |
|
831 /** |
|
832 * This notification completes if the time & date information sent by the network changes |
|
833 * |
|
834 * \retval aNITZInfo Will contain the new time & date information |
|
835 */ |
|
836 { |
|
837 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
838 |
|
839 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyNITZInfoChange,aNITZInfo); |
|
840 Get(EMobilePhoneNotifyNITZInfoChange,aReqStatus,ptr1);*/ |
|
841 } |
|
842 |
|
843 /***********************************************************************************/ |
|
844 // |
|
845 // MobilePrivacy functional unit |
|
846 // |
|
847 /***********************************************************************************/ |
|
848 |
|
849 EXPORT_C TInt RMobilePhone::GetDefaultPrivacy(TMobilePhonePrivacy& aSetting) const |
|
850 /** |
|
851 * This method returns the phone's default voice privacy setting in CDMA mode |
|
852 * |
|
853 * \retval aSetting An enum that will contain the current privacy setting |
|
854 * \return KErrNone |
|
855 * \exception KErrNotSupported if user network access is not supported |
|
856 */ |
|
857 { |
|
858 //TPckg<TMobilePhonePrivacy> ptr1(aSetting); |
|
859 //return Get(EMobilePhoneGetDefaultPrivacy, ptr1); |
|
860 return 0; |
|
861 } |
|
862 |
|
863 EXPORT_C void RMobilePhone::SetDefaultPrivacy(TRequestStatus& aReqStatus, TMobilePhonePrivacy aSetting) const |
|
864 /** |
|
865 * This method sets the phone's default voice privacy setting in CDMA mode |
|
866 * |
|
867 * \param aSetting Supplies the new voice privacy setting |
|
868 */ |
|
869 { |
|
870 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
871 |
|
872 iMmPtrHolder->iPrivacySetting = aSetting; |
|
873 TPtrC8& ptr1=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetDefaultPrivacy,iMmPtrHolder->iPrivacySetting); |
|
874 |
|
875 Set(EMobilePhoneSetDefaultPrivacy,aReqStatus, ptr1);*/ |
|
876 } |
|
877 |
|
878 EXPORT_C void RMobilePhone::NotifyDefaultPrivacyChange(TRequestStatus& aReqStatus, TMobilePhonePrivacy& aSetting) const |
|
879 /** |
|
880 * This notification completes if the default voice privacy setting of the phone changes |
|
881 * |
|
882 * \retval aSetting An enum that will contain the new privacy setting |
|
883 */ |
|
884 { |
|
885 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
886 |
|
887 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyDefaultPrivacyChange, aSetting); |
|
888 |
|
889 Get(EMobilePhoneNotifyDefaultPrivacyChange, aReqStatus, ptr1);*/ |
|
890 } |
|
891 |
|
892 /***********************************************************************************/ |
|
893 // |
|
894 // TSY Capabilities for supplementary call services |
|
895 // |
|
896 /***********************************************************************************/ |
|
897 |
|
898 EXPORT_C TInt RMobilePhone::GetCallServiceCaps(TUint32& aCaps) const |
|
899 /** |
|
900 * This method returns the supplementary call service capabilities of the phone |
|
901 * |
|
902 * \retval aCaps An integer that will contain the bit-wise sum of the call service caps |
|
903 * \return KErrNone |
|
904 * \exception KErrNotSupported if user network access is not supported |
|
905 */ |
|
906 { |
|
907 //TPckg<TUint32> ptr1(aCaps); |
|
908 //return Get(EMobilePhoneGetCallServiceCaps, ptr1); |
|
909 return 0; |
|
910 } |
|
911 |
|
912 EXPORT_C void RMobilePhone::NotifyCallServiceCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const |
|
913 /** |
|
914 * This notification completes if the call service capabilities of the phone change |
|
915 * |
|
916 * \retval aCaps An integer that will contain the new call service capabilities |
|
917 */ |
|
918 { |
|
919 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
920 |
|
921 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyCallServiceCapsChange, aCaps); |
|
922 |
|
923 Get(EMobilePhoneNotifyCallServiceCapsChange, aReqStatus, ptr1);*/ |
|
924 } |
|
925 |
|
926 /***********************************************************************************/ |
|
927 // |
|
928 // MobilePhoneUserNetworkAccess functional unit |
|
929 // |
|
930 /***********************************************************************************/ |
|
931 |
|
932 EXPORT_C void RMobilePhone::ProgramFeatureCode(TRequestStatus& aReqStatus, const TDesC& aFCString, TMobilePhoneNetworkService aService, TMobilePhoneServiceAction aAction) const |
|
933 /** |
|
934 * This method programs a feature code string against a network service action |
|
935 * |
|
936 * \param aFCString Supplies the feature code string to be programmed |
|
937 * \param aService Specifies which service is applicable to the feature code string |
|
938 * \param aAction Specifies which action is applicable to the feature code string |
|
939 */ |
|
940 { |
|
941 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
942 |
|
943 iMmPtrHolder->iProgramFeatureCode.iService = aService; |
|
944 iMmPtrHolder->iProgramFeatureCode.iAction = aAction; |
|
945 TPtrC8& ptr1=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1ProgramFeatureCode,iMmPtrHolder->iProgramFeatureCode); |
|
946 |
|
947 Set(EMobilePhoneProgramFeatureCode,aReqStatus, ptr1, aFCString);*/ |
|
948 } |
|
949 |
|
950 EXPORT_C void RMobilePhone::GetFeatureCode(TRequestStatus& aReqStatus, TDes& aFCString, TMobilePhoneNetworkService aService, TMobilePhoneServiceAction aAction) const |
|
951 /** |
|
952 * This method returns the feature code string programmed against a network service action |
|
953 * |
|
954 * \param aService Specifies which service is applicable to the feature code string |
|
955 * \param aAction Specifies which action is applicable to the feature code string |
|
956 * \retval aFCString Will contain the feature code string programmed |
|
957 */ |
|
958 { |
|
959 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
960 |
|
961 iMmPtrHolder->iGetFeatureCode.iService = aService; |
|
962 iMmPtrHolder->iGetFeatureCode.iAction = aAction; |
|
963 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetFeatureCode,iMmPtrHolder->iGetFeatureCode); |
|
964 |
|
965 Get(EMobilePhoneGetFeatureCode,aReqStatus, ptr1, aFCString);*/ |
|
966 } |
|
967 |
|
968 EXPORT_C void RMobilePhone::SendNetworkServiceRequest(TRequestStatus& aReqStatus, const TDesC& aServiceString) const |
|
969 /** |
|
970 * This method sends a request to the network in the form of a character and digit string |
|
971 * It will complete either when the network has confirmed the request or after the phone has sent it |
|
972 * depending upon whether network confirmation is supported by serving network |
|
973 * |
|
974 * \param aServiceString Supplies the supplementary service or feature code string to be sent |
|
975 */ |
|
976 { |
|
977 //Set(EMobilePhoneSendNetworkServiceRequest, aReqStatus, aServiceString); |
|
978 } |
|
979 |
|
980 /***********************************************************************************/ |
|
981 // |
|
982 // MobilePhoneCallForwarding functional unit |
|
983 // |
|
984 /***********************************************************************************/ |
|
985 |
|
986 EXPORT_C RMobilePhone::TMobilePhoneCFInfoEntryV1::TMobilePhoneCFInfoEntryV1() |
|
987 : iCondition(ECallForwardingUnspecified), |
|
988 iServiceGroup(EServiceUnspecified), |
|
989 iStatus(ECallForwardingStatusUnknown), |
|
990 iTimeout(0) |
|
991 { |
|
992 iExtensionId=KETelExtMultimodeV1; |
|
993 } |
|
994 |
|
995 void RMobilePhone::TMobilePhoneCFInfoEntryV1::InternalizeL(RReadStream& aStream) |
|
996 /** |
|
997 * This method internalizes the call forwarding information from a stream |
|
998 * |
|
999 * \param aStream The read stream containing the call forwarding information |
|
1000 */ |
|
1001 { |
|
1002 /*TMultimodeType::InternalizeL(aStream); |
|
1003 iCondition=STATIC_CAST(TMobilePhoneCFCondition, aStream.ReadUint32L()); |
|
1004 iServiceGroup=STATIC_CAST(TMobileService, aStream.ReadUint32L()); |
|
1005 iStatus=STATIC_CAST(TMobilePhoneCFStatus, aStream.ReadUint32L()); |
|
1006 aStream >> iNumber; |
|
1007 iTimeout=aStream.ReadInt32L();*/ |
|
1008 } |
|
1009 |
|
1010 void RMobilePhone::TMobilePhoneCFInfoEntryV1::ExternalizeL(RWriteStream& aStream) const |
|
1011 /** |
|
1012 * This method externalizes the call forwarding information into a stream |
|
1013 * |
|
1014 * \param aStream The write stream that will contain the call forwarding information |
|
1015 */ |
|
1016 { |
|
1017 /*TMultimodeType::ExternalizeL(aStream); |
|
1018 aStream.WriteUint32L(iCondition); |
|
1019 aStream.WriteUint32L(iServiceGroup); |
|
1020 aStream.WriteUint32L(iStatus); |
|
1021 aStream << iNumber; |
|
1022 aStream.WriteInt32L(iTimeout);*/ |
|
1023 } |
|
1024 |
|
1025 EXPORT_C void RMobilePhone::NotifyCallForwardingStatusChange(TRequestStatus& aReqStatus, TMobilePhoneCFCondition& aCondition) const |
|
1026 /** |
|
1027 * This notification completes if the status of a call forwarding service changes |
|
1028 * |
|
1029 * \retval aCondition Will contain the name of the changed service (CFU, CFB, CFNRc, CFNRy) |
|
1030 */ |
|
1031 { |
|
1032 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1033 |
|
1034 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyCallForwardingStatusChange,aCondition); |
|
1035 |
|
1036 Get(EMobilePhoneNotifyCallForwardingStatusChange,aReqStatus, ptr1);*/ |
|
1037 } |
|
1038 |
|
1039 EXPORT_C RMobilePhone::TMobilePhoneCFChangeV1::TMobilePhoneCFChangeV1() |
|
1040 : iServiceGroup(EServiceUnspecified), |
|
1041 iAction(EServiceActionUnspecified), |
|
1042 iTimeout(0) |
|
1043 { |
|
1044 iExtensionId=KETelExtMultimodeV1; |
|
1045 } |
|
1046 |
|
1047 EXPORT_C void RMobilePhone::SetCallForwardingStatus(TRequestStatus& aReqStatus, TMobilePhoneCFCondition aCondition, const TMobilePhoneCFChangeV1& aInfo) const |
|
1048 /** |
|
1049 * This method sets the call forwarding status for incoming calls across all lines |
|
1050 * It will complete either when the network has confirmed the request or after the phone has sent it |
|
1051 * depending upon whether network confirmation is supported by serving network |
|
1052 * |
|
1053 * \param aCondition Specifies which call forwarding service (CFU, CFB, CFNRy, CFNRc) is being set |
|
1054 * \param aInfo Supplies the new status and/or registered information of the call forwarding service, as applied to all basic services (i.e. all lines) |
|
1055 */ |
|
1056 { |
|
1057 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1058 |
|
1059 iMmPtrHolder->iSetCFCondition = aCondition; |
|
1060 TPtrC8& ptr1=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetCallForwardingStatus,iMmPtrHolder->iSetCFCondition); |
|
1061 |
|
1062 TPtrC8& ptr2=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2SetCallForwardingStatus,aInfo); |
|
1063 |
|
1064 Set(EMobilePhoneSetCallForwardingStatus, aReqStatus, ptr1, ptr2);*/ |
|
1065 } |
|
1066 |
|
1067 EXPORT_C void RMobilePhone::NotifyCallForwardingActive(TRequestStatus& aReqStatus, TMobileService& aServiceGroup, TMobilePhoneCFActive& aActiveType) const |
|
1068 /** |
|
1069 * This notification completes if a call is made on this line while call forwarding is active on it |
|
1070 * |
|
1071 * \retval aActiveType Will indicate whether unconditional (CFU) or one of the conditional (CFB, CFNRy, CFNRc) services is active |
|
1072 */ |
|
1073 { |
|
1074 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1075 |
|
1076 TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1PhoneNotifyCallForwardingActive, aServiceGroup); |
|
1077 TPtr8& ptr2=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot2PhoneNotifyCallForwardingActive, aActiveType); |
|
1078 |
|
1079 Get(EMobilePhoneNotifyCallForwardingActive, aReqStatus, ptr1, ptr2);*/ |
|
1080 } |
|
1081 |
|
1082 /***********************************************************************************/ |
|
1083 // |
|
1084 // Mobile Identity Service functional unit |
|
1085 // |
|
1086 /***********************************************************************************/ |
|
1087 |
|
1088 EXPORT_C void RMobilePhone::GetIdentityServiceStatus(TRequestStatus& aReqStatus, const TMobilePhoneIdService aService, TMobilePhoneIdServiceStatus& aStatus, TMobileInfoLocation aLocation) const |
|
1089 /** |
|
1090 * This method returns the current status of the specified identity service |
|
1091 * |
|
1092 * \param aService Specifies which identity service (CLIP, CLIR, COLP, COLR etc.) is being interrogated |
|
1093 * \retval aStatus Will contain the current status of the service |
|
1094 * \param aLocation Specifies whether the information should be retrieved from phone cache or network |
|
1095 */ |
|
1096 { |
|
1097 /*)__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1098 |
|
1099 iMmPtrHolder->iGetIdentityServiceStatus.iLocation = aLocation; |
|
1100 iMmPtrHolder->iGetIdentityServiceStatus.iService = aService; |
|
1101 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1GetIdentityServiceStatus,iMmPtrHolder->iGetIdentityServiceStatus); |
|
1102 TPtr8& ptr2 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot2GetIdentityServiceStatus,aStatus); |
|
1103 |
|
1104 SetAndGet(EMobilePhoneGetIdentityServiceStatus,aReqStatus,ptr1,ptr2);*/ |
|
1105 } |
|
1106 |
|
1107 /***********************************************************************************/ |
|
1108 // |
|
1109 // Mobile Call Barring functional unit |
|
1110 // |
|
1111 /***********************************************************************************/ |
|
1112 |
|
1113 EXPORT_C RMobilePhone::TMobilePhoneCBInfoEntryV1::TMobilePhoneCBInfoEntryV1() |
|
1114 : iCondition(EBarUnspecified), |
|
1115 iServiceGroup(EServiceUnspecified), |
|
1116 iStatus(ECallBarringStatusUnknown) |
|
1117 { |
|
1118 iExtensionId=KETelExtMultimodeV1; |
|
1119 } |
|
1120 |
|
1121 void RMobilePhone::TMobilePhoneCBInfoEntryV1::InternalizeL(RReadStream& aStream) |
|
1122 /** |
|
1123 * This method internalizes the call barring inforamation from a stream |
|
1124 * |
|
1125 * \param aStream The read stream containing the call barring inforamation |
|
1126 */ |
|
1127 { |
|
1128 /*TMultimodeType::InternalizeL(aStream); |
|
1129 iCondition = STATIC_CAST(TMobilePhoneCBCondition,aStream.ReadUint32L()); |
|
1130 iServiceGroup = STATIC_CAST(TMobileService,aStream.ReadUint32L()); |
|
1131 iStatus = STATIC_CAST(TMobilePhoneCBStatus,aStream.ReadUint32L());*/ |
|
1132 } |
|
1133 |
|
1134 void RMobilePhone::TMobilePhoneCBInfoEntryV1::ExternalizeL(RWriteStream& aStream) const |
|
1135 /** |
|
1136 * This method externalizes the call barring information into a stream |
|
1137 * |
|
1138 * \param aStream The write stream that will contain the call barring information |
|
1139 */ |
|
1140 { |
|
1141 /*TMultimodeType::ExternalizeL(aStream); |
|
1142 aStream.WriteUint32L(iCondition); |
|
1143 aStream.WriteUint32L(iServiceGroup); |
|
1144 aStream.WriteUint32L(iStatus);*/ |
|
1145 } |
|
1146 |
|
1147 EXPORT_C RMobilePhone::TMobilePhoneCBChangeV1::TMobilePhoneCBChangeV1() |
|
1148 : iServiceGroup(EServiceUnspecified), |
|
1149 iAction(EServiceActionUnspecified) |
|
1150 { |
|
1151 iExtensionId=KETelExtMultimodeV1; |
|
1152 } |
|
1153 |
|
1154 EXPORT_C void RMobilePhone::SetCallBarringStatus(TRequestStatus& aReqStatus, TMobilePhoneCBCondition aCondition, const TMobilePhoneCBChangeV1& aInfo) const |
|
1155 /** |
|
1156 * This method sets the call barring status for calls across all lines |
|
1157 * It will complete either when the network has confirmed the request or after the phone has sent it |
|
1158 * depending upon whether network confirmation is supported by serving network |
|
1159 * |
|
1160 * \param aCondition Specifies which call barring program (BAOC, BIC etc) is being set |
|
1161 * \param aInfo Supplies the new status of the call barring service, as applied to all basic services (i.e. all lines) |
|
1162 */ |
|
1163 { |
|
1164 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1165 |
|
1166 iMmPtrHolder->iSetCBStatusCondition = aCondition; |
|
1167 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetCallBarringStatus,iMmPtrHolder->iSetCBStatusCondition); |
|
1168 TPtrC8& ptr2 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2SetCallBarringStatus,aInfo); |
|
1169 |
|
1170 Set(EMobilePhoneSetCallBarringStatus,aReqStatus,ptr1,ptr2);*/ |
|
1171 } |
|
1172 |
|
1173 EXPORT_C void RMobilePhone::NotifyCallBarringStatusChange(TRequestStatus& aReqStatus, TMobilePhoneCBCondition& aCondition) const |
|
1174 /** |
|
1175 * This notification completes if the status of a call barring program changes |
|
1176 * |
|
1177 * \retval aCondition Will contain the name of the changed barring program (BAOC, BIC etc.) |
|
1178 */ |
|
1179 { |
|
1180 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1181 |
|
1182 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyCallBarringStatusChange,aCondition); |
|
1183 |
|
1184 Get(EMobilePhoneNotifyCallBarringStatusChange,aReqStatus,ptr1);*/ |
|
1185 } |
|
1186 |
|
1187 EXPORT_C RMobilePhone::TMobilePhonePasswordChangeV1::TMobilePhonePasswordChangeV1() |
|
1188 { |
|
1189 iExtensionId=KETelExtMultimodeV1; |
|
1190 } |
|
1191 |
|
1192 EXPORT_C void RMobilePhone::SetCallBarringPassword(TRequestStatus& aReqStatus, const TMobilePhonePasswordChangeV1& aPassword) const |
|
1193 /** |
|
1194 * This method sets the call barring password that is part of the subscription for any call barring program |
|
1195 * It will complete either when the network has confirmed the request or after the phone has sent it |
|
1196 * depending upon whether network confirmation is supported by serving network |
|
1197 * |
|
1198 * \param aPassword Supplies the old and new call barring passwords |
|
1199 */ |
|
1200 { |
|
1201 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1202 |
|
1203 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetCallBarringPassword,aPassword); |
|
1204 |
|
1205 Set(EMobilePhoneSetCallBarringPassword,aReqStatus,ptr1);*/ |
|
1206 } |
|
1207 |
|
1208 /***********************************************************************************/ |
|
1209 // |
|
1210 // Mobile Call Waiting functional unit |
|
1211 // |
|
1212 /***********************************************************************************/ |
|
1213 |
|
1214 void RMobilePhone::TMobilePhoneCWInfoEntryV1::InternalizeL(RReadStream& aStream) |
|
1215 /** |
|
1216 * This method internalizes the call waiting inforamation from a stream |
|
1217 * |
|
1218 * \param aStream The read stream containing the call waiting inforamation |
|
1219 */ |
|
1220 { |
|
1221 /*TMultimodeType::InternalizeL(aStream); |
|
1222 iServiceGroup = STATIC_CAST(TMobileService,aStream.ReadUint32L()); |
|
1223 iStatus = STATIC_CAST(TMobilePhoneCWStatus,aStream.ReadUint32L());*/ |
|
1224 } |
|
1225 |
|
1226 void RMobilePhone::TMobilePhoneCWInfoEntryV1::ExternalizeL(RWriteStream& aStream) const |
|
1227 /** |
|
1228 * This method externalizes the call waiting information into a stream |
|
1229 * |
|
1230 * \param aStream The write stream that will contain the call waiting information |
|
1231 */ |
|
1232 { |
|
1233 /*TMultimodeType::ExternalizeL(aStream); |
|
1234 aStream.WriteUint32L(iServiceGroup); |
|
1235 aStream.WriteUint32L(iStatus);*/ |
|
1236 } |
|
1237 |
|
1238 EXPORT_C RMobilePhone::TMobilePhoneCWInfoEntryV1::TMobilePhoneCWInfoEntryV1() |
|
1239 : iServiceGroup(EServiceUnspecified), |
|
1240 iStatus(ECallWaitingStatusUnknown) |
|
1241 { |
|
1242 iExtensionId=KETelExtMultimodeV1; |
|
1243 } |
|
1244 |
|
1245 EXPORT_C void RMobilePhone::SetCallWaitingStatus(TRequestStatus& aReqStatus, TMobileService aServiceGroup, TMobilePhoneServiceAction aAction) const |
|
1246 /** |
|
1247 * This method sets the status of the call waiting service for all lines |
|
1248 * It will complete either when the network has confirmed the request or after the phone has sent it |
|
1249 * depending upon whether network confirmation is supported by serving network |
|
1250 * |
|
1251 * \param aAction Supplies the new status of the call waiting service, as applied to all basic services |
|
1252 */ |
|
1253 { |
|
1254 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1255 |
|
1256 iMmPtrHolder->iSetCallWaitingStatusGroup = aServiceGroup; |
|
1257 iMmPtrHolder->iSetCallWaitingStatusAction = aAction; |
|
1258 |
|
1259 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetCallWaitingStatus,iMmPtrHolder->iSetCallWaitingStatusGroup); |
|
1260 TPtrC8& ptr2 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2SetCallWaitingStatus,iMmPtrHolder->iSetCallWaitingStatusAction); |
|
1261 |
|
1262 Set(EMobilePhoneSetCallWaitingStatus,aReqStatus,ptr1,ptr2);*/ |
|
1263 } |
|
1264 |
|
1265 EXPORT_C void RMobilePhone::NotifyCallWaitingStatusChange(TRequestStatus& aReqStatus, TDes8& aCWStatus) const |
|
1266 /** |
|
1267 * This notification completes if the status of the call waiting service changes |
|
1268 * |
|
1269 * \retval aCWStatus Will contain the new status of the call waiting service |
|
1270 */ |
|
1271 { |
|
1272 //Get(EMobilePhoneNotifyCallWaitingStatusChange,aReqStatus,aCWStatus); |
|
1273 } |
|
1274 |
|
1275 |
|
1276 /***********************************************************************************/ |
|
1277 // |
|
1278 // Mobile Call Completion functional unit |
|
1279 // |
|
1280 /***********************************************************************************/ |
|
1281 |
|
1282 EXPORT_C void RMobilePhone::GetCCBSStatus(TRequestStatus& aReqStatus, TMobilePhoneCCBSStatus& aCcbsStatus, TMobileInfoLocation aLocation) const |
|
1283 /** |
|
1284 * This method returns the current status of the CCBS service |
|
1285 * |
|
1286 * \retval aCcbsStatus Will contain the current status of the service |
|
1287 * \param aLocation Specifies whether the information should be retrieved from phone cache or network |
|
1288 */ |
|
1289 { |
|
1290 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1291 |
|
1292 iMmPtrHolder->iGetCCBSStatusLocation = aLocation; |
|
1293 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetCCBSStatus,aCcbsStatus); |
|
1294 TPtr8& ptr2 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot2GetCCBSStatus,iMmPtrHolder->iGetCCBSStatusLocation); |
|
1295 |
|
1296 Get(EMobilePhoneGetCCBSStatus,aReqStatus,ptr1,ptr2);*/ |
|
1297 } |
|
1298 |
|
1299 EXPORT_C void RMobilePhone::NotifyCCBSStatusChange(TRequestStatus& aReqStatus, TMobilePhoneCCBSStatus& aCcbsStatus) const |
|
1300 /** |
|
1301 * This notification completes if the status of the CCBS service changes |
|
1302 * |
|
1303 * \retval aCcbsStatus Will contain the new status of the CCBS service |
|
1304 */ |
|
1305 { |
|
1306 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1307 |
|
1308 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyCCBSStatusChange,aCcbsStatus); |
|
1309 |
|
1310 Get(EMobilePhoneNotifyCCBSStatusChange,aReqStatus,ptr1);*/ |
|
1311 } |
|
1312 |
|
1313 /*EXPORT_C void RMobilePhone::DeactivateAllCCBS(TRequestStatus& aReqStatus) const |
|
1314 /** |
|
1315 * This method deactivates all currently active CCBS requests |
|
1316 * It will complete either when the network has confirmed the request or after the phone has sent it |
|
1317 * depending upon whether network confirmation is supported by serving network |
|
1318 * |
|
1319 */ |
|
1320 //{ |
|
1321 //Blank(EMobilePhoneDeactivateAllCCBS,aReqStatus); |
|
1322 //} |
|
1323 |
|
1324 void RMobilePhone::TMobilePhoneCCBSEntryV1::InternalizeL(RReadStream& aStream) |
|
1325 /** |
|
1326 * This method internalizes the CCBS inforamation from a stream |
|
1327 * |
|
1328 * \param aStream The read stream containing the CCBS inforamation |
|
1329 */ |
|
1330 { |
|
1331 /*TMultimodeType::InternalizeL(aStream); |
|
1332 aStream >> iCallName; |
|
1333 iServiceGroup = STATIC_CAST(TMobileService,aStream.ReadUint32L()); |
|
1334 iCcbsIndex = STATIC_CAST(TInt,aStream.ReadUint32L()); |
|
1335 aStream >> iDestination;*/ |
|
1336 } |
|
1337 |
|
1338 void RMobilePhone::TMobilePhoneCCBSEntryV1::ExternalizeL(RWriteStream& aStream) const |
|
1339 /** |
|
1340 * This method externalizes the CCBS information into a stream |
|
1341 * |
|
1342 * \param aStream The write stream that will contain the CCBS information |
|
1343 */ |
|
1344 { |
|
1345 /*TMultimodeType::ExternalizeL(aStream); |
|
1346 aStream << iCallName; |
|
1347 aStream.WriteInt32L(iServiceGroup); |
|
1348 aStream.WriteInt32L(iCcbsIndex); |
|
1349 aStream << iDestination;*/ |
|
1350 } |
|
1351 |
|
1352 EXPORT_C RMobilePhone::TMobilePhoneCCBSEntryV1::TMobilePhoneCCBSEntryV1() |
|
1353 : iCcbsIndex(0), iServiceGroup(EServiceUnspecified) |
|
1354 { |
|
1355 iExtensionId=KETelExtMultimodeV1; |
|
1356 } |
|
1357 |
|
1358 /***********************************************************************************/ |
|
1359 // |
|
1360 // Mobile Alternating Call functional unit |
|
1361 // |
|
1362 /***********************************************************************************/ |
|
1363 |
|
1364 EXPORT_C TInt RMobilePhone::GetAlternatingCallCaps(TUint32& aCaps) const |
|
1365 /** |
|
1366 * This method returns the alternating call capabilities of the phone |
|
1367 * |
|
1368 * \retval aCaps An integer that will contain the bit-wise sum of the alternating call capabilities |
|
1369 * \return KErrNone |
|
1370 * \exception KErrNotSupported if alternating calls are not supported |
|
1371 */ |
|
1372 { |
|
1373 /*TPckg<TUint32> ptr1(aCaps); |
|
1374 return Get(EMobilePhoneGetAlternatingCallCaps,ptr1);*/ |
|
1375 return 0; |
|
1376 } |
|
1377 |
|
1378 EXPORT_C void RMobilePhone::NotifyAlternatingCallCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const |
|
1379 /** |
|
1380 * This notification completes if the alternating call capabilities of the phone change |
|
1381 * |
|
1382 * \retval aCaps An integer that will contain the new alternating call capabilities |
|
1383 */ |
|
1384 { |
|
1385 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1386 |
|
1387 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyAlternatingCallCapsChange,aCaps); |
|
1388 |
|
1389 Get(EMobilePhoneNotifyAlternatingCallCapsChange,aReqStatus,ptr1);*/ |
|
1390 } |
|
1391 |
|
1392 EXPORT_C TInt RMobilePhone::GetAlternatingCallMode(TMobilePhoneAlternatingCallMode& aMode, TMobileService& aFirstService) const |
|
1393 /** |
|
1394 * This method returns the current alternating call mode |
|
1395 * |
|
1396 * \retval aMode Will contain the current alternating call mode |
|
1397 * \retval aFirstService Will contain the service that will be first in an alternating call (voice, data, fax) |
|
1398 */ |
|
1399 { |
|
1400 /*TPckg<TMobilePhoneAlternatingCallMode> ptr1(aMode); |
|
1401 TPckg<TMobileService> ptr2(aFirstService); |
|
1402 |
|
1403 return Get(EMobilePhoneGetAlternatingCallMode,ptr1,ptr2);*/ |
|
1404 } |
|
1405 |
|
1406 EXPORT_C void RMobilePhone::SetAlternatingCallMode(TRequestStatus& aReqStatus, TMobilePhoneAlternatingCallMode aMode, TMobileService aFirstService) const |
|
1407 /** |
|
1408 * This method sets a new value for alternating call mode |
|
1409 * |
|
1410 * \param aMode Specifies the new alternating call mode |
|
1411 * \param aFirstService Specifies the service that will be first in an alternating call (voice, data, fax) |
|
1412 */ |
|
1413 { |
|
1414 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1415 |
|
1416 iMmPtrHolder->iSetAlternatingCallModeMode = aMode; |
|
1417 iMmPtrHolder->iSetAlternatingCallModeService = aFirstService; |
|
1418 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetAlternatingCallMode,iMmPtrHolder->iSetAlternatingCallModeMode); |
|
1419 TPtrC8& ptr2 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2SetAlternatingCallMode,iMmPtrHolder->iSetAlternatingCallModeService); |
|
1420 |
|
1421 Set(EMobilePhoneSetAlternatingCallMode,aReqStatus,ptr1,ptr2);*/ |
|
1422 } |
|
1423 |
|
1424 EXPORT_C void RMobilePhone::NotifyAlternatingCallModeChange(TRequestStatus& aReqStatus, TMobilePhoneAlternatingCallMode& aMode,TMobileService& aFirstService) const |
|
1425 /** |
|
1426 * This notification completes if the alternating call mode of the phone changes |
|
1427 * |
|
1428 * \retval aMode Will contain the new alternating call mode |
|
1429 * \retval aFirstService Will contain the service that will be first in an alternating call (voice, data, fax) |
|
1430 */ |
|
1431 { |
|
1432 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1433 |
|
1434 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyAlternatingCallModeChange,aMode); |
|
1435 TPtr8& ptr2 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot2NotifyAlternatingCallModeChange,aFirstService); |
|
1436 |
|
1437 Get(EMobilePhoneNotifyAlternatingCallModeChange,aReqStatus,ptr1,ptr2);*/ |
|
1438 } |
|
1439 |
|
1440 /***********************************************************************************/ |
|
1441 // |
|
1442 // Mobile Alternate Line Service functional unit |
|
1443 // |
|
1444 /***********************************************************************************/ |
|
1445 |
|
1446 |
|
1447 EXPORT_C TInt RMobilePhone::GetALSLine(TMobilePhoneALSLine& aALSLine) const |
|
1448 /** |
|
1449 * This method returns the current ALS line selected |
|
1450 * |
|
1451 * \retval aALSLine Will contain the ALS line selected |
|
1452 */ |
|
1453 { |
|
1454 /*TPckg<TMobilePhoneALSLine> ptr1(aALSLine); |
|
1455 return Get(EMobilePhoneGetALSLine,ptr1);*/ |
|
1456 return 0; |
|
1457 } |
|
1458 |
|
1459 EXPORT_C void RMobilePhone::SetALSLine(TRequestStatus& aReqStatus, TMobilePhoneALSLine aALSLine) const |
|
1460 /** |
|
1461 * This method sets a new values for the ALS line selected |
|
1462 * |
|
1463 * \param aALSLine Specifies the new ALS line selected |
|
1464 */ |
|
1465 { |
|
1466 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1467 |
|
1468 iMmPtrHolder->iSetALSLine = aALSLine; |
|
1469 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetALSLine,iMmPtrHolder->iSetALSLine); |
|
1470 |
|
1471 Set(EMobilePhoneSetALSLine,aReqStatus,ptr1);*/ |
|
1472 } |
|
1473 |
|
1474 EXPORT_C void RMobilePhone::NotifyALSLineChange(TRequestStatus& aReqStatus, TMobilePhoneALSLine& aALSLine) const |
|
1475 /** |
|
1476 * This notification completes if the ALS line selected changes |
|
1477 * |
|
1478 * \retval aALSLine Will contain the new ALS line selected |
|
1479 */ |
|
1480 { |
|
1481 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1482 |
|
1483 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyALSLineChange,aALSLine); |
|
1484 |
|
1485 Get(EMobilePhoneNotifyALSLineChange,aReqStatus,ptr1);*/ |
|
1486 } |
|
1487 |
|
1488 /***********************************************************************************/ |
|
1489 // |
|
1490 // Mobile Cost functional unit |
|
1491 // |
|
1492 /***********************************************************************************/ |
|
1493 |
|
1494 |
|
1495 EXPORT_C TInt RMobilePhone::GetCostCaps(TUint32& aCaps) const |
|
1496 /** |
|
1497 * This method returns the call cost information capabilities of the phone |
|
1498 * |
|
1499 * \retval aCaps An integer that will contain the bit-wise sum of the call cost information capabilities |
|
1500 * \return KErrNone |
|
1501 * \exception KErrNotSupported if call cost information is not supported |
|
1502 */ |
|
1503 { |
|
1504 //TPckg<TUint32> ptr1(aCaps); |
|
1505 //return Get(EMobilePhoneGetCostCaps,ptr1); |
|
1506 return 0; |
|
1507 } |
|
1508 |
|
1509 EXPORT_C void RMobilePhone::NotifyCostCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const |
|
1510 /** |
|
1511 * This notification completes if the call cost information capabilities of the phone change |
|
1512 * |
|
1513 * \retval aCaps An integer that will contain the new call cost information capabilities |
|
1514 */ |
|
1515 { |
|
1516 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1517 |
|
1518 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyCostCapsChange,aCaps); |
|
1519 |
|
1520 Get(EMobilePhoneNotifyCostCapsChange,aReqStatus,ptr1);*/ |
|
1521 } |
|
1522 |
|
1523 EXPORT_C void RMobilePhone::ClearCostMeter(TRequestStatus& aReqStatus, TMobilePhoneCostMeters aMeter) const |
|
1524 /** |
|
1525 * This method clears the Accumulated Cost Meter (ACM) on the SIM |
|
1526 * It will complete either when the SIM confirms that ACM is cleared or after the phone has |
|
1527 * been denied access due to the requirement for PIN2 entry first |
|
1528 */ |
|
1529 { |
|
1530 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1531 |
|
1532 iMmPtrHolder->iClearCostMeter = aMeter; |
|
1533 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1ClearCostMeter,iMmPtrHolder->iClearCostMeter); |
|
1534 |
|
1535 Set(EMobilePhoneClearCostMeter,aReqStatus,ptr1);*/ |
|
1536 } |
|
1537 |
|
1538 EXPORT_C void RMobilePhone::SetMaxCostMeter(TRequestStatus& aReqStatus, TUint aUnits) const |
|
1539 /** |
|
1540 * This method sets a new value for the Max Accumulated Cost Meter (ACMmax) on the SIM |
|
1541 * It will complete either when the SIM confirms that ACMmax is set or after the phone has |
|
1542 * been denied access due to the requirement for PIN2 entry first |
|
1543 * |
|
1544 * \param aUnits Specifies the number of units to set ACMmax to |
|
1545 */ |
|
1546 { |
|
1547 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1548 |
|
1549 iMmPtrHolder->iSetMaxCostMeterUnits = aUnits; |
|
1550 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetMaxCostMeter,iMmPtrHolder->iSetMaxCostMeterUnits); |
|
1551 |
|
1552 Set(EMobilePhoneSetMaxCostMeter,aReqStatus,ptr1);*/ |
|
1553 } |
|
1554 |
|
1555 EXPORT_C RMobilePhone::TMobilePhonePuctV1::TMobilePhonePuctV1() |
|
1556 : iPricePerUnit(0.0) |
|
1557 { |
|
1558 iExtensionId=KETelExtMultimodeV1; |
|
1559 } |
|
1560 |
|
1561 |
|
1562 EXPORT_C void RMobilePhone::SetPuct(TRequestStatus& aReqStatus, const TDesC8& aPuct) const |
|
1563 /** |
|
1564 * This method sets a new value for the Price Per Unit & Currency Table (PUCT) on the SIM |
|
1565 * It will complete either when the SIM confirms that PUCT is set or after the phone has |
|
1566 * been denied access due to the requirement for PIN2 entry first |
|
1567 * |
|
1568 * \param aPuct Supplies the new PUCT setting |
|
1569 */ |
|
1570 { |
|
1571 Set(EMobilePhoneSetPuct,aReqStatus,aPuct); |
|
1572 } |
|
1573 |
|
1574 EXPORT_C RMobilePhone::TMobilePhoneCostInfoV1::TMobilePhoneCostInfoV1() |
|
1575 : iService(ECostServiceUnknown), |
|
1576 iCCM(0), |
|
1577 iACM(0), |
|
1578 iACMmax(0) |
|
1579 { |
|
1580 iExtensionId=KETelExtMultimodeV1; |
|
1581 } |
|
1582 |
|
1583 EXPORT_C void RMobilePhone::GetCostInfo(TRequestStatus& aReqStatus, TDes8& aCostInfo) const |
|
1584 /** |
|
1585 * This method returns the current snapshot of the phone's call cost information |
|
1586 * |
|
1587 * \retval aCostInfo Will contain the cost information |
|
1588 */ |
|
1589 { |
|
1590 //Get(EMobilePhoneGetCostInfo,aReqStatus,aCostInfo); |
|
1591 } |
|
1592 |
|
1593 EXPORT_C void RMobilePhone::NotifyCostInfoChange(TRequestStatus& aReqStatus, TDes8& aCostInfo) const |
|
1594 /** |
|
1595 * This notification completes if the call cost information changes |
|
1596 * |
|
1597 * \retval aCostInfo Will contain the new call cost information |
|
1598 */ |
|
1599 { |
|
1600 //Get(EMobilePhoneNotifyCostInfoChange,aReqStatus,aCostInfo); |
|
1601 } |
|
1602 |
|
1603 |
|
1604 /***********************************************************************************/ |
|
1605 // |
|
1606 // Mobile Security functional unit |
|
1607 // |
|
1608 /***********************************************************************************/ |
|
1609 |
|
1610 EXPORT_C TInt RMobilePhone::GetSecurityCaps(TUint32& aCaps) const |
|
1611 /** |
|
1612 * This method returns the security capabilities of the phone |
|
1613 * |
|
1614 * \retval aCaps An integer that will contain the bit-wise sum of the security capabilities |
|
1615 * \return KErrNone |
|
1616 * \exception KErrNotSupported if security is not supported |
|
1617 */ |
|
1618 { |
|
1619 /*TPckg<TUint32> ptr1(aCaps); |
|
1620 return Get(EMobilePhoneGetSecurityCaps,ptr1);*/ |
|
1621 return 0; |
|
1622 } |
|
1623 |
|
1624 EXPORT_C void RMobilePhone::NotifySecurityCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const |
|
1625 /** |
|
1626 * This notification completes if the security capabilities of the phone change |
|
1627 * |
|
1628 * \retval aCaps An integer that will contain the new security capabilities |
|
1629 */ |
|
1630 { |
|
1631 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1632 |
|
1633 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifySecurityCapsChange,aCaps); |
|
1634 |
|
1635 Get(EMobilePhoneNotifySecurityCapsChange,aReqStatus,ptr1);*/ |
|
1636 } |
|
1637 |
|
1638 EXPORT_C RMobilePhone::TMobilePhoneLockInfoV1::TMobilePhoneLockInfoV1() |
|
1639 : iStatus(EStatusLocked), |
|
1640 iSetting(ELockSetEnabled) |
|
1641 { |
|
1642 iExtensionId=KETelExtMultimodeV1; |
|
1643 } |
|
1644 |
|
1645 EXPORT_C void RMobilePhone::GetLockInfo(TRequestStatus& aReqStatus, TMobilePhoneLock aLock, TDes8& aLockInfo) const |
|
1646 /** |
|
1647 * This method returns the current status and setting of the specified lock |
|
1648 * |
|
1649 * \param aLock Specifies which lock is being interrogated |
|
1650 * \retval aLockInfo Will contain the lock's current status and setting |
|
1651 */ |
|
1652 { |
|
1653 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1654 |
|
1655 iMmPtrHolder->iLock = aLock; |
|
1656 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1GetLockInfo,iMmPtrHolder->iLock); |
|
1657 |
|
1658 SetAndGet(EMobilePhoneGetLockInfo,aReqStatus,ptr1,aLockInfo);*/ |
|
1659 } |
|
1660 |
|
1661 EXPORT_C void RMobilePhone::NotifyLockInfoChange(TRequestStatus& aReqStatus, TMobilePhoneLock& aLock, TDes8& aLockInfo) const |
|
1662 /** |
|
1663 * This notification completes if the status or information of a lock changes |
|
1664 * |
|
1665 * \retval aLockInfo Will contain the new lock status and information |
|
1666 */ |
|
1667 { |
|
1668 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1669 |
|
1670 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyLockInfoChange,aLock); |
|
1671 |
|
1672 Get(EMobilePhoneNotifyLockInfoChange,aReqStatus,ptr1,aLockInfo);*/ |
|
1673 } |
|
1674 |
|
1675 EXPORT_C void RMobilePhone::SetLockSetting(TRequestStatus& aReqStatus, TMobilePhoneLock aLock, TMobilePhoneLockSetting aSetting) const |
|
1676 /** |
|
1677 * This method sets a new value for the setting of the specified lock |
|
1678 * |
|
1679 * \param aLock Specifies which lock is being set |
|
1680 * \param aSetting Supplies the lock's new setting |
|
1681 */ |
|
1682 { |
|
1683 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1684 |
|
1685 iMmPtrHolder->iSetLockSettingLock = aLock; |
|
1686 iMmPtrHolder->iSetLockSettingSetting = aSetting; |
|
1687 |
|
1688 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetLockSetting,iMmPtrHolder->iSetLockSettingLock); |
|
1689 TPtrC8& ptr2 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2SetLockSetting,iMmPtrHolder->iSetLockSettingSetting); |
|
1690 |
|
1691 Set(EMobilePhoneSetLockSetting,aReqStatus,ptr1,ptr2);*/ |
|
1692 } |
|
1693 |
|
1694 EXPORT_C void RMobilePhone::ChangeSecurityCode(TRequestStatus& aReqStatus, TMobilePhoneSecurityCode aType, const TMobilePhonePasswordChangeV1& aChange) const |
|
1695 /** |
|
1696 * This method changes the value of the specified security code |
|
1697 * |
|
1698 * \param aType Specifies which security code is being changed |
|
1699 * \param aChange Supplies the old and new values for the security code |
|
1700 */ |
|
1701 { |
|
1702 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1703 |
|
1704 iMmPtrHolder->iChangeSecurityCodeType = aType; |
|
1705 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1ChangeSecurityCode,iMmPtrHolder->iChangeSecurityCodeType); |
|
1706 TPtrC8& ptr2 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2ChangeSecurityCode,aChange); |
|
1707 |
|
1708 Set(EMobilePhoneChangeSecurityCode,aReqStatus,ptr1,ptr2);*/ |
|
1709 } |
|
1710 |
|
1711 EXPORT_C void RMobilePhone::NotifySecurityEvent(TRequestStatus& aReqStatus, TMobilePhoneSecurityEvent& aEvent) const |
|
1712 /** |
|
1713 * This notification completes if the phone recognises that a security event has occurred |
|
1714 * |
|
1715 * \retval aEvent Will contain the security event |
|
1716 */ |
|
1717 { |
|
1718 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1719 |
|
1720 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifySecurityEvent,aEvent); |
|
1721 |
|
1722 Get(EMobilePhoneNotifySecurityEvent,aReqStatus,ptr1);*/ |
|
1723 } |
|
1724 |
|
1725 EXPORT_C void RMobilePhone::VerifySecurityCode(TRequestStatus& aReqStatus, TMobilePhoneSecurityCode aType, const TMobilePassword& aCode, |
|
1726 const TMobilePassword& aUnblockCode) const |
|
1727 /** |
|
1728 * This method verifies the user's code agains the specified stored security code |
|
1729 * |
|
1730 * \param aType Specifies which security code is being verified |
|
1731 * \param aCode Supplies the user's code |
|
1732 * \param aUnblockCode Supplies the user's unblock code which may be needed if the user is actually unblocking a security code (e.g. PIN1 or PIN2) |
|
1733 */ |
|
1734 { |
|
1735 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1736 |
|
1737 iMmPtrHolder->iVerifySecurityCodeType = aType; |
|
1738 iMmPtrHolder->iVerifySecurityCodeData.iCode = aCode; |
|
1739 iMmPtrHolder->iVerifySecurityCodeData.iUnblockCode = aUnblockCode; |
|
1740 |
|
1741 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1VerifySecurityCode,iMmPtrHolder->iVerifySecurityCodeType); |
|
1742 TPtrC8& ptr2 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2VerifySecurityCode,iMmPtrHolder->iVerifySecurityCodeData); |
|
1743 |
|
1744 Set(EMobilePhoneVerifySecurityCode,aReqStatus,ptr1,ptr2);*/ |
|
1745 } |
|
1746 |
|
1747 EXPORT_C TInt RMobilePhone::AbortSecurityCode(TMobilePhoneSecurityCode aType) const |
|
1748 /** |
|
1749 * This method informs the phone that the user has cancelled the request for a security code to be entered |
|
1750 */ |
|
1751 { |
|
1752 /*TPckg<TMobilePhoneSecurityCode> ptr1(aType); |
|
1753 return Set(EMobilePhoneAbortSecurityCode,ptr1);*/ |
|
1754 } |
|
1755 |
|
1756 EXPORT_C RMobilePhone::TMobilePhoneMulticallSettingsV1::TMobilePhoneMulticallSettingsV1() |
|
1757 : iUserMaxBearers(-1),iServiceProviderMaxBearers(-1),iNetworkSupportedMaxBearers(-1), |
|
1758 iUESupportedMaxBearers(-1) |
|
1759 { |
|
1760 iExtensionId=KETelExtMultimodeV1; |
|
1761 } |
|
1762 |
|
1763 EXPORT_C void RMobilePhone::GetMulticallParams(TRequestStatus& aReqStatus, TDes8& aMulticallParams) const |
|
1764 /** |
|
1765 * This method retrieves the maximum number of simultaneous CS service bearers defined by |
|
1766 * the user, defined by the service provider, supported by the network and supported by the phone. |
|
1767 * |
|
1768 * \param aMulticallParams Will contain the multicall bearer settings |
|
1769 */ |
|
1770 { |
|
1771 //Get(EMobilePhoneGetMulticallParams, aReqStatus, aMulticallParams); |
|
1772 } |
|
1773 |
|
1774 EXPORT_C void RMobilePhone::SetMulticallParams(TRequestStatus& aReqStatus, TInt aUserMaxBearers) const |
|
1775 /** |
|
1776 * This method is used by client application to set the maximum number of |
|
1777 * simultaneous CS bearers specified by the user (iUserMaxBearers) |
|
1778 * |
|
1779 * \param aUserMaxBearers Supplies the new user specified value |
|
1780 */ |
|
1781 { |
|
1782 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1783 |
|
1784 iMmPtrHolder->iUserMaxBearers = aUserMaxBearers; |
|
1785 TPtrC8& ptr1=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetMulticallParams, iMmPtrHolder->iUserMaxBearers); |
|
1786 |
|
1787 Set(EMobilePhoneSetMulticallParams,aReqStatus,ptr1);*/ |
|
1788 } |
|
1789 |
|
1790 EXPORT_C void RMobilePhone::NotifyMulticallParamsChange(TRequestStatus& aReqStatus, TDes8& aMulticallParams) const |
|
1791 /** |
|
1792 * This notification completes if the multicall parameters of the phone change |
|
1793 * |
|
1794 * \retval aMulticallParams Will contain the new Multicall parameters set by the network |
|
1795 */ |
|
1796 { |
|
1797 //Get(EMobilePhoneNotifyMulticallParamsChange, aReqStatus, aMulticallParams); |
|
1798 } |
|
1799 |
|
1800 /***********************************************************************************/ |
|
1801 // |
|
1802 // Mobile Message Waiting functional unit |
|
1803 // |
|
1804 /***********************************************************************************/ |
|
1805 |
|
1806 EXPORT_C RMobilePhone::TMobilePhoneMessageWaitingV1::TMobilePhoneMessageWaitingV1() |
|
1807 : iVoiceMsgs(0), iAuxVoiceMsgs(0), iDataMsgs(0), iFaxMsgs(0), iEmailMsgs(0), iOtherMsgs(0) |
|
1808 { |
|
1809 iExtensionId=KETelExtMultimodeV1; |
|
1810 } |
|
1811 |
|
1812 EXPORT_C void RMobilePhone::NotifyMessageWaiting(TRequestStatus& aReqStatus, TInt& aCount) const |
|
1813 /** |
|
1814 * This notification completes if the phone receives a "message waiting" message from the network |
|
1815 * |
|
1816 * \retval aCount Will contain the number of voicemail messages waiting |
|
1817 */ |
|
1818 { |
|
1819 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1820 |
|
1821 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyMessageWaiting,aCount); |
|
1822 |
|
1823 Get(EMobilePhoneNotifyMessageWaiting,aReqStatus,ptr1);*/ |
|
1824 } |
|
1825 |
|
1826 EXPORT_C void RMobilePhone::GetIccMessageWaitingIndicators(TRequestStatus& aReqStatus, TDes8& aMsgIndicators) const |
|
1827 /** |
|
1828 * This method retrieves the set of message waiting indicators from the current ICC |
|
1829 * |
|
1830 * \retval aMsgIndicators Will contain the type and number of waiting messages |
|
1831 */ |
|
1832 { |
|
1833 //Get(EMobilePhoneGetIccMessageWaitingIndicators,aReqStatus,aMsgIndicators); |
|
1834 } |
|
1835 |
|
1836 EXPORT_C void RMobilePhone::SetIccMessageWaitingIndicators(TRequestStatus& aReqStatus, const TDesC8& aMsgIndicators) const |
|
1837 /** |
|
1838 * This method sets the message waiting indicators on the current ICC |
|
1839 * |
|
1840 * \retval aMsgIndicators Will contain the type and number of waiting messages |
|
1841 */ |
|
1842 { |
|
1843 //Set(EMobilePhoneSetIccMessageWaitingIndicators,aReqStatus,aMsgIndicators); |
|
1844 } |
|
1845 |
|
1846 EXPORT_C void RMobilePhone::NotifyIccMessageWaitingIndicatorsChange(TRequestStatus& aReqStatus, TDes8& aMsgIndicators) const |
|
1847 /** |
|
1848 * This notification completes if the message waiting indicators change on the current ICC |
|
1849 * |
|
1850 * \retval aMsgIndicators Will contain the type and number of waiting messages |
|
1851 */ |
|
1852 { |
|
1853 //Get(EMobilePhoneNotifyIccMessageWaitingIndicatorsChange,aReqStatus,aMsgIndicators); |
|
1854 } |
|
1855 |
|
1856 /***********************************************************************************/ |
|
1857 // |
|
1858 // Mobile Fixed Dialling Numbers functional unit |
|
1859 // |
|
1860 /***********************************************************************************/ |
|
1861 |
|
1862 |
|
1863 EXPORT_C TInt RMobilePhone::GetFdnStatus(TMobilePhoneFdnStatus& aFdnStatus) const |
|
1864 /** |
|
1865 * This method returns the current status of the Fixed Dialling Number (FDN) service |
|
1866 * |
|
1867 * \retval aFdnStatus Will contain the current status of FDN |
|
1868 */ |
|
1869 { |
|
1870 /*TPckg<TMobilePhoneFdnStatus> ptr1(aFdnStatus); |
|
1871 |
|
1872 return Get(EMobilePhoneGetFdnStatus,ptr1);*/ |
|
1873 } |
|
1874 |
|
1875 EXPORT_C void RMobilePhone::SetFdnSetting(TRequestStatus& aReqStatus, TMobilePhoneFdnSetting aFdnSetting) const |
|
1876 /** |
|
1877 * This method sets a new value for the status of the Fixed Dialling Number (FDN) service |
|
1878 * |
|
1879 * \retval aFdnSetting Supplies the new status of FDN |
|
1880 */ |
|
1881 { |
|
1882 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1883 |
|
1884 iMmPtrHolder->iSetFdnSetting = aFdnSetting; |
|
1885 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetFdnSetting,iMmPtrHolder->iSetFdnSetting); |
|
1886 |
|
1887 Set(EMobilePhoneSetFdnSetting,aReqStatus,ptr1);*/ |
|
1888 } |
|
1889 |
|
1890 EXPORT_C void RMobilePhone::NotifyFdnStatusChange(TRequestStatus& aReqStatus, TMobilePhoneFdnStatus& aFdnStatus) const |
|
1891 /** |
|
1892 * This notification completes if the status of the FDN service changes |
|
1893 * |
|
1894 * \retval aFdnStatus Will contain the new FDN status |
|
1895 */ |
|
1896 { |
|
1897 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1898 |
|
1899 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyFdnStatusChange,aFdnStatus); |
|
1900 |
|
1901 Get(EMobilePhoneNotifyFdnStatusChange,aReqStatus,ptr1);*/ |
|
1902 } |
|
1903 |
|
1904 /************************************************************************************/ |
|
1905 // |
|
1906 // Single Numbering Scheme functional unit |
|
1907 // |
|
1908 /************************************************************************************/ |
|
1909 |
|
1910 |
|
1911 EXPORT_C void RMobilePhone::GetIncomingCallType(TRequestStatus& aReqStatus, TMobilePhoneIncomingCallType& aCallType, TDes8& aDataParams) const |
|
1912 /** |
|
1913 * This method retrieves the current setting of the incoming call type |
|
1914 * |
|
1915 * \retval aType Will contain the incoming call types supported by the phone |
|
1916 * |
|
1917 * \param aDataParams Will contain the data bearer service settings if aType |
|
1918 * indicates that incoming calls will include a data bearer element |
|
1919 */ |
|
1920 { |
|
1921 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1922 |
|
1923 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetIncomingCallType, aCallType); |
|
1924 |
|
1925 Get(EMobilePhoneGetIncomingCallType, aReqStatus, ptr1, aDataParams);*/ |
|
1926 } |
|
1927 |
|
1928 EXPORT_C void RMobilePhone::SetIncomingCallType(TRequestStatus& aReqStatus, TMobilePhoneIncomingCallType aCallType, TDes8& aDataParams) const |
|
1929 /** |
|
1930 * This method sets the incoming call type. |
|
1931 * |
|
1932 * \param aCallType Supplies the new settings for the incoming call types |
|
1933 * \param aDataParam Suppies the new data settings in the case of a data bearer |
|
1934 */ |
|
1935 { |
|
1936 /*)__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1937 |
|
1938 iMmPtrHolder->iCallType = aCallType; |
|
1939 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetIncomingCallType, iMmPtrHolder->iCallType); |
|
1940 |
|
1941 Set(EMobilePhoneSetIncomingCallType, aReqStatus, ptr1, aDataParams);*/ |
|
1942 } |
|
1943 |
|
1944 EXPORT_C void RMobilePhone::NotifyIncomingCallTypeChange(TRequestStatus& aReqStatus, TMobilePhoneIncomingCallType& aCallType, TDes8& aDataParams) const |
|
1945 /** |
|
1946 * This method notifies the client if the setting of the incoming call type changes. |
|
1947 * |
|
1948 * \retval aCallType Will contain the new incoming call type. |
|
1949 * |
|
1950 * \param aDataParams Will contain the data bearer service settings if aCallType |
|
1951 * indicates that incoming calls will include a data bearer element |
|
1952 */ |
|
1953 { |
|
1954 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1955 |
|
1956 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyIncomingCallTypeChange, aCallType); |
|
1957 |
|
1958 Get(EMobilePhoneNotifyIncomingCallTypeChange, aReqStatus, ptr1, aDataParams);*/ |
|
1959 } |
|
1960 |
|
1961 /************************************************************************************/ |
|
1962 // |
|
1963 // User-To-User Signalling functional unit |
|
1964 // |
|
1965 /************************************************************************************/ |
|
1966 |
|
1967 |
|
1968 EXPORT_C void RMobilePhone::GetUUSSetting(TRequestStatus& aReqStatus, TMobilePhoneUUSSetting& aSetting) const |
|
1969 /** |
|
1970 * This method retrieves the current User-User Signalling settings of the phone |
|
1971 * |
|
1972 * \retval aSetting An integer that will contain the current UUS settings |
|
1973 * \return KErrNone |
|
1974 * \exception KErrNotSupported if UUS functionality is not supported by the phone/TSY |
|
1975 */ |
|
1976 { |
|
1977 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1978 |
|
1979 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetUUSSetting, aSetting); |
|
1980 Get(EMobilePhoneGetUUSSetting, aReqStatus, ptr1);*/ |
|
1981 } |
|
1982 |
|
1983 EXPORT_C void RMobilePhone::SetUUSSetting(TRequestStatus& aReqStatus, TMobilePhoneUUSSetting aSetting) const |
|
1984 /** |
|
1985 * This method sets the User-User Signalling settings of the phone |
|
1986 * |
|
1987 * \param aSetting Supplies the new UUS settings |
|
1988 */ |
|
1989 { |
|
1990 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1991 |
|
1992 iMmPtrHolder->iSetUUSSetting = aSetting; |
|
1993 TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetUUSSetting, iMmPtrHolder->iSetUUSSetting); |
|
1994 |
|
1995 Set(EMobilePhoneSetUUSSetting, aReqStatus, ptr1);*/ |
|
1996 } |
|
1997 |
|
1998 EXPORT_C void RMobilePhone::NotifyUUSSettingChange(TRequestStatus& aReqStatus, TMobilePhoneUUSSetting& aSetting) const |
|
1999 /** |
|
2000 * This notification completes if the User-User Signalling settings of the phone change |
|
2001 * |
|
2002 * \retval aCaps An integer that will contain the new UUS settings |
|
2003 */ |
|
2004 { |
|
2005 /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
2006 |
|
2007 TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyUUSSettingChange,aSetting); |
|
2008 |
|
2009 Get(EMobilePhoneNotifyUUSSettingChange, aReqStatus, ptr1);*/ |
|
2010 } |
|
2011 |
|
2012 /***********************************************************************************/ |