|
1 // Copyright (c) 2002-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 // (U)SAT API implementation - RSat |
|
15 // |
|
16 // |
|
17 |
|
18 /** |
|
19 @file |
|
20 */ |
|
21 |
|
22 #include <et_clsvr.h> |
|
23 #include "etelext.h" |
|
24 |
|
25 #include "Etelsat.h" |
|
26 #include "Satptr.h" |
|
27 #include <satcs.h> |
|
28 |
|
29 _LIT(KSatToolkit,"TOOLKIT"); |
|
30 |
|
31 |
|
32 |
|
33 EXPORT_C RSat::RSat() |
|
34 : RTelSubSessionBase(), |
|
35 iEtelSatPtrHolder(NULL) |
|
36 /** Default constructor */ |
|
37 { |
|
38 } |
|
39 |
|
40 EXPORT_C void RSat::ConstructL() |
|
41 /** Initialises RSat. called as part of the two-phase construction (typical to Symbian OS). */ |
|
42 { |
|
43 __ASSERT_ALWAYS(iEtelSatPtrHolder==NULL,PanicClient(EEtelPanicHandleNotClosed)); |
|
44 iEtelSatPtrHolder = CSatPtrHolder::NewL(EMaxNumberSatPtrSlots, EMaxNumberSatCPtrSlots); |
|
45 __ASSERT_ALWAYS(iEtelSatPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
46 } |
|
47 |
|
48 EXPORT_C void RSat::Destruct() |
|
49 /** Default destructor */ |
|
50 { |
|
51 delete iEtelSatPtrHolder; |
|
52 iEtelSatPtrHolder = NULL; |
|
53 } |
|
54 |
|
55 EXPORT_C TInt RSat::Open(RPhone& aPhone) |
|
56 /** |
|
57 * This method opens the RSat interface. |
|
58 * |
|
59 * You must have previously opened an interface to the phone (either an RPhone or EMobilePhone). |
|
60 * Pass the phone session to RSat::Open(). |
|
61 * |
|
62 * After opening the RSat session: |
|
63 * |
|
64 * - Send your profile to the UICC (see RSat::GetMeSideSatProfile() ) |
|
65 * - Request notification to receive proactive commands (see the RSat::Notify.... functions). |
|
66 * - Finally, indicate that you are ready to receive proactive commands from the UICC with RSat::UsatClientReadyIndication() |
|
67 * |
|
68 * @param aPhone A phone session (either an RPhone or EMobilePhone). |
|
69 * @see RSat::Close() |
|
70 * @capability None |
|
71 */ |
|
72 { |
|
73 RSessionBase* session=&aPhone.SessionHandle(); |
|
74 __ASSERT_ALWAYS(session!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
75 TInt subSessionHandle=aPhone.SubSessionHandle(); |
|
76 __ASSERT_ALWAYS(subSessionHandle!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
77 |
|
78 TRAPD(ret,ConstructL()); |
|
79 if (ret) |
|
80 return ret; |
|
81 TPtrC name(KSatToolkit); |
|
82 SetSessionHandle(*session); |
|
83 ret = CreateSubSession(*session,EEtelOpenFromSubSession,TIpcArgs(&name,TIpcArgs::ENothing,subSessionHandle)); |
|
84 if (ret) |
|
85 Destruct(); |
|
86 return ret; |
|
87 } |
|
88 |
|
89 EXPORT_C void RSat::Close() |
|
90 /** |
|
91 * This method closes RSat. |
|
92 * @see RSat::Open() |
|
93 * @capability None |
|
94 */ |
|
95 { |
|
96 CloseSubSession(EEtelClose); |
|
97 Destruct(); |
|
98 } |
|
99 |
|
100 |
|
101 RSat::TSatBase::TSatBase() |
|
102 :iExtensionId(KSatVersionNotSet) |
|
103 /** Default constructor */ |
|
104 { |
|
105 } |
|
106 |
|
107 EXPORT_C TInt RSat::TSatBase::ExtensionId() const |
|
108 /** |
|
109 * This method returns the version number of the parameter. |
|
110 * It will be a value from RSat::TSatVersion. |
|
111 * The version number is also called the extension identifier. |
|
112 * |
|
113 * @return The API version number. |
|
114 * |
|
115 * @see RSat::TSatVersion |
|
116 */ |
|
117 { |
|
118 return iExtensionId; |
|
119 } |
|
120 |
|
121 RSat::TSatPCmdBase::TSatPCmdBase() |
|
122 : TSatBase(), |
|
123 iPCmdNumber(0) |
|
124 /** Default constructor */ |
|
125 { |
|
126 } |
|
127 |
|
128 EXPORT_C TUint8 RSat::TSatPCmdBase::PCmdNumber() const |
|
129 /** |
|
130 * This method returns the value of iPCmdNumber for the associated proactive command class. |
|
131 * The PCmd Number is the one originally issued by the UICC card. |
|
132 * |
|
133 * @return The protected data member iPCmdNumber which specifies the proactive command number. |
|
134 */ |
|
135 { |
|
136 return iPCmdNumber; |
|
137 } |
|
138 |
|
139 EXPORT_C TInt RSat::TSatPCmdBase::SetPCmdNumber(TUint8 aNumber) |
|
140 /** |
|
141 * This method sets iPCmdNumber for the associated proactive command class. |
|
142 * The PCmd Number is the one originally issued by the UICC card. |
|
143 * |
|
144 * @param aNumber PCmdNumber associated with the proactive command sent by the UICC card. |
|
145 * @return KErrNotSupported returned if aNumber is not within the valid range (1->254 inclusive). |
|
146 * Otherwise, KErrNone returned. |
|
147 */ |
|
148 { |
|
149 if ((aNumber<1) || aNumber>254) |
|
150 return KErrNotSupported; |
|
151 else |
|
152 { |
|
153 iPCmdNumber=aNumber; |
|
154 return KErrNone; |
|
155 } |
|
156 } |
|
157 |
|
158 EXPORT_C void RSat::GetIcon(TRequestStatus& aReqStatus, TUint8 aRecordNumber, RSat::TIcon& aIconEf) const |
|
159 /** |
|
160 * A proactive command may be accompanied by an icon to be displayed to the user; |
|
161 * see RSat::TIconId. The command does not contain the icon. Instead, it |
|
162 * contains an icon identifier, RSat::TIconId::iIdentifier. When you want to display an |
|
163 * icon, the first step is to pass RSat::TIconId::iIdentifier to |
|
164 * RSat::GetIcon() to retrieve the icon's EF record from the UICC. |
|
165 * |
|
166 * The EF record describes the icon. The UICC may store several images that |
|
167 * represent the same icon. Images can differ in size and coding scheme. Each is |
|
168 * listed and described in the EF record. Analyse the EF record and choose a |
|
169 * suitable image, then call RSat::GetImageInstance() to retrieves |
|
170 * the actual image data to display. |
|
171 * |
|
172 * If none of the images are suitable then see the error conditions described in |
|
173 * RSat::TIconId. |
|
174 * |
|
175 * The EF record is described in ETSI TS 131 102; search for EFimg or "Contents |
|
176 * of files at the DFGRAPHICS level" |
|
177 * |
|
178 * To cancel an outstanding request, call |
|
179 * RTelSubSessionBase::CancelAsyncRequest( ESatGetIcon ) |
|
180 * |
|
181 * @param aReqStatus This method is asynchronous. aReqStatus indicates when the operation has completed. |
|
182 * @param aRecordNumber EF record number of the icon to get. This must be a value from RSat::TIconId::iIdentifier. |
|
183 * @param aIconEf The TSY fills this with the icon EF record retrieved from the UICC, specified by aRecordNumber. |
|
184 * @capability None |
|
185 * @see RSat::TIconId |
|
186 * @see RSat::GetImageInstance() |
|
187 */ |
|
188 { |
|
189 __ASSERT_ALWAYS(iEtelSatPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
190 |
|
191 iEtelSatPtrHolder->iGetIcon = aRecordNumber; |
|
192 TPtr8& ptr1=iEtelSatPtrHolder->Set(ESlot1GetIcon,iEtelSatPtrHolder->iGetIcon); |
|
193 TPtr8& ptr2=iEtelSatPtrHolder->Set(ESlot2GetIcon,aIconEf); |
|
194 |
|
195 Get(ESatGetIcon,aReqStatus, ptr1, ptr2); |
|
196 } |
|
197 |
|
198 |
|
199 EXPORT_C void RSat::GetImageInstance(TRequestStatus& aReqStatus, const TDesC8& aInstanceInfo, TDes8& aInstance) const |
|
200 /** |
|
201 * This method retrieves an icon's image data from the UICC. The data is |
|
202 * returned in aInstance. |
|
203 * |
|
204 * For colour images, you will also need to retrieve a Colour LookUp Table (CLUT). |
|
205 * Use RSat::GetClut() for this. |
|
206 * |
|
207 * Before calling this method, you must have called RSat::GetIcon() to retrieve |
|
208 * the icon's EF record. |
|
209 * |
|
210 * aInstanceInfo is a RSat::TInstanceInfoV3Pckg (a packaged |
|
211 * RSat::TInstanceInfoV3) containing details of the image you would |
|
212 * like to get. This includes the image's size. aInstance should be the size of the image. |
|
213 * |
|
214 * The EF record is described in ETSI TS 131 102; search for EFimg or "Contents |
|
215 * of files at the DFGRAPHICS level". The format of both image data and CLUT |
|
216 * is also described in ETSI TS 131 102; see Annex B. |
|
217 * |
|
218 * To cancel an outstanding request, call |
|
219 * RTelSubSessionBase::CancelAsyncRequest( ESatGetImageInstance ) |
|
220 * |
|
221 * @param aReqStatus This method is asynchronous. aReqStatus indicates when the operation has completed. |
|
222 * @param aInstanceInfo Specifies the instance number, |
|
223 * offset and length of the image to retrieve from EF. |
|
224 * @param aInstance The TSY fills this with the image instance EF specified by aInstanceInfo, retrieved from the UICC. |
|
225 * @capability None |
|
226 * @see RSat::TIconId |
|
227 * @see RSat::GetIcon() |
|
228 * @see RSat::TInstanceInfoV3 |
|
229 * @see RSat::TInstanceInfoV3Pckg |
|
230 */ |
|
231 { |
|
232 SetAndGet(ESatGetImageInstance,aReqStatus, aInstanceInfo, aInstance); |
|
233 } |
|
234 |
|
235 |
|
236 EXPORT_C RSat::TInstanceInfoV2::TInstanceInfoV2() |
|
237 : TSatPCmdBase(), |
|
238 iInstanceNumber(0), |
|
239 iOffset(0), |
|
240 iLength(0) |
|
241 /** |
|
242 * Default constructor. |
|
243 */ |
|
244 { |
|
245 iExtensionId = RSat::KSatV2; |
|
246 } |
|
247 |
|
248 EXPORT_C RSat::TInstanceInfoV3::TInstanceInfoV3() |
|
249 : TInstanceInfoV2(), |
|
250 iCoding(KBasic), |
|
251 iImgWidth(0), |
|
252 iImgHeight(0), |
|
253 iFileId(0) |
|
254 /** |
|
255 * Default constructor. |
|
256 */ |
|
257 { |
|
258 iExtensionId = RSat::KSatV3; |
|
259 } |
|
260 |
|
261 EXPORT_C void RSat::GetClut(TRequestStatus& aReqStatus, TUint aInstanceNumber, TUint aOffset, TDes8& aClut) const |
|
262 /** |
|
263 * This method retrieves the CLUT (Colour Lookup Table) for an image instance designated by aInstanceNumber. |
|
264 * This is used when displaying icons; see RSat::GetImageInstance(). |
|
265 * |
|
266 * The format of the CLUT is described in ETSI TS 131 102; see Annex B. |
|
267 * |
|
268 * To cancel an outstanding request, call |
|
269 * RTelSubSessionBase::CancelAsyncRequest( ESatGetClut ) |
|
270 * |
|
271 * @param aReqStatus This method is asynchronous. aReqStatus indicates when the operation has completed. |
|
272 * @param aInstanceNumber Specifies which instance of an icon is to be retrieved. |
|
273 * @param aOffset Specifies the offset at which is located the clut within the image instance. |
|
274 * @param aClut The TSY fills this with the colour look up table specified by aInstance Number, retrieved from the UICC. |
|
275 * @capability None |
|
276 */ |
|
277 { |
|
278 __ASSERT_ALWAYS(iEtelSatPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
279 |
|
280 iEtelSatPtrHolder->iGetClut.iInstanceNumber= aInstanceNumber; |
|
281 iEtelSatPtrHolder->iGetClut.iOffset= aOffset; |
|
282 TPtr8& ptr1=iEtelSatPtrHolder->Set(ESlot1GetClut,iEtelSatPtrHolder->iGetClut); |
|
283 |
|
284 Get(ESatGetClut,aReqStatus, ptr1, aClut); |
|
285 } |
|
286 |
|
287 |
|
288 EXPORT_C void RSat::TerminalRsp(TRequestStatus& aReqStatus, TPCmd aPCmd, const TDesC8& aRsp) const |
|
289 /** |
|
290 * This method replies to a proactive command. |
|
291 * The reply is sent to the UICC. |
|
292 * This is a generic method which replies to every proactive command. |
|
293 * |
|
294 * Each type of proactive command requires a different response. There are classes |
|
295 * to implement the responses for the different commands. To respond to a command, create an instance |
|
296 * of the appropriate class, fill in the fields, and then package the object. Then pass |
|
297 * the package and the associated proactive command type to RSat::TerminalRsp(). |
|
298 * |
|
299 * @param aReqStatus This method is asynchronous. aReqStatus indicates when the operation has completed. |
|
300 * @param aPCmd The type of proactive command that you are responding to. |
|
301 * @param aRsp Packaged response object associated with the proactive command type. |
|
302 * @capability NetworkControl |
|
303 */ |
|
304 { |
|
305 __ASSERT_ALWAYS(iEtelSatPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
306 |
|
307 iEtelSatPtrHolder->iPCmd=aPCmd; |
|
308 TPtr8& ptr1=iEtelSatPtrHolder->Set(ESlotPCmd,iEtelSatPtrHolder->iPCmd); |
|
309 |
|
310 Set(ESatTerminalRsp,aReqStatus,ptr1,aRsp); |
|
311 } |
|
312 |
|
313 |
|
314 EXPORT_C RSat::TSatProfileV1::TSatProfileV1() |
|
315 : TSatBase(), |
|
316 iSatProfileByte1(0), |
|
317 iSatProfileByte2(0), |
|
318 iSatProfileByte3(0), |
|
319 iSatProfileByte4(0), |
|
320 iSatProfileByte5(0), |
|
321 iSatProfileByte6(0), |
|
322 iSatProfileByte7(0), |
|
323 iSatProfileByte8(0), |
|
324 iSatProfileByte9(0) |
|
325 /** |
|
326 * Default constructor. |
|
327 */ |
|
328 { |
|
329 iExtensionId=KSatV1; |
|
330 } |
|
331 |
|
332 EXPORT_C RSat::TSatProfileV2::TSatProfileV2() |
|
333 : TSatProfileV1(), iSatProfileByte10(0), iSatProfileByte11(0), iSatProfileByte12(0), |
|
334 iSatProfileByte13(0), iNumOfChannels(0), iSatProfileByte14(0), iScreenHeight(0), |
|
335 iSatProfileByte15(0), iScreenWidth (0), iSatProfileByte16(0), iWidthReduction(0), |
|
336 iSatProfileByte17(0), iSatProfileByte18(0), iTiaEiaProtoVersion(0) |
|
337 /** |
|
338 * Default constructor. |
|
339 */ |
|
340 { |
|
341 iExtensionId=KSatV2; |
|
342 } |
|
343 |
|
344 EXPORT_C RSat::TSatProfileV5::TSatProfileV5() |
|
345 : TSatProfileV2(), iSatProfileByte28(0), iSatProfileByte29(0) |
|
346 /** |
|
347 * Default constructor. |
|
348 */ |
|
349 { |
|
350 iExtensionId=KSatV5; |
|
351 } |
|
352 |
|
353 EXPORT_C RSat::TSatProfileV6::TSatProfileV6() |
|
354 : TSatProfileV5(), iSatProfileByte21(0), iSatProfileByte22(0), iSatProfileByte23(0), |
|
355 iSatProfileByte24(0), iSatProfileByte25(0) |
|
356 /** |
|
357 * Default constructor. |
|
358 */ |
|
359 { |
|
360 iExtensionId=KSatV6; |
|
361 } |
|
362 |
|
363 EXPORT_C TInt RSat::UsatClientReadyIndication() const |
|
364 /** |
|
365 * Indicates that you are ready to receive proactive commands from the UICC. Do not call this until: |
|
366 * |
|
367 * - You have sent your profile to the UICC (see RSat::GetMeSideSatProfile() ) |
|
368 * |
|
369 * - You have requested notification to receive proactive commands (see the |
|
370 * RSat::Notify.... functions). |
|
371 * |
|
372 * @return KErrNone |
|
373 * @capability NetworkControl |
|
374 */ |
|
375 { |
|
376 return Blank(ESatUsatClientReadyIndication); |
|
377 } |
|
378 |
|
379 EXPORT_C void RSat::GetMeSideSatProfile(TRequestStatus& aReqStatus, TDes8& aMeSimSatProfile) const |
|
380 /** |
|
381 * At the beginning of a ETelSat API session, you must tell the UICC what SAT |
|
382 * features the phone supports. Do this after creating and opening an RSat |
|
383 * session. This is a three-part process: |
|
384 * |
|
385 * - Firstly, call RSat::GetMeSideSatProfile(). This returns a profile describing |
|
386 * the SAT features that are supported by the phone's hardware and the TSY. These |
|
387 * features are not under the ETelSat API control; they happen without your |
|
388 * involvement. |
|
389 * |
|
390 * - Modify the profile to include the SAT features that you support. The profile is |
|
391 * a RSat::TSatProfileV1 in Symbian OS v6.1 and v7.0. Up to v8.1, it is a |
|
392 * RSat::TSatProfileV2. For Symbian OS v9.2, it is a RSat::TSatProfileV5. |
|
393 * For Symbian OS v9.4, it is a RSat::TSatProfileV6. In later versions of Symbian OS, check for updated |
|
394 * class (RSat::TSatProfileV7 etc). |
|
395 * |
|
396 * - Finally, send the profile to the UICC by calling RSat::ClientSatProfileIndication() |
|
397 * |
|
398 * Once you have told the UICC of the profile: |
|
399 * |
|
400 * - Firstly, request notification of proactive commands with the RSat::Notify... functions. |
|
401 * |
|
402 * - Finally call RSat::UsatClientReadyIndication() to tell the UICC you are ready for its proactive commands. |
|
403 * |
|
404 * @see RSat::UsatClientReadyIndication() |
|
405 * @see RSat::ClientSatProfileIndication() |
|
406 * @see RSat::TSatProfileV1 |
|
407 * @see RSat::TSatProfileV1Pckg |
|
408 * @see RSat::TSatProfileV2 |
|
409 * @see RSat::TSatProfileV2Pckg |
|
410 * @see RSat::TSatProfileV5 |
|
411 * @see RSat::TSatProfileV5Pckg |
|
412 * @see RSat::TSatProfileV6 |
|
413 * @see RSat::TSatProfileV6Pckg |
|
414 * |
|
415 * @param aReqStatus This method is asynchronous. aReqStatus indicates when the operation has completed. |
|
416 * @param aMeSimSatProfile The TSY fills this with the phone hardware and TSY's SAT profile, packaged in a RSat::TSatProfileV1Pckg or RSat::TSatProfileV2Pckg |
|
417 * @capability None |
|
418 */ |
|
419 { |
|
420 Get(ESatGetMeSideSatProfile,aReqStatus,aMeSimSatProfile); |
|
421 } |
|
422 |
|
423 |
|
424 EXPORT_C TInt RSat::ClientSatProfileIndication(const TDesC8& aClientSatProfile) const |
|
425 /** |
|
426 * At the beginning of a ETelSat API session, you must tell the UICC what SAT |
|
427 * features the phone supports. Do this after creating and opening an RSat |
|
428 * session. This is a three-part process: |
|
429 * |
|
430 * - Firstly, call RSat::GetMeSideSatProfile(). This returns a profile describing |
|
431 * the SAT features that are supported by the phone's hardware and the TSY. These |
|
432 * features are not under the ETelSat API control; they happen without your |
|
433 * involvement. |
|
434 * |
|
435 * - Modify the profile to include the SAT features that you support. The profile is |
|
436 * a RSat::TSatProfileV1 in Symbian OS v6.1 and v7.0. Up to v8.1, it is a |
|
437 * RSat::TSatProfileV2. For Symbian OS v9.2, it is a RSat::TSatProfileV5. |
|
438 * For Symbian OS v9.4, it is a RSat::TSatProfileV6. In later versions of Symbian OS, check for updated |
|
439 * class (RSat::TSatProfileV7 etc). |
|
440 * |
|
441 * - Finally, send the profile to the UICC by calling RSat::ClientSatProfileIndication() |
|
442 * |
|
443 * Once you have told the UICC of the profile: |
|
444 * |
|
445 * - Firstly, request notification of proactive commands with the RSat::Notify... functions. |
|
446 * |
|
447 * - Finally call RSat::UsatClientReadyIndication() to tell the UICC you are ready for its proactive commands. |
|
448 * |
|
449 * @see RSat::UsatClientReadyIndication() |
|
450 * @see RSat::GetMeSideSatProfile() |
|
451 * @see RSat::TSatProfileV1 |
|
452 * @see RSat::TSatProfileV1Pckg |
|
453 * @see RSat::TSatProfileV2 |
|
454 * @see RSat::TSatProfileV2Pckg |
|
455 * @see RSat::TSatProfileV5 |
|
456 * @see RSat::TSatProfileV5Pckg |
|
457 * @see RSat::TSatProfileV6 |
|
458 * @see RSat::TSatProfileV6Pckg |
|
459 * |
|
460 * @param aClientSatProfile Client SAT profile. A packaged RSat::TSatProfileVx class. See above for which version to use. |
|
461 * @capability NetworkControl |
|
462 * @capability WriteDeviceData |
|
463 * @return KErrNone on success, other system-wide error code otherwise. |
|
464 */ |
|
465 { |
|
466 return Set(ESatClientSatProfileIndication,aClientSatProfile); |
|
467 } |
|
468 |
|
469 EXPORT_C RSat::TMenuSelectionV1::TMenuSelectionV1() |
|
470 : TSatBase(), |
|
471 iItemId(0x00), |
|
472 iHelp(EHelpRequestNotSet) |
|
473 /** |
|
474 * Default constructor. |
|
475 */ |
|
476 { |
|
477 iExtensionId=KSatV1; |
|
478 iHelp=EHelpRequestNotSet; |
|
479 } |
|
480 |
|
481 EXPORT_C void RSat::MenuSelection(TRequestStatus& aReqStatus, const TDesC8& aSelection) const |
|
482 /** |
|
483 * Sends a MENU SELECTION envelope command to the UICC. This is related to a SET |
|
484 * UP MENU proactive command. SET UP MENU asks for a menu to be added to the |
|
485 * phone's menu system. If a user chooses an item from this menu, then inform the |
|
486 * UICC of the user's selection with RSat::MenuSelection(). |
|
487 * |
|
488 * @param aReqStatus This method is asynchronous. aReqStatus indicates when the operation has completed. |
|
489 * @param aSelection Describes the menu item that the user selected. |
|
490 * Pass a packaged version of the latest "TMenuSelection" class. For Symbian OS |
|
491 * versions up to and including v8.1a and 8.1b use RSat::TMenuSelectionV1Pckg, a |
|
492 * packaged RSat::TMenuSelectionV1. For later versions of Symbian OS, check for an |
|
493 * updated API (RSat::TMenuSelectionV2 etc). |
|
494 * |
|
495 * @capability NetworkControl |
|
496 * @capability ReadDeviceData |
|
497 * |
|
498 * @see RSat::TMenuSelectionV1 |
|
499 * @see RSat::NotifySetUpMenuPCmd() |
|
500 */ |
|
501 { |
|
502 Set(ESatMenuSelection,aReqStatus,aSelection); |
|
503 } |
|
504 |
|
505 EXPORT_C RSat::TCallControlV1::TCallControlV1() |
|
506 : TSatBase(), |
|
507 iType(ECcTypeNotSet), |
|
508 iCcp1(), |
|
509 iSubAddress(), |
|
510 iCcp2(), |
|
511 iDcs(0), |
|
512 iTypeOfNumber(ETypeOfNumberNotSet), |
|
513 iNumberPlan(ENumberingPlanNotSet), |
|
514 iBuf(), |
|
515 iResult(EControlResultNotSet), |
|
516 iValidity(EAlphaIdValidityNotSet), |
|
517 iBCRepeatIndicator(EBCAlternateMode) |
|
518 /** |
|
519 * Default constructor. |
|
520 */ |
|
521 { |
|
522 iExtensionId=KSatV1; |
|
523 iAlphaId.iStatus=EAlphaIdNotSet; |
|
524 } |
|
525 |
|
526 EXPORT_C void RSat::TCallControlV1::SetCallSetUpDetails(const TCallSetUpParams& aParams) |
|
527 /** |
|
528 * This method is used by the TSY to set the call set up details within the TCallControlV1 class |
|
529 * |
|
530 * This method sets iType to ECcAddress, to specify that the call control has transformed |
|
531 * a outstanding SET UP CALL, SEND SS or SEND USSD request into a new call set up request. |
|
532 * |
|
533 * @param aParams Call set up parameters. |
|
534 */ |
|
535 { |
|
536 iType=ECcAddress; |
|
537 iCcp1=aParams.iCcp1; |
|
538 iSubAddress=aParams.iSubAddress; |
|
539 iCcp2=aParams.iCcp2; |
|
540 iTypeOfNumber=aParams.iAddress.iTypeOfNumber; |
|
541 iNumberPlan=aParams.iAddress.iNumberPlan; |
|
542 iBuf=aParams.iAddress.iTelNumber; |
|
543 } |
|
544 |
|
545 EXPORT_C void RSat::TCallControlV1::SetSendSsDetails(const TSsString& aString) |
|
546 /** |
|
547 * This method is used by the TSY to set the SEND SS details within the TCallControlV1 class |
|
548 * |
|
549 * This method sets iType to ECcString, to specify that the call control has transformed |
|
550 * a outstanding SET UP CALL, SEND SS or SEND USSD request into a new SEND SS request. |
|
551 * |
|
552 * @param aString SS string details. |
|
553 */ |
|
554 { |
|
555 iType=ECcSsString; |
|
556 iTypeOfNumber=aString.iTypeOfNumber; |
|
557 iNumberPlan=aString.iNumberPlan; |
|
558 iBuf.Copy(aString.iSsString); //convert 8 bit into 16 bit data |
|
559 } |
|
560 |
|
561 EXPORT_C void RSat::TCallControlV1::SetSendUssdDetails(const TUssdString& aString) |
|
562 /** |
|
563 * This method is used by the TSY to set the SEND USSD details within the TCallControlV1 class |
|
564 * |
|
565 * This method sets iType to ECcUssdString, to specify that the call control has transformed |
|
566 * a outstanding SET UP CALL, SEND SS or SEND USSD request into a new SEND USSD request. |
|
567 * |
|
568 * @param aString USSD string details. |
|
569 */ |
|
570 { |
|
571 iType=ECcUssdString; |
|
572 iDcs=aString.iDcs; |
|
573 iBuf.Copy(aString.iUssdString); // convert 8 bit into 16 bit data |
|
574 } |
|
575 |
|
576 EXPORT_C void RSat::TCallControlV1::SetCcGeneralResult(TControlResult aResult) |
|
577 /** |
|
578 * This method is used by the TSY to set the general call control result, iResult. |
|
579 * |
|
580 * @param aResult General call control result. |
|
581 */ |
|
582 { |
|
583 iResult=aResult; |
|
584 } |
|
585 |
|
586 EXPORT_C void RSat::TCallControlV1::SetAlphaId(TAlphaIdValidity aValidity, TAlphaId& aAlphaId) |
|
587 /** |
|
588 * This method is used by the TSY to set the alpha identifier. |
|
589 * |
|
590 * @param aValidity Alpha Identifier validity. |
|
591 * @param aAlphaId Alpha Identifier. |
|
592 */ |
|
593 { |
|
594 iValidity=aValidity; |
|
595 iAlphaId=aAlphaId; |
|
596 } |
|
597 |
|
598 EXPORT_C void RSat::TCallControlV1::GetCallControlType(TCallControlType& aType) const |
|
599 /** |
|
600 * This method is used by the Client to get the call control type. |
|
601 * |
|
602 * @param aType Call control type (SET UP CALL, SEND SS or USSD). |
|
603 */ |
|
604 { |
|
605 aType=iType; |
|
606 } |
|
607 |
|
608 EXPORT_C void RSat::TCallControlV1::GetCcGeneralResult(TControlResult& aResult)const |
|
609 /** |
|
610 * This method is used by the Client to get the call control general result. |
|
611 * |
|
612 * @param aResult Call control general result. |
|
613 */ |
|
614 { |
|
615 aResult=iResult; |
|
616 } |
|
617 |
|
618 EXPORT_C TInt RSat::TCallControlV1::GetCallSetUpDetails(TCallSetUpParams& aParams) const |
|
619 /** |
|
620 * This method is used by the Client to get the call set up details. |
|
621 * If the call control type is not ECcAddress, the client should not use this method, |
|
622 * which will return KErrNotSupported |
|
623 * |
|
624 * @param aParams Call set up details. |
|
625 * @return KErrNotSupported returned if the type of call control is not a SET UP CALL. |
|
626 * Otherwise, KErrNone returned. |
|
627 */ |
|
628 { |
|
629 if (iType!=ECcAddress) |
|
630 return KErrNotSupported; |
|
631 else |
|
632 { |
|
633 aParams.iCcp1=iCcp1; |
|
634 aParams.iSubAddress=iSubAddress; |
|
635 aParams.iCcp2=iCcp2; |
|
636 aParams.iAddress.iTypeOfNumber=iTypeOfNumber; |
|
637 aParams.iAddress.iNumberPlan=iNumberPlan; |
|
638 aParams.iAddress.iTelNumber=iBuf; |
|
639 return KErrNone; |
|
640 } |
|
641 } |
|
642 |
|
643 EXPORT_C TInt RSat::TCallControlV1::GetSendSsDetails(TSsString& aString) const |
|
644 /** |
|
645 * This method is used by the Client to get the SEND SS details. |
|
646 * If the call control type is not ECcSsString, the client should not use this method |
|
647 * which will returns KErrNotSupported. |
|
648 * |
|
649 * @param aString SS String details. |
|
650 * @return KErrNotSupported returned if the type of call control is not a SS String. |
|
651 * Otherwise, KErrNone returned. |
|
652 */ |
|
653 { |
|
654 if (iType!=ECcSsString) |
|
655 return KErrNotSupported; |
|
656 else |
|
657 { |
|
658 aString.iTypeOfNumber=iTypeOfNumber; |
|
659 aString.iNumberPlan=iNumberPlan; |
|
660 aString.iSsString.Copy(iBuf); // convert 16bit into 8bit data |
|
661 return KErrNone; |
|
662 } |
|
663 } |
|
664 |
|
665 EXPORT_C TInt RSat::TCallControlV1::GetSendUssdDetails(TUssdString& aString) const |
|
666 /** |
|
667 * This method is used by the Client to get the SEND USSD details. |
|
668 * If the call control type is not ECcUssdString, the client should not use this method |
|
669 * which will returns KErrNotSupported. |
|
670 * |
|
671 * @param aString USSD string details. |
|
672 * @return KErrNotSupported returned if the type of call control is not a SEND USSD. |
|
673 * Otherwise, KErrNone returned. |
|
674 */ |
|
675 { |
|
676 if (iType!=ECcUssdString) |
|
677 return KErrNotSupported; |
|
678 else |
|
679 { |
|
680 aString.iDcs=iDcs; |
|
681 aString.iUssdString.Copy(iBuf); // convert 16 bit into 8 bit data |
|
682 return KErrNone; |
|
683 } |
|
684 } |
|
685 |
|
686 EXPORT_C void RSat::TCallControlV1::GetAlphaId(TAlphaIdValidity& aValidity, TAlphaId& aAlphaId) const |
|
687 /** |
|
688 * This method returns the Alpha Identifier provided by the UICC for user display. |
|
689 * |
|
690 * @param aValidity Alpha identifier validity. |
|
691 * @param aAlphaId Alpha identifier. |
|
692 */ |
|
693 { |
|
694 aValidity=iValidity; |
|
695 aAlphaId=iAlphaId; |
|
696 } |
|
697 |
|
698 EXPORT_C void RSat::TCallControlV1::SetBCRepeatIndicator(const TBCRepeatIndicator& aBCRepeatIndicator) |
|
699 /** |
|
700 * This method returns the BC Repeat Indicator |
|
701 * |
|
702 * @param aBCRepeatIndicator Bearer Capability Repeat Indicator |
|
703 * |
|
704 */ |
|
705 { |
|
706 iBCRepeatIndicator=aBCRepeatIndicator; |
|
707 } |
|
708 |
|
709 EXPORT_C void RSat::TCallControlV1::GetBCRepeatIndicator(TBCRepeatIndicator& aBCRepeatIndicator) const |
|
710 /** |
|
711 * This method returns the Bearer Capability Repeat Indicator |
|
712 * |
|
713 * @param aBCRepeatIndicator Bearer Capability Repeat Indicator. |
|
714 */ |
|
715 { |
|
716 aBCRepeatIndicator = iBCRepeatIndicator; |
|
717 } |
|
718 |
|
719 |
|
720 EXPORT_C RSat::TCallControlV2::TCallControlV2() |
|
721 : TCallControlV1(), |
|
722 iCallName(), |
|
723 iNewActionOriginator(EActionOriginatorNotSet) |
|
724 /** |
|
725 * Default constructor. |
|
726 */ |
|
727 { |
|
728 iExtensionId=KSatV2; |
|
729 } |
|
730 |
|
731 EXPORT_C void RSat::TCallControlV2::SetCallName(const TName& aName) |
|
732 /** |
|
733 * This method is used by the TSY to set the call name details within the TCallControlV2 class |
|
734 * |
|
735 * @param aName Call name |
|
736 */ |
|
737 { |
|
738 iCallName = aName; |
|
739 } |
|
740 |
|
741 EXPORT_C void RSat::TCallControlV2::SetActionOriginator(const TActionOriginator aOriginator) |
|
742 /** |
|
743 * This method is used by the TSY to set the Call Originator details within the TCallControlV2 class |
|
744 * |
|
745 * @param aOriginator Call originator |
|
746 */ |
|
747 { |
|
748 iNewActionOriginator = aOriginator; |
|
749 } |
|
750 |
|
751 EXPORT_C void RSat::TCallControlV2::GetCallName(TName& aName) const |
|
752 /** |
|
753 * This method returns the call name. |
|
754 * |
|
755 * @param aName Call Name |
|
756 */ |
|
757 { |
|
758 aName = iCallName; |
|
759 } |
|
760 |
|
761 EXPORT_C void RSat::TCallControlV2::GetActionOriginator(TActionOriginator& aOriginator) const |
|
762 /** |
|
763 * This method returns the action originator. |
|
764 * |
|
765 * @param aOriginator Call originator |
|
766 */ |
|
767 { |
|
768 aOriginator = iNewActionOriginator; |
|
769 } |
|
770 |
|
771 EXPORT_C void RSat::NotifyCallControlRequest(TRequestStatus& aReqStatus, TDes8& aCallControlDetails ) const |
|
772 /** |
|
773 * In SAT-enabled phones, the UICC can request control of outgoing calls or activation of PDP Contexts. |
|
774 * The phone's TSY passes the call's parameters to the UICC, such as the telephone number, or in the case of PDP activation |
|
775 * PDP parameters. The UICC will allow the call (activation of the context), disallow the call (activation of the context), or it will modify the call's (pdp context activation) parameters. |
|
776 * This happens without the RSat client's involvement. However, RSat clients can be |
|
777 * informed when call control has taken place the by calling |
|
778 * RSat::NotifyCallControlRequest(). |
|
779 * |
|
780 * This notification completes when a client requests a call set up or PDP contedxt activation which is |
|
781 * modified by the UICC. |
|
782 * |
|
783 * You may receive this notification following your attempt to send an SMS in |
|
784 * response to a SET UP CALL proactive command (call) or OPEN CHANNEL proactive command (PDP context). |
|
785 * You may also receive it when another application attempts to set up a call or activate PDP context. |
|
786 * |
|
787 * Upon completion, for a call, aCallControlDetails contains the details of the new action to |
|
788 * be performed, instead of the original call set up; for a PDP context activation, aPdpParameters contain the parameters |
|
789 * that shall be utilized instead or original PDP activation request. |
|
790 * |
|
791 * @param aReqStatus This method is asynchronous. aReqStatus indicates when the operation has completed. |
|
792 * @param aCallControlDetails TCallControlV1 packaged into a descriptor, TCallControlV1Pckg. |
|
793 * starting with version 9.2, in the case of PDP context activation TCallControlV3 packaged into a descriptor, TCallControlV3Pckg. |
|
794 * @capability NetworkControl |
|
795 * @capability ReadDeviceData |
|
796 */ |
|
797 { |
|
798 Get(ESatNotifyCallControlRequest,aReqStatus,aCallControlDetails); |
|
799 } |
|
800 |
|
801 |
|
802 EXPORT_C RSat::TMoSmControlV1::TMoSmControlV1() |
|
803 : TSatBase(), |
|
804 iResult(EControlResultNotSet) |
|
805 /** |
|
806 * Default constructor. |
|
807 */ |
|
808 { |
|
809 iExtensionId=KSatV1; |
|
810 iAlphaId.iStatus=EAlphaIdNotSet; |
|
811 iRpAddress.iTypeOfNumber=ETypeOfNumberNotSet; |
|
812 iRpAddress.iNumberPlan=ENumberingPlanNotSet; |
|
813 iTpAddress.iTypeOfNumber=ETypeOfNumberNotSet; |
|
814 iTpAddress.iNumberPlan=ENumberingPlanNotSet; |
|
815 |
|
816 } |
|
817 |
|
818 EXPORT_C void RSat::NotifyMoSmControlRequest(TRequestStatus& aReqStatus,TDes8& aMoSmDetails) const |
|
819 /** |
|
820 * In SAT-enabled phones on GSM/WCDMA networks, the UICC can control who SMS |
|
821 * messages are sent to. The phone's TSY passes the UICC the SMS's parameters, |
|
822 * such as the telephone number of the recipient. The UICC will allow the |
|
823 * message, disallow the message, or it modify the delivery parameters. This |
|
824 * happens without the RSat client's involvement. However, RSat clients can be |
|
825 * informed when SMS control has taken place the by calling |
|
826 * RSat::NotifyMoSmControlRequest(). |
|
827 * |
|
828 * This notification completes when a client tries to send an SMS which is then |
|
829 * modified by SMS control. |
|
830 * |
|
831 * You may receive this notification following your attempt to send an SMS in |
|
832 * response to a SEND SHORT MESSAGE proactive command. You may also receive it |
|
833 * when another application attempts to send an SMS. |
|
834 * |
|
835 * Upon completion, aMoSmDetails contains the details of the new SMS operation to |
|
836 * be performed instead of the original request. |
|
837 * |
|
838 * @param aReqStatus This method is asynchronous. aReqStatus indicates when the operation has completed. |
|
839 * @param aMoSmDetails TMoSmControlV1 packaged into a descriptor, TMoSmControlV1Pckg. |
|
840 * @capability NetworkControl |
|
841 * @capability ReadDeviceData |
|
842 */ |
|
843 { |
|
844 Get(ESatNotifyMoSmControlRequest,aReqStatus,aMoSmDetails); |
|
845 } |
|
846 |
|
847 EXPORT_C RSat::TTimerExpirationV3::TTimerExpirationV3() |
|
848 : TSatBase() |
|
849 /** |
|
850 * Default constructor. |
|
851 */ |
|
852 { |
|
853 iExtensionId=KSatV3; |
|
854 } |
|
855 |
|
856 EXPORT_C void RSat::NotifyTimerExpiration(TRequestStatus& aReqStatus,TDes8& aTimerExpiration) const |
|
857 /** |
|
858 * The phone provides timers for the UICC. Using the TIMER MANAGEMENT proactive |
|
859 * command, the UICC can start, stop and read the current value of a timer. |
|
860 * Receive these commands with RSat::NotifyTimerMgmtPCmd(), then start, stop or |
|
861 * read a timer as requested. Timers are started with a particular value. When |
|
862 * this counts down to zero, send a TIMER EXPIRATION envelope command to the UICC |
|
863 * with RSat::NotifyTimerExpiration(). |
|
864 * |
|
865 * Each TIMER MANAGEMENT proactive command includes an ID that identifiers the |
|
866 * timer. You must manage up to 8 timer for the UICC. When a timer expires, pass |
|
867 * the ID of the timer to the UICC in aTimerExpiration. |
|
868 * |
|
869 * Support for this command is only available from v7.0s of Symbian OS onwards. |
|
870 * |
|
871 * @see RSat::NotifyTimerMgmtPCmd() |
|
872 * @see RSat::TTimerExpirationV3 |
|
873 * |
|
874 * @param aReqStatus This method is asynchronous. aReqStatus indicates when the operation has completed. |
|
875 * @param aTimerExpiration Information about the timer that has expired. A RSat::TTimerExpirationV3Pckg, a packaged RSat::TTimerExpirationV3. |
|
876 * @capability None |
|
877 */ |
|
878 { |
|
879 Get(ESatNotifyTimerExpiration, aReqStatus,aTimerExpiration); |
|
880 } |
|
881 |
|
882 EXPORT_C RSat::TSmsPpDownloadV3::TSmsPpDownloadV3() |
|
883 : TSatBase(), |
|
884 iPdu() |
|
885 /** |
|
886 * Default constructor. |
|
887 */ |
|
888 { |
|
889 iExtensionId=KSatV3; |
|
890 } |
|
891 |
|
892 EXPORT_C void RSat::NotifySmsPpDownload(TRequestStatus& aReqStatus,TDes8& aSmsPpDownload) const |
|
893 /** |
|
894 * This notification completes when a client (not necessarily the SAT client) |
|
895 * requests a SMS-PP data download. Upon completion the envelope command details will |
|
896 * be returned in a RSar::TSmsPpDownloadV3Pckg, a packaged version of the RSat::TSmsPpDownloadV3 class in the aSmsPpDownload. |
|
897 * |
|
898 * @param aReqStatus TRequestStatus result code after the asynchronous call completes |
|
899 * @param aSmsPpDownload RSat::TSmsPpDownloadV3 packaged in a RSat::TSmsPpDownloadV3Pckg |
|
900 * @capability NetworkControl |
|
901 * @capability ReadUserData |
|
902 */ |
|
903 { |
|
904 Get(ESatNotifySmsPpDownload, aReqStatus,aSmsPpDownload); |
|
905 } |
|
906 |
|
907 EXPORT_C RSat::TCbDownloadV3::TCbDownloadV3() |
|
908 : TSatBase(), |
|
909 iPdu() |
|
910 /** |
|
911 * Default constructor. |
|
912 */ |
|
913 { |
|
914 iExtensionId=KSatV3; |
|
915 } |
|
916 |
|
917 EXPORT_C void RSat::NotifyCbDownload(TRequestStatus& aReqStatus,TDes8& aCbDownload) const |
|
918 /** |
|
919 * This notification completes when a client (not necessarily the SAT client) |
|
920 * requests a Cell Broadcast data download. Upon completion the envelope command |
|
921 * details will be returned in a RSat::TCbDownloadV3Pckg, a packaged version of the RSat::TCbDownloadV3 class in the aCbDownload. |
|
922 * |
|
923 * @param aReqStatus TRequestStatus result code after the asynchronous call completes |
|
924 * @param aCbDownload An RSat:: TCbDownloadV3 packaged in a RSat::TCbDownloadV3Pckg |
|
925 * @capability NetworkControl |
|
926 * @capability ReadUserData |
|
927 */ |
|
928 { |
|
929 Get(ESatNotifyCbDownload, aReqStatus,aCbDownload); |
|
930 } |
|
931 |
|
932 EXPORT_C RSat::TEventDownloadBaseV2::TEventDownloadBaseV2() |
|
933 : TSatBase(), |
|
934 iDataAvailable(EFalse) |
|
935 /** |
|
936 * Default constructor. |
|
937 */ |
|
938 { |
|
939 iExtensionId = KSatV2; |
|
940 } |
|
941 |
|
942 EXPORT_C RSat::TCardReaderStatusEventV2::TCardReaderStatusEventV2() |
|
943 : TEventDownloadBaseV2(), |
|
944 iCardReaderStatus(0) |
|
945 /** |
|
946 * Default constructor. |
|
947 */ |
|
948 { |
|
949 iDataAvailable = ETrue; |
|
950 } |
|
951 |
|
952 EXPORT_C RSat::TLanguageSelectionEventV2::TLanguageSelectionEventV2() |
|
953 : TEventDownloadBaseV2(), |
|
954 iLanguage(0) |
|
955 /** |
|
956 * Default constructor. |
|
957 */ |
|
958 { |
|
959 iDataAvailable = ETrue; |
|
960 } |
|
961 |
|
962 EXPORT_C RSat::TChannelStatusEventV2::TChannelStatusEventV2() |
|
963 : TEventDownloadBaseV2(), |
|
964 iStatus() |
|
965 /** |
|
966 * Default constructor. |
|
967 */ |
|
968 { |
|
969 iDataAvailable = ETrue; |
|
970 } |
|
971 |
|
972 EXPORT_C RSat::TBrowserTerminationEventV2::TBrowserTerminationEventV2() |
|
973 : TEventDownloadBaseV2(), |
|
974 iCause(EUnknownCause) |
|
975 /** |
|
976 * Default constructor. |
|
977 */ |
|
978 { |
|
979 iDataAvailable = ETrue; |
|
980 } |
|
981 |
|
982 EXPORT_C RSat::TDataAvailableEventV2::TDataAvailableEventV2() |
|
983 : TEventDownloadBaseV2(), |
|
984 iStatus(), |
|
985 iLength(0) |
|
986 /** |
|
987 * Default constructor. |
|
988 */ |
|
989 { |
|
990 iDataAvailable = ETrue; |
|
991 } |
|
992 |
|
993 EXPORT_C RSat::TLocalConnectionEventV2::TLocalConnectionEventV2() |
|
994 : TEventDownloadBaseV2() |
|
995 /** |
|
996 * Default constructor. |
|
997 */ |
|
998 { |
|
999 iDataAvailable = ETrue; |
|
1000 iRecord.iBearerId=ELocalBearerIdNotSet; |
|
1001 iRecord.iServiceId=0; |
|
1002 iAddress.iCoding=ECodingNotSet; |
|
1003 } |
|
1004 |
|
1005 EXPORT_C RSat::TDisplayParamsEventV2::TDisplayParamsEventV2() |
|
1006 : TEventDownloadBaseV2(), |
|
1007 iSatProfileByte14(0), |
|
1008 iScreenHeight(0), |
|
1009 iSatProfileByte15(0), |
|
1010 iScreenWidth(0), |
|
1011 iSatProfileByte16(0), |
|
1012 iWidthReduction(0) |
|
1013 /** |
|
1014 * Default constructor. |
|
1015 */ |
|
1016 { |
|
1017 iDataAvailable = ETrue; |
|
1018 } |
|
1019 |
|
1020 EXPORT_C RSat::TNetworkSearchModeChangeEventV6::TNetworkSearchModeChangeEventV6() |
|
1021 : TEventDownloadBaseV2(), iNetworkSearchMode(EUnknown) |
|
1022 /** |
|
1023 * Default constructor. |
|
1024 */ |
|
1025 { |
|
1026 iDataAvailable = ETrue; |
|
1027 } |
|
1028 |
|
1029 EXPORT_C RSat::TBrowsingStatusEventV6::TBrowsingStatusEventV6() |
|
1030 : TEventDownloadBaseV2(),iBrowserStatus(0) |
|
1031 /** |
|
1032 * Default constructor. |
|
1033 */ |
|
1034 { |
|
1035 iDataAvailable = ETrue; |
|
1036 } |
|
1037 |
|
1038 EXPORT_C RSat::TFramesInformationChangedEventV6::TFramesInformationChangedEventV6() |
|
1039 : TEventDownloadBaseV2() |
|
1040 /** |
|
1041 * Default constructor. |
|
1042 */ |
|
1043 { |
|
1044 iDataAvailable = ETrue; |
|
1045 iFramesInformation.iFrameId=0; |
|
1046 } |
|
1047 |
|
1048 EXPORT_C void RSat::EventDownload(TRequestStatus& aReqStatus, TEventList aSingleEvent, const TDesC8& aEventInfo) const |
|
1049 /** |
|
1050 * The SET UP EVENT LIST proactive command gives the phone a list of events that may occur |
|
1051 * to the phone. The event list may include a change of access technology, user |
|
1052 * action, browser termination and more. You must inform the UICC when an event |
|
1053 * on the list occurs by calling RSat::EventDownload(). If the event is not on the |
|
1054 * list then you do not need to notify the UICC. |
|
1055 * |
|
1056 * See RSat::NotifySetUpEventListPCmd() for more information. |
|
1057 * |
|
1058 * @param aReqStatus This method is asynchronous. aReqStatus indicates when the operation has completed. |
|
1059 * @param aSingleEvent Name of the event that has occurred. |
|
1060 * @param aEventInfo Additional information available about aSingleEvent. |
|
1061 * |
|
1062 * @capability NetworkControl |
|
1063 * @capability WriteDeviceData |
|
1064 * |
|
1065 * @see RSat::NotifySetUpEventListPCmd() |
|
1066 * @see RSat::TEventList |
|
1067 */ |
|
1068 { |
|
1069 __ASSERT_ALWAYS(iEtelSatPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
1070 |
|
1071 iEtelSatPtrHolder->iSingleEvent=aSingleEvent; |
|
1072 TPtrC8& ptr1=iEtelSatPtrHolder->SetC(ESlotSingleEvent,iEtelSatPtrHolder->iSingleEvent); |
|
1073 |
|
1074 Set(ESatEventDownload,aReqStatus,ptr1,aEventInfo); |
|
1075 } |
|
1076 |
|
1077 |
|
1078 EXPORT_C RSat::TDisplayTextV1::TDisplayTextV1() |
|
1079 : TSatPCmdBase(), |
|
1080 iPriority(EDisplayPriorityNotSet), |
|
1081 iClearScreenTrigger(EClearScreenTriggerNotSet), |
|
1082 iText(), |
|
1083 iImmediateRsp(EImmediateRspNotSet) |
|
1084 /** |
|
1085 * Default constructor. |
|
1086 */ |
|
1087 { |
|
1088 iExtensionId=KSatV1; |
|
1089 iIconId.iQualifier=EIconQualifierNotSet; |
|
1090 iIconId.iIdentifier=0; |
|
1091 } |
|
1092 |
|
1093 EXPORT_C RSat::TDisplayTextV2::TDisplayTextV2() |
|
1094 : TDisplayTextV1() |
|
1095 /** |
|
1096 * Default constructor. |
|
1097 */ |
|
1098 { |
|
1099 iExtensionId=KSatV2; |
|
1100 iDuration.iTimeUnit=ETimeUnitNotSet; |
|
1101 iDuration.iNumOfUnits=0; |
|
1102 } |
|
1103 |
|
1104 EXPORT_C RSat::TDisplayTextV5::TDisplayTextV5() |
|
1105 : TDisplayTextV2() |
|
1106 /** |
|
1107 * Default constructor. |
|
1108 */ |
|
1109 { |
|
1110 iExtensionId=KSatV5; |
|
1111 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
1112 } |
|
1113 |
|
1114 EXPORT_C RSat::TDisplayTextV6::TDisplayTextV6() |
|
1115 : TDisplayTextV5(),iFrameId(0) |
|
1116 /** |
|
1117 * Default constructor. |
|
1118 */ |
|
1119 { |
|
1120 iExtensionId=KSatV6; |
|
1121 } |
|
1122 |
|
1123 EXPORT_C RSat::TDisplayTextRspV1::TDisplayTextRspV1() |
|
1124 : TSatPCmdBase(), |
|
1125 iGeneralResult(KPCmdResultNotSet), |
|
1126 iInfoType(0), |
|
1127 iAdditionalInfo() |
|
1128 /** |
|
1129 * Default constructor. |
|
1130 */ |
|
1131 { |
|
1132 iExtensionId=KSatV1; |
|
1133 } |
|
1134 |
|
1135 EXPORT_C void RSat::NotifyDisplayTextPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
1136 /** |
|
1137 * This method requests notification when a DISPLAY TEXT proactive command is sent |
|
1138 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
1139 * aReqStatus is completed. Unpack the command to examine its contents. |
|
1140 * |
|
1141 * The DISPLAY TEXT command instructs the terminal to display a text message, |
|
1142 * and/or an icon. The command is described fully in ETSI TS 102 223. Briefly, |
|
1143 * though, the command includes: |
|
1144 * |
|
1145 * - Text to display - RSat::TDisplayTextV1::iText |
|
1146 * - Icon to display - RSat::TDisplayTextV1::iIconId |
|
1147 * - Priority of icon/text - RSat::TDisplayTextV1::iPriority |
|
1148 * - Determines whether you respond to the UICC straight away or when the text/icon is removed |
|
1149 * from the screen - RSat::TDisplayTextV1::iImmediateRsp |
|
1150 * - Determines whether the text should be removed from the screen after a delay or after user |
|
1151 * action. - RSat::TDisplayTextV1::iClearScreenTrigger |
|
1152 * - Length of delay to display text - RSat::TDisplayTextV2::iDuration (Symbian OS v7.0s and later.) |
|
1153 * - Text attributes of the text string to display - RSat::TDisplayTextV5::iTextAttribute (Symbian OS v9.2 or later) |
|
1154 * |
|
1155 * Once you have dealt with the command, you must give your response to the |
|
1156 * DISPLAY TEXT command. In Symbian OS versions up to and including 8.1a & 8.1b, |
|
1157 * pass RSat::TerminalRsp() a RSat::TDisplayTextRspV1Pckg (a packaged |
|
1158 * RSat::TDisplayTextRspV1). For later versions of Symbian OS, check for an updated API |
|
1159 * (RSat::TDisplayTextRspV2 etc). |
|
1160 * |
|
1161 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
1162 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
1163 * command. aPCmd must be a packaged version of the latest "TDisplayText" class. |
|
1164 * For Symbian OS 7.0s, 8.0 and 8.1 use RSat::TDisplayTextV2Pckg, a packaged |
|
1165 * RSat::TDisplayTextV2. Use RSat::TDisplayTextV1 with older versions of |
|
1166 * Symbian OS. For Symbian OS version 9.2, use RSat::TDisplayTextV5Pckg. |
|
1167 * For Symbian OS version 9.4, use RSat::TDisplayTextV6Pckg. |
|
1168 * For later versions of Symbian OS, check for an updated API |
|
1169 * (RSat::TDisplayTextV7 etc). |
|
1170 * |
|
1171 * @see RSat::TDisplayTextV1 |
|
1172 * @see RSat::TDisplayTextV2 |
|
1173 * @see RSat::TDisplayTextV5 |
|
1174 * @see RSat::TDisplayTextV6 |
|
1175 * @see RSat::TDisplayTextRspV1 |
|
1176 * |
|
1177 * @capability ReadDeviceData |
|
1178 */ |
|
1179 { |
|
1180 Get(ESatNotifyDisplayTextPCmd,aReqStatus,aPCmd); |
|
1181 } |
|
1182 |
|
1183 EXPORT_C RSat::TGetInkeyV1::TGetInkeyV1() |
|
1184 : TSatPCmdBase(), |
|
1185 iRspFormat(EGetInkeyRspFormatNotSet), |
|
1186 iText(), |
|
1187 iHelp(EHelpNotSet) |
|
1188 /** |
|
1189 * Default constructor. |
|
1190 */ |
|
1191 { |
|
1192 iExtensionId=KSatV1; |
|
1193 iIconId.iQualifier=EIconQualifierNotSet; |
|
1194 iIconId.iIdentifier=0; |
|
1195 } |
|
1196 |
|
1197 EXPORT_C RSat::TGetInkeyV2::TGetInkeyV2() |
|
1198 : TGetInkeyV1(), |
|
1199 iMode(EGetInkeyRspModeNotSet) |
|
1200 /** |
|
1201 * Default constructor. |
|
1202 */ |
|
1203 { |
|
1204 iExtensionId=KSatV2; |
|
1205 iDuration.iTimeUnit=ETimeUnitNotSet; |
|
1206 iDuration.iNumOfUnits=0; |
|
1207 } |
|
1208 |
|
1209 EXPORT_C RSat::TGetInkeyV5::TGetInkeyV5() |
|
1210 : TGetInkeyV2() |
|
1211 /** |
|
1212 * Default constructor. |
|
1213 */ |
|
1214 { |
|
1215 iExtensionId=KSatV5; |
|
1216 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
1217 } |
|
1218 |
|
1219 EXPORT_C RSat::TGetInkeyV6::TGetInkeyV6() |
|
1220 : TGetInkeyV5(),iFrameId(0) |
|
1221 /** |
|
1222 * Default constructor. |
|
1223 */ |
|
1224 { |
|
1225 iExtensionId=KSatV6; |
|
1226 } |
|
1227 |
|
1228 EXPORT_C RSat::TGetInkeyRspV1::TGetInkeyRspV1() |
|
1229 : TSatPCmdBase(), |
|
1230 iGeneralResult(KPCmdResultNotSet), |
|
1231 iInfoType(0), |
|
1232 iRspFormat(EGetInkeyRspFormatNotSet), |
|
1233 iAdditionalInfo() |
|
1234 /** |
|
1235 * Default constructor. |
|
1236 */ |
|
1237 { |
|
1238 iExtensionId=KSatV1; |
|
1239 } |
|
1240 |
|
1241 EXPORT_C RSat::TGetInkeyRspV2::TGetInkeyRspV2() |
|
1242 : TGetInkeyRspV1() |
|
1243 /** |
|
1244 * Default constructor. |
|
1245 */ |
|
1246 { |
|
1247 iExtensionId=KSatV2; |
|
1248 iDuration.iTimeUnit=ETimeUnitNotSet; |
|
1249 iDuration.iNumOfUnits=0; |
|
1250 } |
|
1251 |
|
1252 EXPORT_C void RSat::NotifyGetInkeyPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
1253 /** |
|
1254 * This method requests notification when a GET INKEY proactive command is sent by |
|
1255 * the UICC. When the request completes, the command is placed into aPCmd and the |
|
1256 * aReqStatus is completed. Unpack the command to |
|
1257 * examine its contents. |
|
1258 * |
|
1259 * The GET INKEY command instructs you to display text and/or an icon and to |
|
1260 * expect the user to enter a single character. The command states the required |
|
1261 * response: |
|
1262 * |
|
1263 * - Get a digit (0-9, *, #, and +) from the user. |
|
1264 * - Get a character from the user from the SMS alphabet. |
|
1265 * - Get a character from the user from the UCS2 alphabet. |
|
1266 * - Get a Yes or No decision from the user. |
|
1267 * |
|
1268 * The response entered by the user shall be passed back to the UICC. The command |
|
1269 * is described fully in ETSI TS 102 223. Briefly, though, the command includes: |
|
1270 * |
|
1271 * - Text to display - RSat::TGetInkeyV1::iText |
|
1272 * - Icon to display - RSat::TGetInkeyV1::iIconId |
|
1273 * - Response required - RSat::TGetInkeyV1::iRspFormat |
|
1274 * - Determines whether help is available - RSat::TGetInkeyV1::iHelp |
|
1275 * - Determines how long should you wait for the user to respond. - |
|
1276 * RSat::TGetInkeyV2::iDuration (Symbian OS v7.0s and later.) |
|
1277 * - Determines whether the user can alter/confirm their choice. - |
|
1278 * RSat::TGetInkeyV2::iMode (Symbian OS v7.0s and later.) |
|
1279 * - Text attributes of text contained in iText - RSat::TGetInkeyV5::iTextAttribute (Symbian OS v9.2 or later) |
|
1280 * |
|
1281 * Once you have dealt with the command, you must give your response to the GET |
|
1282 * INKEY command. For Symbian OS v6.1 or v7.0 pass RSat::TerminalRsp() a |
|
1283 * RSat::TGetInkeyRspV1Pckg (a packaged TGetInkeyRspV1). For versions up to and |
|
1284 * included v8.1a and v8.1b use RSat::TGetInkeyRspV2Pckg (a packaged |
|
1285 * RSat::TGetInkeyRspV2). For later versions of Symbian OS, check for an updated API |
|
1286 * (RSat::TGetInkeyRspV3 etc). |
|
1287 * |
|
1288 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
1289 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
1290 * command. aPCmd must be a packaged version of the latest "TGetInkey" class. |
|
1291 * For Symbian OS 7.0s, 8.0 and 8.1 use RSat::TGetInkeyV2Pckg, a packaged |
|
1292 * RSat::TGetInkeyV2. For Symbian OS version 9.2, use RSat::TDisplayTextV5Pckg. |
|
1293 * Use RSat::TGetInkeyV1 with older versions of Symbian OS. For Symbian OS version 9.4, use |
|
1294 * RSat::TDisplayTextV6Pckg.a packaged RSat::TGetInkeyV6. For later versions of Symbian OS, check |
|
1295 * for an updated API(RSat::TGetInkeyV7 etc). |
|
1296 * |
|
1297 * @see RSat::TGetInkeyV1 |
|
1298 * @see RSat::TGetInkeyV2 |
|
1299 * @see RSat::TGetInkeyV5 |
|
1300 * @see RSat::TGetInkeyV6 |
|
1301 * @see RSat::TGetInkeyRspV1 |
|
1302 * @see RSat::TGetInkeyRspV2 |
|
1303 * |
|
1304 * @capability None |
|
1305 */ |
|
1306 { |
|
1307 Get(ESatNotifyGetInkeyPCmd,aReqStatus,aPCmd); |
|
1308 } |
|
1309 |
|
1310 |
|
1311 EXPORT_C RSat::TGetInputV1::TGetInputV1() |
|
1312 : TSatPCmdBase(), |
|
1313 iInputDisplayOption(EInputDisplayOptionNotSet), |
|
1314 iRspFormat(EGetInputRspFormatNotSet), |
|
1315 iText(), |
|
1316 iDefaultText(), |
|
1317 iHelp(EHelpNotSet) |
|
1318 /** |
|
1319 * Default constructor. |
|
1320 */ |
|
1321 { |
|
1322 iExtensionId=KSatV1; |
|
1323 iIconId.iQualifier=EIconQualifierNotSet; |
|
1324 iIconId.iIdentifier=0; |
|
1325 iRspLength.iMinRspLength=0; |
|
1326 iRspLength.iMaxRspLength=0; |
|
1327 } |
|
1328 |
|
1329 EXPORT_C RSat::TGetInputV5::TGetInputV5() |
|
1330 : TGetInputV1() |
|
1331 /** |
|
1332 * Default constructor. |
|
1333 */ |
|
1334 { |
|
1335 iExtensionId=KSatV5; |
|
1336 iTextAttribute.iStatus=ETextAttributeNotSet; |
|
1337 } |
|
1338 |
|
1339 EXPORT_C RSat::TGetInputV6::TGetInputV6() |
|
1340 : TGetInputV5(),iFrameId(0) |
|
1341 /** |
|
1342 * Default constructor. |
|
1343 */ |
|
1344 { |
|
1345 iExtensionId=KSatV6; |
|
1346 } |
|
1347 |
|
1348 EXPORT_C RSat::TGetInputRspV1::TGetInputRspV1() |
|
1349 : TSatPCmdBase(), |
|
1350 iGeneralResult(KPCmdResultNotSet), |
|
1351 iInfoType(0), |
|
1352 iRspFormat(EGetInputRspFormatNotSet), |
|
1353 iAdditionalInfo() |
|
1354 /** |
|
1355 * Default constructor. |
|
1356 */ |
|
1357 { |
|
1358 iExtensionId=KSatV1; |
|
1359 } |
|
1360 |
|
1361 EXPORT_C void RSat::NotifyGetInputPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
1362 /** |
|
1363 * This method requests notification when a GET INPUT proactive command is sent |
|
1364 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
1365 * aReqStatus is competed. Unpack the command to examine its contents. |
|
1366 * |
|
1367 * The GET INPUT command instructs you to display text and/or an icon and to |
|
1368 * expect the user to enter a string. Pass the string back to the UICC. The |
|
1369 * command is described fully in ETSI TS 102 223. Briefly, though, the command |
|
1370 * includes: |
|
1371 * |
|
1372 * - Text to display - RSat::TGetInkeyV1::iText |
|
1373 * - Icon to display - RSat::TGetInkeyV1::iIconId |
|
1374 * - Determines wether help is available - RSat::TGetInkeyV1::iHelp |
|
1375 * - The required string format: digits only (0-9, *, # and +), characters from |
|
1376 * the SMS default alphabet, or characters from the UCS2 alphabet - |
|
1377 * RSat::TGetInputV1::iRspFormat |
|
1378 * - The maximum and minimum length of string - RSat::TGetInputV1::iRspLength |
|
1379 * - Determines whether the string can contain digits or the characters from |
|
1380 * SMS default alphabet. Also determines whether they are in a |
|
1381 * packed or unpacked format. - RSat::TGetInputV1::iRspFormat |
|
1382 * - Determines whether the user can see the characters they enter. RSat::TGetInputV1::iInputDisplayOption. |
|
1383 * - A default string can be provided. This field determines whether the |
|
1384 * user can edit this, or can only delete it and replace it with their own text - |
|
1385 * RSat::TGetInputV1::iDefaultText |
|
1386 * - Text attributes of text contained in iText - RSat::TGetInputV5::iTextAttribute (Symbian OS v9.2 or later) |
|
1387 * |
|
1388 * Once you have dealt with the command, you must give your response to the GET |
|
1389 * INPUT command. For Symbian OS versions up to and including v8.1a and v8.1b |
|
1390 * pass RSat::TerminalRsp() a RSat::TGetInputRspV1Pckg (a packaged |
|
1391 * RSat::TGetInputRspV1). For later versions of Symbian OS, check for an updated API |
|
1392 * (RSat::TGetInputRspV2 etc). |
|
1393 * |
|
1394 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
1395 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
1396 * command. aPCmd must be a packaged version of the latest "TGetInput" class. |
|
1397 * For Symbian OS versions up to and including v8.1a and 8.1b use |
|
1398 * RSat::TGetInkeyV1Pckg, a packaged RSat::TGetInkeyV1. |
|
1399 * For Symbian OS version 9.2, use RSat::TGetInkeyV5Pckg. |
|
1400 * For Symbian OS version 9.4, use RSat::TGetInkeyV6Pckg. |
|
1401 * For later versions of Symbian OS, check for an updated API |
|
1402 * (RSat::TGetInkeyV7 etc). |
|
1403 * |
|
1404 * @see RSat::TGetInputV1 |
|
1405 * @see RSat::TGetInputV5 |
|
1406 * @see RSat::TGetInputV6 |
|
1407 * @see RSat::TGetInputRspV1 |
|
1408 * |
|
1409 * @capability None |
|
1410 */ |
|
1411 { |
|
1412 Get(ESatNotifyGetInputPCmd,aReqStatus,aPCmd); |
|
1413 } |
|
1414 |
|
1415 EXPORT_C RSat::TPlayToneV1::TPlayToneV1() |
|
1416 : TSatPCmdBase(), |
|
1417 iTone(KToneNotSet) |
|
1418 /** |
|
1419 * Default constructor. |
|
1420 */ |
|
1421 { |
|
1422 iExtensionId=KSatV1; |
|
1423 iDuration.iTimeUnit=ETimeUnitNotSet; |
|
1424 iDuration.iNumOfUnits=0; |
|
1425 iAlphaId.iStatus=EAlphaIdNotSet; |
|
1426 } |
|
1427 |
|
1428 EXPORT_C RSat::TPlayToneV2::TPlayToneV2() |
|
1429 : TPlayToneV1() |
|
1430 /** |
|
1431 * Default constructor. |
|
1432 */ |
|
1433 { |
|
1434 iExtensionId=KSatV2; |
|
1435 iIconId.iQualifier=EIconQualifierNotSet; |
|
1436 iIconId.iIdentifier=0; |
|
1437 } |
|
1438 |
|
1439 EXPORT_C RSat::TPlayToneV5::TPlayToneV5() |
|
1440 : TPlayToneV2() |
|
1441 /** |
|
1442 * Default constructor. |
|
1443 */ |
|
1444 { |
|
1445 iExtensionId=KSatV5; |
|
1446 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
1447 } |
|
1448 |
|
1449 EXPORT_C RSat::TPlayToneV6::TPlayToneV6() |
|
1450 : TPlayToneV5(),iFrameId(0) |
|
1451 /** |
|
1452 * Default constructor. |
|
1453 */ |
|
1454 { |
|
1455 iExtensionId=KSatV6; |
|
1456 } |
|
1457 |
|
1458 EXPORT_C RSat::TPlayToneRspV1::TPlayToneRspV1() |
|
1459 : TSatPCmdBase(), |
|
1460 iGeneralResult(KPCmdResultNotSet), |
|
1461 iInfoType(0), |
|
1462 iAdditionalInfo() |
|
1463 /** |
|
1464 * Default constructor. |
|
1465 */ |
|
1466 { |
|
1467 iExtensionId=KSatV1; |
|
1468 } |
|
1469 |
|
1470 EXPORT_C void RSat::NotifyPlayTonePCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
1471 /** |
|
1472 * This method requests notification when a PLAY TONE proactive command is sent |
|
1473 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
1474 * aReqStatus is competed. Unpack the command to examine its contents. |
|
1475 * |
|
1476 * The PLAY TONE command instructs you to play a tone. The |
|
1477 * command is described fully in ETSI TS 102 223. Briefly, though, the command |
|
1478 * includes: |
|
1479 * |
|
1480 * - The tone to play - RSat::TPlayToneV1::iTone. |
|
1481 * - The duration of the tone - RSat::TPlayToneV1::iDuration. |
|
1482 * - An alpha identifier containing text to display - RSat::TPlayToneV1::iAlphaId. |
|
1483 * - An icon to display - RSat::TPlayToneV2::iIconId (Symbian OS v7.0s and later.) |
|
1484 * - Text attributes of text contained in iAlphaId - RSat::TPlayToneV5::iTextAttribute (Symbian OS v9.2 or later) |
|
1485 * |
|
1486 * See the description of the PLAY TONE command in ETSI TS 102 223 for the |
|
1487 * circumstances under which the alpha identifier's text should be displayed. |
|
1488 * Display the icon as described in RSat::TIconId. |
|
1489 * |
|
1490 * Once you have dealt with the command, you must give your response to the PLAY |
|
1491 * TONE command. For Symbian OS v6.1 or v7.0 pass RSat::TerminalRsp() a |
|
1492 * RSat::TPlayToneRspV1Pckg (a packaged TPlayToneRspV1). For versions up to and |
|
1493 * including v8.1a and v8.1b use RSat::TPlayToneRspV2Pckg (a packaged |
|
1494 * RSat::TPlayToneRspV2). |
|
1495 * For later versions of Symbian OS, check for an updated API |
|
1496 * (RSat::TPlayToneRspV3 etc). |
|
1497 * |
|
1498 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
1499 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
1500 * command. aPCmd must be a packaged version of the latest "TPlayTone" class. |
|
1501 * For Symbian OS versions up to and including v8.1a and 8.1b use |
|
1502 * RSat::TPlayToneV2Pckg, a packaged RSat::TPlayToneV2. |
|
1503 * For Symbian OS version 9.2, use RSat::TPlayToneV5Pckg. |
|
1504 * For Symbian OS version 9.4, use RSat::TPlayToneV6Pckg. |
|
1505 * For later versions of Symbian OS, check for an updated API |
|
1506 * (RSat::TPlayToneV7 etc). |
|
1507 * |
|
1508 * @see RSat::TPlayToneV1 |
|
1509 * @see RSat::TPlayToneV2 |
|
1510 * @see RSat::TPlayToneV5 |
|
1511 * @see RSat::TPlayToneV6 |
|
1512 * @see RSat::TPlayToneRspV1 |
|
1513 * |
|
1514 * @capability None |
|
1515 */ |
|
1516 { |
|
1517 Get(ESatNotifyPlayTonePCmd,aReqStatus,aPCmd); |
|
1518 } |
|
1519 |
|
1520 EXPORT_C RSat::TMenuItemBaseV1::TMenuItemBaseV1() |
|
1521 : TSatPCmdBase(), |
|
1522 iNumberOfItems(0), |
|
1523 iMenuContent(0), |
|
1524 iBuf() |
|
1525 /** |
|
1526 * Default constructor. |
|
1527 */ |
|
1528 { |
|
1529 iExtensionId=KSatV1; |
|
1530 } |
|
1531 |
|
1532 EXPORT_C RSat::TMenuItemBaseV5::TMenuItemBaseV5() |
|
1533 : TMenuItemBaseV1() |
|
1534 /** |
|
1535 * Default constructor. |
|
1536 */ |
|
1537 { |
|
1538 iExtensionId=KSatV5; |
|
1539 } |
|
1540 |
|
1541 EXPORT_C TBool RSat::TMenuItemBaseV1::IsRemoveMenu() const |
|
1542 /** |
|
1543 * This method returns ETrue if the SET UP MENU |
|
1544 * proactive command specifies that the existing SAT menu should be removed. |
|
1545 * |
|
1546 * This method returns EFalse if the SET UP MENU |
|
1547 * proactive command specifies a new SAT menu to be added to the phone's menu system. |
|
1548 * |
|
1549 * RSat::TMenuItemBaseV1 is used to contain both SET UP MENU and SELECT ITEM |
|
1550 * proactive commands. However, only call this method when handling a SET UP MENU command. |
|
1551 * |
|
1552 * @return ETrue if the existing SAT menu should be removed from the phone menu system. |
|
1553 * @return EFalse if a new SAT menu should be inserted in the phone menu system. |
|
1554 */ |
|
1555 { |
|
1556 if(iBuf.Length()==0) |
|
1557 return ETrue; |
|
1558 else |
|
1559 return EFalse; |
|
1560 } |
|
1561 |
|
1562 EXPORT_C TInt RSat::TMenuItemBaseV1::MenuContent() const |
|
1563 /** |
|
1564 * This method describes the menu's content by returning four flags. |
|
1565 * All menus contain a number of items which may also have an |
|
1566 * associated text attribute. |
|
1567 * Items are indicated by the RSat::KItems flag. |
|
1568 * The presence of text attribute information for these items is |
|
1569 * indicated by the RSat::KItemTextAttributes flag. |
|
1570 * |
|
1571 * In addition, every item in a menu may be accompanied by an icon |
|
1572 * (indicated by RSat::KItemIconIds) and/or a "next action indicator" |
|
1573 * (RSat::KItemNextActions). |
|
1574 * |
|
1575 * In a menu, either ALL menu items will have an icon, or NONE of |
|
1576 * them will. |
|
1577 * Similarly, all menu items in a menu will also have text |
|
1578 * attribute information or none of them will. |
|
1579 * Also, all menu items in a menu will have a "next action indicator" |
|
1580 * or none of them will. |
|
1581 * |
|
1582 * @return A combination of the flags RSat::KItems, RSat::KItemTextAttributes, RSat::KItemNextActions and RSat::KItemIconIds. |
|
1583 */ |
|
1584 { |
|
1585 return iMenuContent; |
|
1586 } |
|
1587 |
|
1588 EXPORT_C TUint RSat::TMenuItemBaseV1::NumberOfItems() const |
|
1589 /** |
|
1590 * This method returns the number of items in the menu. |
|
1591 * |
|
1592 * @return Protected data member, iNumberOfItems. |
|
1593 */ |
|
1594 { |
|
1595 return iNumberOfItems; |
|
1596 } |
|
1597 |
|
1598 TInt RSat::TMenuItemBaseV1::FindItemInBuffer(TUint aIndex, TInt& aOffset) const |
|
1599 /** |
|
1600 * This method finds the position of the item designated by aIndex in iBuf (which |
|
1601 * contains the menu item list) |
|
1602 * The position of the item is returned in aOffset. |
|
1603 * |
|
1604 * Actions and icons are optional, so the buffer could only be made of items or items&actions |
|
1605 * or items&icons or items&actions&icons. |
|
1606 * |
|
1607 * In all of the above mentioned menu structures, the items themselves can consist of |
|
1608 * only the item text string or the item text string and associated text attribute |
|
1609 * information. If an item with text attributes is added to the menu, then all subsequent |
|
1610 * items must also contain text attribute information. |
|
1611 * |
|
1612 * The structure of the buffer is as follows: |
|
1613 * |
|
1614 * <pre> |
|
1615 * |-------------|--------|------|-- |
|
1616 * | item header | itemid | item | item header |
|
1617 * |-------------|--------|------|-- |
|
1618 * |
|
1619 * |-------------|--------|------|---------------|--------|-- |
|
1620 * | item header | itemid | item | action header | action | item header |
|
1621 * |-------------|--------|------|---------------|--------|-- |
|
1622 * |
|
1623 * |-------------|--------|------|----------------|---------|-- |
|
1624 * | item header | itemid | item | icon ID header | icon ID | item header |
|
1625 * |-------------|--------|------|----------------|---------|-- |
|
1626 * |
|
1627 * |-------------|--------|------|---------------|--------|----------------|---------|-- |
|
1628 * | item header | itemid | item | action header | action | icon ID header | icon ID | item header |
|
1629 * |-------------|--------|------|---------------|--------|----------------|---------|-- |
|
1630 * |
|
1631 * In Symbian OS v9.2, support for these structures was added: |
|
1632 * |
|
1633 * |---------------------------------|--------|---------------------|------|------- |
|
1634 * | item with text attribute header | itemid | item text attribute | item | item with text attribute header |
|
1635 * |---------------------------------|--------|---------------------|------|------- |
|
1636 * |
|
1637 * |---------------------------------|--------|---------------------|------|---------------|--------|-- |
|
1638 * | item with text attribute header | itemid | item text attribute | item | action header | action | item with text attribute header |
|
1639 * |---------------------------------|--------|---------------------|------|---------------|--------|-- |
|
1640 * |
|
1641 * |---------------------------------|--------|---------------------|------|----------------|---------|-- |
|
1642 * | item with text attribute header | itemid | item text attribute | item | icon ID header | icon ID | item with text attribute header |
|
1643 * |---------------------------------|--------|---------------------|------|----------------|---------|-- |
|
1644 * |
|
1645 * |---------------------------------|--------|---------------------|------|---------------|--------|----------------|---------|-- |
|
1646 * | item with text attribute header | itemid | item text attribute | item | action header | action | icon ID header | icon ID | item with text attribute header |
|
1647 * |---------------------------------|--------|---------------------|------|---------------|--------|----------------|---------|-- |
|
1648 * |
|
1649 * </pre> |
|
1650 * |
|
1651 * The header is two bytes: |
|
1652 * - the first byte is a tag corresponding to the associated object (item, action or icon). |
|
1653 * - the second byte is the length of the associated object. |
|
1654 * |
|
1655 * @param aIndex Index of the item to be found in the buffer. |
|
1656 * @param aOffset Position of the item in iBuf (offset from the start of iBuf). |
|
1657 * @return KErrCorrupt returned if the buffer is corrupted & the item can't be found. |
|
1658 * Otherwise, KErrNone returned |
|
1659 */ |
|
1660 { |
|
1661 aOffset=0; |
|
1662 for (TUint i=1;i<aIndex;i++) |
|
1663 { |
|
1664 // All the header bits are in the upper byte of the TBuf16 only so |
|
1665 // compare the upper byte with item header. |
|
1666 if(((iBuf[aOffset]&KUpperByte)!=KItemHeader) && |
|
1667 ((iBuf[aOffset]&KUpperByte)!=KItemWithTextAttributeHeader)) |
|
1668 { |
|
1669 return KErrCorrupt; |
|
1670 } |
|
1671 else |
|
1672 { |
|
1673 // The length is in the lower byte of the item header. |
|
1674 // This length does NOT include the header length. |
|
1675 // Jump to next header. |
|
1676 aOffset+=KHeaderLength+(iBuf[aOffset]&KLowerByte); |
|
1677 |
|
1678 // Next header can be an action, jump past it, if so. |
|
1679 if((iBuf[aOffset]&KUpperByte)==KActionHeader) |
|
1680 { |
|
1681 aOffset=aOffset+KHeaderLength+KActionLength; |
|
1682 } |
|
1683 |
|
1684 // Next header can be an icon, jump past it, if so. |
|
1685 if ((iBuf[aOffset]&KUpperByte)==KIconIdHeader) |
|
1686 { |
|
1687 aOffset=aOffset+KHeaderLength+KIconIdLength; |
|
1688 } |
|
1689 } |
|
1690 } |
|
1691 return KErrNone; |
|
1692 } |
|
1693 |
|
1694 |
|
1695 EXPORT_C TInt RSat::TMenuItemBaseV1::GetItem(TUint aIndex, TItem& aItem) const |
|
1696 /** |
|
1697 * This method returns the menu item, designated by aIndex. |
|
1698 * |
|
1699 * @param aIndex Index of the menu item. Index range starts at 1. |
|
1700 * RSat::TMenuItemBaseV1::NumberOfItems() returns the total |
|
1701 * number of items. |
|
1702 * @param aItem Item from the menu, designated by aIndex. |
|
1703 * @return KErrNotFound returned if the menu contains no items or aIndex is out of range. |
|
1704 * KErrCorrupt returned if the buffer is corrupted and the item can't be found. |
|
1705 */ |
|
1706 { |
|
1707 // Check if aIndex is in the valid range. |
|
1708 // Also check that iBuf is not empty, in which case there are no menu items stored. |
|
1709 if((iBuf.Length()==0) || (aIndex<1) || (aIndex>iNumberOfItems)) |
|
1710 { |
|
1711 return KErrNotFound; |
|
1712 } |
|
1713 else |
|
1714 { |
|
1715 TInt offset; |
|
1716 // FindItemInBuffer modifies offset to return the position of the requested |
|
1717 // menu item within iBuf. |
|
1718 if (FindItemInBuffer(aIndex, offset)==KErrCorrupt) |
|
1719 { |
|
1720 return KErrCorrupt; |
|
1721 } |
|
1722 |
|
1723 // The offset should be pointing at one of the item headers now. |
|
1724 if (((iBuf[offset]&KUpperByte)!=KItemHeader) && |
|
1725 (iBuf[offset]&KUpperByte)!=KItemWithTextAttributeHeader) |
|
1726 { |
|
1727 return KErrCorrupt; |
|
1728 } |
|
1729 else |
|
1730 { |
|
1731 // The item ID is a TUint8, which has been stored in a unicode buffer. |
|
1732 // Before casting it back to a TUint8 we check that the upper byte |
|
1733 // is zero. |
|
1734 // If it is different from 0, then there has been a data corruption |
|
1735 // since only headers have any content in the upper byte. |
|
1736 if((iBuf[offset+KHeaderLength]&KUpperByte)!=0) |
|
1737 { |
|
1738 return KErrCorrupt; |
|
1739 } |
|
1740 else |
|
1741 { |
|
1742 TUint8 textAttributeOffset = 0; |
|
1743 if ((iBuf[offset]&KUpperByte)==KItemWithTextAttributeHeader) |
|
1744 { |
|
1745 textAttributeOffset = KTextAttributeBufSize; |
|
1746 } |
|
1747 |
|
1748 aItem.iItemId=static_cast<TUint8>(iBuf[offset+KHeaderLength]); |
|
1749 aItem.iItemString=iBuf.Mid(offset+KHeaderLength+KItemIdLength+textAttributeOffset, |
|
1750 ((iBuf[offset]&KLowerByte)-KItemIdLength-textAttributeOffset)); |
|
1751 return KErrNone; |
|
1752 } |
|
1753 } |
|
1754 } |
|
1755 } |
|
1756 |
|
1757 |
|
1758 EXPORT_C TInt RSat::TMenuItemBaseV1::GetItem(TUint aIndex, TItem& aItem, TInt& aAction) const |
|
1759 /** |
|
1760 * This method is an overloaded method of RSat::TMenuItemBaseV1::GetItem(TUint aIndex, TItem& aItem). |
|
1761 * It returns the menu item's "next action indicator" (if available) as well as the menu item itself. |
|
1762 * RSat::TMenuItemBaseV1::MenuContent() tells you whether a menu's items are |
|
1763 * accompanied by "next action indicators". |
|
1764 * |
|
1765 * @param aIndex Index of the menu item. Index range starts at 1. |
|
1766 * RSat::TMenuItemBaseV1::NumberOfItems() returns the total |
|
1767 * number of items. |
|
1768 * @param aItem Item from the menu, designated by aIndex. |
|
1769 * @param aAction Action associated with the item. |
|
1770 * @return KErrNotFound returned if the menu contains no items or aIndex is out of range. |
|
1771 * KErrCorrupt returned if the buffer is corrupted and the item can't be found. |
|
1772 */ |
|
1773 { |
|
1774 // Check if aIndex is in the valid range. |
|
1775 // Also check that iBuf is not empty, in which case there are no menu items stored. |
|
1776 if((iBuf.Length()==0)||(aIndex<1)||(aIndex>iNumberOfItems)) |
|
1777 { |
|
1778 return KErrNotFound; |
|
1779 } |
|
1780 else |
|
1781 { |
|
1782 TInt offset; |
|
1783 // FindItemInBuffer modifies offset to return the position of the requested |
|
1784 // menu item within iBuf. |
|
1785 if (FindItemInBuffer(aIndex, offset)==KErrCorrupt) |
|
1786 { |
|
1787 return KErrCorrupt; |
|
1788 } |
|
1789 |
|
1790 if (((iBuf[offset]&KUpperByte)!=KItemHeader) && |
|
1791 (iBuf[offset]&KUpperByte)!=KItemWithTextAttributeHeader) |
|
1792 { |
|
1793 return KErrCorrupt; |
|
1794 } |
|
1795 else |
|
1796 { |
|
1797 if((iBuf[offset+KHeaderLength]&KUpperByte)!=0) |
|
1798 { |
|
1799 return KErrCorrupt; |
|
1800 } |
|
1801 else |
|
1802 { |
|
1803 TUint8 textAttributeOffset = 0; |
|
1804 if ((iBuf[offset]&KUpperByte)==KItemWithTextAttributeHeader) |
|
1805 { |
|
1806 textAttributeOffset = KTextAttributeBufSize; |
|
1807 } |
|
1808 |
|
1809 aItem.iItemId=static_cast<TUint8>(iBuf[offset+KHeaderLength]); |
|
1810 aItem.iItemString=iBuf.Mid(offset+KHeaderLength+KItemIdLength+textAttributeOffset, |
|
1811 ((iBuf[offset]&KLowerByte)-KItemIdLength-textAttributeOffset)); |
|
1812 // Set the offset past the item data, should be pointing to |
|
1813 // action header now. |
|
1814 offset+=KHeaderLength+(iBuf[offset]&KLowerByte); |
|
1815 if ((offset+KActionLength)>iBuf.Length()) |
|
1816 { |
|
1817 // There is no item next action associated with the requested item |
|
1818 // and offset has reached the end of iBuf. |
|
1819 aAction=KErrNotFound; |
|
1820 } |
|
1821 else |
|
1822 { |
|
1823 if((iBuf[offset]&KUpperByte)!=KActionHeader) |
|
1824 { |
|
1825 // There is no item next action associated with the requested item |
|
1826 aAction=KErrNotFound; |
|
1827 } |
|
1828 else |
|
1829 { |
|
1830 aAction=iBuf[offset+KHeaderLength]; |
|
1831 } |
|
1832 } |
|
1833 return KErrNone; |
|
1834 } |
|
1835 } |
|
1836 } |
|
1837 } |
|
1838 |
|
1839 EXPORT_C TInt RSat::TMenuItemBaseV1::GetItemIcon(TUint aIndex, TItem& aItem, TInt& aIconId) const |
|
1840 /** |
|
1841 * This method is an overloaded method of RSat::TMenuItemBaseV1::GetItem(TUint aIndex, TItem& aItem). |
|
1842 * It returns the menu item's icon identifier (if available) as well as the menu item itself. |
|
1843 * RSat::TMenuItemBaseV1::MenuContent() tells you whether a menu's items are |
|
1844 * accompanied by icon identifier. |
|
1845 * |
|
1846 * @param aIndex Index of the menu item. Index range starts at 1. |
|
1847 * RSat::TMenuItemBaseV1::NumberOfItems() returns the total |
|
1848 * number of items. |
|
1849 * @param aItem Item from the menu, designated by aIndex. |
|
1850 * @param aIconId Icon associated with the menu item. |
|
1851 * @return KErrNotFound returned if the menu contains no items or aIndex is out of range. |
|
1852 * KErrCorrupt returned if the buffer is corrupted and the item can't be found. |
|
1853 */ |
|
1854 { |
|
1855 if((iBuf.Length()==0) || (aIndex<1) || (aIndex>iNumberOfItems)) |
|
1856 { |
|
1857 return KErrNotFound; |
|
1858 } |
|
1859 else |
|
1860 { |
|
1861 TInt offset; |
|
1862 // FindItemInBuffer modifies offset to return the position of the requested |
|
1863 // menu item within iBuf. |
|
1864 if (FindItemInBuffer(aIndex,offset)==KErrCorrupt) |
|
1865 { |
|
1866 return KErrCorrupt; |
|
1867 } |
|
1868 |
|
1869 if (((iBuf[offset]&KUpperByte)!=KItemHeader) && |
|
1870 (iBuf[offset]&KUpperByte)!=KItemWithTextAttributeHeader) |
|
1871 { |
|
1872 return KErrCorrupt; |
|
1873 } |
|
1874 else |
|
1875 { |
|
1876 // Only headers should have the upper byte set, so there shouldn't |
|
1877 // be anything in the upper byte after the header. |
|
1878 if((iBuf[offset+KHeaderLength]&KUpperByte)!=0) |
|
1879 { |
|
1880 return KErrCorrupt; |
|
1881 } |
|
1882 else |
|
1883 { |
|
1884 TUint8 textAttributeOffset = 0; |
|
1885 if ((iBuf[offset]&KUpperByte)==KItemWithTextAttributeHeader) |
|
1886 { |
|
1887 textAttributeOffset = KTextAttributeBufSize; |
|
1888 } |
|
1889 |
|
1890 aItem.iItemId=static_cast<TUint8>(iBuf[offset+KHeaderLength]); |
|
1891 aItem.iItemString=iBuf.Mid(offset+KHeaderLength+KItemIdLength+textAttributeOffset, |
|
1892 ((iBuf[offset]&KLowerByte)-KItemIdLength-textAttributeOffset)); |
|
1893 offset+=KHeaderLength+(iBuf[offset]&KLowerByte); |
|
1894 if ((offset+KActionLength)>iBuf.Length()) |
|
1895 { |
|
1896 // There is no item icon ID associated with the requested item |
|
1897 // and offset has reached the end of iBuf. |
|
1898 aIconId=KErrNotFound; |
|
1899 } |
|
1900 else |
|
1901 { |
|
1902 if ((iBuf[offset]&KUpperByte)==KActionHeader) |
|
1903 { |
|
1904 offset+=KHeaderLength+(iBuf[offset]&KLowerByte); |
|
1905 } |
|
1906 if ((offset+KIconIdLength)>iBuf.Length()) |
|
1907 { |
|
1908 aIconId=KErrNotFound; |
|
1909 } |
|
1910 else |
|
1911 { |
|
1912 if((iBuf[offset]&KUpperByte)!=KIconIdHeader) |
|
1913 { |
|
1914 // There is no item icon ID associated with the requested item |
|
1915 aIconId=KErrNotFound; |
|
1916 } |
|
1917 else |
|
1918 { |
|
1919 aIconId=iBuf[offset+KHeaderLength]; |
|
1920 } |
|
1921 } |
|
1922 } |
|
1923 return KErrNone; |
|
1924 } |
|
1925 } |
|
1926 } |
|
1927 } |
|
1928 |
|
1929 EXPORT_C TInt RSat::TMenuItemBaseV1::GetItem(TUint aIndex, TItem& aItem, TInt& aAction, TInt& aIconId) const |
|
1930 /** |
|
1931 * This method is an overloaded method of RSat::TMenuItemBaseV1::GetItem(TUint aIndex, TItem& aItem). |
|
1932 * It returns the menu item's "next action indicator" and icon identifier |
|
1933 * (if they are available) as well as the requested menu item. |
|
1934 * RSat::TMenuItemBaseV1::MenuContent() tells you whether a menu's items are |
|
1935 * accompanied by icon identifiers and "next action indicators". |
|
1936 * |
|
1937 * @param aIndex Index of the menu item. Index range starts at 1. |
|
1938 * RSat::TMenuItemBaseV1::NumberOfItems() returns the total |
|
1939 * number of items. |
|
1940 * @param aItem Item from the menu, designated by aIndex. |
|
1941 * @param aAction Action associated with the item. |
|
1942 * @param aIconId Icon associated with the menu item. |
|
1943 * @return KErrNotFound returned if the menu contains no items or aIndex is out of range. |
|
1944 * KErrCorrupt returned if the buffer is corrupted and the item can't be found. |
|
1945 */ |
|
1946 { |
|
1947 if((iBuf.Length()==0) || (aIndex<1) || (aIndex>iNumberOfItems)) |
|
1948 { |
|
1949 return KErrNotFound; |
|
1950 } |
|
1951 else |
|
1952 { |
|
1953 TInt offset; |
|
1954 // FindItemInBuffer modifies offset to return the position of the requested |
|
1955 // menu item within iBuf. |
|
1956 if (FindItemInBuffer(aIndex,offset)==KErrCorrupt) |
|
1957 { |
|
1958 return KErrCorrupt; |
|
1959 } |
|
1960 |
|
1961 if (((iBuf[offset]&KUpperByte)!=KItemHeader) && |
|
1962 (iBuf[offset]&KUpperByte)!=KItemWithTextAttributeHeader) |
|
1963 { |
|
1964 return KErrCorrupt; |
|
1965 } |
|
1966 else |
|
1967 { |
|
1968 if((iBuf[offset+KHeaderLength]&KUpperByte)!=0) |
|
1969 { |
|
1970 return KErrCorrupt; |
|
1971 } |
|
1972 else |
|
1973 { |
|
1974 TUint8 textAttributeOffset = 0; |
|
1975 if ((iBuf[offset]&KUpperByte)==KItemWithTextAttributeHeader) |
|
1976 { |
|
1977 textAttributeOffset = KTextAttributeBufSize; |
|
1978 } |
|
1979 |
|
1980 aItem.iItemId=static_cast<TUint8>(iBuf[offset+KHeaderLength]); |
|
1981 aItem.iItemString=iBuf.Mid(offset+KHeaderLength+KItemIdLength+textAttributeOffset, |
|
1982 ((iBuf[offset]&KLowerByte)-KItemIdLength-textAttributeOffset)); |
|
1983 // Make offset point past the item string |
|
1984 offset+=KHeaderLength+(iBuf[offset]&KLowerByte); |
|
1985 |
|
1986 if ((offset+KActionLength)>iBuf.Length()) |
|
1987 { |
|
1988 aAction=KErrNotFound; |
|
1989 aIconId=KErrNotFound; |
|
1990 } |
|
1991 else |
|
1992 { |
|
1993 if((iBuf[offset]&KUpperByte)!=KActionHeader) |
|
1994 { |
|
1995 aAction=KErrNotFound; |
|
1996 } |
|
1997 else |
|
1998 { |
|
1999 aAction=iBuf[offset+KHeaderLength]; |
|
2000 offset+=KHeaderLength+KActionLength; |
|
2001 } |
|
2002 if ((offset+KIconIdLength)>iBuf.Length()) |
|
2003 { |
|
2004 aIconId=KErrNotFound; |
|
2005 } |
|
2006 else |
|
2007 { |
|
2008 if ((iBuf[offset]&KUpperByte)!=KIconIdHeader) |
|
2009 aIconId=KErrNotFound; |
|
2010 else |
|
2011 aIconId=iBuf[offset+KHeaderLength]; |
|
2012 } |
|
2013 } |
|
2014 return KErrNone; |
|
2015 } |
|
2016 } |
|
2017 } |
|
2018 } |
|
2019 |
|
2020 EXPORT_C TInt RSat::TMenuItemBaseV1::AddItem(const TItem& aItem) |
|
2021 /** |
|
2022 * This method adds a menu item to iBuf, which contains the menu item list. |
|
2023 * It is not needed by RSat clients, only the TSY. |
|
2024 * |
|
2025 * @param aItem Item to be added to iBuf. |
|
2026 * @return KErrNoMemory returned if there is not |
|
2027 * enough space left in iBuf to stored aItem. |
|
2028 * Otherwise KErrNone returned. |
|
2029 */ |
|
2030 { |
|
2031 TInt header=0; |
|
2032 |
|
2033 if ((iBuf.Length()!=0)&&(iMenuContent != KItems)) |
|
2034 { |
|
2035 return KErrNotSupported; |
|
2036 } |
|
2037 else if ((iBuf.Length()+KHeaderLength+KItemIdLength+aItem.iItemString.Length())>iBuf.MaxLength()) |
|
2038 { |
|
2039 // There is not enough space left in iBuf to add an item |
|
2040 return KErrNoMemory; |
|
2041 } |
|
2042 else |
|
2043 { |
|
2044 // If the menu is empty or only contains items (with no text attributes) |
|
2045 // and there is enough space for the next item, a new item can be added. |
|
2046 header = KItemHeader|(aItem.iItemString.Length()+KItemIdLength); |
|
2047 iBuf.Append(header); |
|
2048 iBuf.Append(aItem.iItemId); |
|
2049 iBuf.Append(aItem.iItemString); |
|
2050 iMenuContent = KItems; |
|
2051 iNumberOfItems++; |
|
2052 return KErrNone; |
|
2053 } |
|
2054 } |
|
2055 |
|
2056 EXPORT_C TInt RSat::TMenuItemBaseV1::AddItem(const TItem& aItem, TUint aAction) |
|
2057 /** |
|
2058 * This method is an overloaded method of AddItem(TItem aItem) |
|
2059 * It adds the menu item next action as well as the specified menu item. |
|
2060 * It is not needed by RSat clients, only the TSY. |
|
2061 * |
|
2062 * @param aItem Item to be added to iBuf. |
|
2063 * @param aAction Action associated with an item that is to be added to iBuf. |
|
2064 * @return KErrNoMemory returned if there is not |
|
2065 * enough space left in iBuf to stored aItem and an Action. |
|
2066 * Otherwise, KErrNone returned. |
|
2067 */ |
|
2068 { |
|
2069 TInt header=0; |
|
2070 |
|
2071 if ((iBuf.Length()!=0)&&(iMenuContent!=(KItems|KItemNextActions))) |
|
2072 { |
|
2073 return KErrNotSupported; |
|
2074 } |
|
2075 else if ((iBuf.Length()+KHeaderLength+KItemIdLength+aItem.iItemString.Length() |
|
2076 +KHeaderLength+KActionLength)>iBuf.MaxLength()) |
|
2077 { |
|
2078 // There is not enough space left in iBuf to add an item and its associated |
|
2079 // next action |
|
2080 return KErrNoMemory; |
|
2081 } |
|
2082 else |
|
2083 { |
|
2084 header = KItemHeader|(aItem.iItemString.Length()+KItemIdLength); |
|
2085 iBuf.Append(header); |
|
2086 iBuf.Append(aItem.iItemId); |
|
2087 iBuf.Append(aItem.iItemString); |
|
2088 header = KActionHeader|KActionLength; |
|
2089 iBuf.Append(header); |
|
2090 iBuf.Append(aAction); |
|
2091 iMenuContent=KItems|KItemNextActions; |
|
2092 iNumberOfItems++; |
|
2093 return KErrNone; |
|
2094 } |
|
2095 } |
|
2096 |
|
2097 EXPORT_C TInt RSat::TMenuItemBaseV1::AddItemIcon(const TItem& aItem, TUint aIconId) |
|
2098 /** |
|
2099 * This method is an overloaded method of AddItem(TItem aItem) |
|
2100 * It adds the menu item icon ID as well as the specified menu item. |
|
2101 * It is not needed by RSat clients, only the TSY. |
|
2102 * |
|
2103 * @param aItem Item to be added to iBuf. |
|
2104 * @param aIconId Icon identifier, associated with aItem, to be added to iBuf. |
|
2105 * @return KErrNoMemory returned if there is not |
|
2106 * enough space left in iBuf to store aItem and aIconId. |
|
2107 * Otherwise, KErrNone returned. |
|
2108 */ |
|
2109 { |
|
2110 TInt header=0; |
|
2111 |
|
2112 if ((iBuf.Length()!=0)&&(iMenuContent!=(KItems|KItemIconIds))) |
|
2113 { |
|
2114 return KErrNotSupported; |
|
2115 } |
|
2116 else if ((iBuf.Length()+KHeaderLength+KItemIdLength+aItem.iItemString.Length() |
|
2117 +KHeaderLength+KIconIdLength)>iBuf.MaxLength()) |
|
2118 { |
|
2119 // There is not enough space left in iBuf to add an item and its associated |
|
2120 // icon identifier. |
|
2121 return KErrNoMemory; |
|
2122 } |
|
2123 else |
|
2124 { |
|
2125 header=KItemHeader|(aItem.iItemString.Length()+KItemIdLength); |
|
2126 iBuf.Append(header); |
|
2127 iBuf.Append(aItem.iItemId); |
|
2128 iBuf.Append(aItem.iItemString); |
|
2129 header=KIconIdHeader|KIconIdLength; |
|
2130 iBuf.Append(header); |
|
2131 iBuf.Append(aIconId); |
|
2132 iMenuContent=KItems|KItemIconIds; |
|
2133 iNumberOfItems++; |
|
2134 return KErrNone; |
|
2135 } |
|
2136 } |
|
2137 |
|
2138 EXPORT_C TInt RSat::TMenuItemBaseV1::AddItem(const TItem& aItem, TUint aAction, TUint aIconId) |
|
2139 /** |
|
2140 * This method is an overloaded method of AddItem(TItem aItem) |
|
2141 * It adds the menu item next action and icon ID as well as the specified menu item |
|
2142 * It is not needed by RSat clients, only the TSY. |
|
2143 * |
|
2144 * @param aItem Item to be added to iBuf. |
|
2145 * @param aAction Action associated with an item that is to be added to iBuf. |
|
2146 * @param aIconId Icon identifier, associated with aItem, to be added to iBuf. |
|
2147 * @return KErrNoMemory returned if there is not |
|
2148 * enough space left in iBuf to store aItem and aIconId. |
|
2149 * Otherwise, KErrNone returned. |
|
2150 */ |
|
2151 { |
|
2152 TInt header=0; |
|
2153 if ((iBuf.Length()!=0)&&(iMenuContent!=(KItems|KItemNextActions|KItemIconIds))) |
|
2154 { |
|
2155 return KErrNotSupported; |
|
2156 } |
|
2157 else if ((iBuf.Length()+3*(KHeaderLength)+KItemIdLength+aItem.iItemString.Length() |
|
2158 +KActionLength+KIconIdLength)>iBuf.MaxLength()) |
|
2159 { |
|
2160 // There is not enough space left in iBuf to add an item and its associated |
|
2161 // icon identifier and next action. |
|
2162 return KErrNoMemory; |
|
2163 } |
|
2164 else |
|
2165 { |
|
2166 header = KItemHeader|(aItem.iItemString.Length()+KItemIdLength); |
|
2167 iBuf.Append(header); |
|
2168 iBuf.Append(aItem.iItemId); |
|
2169 iBuf.Append(aItem.iItemString); |
|
2170 header = KActionHeader|KActionLength; |
|
2171 iBuf.Append(header); |
|
2172 iBuf.Append(aAction); |
|
2173 header = KIconIdHeader|KIconIdLength; |
|
2174 iBuf.Append(header); |
|
2175 iBuf.Append(aIconId); |
|
2176 iMenuContent=KItems|KItemNextActions|KItemIconIds; |
|
2177 iNumberOfItems++; |
|
2178 return KErrNone; |
|
2179 } |
|
2180 } |
|
2181 |
|
2182 EXPORT_C void RSat::TMenuItemBaseV1::Reset() |
|
2183 /** |
|
2184 * This method sets the iBuf length and content to zero. |
|
2185 * It is not needed by RSat clients, only the TSY. |
|
2186 */ |
|
2187 { |
|
2188 iNumberOfItems=0; |
|
2189 iMenuContent=0; |
|
2190 iBuf.SetLength(0); |
|
2191 } |
|
2192 |
|
2193 EXPORT_C TInt RSat::TMenuItemBaseV5::GetItem (TUint aIndex, TItem& aItem, TTextAttribute& aTextAttribute) const |
|
2194 /** |
|
2195 * This method is an overloaded method of RSat::TMenuItemBaseV1::GetItem(TUint aIndex, TItem& aItem). |
|
2196 * It returns the menu item's text attribute |
|
2197 * (if available) as well as the requested menu item. |
|
2198 * RSat::TMenuItemBaseV1::MenuContent() tells you whether a menu's items are |
|
2199 * accompanied by text attributes. |
|
2200 * |
|
2201 * @param aIndex Index of the menu item. Index range starts at 1. |
|
2202 * RSat::TMenuItemBaseV1::NumberOfItems() returns the total |
|
2203 * number of items. |
|
2204 * @param aItem Item from the menu, designated by aIndex. |
|
2205 * @param aTextAttribute Text attribute of the item at aIndex in the menu. |
|
2206 * @return KErrNotFound returned if the menu contains no items or aIndex is out of range. |
|
2207 * KErrCorrupt returned if the buffer is corrupted and the item can't be found. |
|
2208 */ |
|
2209 { |
|
2210 // Check if aIndex is in the valid range. |
|
2211 // Also check that iBuf is not empty, in which case there are no menu items stored. |
|
2212 if((iBuf.Length()==0) || (aIndex<1) || (aIndex>iNumberOfItems)) |
|
2213 { |
|
2214 return KErrNotFound; |
|
2215 } |
|
2216 else |
|
2217 { |
|
2218 TInt offset; |
|
2219 // FindItemInBuffer modifies offset to return the position of the requested |
|
2220 // menu item within iBuf. |
|
2221 if (FindItemInBuffer(aIndex, offset)==KErrCorrupt) |
|
2222 { |
|
2223 return KErrCorrupt; |
|
2224 } |
|
2225 |
|
2226 // The offset should be pointing at one of the item headers now. |
|
2227 if (((iBuf[offset]&KUpperByte)!=KItemHeader) && |
|
2228 (iBuf[offset]&KUpperByte)!=KItemWithTextAttributeHeader) |
|
2229 { |
|
2230 return KErrCorrupt; |
|
2231 } |
|
2232 else |
|
2233 { |
|
2234 // The item ID is a TUint8, which has been stored in a unicode buffer. |
|
2235 // Before casting it back to a TUint8 we check that the upper byte |
|
2236 // is zero. |
|
2237 // If it is different from 0, then there has been a data corruption |
|
2238 // since only headers have any content in the upper byte. |
|
2239 if((iBuf[offset+KHeaderLength]&KUpperByte)!=0) |
|
2240 { |
|
2241 return KErrCorrupt; |
|
2242 } |
|
2243 else |
|
2244 { |
|
2245 TUint8 textAttributeOffset = 0; |
|
2246 if ((iBuf[offset]&KUpperByte)==KItemWithTextAttributeHeader) |
|
2247 { |
|
2248 textAttributeOffset = KTextAttributeBufSize; |
|
2249 aTextAttribute.iStatus = ETextAttributeProvided; |
|
2250 aTextAttribute.iTextAttributeData.SetLength(KTextAttributeBufSize); |
|
2251 for (TUint8 i = 0; i < KTextAttributeBufSize; i++) |
|
2252 { |
|
2253 aTextAttribute.iTextAttributeData[i] = iBuf[offset+KHeaderLength+KItemIdLength+i]; |
|
2254 } |
|
2255 } |
|
2256 else |
|
2257 { |
|
2258 aTextAttribute.iStatus = ETextAttributeNotPresent; |
|
2259 } |
|
2260 aItem.iItemId=static_cast<TUint8>(iBuf[offset+KHeaderLength]); |
|
2261 aItem.iItemString=iBuf.Mid(offset+KHeaderLength+KItemIdLength+textAttributeOffset, |
|
2262 ((iBuf[offset]&KLowerByte)-KItemIdLength-textAttributeOffset)); |
|
2263 |
|
2264 return KErrNone; |
|
2265 } |
|
2266 } |
|
2267 } |
|
2268 } |
|
2269 |
|
2270 EXPORT_C TInt RSat::TMenuItemBaseV5::GetItem (TUint aIndex, TItem& aItem, TTextAttribute& aTextAttribute, TInt& aAction) const |
|
2271 /** |
|
2272 * This method is an overloaded method of RSat::TMenuItemBaseV1::GetItem(TUint aIndex, TItem& aItem). |
|
2273 * It returns the menu item's text attribute |
|
2274 * (if available) as well as the requested menu item. |
|
2275 * RSat::TMenuItemBaseV1::MenuContent() tells you whether a menu's items are |
|
2276 * accompanied by text attributes and item next actions. |
|
2277 * |
|
2278 * @param aIndex Index of the menu item. Index range starts at 1. |
|
2279 * RSat::TMenuItemBaseV1::NumberOfItems() returns the total |
|
2280 * number of items. |
|
2281 * @param aItem Item from the menu, designated by aIndex. |
|
2282 * @param aTextAttribute Text attribute of the item at aIndex in the menu. |
|
2283 * @param aAction Action associated with the item. |
|
2284 * @return KErrNotFound returned if the menu contains no items or aIndex is out of range. |
|
2285 * KErrCorrupt returned if the buffer is corrupted and the item can't be found. |
|
2286 */ |
|
2287 { |
|
2288 // Check if aIndex is in the valid range. |
|
2289 // Also check that iBuf is not empty, in which case there are no menu items stored. |
|
2290 if((iBuf.Length()==0) || (aIndex<1) || (aIndex>iNumberOfItems)) |
|
2291 { |
|
2292 return KErrNotFound; |
|
2293 } |
|
2294 else |
|
2295 { |
|
2296 TInt offset; |
|
2297 // FindItemInBuffer modifies offset to return the position of the requested |
|
2298 // menu item within iBuf. |
|
2299 if (FindItemInBuffer(aIndex, offset)==KErrCorrupt) |
|
2300 { |
|
2301 return KErrCorrupt; |
|
2302 } |
|
2303 |
|
2304 // The offset should be pointing at one of the item headers now. |
|
2305 if (((iBuf[offset]&KUpperByte)!=KItemHeader) && |
|
2306 (iBuf[offset]&KUpperByte)!=KItemWithTextAttributeHeader) |
|
2307 { |
|
2308 return KErrCorrupt; |
|
2309 } |
|
2310 else |
|
2311 { |
|
2312 // The item ID is a TUint8, which has been stored in a unicode buffer. |
|
2313 // Before casting it back to a TUint8 we check that the upper byte |
|
2314 // is zero. |
|
2315 // If it is different from 0, then there has been a data corruption |
|
2316 // since only headers have any content in the upper byte. |
|
2317 if((iBuf[offset+KHeaderLength]&KUpperByte)!=0) |
|
2318 { |
|
2319 return KErrCorrupt; |
|
2320 } |
|
2321 else |
|
2322 { |
|
2323 TUint8 textAttributeOffset = 0; |
|
2324 if ((iBuf[offset]&KUpperByte)==KItemWithTextAttributeHeader) |
|
2325 { |
|
2326 textAttributeOffset = KTextAttributeBufSize; |
|
2327 aTextAttribute.iStatus = ETextAttributeProvided; |
|
2328 aTextAttribute.iTextAttributeData.SetLength(KTextAttributeBufSize); |
|
2329 for (TUint8 i = 0; i < KTextAttributeBufSize; i++) |
|
2330 { |
|
2331 aTextAttribute.iTextAttributeData[i] = iBuf[offset+KHeaderLength+KItemIdLength+i]; |
|
2332 } |
|
2333 } |
|
2334 else |
|
2335 { |
|
2336 aTextAttribute.iStatus = ETextAttributeNotPresent; |
|
2337 } |
|
2338 aItem.iItemId=static_cast<TUint8>(iBuf[offset+KHeaderLength]); |
|
2339 aItem.iItemString=iBuf.Mid(offset+KHeaderLength+KItemIdLength+textAttributeOffset, |
|
2340 ((iBuf[offset]&KLowerByte)-KItemIdLength-textAttributeOffset)); |
|
2341 |
|
2342 // Make offset point past the item string |
|
2343 offset+=KHeaderLength+(iBuf[offset]&KLowerByte); |
|
2344 |
|
2345 if ((offset+KActionLength)>iBuf.Length()) |
|
2346 { |
|
2347 aAction=KErrNotFound; |
|
2348 } |
|
2349 else |
|
2350 { |
|
2351 if((iBuf[offset]&KUpperByte)!=KActionHeader) |
|
2352 { |
|
2353 aAction=KErrNotFound; |
|
2354 } |
|
2355 else |
|
2356 { |
|
2357 aAction=iBuf[offset+KHeaderLength]; |
|
2358 } |
|
2359 } |
|
2360 |
|
2361 return KErrNone; |
|
2362 } |
|
2363 } |
|
2364 } |
|
2365 } |
|
2366 |
|
2367 EXPORT_C TInt RSat::TMenuItemBaseV5::GetItemIcon (TUint aIndex, TItem& aItem, TTextAttribute& aTextAttribute, TInt& aIconId) const |
|
2368 /** |
|
2369 * This method is an overloaded method of RSat::TMenuItemBaseV1::GetItem(TUint aIndex, TItem& aItem). |
|
2370 * It returns the menu item's text attribute |
|
2371 * (if available) as well as the requested menu item. |
|
2372 * RSat::TMenuItemBaseV1::MenuContent() tells you whether a menu's items are |
|
2373 * accompanied by text attributes and item next actions. |
|
2374 * |
|
2375 * @param aIndex Index of the menu item. Index range starts at 1. |
|
2376 * RSat::TMenuItemBaseV1::NumberOfItems() returns the total |
|
2377 * number of items. |
|
2378 * @param aItem Item from the menu, designated by aIndex. |
|
2379 * @param aTextAttribute Text attribute of the item at aIndex in the menu. |
|
2380 * @param aAction Action associated with the item. |
|
2381 * @return KErrNotFound returned if the menu contains no items or aIndex is out of range. |
|
2382 * KErrCorrupt returned if the buffer is corrupted and the item can't be found. |
|
2383 */ |
|
2384 { |
|
2385 if((iBuf.Length()==0) || (aIndex<1) || (aIndex>iNumberOfItems)) |
|
2386 { |
|
2387 return KErrNotFound; |
|
2388 } |
|
2389 else |
|
2390 { |
|
2391 TInt offset; |
|
2392 // FindItemInBuffer modifies offset to return the position of the requested |
|
2393 // menu item within iBuf. |
|
2394 if (FindItemInBuffer(aIndex,offset)==KErrCorrupt) |
|
2395 { |
|
2396 return KErrCorrupt; |
|
2397 } |
|
2398 |
|
2399 if (((iBuf[offset]&KUpperByte)!=KItemHeader) && |
|
2400 (iBuf[offset]&KUpperByte)!=KItemWithTextAttributeHeader) |
|
2401 { |
|
2402 return KErrCorrupt; |
|
2403 } |
|
2404 else |
|
2405 { |
|
2406 // Only headers should have the upper byte set, so there shouldn't |
|
2407 // be anything in the upper byte after the header. |
|
2408 if((iBuf[offset+KHeaderLength]&KUpperByte)!=0) |
|
2409 { |
|
2410 return KErrCorrupt; |
|
2411 } |
|
2412 else |
|
2413 { |
|
2414 TUint8 textAttributeOffset = 0; |
|
2415 if ((iBuf[offset]&KUpperByte)==KItemWithTextAttributeHeader) |
|
2416 { |
|
2417 textAttributeOffset = KTextAttributeBufSize; |
|
2418 aTextAttribute.iStatus = ETextAttributeProvided; |
|
2419 aTextAttribute.iTextAttributeData.SetLength(KTextAttributeBufSize); |
|
2420 for (TUint8 i = 0; i < KTextAttributeBufSize; i++) |
|
2421 { |
|
2422 aTextAttribute.iTextAttributeData[i] = iBuf[offset+KHeaderLength+KItemIdLength+i]; |
|
2423 } |
|
2424 } |
|
2425 else |
|
2426 { |
|
2427 aTextAttribute.iStatus = ETextAttributeNotPresent; |
|
2428 } |
|
2429 |
|
2430 aItem.iItemId=static_cast<TUint8>(iBuf[offset+KHeaderLength]); |
|
2431 aItem.iItemString=iBuf.Mid(offset+KHeaderLength+KItemIdLength+textAttributeOffset, |
|
2432 ((iBuf[offset]&KLowerByte)-KItemIdLength-textAttributeOffset)); |
|
2433 |
|
2434 offset+=KHeaderLength+(iBuf[offset]&KLowerByte); |
|
2435 if ((offset+KActionLength)>iBuf.Length()) |
|
2436 { |
|
2437 // There is no item icon ID associated with the requested item |
|
2438 // and offset has reached the end of iBuf. |
|
2439 aIconId=KErrNotFound; |
|
2440 } |
|
2441 else |
|
2442 { |
|
2443 if ((iBuf[offset]&KUpperByte)==KActionHeader) |
|
2444 { |
|
2445 offset+=KHeaderLength+(iBuf[offset]&KLowerByte); |
|
2446 } |
|
2447 if ((offset+KIconIdLength)>iBuf.Length()) |
|
2448 { |
|
2449 aIconId=KErrNotFound; |
|
2450 } |
|
2451 else |
|
2452 { |
|
2453 if((iBuf[offset]&KUpperByte)!=KIconIdHeader) |
|
2454 { |
|
2455 // There is no item icon ID associated with the requested item |
|
2456 aIconId=KErrNotFound; |
|
2457 } |
|
2458 else |
|
2459 { |
|
2460 aIconId=iBuf[offset+KHeaderLength]; |
|
2461 } |
|
2462 } |
|
2463 } |
|
2464 return KErrNone; |
|
2465 } |
|
2466 } |
|
2467 } |
|
2468 } |
|
2469 |
|
2470 EXPORT_C TInt RSat::TMenuItemBaseV5::GetItem (TUint aIndex, TItem& aItem, TTextAttribute& aTextAttribute, TInt& aAction, TInt& aIconId) const |
|
2471 /** |
|
2472 * This method is an overloaded method of RSat::TMenuItemBaseV1::GetItem(TUint aIndex, TItem& aItem). |
|
2473 * It returns the menu item's text attribute, item next action and icon if |
|
2474 * they are available as well as the requested menu item. |
|
2475 * RSat::TMenuItemBaseV1::MenuContent() tells you whether a menu's items are |
|
2476 * accompanied by text attributes, item next actions, and icons. |
|
2477 * |
|
2478 * @param aIndex Index of the menu item. Index range starts at 1. |
|
2479 * RSat::TMenuItemBaseV1::NumberOfItems() returns the total |
|
2480 * number of items. |
|
2481 * @param aItem Item from the menu, designated by aIndex. |
|
2482 * @param aTextAttribute Text attribute of the item at aIndex in the menu. |
|
2483 * @param aIcon Icon associated with the item. |
|
2484 * @param aAction Action associated with the item. |
|
2485 * @return KErrNotFound returned if the menu contains no items or aIndex is out of range. |
|
2486 * KErrCorrupt returned if the buffer is corrupted and the item can't be found. |
|
2487 * |
|
2488 */ |
|
2489 { |
|
2490 if((iBuf.Length()==0) || (aIndex<1) || (aIndex>iNumberOfItems)) |
|
2491 { |
|
2492 return KErrNotFound; |
|
2493 } |
|
2494 else |
|
2495 { |
|
2496 TInt offset; |
|
2497 // FindItemInBuffer modifies offset to return the position of the requested |
|
2498 // menu item within iBuf. |
|
2499 if (FindItemInBuffer(aIndex,offset)==KErrCorrupt) |
|
2500 { |
|
2501 return KErrCorrupt; |
|
2502 } |
|
2503 |
|
2504 if (((iBuf[offset]&KUpperByte)!=KItemHeader) && |
|
2505 (iBuf[offset]&KUpperByte)!=KItemWithTextAttributeHeader) |
|
2506 { |
|
2507 return KErrCorrupt; |
|
2508 } |
|
2509 else |
|
2510 { |
|
2511 if((iBuf[offset+KHeaderLength]&KUpperByte)!=0) |
|
2512 { |
|
2513 return KErrCorrupt; |
|
2514 } |
|
2515 else |
|
2516 { |
|
2517 // textAttributeOffset indicates the extra 'jump' needed |
|
2518 // to get to the item string which is four bytes |
|
2519 // further into the buffer when there is a text |
|
2520 // attribute present. |
|
2521 TUint8 textAttributeOffset = 0; |
|
2522 if ((iBuf[offset]&KUpperByte)==KItemWithTextAttributeHeader) |
|
2523 { |
|
2524 textAttributeOffset = KTextAttributeBufSize; |
|
2525 aTextAttribute.iStatus = ETextAttributeProvided; |
|
2526 aTextAttribute.iTextAttributeData.SetLength(KTextAttributeBufSize); |
|
2527 for (TUint8 i = 0; i < KTextAttributeBufSize; i++) |
|
2528 { |
|
2529 aTextAttribute.iTextAttributeData[i] = iBuf[offset+KHeaderLength+KItemIdLength+i]; |
|
2530 } |
|
2531 } |
|
2532 else |
|
2533 { |
|
2534 aTextAttribute.iStatus = ETextAttributeNotPresent; |
|
2535 } |
|
2536 |
|
2537 aItem.iItemId=static_cast<TUint8>(iBuf[offset+KHeaderLength]); |
|
2538 aItem.iItemString=iBuf.Mid(offset+KHeaderLength+KItemIdLength+textAttributeOffset, |
|
2539 ((iBuf[offset]&KLowerByte)-KItemIdLength-textAttributeOffset)); |
|
2540 // Make offset point past the item string |
|
2541 offset+=KHeaderLength+(iBuf[offset]&KLowerByte); |
|
2542 |
|
2543 if ((offset+KActionLength)>iBuf.Length()) |
|
2544 { |
|
2545 aAction=KErrNotFound; |
|
2546 aIconId=KErrNotFound; |
|
2547 } |
|
2548 else |
|
2549 { |
|
2550 if((iBuf[offset]&KUpperByte)!=KActionHeader) |
|
2551 { |
|
2552 aAction=KErrNotFound; |
|
2553 } |
|
2554 else |
|
2555 { |
|
2556 aAction=iBuf[offset+KHeaderLength]; |
|
2557 offset+=KHeaderLength+KActionLength; |
|
2558 } |
|
2559 if ((offset+KIconIdLength)>iBuf.Length()) |
|
2560 { |
|
2561 aIconId=KErrNotFound; |
|
2562 } |
|
2563 else |
|
2564 { |
|
2565 if ((iBuf[offset]&KUpperByte)!=KIconIdHeader) |
|
2566 aIconId=KErrNotFound; |
|
2567 else |
|
2568 aIconId=iBuf[offset+KHeaderLength]; |
|
2569 } |
|
2570 } |
|
2571 return KErrNone; |
|
2572 } |
|
2573 } |
|
2574 } |
|
2575 } |
|
2576 |
|
2577 EXPORT_C TInt RSat::TMenuItemBaseV5::AddItem (const TItem& aItem, const TTextAttribute& aTextAttribute) |
|
2578 /** |
|
2579 * This method is an overloaded method of AddItem(TItem aItem) |
|
2580 * It adds a menu item and a text attribute to the menu. |
|
2581 * |
|
2582 * It is only possible to add a menu item and text attribute |
|
2583 * if the menu is either empty or already contains items all |
|
2584 * with text attributes only. If the existing menu items contain |
|
2585 * icons or item next actions, then an icon/next action for the |
|
2586 * menu item must also be specified by adding the item using |
|
2587 * one of the other overloaded methods of AddItem(TItem aItem). |
|
2588 * If the existing menu items do not have text attributes |
|
2589 * specified, then it is not possible to specify a text attribute |
|
2590 * for the new menu item and one of the other overloaded methods |
|
2591 * of AddItem(TItem aItem) that does not |
|
2592 * contain a TTextAttribute parameter must |
|
2593 * be used. |
|
2594 * |
|
2595 * It is not needed by RSat clients, only the TSY. |
|
2596 * |
|
2597 * @param aItem Item to be added to iBuf. |
|
2598 * @param aTextAttribute Item text attribute which applies to aItem to be added to iBuf. |
|
2599 * @param aIconId Icon identifier, associated with aItem, to be added to iBuf. |
|
2600 * @return KErrNoMemory returned if there is not enough space left in iBuf to store aItem and aIconId. |
|
2601 * KErrNotSupported returned if the current menu format does not support items with associated text attribute only. |
|
2602 * Otherwise, KErrNone returned. |
|
2603 */ |
|
2604 { |
|
2605 TInt header=0; |
|
2606 |
|
2607 if ((iBuf.Length()!=0)&&(iMenuContent != (KItems|KItemTextAttributes))) |
|
2608 { |
|
2609 return KErrNotSupported; |
|
2610 } |
|
2611 else if ((iBuf.Length()+KHeaderLength+KItemIdLength+KTextAttributeBufSize+aItem.iItemString.Length())>iBuf.MaxLength()) |
|
2612 { |
|
2613 // There is not enough space left in iBuf to add an item |
|
2614 return KErrNoMemory; |
|
2615 } |
|
2616 else |
|
2617 { |
|
2618 // If the menu is empty or only contains items (with no text attributes) |
|
2619 // and there is enough space for the new item, a new item can be added. |
|
2620 header = KItemWithTextAttributeHeader|(aItem.iItemString.Length()+KItemIdLength+KTextAttributeBufSize); |
|
2621 iBuf.Append(header); |
|
2622 iBuf.Append(aItem.iItemId); |
|
2623 for (TUint8 i = 0; i < KTextAttributeBufSize; i++) |
|
2624 { |
|
2625 iBuf.Append(aTextAttribute.iTextAttributeData[i]); |
|
2626 } |
|
2627 iBuf.Append(aItem.iItemString); |
|
2628 iMenuContent = KItems|KItemTextAttributes; |
|
2629 iNumberOfItems++; |
|
2630 return KErrNone; |
|
2631 } |
|
2632 } |
|
2633 |
|
2634 |
|
2635 EXPORT_C TInt RSat::TMenuItemBaseV5::AddItem (const TItem& aItem, const TTextAttribute& aTextAttribute, TUint aAction) |
|
2636 /** |
|
2637 * This method is an overloaded method of AddItem(TItem aItem) |
|
2638 * It adds a menu item,a text attribute and an item next action to the menu. |
|
2639 * |
|
2640 * It is only possible to add a menu item, text attribute and item next |
|
2641 * action if the menu is either empty or already contains items ALL |
|
2642 * with text attributes and item next actions only. |
|
2643 * If the existing menu items contain icons, all new menu items must also |
|
2644 * contain icons, therefore, this function cannot |
|
2645 * be used to add items to the menu. One of the other |
|
2646 * overloaded methods of AddItem(TItem aItem) which allow an icon to be |
|
2647 * specified should be used. |
|
2648 * |
|
2649 * It is not needed by RSat clients, only the TSY. |
|
2650 * |
|
2651 * @param aItem Item to be added to iBuf. |
|
2652 * @param aTextAttribute Item text attribute which applies to aItem to be added to iBuf. |
|
2653 * @param aAction Item next action. |
|
2654 * @return KErrNoMemory returned if there is not enough space left in iBuf to store aItem and aIconId. |
|
2655 * KErrNotSupported returned if the current menu format does not support items with associated text attribute only. |
|
2656 * Otherwise, KErrNone returned. |
|
2657 */ |
|
2658 { |
|
2659 TInt header=0; |
|
2660 |
|
2661 if ((iBuf.Length()!=0)&&(iMenuContent!=(KItems|KItemTextAttributes|KItemNextActions))) |
|
2662 { |
|
2663 return KErrNotSupported; |
|
2664 } |
|
2665 else if ((iBuf.Length()+KHeaderLength+KItemIdLength+KTextAttributeBufSize+ |
|
2666 aItem.iItemString.Length()+KHeaderLength+KActionLength)>iBuf.MaxLength()) |
|
2667 { |
|
2668 // There is not enough space left in iBuf to add an item and its associated |
|
2669 // next action |
|
2670 return KErrNoMemory; |
|
2671 } |
|
2672 else |
|
2673 { |
|
2674 header = KItemWithTextAttributeHeader| |
|
2675 (aItem.iItemString.Length()+KItemIdLength+KTextAttributeBufSize); |
|
2676 iBuf.Append(header); |
|
2677 iBuf.Append(aItem.iItemId); |
|
2678 for (TUint8 i = 0; i < KTextAttributeBufSize; i++) |
|
2679 { |
|
2680 iBuf.Append(aTextAttribute.iTextAttributeData[i]); |
|
2681 } |
|
2682 iBuf.Append(aItem.iItemString); |
|
2683 header = KActionHeader|KActionLength; |
|
2684 iBuf.Append(header); |
|
2685 iBuf.Append(aAction); |
|
2686 iMenuContent=KItems|KItemNextActions|KItemTextAttributes; |
|
2687 iNumberOfItems++; |
|
2688 return KErrNone; |
|
2689 } |
|
2690 } |
|
2691 |
|
2692 EXPORT_C TInt RSat::TMenuItemBaseV5::AddItemIcon (const TItem& aItem, const TTextAttribute& aTextAttribute, TUint aIconId) |
|
2693 /** |
|
2694 * This method is an overloaded method of |
|
2695 * RSat::TMenuItemBaseV1::AddItemIcon(TItem aItem) |
|
2696 * It adds a menu item,a text attribute and an item next action to the menu. |
|
2697 * |
|
2698 * It is only possible to add a menu item, text attribute and item icon |
|
2699 * if the menu is either empty or already contains items ALL |
|
2700 * with text attributes and item icons only. |
|
2701 * If the existing menu items contain item next actions, all new menu items |
|
2702 * must also contain icons, therefore, this function cannot |
|
2703 * be used to add items to the menu. One of the other |
|
2704 * overloaded methods of AddItem(TItem aItem) which allow an item next |
|
2705 * action to be specified should be used instead. |
|
2706 * |
|
2707 * It is not needed by RSat clients, only the TSY. |
|
2708 * |
|
2709 * @param aItem Item to be added to iBuf. |
|
2710 * @param aTextAttribute Item text attribute which applies to aItem to be added to iBuf. |
|
2711 * @param aIcon Item icon to be added to iBuf. |
|
2712 * @return KErrNoMemory returned if there is not enough space left in iBuf to store aItem and aIconId. |
|
2713 * KErrNotSupported returned if the current menu format does not support items with associated text attribute only. |
|
2714 * Otherwise, KErrNone returned. |
|
2715 */ |
|
2716 { |
|
2717 TInt header=0; |
|
2718 |
|
2719 if ((iBuf.Length()!=0)&&(iMenuContent!=(KItems|KItemTextAttributes|KItemIconIds))) |
|
2720 { |
|
2721 return KErrNotSupported; |
|
2722 } |
|
2723 else if ((iBuf.Length()+KHeaderLength+KItemIdLength+KTextAttributeBufSize+aItem.iItemString.Length() |
|
2724 +KHeaderLength+KIconIdLength)>iBuf.MaxLength()) |
|
2725 { |
|
2726 // There is not enough space left in iBuf to add an item and its associated |
|
2727 // icon identifier. |
|
2728 return KErrNoMemory; |
|
2729 } |
|
2730 else |
|
2731 { |
|
2732 header=KItemWithTextAttributeHeader|(aItem.iItemString.Length()+KTextAttributeBufSize+KItemIdLength); |
|
2733 iBuf.Append(header); |
|
2734 iBuf.Append(aItem.iItemId); |
|
2735 for (TUint8 i = 0; i < KTextAttributeBufSize; i++) |
|
2736 { |
|
2737 iBuf.Append(aTextAttribute.iTextAttributeData[i]); |
|
2738 } |
|
2739 iBuf.Append(aItem.iItemString); |
|
2740 header=KIconIdHeader|KIconIdLength; |
|
2741 iBuf.Append(header); |
|
2742 iBuf.Append(aIconId); |
|
2743 iMenuContent=KItems|KItemIconIds|KItemTextAttributes; |
|
2744 iNumberOfItems++; |
|
2745 return KErrNone; |
|
2746 } |
|
2747 } |
|
2748 |
|
2749 EXPORT_C TInt RSat::TMenuItemBaseV5::AddItem (const TItem& aItem, const TTextAttribute& aTextAttribute, TUint aAction, TUint aIconId) |
|
2750 /** |
|
2751 * This method is an overloaded method of AddItem(TItem aItem) |
|
2752 * It adds a menu item,a text attribute and an item next action |
|
2753 * and icon to the menu. |
|
2754 * |
|
2755 * It is only possible to add a menu item with all the associated |
|
2756 * information if the menu is either empty or already contains |
|
2757 * items ALL of which also contain text attributes, item icons, |
|
2758 * and item next actions. |
|
2759 * If the existing menu items do not contain all of these, |
|
2760 * this function cannot be used to add items to the menu. |
|
2761 * One of the other overloaded methods of AddItem(TItem aItem) |
|
2762 * which allow an item next action to be specified should be |
|
2763 * used instead. |
|
2764 * |
|
2765 * It is not needed by RSat clients, only the TSY. |
|
2766 * |
|
2767 * @param aItem Item to be added to iBuf. |
|
2768 * @param aTextAttribute Item text attribute which applies to aItem to be added to iBuf. |
|
2769 * @param aIcon Item icon to be added to iBuf. |
|
2770 * @param aAction Item next action to be added to iBuf. |
|
2771 * @return KErrNoMemory returned if there is not enough space left in iBuf to store aItem and aIconId. |
|
2772 * KErrNotSupported returned if the current menu format does not support items with associated text attribute only. |
|
2773 * Otherwise, KErrNone returned. |
|
2774 */ |
|
2775 { |
|
2776 TInt header=0; |
|
2777 if ((iBuf.Length()!=0)&&(iMenuContent!=(KItems|KItemNextActions|KItemIconIds|KItemTextAttributes))) |
|
2778 { |
|
2779 return KErrNotSupported; |
|
2780 } |
|
2781 else if ((iBuf.Length()+3*(KHeaderLength)+KItemIdLength+KTextAttributeBufSize+aItem.iItemString.Length() |
|
2782 +KActionLength+KIconIdLength)>iBuf.MaxLength()) |
|
2783 { |
|
2784 // There is not enough space left in iBuf to add an item and its associated |
|
2785 // icon identifier and next action. |
|
2786 return KErrNoMemory; |
|
2787 } |
|
2788 else |
|
2789 { |
|
2790 header = KItemWithTextAttributeHeader|(aItem.iItemString.Length()+KTextAttributeBufSize+KItemIdLength); |
|
2791 iBuf.Append(header); |
|
2792 iBuf.Append(aItem.iItemId); |
|
2793 for (TUint8 i = 0; i < KTextAttributeBufSize; i++) |
|
2794 { |
|
2795 iBuf.Append(aTextAttribute.iTextAttributeData[i]); |
|
2796 } |
|
2797 iBuf.Append(aItem.iItemString); |
|
2798 header = KActionHeader|KActionLength; |
|
2799 iBuf.Append(header); |
|
2800 iBuf.Append(aAction); |
|
2801 header = KIconIdHeader|KIconIdLength; |
|
2802 iBuf.Append(header); |
|
2803 iBuf.Append(aIconId); |
|
2804 iMenuContent=KItems|KItemNextActions|KItemIconIds|KItemTextAttributes; |
|
2805 iNumberOfItems++; |
|
2806 return KErrNone; |
|
2807 } |
|
2808 } |
|
2809 |
|
2810 EXPORT_C RSat::TSetUpMenuV1::TSetUpMenuV1() |
|
2811 : TMenuItemBaseV1(), |
|
2812 iHelp(EHelpNotSet), |
|
2813 iIconListQualifier(EIconQualifierNotSet) |
|
2814 /** |
|
2815 * Default constructor. |
|
2816 */ |
|
2817 { |
|
2818 iExtensionId=KSatV1; |
|
2819 iAlphaId.iStatus=EAlphaIdNotSet; |
|
2820 iIconId.iQualifier=EIconQualifierNotSet; |
|
2821 iIconId.iIdentifier=0; |
|
2822 } |
|
2823 |
|
2824 EXPORT_C RSat::TSetUpMenuV2::TSetUpMenuV2() |
|
2825 :TSetUpMenuV1(), |
|
2826 iPreference(ESelectionPreferenceNotSet) |
|
2827 /** |
|
2828 * Default constructor. |
|
2829 */ |
|
2830 { |
|
2831 iExtensionId=KSatV2; |
|
2832 } |
|
2833 |
|
2834 EXPORT_C RSat::TSetUpMenuV5::TSetUpMenuV5() |
|
2835 :TMenuItemBaseV5() |
|
2836 /** |
|
2837 * Default constructor. |
|
2838 */ |
|
2839 { |
|
2840 iExtensionId=KSatV5; |
|
2841 iAlphaId.iStatus=EAlphaIdNotSet; |
|
2842 iHelp=EHelpNotSet; |
|
2843 iIconId.iQualifier=EIconQualifierNotSet; |
|
2844 iIconId.iIdentifier=0; |
|
2845 iIconListQualifier=EIconQualifierNotSet; |
|
2846 iPreference=ESelectionPreferenceNotSet; |
|
2847 iTextAttribute.iStatus=ETextAttributeNotSet; |
|
2848 } |
|
2849 |
|
2850 EXPORT_C RSat::TSetUpMenuRspV1::TSetUpMenuRspV1() |
|
2851 : TSatPCmdBase(), |
|
2852 iGeneralResult(KPCmdResultNotSet), |
|
2853 iInfoType(0), |
|
2854 iAdditionalInfo() |
|
2855 /** |
|
2856 * Default constructor. |
|
2857 */ |
|
2858 { |
|
2859 iExtensionId=KSatV1; |
|
2860 } |
|
2861 |
|
2862 EXPORT_C void RSat::NotifySetUpMenuPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
2863 /** |
|
2864 * This method requests notification when a SET UP MENU proactive command is sent |
|
2865 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
2866 * aReqStatus is competed. Unpack the command to examine its contents. |
|
2867 * |
|
2868 * The SET UP MENU command provides a set of menu items to be integrated with the |
|
2869 * phone's menu system. The user can choose one of these menu items at their own |
|
2870 * discretion. The command is described fully in ETSI TS 102 223. Briefly, |
|
2871 * though, the command includes: |
|
2872 * |
|
2873 * - The items in the menu, in a RSat::TMenuItemBaseV1 |
|
2874 * - A title for the menu in an alpha identifier - RSat::TSetUpMenuV1::iAlphaId |
|
2875 * - An icon that represents the menu - RSat::TSetUpMenuV1::iIconId |
|
2876 * - Determines whether help is available - RSat::TSetUpMenuV1::iHelp |
|
2877 * - Determines whether soft key is used with the menu - RSat::TSetUpMenuV2::iPreference (Symbian OS v7.0s and later.) |
|
2878 * - Text attributes of text contained in iAlphaId - RSat::TSetUpMenuV5::iTextAttribute (Symbian OS v9.2 or later) |
|
2879 * |
|
2880 * Once you have integrated the menu (but before the user has made a selection), |
|
2881 * you must give your response to the SET UP MENU command. For Symbian OS |
|
2882 * versions up to and including v8.1a and v8.1b pass RSat::TerminalRsp() a |
|
2883 * RSat::TSetUpMenuRspV1Pckg (a packaged TGetInputRspV1). For later versions of |
|
2884 * Symbian OS, check for an updated API (RSat::TSetUpMenuRspV2 etc). |
|
2885 * |
|
2886 * If the user chooses a menu item then inform the UICC with |
|
2887 * RSat::MenuSelection(). This includes the identifier of the chosen menu item. |
|
2888 * |
|
2889 * You may receive a SET UP MENU command with no menu! This means that the menu |
|
2890 * from the previous SET UP MENU command should be removed; see |
|
2891 * RSat::TMenuItemBaseV1::IsRemoveMenu(). |
|
2892 * |
|
2893 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
2894 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
2895 * command. Use a packaged version of the latest "TSetUpMenu" class. For |
|
2896 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TSetUpMenuV2Pckg, a packaged |
|
2897 * RSat::TSetUpMenuV2. For Symbian OS version 9.2, use RSat::TSetUpMenuV5. |
|
2898 * Use RSat::TSetUpMenuV1 with some older versions of Symbian |
|
2899 * OS. For later versions of Symbian OS, check for an updated API |
|
2900 * (RSat::TSetUpMenuV6 etc). |
|
2901 * |
|
2902 * @see RSat::TSetUpMenuV1 |
|
2903 * @see RSat::TSetUpMenuV2 |
|
2904 * @see RSat::TSetUpMenuV5 |
|
2905 * @see RSat::TMenuItemBaseV1 |
|
2906 * @see RSat::TMenuItemBaseV5 |
|
2907 * @see RSat::TSetUpMenuRspV1 |
|
2908 * @see RSat::MenuSelection() |
|
2909 * @capability None |
|
2910 */ |
|
2911 { |
|
2912 Get(ESatNotifySetUpMenuPCmd,aReqStatus,aPCmd); |
|
2913 } |
|
2914 |
|
2915 EXPORT_C RSat::TSelectItemV1::TSelectItemV1() |
|
2916 : TMenuItemBaseV1(), |
|
2917 iPresentationType(EPresentationTypeNotSet), |
|
2918 iHelp(EHelpNotSet), |
|
2919 iDefaultItemId(0), |
|
2920 iIconListQualifier(EIconQualifierNotSet) |
|
2921 /** |
|
2922 * Default constructor. |
|
2923 */ |
|
2924 { |
|
2925 iExtensionId=KSatV1; |
|
2926 iAlphaId.iStatus=EAlphaIdNotSet; |
|
2927 iIconId.iQualifier=EIconQualifierNotSet; |
|
2928 iIconId.iIdentifier=0; |
|
2929 } |
|
2930 |
|
2931 EXPORT_C RSat::TSelectItemV2::TSelectItemV2() |
|
2932 : TSelectItemV1(), |
|
2933 iPreference(ESelectionPreferenceNotSet) |
|
2934 /** |
|
2935 * Default constructor. |
|
2936 */ |
|
2937 { |
|
2938 iExtensionId=KSatV2; |
|
2939 } |
|
2940 |
|
2941 EXPORT_C RSat::TSelectItemV5::TSelectItemV5() |
|
2942 : TMenuItemBaseV5() |
|
2943 /** |
|
2944 * Default constructor. |
|
2945 */ |
|
2946 { |
|
2947 iExtensionId=KSatV5; |
|
2948 iPresentationType=EPresentationTypeNotSet; |
|
2949 iAlphaId.iStatus=EAlphaIdNotSet; |
|
2950 iHelp=EHelpNotSet; |
|
2951 iDefaultItemId=0; |
|
2952 iIconId.iQualifier=EIconQualifierNotSet; |
|
2953 iIconId.iIdentifier=0; |
|
2954 iIconListQualifier=EIconQualifierNotSet; |
|
2955 iPreference=ESelectionPreferenceNotSet; |
|
2956 iTextAttribute.iStatus=ETextAttributeNotSet; |
|
2957 } |
|
2958 |
|
2959 EXPORT_C RSat::TSelectItemV6::TSelectItemV6() |
|
2960 : TSelectItemV5(),iFrameId(0) |
|
2961 /** |
|
2962 * Default constructor. |
|
2963 */ |
|
2964 { |
|
2965 iExtensionId=KSatV6; |
|
2966 } |
|
2967 |
|
2968 EXPORT_C RSat::TSelectItemRspV1::TSelectItemRspV1() |
|
2969 : TSatPCmdBase(), |
|
2970 iGeneralResult(KPCmdResultNotSet), |
|
2971 iInfoType(0), |
|
2972 iAdditionalInfo() |
|
2973 /** |
|
2974 * Default constructor. |
|
2975 */ |
|
2976 { |
|
2977 iExtensionId=KSatV1; |
|
2978 } |
|
2979 |
|
2980 EXPORT_C void RSat::NotifySelectItemPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
2981 /** |
|
2982 * This method requests notification when a SELECT ITEM proactive command is sent |
|
2983 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
2984 * aReqStatus is competed. Unpack the command to examine its contents. |
|
2985 * |
|
2986 * The SELECT ITEM command provides a set of menu items to be shown to the user. |
|
2987 * The user can choose one of these menu items. The command is described fully in |
|
2988 * ETSI TS 102 223. Briefly, though, the command includes: |
|
2989 * |
|
2990 * - The items in the menu, in a RSat::TMenuItemBaseV1 |
|
2991 * - A title for the menu in an alpha identifier - RSat::TSelectItemV1::iAlphaId |
|
2992 * - An icon that represents the menu - RSat::TSelectItemV1::iIconId |
|
2993 * - A default menu selection - RSat::TSelectItemV1::iDefaultItemId |
|
2994 * - Determines whether help is available - RSat::TSelectItemV1::iHelp |
|
2995 * - Determines whether soft key is used with the menu - RSat::TSelectItemV2::iPreference (Symbian OS v7.0s and later.) |
|
2996 * - Text attributes of text contained in iAlphaId - RSat::TSelectItemV5::iTextAttribute (Symbian OS v9.2 or later) |
|
2997 * |
|
2998 * Once you have integrated the menu (but before the user has made a selection), |
|
2999 * you must give your response to the SELECT ITEM command. For Symbian OS |
|
3000 * versions up to and including v8.1a and v8.1b pass RSat::TerminalRsp() a |
|
3001 * RSat::TSelectItemRspV1Pckg (a packaged TGetInputRspV1). For later versions of |
|
3002 * Symbian OS, check for an updated API (RSat::TSelectItemRspV2 etc). |
|
3003 * |
|
3004 * If the user chooses a menu item then inform the UICC with |
|
3005 * RSat::MenuSelection(). This includes the identifier of the chosen menu item. |
|
3006 * |
|
3007 * You may receive a SELECT ITEM command with no menu! This means that the menu |
|
3008 * from the previous SELECT ITEM command should be removed; see |
|
3009 * RSat::TMenuItemBaseV1::IsRemoveMenu(). |
|
3010 * |
|
3011 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
3012 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
3013 * command. Use a packaged version of the latest "TSelectItem" class. For |
|
3014 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TSelectItemV2Pckg, a packaged |
|
3015 * RSat::TSelectItemV2. |
|
3016 * For Symbian OS version 9.2, use RSat::TDisplayTextV5Pckg. |
|
3017 * For Symbian OS version 9.4, use RSat::TDisplayTextV6Pckg. |
|
3018 * Use RSat::TSelectItemV1 with some older versions of Symbian |
|
3019 * OS. For later versions of Symbian OS, check for an updated API |
|
3020 * (RSat::TSelectItemV7 etc). |
|
3021 * |
|
3022 * @see RSat::TSelectItemV1 |
|
3023 * @see RSat::TSelectItemV2 |
|
3024 * @see RSat::TSelectItemV5 |
|
3025 * @see RSat::TSelectItemV6 |
|
3026 * @see RSat::TMenuItemBaseV1 |
|
3027 * @see RSat::TMenuItemBaseV5 |
|
3028 * @see RSat::TSelectItemRspV1 |
|
3029 * @see RSat::MenuSelection() |
|
3030 * @capability None |
|
3031 */ |
|
3032 { |
|
3033 Get(ESatNotifySelectItemPCmd,aReqStatus,aPCmd); |
|
3034 } |
|
3035 |
|
3036 EXPORT_C RSat::TSendSmV1::TSendSmV1() |
|
3037 : TSatPCmdBase(), |
|
3038 iSmsTpdu() |
|
3039 /** |
|
3040 * Default constructor. |
|
3041 */ |
|
3042 { |
|
3043 iExtensionId=KSatV1; |
|
3044 iAlphaId.iStatus=EAlphaIdNotSet; |
|
3045 iAddress.iTypeOfNumber=ETypeOfNumberNotSet; |
|
3046 iAddress.iNumberPlan=ENumberingPlanNotSet; |
|
3047 iIconId.iQualifier=EIconQualifierNotSet; |
|
3048 iIconId.iIdentifier=0; |
|
3049 } |
|
3050 |
|
3051 EXPORT_C RSat::TSendSmV5::TSendSmV5() |
|
3052 : TSendSmV1() |
|
3053 /** |
|
3054 * Default constructor. |
|
3055 */ |
|
3056 { |
|
3057 iExtensionId=KSatV5; |
|
3058 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
3059 } |
|
3060 |
|
3061 EXPORT_C RSat::TSendSmV6::TSendSmV6() |
|
3062 : TSendSmV5(),iFrameId(0) |
|
3063 /** |
|
3064 * Default constructor. |
|
3065 */ |
|
3066 { |
|
3067 iExtensionId=KSatV6; |
|
3068 } |
|
3069 |
|
3070 EXPORT_C RSat::TSendSmRspV1::TSendSmRspV1() |
|
3071 : TSatPCmdBase(), |
|
3072 iGeneralResult(KPCmdResultNotSet), |
|
3073 iInfoType(0), |
|
3074 iAdditionalInfo() |
|
3075 /** |
|
3076 * Default constructor. |
|
3077 */ |
|
3078 { |
|
3079 iExtensionId=KSatV1; |
|
3080 } |
|
3081 |
|
3082 EXPORT_C void RSat::NotifySendSmPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
3083 /** |
|
3084 * This method requests notification when a SEND SHORT MESSAGE proactive command is sent |
|
3085 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
3086 * aReqStatus is competed. Unpack the command to examine its contents. |
|
3087 * |
|
3088 * The SEND SHORT MESSAGE command asks the phone to send an SMS |
|
3089 * message. Return the response to this request to the UICC. |
|
3090 * |
|
3091 * The command is described in ETSI TS 102 223, with additional information for |
|
3092 * GSM/WCDMA networks in 3GPP TS 31.111, and for CDMA networks in 3GPP2 C.S0035-0. |
|
3093 * The command contains: |
|
3094 * |
|
3095 * - The address of the message recipient - RSat::TSendSmV1::iAddress. |
|
3096 * - The SMS message itself - RSat::TSendSmV1::iSmsTpdu. |
|
3097 * - An alpha identifier containing text to display - RSat::TSendSmV1::iAlphaId. |
|
3098 * - An icon to display - RSat::TSendSmV1::iIconId |
|
3099 * - Text attributes of text contained in iAlphaId - RSat::TSendSmV5::iTextAttribute (Symbian OS v9.2 or later) |
|
3100 * |
|
3101 * Display the icon as described in RSat::TIconId. Display the text in the alpha |
|
3102 * identifier, if there is any. If the alpha identifier is not present in the |
|
3103 * proactive command then you can display whatever you like while sending the |
|
3104 * message. |
|
3105 * |
|
3106 * However, if the alpha identifier is present in the proactive command but it is an |
|
3107 * empty string then do not display anything: just send the message without letting the |
|
3108 * user know. To help with this, send the message by calling |
|
3109 * RSat::SendMessageNoLogging() instead of the usual |
|
3110 * RMobileSmsMessaging::SendMessage(). This avoids the message being logged. |
|
3111 * |
|
3112 * Return the result of the SMS or an error code to the UICC. For Symbian |
|
3113 * OS versions up to and including v8.1a and 8.1b pass RSat::TerminalRsp() a |
|
3114 * RSat::TSendSsRspV1Pckg (a packaged TSendSsRspV1). For later versions of |
|
3115 * Symbian OS, check for an updated API (RSat::TSendSsRspV2 etc). |
|
3116 * |
|
3117 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
3118 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
3119 * command. aPCmd must be a packaged version of the latest "TSendSm" class. |
|
3120 * For Symbian OS versions up to and including v8.1a and 8.1b use |
|
3121 * RSat::TSendSmV1Pckg, a packaged RSat::TSendSmV1. |
|
3122 * For Symbian OS version 9.2, use RSat::TSendSmV5Pckg. |
|
3123 * For Symbian OS version 9.4, use RSat::TSendSmV6Pckg. |
|
3124 * For later versions of Symbian OS, check for an updated API (RSat::TSendSmV7 etc). |
|
3125 * |
|
3126 * @see RSat::TSendSmV1 |
|
3127 * @see RSat::TSendSmV5 |
|
3128 * @see RSat::TSendSmV6 |
|
3129 * @see RSat::TSendSmRspV1 |
|
3130 * |
|
3131 * @capability ReadDeviceData |
|
3132 */ |
|
3133 { |
|
3134 Get(ESatNotifySendSmPCmd,aReqStatus,aPCmd); |
|
3135 } |
|
3136 |
|
3137 |
|
3138 EXPORT_C RSat::TSendSsV1::TSendSsV1(): TSatPCmdBase() |
|
3139 /** |
|
3140 * Default constructor. |
|
3141 */ |
|
3142 { |
|
3143 iExtensionId=KSatV1; |
|
3144 iAlphaId.iStatus=EAlphaIdNotSet; |
|
3145 iSsString.iTypeOfNumber=ETypeOfNumberNotSet; |
|
3146 iSsString.iNumberPlan=ENumberingPlanNotSet; |
|
3147 iIconId.iQualifier=EIconQualifierNotSet; |
|
3148 iIconId.iIdentifier=0; |
|
3149 } |
|
3150 |
|
3151 EXPORT_C RSat::TSendSsV6::TSendSsV6() |
|
3152 : TSendSsV1() |
|
3153 /** |
|
3154 * Default constructor. |
|
3155 */ |
|
3156 { |
|
3157 iExtensionId=KSatV6; |
|
3158 iTextAttribute.iStatus =ETextAttributeNotSet; |
|
3159 } |
|
3160 |
|
3161 EXPORT_C RSat::TSendSsRspV1::TSendSsRspV1() |
|
3162 : TSatPCmdBase(), |
|
3163 iGeneralResult(KPCmdResultNotSet), |
|
3164 iInfoType(0), |
|
3165 iAdditionalInfo(), |
|
3166 iGeneralResult2(KPCmdResultNotSet), |
|
3167 iInfoType2(0), |
|
3168 iAdditionalInfo2(), |
|
3169 iCcRequestedAction() |
|
3170 /** |
|
3171 * Default constructor. |
|
3172 */ |
|
3173 { |
|
3174 iExtensionId=KSatV1; |
|
3175 } |
|
3176 |
|
3177 EXPORT_C RSat::TSendSsRspV2::TSendSsRspV2() |
|
3178 : TSendSsRspV1(), |
|
3179 iUssdString() |
|
3180 /** |
|
3181 * Default constructor. |
|
3182 */ |
|
3183 { |
|
3184 iUssdString.iDcs=0; |
|
3185 iExtensionId=KSatV2; |
|
3186 } |
|
3187 |
|
3188 EXPORT_C void RSat::NotifySendSsPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
3189 /** |
|
3190 * This method requests notification when a SEND SS proactive command is sent |
|
3191 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
3192 * aReqStatus is competed. Unpack the command to examine its contents. |
|
3193 * |
|
3194 * This command is only supported on GSM/WCDMA networks. It can be ignored on |
|
3195 * CDMA networks. |
|
3196 * |
|
3197 * The SEND SS command asks the phone to send a supplementary service request to |
|
3198 * the network. Return the response to this request to the UICC. |
|
3199 * |
|
3200 * The command is described fully in 3GPP TS 31.111 but does not appear in ETSI TS |
|
3201 * 102 223. It contains: |
|
3202 * |
|
3203 * - The supplementary services string - RSat::TSendSsV1::iSsString. |
|
3204 * - An alpha identifier containing text to display - RSat::TSendSsV1::iAlphaId. |
|
3205 * - An icon to display - RSat::TSendSsV1::iIconId |
|
3206 * |
|
3207 * See the description of the SEND SS command in 3GPP TS 31.111 for the |
|
3208 * circumstances under which the alpha identifier's text should be displayed. |
|
3209 * Display the icon as described in RSat::TIconId. |
|
3210 * |
|
3211 * Return the result of the SS request or an error code to the UICC. For Symbian |
|
3212 * OS versions up to and including v8.1a and 8.1b pass RSat::TerminalRsp() a |
|
3213 * RSat::TSendSsRspV1Pckg (a packaged TSendSsRspV1). For later versions of |
|
3214 * Symbian OS, check for an updated API (RSat::TSendSsRspV2 etc). |
|
3215 * |
|
3216 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
3217 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
3218 * command. aPCmd must be a packaged version of the latest "TSendSs" class. |
|
3219 * For Symbian OS versions up to and including v8.1a and 8.1b use |
|
3220 * RSat::TSendSsV1Pckg, a packaged RSat::TSendSsV1. |
|
3221 * For Symbian OS version 9.4, use RSat::TSendSmV6Pckg. |
|
3222 * For later versions of Symbian OS, check for an updated API (RSat::TSendSsV7 etc). |
|
3223 * |
|
3224 * @see RSat::TSendSsV1 |
|
3225 * @see RSat::TSendSsV6 |
|
3226 * @see RSat::TSendSsRspV1 |
|
3227 * |
|
3228 * @capability ReadDeviceData |
|
3229 */ |
|
3230 { |
|
3231 Get(ESatNotifySendSsPCmd,aReqStatus,aPCmd); |
|
3232 } |
|
3233 |
|
3234 |
|
3235 EXPORT_C RSat::TSendUssdV1::TSendUssdV1() |
|
3236 : TSatPCmdBase() |
|
3237 /** |
|
3238 * Default constructor. |
|
3239 */ |
|
3240 { |
|
3241 iExtensionId=KSatV1; |
|
3242 iAlphaId.iStatus=EAlphaIdNotSet; |
|
3243 iUssdString.iDcs=0; |
|
3244 iIconId.iQualifier=EIconQualifierNotSet; |
|
3245 iIconId.iIdentifier=0; |
|
3246 } |
|
3247 |
|
3248 EXPORT_C RSat::TSendUssdV6::TSendUssdV6() |
|
3249 : TSendUssdV1() |
|
3250 /** |
|
3251 * Default constructor. |
|
3252 */ |
|
3253 { |
|
3254 iExtensionId=KSatV6; |
|
3255 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
3256 } |
|
3257 |
|
3258 EXPORT_C RSat::TSendUssdRspV1::TSendUssdRspV1() |
|
3259 : TSatPCmdBase(), |
|
3260 iGeneralResult(KPCmdResultNotSet), |
|
3261 iInfoType(0), |
|
3262 iAdditionalInfo(), |
|
3263 iGeneralResult2(KPCmdResultNotSet), |
|
3264 iInfoType2(0), |
|
3265 iAdditionalInfo2(), |
|
3266 iCcRequestedAction() |
|
3267 /** |
|
3268 * Default constructor. |
|
3269 */ |
|
3270 { |
|
3271 iExtensionId=KSatV1; |
|
3272 iUssdString.iDcs=0; |
|
3273 } |
|
3274 |
|
3275 EXPORT_C void RSat::NotifySendUssdPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
3276 /** |
|
3277 * This method requests notification when a SEND USSD proactive command is sent |
|
3278 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
3279 * aReqStatus is competed. Unpack the command to examine its contents. |
|
3280 * |
|
3281 * This command is only supported on GSM/WCDMA networks. It can be ignored on |
|
3282 * CDMA networks. |
|
3283 * |
|
3284 * The SEND USSD command asks the phone to send an Unstructured Supplementary |
|
3285 * Service Data request to the network. Return the response to this request to |
|
3286 * the UICC. |
|
3287 * |
|
3288 * The command is described fully in 3GPP TS 31.111. Note that it does not appear in ETSI TS |
|
3289 * 102 223. It contains: |
|
3290 * |
|
3291 * - The Unstructured Supplementary Service Data (USSD) string - RSat::TSendUssdV1::iUssdString. |
|
3292 * - An alpha identifier containing text to display - RSat::TSendUssdV1::iAlphaId. |
|
3293 * - An icon to display - RSat::TSendUssdV1::iIconId |
|
3294 * |
|
3295 * See the description of the SEND USSD command in 3GPP TS 31.111 for the |
|
3296 * circumstances under which the alpha identifier's text should be displayed. |
|
3297 * Display the icon as described in RSat::TIconId. |
|
3298 * |
|
3299 * Return the result of the USSD request or an error code to the UICC. For Symbian |
|
3300 * OS versions up to and including v8.1a and 8.1b pass RSat::TerminalRsp() a |
|
3301 * RSat::TSendUssdRspV1Pckg (a packaged TSendUssdRspV1). For later versions of |
|
3302 * Symbian OS, check for an updated API (RSat::TSendUssdRspV2 etc). |
|
3303 * |
|
3304 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
3305 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
3306 * command. aPCmd must be a packaged version of the latest "TSendUssd" class. |
|
3307 * For Symbian OS versions up to and including v8.1a and 8.1b use |
|
3308 * RSat::TSendUssdV1Pckg, a packaged RSat::TSendUssdV1. |
|
3309 * For Symbian OS versions 9.4 and above use |
|
3310 * RSat::TSendUssdV6Pckg, a packaged RSat::TSendUssdV6. For later versions of |
|
3311 * Symbian OS, check for an updated API (RSat::TSendUssdV7 etc). |
|
3312 * |
|
3313 * @see RSat::TSendUssdV1 |
|
3314 * @see RSat::TSendUssdV6 |
|
3315 * @see RSat::TSendUssdRspV1 |
|
3316 * |
|
3317 * @capability ReadDeviceData |
|
3318 */ |
|
3319 { |
|
3320 Get(ESatNotifySendUssdPCmd,aReqStatus,aPCmd); |
|
3321 } |
|
3322 |
|
3323 EXPORT_C RSat::TSetUpCallV1::TSetUpCallV1() |
|
3324 : TSatPCmdBase(), |
|
3325 iType(ESetUpCallTypeNotSet), |
|
3326 iCapabilityConfigParams(), |
|
3327 iSubAddress() |
|
3328 /** |
|
3329 * Default constructor. |
|
3330 */ |
|
3331 { |
|
3332 iExtensionId=KSatV1; |
|
3333 iDuration.iTimeUnit=ETimeUnitNotSet; |
|
3334 iDuration.iNumOfUnits=0; |
|
3335 iAlphaIdConfirmationPhase.iStatus=EAlphaIdNotSet; |
|
3336 iAlphaIdCallSetUpPhase.iStatus=EAlphaIdNotSet; |
|
3337 iAddress.iTypeOfNumber=ETypeOfNumberNotSet; |
|
3338 iAddress.iNumberPlan=ENumberingPlanNotSet; |
|
3339 iIconIdConfirmationPhase.iQualifier=EIconQualifierNotSet; |
|
3340 iIconIdConfirmationPhase.iIdentifier=0; |
|
3341 iIconIdCallSetUpPhase.iQualifier=EIconQualifierNotSet; |
|
3342 iIconIdCallSetUpPhase.iIdentifier=0; |
|
3343 } |
|
3344 |
|
3345 EXPORT_C RSat::TSetUpCallV5::TSetUpCallV5() |
|
3346 : TSetUpCallV1() |
|
3347 /** |
|
3348 * Default constructor. |
|
3349 */ |
|
3350 { |
|
3351 iExtensionId=KSatV5; |
|
3352 iTextAttributeConfirmationPhase.iStatus = ETextAttributeNotSet; |
|
3353 iTextAttributeCallSetUpPhase.iStatus = ETextAttributeNotSet; |
|
3354 } |
|
3355 |
|
3356 EXPORT_C RSat::TSetUpCallV6::TSetUpCallV6() |
|
3357 : TSetUpCallV5(),iFrameId(0) |
|
3358 /** |
|
3359 * Default constructor. |
|
3360 */ |
|
3361 { |
|
3362 iExtensionId=KSatV6; |
|
3363 } |
|
3364 |
|
3365 EXPORT_C RSat::TSetUpCallRspV1::TSetUpCallRspV1() |
|
3366 : TSatPCmdBase(), |
|
3367 iGeneralResult(KPCmdResultNotSet), |
|
3368 iInfoType(0), |
|
3369 iAdditionalInfo(), |
|
3370 iGeneralResult2(KPCmdResultNotSet), |
|
3371 iInfoType2(0), |
|
3372 iAdditionalInfo2(), |
|
3373 iCcRequestedAction() |
|
3374 /** |
|
3375 * Default constructor. |
|
3376 */ |
|
3377 { |
|
3378 iExtensionId=KSatV1; |
|
3379 } |
|
3380 |
|
3381 EXPORT_C RSat::TSetUpCallRspV2::TSetUpCallRspV2() |
|
3382 : TSetUpCallRspV1(), |
|
3383 iUssdString() |
|
3384 /** |
|
3385 * Default constructor. |
|
3386 */ |
|
3387 { |
|
3388 iUssdString.iDcs=0; |
|
3389 iExtensionId=KSatV2; |
|
3390 } |
|
3391 |
|
3392 EXPORT_C void RSat::NotifySetUpCallPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
3393 /** |
|
3394 * This method requests notification when a SET UP CALL proactive command is sent |
|
3395 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
3396 * aReqStatus is competed. Unpack the command to examine its contents. |
|
3397 * |
|
3398 * The SET UP CALL command asks you to connect a phone call. The |
|
3399 * command is described fully in ETSI TS 102 223. Briefly, though, the command |
|
3400 * includes: |
|
3401 * |
|
3402 * - The number to call - RSat::TSetUpCallV1::iAddress |
|
3403 * - The sub-address of the remote party - RSat::TSetUpCallV1::iSubAddress |
|
3404 * - Capability configuration parameters - RSat::TSetUpCallV1::iCapabilityConfigParams |
|
3405 * - The procedure to follow if there is already a call in progress - RSat::TSetUpCallV1::iType |
|
3406 * - Determines whether you re-dial if initial attempts to make the call fail - RSat::TSetUpCallV1::iType |
|
3407 * - Detemines how long you should you try to re-dial - RSat::TSetUpCallV1::iDuration |
|
3408 * - An icon and some text for the confirmation phase - RSat::TSetUpCallV1::iAlphaIdConfirmationPhase and RSat::TSetUpCallV1::iIconIdConfirmationPhase |
|
3409 * - An icon and some text for the 'call set up' phase - RSat::TSetUpCallV1::iAlphaIdCallSetUpPhase and RSat::TSetUpCallV1::iIconIdCallSetUpPhase |
|
3410 * - Text attribute information for RSat::TSetUpCallV1::iAlphaIdConfirmationPhase and |
|
3411 * RSat::TSetUpCallV1::iAlphaIdCallSetUpPhase stored in |
|
3412 * RSat::TSetUpCallV5::iTextAttributeCallSetUpPhase and |
|
3413 * RSat::TSetUpCallV5::iTextAttributeConfirmationPhase respectively. (Symbian OS v9.2 and later) |
|
3414 * |
|
3415 * After receiving the command, first look at RSat::TSetUpCallV1::iType to decide |
|
3416 * whether to make the call. Then you need to ask the user's permission to call. This is |
|
3417 * the confirmation phase. Display the confirmation alpha ID and icon as |
|
3418 * described in ETSI TS 102 223. |
|
3419 * |
|
3420 * If the user gives permission, you can dial the number and attempt to connect |
|
3421 * the call. This is the 'call set up' phase. Display the call setup alpha ID and |
|
3422 * icon as described in ETSI TS 102 223. |
|
3423 * |
|
3424 * If the call could not be connected, look at RSat::TSetUpCallV1::iType to see |
|
3425 * whether you should try to dial again. Do not re-dial for longer than |
|
3426 * RSat::TSetUpCallV1::iDuration. |
|
3427 * |
|
3428 * Once the call has connected, or if the call could not be made and you have |
|
3429 * finished re-dialling, you must give your response to the SET UP CALL command. |
|
3430 * For Symbian OS v6.1 or v7.0 pass RSat::TerminalRsp() a |
|
3431 * RSat::TSetUpCallRspV1Pckg (a packaged TSetUpCallRspV1). For versions up to and |
|
3432 * including v8.1a and v8.1b use RSat::TSetUpCallRspV2Pckg (a packaged |
|
3433 * RSat::TSetUpCallRspV2). For later versions of Symbian OS, check for an |
|
3434 * updated API (RSat::TSetUpCallRspV3 etc). |
|
3435 * |
|
3436 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
3437 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
3438 * command. aPCmd must be a packaged version of the latest "TSetUpCall" class. |
|
3439 * For Symbian OS versions up to and including v8.1a and 8.1b use |
|
3440 * RSat::TSetUpCallV1Pckg, a packaged RSat::TSetUpCallV1. |
|
3441 * For Symbian OS version 9.2, use RSat::TSetUpCallV5Pckg. |
|
3442 * For Symbian OS version 9.4, use RSat::TSetUpCallV6Pckg. |
|
3443 * For later versions of Symbian OS, check for an updated API |
|
3444 * (RSat::TSetUpCallV7 etc). |
|
3445 * |
|
3446 * @see RSat::TSetUpCallV1 |
|
3447 * @see RSat::TSetUpCallV5 |
|
3448 * @see RSat::TSetUpCallV6 |
|
3449 * @see RSat::TSetUpCallRspV1 |
|
3450 * @see RSat::TSetUpCallRspV2 |
|
3451 * |
|
3452 * @capability ReadUserData |
|
3453 */ |
|
3454 { |
|
3455 Get(ESatNotifySetUpCallPCmd,aReqStatus,aPCmd); |
|
3456 } |
|
3457 |
|
3458 EXPORT_C RSat::TRefreshV1::TRefreshV1() |
|
3459 : TSatPCmdBase(), |
|
3460 iType(ERefreshTypeNotSet), |
|
3461 iFileList() |
|
3462 /** |
|
3463 * Default constructor. |
|
3464 */ |
|
3465 { |
|
3466 iExtensionId=KSatV1; |
|
3467 } |
|
3468 |
|
3469 EXPORT_C RSat::TRefreshV2::TRefreshV2() |
|
3470 : TRefreshV1(), |
|
3471 iAid() |
|
3472 /** |
|
3473 * Default constructor. |
|
3474 */ |
|
3475 { |
|
3476 iExtensionId=KSatV2; |
|
3477 } |
|
3478 |
|
3479 EXPORT_C RSat::TRefreshRspV1::TRefreshRspV1() |
|
3480 : TSatPCmdBase(), |
|
3481 iGeneralResult(KPCmdResultNotSet), |
|
3482 iInfoType(0), |
|
3483 iAdditionalInfo() |
|
3484 /** |
|
3485 * Default constructor. |
|
3486 */ |
|
3487 { |
|
3488 iExtensionId=KSatV1; |
|
3489 } |
|
3490 |
|
3491 EXPORT_C void RSat::NotifyRefreshPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
3492 /** |
|
3493 * This method requests notification when a REFRESH proactive command is sent |
|
3494 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
3495 * aReqStatus is competed. Unpack the command to examine its contents. |
|
3496 * |
|
3497 * The REFRESH command is described fully in ETSI TS 102 223. It tells you three |
|
3498 * main things: |
|
3499 * |
|
3500 * - It can indicate that one or more of the files on the UICC have changed. |
|
3501 * - It can request that the UICC has been reset. |
|
3502 * - It can request that one of the applications running on the UICC be refreshed. |
|
3503 * |
|
3504 * RSat::TRefreshV1::iType indicates any or all of these things. If one or more |
|
3505 * of the data files on the UICC have changed, a list of the changed files will be |
|
3506 * given in RSat::TRefreshV1::iFileList. This will be a series of identifiers |
|
3507 * from RSat::TElementaryFiles. If an application needs to be refreshed, its ID |
|
3508 * is in RSat::TRefreshV2::iAid. |
|
3509 * |
|
3510 * Any application that deals with UICC data may want to receive notification when |
|
3511 * files change. For instance, the address book application may want to know if |
|
3512 * the address book data changes. Hence the procedure for handling REFRESH |
|
3513 * commands is more complicated than other proactive commands. The following |
|
3514 * scheme is necessary to allow for multiple clients to process a REFRESH |
|
3515 * notification: |
|
3516 * |
|
3517 * Your phone's main SAT application decides when other applications receive |
|
3518 * REFRESH commands. If the main SAT application is in the middle of editing UICC |
|
3519 * data, it can delay the REFRESH notification to other applications until it |
|
3520 * has finished editing: |
|
3521 * |
|
3522 * - To request notification of a REFRESH proactive command, the main SAT |
|
3523 * application calls both RSat::NotifyRefreshRequired() and |
|
3524 * RSat::NotifyRefreshPCmd(), while other applications only call |
|
3525 * RSat::NotifyRefreshPCmd(). |
|
3526 * |
|
3527 * - When the UICC sends a REFRESH command, the RSat::NotifyRefreshRequired() |
|
3528 * notification completes. This tells the main SAT application that a REFRESH |
|
3529 * command is pending. This gives the main SAT application a chance to tidy up. |
|
3530 * |
|
3531 * - Once the main SAT application is ready, it calls RSat::RefreshAllowed(). |
|
3532 * This tells the TSY that it can complete any outstanding |
|
3533 * RSat::NotifyRefreshPCmd() requests. |
|
3534 * |
|
3535 * Once you have dealt with a REFRESH command, you must give your response to the |
|
3536 * UICC. For Symbian OS versions up to and included v8.1a and v8.1b pass a |
|
3537 * RSat::TRefreshRspV2Pckg (a packaged RSat::TRefreshRspV2) to RSat::TerminalRsp(). |
|
3538 * For later versions of Symbian OS, check for an updated API (RSat::TRefreshRspV3 |
|
3539 * etc). |
|
3540 * |
|
3541 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
3542 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
3543 * command. For Symbian OS 7.0s, 8.0 and 8.1 use |
|
3544 * RSat::TRefreshV2Pckg, a packaged RSat::TRefreshV2. Use RSat::TRefreshV1 with |
|
3545 * older versions of Symbian OS. For later versions of Symbian OS, check for an |
|
3546 * updated API (RSat::TRefreshV3 etc). |
|
3547 * |
|
3548 * @see RSat::TRefreshV1 |
|
3549 * @see RSat::TRefreshV2 |
|
3550 * @see RSat::TRefreshRspV1 |
|
3551 * @see RSat::NotifyRefreshRequired() |
|
3552 * @see RSat::RefreshAllowed() |
|
3553 * |
|
3554 * @capability None |
|
3555 */ |
|
3556 { |
|
3557 Get(ESatNotifyRefreshPCmd,aReqStatus,aPCmd); |
|
3558 } |
|
3559 |
|
3560 EXPORT_C RSat::TSetUpEventListV1::TSetUpEventListV1() |
|
3561 : TSatPCmdBase(), |
|
3562 iType(ESetUpEventListTypeNotSet), |
|
3563 iEvents(0) |
|
3564 /** |
|
3565 * Default constructor. |
|
3566 */ |
|
3567 { |
|
3568 iExtensionId=KSatV1; |
|
3569 } |
|
3570 |
|
3571 EXPORT_C RSat::TSetUpEventListRspV1::TSetUpEventListRspV1() |
|
3572 : TSatPCmdBase(), |
|
3573 iGeneralResult(KPCmdResultNotSet), |
|
3574 iInfoType(0), |
|
3575 iAdditionalInfo() |
|
3576 /** |
|
3577 * Default constructor. |
|
3578 */ |
|
3579 { |
|
3580 iExtensionId=KSatV1; |
|
3581 } |
|
3582 |
|
3583 EXPORT_C void RSat::NotifySetUpEventListPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
3584 /** |
|
3585 * This method requests notification when a SET UP EVENT LIST proactive command is sent |
|
3586 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
3587 * aReqStatus is competed. Unpack the command to examine its contents. |
|
3588 * |
|
3589 * The SET UP EVENT LIST command gives the phone a list of events about which |
|
3590 * the UICC is interested in receiving notification. The event list may include |
|
3591 * such things as a change of access technology, user |
|
3592 * action, browser termination and more. You must inform the UICC when an event |
|
3593 * on the list occurs by calling RSat::EventDownload(). If the event is not on the |
|
3594 * list then you do not need to notify the UICC. |
|
3595 * |
|
3596 * RSat::TSetUpEventListV1::iEvents field contains |
|
3597 * the list of events in the form of flags from RSat::TEventList. When a flagged |
|
3598 * event occurs, notify the UICC by passing RSat::EventDownload() the appropriate |
|
3599 * flag. Many events require you to supply information about the event. |
|
3600 * |
|
3601 * The events, their flags and any additional information required by the UICC are |
|
3602 * shown below. Most events are described in the "Envelope Commands (Event |
|
3603 * Download)" section of ETSI TS 102 223. 3GPP TS 31.111 contains additional |
|
3604 * detail for certain events on GSM/WCDMA networks. |
|
3605 * |
|
3606 * - MT(Mobile Terminated) Call Event - RSat::KMTCall flag. Notify the UICC when the |
|
3607 * phone receives a call setup message. Return the transaction number, address |
|
3608 * and subaddress as defined in ETSI TS 102 223 (and 3GPP TS 31.111 on GSM/WCDMA |
|
3609 * networks.) This event is often handled by the TSY, in which case RSat clients can ignore it. |
|
3610 * |
|
3611 * - Call Connected Event - RSat::KCallConnected flag. Notify the UICC when the |
|
3612 * phone receives or sends a call connect message for mobile-terminated calls. |
|
3613 * Return the transaction number as defined in as defined in ETSI TS 102 223 (and |
|
3614 * 3GPP TS 31.111 on GSM/WCDMA networks.) This event is often handled by the TSY, |
|
3615 * in which case RSat clients can ignore it. |
|
3616 * |
|
3617 * - Call Disconnected Event - RSat::KCallDisconnected flag. Notify the UICC |
|
3618 * when a call is disconnected. Return the transaction number and cause code as |
|
3619 * defined in ETSI TS 102 223 (and 3GPP TS 31.111 on GSM/WCDMA networks.) |
|
3620 * This event is often handled by the TSY, in which case RSat clients can ignore it. |
|
3621 * |
|
3622 * - Location Status Event - RSat::KLocationStatus flag. Notify the UICC when |
|
3623 * the phone has changed location. This only happens when the phone enters the |
|
3624 * idle state. Return the location information and location status as defined in |
|
3625 * as defined in ETSI TS 102 223 (and 3GPP TS 31.111 on GSM/WCDMA networks.) |
|
3626 * This event is often handled by the TSY, in which case RSat clients can ignore |
|
3627 * it. |
|
3628 * |
|
3629 * - User Activity Event - RSat::KUserActivity flag. Notify the UICC when you |
|
3630 * detect some user activity (e.g. a key-press, removal of key-lock). There is |
|
3631 * no additional information to be returned to the UICC. Unlike the majority of |
|
3632 * other events, you should only respond to the first instance of user activity. |
|
3633 * Ignore subsequent user activity unless the UICC sends another SET UP EVENT LIST |
|
3634 * command listing the user activity event. |
|
3635 * |
|
3636 * - Idle Screen Available Event - RSat::KIdleScreenAvailable flag. Notify the |
|
3637 * UICC when the phone next enters a state where it is willing to display text |
|
3638 * that is not urgent. More specifically, the phone will accept rather than |
|
3639 * reject a DISPLAY TEXT command of normal priority. Unlike the majority of other |
|
3640 * events, you should only respond to the first "Idle screen available event". |
|
3641 * Ignore subsequent events unless the UICC sends another SET UP EVENT LIST command |
|
3642 * listing the "Idle screen available event". |
|
3643 * |
|
3644 * - Card Reader Status Event - RSat::KCardReaderStatus flag. Notify the UICC |
|
3645 * when a card reader becomes available or unavailable, and when a card is |
|
3646 * inserted or removed. Return the new status. This is a |
|
3647 * RSat::TCardReaderStatusEventV2 containing the "Card Reader Status" object |
|
3648 * defined in ETSI TS 102 223's object definitions. |
|
3649 * |
|
3650 * - Language Selection Event - RSat::KLanguageSelection flag. Notify the UICC |
|
3651 * when the user selects a new language. Return the new language in a |
|
3652 * RSat::TLanguageSelectionEventV2. |
|
3653 * |
|
3654 * - Browser Termination Event - RSat::KBrowserTermination flag. Notify the UICC |
|
3655 * when the browser is terminated either by the user action or by an error. |
|
3656 * Return the reason for termination in a RSat::TBrowserTerminationEventV2. |
|
3657 * |
|
3658 * - Data Available Event - RSat::KDataAvailable flag. Notify the UICC when the |
|
3659 * phone receives data. Return status of the channel |
|
3660 * that received the data in a RSat::TDataAvailableEventV2. Also return the |
|
3661 * length of data received. |
|
3662 * |
|
3663 * - Channel status event - RSat::KChannelStatus flag. Notify the UICC when a |
|
3664 * link enters an error condition. Return status of |
|
3665 * the channel in a RSat::TChannelStatusEventV2. |
|
3666 * |
|
3667 * - Access Technology Change Event - RSat::KAccessTechnologyChange flag. |
|
3668 * Notify the UICC when the phone detects a change in its current access |
|
3669 * technology. |
|
3670 * |
|
3671 * - Display Parameters Changed Event - RSat::KDisplayParamsChanges flag. Notify |
|
3672 * the UICC when the phone's screen is resized. Return the new screen parameters |
|
3673 * in a RSat::TDisplayParamsEventV2. |
|
3674 * |
|
3675 * - Local Connection Event - RSat::KLocalConnection flag. Notify the UICC when |
|
3676 * the phone receives an incoming connection request on a local bearer using a |
|
3677 * service previously declared by the UICC. |
|
3678 * Return information about the new connection in a RSat::TLocalConnectionEventV2. |
|
3679 * |
|
3680 * As an alternative to the above, the SET UP EVENT LIST command may cancel the |
|
3681 * previous command. It does this by setting the command's |
|
3682 * RSat::TSetUpEventListV1::iType to RSat::ERemoveExistingEventList instead of |
|
3683 * RSat::EUpdateEventList. |
|
3684 * |
|
3685 * You must give your response to the command after you receive it. In Symbian OS |
|
3686 * versions up to and including 8.1a & 8.1b, pass RSat::TerminalRsp() a |
|
3687 * RSat::TSetUpEventListRspV1Pckg (a packaged TSetUpEventListRspV1). For later |
|
3688 * versions of Symbian OS, check for an updated API (RSat::TSetUpEventListRspV2 |
|
3689 * etc). |
|
3690 * |
|
3691 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
3692 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
3693 * command. aPCmd must be a packaged version of the latest "TSetUpEventList" |
|
3694 * class. For Symbian OS versions up to and including 8.1a and 8,1b, use |
|
3695 * RSat::TSetUpEventListV1Pckg, a packaged RSat::TSetUpEventListV1. For later |
|
3696 * versions of Symbian OS, check for an updated API (RSat::TSetUpEventListV2 etc). |
|
3697 * |
|
3698 * @see RSat::TSetUpEventListV1 |
|
3699 * @see RSat::TSetUpEventListRspV1 |
|
3700 * @see RSat::TEventList |
|
3701 * @see RSat::TEventDownloadBaseV2 |
|
3702 * @see RSat::TCardReaderStatusEventV2 |
|
3703 * @see RSat::TLanguageSelectionEventV2 |
|
3704 * @see RSat::TBrowserTerminationEventV2 |
|
3705 * @see RSat::TDataAvailableEventV2 |
|
3706 * @see RSat::TChannelStatusEventV2 |
|
3707 * @see RSat::TDisplayParamsEventV2 |
|
3708 * @see RSat::TLocalConnectionEventV2 |
|
3709 * |
|
3710 * @capability None |
|
3711 */ |
|
3712 { |
|
3713 Get(ESatNotifySetUpEventListPCmd,aReqStatus,aPCmd); |
|
3714 } |
|
3715 |
|
3716 EXPORT_C RSat::TSetUpIdleModeTextV1::TSetUpIdleModeTextV1() |
|
3717 : TSatPCmdBase(), |
|
3718 iType(ESetUpIdleModeTextTypeNotSet), |
|
3719 iText() |
|
3720 /** |
|
3721 * Default constructor. |
|
3722 */ |
|
3723 { |
|
3724 iExtensionId=KSatV1; |
|
3725 iIconId.iQualifier=EIconQualifierNotSet; |
|
3726 iIconId.iIdentifier=0; |
|
3727 iCodingScheme=E7bitPacked; |
|
3728 } |
|
3729 |
|
3730 EXPORT_C RSat::TSetUpIdleModeTextV5::TSetUpIdleModeTextV5() |
|
3731 : TSetUpIdleModeTextV1() |
|
3732 /** |
|
3733 * Default constructor. |
|
3734 */ |
|
3735 { |
|
3736 iExtensionId=KSatV5; |
|
3737 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
3738 } |
|
3739 |
|
3740 EXPORT_C RSat::TSetUpIdleModeTextV6::TSetUpIdleModeTextV6() |
|
3741 : TSetUpIdleModeTextV5(),iFrameId(0) |
|
3742 /** |
|
3743 * Default constructor. |
|
3744 */ |
|
3745 { |
|
3746 iExtensionId=KSatV6; |
|
3747 } |
|
3748 |
|
3749 EXPORT_C RSat::TSetUpIdleModeTextRspV1::TSetUpIdleModeTextRspV1() |
|
3750 : TSatPCmdBase(), |
|
3751 iGeneralResult(KPCmdResultNotSet), |
|
3752 iInfoType(0), |
|
3753 iAdditionalInfo() |
|
3754 /** |
|
3755 * Default constructor. |
|
3756 */ |
|
3757 { |
|
3758 iExtensionId=KSatV1; |
|
3759 } |
|
3760 |
|
3761 EXPORT_C void RSat::NotifySetUpIdleModeTextPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
3762 /** |
|
3763 * This method requests notification when a SET UP IDLE MODE TEXT proactive command is sent |
|
3764 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
3765 * aReqStatus is competed. Unpack the command to examine its contents. |
|
3766 * |
|
3767 * The SET UP IDLE MODE TEXT command provides text (and optionally an icon) to be |
|
3768 * displayed when the phone is idle. The presentation style is not defined by |
|
3769 * this command; that is left to the phone designer. The command is described |
|
3770 * fully in ETSI TS 102 223. |
|
3771 * |
|
3772 * Two types of command can be sent by the UICC: |
|
3773 * |
|
3774 * - If RSat::TSetUpIdleModeTextV1::iType is RSat::EUpdateIdleModeText then the |
|
3775 * command contains idle mode text in RSat::TSetUpIdleModeTextV1::iText and, |
|
3776 * optionally, an icon to display in RSat::TSetUpIdleModeTextV1::iIconId. It also |
|
3777 * contains the scheme in which iText has been encoded (7-bit packed, 7-bit unpacked |
|
3778 * or 16-bit UCS-2 Unicode). In Symbian OS v9.2, optional text attribute information |
|
3779 * may be present in RSat::TSetUpIdleModeTextV5::iTextAttribute. |
|
3780 * |
|
3781 * - If RSat::TSetUpIdleModeTextV1::iType is RSat::ERemoveExistingIdleModeText |
|
3782 * then the idle mode text and icon from a previous SET UP IDLE MODE TEXT command |
|
3783 * should no longer be used. The command does not contain text or an icon. |
|
3784 * |
|
3785 * Once you have dealt with the command, you must give your response to the SET UP |
|
3786 * IDLE MODE TEXT command. For Symbian OS versions up to and including v8.1a and |
|
3787 * v8.1b pass RSat::TerminalRsp() a RSat::TSetUpIdleModeTextRspV1Pckg (a packaged |
|
3788 * RSat::TSetUpIdleModeTextRspV1). For later versions of Symbian OS, check for an updated API |
|
3789 * (RSat::TSetUpIdleModeTextRspV2 etc). |
|
3790 * |
|
3791 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
3792 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
3793 * command. aPCmd must be a packaged version of the latest "TSetUpIdleModeText" class. |
|
3794 * For Symbian OS versions up to and including v8.1a and 8.1b use |
|
3795 * RSat::TSetUpIdleModeTextV1Pckg, a packaged RSat::TSetUpIdleModeTextV1. |
|
3796 * For Symbian OS version 9.2, use RSat::TSetUpIdleModeTextV5Pckg. |
|
3797 * For Symbian OS version 9.4, use RSat::TSetUpIdleModeTextV6Pckg. |
|
3798 * For later versions of Symbian OS, check for an updated API (RSat::TSetUpIdleModeTextV7 etc). |
|
3799 * |
|
3800 * @see RSat::TSetUpIdleModeTextV1 |
|
3801 * @see RSat::TSetUpIdleModeTextV5 |
|
3802 * @see RSat::TSetUpIdleModeTextV6 |
|
3803 * @see RSat::TSetUpIdleModeTextRspV1 |
|
3804 * |
|
3805 * @capability ReadDeviceData |
|
3806 */ |
|
3807 { |
|
3808 Get(ESatNotifySetUpIdleModeTextPCmd,aReqStatus,aPCmd); |
|
3809 } |
|
3810 |
|
3811 EXPORT_C RSat::TSendDtmfV1::TSendDtmfV1() |
|
3812 : TSatPCmdBase(), |
|
3813 iDtmfString() |
|
3814 /** |
|
3815 * Default constructor. |
|
3816 */ |
|
3817 { |
|
3818 iExtensionId=KSatV1; |
|
3819 iAlphaId.iStatus=EAlphaIdNotSet; |
|
3820 iIconId.iQualifier=EIconQualifierNotSet; |
|
3821 iIconId.iIdentifier=0; |
|
3822 } |
|
3823 |
|
3824 EXPORT_C RSat::TSendDtmfV5::TSendDtmfV5() |
|
3825 : TSendDtmfV1() |
|
3826 /** |
|
3827 * Default constructor. |
|
3828 */ |
|
3829 { |
|
3830 iExtensionId=KSatV5; |
|
3831 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
3832 } |
|
3833 |
|
3834 EXPORT_C RSat::TSendDtmfV6::TSendDtmfV6() |
|
3835 : TSendDtmfV5(),iFrameId(0) |
|
3836 /** |
|
3837 * Default constructor. |
|
3838 */ |
|
3839 { |
|
3840 iExtensionId=KSatV6; |
|
3841 } |
|
3842 |
|
3843 EXPORT_C RSat::TSendDtmfRspV1::TSendDtmfRspV1() |
|
3844 : TSatPCmdBase(), |
|
3845 iGeneralResult(KPCmdResultNotSet), |
|
3846 iInfoType(0), |
|
3847 iAdditionalInfo() |
|
3848 /** |
|
3849 * Default constructor. |
|
3850 */ |
|
3851 { |
|
3852 iExtensionId=KSatV1; |
|
3853 } |
|
3854 |
|
3855 EXPORT_C void RSat::NotifySendDtmfPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
3856 /** |
|
3857 * This method requests notification when a SEND DTMF proactive command is sent |
|
3858 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
3859 * aReqStatus is competed. Unpack the command to examine its contents. |
|
3860 * |
|
3861 * The SEND DTMF command asks the phone to send a DTMF string. A call must be in |
|
3862 * progress to send DTMF tones. This command is independent of sending DTMF within |
|
3863 * the call set up (as defined in the SET UP CALL command) and therefore can be |
|
3864 * used at any time during a call. |
|
3865 * |
|
3866 * The command is described fully in ETSI TS 102 223. It contains: |
|
3867 * |
|
3868 * - The DTMF string - RSat::TSendDtmfV1::iDtmfString. |
|
3869 * - An alpha identifier containing text to display - RSat::TSendDtmfV1::iAlphaId. |
|
3870 * - An icon to display - RSat::TSendDtmfV1::iIconId |
|
3871 * - Text attributes of text contained in iAlphaId - RSat::TSendDtmfV5::iTextAttribute |
|
3872 * (Symbian OS v9.2 or later) |
|
3873 * |
|
3874 * See the description of the SEND DTMF command in ETSI TS 102 223 for the |
|
3875 * circumstances under which the alpha identifier's text should be displayed. |
|
3876 * Display the icon as described in RSat::TIconId. |
|
3877 * |
|
3878 * Once you have dealt with the command, you must give your response to the SEND |
|
3879 * DTMF command. For Symbian OS v6.1 or v7.0 pass RSat::TerminalRsp() a |
|
3880 * RSat::TSendDtmfRspV1Pckg (a packaged TSendDtmfRspV1). For versions 7.0s, v8.1a and |
|
3881 * v8.1b use RSat::TSendDtmfRspV2Pckg (a packaged TSendDtmfRspV2). For later versions |
|
3882 * of Symbian OS, check for an updated API (RSat::TSendDtmfRspV3 etc). |
|
3883 * |
|
3884 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
3885 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
3886 * command. aPCmd must be a packaged version of the latest "TSendDtmf" class. |
|
3887 * For Symbian OS versions up to and including v8.1a and 8.1b use |
|
3888 * RSat::TSendDtmfV1Pckg, a packaged RSat::TSendDtmfV1. |
|
3889 * For Symbian OS version 9.2, use RSat::TSendDtmfV5. |
|
3890 * For Symbian OS version 9.4, use RSat::TSendDtmfV6. |
|
3891 * For later versions of Symbian OS, check for an updated API (RSat::TSendDtmfV7 etc). |
|
3892 * |
|
3893 * @see RSat::TSendDtmfV1 |
|
3894 * @see RSat::TSendDtmfV5 |
|
3895 * @see RSat::TSendDtmfV6 |
|
3896 * @see RSat::TSendDtmfRspV1 |
|
3897 * |
|
3898 * @capability ReadDeviceData |
|
3899 */ |
|
3900 { |
|
3901 Get(ESatNotifySendDtmfPCmd,aReqStatus,aPCmd); |
|
3902 } |
|
3903 |
|
3904 EXPORT_C RSat::TPerformCardApduV2::TPerformCardApduV2() |
|
3905 : TSatPCmdBase(), |
|
3906 iDestination(KDeviceIdNotSet), |
|
3907 iCApdu() |
|
3908 /** |
|
3909 * Default constructor. |
|
3910 */ |
|
3911 { |
|
3912 iExtensionId=KSatV2; |
|
3913 } |
|
3914 |
|
3915 EXPORT_C RSat::TPerformCardApduRspV2::TPerformCardApduRspV2() |
|
3916 : TSatPCmdBase(), |
|
3917 iGeneralResult(KPCmdResultNotSet), |
|
3918 iInfoType(0), |
|
3919 iAdditionalInfo() |
|
3920 { |
|
3921 iExtensionId=KSatV2; |
|
3922 } |
|
3923 |
|
3924 EXPORT_C void RSat::NotifyPerformCardApduPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
3925 /** |
|
3926 * This method requests notification when a PERFORM CARD APDU proactive command is sent |
|
3927 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
3928 * aReqStatus is competed. Unpack the command to examine its contents. |
|
3929 * |
|
3930 * The PERFORM CARD APDU command asks the phone to send an APDU command to the |
|
3931 * card specified in the command. The command is described fully in ETSI TS 102 |
|
3932 * 223. Symbian OS support for this command is available from v7.0s onwards. |
|
3933 * |
|
3934 * The command includes: |
|
3935 * |
|
3936 * - The APDU command - RSat::TPerformCardApduV2::iCApdu |
|
3937 * - The device that the APDU command is for - RSat::TPerformCardApduV2::iDestination |
|
3938 * |
|
3939 * Once you have dealt with the APDU command, you must give your response to the |
|
3940 * PERFORM CARD APDU command. This should include the APDU command results, if |
|
3941 * there are any. For Symbian OS versions from v7.0s to v8.1a and v8.1b, pass |
|
3942 * RSat::TerminalRsp() a RSat::TPerformCardApduRspV2Pckg (a packaged |
|
3943 * RSat::TPerformCardApduRspV2). For later versions of Symbian OS, check for an updated API |
|
3944 * (RSat::TPerformCardApduRspV3 etc). |
|
3945 * |
|
3946 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
3947 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
3948 * command. Use a packaged version of the latest "TPerformCardApdu" class. For |
|
3949 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TPerformCardApduV2Pckg, a packaged |
|
3950 * RSat::TPerformCardApduV2. For later versions of Symbian OS, check for an updated API |
|
3951 * (RSat::TPerformCardApduV3 etc). |
|
3952 * |
|
3953 * @see RSat::TPerformCardApduV2 |
|
3954 * @see RSat::TPerformCardApduRspV2 |
|
3955 * |
|
3956 * @capability ReadDeviceData |
|
3957 */ |
|
3958 { |
|
3959 Get(ESatNotifyPerformCardApduPCmd,aReqStatus,aPCmd); |
|
3960 } |
|
3961 |
|
3962 EXPORT_C RSat::TPowerOffCardV2::TPowerOffCardV2() |
|
3963 : TSatPCmdBase(), |
|
3964 iDestination(KDeviceIdNotSet) |
|
3965 /** |
|
3966 * Default constructor. |
|
3967 */ |
|
3968 { |
|
3969 iExtensionId=KSatV2; |
|
3970 } |
|
3971 |
|
3972 EXPORT_C RSat::TPowerOffCardRspV2::TPowerOffCardRspV2() |
|
3973 : TSatPCmdBase(), |
|
3974 iGeneralResult(KPCmdResultNotSet), |
|
3975 iInfoType(0), |
|
3976 iAdditionalInfo() |
|
3977 /** |
|
3978 * Default constructor. |
|
3979 */ |
|
3980 { |
|
3981 iExtensionId=KSatV2; |
|
3982 } |
|
3983 |
|
3984 EXPORT_C void RSat::NotifyPowerOffCardPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
3985 /** |
|
3986 * This method requests notification when a POWER OFF CARD proactive command is sent |
|
3987 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
3988 * aReqStatus is competed. Unpack the command to examine its contents. |
|
3989 * |
|
3990 * The POWER OFF CARD command closes the session with the card specified in the |
|
3991 * command. The command is described fully in ETSI TS 102 223. Symbian OS support |
|
3992 * for this command is available from v7.0s onwards. |
|
3993 * |
|
3994 * Once you have tried to close the session, you must give your response to the |
|
3995 * POWER OFF CARD command. This should include the APDU command results, if |
|
3996 * there are any. For Symbian OS versions from v7.0s to v8.1a and v8.1b, pass |
|
3997 * RSat::TerminalRsp() a RSat::TPowerOffCardRspV2Pckg (a packaged |
|
3998 * RSat::TPowerOffCardRspV2). For later versions of Symbian OS, check for an updated API |
|
3999 * (RSat::TPowerOffCardRspV3 etc). |
|
4000 * |
|
4001 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
4002 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
4003 * command. Use a packaged version of the latest "TPowerOffCard" class. For |
|
4004 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TPowerOffCardV2Pckg, a packaged |
|
4005 * RSat::TPowerOffCardV2. For later versions of Symbian OS, check for an updated API |
|
4006 * (RSat::TPowerOffCardV3 etc). |
|
4007 * |
|
4008 * @see RSat::TPowerOffCardV2 |
|
4009 * @see RSat::TPowerOffCardRspV2 |
|
4010 * |
|
4011 * @capability None |
|
4012 */ |
|
4013 { |
|
4014 Get(ESatNotifyPowerOffCardPCmd,aReqStatus,aPCmd); |
|
4015 } |
|
4016 |
|
4017 EXPORT_C RSat::TPowerOnCardV2::TPowerOnCardV2() |
|
4018 : TSatPCmdBase(), |
|
4019 iDestination(KDeviceIdNotSet) |
|
4020 /** |
|
4021 * Default constructor. |
|
4022 */ |
|
4023 { |
|
4024 iExtensionId=KSatV2; |
|
4025 } |
|
4026 |
|
4027 EXPORT_C RSat::TPowerOnCardRspV2::TPowerOnCardRspV2() |
|
4028 : TSatPCmdBase(), |
|
4029 iGeneralResult(KPCmdResultNotSet), |
|
4030 iInfoType(0), |
|
4031 iAdditionalInfo() |
|
4032 /** |
|
4033 * Default constructor. |
|
4034 */ |
|
4035 { |
|
4036 iExtensionId=KSatV2; |
|
4037 } |
|
4038 |
|
4039 EXPORT_C void RSat::NotifyPowerOnCardPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
4040 /** |
|
4041 * This method requests notification when a POWER ON CARD proactive command is sent |
|
4042 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
4043 * aReqStatus is competed. Unpack the command to examine its contents. |
|
4044 * |
|
4045 * The POWER ON CARD command requests that you start a session with the card |
|
4046 * specified in the command. The command is described fully in ETSI TS 102 223. |
|
4047 * Symbian OS support for this command is available from v7.0s onwards. |
|
4048 * |
|
4049 * Once you have tried to start the session, you must give your response to the |
|
4050 * POWER ON CARD command. This should include the APDU command results, if |
|
4051 * there are any. For Symbian OS versions from v7.0s to v8.1a and v8.1b, pass |
|
4052 * RSat::TerminalRsp() a RSat::TPowerOnCardRspV2Pckg (a packaged |
|
4053 * RSat::TPowerOnCardRspV2). For later versions of Symbian OS, check for an updated API |
|
4054 * (RSat::TPowerOnCardRspV3 etc). |
|
4055 * |
|
4056 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
4057 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
4058 * command. Use a packaged version of the latest "TPowerOnCard" class. For |
|
4059 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TPowerOnCardV2Pckg, a packaged |
|
4060 * RSat::TPowerOnCardV2. For later versions of Symbian OS, check for an updated API |
|
4061 * (RSat::TPowerOnCardV3 etc). |
|
4062 * |
|
4063 * @see RSat::TPowerOnCardV2 |
|
4064 * @see RSat::TPowerOnCardRspV2 |
|
4065 * |
|
4066 * @capability None |
|
4067 */ |
|
4068 { |
|
4069 Get(ESatNotifyPowerOnCardPCmd,aReqStatus,aPCmd); |
|
4070 } |
|
4071 |
|
4072 EXPORT_C RSat::TGetReaderStatusV2::TGetReaderStatusV2() |
|
4073 : TSatPCmdBase(), |
|
4074 iDestination(KDeviceIdNotSet), |
|
4075 iMode(ECardReaderModeNotSet) |
|
4076 /** |
|
4077 * Default constructor. |
|
4078 */ |
|
4079 { |
|
4080 iExtensionId=KSatV2; |
|
4081 } |
|
4082 |
|
4083 EXPORT_C RSat::TGetReaderStatusRspV2::TGetReaderStatusRspV2() |
|
4084 : TSatPCmdBase(), |
|
4085 iGeneralResult(KPCmdResultNotSet), |
|
4086 iInfoType(0), |
|
4087 iAdditionalInfo(), |
|
4088 iMode(ECardReaderModeNotSet) |
|
4089 /** |
|
4090 * Default constructor. |
|
4091 */ |
|
4092 { |
|
4093 iExtensionId=KSatV2; |
|
4094 } |
|
4095 |
|
4096 EXPORT_C void RSat::NotifyGetReaderStatusPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
4097 /** |
|
4098 * This method requests notification when a GET READER STATUS proactive command is sent |
|
4099 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
4100 * aReqStatus is competed. Unpack the command to examine its contents. |
|
4101 * |
|
4102 * The GET READER STATUS command requests the status of the card reader specified |
|
4103 * in the command. The command is described fully in ETSI TS 102 223. Symbian OS |
|
4104 * support for this command is available from v7.0s onwards. |
|
4105 * |
|
4106 * The command can request two types of information: |
|
4107 * |
|
4108 * - If RSat::TGetReaderStatusV2::iMode is RSat::ECardReaderStatus then return the card's status. |
|
4109 * - If RSat::TGetReaderStatusV2::iMode is RSat::ECardReaderIdentifier then return the card's identifier. |
|
4110 * |
|
4111 * Once you have tried to get the status, you must give your response to the |
|
4112 * GET READER STATUS command. This should include the APDU command results, if |
|
4113 * there are any. For Symbian OS versions from v7.0s to v8.1a and v8.1b, pass |
|
4114 * RSat::TerminalRsp() a RSat::TGetReaderStatusRspV2Pckg (a packaged |
|
4115 * RSat::TGetReaderStatusRspV2). For later versions of Symbian OS, check for an updated API |
|
4116 * (RSat::TGetReaderStatusRspV3 etc). |
|
4117 * |
|
4118 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
4119 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
4120 * command. Use a packaged version of the latest "TGetReaderStatus" class. For |
|
4121 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TGetReaderStatusV2Pckg, a packaged |
|
4122 * RSat::TGetReaderStatusV2. For later versions of Symbian OS, check for an updated API |
|
4123 * (RSat::TGetReaderStatusV3 etc). |
|
4124 * |
|
4125 * @see RSat::TGetReaderStatusV2 |
|
4126 * @see RSat::TGetReaderStatusRspV2 |
|
4127 * |
|
4128 * @capability None |
|
4129 */ |
|
4130 { |
|
4131 Get(ESatNotifyGetReaderStatusPCmd,aReqStatus,aPCmd); |
|
4132 } |
|
4133 |
|
4134 EXPORT_C RSat::TRunAtCommandV2::TRunAtCommandV2() |
|
4135 : TSatPCmdBase(), |
|
4136 iAtCommand() |
|
4137 /** |
|
4138 * Default constructor. |
|
4139 */ |
|
4140 { |
|
4141 iExtensionId=KSatV2; |
|
4142 iAlphaId.iStatus=EAlphaIdNotSet; |
|
4143 iIconId.iQualifier=EIconQualifierNotSet; |
|
4144 iIconId.iIdentifier=0; |
|
4145 } |
|
4146 |
|
4147 EXPORT_C RSat::TRunAtCommandV5::TRunAtCommandV5() |
|
4148 : TRunAtCommandV2() |
|
4149 /** |
|
4150 * Default constructor. |
|
4151 */ |
|
4152 { |
|
4153 iExtensionId=KSatV5; |
|
4154 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
4155 } |
|
4156 |
|
4157 EXPORT_C RSat::TRunAtCommandV6::TRunAtCommandV6() |
|
4158 : TRunAtCommandV5(),iFrameId(0) |
|
4159 /** |
|
4160 * Default constructor. |
|
4161 */ |
|
4162 { |
|
4163 iExtensionId=KSatV6; |
|
4164 } |
|
4165 |
|
4166 EXPORT_C RSat::TRunAtCommandRspV2::TRunAtCommandRspV2() |
|
4167 : TSatPCmdBase(), |
|
4168 iGeneralResult(KPCmdResultNotSet), |
|
4169 iInfoType(0), |
|
4170 iAdditionalInfo() |
|
4171 /** |
|
4172 * Default constructor. |
|
4173 */ |
|
4174 { |
|
4175 iExtensionId=KSatV2; |
|
4176 } |
|
4177 |
|
4178 EXPORT_C void RSat::NotifyRunAtCommandPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
4179 /** |
|
4180 * This method requests notification when a RUN AT COMMAND proactive command is sent |
|
4181 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
4182 * aReqStatus is competed. Unpack the command to examine its contents. |
|
4183 * |
|
4184 * The RUN AT COMMAND command asks the phone to perform the AT command provided. |
|
4185 * The command is described fully in ETSI TS 102 223 and 3GPP TS 31.111. Symbian |
|
4186 * OS support for this command is available from v7.0s onwards. |
|
4187 * |
|
4188 * The command includes: |
|
4189 * |
|
4190 * - The AT command string - RSat::TRunAtCommandV2::iAtCommand |
|
4191 * - An optional alpha identifier - RSat::TRunAtCommandV2::iAlphaId |
|
4192 * - An optional icon -- RSat::TRunAtCommandV2::iIconId. |
|
4193 * - Text attributes of text contained in iAlphaId - RSat::TRunAtCommandV5::iTextAttribute |
|
4194 * (Symbian OS v9.2 or later) |
|
4195 * |
|
4196 * See the description of the RUN AT COMMAND command in ETSI TS 102 223 for the |
|
4197 * circumstances under which the alpha identifier's text should be displayed. |
|
4198 * Display the icon as described in RSat::TIconId. |
|
4199 * |
|
4200 * Once you have dealt with the command, you must give your response to the RUN AT |
|
4201 * COMMAND command. This should include the AT response string, if there is one. |
|
4202 * For Symbian OS versions from v7.0s to v8.1a and v8.1b, pass RSat::TerminalRsp() |
|
4203 * a RSat::TRunAtCommandV2RspPckg (a packaged TRunAtCommandRspV2). For later versions of |
|
4204 * Symbian OS, check for an updated API (RSat::TRunAtCommandRspV3 etc). |
|
4205 * |
|
4206 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
4207 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
4208 * command. Use a packaged version of the latest "TRunAtCommand" class. For |
|
4209 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TRunAtCommandV2Pckg, a packaged |
|
4210 * RSat::TRunAtCommandV2. For Symbian OS version 9.2, use RSat::TRunAtCommandV5Pckg. |
|
4211 * For Symbian OS version 9.4, use RSat::TRunAtCommandV6Pckg. |
|
4212 * For later versions of Symbian OS, check for an updated API |
|
4213 * (RSat::TRunAtCommandV7 etc). |
|
4214 * |
|
4215 * @see RSat::TRunAtCommandV2 |
|
4216 * @see RSat::TRunAtCommandV5 |
|
4217 * @see RSat::TRunAtCommandV6 |
|
4218 * @see RSat::TRunAtCommandRspV2 |
|
4219 * |
|
4220 * @capability ReadDeviceData |
|
4221 */ |
|
4222 { |
|
4223 Get(ESatNotifyRunAtCommandPCmd,aReqStatus,aPCmd); |
|
4224 } |
|
4225 |
|
4226 EXPORT_C RSat::TLanguageNotificationV2::TLanguageNotificationV2() |
|
4227 : TSatPCmdBase(), |
|
4228 iNotificationType(ENotificationTypeNotSet), |
|
4229 iLanguage(0) |
|
4230 /** |
|
4231 * Default constructor. |
|
4232 */ |
|
4233 { |
|
4234 iExtensionId=KSatV2; |
|
4235 } |
|
4236 |
|
4237 EXPORT_C RSat::TLanguageNotificationRspV2::TLanguageNotificationRspV2() |
|
4238 : TSatPCmdBase(), |
|
4239 iGeneralResult(KPCmdResultNotSet), |
|
4240 iInfoType(0), |
|
4241 iAdditionalInfo() |
|
4242 /** |
|
4243 * Default constructor. |
|
4244 */ |
|
4245 { |
|
4246 iExtensionId=KSatV2; |
|
4247 } |
|
4248 |
|
4249 EXPORT_C void RSat::NotifyLanguageNotificationPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
4250 /** |
|
4251 * This method requests notification when a LANGUAGE NOTIFICATION proactive command is sent |
|
4252 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
4253 * aReqStatus is competed. Unpack the command to examine its contents. |
|
4254 * |
|
4255 * The LANGUAGE NOTIFICATION command tells the phone the language in which any |
|
4256 * text strings from the UICC are written. This includes text within proactive |
|
4257 * commands or envelope command responses. The command is described fully in ETSI |
|
4258 * TS 102 223 and 3GPP TS 31.111. Symbian OS support for this command is |
|
4259 * available from v7.0s onwards. |
|
4260 * |
|
4261 * The command contains a flag, RSat::TLanguageNotificationV2::iNotificationType, |
|
4262 * that describes the command's purpose: |
|
4263 * |
|
4264 * - If iNotificationType is set to RSat::ESpecificLangNotification then |
|
4265 * RSat::TLanguageNotificationV2::iLanguage contains the language in use by the |
|
4266 * UICC. |
|
4267 * |
|
4268 * - If iNotificationType is set to RSat::ENonSpecificLangNotification then the |
|
4269 * UICC is not using any specific language. This has the effect of cancelling |
|
4270 * previous specific LANGUAGE NOTIFICATION commands. |
|
4271 * |
|
4272 * Once you have dealt with the command, you must give your response to the |
|
4273 * LANGUAGE NOTIFICATION command. For Symbian OS versions from v7.0s to v8.1a |
|
4274 * and v8.1b, pass RSat::TerminalRsp() a RSat::TLanguageNotificationRspV2Pckg (a |
|
4275 * packaged TLanguageNotificationRspV2). For later versions of Symbian OS, check |
|
4276 * for an updated API (RSat::TLanguageNotificationRspV3 etc). |
|
4277 * |
|
4278 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
4279 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
4280 * command. Use a packaged version of the latest "TRunAtCommand" class. For |
|
4281 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TRunAtCommandV2Pckg, a packaged |
|
4282 * RSat::TRunAtCommandV2. For later versions of Symbian OS, check for an updated API |
|
4283 * (RSat::TRunAtCommandV3 etc). |
|
4284 * |
|
4285 * @see RSat::TRunAtCommandV2 |
|
4286 * @see RSat::TRunAtCommandRspV2 |
|
4287 * |
|
4288 * @capability None |
|
4289 */ |
|
4290 { |
|
4291 Get(ESatNotifyLanguageNotificationPCmd,aReqStatus,aPCmd); |
|
4292 } |
|
4293 |
|
4294 EXPORT_C void RSat::GetProvisioningRefFile(TRequestStatus& aReqStatus, |
|
4295 const TProvisioningFileRef& aFileRef, |
|
4296 TDes8& aFile) const |
|
4297 /** |
|
4298 * This method retrieves the Provisioning Reference File designated by aFileRef. |
|
4299 * Call this when handling a LAUNCH BROWSER proactive command. |
|
4300 * |
|
4301 * @param aReqStatus This method is asynchronous. aReqStatus indicates when the operation has completed. |
|
4302 * @param aFileRef Specifies which provisioning file is to be retrieved. |
|
4303 * @param aFile File, specified by aInstance Number, retrieved from the UICC. |
|
4304 * @capability ReadDeviceData |
|
4305 * |
|
4306 * @see RSat::NotifyLaunchBrowserPCmd() |
|
4307 */ |
|
4308 { |
|
4309 __ASSERT_ALWAYS(iEtelSatPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
4310 |
|
4311 iEtelSatPtrHolder->iGetProvisioningRefFile = aFileRef; |
|
4312 TPtrC8& ptr1=iEtelSatPtrHolder->SetC(ESlot1GetProvisioningRefFile,iEtelSatPtrHolder->iGetProvisioningRefFile); |
|
4313 |
|
4314 SetAndGet(ESatGetProvisioningRefFile,aReqStatus, ptr1, aFile); |
|
4315 } |
|
4316 |
|
4317 EXPORT_C RSat::TLaunchBrowserV2::TLaunchBrowserV2() |
|
4318 : TSatPCmdBase(), |
|
4319 iBrowserSel(EBrowserSelectionNotSet), |
|
4320 iBrowserId(EBrowserIdNotSet), |
|
4321 iUrl(), |
|
4322 iBearerList(), |
|
4323 iText(), |
|
4324 iFileRef(), |
|
4325 iNumOfFiles(0) |
|
4326 /** |
|
4327 * Default constructor. |
|
4328 */ |
|
4329 { |
|
4330 iExtensionId = KSatV2; |
|
4331 iOffset[0] = 0; |
|
4332 iLength[0] = 0; |
|
4333 iAlphaId.iStatus=EAlphaIdNotSet; |
|
4334 iIconId.iQualifier=EIconQualifierNotSet; |
|
4335 iIconId.iIdentifier=0; |
|
4336 } |
|
4337 |
|
4338 EXPORT_C TInt RSat::TLaunchBrowserV2::AddFileRef(const TProvisioningFileRef& aFileRef) |
|
4339 /** |
|
4340 * This method adds a Provisioning Reference File designated by aFileRef |
|
4341 * @param aFileRef File ref to add |
|
4342 * @return An error or KErrNone |
|
4343 */ |
|
4344 { |
|
4345 if (iNumOfFiles >= RSat::KFileRefMaxSize) |
|
4346 return KErrOverflow; |
|
4347 else |
|
4348 { |
|
4349 if ((aFileRef.Length() + iFileRef.Length()) >= iFileRef.MaxLength()) |
|
4350 return KErrOverflow; |
|
4351 |
|
4352 iOffset[iNumOfFiles] = (TUint8)iFileRef.Length(); // Current length gives offset |
|
4353 iLength[iNumOfFiles] = (TUint8)aFileRef.Length(); // Store length of new entry |
|
4354 iFileRef.Append(aFileRef); // Store object in iFileRef |
|
4355 ++iNumOfFiles; |
|
4356 |
|
4357 return KErrNone; |
|
4358 } |
|
4359 } |
|
4360 |
|
4361 EXPORT_C TInt RSat::TLaunchBrowserV2::GetFileRef(TUint aIndex, TProvisioningFileRef& aFileRef) const |
|
4362 /** |
|
4363 * This method retrieves the Provisioning Reference File designated by aIndex |
|
4364 * @return An error or KErrNone |
|
4365 * @param aIndex Index of file ref to retrieve |
|
4366 * @param aFileRef Specifies which provisioning file is to be retrieved. |
|
4367 */ |
|
4368 { |
|
4369 TInt index = (TInt)aIndex - 1; // External index is 1..max, internal is 0..max-1 (cast required to convert unsigned->signed) |
|
4370 |
|
4371 if (index < 0) |
|
4372 return KErrArgument; |
|
4373 else if (index >= RSat::KFileRefMaxSize || index >= iNumOfFiles) |
|
4374 return KErrNotFound; |
|
4375 else |
|
4376 aFileRef = iFileRef.Mid(iOffset[index], iLength[index]); |
|
4377 |
|
4378 return KErrNone; |
|
4379 } |
|
4380 |
|
4381 EXPORT_C void RSat::TLaunchBrowserV2::ResetFileRef() |
|
4382 /* |
|
4383 * Resets the buffer storing the provisioning file references. |
|
4384 */ |
|
4385 { |
|
4386 iNumOfFiles = 0; |
|
4387 iFileRef.SetLength(0); |
|
4388 } |
|
4389 |
|
4390 EXPORT_C TUint RSat::TLaunchBrowserV2::NumberOfFileRef() const |
|
4391 /** |
|
4392 * Returns the number of provisioning file references. |
|
4393 * |
|
4394 * @return Returns the number of provisioning file references. |
|
4395 */ |
|
4396 { |
|
4397 return iNumOfFiles; |
|
4398 } |
|
4399 |
|
4400 EXPORT_C RSat::TLaunchBrowserV5::TLaunchBrowserV5() |
|
4401 : TLaunchBrowserV2() |
|
4402 /** |
|
4403 * Default constructor. |
|
4404 */ |
|
4405 { |
|
4406 iExtensionId = KSatV5; |
|
4407 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
4408 } |
|
4409 |
|
4410 EXPORT_C RSat::TLaunchBrowserV6::TLaunchBrowserV6() |
|
4411 : TLaunchBrowserV5(),iFrameId(0) |
|
4412 /** |
|
4413 * Default constructor. |
|
4414 */ |
|
4415 { |
|
4416 iExtensionId = KSatV6; |
|
4417 } |
|
4418 |
|
4419 EXPORT_C RSat::TLaunchBrowserRspV2::TLaunchBrowserRspV2() |
|
4420 : TSatPCmdBase(), |
|
4421 iGeneralResult(KPCmdResultNotSet), |
|
4422 iInfoType(0), |
|
4423 iAdditionalInfo() |
|
4424 /** |
|
4425 * Default constructor. |
|
4426 */ |
|
4427 { |
|
4428 iExtensionId=KSatV2; |
|
4429 } |
|
4430 |
|
4431 EXPORT_C void RSat::NotifyLaunchBrowserPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
4432 /** |
|
4433 * This method requests notification when a LAUNCH BROWSER proactive command is sent |
|
4434 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
4435 * aReqStatus is competed. Unpack the command to examine its contents. |
|
4436 * |
|
4437 * The LAUNCH BROWSER command requests that the phone browses to the supplied URL. |
|
4438 * The command is described fully in ETSI TS 102 223 and 3GPP TS 31.111. Symbian |
|
4439 * OS support for this command is available from v7.0s onwards. |
|
4440 * |
|
4441 * Handling the command is a four-stage process: |
|
4442 * |
|
4443 * Step one is to ask the user for their permission to launch the browser. The LAUNCH |
|
4444 * BROWSER command provides two parameters for this: an alpha identifier |
|
4445 * (RSat::TLaunchBrowserV2::iAlphaId) and an icon |
|
4446 * (RSat::TLaunchBrowserV2::iIconId). You can display these to help the user make a choice. |
|
4447 * |
|
4448 * Step two: examine the rest of the command and decide whether you can proceed. |
|
4449 * The command includes: |
|
4450 * |
|
4451 * - A description of the browser to use - RSat::TLaunchBrowserV2::iBrowserSel |
|
4452 * - The URL - RSat::TLaunchBrowserV2::iUrl |
|
4453 * - A list of bearers allowed in order of priority - RSat::TLaunchBrowserV2::iBearerList |
|
4454 * - Name/identity of the Gateway/Proxy - RSat::TLaunchBrowserV2::iText |
|
4455 * - A number of reference files - see RSat::TLaunchBrowserV2. |
|
4456 * - Text attributes of text contained in iText - RSat::TLaunchBrowserV5::iTextAttribute |
|
4457 * (Symbian OS v9.2 or later) |
|
4458 * |
|
4459 * Step three is to tell the UICC your intentions. You must do this before |
|
4460 * launching the browser. For Symbian OS versions from 7.0s to v8.1a and |
|
4461 * v8.1b pass RSat::TerminalRsp() a RSat::TLaunchBrowserRspV2Pckg (a packaged |
|
4462 * RSat::TLaunchBrowserRspV2). For later versions of Symbian OS, check for an updated API |
|
4463 * (RSat::TLaunchBrowserRspV3 etc). |
|
4464 * |
|
4465 * Finally, you can launch the browser. |
|
4466 * |
|
4467 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
4468 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
4469 * command. Use a packaged version of the latest "TLaunchBrowser" class. For |
|
4470 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TLaunchBrowserV2Pckg, a packaged |
|
4471 * RSat::TLaunchBrowserV2. For Symbian OS version 9.2, use RSat::TLaunchBrowserV5Pckg. |
|
4472 * For Symbian OS version 9.4, use RSat::TLaunchBrowserV6Pckg. |
|
4473 * For later versions of Symbian OS, check for an updated API |
|
4474 * (RSat::TLaunchBrowserV7 etc). |
|
4475 * |
|
4476 * @see RSat::TLaunchBrowserV2 |
|
4477 * @see RSat::TLaunchBrowserV5 |
|
4478 * @see RSat::TLaunchBrowserV6 |
|
4479 * @see RSat::TLaunchBrowserRspV2 |
|
4480 * @see RSat::GetProvisioningRefFile() |
|
4481 * |
|
4482 * @capability ReadDeviceData |
|
4483 */ |
|
4484 { |
|
4485 Get(ESatNotifyLaunchBrowserPCmd,aReqStatus,aPCmd); |
|
4486 } |
|
4487 |
|
4488 EXPORT_C RSat::TOpenChannelBaseV2::TOpenChannelBaseV2() |
|
4489 : TSatPCmdBase(), |
|
4490 iPCmdType(EPCmdTypeNotSet), |
|
4491 iLinkEst(ELinkEstablishmentNotSet), |
|
4492 iReconnectionMode(EReconnectionModeNotSet), |
|
4493 iBufferSize(0) |
|
4494 /** |
|
4495 * Default constructor. |
|
4496 */ |
|
4497 { |
|
4498 iExtensionId=KSatV2; |
|
4499 iAlphaId.iStatus=EAlphaIdNotSet; |
|
4500 iIconId.iQualifier=EIconQualifierNotSet; |
|
4501 iIconId.iIdentifier=0; |
|
4502 iBearer.iType=EBearerTypeNotSet; |
|
4503 iDestinationAddress.iType=EAddressNotSet; |
|
4504 iSimMeInterface.iTransportProto=EProtocolNotSet; |
|
4505 iSimMeInterface.iPrtNumber=0; |
|
4506 } |
|
4507 |
|
4508 EXPORT_C RSat::TOpenCsChannelV2::TOpenCsChannelV2() |
|
4509 : TOpenChannelBaseV2(), |
|
4510 iSubAddress(), |
|
4511 iUserLogin(), |
|
4512 iUserPassword() |
|
4513 /** |
|
4514 * Default constructor. |
|
4515 */ |
|
4516 { |
|
4517 iExtensionId=KSatV2; |
|
4518 iDuration1.iTimeUnit=ETimeUnitNotSet; |
|
4519 iDuration1.iNumOfUnits=0; |
|
4520 iDuration2.iTimeUnit=ETimeUnitNotSet; |
|
4521 iDuration2.iNumOfUnits=0; |
|
4522 iAddress.iTypeOfNumber=ETypeOfNumberNotSet; |
|
4523 iAddress.iNumberPlan=ENumberingPlanNotSet; |
|
4524 iLocalAddress.iType=EAddressNotSet; |
|
4525 } |
|
4526 |
|
4527 EXPORT_C RSat::TOpenCsChannelV5::TOpenCsChannelV5() |
|
4528 : TOpenCsChannelV2() |
|
4529 /** |
|
4530 * Default constructor. |
|
4531 */ |
|
4532 { |
|
4533 iExtensionId=KSatV5; |
|
4534 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
4535 } |
|
4536 |
|
4537 EXPORT_C RSat::TOpenCsChannelV6::TOpenCsChannelV6() |
|
4538 : TOpenCsChannelV5(),iFrameId(0) |
|
4539 /** |
|
4540 * Default constructor. |
|
4541 */ |
|
4542 { |
|
4543 iExtensionId=KSatV6; |
|
4544 } |
|
4545 |
|
4546 EXPORT_C RSat::TOpenGprsChannelV2::TOpenGprsChannelV2() |
|
4547 : TOpenChannelBaseV2(), |
|
4548 iAccessName() |
|
4549 /** |
|
4550 * Default constructor. |
|
4551 */ |
|
4552 { |
|
4553 iExtensionId=KSatV2; |
|
4554 iLocalAddress.iType=EAddressNotSet; |
|
4555 } |
|
4556 |
|
4557 EXPORT_C RSat::TOpenGprsChannelV4::TOpenGprsChannelV4() |
|
4558 : TOpenGprsChannelV2(), |
|
4559 iUserLogin(), |
|
4560 iUserPassword() |
|
4561 /** |
|
4562 * Default constructor. |
|
4563 */ |
|
4564 { |
|
4565 iExtensionId = KSatV4; |
|
4566 } |
|
4567 |
|
4568 EXPORT_C RSat::TOpenGprsChannelV5::TOpenGprsChannelV5() |
|
4569 : TOpenGprsChannelV4() |
|
4570 /** |
|
4571 * Default constructor. |
|
4572 */ |
|
4573 { |
|
4574 iExtensionId = KSatV5; |
|
4575 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
4576 } |
|
4577 |
|
4578 EXPORT_C RSat::TOpenGprsChannelV6::TOpenGprsChannelV6() |
|
4579 : TOpenGprsChannelV5(),iFrameId(0) |
|
4580 /** |
|
4581 * Default constructor. |
|
4582 */ |
|
4583 { |
|
4584 iExtensionId = KSatV6; |
|
4585 } |
|
4586 |
|
4587 EXPORT_C RSat::TOpenLocalLinksChannelV2::TOpenLocalLinksChannelV2() |
|
4588 : TOpenChannelBaseV2(), |
|
4589 iUserPassword() |
|
4590 /** |
|
4591 * Default constructor. |
|
4592 */ |
|
4593 { |
|
4594 iExtensionId=KSatV2; |
|
4595 iDuration1.iTimeUnit=ETimeUnitNotSet; |
|
4596 iDuration1.iNumOfUnits=0; |
|
4597 iDuration2.iTimeUnit=ETimeUnitNotSet; |
|
4598 iDuration2.iNumOfUnits=0; |
|
4599 iRemoteAddress.iCoding=ECodingNotSet; |
|
4600 } |
|
4601 |
|
4602 EXPORT_C RSat::TOpenLocalLinksChannelV5::TOpenLocalLinksChannelV5() |
|
4603 : TOpenLocalLinksChannelV2() |
|
4604 /** |
|
4605 * Default constructor. |
|
4606 */ |
|
4607 { |
|
4608 iExtensionId=KSatV5; |
|
4609 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
4610 } |
|
4611 |
|
4612 EXPORT_C RSat::TOpenLocalLinksChannelV6::TOpenLocalLinksChannelV6() |
|
4613 : TOpenLocalLinksChannelV5(), iFrameId(0) |
|
4614 /** |
|
4615 * Default constructor. |
|
4616 */ |
|
4617 { |
|
4618 iExtensionId=KSatV6; |
|
4619 } |
|
4620 |
|
4621 EXPORT_C RSat::TOpenUiccServerModeChannelV7::TOpenUiccServerModeChannelV7() |
|
4622 : TOpenChannelBaseV2(), iFrameId(0) |
|
4623 /** |
|
4624 * Default constructor. |
|
4625 */ |
|
4626 { |
|
4627 iExtensionId=KSatV7; |
|
4628 iBearer.iType = EBearerTypeNotSet; |
|
4629 iSimMeInterface.iTransportProto = EProtocolNotSet; |
|
4630 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
4631 } |
|
4632 |
|
4633 EXPORT_C RSat::TOpenChannelRspV2::TOpenChannelRspV2() |
|
4634 : TSatPCmdBase(), |
|
4635 iGeneralResult(KPCmdResultNotSet), |
|
4636 iInfoType(0), |
|
4637 iAdditionalInfo(), |
|
4638 iBearer(), |
|
4639 iBufferSize(0) |
|
4640 /** |
|
4641 * Default constructor. |
|
4642 */ |
|
4643 { |
|
4644 iExtensionId=KSatV2; |
|
4645 } |
|
4646 |
|
4647 EXPORT_C void RSat::NotifyOpenChannelPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
4648 /** |
|
4649 * This method requests notification when an OPEN CHANNEL proactive command is sent |
|
4650 * by the UICC. When the request completes, the command is placed into aPCmd and the |
|
4651 * aReqStatus is competed. Unpack the command to examine its contents. |
|
4652 * |
|
4653 * The OPEN CHANNEL command asks the phone to open a channel. You must inform the |
|
4654 * UICC whether you were successful. If so, subsequent proactive commands ask |
|
4655 * the phone to read or write data to the channel, to get the channel's status |
|
4656 * and to close the channel. |
|
4657 * |
|
4658 * The command is described fully in ETSI TS 102 223 and 3GPP TS 31.111. The |
|
4659 * documents also describe these related commands: |
|
4660 * |
|
4661 * - CLOSE CHANNEL |
|
4662 * - SEND DATA |
|
4663 * - RECEIVE DATA |
|
4664 * - GET CHANNEL STATUS |
|
4665 * |
|
4666 * The OPEN COMMAND defines the channel that should be opened. Typical examples |
|
4667 * are a channel to an IP address, an Internet domain name, a local serial |
|
4668 * connection etc. |
|
4669 * |
|
4670 * The command is returned in a class that inherits from RSat::TOpenChannelBaseV2. |
|
4671 * When you receive an OPEN CHANNEL command, look at its |
|
4672 * RSat::TOpenChannelBaseV2::iPCmdType field. This determines the type of bearer |
|
4673 * to use for the channel. There are three types: |
|
4674 * |
|
4675 * - Circuit switched. iPCmdType will be RSat::ECsBearer. |
|
4676 * - The command is contained in a RSat::TOpenCsChannelV2 (or derived class). |
|
4677 * - Packet switched. iPCmdType will be RSat::EGprsBearer. |
|
4678 * - The command is contained in a RSat::TOpenGprsChannelV2 (or derived class). |
|
4679 * - Local (such as infra-red and Bluetooth.) iPCmdType will be RSat::ELocalLinksBearer. |
|
4680 * - The command is contained in a RSat::TOpenLocalLinksChannelV2 (or derived class). |
|
4681 * - UICC server mode |
|
4682 * - The command is contained in a RSat::TOpenUiccServerModeChannelV7 (or derived class). |
|
4683 * |
|
4684 * The description of the "TOpen..." classes describes their contents and |
|
4685 * how to set up the channel. |
|
4686 * |
|
4687 * If you successfully open a channel then you must assign it a channel number |
|
4688 * from 1 to 7. You can have up to seven channels open at once, each opened with a |
|
4689 * separate OPEN CHANNEL command. You must inform the UICC of your chosen channel |
|
4690 * number. Subsequent CLOSE CHANNEL, SEND DATA, RECEIVE DATA and GET CHANNEL |
|
4691 * STATUS commands from the UICC will include a channel number from those you have |
|
4692 * returned to the UICC. |
|
4693 * |
|
4694 * If you do not successfully open a channel then return an error code as |
|
4695 * recommended in ETSI TS 102 223 and 3GPP TS 31.111. |
|
4696 * |
|
4697 * Whether you are successful or unsuccessful, respond to the OPEN CHANNEL command |
|
4698 * as follows: for Symbian OS versions from 7.0s to v8.1a and v8.1b pass |
|
4699 * RSat::TerminalRsp() a RSat::TOpenChannelRspV2Pckg (a packaged |
|
4700 * RSat::TOpenChannelRspV2). |
|
4701 * For later versions of Symbian OS, check for an updated |
|
4702 * API (RSat::TOpenChannelRspV3 etc). |
|
4703 * |
|
4704 * @param aReqStatus The aReqStatus is completed when the proactive command is received. |
|
4705 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
4706 * command. Pass in a RSat::TOpenChannelBaseV2Pckg. When the request |
|
4707 * completes, class will be changed to a RSat::TOpenCsChannelV2Pckg for Symbian OS 7.0s, 8.0 and 8.1. |
|
4708 * For Symbian OS 9.2, class will be changed to a RSat::TOpenCsChannelV5Pckg. |
|
4709 * For Symbian OS 9.4, class will be changed to a RSat::TOpenCsChannelV6Pckg. |
|
4710 * or for Symbian OS 7.0s, 8.0 and 8.1, class will be changed to a RSat::TOpenGprsChannelV2Pckg. |
|
4711 * For Symbian OS 9.2, class will be changed to a RSat::TOpenGprsChannelV5Pckg. |
|
4712 * For Symbian OS 9.4, class will be changed to a RSat::TOpenGprsChannelV6Pckg. |
|
4713 * or for Symbian OS 7.0s, 8.0 and 8.1, class will be changed to a RSat::TOpenLocalLinksChannelV2Pckg. |
|
4714 * For Symbian OS 9.2, class will be changed to a RSat::TOpenLocalLinksChannelV5Pckg. |
|
4715 * For Symbian OS 9.4, class will be changed to a RSat::TOpenLocalLinksChannelV6Pckg. |
|
4716 * and RSat::TOpenUiccServerModeChannelV7Pckg has been introduced to support UICC Server Mode. |
|
4717 * Look at RSat::TOpenChannelBaseV2::iPCmdType to find out which determines the type of bearer to |
|
4718 * use for the channel. |
|
4719 * For later versions of Symbian OS, check for an updated version of APIs |
|
4720 * (RSat::TOpenCsChannelV7 or RSat::TOpenGprsChannelV6 or |
|
4721 * RSat::TOpenLocalLinksChannelV7 or TOpenUiccServerModeChannelV8 etc). |
|
4722 * |
|
4723 * @see RSat::TOpenChannelBaseV2 |
|
4724 * @see RSat::TOpenCsChannelV2 |
|
4725 * @see RSat::TOpenGprsChannelV2 |
|
4726 * @see RSat::TOpenCsChannelV5 |
|
4727 * @see RSat::TOpenGprsChannelV5 |
|
4728 * @see RSat::TOpenLocalLinksChannelV2 |
|
4729 * @see RSat::TOpenLocalLinksChannelV5 |
|
4730 * @see RSat::TOpenCsChannelV6 |
|
4731 * @see RSat::TOpenGprsChannelV6 |
|
4732 * @see RSat::TOpenLocalLinksChannelV6 |
|
4733 * @see RSat::TOpenUiccServerModeChannelV7 |
|
4734 * @see RSat::TOpenChannelRspV2 |
|
4735 * @see RSat::NotifyCloseChannelPCmd() |
|
4736 * @see RSat::NotifySendDataPCmd() |
|
4737 * @see RSat::NotifyReceiveDataPCmd() |
|
4738 * @see RSat::NotifyGetChannelStatusPCmd() |
|
4739 * |
|
4740 * @capability ReadDeviceData |
|
4741 */ |
|
4742 { |
|
4743 Get(ESatNotifyOpenChannelPCmd,aReqStatus,aPCmd); |
|
4744 } |
|
4745 |
|
4746 EXPORT_C void RSat::GetOpenChannelPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
4747 /** |
|
4748 * This method can be used to retrieve more details about the channel after |
|
4749 * the channel is opened. PCmd type should be set to RSat::ECsBearer, |
|
4750 * RSat::EGprsBearer, RSat::ELocalLinksBearer or RSat::EUiccServerMode (or another |
|
4751 * enum defined in RSat::TOpenChannelType. |
|
4752 * |
|
4753 * @param aPCmd Pass in a RSat::TOpenCsChannelV2Pckg, RSat::TOpenGprsChannelV2Pckg, |
|
4754 * RSat::TOpenLocalLinksChannelV2Pckg, RSat::TOpenUiccServerModeChannelV7 or |
|
4755 * derived class as appropriate. |
|
4756 * |
|
4757 * @see RSat::TOpenChannelBaseV2 |
|
4758 * @see RSat::TOpenCsChannelV2 |
|
4759 * @see RSat::TOpenGprsChannelV2 |
|
4760 * @see RSat::TOpenLocalLinksChannelV2 |
|
4761 * @see RSat::TOpenUiccServerModeChannelV7 |
|
4762 * @see RSat::NotifyOpenChannelPCmd |
|
4763 * |
|
4764 * @capability ReadDeviceData |
|
4765 */ |
|
4766 { |
|
4767 Get(ESatGetOpenChannelPCmd,aReqStatus,aPCmd); |
|
4768 } |
|
4769 |
|
4770 EXPORT_C RSat::TCloseChannelV2::TCloseChannelV2() |
|
4771 : TSatPCmdBase(), |
|
4772 iDestination(KDeviceIdNotSet) |
|
4773 /** |
|
4774 * Default constructor. |
|
4775 */ |
|
4776 { |
|
4777 iExtensionId=KSatV2; |
|
4778 iAlphaId.iStatus=EAlphaIdNotSet; |
|
4779 iIconId.iQualifier=EIconQualifierNotSet; |
|
4780 iIconId.iIdentifier=0; |
|
4781 } |
|
4782 |
|
4783 EXPORT_C RSat::TCloseChannelV5::TCloseChannelV5() |
|
4784 : TCloseChannelV2() |
|
4785 /** |
|
4786 * Default constructor. |
|
4787 */ |
|
4788 { |
|
4789 iExtensionId=KSatV5; |
|
4790 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
4791 } |
|
4792 |
|
4793 EXPORT_C RSat::TCloseChannelV6::TCloseChannelV6() |
|
4794 : TCloseChannelV5(),iFrameId(0) |
|
4795 /** |
|
4796 * Default constructor. |
|
4797 */ |
|
4798 { |
|
4799 iExtensionId=KSatV6; |
|
4800 } |
|
4801 |
|
4802 EXPORT_C RSat::TCloseChannelRspV2::TCloseChannelRspV2() |
|
4803 : TSatPCmdBase(), |
|
4804 iGeneralResult(KPCmdResultNotSet), |
|
4805 iInfoType(0), |
|
4806 iAdditionalInfo() |
|
4807 /** |
|
4808 * Default constructor. |
|
4809 */ |
|
4810 { |
|
4811 iExtensionId=KSatV2; |
|
4812 } |
|
4813 |
|
4814 EXPORT_C void RSat::NotifyCloseChannelPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
4815 /** |
|
4816 * This method requests notification when a CLOSE CHANNEL proactive command is |
|
4817 * sent by the UICC. When the request completes, the command is placed into aPCmd |
|
4818 * and the aReqStatus is completed. Unpack the command |
|
4819 * to examine its contents. |
|
4820 * |
|
4821 * The CLOSE CHANNEL command requests that the phone closes a channel previously |
|
4822 * opened with the OPEN CHANNEL proactive command. The command is described fully |
|
4823 * in ETSI TS 102 223 and 3GPP TS 31.111. |
|
4824 * |
|
4825 * Symbian OS support for this command is available from v7.0s onwards. |
|
4826 * |
|
4827 * The command includes: |
|
4828 * |
|
4829 * - a channel identifier that tells you which channel to close - RSat::TCloseChannelV2::iDestination. |
|
4830 * - An alpha identifier containing text to display - RSat::TCloseChannelV2::iAlphaId. |
|
4831 * - An icon to display - RSat::TCloseChannelV2::iIconId |
|
4832 * - Text attributes of text contained in iAlphaId - RSat::TCloseChannelV5::iTextAttribute |
|
4833 * (Symbian OS v9.2 or later) |
|
4834 * |
|
4835 * When you open a channel following an OPEN CHANNEL command, you chose a channel |
|
4836 * identifier - a number from 1 to 7. When you inform the UICC that you opened a |
|
4837 * channel successfully, you tell the UICC which number you have chosen to |
|
4838 * represent the channel. The UICC includes this number in subsequent CLOSE |
|
4839 * CHANNEL commands so that you know which channel to close. |
|
4840 * |
|
4841 * See the description of the CLOSE CHANNEL command in ETSI TS 102 223 for the |
|
4842 * circumstances under which the alpha identifier's text should be displayed. |
|
4843 * Display the icon as described in RSat::TIconId. |
|
4844 * |
|
4845 * Once you have attempted to close the channel, give your response to the UICC. |
|
4846 * For Symbian OS versions from 7.0s to v8.1a and v8.1b pass RSat::TerminalRsp() a |
|
4847 * RSat::TCloseChannelRspV2Pckg (a packaged TCloseChannelRspV2). For later |
|
4848 * versions of Symbian OS, check for an updated API (RSat::TCloseChannelRspV3 |
|
4849 * etc). |
|
4850 * |
|
4851 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
4852 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
4853 * command. Use a packaged version of the latest "TCloseChannel" class. For |
|
4854 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TCloseChannelV2Pckg, a packaged |
|
4855 * RSat::TCloseChannelV2. For Symbian OS version 9.2, use RSat::TCloseChannelV5Pckg. |
|
4856 * For Symbian OS version 9.4, use RSat::TCloseChannelV6Pckg. |
|
4857 * For later versions of Symbian OS, check for an updated API |
|
4858 * (RSat::TCloseChannelV7 etc). |
|
4859 * |
|
4860 * @see RSat::TCloseChannelV2 |
|
4861 * @see RSat::TCloseChannelV5 |
|
4862 * @see RSat::TCloseChannelV6 |
|
4863 * @see RSat::TCloseChannelRspV2 |
|
4864 * @see RSat::NotifyOpenChannelPCmd() |
|
4865 * @see RSat::NotifySendDataPCmd() |
|
4866 * @see RSat::NotifyReceiveDataPCmd() |
|
4867 * @see RSat::NotifyGetChannelStatusPCmd() |
|
4868 * |
|
4869 * @capability None |
|
4870 */ |
|
4871 { |
|
4872 Get(ESatNotifyCloseChannelPCmd,aReqStatus,aPCmd); |
|
4873 } |
|
4874 |
|
4875 EXPORT_C RSat::TReceiveDataV2::TReceiveDataV2() |
|
4876 : TSatPCmdBase(), |
|
4877 iDestination(KDeviceIdNotSet), |
|
4878 iChannelDataLength(0) |
|
4879 /** |
|
4880 * Default constructor. |
|
4881 */ |
|
4882 { |
|
4883 iExtensionId=KSatV2; |
|
4884 iAlphaId.iStatus=EAlphaIdNotSet; |
|
4885 iIconId.iQualifier=EIconQualifierNotSet; |
|
4886 iIconId.iIdentifier=0; |
|
4887 } |
|
4888 |
|
4889 EXPORT_C RSat::TReceiveDataV5::TReceiveDataV5() |
|
4890 : TReceiveDataV2() |
|
4891 /** |
|
4892 * Default constructor. |
|
4893 */ |
|
4894 { |
|
4895 iExtensionId=KSatV5; |
|
4896 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
4897 } |
|
4898 |
|
4899 EXPORT_C RSat::TReceiveDataV6::TReceiveDataV6() |
|
4900 : TReceiveDataV5(),iFrameId(0) |
|
4901 /** |
|
4902 * Default constructor. |
|
4903 */ |
|
4904 { |
|
4905 iExtensionId=KSatV6; |
|
4906 } |
|
4907 |
|
4908 EXPORT_C RSat::TReceiveDataRspV2::TReceiveDataRspV2() |
|
4909 : TSatPCmdBase(), |
|
4910 iGeneralResult(KPCmdResultNotSet), |
|
4911 iInfoType(0), |
|
4912 iAdditionalInfo(), |
|
4913 iChannelDataLength(0) |
|
4914 /** |
|
4915 * Default constructor. |
|
4916 */ |
|
4917 { |
|
4918 iExtensionId=KSatV2; |
|
4919 } |
|
4920 |
|
4921 EXPORT_C void RSat::NotifyReceiveDataPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
4922 /** |
|
4923 * This method requests notification when a RECEIVE DATA proactive command is |
|
4924 * sent by the UICC. When the request completes, the command is placed into aPCmd |
|
4925 * and the aReqStatus is completed. Unpack the command |
|
4926 * to examine its contents. |
|
4927 * |
|
4928 * The RECEIVE DATA command asks the phone for data from a channel opened with |
|
4929 * the OPEN CHANNEL proactive command. Both of these commands are described fully |
|
4930 * in ETSI TS 102 223 and 3GPP TS 31.111. |
|
4931 * |
|
4932 * Symbian OS support for this command is available from v7.0s onwards. |
|
4933 * |
|
4934 * The command includes: |
|
4935 * |
|
4936 * - A channel identifier that tells you which channel to receive data from - RSat::TReceiveDataV2::iDestination. |
|
4937 * - The length of data to receive - RSat::TReceiveDataV2::iChannelDataLength. |
|
4938 * - An alpha identifier containing text to display - RSat::TReceiveDataV2::iAlphaId. |
|
4939 * - An icon to display - RSat::TReceiveDataV2::iIconId |
|
4940 * - Text attributes of text contained in iAlphaId - RSat::TReceiveDataV5::iTextAttribute |
|
4941 * (Symbian OS v9.2 or later) |
|
4942 * |
|
4943 * When you open a channel following an OPEN CHANNEL command, you chose a channel |
|
4944 * identifier - a number from 1 to 7. When you inform the UICC that you opened a |
|
4945 * channel successfully, you tell the UICC which number you have chosen to |
|
4946 * represent the channel. The UICC includes this number in subsequent RECEIVE |
|
4947 * DATA commands so that you know which channel to use. |
|
4948 * |
|
4949 * See the description of the RECEIVE DATA command in ETSI TS 102 223 for the |
|
4950 * circumstances under which the alpha identifier's text should be displayed. |
|
4951 * Display the icon as described in RSat::TIconId. |
|
4952 * |
|
4953 * You need to give the data or an error to the UICC. For Symbian OS versions from |
|
4954 * 7.0s to v8.1a and v8.1b pass RSat::TerminalRsp() a RSat::TReceiveDataRspV2Pckg |
|
4955 * (a packaged TReceiveDataRspV2). For later versions of Symbian OS, check for an |
|
4956 * updated API (RSat::TReceiveDataRspV3 etc). |
|
4957 * |
|
4958 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
4959 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
4960 * command. Use a packaged version of the latest "TReceiveData" class. For |
|
4961 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TReceiveDataV2Pckg, a packaged |
|
4962 * RSat::TReceiveDataV2. For Symbian OS version 9.2, use RSat::TReceiveDataV5Pckg. |
|
4963 * For Symbian OS version 9.4, use RSat::TReceiveDataV6Pckg. |
|
4964 * For later versions of Symbian OS, check for an updated API |
|
4965 * (RSat::TReceiveDataV7 etc). |
|
4966 * |
|
4967 * @see RSat::TReceiveDataV2 |
|
4968 * @see RSat::TReceiveDataV5 |
|
4969 * @see RSat::TReceiveDataV6 |
|
4970 * @see RSat::TReceiveDataRspV2 |
|
4971 * @see RSat::NotifyOpenChannelPCmd() |
|
4972 * @see RSat::NotifySendDataPCmd() |
|
4973 * @see RSat::NotifyCloseChannelPCmd() |
|
4974 * @see RSat::NotifyGetChannelStatusPCmd() |
|
4975 * |
|
4976 * @capability None |
|
4977 */ |
|
4978 { |
|
4979 Get(ESatNotifyReceiveDataPCmd,aReqStatus,aPCmd); |
|
4980 } |
|
4981 |
|
4982 EXPORT_C RSat::TSendDataV2::TSendDataV2() |
|
4983 : TSatPCmdBase(), |
|
4984 iDestination(KDeviceIdNotSet), |
|
4985 iMode(ESendDataModeNotSet), |
|
4986 iChannelData() |
|
4987 /** |
|
4988 * Default constructor. |
|
4989 */ |
|
4990 { |
|
4991 iExtensionId=KSatV2; |
|
4992 iAlphaId.iStatus=EAlphaIdNotSet; |
|
4993 iIconId.iQualifier=EIconQualifierNotSet; |
|
4994 iIconId.iIdentifier=0; |
|
4995 } |
|
4996 |
|
4997 EXPORT_C RSat::TSendDataV5::TSendDataV5() |
|
4998 : TSendDataV2() |
|
4999 /** |
|
5000 * Default constructor. |
|
5001 */ |
|
5002 { |
|
5003 iExtensionId=KSatV5; |
|
5004 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
5005 } |
|
5006 |
|
5007 EXPORT_C RSat::TSendDataV6::TSendDataV6() |
|
5008 : TSendDataV5(),iFrameId(0) |
|
5009 /** |
|
5010 * Default constructor. |
|
5011 */ |
|
5012 { |
|
5013 iExtensionId=KSatV6; |
|
5014 } |
|
5015 |
|
5016 EXPORT_C RSat::TSendDataRspV2::TSendDataRspV2() |
|
5017 : TSatPCmdBase(), |
|
5018 iGeneralResult(KPCmdResultNotSet), |
|
5019 iInfoType(0), |
|
5020 iAdditionalInfo(), |
|
5021 iChannelDataLength(0) |
|
5022 /** |
|
5023 * Default constructor. |
|
5024 */ |
|
5025 { |
|
5026 iExtensionId=KSatV2; |
|
5027 } |
|
5028 |
|
5029 EXPORT_C void RSat::NotifySendDataPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
5030 /** |
|
5031 * This method requests notification when a SEND DATA proactive command is |
|
5032 * sent by the UICC. When the request completes, the command is placed into aPCmd |
|
5033 * and the aReqStatus is completed. Unpack the command |
|
5034 * to examine its contents. |
|
5035 * |
|
5036 * The SEND DATA command asks the phone to send data on a channel opened with the |
|
5037 * OPEN CHANNEL proactive command. Both of these commands are described fully in |
|
5038 * ETSI TS 102 223 and 3GPP TS 31.111. |
|
5039 * |
|
5040 * Symbian OS support for this command is available from v7.0s onwards. |
|
5041 * |
|
5042 * The command includes: |
|
5043 * |
|
5044 * - A channel identifier that tells you which channel to send data on - RSat::TSendDataV2::iDestination. |
|
5045 * - A mode indicator: determines whether the SEND DATA command's data is sent immediately, or |
|
5046 * the data from a series of SEND DATA commands is buffered by the phone |
|
5047 * and sent at whatever rate the phone considers best RSat::TSendDataV2::iMode |
|
5048 * - The length of data to send - RSat::TSendDataV2::iChannelDataLength. |
|
5049 * - An alpha identifier containing text to display - RSat::TSendDataV2::iAlphaId. |
|
5050 * - An icon to display - RSat::TSendDataV2::iIconId |
|
5051 * - Text attributes of text contained in iAlphaId - RSat::TSendDataV5::iTextAttribute |
|
5052 * (Symbian OS v9.2 or later) |
|
5053 * |
|
5054 * When you open a channel following an OPEN CHANNEL command, you chose a channel |
|
5055 * identifier - a number from 1 to 7. When you inform the UICC that you opened a |
|
5056 * channel successfully, you tell the UICC which number you have chosen to |
|
5057 * represent the channel. The UICC includes this number in subsequent SEND |
|
5058 * DATA commands so that you know which channel to use. |
|
5059 * |
|
5060 * See the description of the SEND DATA command in ETSI TS 102 223 for the |
|
5061 * circumstances under which the alpha identifier's text should be displayed. |
|
5062 * Display the icon as described in RSat::TIconId. |
|
5063 * |
|
5064 * You need to give a response to the UICC. For Symbian OS versions from |
|
5065 * 7.0s to v8.1a and v8.1b pass RSat::TerminalRsp() a RSat::TSendDataRspV2Pckg |
|
5066 * (a packaged TSendDataRspV2). For later versions of Symbian OS, check for an |
|
5067 * updated API (RSat::TSendDataRspV3 etc). |
|
5068 * |
|
5069 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
5070 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
5071 * command. Use a packaged version of the latest "TSendData" class. For |
|
5072 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TSendDataV2Pckg, a packaged |
|
5073 * RSat::TSendDataV2. For Symbian OS version 9.2, use RSat::TSendDataV5Pckg. |
|
5074 * For Symbian OS version 9.4, use RSat::TSendDataV6Pckg. |
|
5075 * For later versions of Symbian OS, check for an updated API |
|
5076 * (RSat::TSendDataV7 etc). |
|
5077 * |
|
5078 * @see RSat::TSendDataV2 |
|
5079 * @see RSat::TSendDataV5 |
|
5080 * @see RSat::TSendDataV6 |
|
5081 * @see RSat::TSendDataRspV2 |
|
5082 * @see RSat::NotifyOpenChannelPCmd() |
|
5083 * @see RSat::NotifyReceiveDataPCmd() |
|
5084 * @see RSat::NotifyCloseChannelPCmd() |
|
5085 * @see RSat::NotifyGetChannelStatusPCmd() |
|
5086 * |
|
5087 * @capability ReadDeviceData |
|
5088 */ |
|
5089 { |
|
5090 Get(ESatNotifySendDataPCmd,aReqStatus,aPCmd); |
|
5091 } |
|
5092 |
|
5093 EXPORT_C RSat::TGetChannelStatusV2::TGetChannelStatusV2() |
|
5094 : TSatPCmdBase() |
|
5095 /** |
|
5096 * Default constructor. |
|
5097 */ |
|
5098 { |
|
5099 iExtensionId=KSatV2; |
|
5100 } |
|
5101 |
|
5102 EXPORT_C RSat::TGetChannelStatusRspV2::TGetChannelStatusRspV2() |
|
5103 : TSatPCmdBase(), |
|
5104 iGeneralResult(KPCmdResultNotSet), |
|
5105 iInfoType(0), |
|
5106 iAdditionalInfo() |
|
5107 /** |
|
5108 * Default constructor. |
|
5109 */ |
|
5110 { |
|
5111 iExtensionId=KSatV2; |
|
5112 iGeneralResult=KPCmdResultNotSet; |
|
5113 iInfoType=0; |
|
5114 } |
|
5115 |
|
5116 EXPORT_C void RSat::NotifyGetChannelStatusPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
5117 /** |
|
5118 * This method requests notification when a GET CHANNEL STATUS proactive command is |
|
5119 * sent by the UICC. When the request completes, the command is placed into aPCmd |
|
5120 * and the aReqStatus is completed. Unpack the command |
|
5121 * to examine its contents. |
|
5122 * |
|
5123 * The GET CHANNEL STATUS command asks the phone to return the status of a channel |
|
5124 * opened with the OPEN CHANNEL proactive command. Both of these commands are |
|
5125 * described fully in ETSI TS 102 223 and 3GPP TS 31.111. |
|
5126 * |
|
5127 * When you open a channel following an OPEN CHANNEL command, you chose a channel |
|
5128 * identifier - a number from 1 to 7. When you inform the UICC that you opened a |
|
5129 * channel successfully, you tell the UICC which number you have chosen to |
|
5130 * represent the channel. The UICC includes this number in subsequent GET CHANNEL STATUS |
|
5131 * commands so that you know which channel's status to return. |
|
5132 * |
|
5133 * Symbian OS support for this command is available from v7.0s onwards. |
|
5134 * |
|
5135 * You need to return the channel status or an error to the UICC. For Symbian OS |
|
5136 * versions from 7.0s to v8.1a and v8.1b pass RSat::TerminalRsp() a |
|
5137 * RSat::TGetChannelStatusRspV2Pckg (a packaged TGetChannelStatusRspV2). For later versions of |
|
5138 * Symbian OS, check for an updated API (RSat::TGetChannelStatusRspV3 etc). |
|
5139 * |
|
5140 * @param aReqStatus The aReqStatus is completed when the proactive command is received. |
|
5141 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
5142 * command. Use a packaged version of the latest "TGetChannelStatus" class. For |
|
5143 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TGetChannelStatusV2Pckg, a packaged |
|
5144 * RSat::TGetChannelStatusV2. For later versions of Symbian OS, check for an updated API |
|
5145 * (RSat::TGetChannelStatusV3 etc). |
|
5146 * |
|
5147 * @see RSat::TGetChannelStatusV2 |
|
5148 * @see RSat::TGetChannelStatusRspV2 |
|
5149 * @see RSat::NotifyOpenChannelPCmd() |
|
5150 * @see RSat::NotifyReceiveDataPCmd() |
|
5151 * @see RSat::NotifySendDataPCmd() |
|
5152 * @see RSat::NotifyCloseChannelPCmd() |
|
5153 * |
|
5154 * @capability None |
|
5155 */ |
|
5156 { |
|
5157 Get(ESatNotifyGetChannelStatusPCmd,aReqStatus,aPCmd); |
|
5158 } |
|
5159 |
|
5160 EXPORT_C RSat::TServiceSearchV2::TServiceSearchV2() |
|
5161 : TSatPCmdBase() |
|
5162 /** |
|
5163 * Default constructor. |
|
5164 */ |
|
5165 { |
|
5166 iExtensionId=KSatV2; |
|
5167 iAlphaId.iStatus=EAlphaIdNotSet; |
|
5168 iIconId.iQualifier=EIconQualifierNotSet; |
|
5169 iIconId.iIdentifier=0; |
|
5170 iSearch.iBearerId=ELocalBearerIdNotSet; |
|
5171 iFilter.iBearerId=ELocalBearerIdNotSet; |
|
5172 } |
|
5173 |
|
5174 EXPORT_C RSat::TServiceSearchV5::TServiceSearchV5() |
|
5175 : TServiceSearchV2() |
|
5176 /** |
|
5177 * Default constructor. |
|
5178 */ |
|
5179 { |
|
5180 iExtensionId=KSatV5; |
|
5181 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
5182 } |
|
5183 |
|
5184 EXPORT_C RSat::TServiceSearchV6::TServiceSearchV6() |
|
5185 : TServiceSearchV5(),iFrameId(0) |
|
5186 /** |
|
5187 * Default constructor. |
|
5188 */ |
|
5189 { |
|
5190 iExtensionId=KSatV6; |
|
5191 } |
|
5192 |
|
5193 EXPORT_C RSat::TServiceSearchRspV2::TServiceSearchRspV2() |
|
5194 : TSatPCmdBase(), |
|
5195 iGeneralResult(KPCmdResultNotSet), |
|
5196 iInfoType(0), |
|
5197 iAdditionalInfo() |
|
5198 /** |
|
5199 * Default constructor. |
|
5200 */ |
|
5201 { |
|
5202 iExtensionId=KSatV2; |
|
5203 } |
|
5204 |
|
5205 EXPORT_C void RSat::NotifyServiceSearchPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
5206 /** |
|
5207 * This method requests notification when a SERVICE SEARCH proactive command is |
|
5208 * sent by the UICC. When the request completes, the command is placed into aPCmd |
|
5209 * and the aReqStatus is completed. Unpack the command |
|
5210 * to examine its contents. |
|
5211 * |
|
5212 * The command is described fully in ETSI TS 102 223 and 3GPP TS 31.111. |
|
5213 * |
|
5214 * Symbian OS support for this command is available from v7.0s onwards. |
|
5215 * |
|
5216 * You need to give a response to command back to the UICC. For Symbian OS |
|
5217 * versions from 7.0s to v8.1a and v8.1b pass RSat::TerminalRsp() a |
|
5218 * RSat::TServiceSearchRspV2Pckg (a packaged TServiceSearchRspV2). For later versions of |
|
5219 * Symbian OS, check for an updated API (RSat::TServiceSearchRspV3 etc). |
|
5220 * |
|
5221 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
5222 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
5223 * command. Use a packaged version of the latest "TServiceSearch" class. For |
|
5224 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TServiceSearchV2Pckg, a packaged |
|
5225 * RSat::TServiceSearchV2. For Symbian OS version 9.2, use RSat::TServiceSearchV5Pckg. |
|
5226 * For Symbian OS version 9.4, use RSat::TServiceSearchV6Pckg. |
|
5227 * For later versions of Symbian OS, check for an updated API |
|
5228 * (RSat::TServiceSearchV7 etc). |
|
5229 * |
|
5230 * @see RSat::TServiceSearchV2 |
|
5231 * @see RSat::TServiceSearchV5 |
|
5232 * @see RSat::TServiceSearchV6 |
|
5233 * @see RSat::TServiceSearchRspV2 |
|
5234 * @see RSat::NotifyGetServiceInfoPCmd() |
|
5235 * @see RSat::NotifyDeclareServicePCmd() |
|
5236 * |
|
5237 * @capability ReadDeviceData |
|
5238 */ |
|
5239 { |
|
5240 Get(ESatNotifyServiceSearchPCmd,aReqStatus,aPCmd); |
|
5241 } |
|
5242 |
|
5243 |
|
5244 EXPORT_C RSat::TGetServiceInfoV2::TGetServiceInfoV2() |
|
5245 : TSatPCmdBase() |
|
5246 /** |
|
5247 * Default constructor. |
|
5248 */ |
|
5249 { |
|
5250 iExtensionId=KSatV2; |
|
5251 iAlphaId.iStatus=EAlphaIdNotSet; |
|
5252 iIconId.iQualifier=EIconQualifierNotSet; |
|
5253 iIconId.iIdentifier=0; |
|
5254 iAttributeInfo.iBearerId=ELocalBearerIdNotSet; |
|
5255 } |
|
5256 |
|
5257 EXPORT_C RSat::TGetServiceInfoV5::TGetServiceInfoV5() |
|
5258 : TGetServiceInfoV2() |
|
5259 /** |
|
5260 * Default constructor. |
|
5261 */ |
|
5262 { |
|
5263 iExtensionId=KSatV5; |
|
5264 iTextAttribute.iStatus = ETextAttributeNotSet; |
|
5265 } |
|
5266 |
|
5267 EXPORT_C RSat::TGetServiceInfoV6::TGetServiceInfoV6() |
|
5268 : TGetServiceInfoV5(),iFrameId(0) |
|
5269 /** |
|
5270 * Default constructor. |
|
5271 */ |
|
5272 { |
|
5273 iExtensionId=KSatV6; |
|
5274 } |
|
5275 |
|
5276 EXPORT_C RSat::TGetServiceInfoRspV2::TGetServiceInfoRspV2() |
|
5277 : TSatPCmdBase(), |
|
5278 iGeneralResult(KPCmdResultNotSet), |
|
5279 iInfoType(0), |
|
5280 iAdditionalInfo() |
|
5281 /** |
|
5282 * Default constructor. |
|
5283 */ |
|
5284 { |
|
5285 iExtensionId=KSatV2; |
|
5286 iRecordInfo.iBearerId=ELocalBearerIdNotSet; |
|
5287 iRecordInfo.iServiceId=0; |
|
5288 } |
|
5289 |
|
5290 EXPORT_C void RSat::NotifyGetServiceInfoPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
5291 /** |
|
5292 * This method requests notification when a GET SERVICE INFO proactive command is |
|
5293 * sent by the UICC. When the request completes, the command is placed into aPCmd |
|
5294 * and the aReqStatus is completed. Unpack the command |
|
5295 * to examine its contents. |
|
5296 * |
|
5297 * The command is described fully in ETSI TS 102 223 and 3GPP TS 31.111. |
|
5298 * |
|
5299 * Symbian OS support for this command is available from v7.0s onwards. |
|
5300 * |
|
5301 * You need to give a response to command back to the UICC. For Symbian OS |
|
5302 * versions from 7.0s to v8.1a and v8.1b pass RSat::TerminalRsp() a |
|
5303 * RSat::TGetServiceInfoRspV2Pckg (a packaged TGetServiceInfoRspV2). For later versions of |
|
5304 * Symbian OS, check for an updated API (RSat::TGetServiceInfoRspV3 etc). |
|
5305 * |
|
5306 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
5307 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
5308 * command. Use a packaged version of the latest "TGetServiceInfo" class. For |
|
5309 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TGetServiceInfoV2Pckg, a packaged |
|
5310 * RSat::TGetServiceInfoV2. For Symbian OS version 9.2, use RSat::TGetServiceInfoV5Pckg. |
|
5311 * For Symbian OS version 9.4, use RSat::TGetServiceInfoV6Pckg. |
|
5312 * For later versions of Symbian OS, check for an updated API |
|
5313 * (RSat::TGetServiceInfoV7 etc). |
|
5314 * |
|
5315 * @see RSat::TGetServiceInfoV2 |
|
5316 * @see RSat::TGetServiceInfoV5 |
|
5317 * @see RSat::TGetServiceInfoV6 |
|
5318 * @see RSat::TGetServiceInfoRspV2 |
|
5319 * @see RSat::NotifyServiceSearchPCmd() |
|
5320 * @see RSat::NotifyDeclareServicePCmd() |
|
5321 * |
|
5322 * @capability ReadDeviceData |
|
5323 */ |
|
5324 { |
|
5325 Get(ESatNotifyGetServiceInfoPCmd,aReqStatus,aPCmd); |
|
5326 } |
|
5327 |
|
5328 EXPORT_C RSat::TDeclareServiceV2::TDeclareServiceV2() |
|
5329 : TSatPCmdBase(), |
|
5330 iType(EDeclarationTypeNotSet) |
|
5331 /** |
|
5332 * Default constructor. |
|
5333 */ |
|
5334 { |
|
5335 iExtensionId=KSatV2; |
|
5336 iServiceRecord.iBearerId=ELocalBearerIdNotSet; |
|
5337 iServiceRecord.iServiceId=0; |
|
5338 iInterface.iTransportProto=EProtocolNotSet; |
|
5339 iInterface.iPrtNumber=0; |
|
5340 } |
|
5341 |
|
5342 EXPORT_C RSat::TDeclareServiceRspV2::TDeclareServiceRspV2() |
|
5343 : TSatPCmdBase(), |
|
5344 iGeneralResult(KPCmdResultNotSet), |
|
5345 iInfoType(0), |
|
5346 iAdditionalInfo() |
|
5347 /** |
|
5348 * Default constructor. |
|
5349 */ |
|
5350 { |
|
5351 iExtensionId=KSatV2; |
|
5352 } |
|
5353 |
|
5354 EXPORT_C void RSat::NotifyDeclareServicePCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
5355 /** |
|
5356 * This method requests notification when a DECLARE SERVICE proactive command is |
|
5357 * sent by the UICC. When the request completes, the command is placed into aPCmd |
|
5358 * and the aReqStatus is completed. Unpack the command |
|
5359 * to examine its contents. |
|
5360 * |
|
5361 * The command is described fully in ETSI TS 102 223 and 3GPP TS 31.111. |
|
5362 * |
|
5363 * Symbian OS support for this command is available from v7.0s onwards. |
|
5364 * |
|
5365 * You need to give a response to command back to the UICC. For Symbian OS |
|
5366 * versions from 7.0s to v8.1a and v8.1b pass RSat::TerminalRsp() a |
|
5367 * RSat::TDeclareServiceRspV2Pckg (a packaged TDeclareServiceRspV2). For later versions of |
|
5368 * Symbian OS, check for an updated API (RSat::TDeclareServiceRspV3 etc). |
|
5369 * |
|
5370 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
5371 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
5372 * command. Use a packaged version of the latest "TDeclareService" class. For |
|
5373 * Symbian OS 7.0s, 8.0 and 8.1 use RSat::TDeclareServiceV2Pckg, a packaged |
|
5374 * RSat::TDeclareServiceV2. For later versions of Symbian OS, check for an updated API |
|
5375 * (RSat::TDeclareServiceV3 etc). |
|
5376 * |
|
5377 * @see RSat::TDeclareServiceV2 |
|
5378 * @see RSat::TDeclareServiceRspV2 |
|
5379 * @see RSat::NotifyGetServiceInfoPCmd() |
|
5380 * @see RSat::NotifyDeclareServicePCmd() |
|
5381 * |
|
5382 * @capability ReadDeviceData |
|
5383 */ |
|
5384 { |
|
5385 Get(ESatNotifyDeclareServicePCmd,aReqStatus,aPCmd); |
|
5386 } |
|
5387 |
|
5388 EXPORT_C RSat::TTimerMgmtV3::TTimerMgmtV3() |
|
5389 : TSatPCmdBase() |
|
5390 /** |
|
5391 * Default constructor. |
|
5392 */ |
|
5393 { |
|
5394 iExtensionId=KSatV3; |
|
5395 } |
|
5396 |
|
5397 EXPORT_C RSat::TTimerMgmtRspV3::TTimerMgmtRspV3() |
|
5398 : TSatPCmdBase(), |
|
5399 iGeneralResult(KPCmdResultNotSet), |
|
5400 iInfoType(0), |
|
5401 iAdditionalInfo() |
|
5402 /** |
|
5403 * Default constructor. |
|
5404 */ |
|
5405 { |
|
5406 iExtensionId=KSatV3; |
|
5407 } |
|
5408 |
|
5409 EXPORT_C void RSat::NotifyTimerMgmtPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
5410 /** |
|
5411 * This method requests notification when a TIMER MANAGEMENT proactive |
|
5412 * command is sent by the UICC. When the request completes, the command is placed |
|
5413 * into aPCmd and the aReqStatus is completed. Unpack |
|
5414 * the command to examine its contents. |
|
5415 * |
|
5416 * Support for this command is only available from v7.0s of Symbian OS onwards. |
|
5417 * |
|
5418 * The phone provides timers for the UICC. Using proactive commands, the UICC |
|
5419 * can start, stop and read the current value of timers. Timers are started with a |
|
5420 * particular value. When this counts down to zero, send a Timer Expiration |
|
5421 * envelope command to the UICC; see RSat::NotifyTimerExpiration(). You must |
|
5422 * manage up to 8 timers for the UICC. |
|
5423 * |
|
5424 * The command is described fully in ETSI TS 102 223, 3GPP2 C.S0035-0 and 3GPP TS |
|
5425 * 31.111. Briefly, though, TIMER MANAGEMENT commands are of three |
|
5426 * types: |
|
5427 * |
|
5428 * - Start a timer at the specified value - RSat::TTimerMgmtV3::iOperation is |
|
5429 * RSat::EStartTimer. The timer counts down from the value in |
|
5430 * RSat::TTimerMgmtV3::iTimerValue |
|
5431 * - Stop a timer and return the timer's value when it was stopped - |
|
5432 * RSat::TTimerMgmtV3::iOperation is RSat::EDeactivateTimer. |
|
5433 * - Return a timer's value to the UICC without stopping it - |
|
5434 * RSat::TTimerMgmtV3::iOperation is RSat::EGetTimerValue. |
|
5435 * |
|
5436 * Each command includes a timer identifier, RSat::TTimerMgmtV3::iTimerId, so that |
|
5437 * you know which timer to use. |
|
5438 * |
|
5439 * After you have tried to stop, start or read a timer, respond to the UICC as |
|
5440 * follows: In Symbian OS versions 7.0s, 8.1a & 8.1b, pass RSat::TerminalRsp() a |
|
5441 * RSat::TTimerMgmtRspV3Pckg (a packaged TTimerMgmtRspV3). For later versions of |
|
5442 * Symbian OS, check for an updated API (RSat::TTimerMgmtRspV4 etc). |
|
5443 * |
|
5444 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
5445 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
5446 * command. aPCmd must be a packaged version of the latest "TTimerMgmt" class. |
|
5447 * For Symbian OS versions up to and including v8.1a and 8.1b use |
|
5448 * RSat::TTimerMgmtV3Pckg, a packaged RSat::TTimerMgmtV3. For later versions of |
|
5449 * Symbian OS, check for an updated API (RSat::TTimerMgmtV4 etc). |
|
5450 * |
|
5451 * @see RSat::TTimerMgmtV3 |
|
5452 * @see RSat::TTimerMgmtRspV3 |
|
5453 * @see RSat::NotifyTimerExpiration() |
|
5454 * |
|
5455 * @capability None |
|
5456 */ |
|
5457 { |
|
5458 Get(ESatNotifyTimerMgmtPCmd,aReqStatus,aPCmd); |
|
5459 } |
|
5460 |
|
5461 EXPORT_C RSat::TLocalInfoV3::TLocalInfoV3() |
|
5462 : TSatPCmdBase() |
|
5463 /** |
|
5464 * Default constructor. |
|
5465 */ |
|
5466 { |
|
5467 iExtensionId=KSatV3; |
|
5468 } |
|
5469 |
|
5470 EXPORT_C RSat::TLocalInfoV6::TLocalInfoV6() |
|
5471 : TLocalInfoV3(),iUtranMeasurementQualifier(EUtranMeasurementQualifierNotSet) |
|
5472 /** |
|
5473 * Default constructor. |
|
5474 */ |
|
5475 { |
|
5476 iExtensionId=KSatV6; |
|
5477 } |
|
5478 |
|
5479 EXPORT_C RSat::TLocalInfoRspV3::TLocalInfoRspV3() |
|
5480 : TSatPCmdBase(), |
|
5481 iGeneralResult(KPCmdResultNotSet), |
|
5482 iInfoType(0), |
|
5483 iAdditionalInfo() |
|
5484 /** |
|
5485 * Default constructor. |
|
5486 */ |
|
5487 { |
|
5488 iExtensionId=KSatV3; |
|
5489 } |
|
5490 |
|
5491 EXPORT_C void RSat::NotifyLocalInfoPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
5492 /** |
|
5493 * This method requests notification when a PROVIDE LOCAL INFORMATION proactive |
|
5494 * command is sent by the UICC. When the request completes, the command is placed |
|
5495 * into aPCmd and the aReqStatus is completed. Unpack |
|
5496 * the command to examine its contents. |
|
5497 * |
|
5498 * Support for this command is only available from v7.0s of Symbian OS onwards. |
|
5499 * |
|
5500 * The PROVIDE LOCAL INFORMATION command instructs the phone to send local |
|
5501 * information to the UICC. The command is described fully in ETSI TS 102 223, |
|
5502 * 3GPP2 C.S0035-0 and 3GPP TS 31.111. Briefly, though, the command includes: |
|
5503 * |
|
5504 * - The type of information required - RSat::TLocalInfoV3::iInfoType |
|
5505 * - The device for which the information is required - RSat::TLocalInfoV3::iDevideId |
|
5506 * (note the spelling mistake in the member variable's name). |
|
5507 * |
|
5508 * The type of information depends upon the network on which the phone is running. |
|
5509 * For GSM/WCDMA networks, read 3GPP TS 31.111; for CDMA networks read 3GPP2 |
|
5510 * C.S0035-0. ETSI TS 102 223 only provides generic information about the PROVIDE |
|
5511 * LOCAL INFORMATION command. |
|
5512 * |
|
5513 * Provide the information (or an error code) in the format described in the |
|
5514 * specifications. In Symbian OS versions up to and including 8.1a & 8.1b, pass |
|
5515 * RSat::TerminalRsp() a RSat::TLocalInfoRspV3Pckg (a packaged |
|
5516 * RSat::TLocalInfoRspV3). For later versions of Symbian OS, check for an updated API |
|
5517 * (RSat::TLocalInfoRspV4 etc). |
|
5518 * |
|
5519 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
5520 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
5521 * command. aPCmd must be a packaged version of the latest "TLocalInfo" class. |
|
5522 * For Symbian OS versions up to and including v8.1a and 8.1b use |
|
5523 * RSat::TLocalInfoV3Pckg, a packaged RSat::TLocalInfoV3. |
|
5524 * For Symbian OS version 9.4, use RSat::TLocalInfoV6. |
|
5525 * For later versions of Symbian OS, check for an updated API (RSat::TLocalInfoV7 etc). |
|
5526 * |
|
5527 * @see RSat::TLocalInfoV3 |
|
5528 * @see RSat::TLocalInfoV6 |
|
5529 * @see RSat::TLocalInfoRspV3 |
|
5530 * |
|
5531 * @capability ReadDeviceData |
|
5532 */ |
|
5533 { |
|
5534 Get(ESatNotifyLocalInfoPCmd,aReqStatus,aPCmd); |
|
5535 } |
|
5536 |
|
5537 EXPORT_C RSat::TPollingIntervalV3::TPollingIntervalV3() |
|
5538 : TSatPCmdBase() |
|
5539 /** |
|
5540 * Default constructor. |
|
5541 */{ |
|
5542 iExtensionId=KSatV3; |
|
5543 } |
|
5544 |
|
5545 EXPORT_C RSat::TPollingIntervalRspV3::TPollingIntervalRspV3() |
|
5546 : TSatPCmdBase(), |
|
5547 iGeneralResult(KPCmdResultNotSet), |
|
5548 iInfoType(0), |
|
5549 iAdditionalInfo() |
|
5550 /** |
|
5551 * Default constructor. |
|
5552 */ |
|
5553 { |
|
5554 iExtensionId=KSatV3; |
|
5555 } |
|
5556 |
|
5557 EXPORT_C void RSat::NotifyPollingIntervalPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
5558 /** |
|
5559 * This method requests notification when a POLL INTERVAL proactive |
|
5560 * command is sent by the UICC. When the request completes, the command is placed |
|
5561 * into aPCmd and the aReqStatus is completed. Unpack |
|
5562 * the command to examine its contents. |
|
5563 * |
|
5564 * Support for this command is only available from v7.0s of Symbian OS onwards. |
|
5565 * |
|
5566 * The POLL INTERVAL command tells the phone how often the UICC would like to be |
|
5567 * polled by the phone. Each time it is polled, it can pass proactive commands to the phone. |
|
5568 * The command is described fully in ETSI TS 102 223. The command includes: |
|
5569 * |
|
5570 * - The requested polling interval - RSat::TPollingIntervalV3::iIntv. |
|
5571 * - The device for which the polling is required - RSat::TPollingIntervalV3::iDestination. |
|
5572 * |
|
5573 * It is up to the phone to choose the polling interval; the value in the |
|
5574 * proactive command is only a request. It should choose the closest acceptable |
|
5575 * value. The phone should tell the UICC what interval it has chosen to use as follows: |
|
5576 * |
|
5577 * In Symbian OS versions up to and including 8.1a & 8.1b, pass |
|
5578 * RSat::TerminalRsp() a RSat::TPollingIntervalRspV3Pckg (a packaged |
|
5579 * RSat::TPollingIntervalRspV3). For later versions of Symbian OS, check for an updated API |
|
5580 * (RSat::TPollingIntervalRspV4 etc). |
|
5581 * |
|
5582 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
5583 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
5584 * command. aPCmd must be a packaged version of the latest "TPollingInterval" class. |
|
5585 * For Symbian OS versions from v7.0s to v8.1a and 8.1b use |
|
5586 * RSat::TPollingIntervalV3Pckg, a packaged RSat::TPollingIntervalV3. For later versions of |
|
5587 * Symbian OS, check for an updated API (RSat::TPollingIntervalV4 etc). |
|
5588 * |
|
5589 * @see RSat::TPollingIntervalV3 |
|
5590 * @see RSat::TPollingIntervalRspV3 |
|
5591 * |
|
5592 * @capability None |
|
5593 */ |
|
5594 { |
|
5595 Get(ESatNotifyPollingIntervalPCmd,aReqStatus,aPCmd); |
|
5596 } |
|
5597 |
|
5598 EXPORT_C RSat::TPollingOffV3::TPollingOffV3() |
|
5599 : TSatPCmdBase() |
|
5600 /** |
|
5601 * Default constructor. |
|
5602 */ |
|
5603 { |
|
5604 iExtensionId=KSatV3; |
|
5605 } |
|
5606 |
|
5607 EXPORT_C RSat::TPollingOffRspV3::TPollingOffRspV3() |
|
5608 : TSatPCmdBase(), |
|
5609 iGeneralResult(KPCmdResultNotSet), |
|
5610 iInfoType(0), |
|
5611 iAdditionalInfo() |
|
5612 /** |
|
5613 * Default constructor. |
|
5614 */ |
|
5615 { |
|
5616 iExtensionId=KSatV3; |
|
5617 } |
|
5618 |
|
5619 EXPORT_C void RSat::NotifyPollingOffPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
5620 /** |
|
5621 * This method requests notification when a POLLING OFF proactive |
|
5622 * command is sent by the UICC. When the request completes, the command is placed |
|
5623 * into aPCmd and the aReqStatus is completed. Unpack |
|
5624 * the command to examine its contents. |
|
5625 * |
|
5626 * Support for this command is only available from v7.0s of Symbian OS onwards. |
|
5627 * |
|
5628 * The POLLING OFF command tells the phone not to poll the UICC for proactive |
|
5629 * commands any more. The command is described fully in ETSI TS 102 223. The |
|
5630 * command includes the device for which polling should be turned off - |
|
5631 * RSat::TPollingOffV3::iDestination. |
|
5632 * |
|
5633 * Once you have dealt with the command, you must give your response to the UICC. |
|
5634 * In Symbian OS versions up to and including 8.1a & 8.1b, pass |
|
5635 * RSat::TerminalRsp() a RSat::TPollingOffRspV3Pckg (a packaged |
|
5636 * RSat::TPollingOffRspV3). For later versions of Symbian OS, check for an updated |
|
5637 * API (RSat::TPollingOffRspV4 etc). |
|
5638 * |
|
5639 * @param aReqStatus The aReqStatus is completed when the proactive command is received |
|
5640 * @param aPCmd When the request completes, this buffer will contain the proactive |
|
5641 * command. aPCmd must be a packaged version of the latest "TPollingOff" class. |
|
5642 * For Symbian OS versions from v7.0s to v8.1a and 8.1b use |
|
5643 * RSat::TPollingOffV3Pckg, a packaged RSat::TPollingOffV3. For later versions of |
|
5644 * Symbian OS, check for an updated API (RSat::TPollingOffV4 etc). |
|
5645 * |
|
5646 * @see RSat::TPollingOffV3 |
|
5647 * @see RSat::TPollingOffRspV3 |
|
5648 * |
|
5649 * @capability None |
|
5650 */ |
|
5651 { |
|
5652 Get(ESatNotifyPollingOffPCmd,aReqStatus,aPCmd); |
|
5653 } |
|
5654 |
|
5655 EXPORT_C RSat::TSatSmsV1::TSatSmsV1() |
|
5656 : TSatPCmdBase(), |
|
5657 iBuf(0) |
|
5658 /** |
|
5659 * Default constructor. |
|
5660 */ |
|
5661 { |
|
5662 } |
|
5663 |
|
5664 EXPORT_C void RSat::SendMessageNoLogging(TRequestStatus& aReqStatus, const TDesC8& aMsg, TUint16& aMsgRef) const |
|
5665 /** |
|
5666 * This method sends a SAT SMS without it being logged. |
|
5667 * |
|
5668 * See RSat::NotifySendSmPCmd() for more information. |
|
5669 * |
|
5670 * @param aReqStatus This method is asynchronous. aReqStatus indicates when the operation has completed. |
|
5671 * @param aMsg TSatSmsV1 packaged into a descriptor, TSatSmsV1Pckg. |
|
5672 * @capability NetworkServices |
|
5673 * @capability WriteDeviceData |
|
5674 */ |
|
5675 { |
|
5676 __ASSERT_ALWAYS(iEtelSatPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
5677 TPtr8& ptr1=iEtelSatPtrHolder->Set(ESlotMsgRef,aMsgRef); |
|
5678 |
|
5679 SetAndGet(ESatSendMessageNoLogging,aReqStatus,aMsg,ptr1); |
|
5680 } |
|
5681 |
|
5682 EXPORT_C void RSat::NotifyProactiveSimSessionStart(TRequestStatus& aReqStatus) const |
|
5683 /** |
|
5684 * This function is no longer needed when using the ETelSat API. |
|
5685 * @capability None |
|
5686 */ |
|
5687 { |
|
5688 Blank(ESatNotifyProactiveSimSessionStart,aReqStatus); |
|
5689 } |
|
5690 |
|
5691 EXPORT_C void RSat::NotifyProactiveSimSessionEnd(TRequestStatus& aReqStatus) const |
|
5692 /** |
|
5693 * This function is no longer needed when using the ETelSat API. |
|
5694 * @capability None |
|
5695 */ |
|
5696 { |
|
5697 Blank(ESatNotifyProactiveSimSessionEnd,aReqStatus); |
|
5698 } |
|
5699 |
|
5700 EXPORT_C void RSat::NotifyTsyStateUpdated(TRequestStatus& aReqStatus, TPCmd& aPCmd) const |
|
5701 /** |
|
5702 * This notification completes when the TSY has finished its handling of a proactive command. |
|
5703 * This should be used for proactive commands that are handled by the TSY |
|
5704 * and not by the ETelSat client. It informs the ETelSat client when the |
|
5705 * TSY has completed the required actions of the command. |
|
5706 * |
|
5707 * @param aReqStatus This method is asynchronous. aReqStatus indicates when the operation has completed. |
|
5708 * @param aPCmd Upon completion, aPcmd contains an RSat::TPCmd indicating the proactive command that has completed. |
|
5709 * @capability None |
|
5710 */ |
|
5711 { |
|
5712 __ASSERT_ALWAYS(iEtelSatPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); |
|
5713 TPtr8& ptr1=iEtelSatPtrHolder->Set(ESlot1NotifyTsyStateUpdated,aPCmd); |
|
5714 |
|
5715 Get(ESatNotifyTsyStateUpdated,aReqStatus,ptr1); |
|
5716 } |
|
5717 |
|
5718 EXPORT_C void RSat::NotifyRefreshRequired(TRequestStatus& aReqStatus) const |
|
5719 /** |
|
5720 * This notification completes when SAT engine indicates that it can complete the required refresh. |
|
5721 * This is phase 1 of a two phase refresh cycle with RSat::NotifyRefreshPCmd() being phase 2. The TSY should inform |
|
5722 * the UICC via terminal response should refresh not be possible at this time. This is intended to be used |
|
5723 * only by the SAT engine. |
|
5724 * |
|
5725 * See RSat::NotifyRefreshPCmd() for more information. |
|
5726 * |
|
5727 * @return aReqStatus TRequestStatus result code after the asynchronous call completes |
|
5728 * @capability None |
|
5729 */ |
|
5730 { |
|
5731 Blank(ESatNotifyRefreshRequired, aReqStatus); |
|
5732 } |
|
5733 |
|
5734 EXPORT_C void RSat::NotifyRefreshRequired(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
5735 /** |
|
5736 * This notification completes when SAT Engine indicates that it can complete the required refresh. |
|
5737 * This is phase 1 on a two phase refresh cycle with NotifyRefreshPCmd being phase 2. The TSY should inform |
|
5738 * the UICC via terminal response should refresh not be possible at this time. This is intended to be used |
|
5739 * only by the SAT Engine. |
|
5740 * |
|
5741 * @return aReqStatus TRequestStatus result code after the asynchronous call completes |
|
5742 * @param aPCmd TRefreshV1 packaged into a descriptor, TRefreshV1Pckg. |
|
5743 * @capability None |
|
5744 */ |
|
5745 { |
|
5746 Get(ESatNotifyRefreshRequiredParam,aReqStatus,aPCmd); |
|
5747 } |
|
5748 |
|
5749 EXPORT_C void RSat::RefreshAllowed(TRequestStatus& aReqStatus, const TDesC8& aRefreshAllowedRsp) const |
|
5750 /** |
|
5751 * This method allows client to report whether refresh can be carried out. This is intended to be used |
|
5752 * only by the SAT engine. |
|
5753 * |
|
5754 * See RSat::NotifyRefreshPCmd() for more information. |
|
5755 * |
|
5756 * @param aReqStatus This method is asynchronous. aReqStatus indicates when the operation has completed. |
|
5757 * @param aRefreshAllowedRsp Indication that successful refresh can be carried out or nature of error if not |
|
5758 * @capability WriteDeviceData |
|
5759 */ |
|
5760 { |
|
5761 Set(ESatRefreshAllowed, aReqStatus, aRefreshAllowedRsp); |
|
5762 } |
|
5763 |
|
5764 EXPORT_C RSat::TCallControlV5::TCallControlV5() |
|
5765 : TCallControlV2() |
|
5766 /** |
|
5767 * Default constructor. |
|
5768 */ |
|
5769 { |
|
5770 iExtensionId=KSatV5; |
|
5771 } |
|
5772 |
|
5773 EXPORT_C void RSat::TCallControlV5::SetPdpParameters(const TPdpParameters& aPdpParams) |
|
5774 /** |
|
5775 * This method is used by the TSY to set the PDP parameters within the TCallControlV5 class |
|
5776 * |
|
5777 * This method sets iType to ECcPDPParameters, to specify that the call control has transformed |
|
5778 * a outstanding PDP Context Activate request to a new one. |
|
5779 * |
|
5780 * @param aPdpParameters PDP parameters. |
|
5781 */ |
|
5782 { |
|
5783 iType=ECcPDPParameters; |
|
5784 iPdpParameters=aPdpParams; |
|
5785 } |
|
5786 |
|
5787 EXPORT_C void RSat::TCallControlV5::GetPdpParameters(TPdpParameters& aPdpParams) const |
|
5788 /** |
|
5789 * This method is used by the Client to get the PDP Context activation parameters. |
|
5790 * If the call control type is not ECcPdpParameters, the client should not use this method. |
|
5791 * |
|
5792 * @param aPdpParams PDP context parameters. |
|
5793 */ |
|
5794 { |
|
5795 aPdpParams=iPdpParameters; |
|
5796 } |
|
5797 |
|
5798 EXPORT_C RSat::TCallControlV6::TCallControlV6() |
|
5799 : TCallControlV5() |
|
5800 /** |
|
5801 * Default constructor. |
|
5802 */ |
|
5803 { |
|
5804 iExtensionId=KSatV6; |
|
5805 } |
|
5806 |
|
5807 EXPORT_C void RSat::TCallControlV6::SetCallParamOrigin (TCallParamOrigin aCallParamOrigin) |
|
5808 /** |
|
5809 * This method is used by the TSY to set the call originator |
|
5810 * within the TCallControlV6 class. |
|
5811 * |
|
5812 * The TSY should set this to the same value as that in the |
|
5813 * incoming call parameters. |
|
5814 * |
|
5815 * @param aCallParamOrigin The originator of the call. |
|
5816 * |
|
5817 * @see RSat::TCallControlV6::iCallParamOrigin |
|
5818 */ |
|
5819 { |
|
5820 iCallParamOrigin = aCallParamOrigin; |
|
5821 } |
|
5822 |
|
5823 EXPORT_C void RSat::TCallControlV6::GetCallParamOrigin (TCallParamOrigin& aCallParamOrigin) const |
|
5824 /** |
|
5825 * Retrieves the call parameter origin. |
|
5826 * |
|
5827 * @param aCallParamOrigin Is populated with the call originator when |
|
5828 * the function returns. |
|
5829 */ |
|
5830 { |
|
5831 aCallParamOrigin = iCallParamOrigin; |
|
5832 } |
|
5833 |
|
5834 EXPORT_C RSat::TRetrieveMultimediaMessageV6::TRetrieveMultimediaMessageV6() |
|
5835 : TSatPCmdBase(), |
|
5836 iDestination(KDeviceIdNotSet) |
|
5837 /** |
|
5838 * Default constructor |
|
5839 */ |
|
5840 { |
|
5841 iExtensionId=KSatV6; |
|
5842 iAlphaId.iStatus=EAlphaIdNotSet; |
|
5843 iIconId.iIdentifier=0; |
|
5844 iTextAttribute.iStatus=ETextAttributeNotSet; |
|
5845 } |
|
5846 |
|
5847 EXPORT_C void RSat::NotifyRetrieveMultimediaMsgPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
5848 /** |
|
5849 * The RETRIEVE MULTIMEDIA MESSAGE command tells the phone to retrieve a Multimedia file from Network. |
|
5850 * |
|
5851 * The command is described fully in 3GPP TS 31.111. Note that it does not appear in ETSI TS |
|
5852 * 102 223. It contains: |
|
5853 * - An alpha identifier containing text to display - RSat::TRetrieveMultimediaMessageV6::iAlphaId. |
|
5854 * - An icon to display - RSat::TRetrieveMultimediaMessageV6::iIconId |
|
5855 * - Text attributes of text contained in iAlphaId - RSat::TRetrieveMultimediaMessageV6::iTextAttribute |
|
5856 * - Location in the UICC where the file needed to be stored - RSat::TFileList |
|
5857 * - It contains the information,which refers to the location of the content of the multimedia file to be |
|
5858 * retrieved - RSat::TRetrieveMultimediaMessageV6::iMultimediaMessageRef |
|
5859 * - This contains the Data Object tag to be used when the MM Content is stored in the referenced |
|
5860 * BER-TLV file - RSat::TRetrieveMultimediaMessageV6::iMultimediaContentId |
|
5861 * - Multimedia Message Identifier is the identifier of the Multimedia Message within the MMS Reception File, |
|
5862 * It is mandatory when the file supports multiple MMs - RSat::TRetrieveMultimediaMessageV6::iMultimediaMessageId |
|
5863 * |
|
5864 * This asynchronous request is a notifier that completes when the UICC issues a |
|
5865 * RETRIEVE MULTIMEDIA MESSAGE PCmd. Upon completion the proactive command details |
|
5866 * will be returned in a packaged version of TRetrieveMultimediaMessageV6 in the |
|
5867 * aPCmd parameter. |
|
5868 * |
|
5869 * To cancel a previously placed RSat::NotifyRetrieveMultimediaMsgPCmd request, |
|
5870 * call RTelSubSessionBase::CancelAsyncRequest(ESatNotifyRetrieveMultimediaMsgPCmd) |
|
5871 * |
|
5872 * Once you have dealt with the command, you must give your response to the UICC. |
|
5873 * In Symbian OS versions beginning from 9.4, pass |
|
5874 * RSat::TerminalRsp() a RSat::TRetrieveMultimediaMessageRspV6Pckg (a packaged |
|
5875 * RSat::TRetrieveMultimediaMessageRspV6). For later versions of Symbian OS, check for an updated |
|
5876 * API (RSat::TRetrieveMultimediaMessageRspV7 etc). |
|
5877 * |
|
5878 * @param aReqStatus TRequestStatus result code after the asynchronous call completes. |
|
5879 * Set to KErrNone on successful completion; another error code otherwise. |
|
5880 * @param aPCmd a RSat::TRetrieveMultimediaMessageV6, packaged into a RSat::TRetrieveMultimediaMessageV6Pckg. |
|
5881 * Get filled with the details of the proactive command on completion of this notification. |
|
5882 * @capability ReadDeviceData |
|
5883 */ |
|
5884 { |
|
5885 Get(ESatNotifyRetrieveMultimediaMsgPCmd, aReqStatus, aPCmd); |
|
5886 } |
|
5887 |
|
5888 EXPORT_C RSat::TRetrieveMultimediaMessageRspV6::TRetrieveMultimediaMessageRspV6() |
|
5889 : TSatPCmdBase(), |
|
5890 iGeneralResult(KPCmdResultNotSet),iInfoType(0),iAdditionalInfo() |
|
5891 /** |
|
5892 * Default constructor |
|
5893 */ |
|
5894 { |
|
5895 iExtensionId=KSatV6; |
|
5896 } |
|
5897 |
|
5898 EXPORT_C RSat::TSubmitMultimediaMessageV6::TSubmitMultimediaMessageV6() |
|
5899 : TSatPCmdBase(), |
|
5900 iDestination(KDeviceIdNotSet) |
|
5901 /** |
|
5902 * Default constructor |
|
5903 */ |
|
5904 { |
|
5905 iExtensionId=KSatV6; |
|
5906 iAlphaId.iStatus=EAlphaIdNotSet; |
|
5907 iIconId.iIdentifier=0; |
|
5908 iTextAttribute.iStatus=ETextAttributeNotSet; |
|
5909 } |
|
5910 |
|
5911 EXPORT_C void RSat::NotifySubmitMultimediaMsgPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
5912 /** |
|
5913 * The SUBMIT MULTIMEDIA MESSAGE command tells the phone to Submit a Multimedia file to the Network. |
|
5914 * |
|
5915 * The command is described fully in 3GPP TS 31.111. Note that it does not appear in ETSI TS |
|
5916 * 102 223. It contains: |
|
5917 * - An alpha identifier containing text to display - RSat::TSubmitMultimediaMessageV6::iAlphaId. |
|
5918 * - An icon to display - RSat::TSubmitMultimediaMessageV6::iIconId |
|
5919 * - Text attributes of text contained in iAlphaId - RSat::TSubmitMultimediaMessageV6::iTextAttribute |
|
5920 * - Location in the UICC from where the file should be retrieved for submission - RSat::TSubmitMultimediaMessageV6::iSubmissionFile |
|
5921 * - Multimedia Message Identifier is the identifier of the MMs within the MMS Submission Files, |
|
5922 * It is mandatory when the file supports multiple MMs - RSat::TSubmitMultimediaMessageV6::iMultimediaMessageId |
|
5923 * |
|
5924 * This asynchronous request is a notifier that completes when the UICC issues a |
|
5925 * SUBMIT MULTIMEDIA MESSAGE PCmd. Upon completion the proactive command details |
|
5926 * will be returned in a packaged version of TSubmitMultimediaMessageV6 in the |
|
5927 * aPCmd parameter. |
|
5928 * |
|
5929 * To cancel a previously placed RSat::NotifySubmitMultimediaMsgPCmd request, |
|
5930 * call RTelSubSessionBase::CancelAsyncRequest(ESatNotifySubmitMultimediaMsgPCmd) |
|
5931 * |
|
5932 * Once you have dealt with the command, you must give your response to the UICC. |
|
5933 * In Symbian OS versions beginning from 9.4, pass RSat::TerminalRsp() a RSat::TSubmitMultimediaMessageRspV6Pckg (a packaged |
|
5934 * RSat::TSubmitMultimediaMessageRspV6). For later versions of Symbian OS, check for an updated |
|
5935 * API (RSat::TSubmitMultimediaMessageRspV7 etc). |
|
5936 * |
|
5937 * @param aReqStatus TRequestStatus result code after the asynchronous call completes |
|
5938 * @param aPCmd RSat::TSubmitMultimediaMessageV6, packaged into RSat::TSubmitMultimediaMessageV6Pckg |
|
5939 * @capability ReadDeviceData |
|
5940 */ |
|
5941 { |
|
5942 Get(ESatNotifySubmitMultimediaMsgPCmd, aReqStatus, aPCmd); |
|
5943 } |
|
5944 |
|
5945 EXPORT_C RSat::TSubmitMultimediaMessageRspV6::TSubmitMultimediaMessageRspV6() |
|
5946 : TSatPCmdBase(), |
|
5947 iGeneralResult(KPCmdResultNotSet),iInfoType(0),iAdditionalInfo() |
|
5948 /** |
|
5949 * Default constructor |
|
5950 */ |
|
5951 { |
|
5952 iExtensionId=KSatV6; |
|
5953 } |
|
5954 |
|
5955 EXPORT_C RSat::TDisplayMultimediaMessageV6::TDisplayMultimediaMessageV6() |
|
5956 : TSatPCmdBase(), |
|
5957 iDestination(KDeviceIdNotSet), |
|
5958 iDisplayPriority(EDisplayPriorityNotSet), |
|
5959 iClearScreenTrigger(EClearScreenTriggerNotSet), |
|
5960 iImmediateRsp(EImmediateRspNotSet) |
|
5961 /** |
|
5962 * Default constructor |
|
5963 */ |
|
5964 { |
|
5965 iExtensionId=KSatV6; |
|
5966 } |
|
5967 |
|
5968 EXPORT_C void RSat::NotifyDisplayMultimediaMsgPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
5969 /** |
|
5970 * The DISPLAY MULTIMEDIA MESSAGE command tells the phone to Display the Multimedia file to the User. |
|
5971 * |
|
5972 * The command is described fully in 3GPP TS 31.111. Note that it does not appear in ETSI TS |
|
5973 * 102 223. It contains: |
|
5974 * - This determines the text's priority - RSat::TDisplayMultimediaMessageV6::iDisplayPriority. |
|
5975 * - Determines whether the text should be removed from the screen after a delay or after the |
|
5976 * user's action - RSat::TDisplayMultimediaMessageV6::iClearScreenTrigger |
|
5977 * - Location in the UICC from where the file should be retrieved for submission - RSat::TDisplayMultimediaMessageV6::iSubmissionFile |
|
5978 * - Multimedia Message Identifier is the identifier of the MMs within the MMS Submission Files, |
|
5979 * It is mandatory when the file supports multiple MMs - RSat::iMultimediaMessageId |
|
5980 * - It indicates whether or not the (U)SAT UI client should sustain the display beyond sending the |
|
5981 * Terminal Response - RSat::TDisplayMultimediaMessageV6::iImmediateRsp |
|
5982 * |
|
5983 * This asynchronous request is a notifier that completes when the UICC issues a |
|
5984 * DISPLAY MULTIMEDIA MESSAGE PCmd. Upon completion the proactive command details |
|
5985 * will be returned in a packaged version of TDisplayMultimediaMessageV6 in the |
|
5986 * aPCmd parameter. |
|
5987 * |
|
5988 * To cancel a previously placed RSat::NotifyDisplayMultimediaMsgPCmd request, |
|
5989 * call RTelSubSessionBase::CancelAsyncRequest(ESatNotifyDisplayMultimediaMsgPCmd) |
|
5990 * |
|
5991 * Once you have dealt with the command, you must give your response to the UICC. |
|
5992 * In Symbian OS versions up to and including 9.4, pass RSat::TerminalRsp() a RSat::TDisplayMultimediaMessageRspV6Pckg (a packaged |
|
5993 * RSat::TDisplayMultimediaMessageRspV6). For later versions of Symbian OS, check for an updated |
|
5994 * API (RSat::TDisplayMultimediaMessageRspV7 etc). |
|
5995 * |
|
5996 * @return aReqStatus TRequestStatus result code after the asynchronous call completes |
|
5997 * @param aPCmd RSat::TDisplayMultimediaMessageV6, packaged into RSat::TDisplayMultimediaMessageV6Pckg |
|
5998 * @capability ReadDeviceData |
|
5999 */ |
|
6000 { |
|
6001 Get(ESatNotifyDisplayMultimediaMsgPCmd, aReqStatus, aPCmd); |
|
6002 } |
|
6003 |
|
6004 EXPORT_C RSat::TDisplayMultimediaMessageRspV6::TDisplayMultimediaMessageRspV6() |
|
6005 : TSatPCmdBase(), |
|
6006 iGeneralResult(KPCmdResultNotSet),iInfoType(0),iAdditionalInfo() |
|
6007 /** |
|
6008 * Default constructor |
|
6009 */ |
|
6010 { |
|
6011 iExtensionId=KSatV6; |
|
6012 } |
|
6013 |
|
6014 EXPORT_C RSat::TSetFramesV6::TSetFramesV6() |
|
6015 :TSatPCmdBase(),iDestination(KDeviceIdNotSet) |
|
6016 /** |
|
6017 * Default constructor |
|
6018 */ |
|
6019 { |
|
6020 iExtensionId=KSatV6; |
|
6021 } |
|
6022 |
|
6023 EXPORT_C void RSat::NotifySetFramesPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
6024 /** |
|
6025 * SET FRAMES command instructs the terminal to divide the terminal screen into multiple, |
|
6026 * scrollable rectangular regions called frames inorder to present multiple information at once. |
|
6027 * It can be applied to entire screen or to an already existing frame, dividing this frame into sub-frames |
|
6028 * |
|
6029 * The command is described fully in 3GPP TS 31.111. Note that it does not appear in ETSI TS |
|
6030 * 102 223. It contains: |
|
6031 * - The indicator tells the terminal whether or not to draw a separator between every |
|
6032 * adjoining frame - RSat::TSetFramesV6::iFrameSeparator |
|
6033 * - This value is used to indentify the frame, a value of '00' refers to the entire terminal's |
|
6034 * screen.Any other value refers to an existing frame - RSat::TSetFramesV6::iFrameId |
|
6035 * - It contains the layout information of the frame - RSat::TSetFramesV6::iFrameLayout |
|
6036 * - This is optional. It contains an indication of the frame to be used to display information |
|
6037 * in case a Frame Identifier is not included - RSat::TSetFramesV6::iDefaultFrameId |
|
6038 * |
|
6039 * This asynchronous request is a notifier that completes when the UICC issues a |
|
6040 * SET FRAMES PCmd. Upon completion the proactive command details |
|
6041 * will be returned in a packaged version of TSetFramesV6 in the |
|
6042 * aPCmd parameter. |
|
6043 * |
|
6044 * To cancel a previously placed RSat::NotifySetFramesPCmd request, |
|
6045 * call RTelSubSessionBase::CancelAsyncRequest(ESatNotifySetFramesPCmd) |
|
6046 * |
|
6047 * Once you have dealt with the command, you must give your response to the UICC. |
|
6048 * In Symbian OS versions up to and including 9.4, pass RSat::TerminalRsp() a RSat::TSetFramesRspV6Pckg (a packaged |
|
6049 * RSat::TSetFramesRspV6). For later versions of Symbian OS, check for an updated |
|
6050 * API (RSat::TSetFramesRspV7 etc). |
|
6051 * |
|
6052 * @param aReqStatus TRequestStatus result code after the asynchronous call completes |
|
6053 * @param aPCmd RSat::TSetFramesV6, packaged into RSat::TSetFramesV6Pckg |
|
6054 * @capability ReadDeviceData |
|
6055 */ |
|
6056 { |
|
6057 Get(ESatNotifySetFramesPCmd, aReqStatus, aPCmd); |
|
6058 } |
|
6059 |
|
6060 EXPORT_C RSat::TSetFramesRspV6::TSetFramesRspV6() |
|
6061 :TSatPCmdBase(), |
|
6062 iGeneralResult(KPCmdResultNotSet),iInfoType(0),iAdditionalInfo() |
|
6063 /** |
|
6064 * Default constructor |
|
6065 */ |
|
6066 { |
|
6067 iExtensionId=KSatV6; |
|
6068 iFramesInformation.iFrameId=0; |
|
6069 } |
|
6070 |
|
6071 EXPORT_C RSat::TGetFramesStatusV6::TGetFramesStatusV6() |
|
6072 :TSatPCmdBase(),iDestination(KDeviceIdNotSet) |
|
6073 /** |
|
6074 * Default constructor |
|
6075 */ |
|
6076 { |
|
6077 iExtensionId=KSatV6; |
|
6078 } |
|
6079 |
|
6080 EXPORT_C void RSat::NotifyGetFramesStatusPCmd(TRequestStatus& aReqStatus, TDes8& aPCmd) const |
|
6081 /** |
|
6082 * GET FRAMES STATUS command requests the terminal to return a Frames parameters data object. |
|
6083 * |
|
6084 * The command is described fully in 3GPP TS 31.111. Note that it does not appear in ETSI TS |
|
6085 * 102 223. It contains: |
|
6086 * - Device identification - RSat::TGetFramesStatusV6::iDestination |
|
6087 * Here,terminal is the destination, It sends the frames information in the terminal response. |
|
6088 * |
|
6089 * This asynchronous request is a notifier that completes when the UICC issues a |
|
6090 * GET FRAMES STATUS PCmd. Upon completion the proactive command details |
|
6091 * will be returned in a packaged version of TGetFramesStatusV6 in the |
|
6092 * aPCmd parameter. |
|
6093 * |
|
6094 * To cancel a previously placed RSat::NotifyGetFramesStatusPCmd request, |
|
6095 * call RTelSubSessionBase::CancelAsyncRequest(ESatNotifyGetFramesStatusPCmd) |
|
6096 * |
|
6097 * Once you have dealt with the command, you must give your response to the UICC. |
|
6098 * In Symbian OS versions up to and including 9.4, pass RSat::TerminalRsp() a RSat::TGetFramesStatusRspV6Pckg (a packaged |
|
6099 * RSat::TGetFramesStatusRspV6). For later versions of Symbian OS, check for an updated |
|
6100 * API (RSat::TGetFramesStatusRspV7 etc). |
|
6101 * |
|
6102 * @param aReqStatus TRequestStatus result code after the asynchronous call completes |
|
6103 * @param aPCmd RSat::TGetFramesStatusV6, packaged into RSat::TGetFramesStatusV6Pckg |
|
6104 * @capability None |
|
6105 */ |
|
6106 { |
|
6107 Get(ESatNotifyGetFramesStatusPCmd, aReqStatus, aPCmd); |
|
6108 } |
|
6109 |
|
6110 EXPORT_C RSat::TGetFramesStatusRspV6::TGetFramesStatusRspV6() |
|
6111 :TSatPCmdBase(), |
|
6112 iGeneralResult(KPCmdResultNotSet),iInfoType(0),iAdditionalInfo() |
|
6113 /** |
|
6114 * Default constructor |
|
6115 */ |
|
6116 { |
|
6117 iExtensionId=KSatV6; |
|
6118 iFramesInformation.iFrameId=0; |
|
6119 } |
|
6120 |
|
6121 EXPORT_C RSat::TMmsNotificationDownloadV6::TMmsNotificationDownloadV6() |
|
6122 : TSatBase(), iDeviceId(KDeviceIdNotSet) |
|
6123 /** |
|
6124 * Default constructor |
|
6125 */ |
|
6126 { |
|
6127 iExtensionId=KSatV6; |
|
6128 } |
|
6129 |
|
6130 EXPORT_C void RSat::MmsNotificationDownload(TRequestStatus& aReqStatus, const TDesC8& aMmsNotificationDownload) const |
|
6131 /** |
|
6132 * This method allows the client to pass the MM1_notification.REQ message to the UICC upon |
|
6133 * receiving the MMS notification intended for the UICC. The MMS Notification download envelope |
|
6134 * command details are passed in the packaged version of TMmsNotificationDownloadV6 in |
|
6135 * the aMmsNotificationDownload parameter. |
|
6136 * |
|
6137 * The command is described fully in 3GPP TS 31.111. Note that it does not appear in ETSI TS |
|
6138 * 102 223. It contains: |
|
6139 * - Additional information requested by the network to retrieve a MM is sent |
|
6140 * to UICC - RSat::TMmsNotificationDownloadV6::iMMSNotification |
|
6141 * |
|
6142 * - Indicates the last envelope sent to transmit the MMS notification into |
|
6143 * the card - RSat::TMmsNotificationDownloadV6::iLastEnvelope |
|
6144 * |
|
6145 * To cancel a previously placed RSat::MmsNotificationDownload request, |
|
6146 * call RTelSubSessionBase::CancelAsyncRequest(ESatMmsNotificationDownload) |
|
6147 * |
|
6148 * @param aReqStatus TRequestStatus result code after the asynchronous call completes |
|
6149 * @param aPCmd RSat::TMMSNotificationDownloadV6, packaged into RSat::TMMSNotificationDownloadV6Pckg |
|
6150 * @capability NetworkControl |
|
6151 * @capability WriteDeviceData |
|
6152 */ |
|
6153 { |
|
6154 Set(ESatMmsNotificationDownload, aReqStatus, aMmsNotificationDownload); |
|
6155 } |
|
6156 |
|
6157 EXPORT_C RSat::TMmsTransferStatusV6::TMmsTransferStatusV6() |
|
6158 :TSatBase(),iDeviceId(KDeviceIdNotSet) |
|
6159 /** |
|
6160 * Default constructor |
|
6161 */ |
|
6162 { |
|
6163 iExtensionId=KSatV6; |
|
6164 } |
|
6165 |
|
6166 EXPORT_C void RSat::MmsTransferStatus(TRequestStatus& aReqStatus, const TDesC8& aMmsTransferStatus) const |
|
6167 /** |
|
6168 * This method allows the client to notify the UICC of the following: |
|
6169 * - the status of an MMS message submitted to the network. |
|
6170 * - the UICC storage completion of a retrieved MMS message. |
|
6171 * |
|
6172 * The command is described fully in 3GPP TS 31.111. Note that it does not appear in ETSI TS |
|
6173 * 102 223. It contains: |
|
6174 * - Location of the Submitted/Retrieved Multimedia file on the UICC - RSat::TMmsTransferStatusV6::iMMSTransferFile |
|
6175 * - Transfer status of the file - RSat::TMmsTransferStatusV6::iMultimediaMessageStatus |
|
6176 * - Multimedia Identifier is used when the file supports multiple MMs - RSat::TMmsTransferStatusV6::iMultimediaMessageId |
|
6177 * It completes when the UICC informs the TSY that the download is complete. |
|
6178 * |
|
6179 * To cancel a previously placed RSat::MmsTransferStatus request, |
|
6180 * call RTelSubSessionBase::CancelAsyncRequest(ESatMmsTransferStatus) |
|
6181 * |
|
6182 * @param aReqStatus TRequestStatus result code after the asynchronous call completes |
|
6183 * @param aPCmd RSat::TMmsTransferStatusV6, packaged into RSat::TMmsTransferStatusV6Pckg |
|
6184 * @capability NetworkControl |
|
6185 * @capability WriteDeviceData |
|
6186 */ |
|
6187 { |
|
6188 Set(ESatMmsTransferStatus, aReqStatus, aMmsTransferStatus); |
|
6189 } |
|
6190 |
|
6191 EXPORT_C RSat::TUssdDataDownloadV6::TUssdDataDownloadV6() |
|
6192 :TSatBase(),iDeviceId(KDeviceIdNotSet) |
|
6193 /** |
|
6194 * Default constructor |
|
6195 */ |
|
6196 { |
|
6197 iExtensionId=KSatV6; |
|
6198 } |
|
6199 |
|
6200 |
|
6201 EXPORT_C void RSat::UssdDataDownload(TRequestStatus& aReqStatus, const TDesC8& aDes) const |
|
6202 /** |
|
6203 * This method allows the client to pass a USSD packet to the UICC upon receiving the USSD |
|
6204 * packet intended for the UICC. The USSD Data Download ENVELOPE command details are passed |
|
6205 * in the packaged version of TUssdDataDownloadV6 class in the aDes parameter |
|
6206 * |
|
6207 * The command is described fully in 3GPP TS 31.111. Note that it does not appear in ETSI TS |
|
6208 * 102 223. It contains: |
|
6209 * - The details of the Ussd Data Download - RSat::TUssdDataDownloadV6::iUssdString |
|
6210 * |
|
6211 * To cancel a previously placed RSat::UssdDataDownload request, |
|
6212 * call RTelSubSessionBase::CancelAsyncRequest(ESatUssdDataDownload) |
|
6213 * |
|
6214 * @param aReqStatus TRequestStatus result code after the asynchronous call completes |
|
6215 * @param aUssdDataDownload RSat::TUssdDataDownloadV6 packaged in a RSat::TUssdDataDownloadV6Pckg |
|
6216 * @capability NetworkControl |
|
6217 * @capability WriteUserData |
|
6218 */ |
|
6219 { |
|
6220 Set(ESatUssdDataDownload, aReqStatus, aDes); |
|
6221 } |
|
6222 |